mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-07-04 06:54:33 +00:00
Code Issues Projects Releases Wiki Activity

Decompiles sched.c (#145)

Browse source 
* decompile sched.c

* rename Game_AllocEnd to Game_Alloc in z_effect_soft_sprite.c

* pr updates
This commit is contained in:
krimtonz 2020-05-26 10:39:27 -05:00 • committed by GitHub
parent 3175f5c988
commit d48792870c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
47 changed files with 658 additions and 1807 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/code/audioMgr.c
View file

@ -26,7 +26,7 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
audioMgr->unk_5C = NULL;
osSendMesg(&audioMgr->sched->cmdQ, &audioMgr->unk_8, OS_MESG_BLOCK);
func_800C95F8(audioMgr->sched);
Sched_SendEntryMsg(audioMgr->sched);
}
D_8016A550 = osGetTime();
if (SREG(20) >= 2) {

2
src/code/game.c
View file

@ -496,7 +496,7 @@ u32 GameState_IsRunning(GameState* gameState) {
return gameState->running;
}
void* GameState_AllocEnd(GameState* gameState, size_t size, char* file, s32 line) {
void* GameState_Alloc(GameState* gameState, size_t size, char* file, s32 line) {
void* ret;
if (THA_IsCrash(&gameState->tha)) {

16
src/code/graph.c
View file

@ -244,7 +244,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
cfb = sGraphCfbInfos + sGraphCfbInfoIdx++;
cfb->fb1 = gfxCtx->curFrameBuffer;
cfb->swapbuffer = gfxCtx->curFrameBuffer;
cfb->swapBuffer = gfxCtx->curFrameBuffer;
cfb->viMode = gfxCtx->viMode;
cfb->features = gfxCtx->viFeatures;
cfb->xScale = gfxCtx->xScale;
@ -257,7 +257,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
gfxCtx->schedMsgQ = &gSchedContext.cmdQ;
osSendMesg(&gSchedContext.cmdQ, scTask, OS_MESG_BLOCK);
func_800C95F8(&gSchedContext); // osScKickEntryMsg
Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
}
#else
u32 D_8012D260 = 0;
@ -374,12 +374,12 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) {
func_800F3054();
time = osGetTime();
D_8016A538 = D_8016A568;
D_8016A530 = D_8016A560;
D_8016A540 = D_8016A580;
D_8016A568 = 0;
D_8016A560 = 0;
D_8016A580 = 0;
D_8016A538 = gRSPGFXTotalTime;
D_8016A530 = gRSPAudioTotalTime;
D_8016A540 = gRDPTotalTime;
gRSPGFXTotalTime = 0;
gRSPAudioTotalTime = 0;
gRDPTotalTime = 0;
if (sGraphUpdateTime != 0) {
D_8016A548 = time - sGraphUpdateTime;

2
src/code/main.c
View file

@ -79,7 +79,7 @@ void Main(void* arg0) {
osSyncPrintf("タスクスケジューラの初期化\n"); // Initialize the task scheduler
StackCheck_Init(&sSchedStackInfo, sSchedStack, sSchedStack + sizeof(sSchedStack), 0, 0x100, "sched");
func_800C9874(&gSchedContext, &sAudioStack, 0xf, D_80013960, 1, &gIrqMgr);
Sched_Init(&gSchedContext, &sAudioStack, 0xf, D_80013960, 1, &gIrqMgr);
IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQ);

489
src/code/sched.c
View file

@ -1,9 +1,59 @@
#include <ultra64.h>
#include <global.h>
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C82A0.s")
#define RSP_DONE_MSG 667
#define RDP_DONE_MSG 668
#define ENTRY_MSG 670
void func_800C84E4(SchedContext* sc, UNK_TYPE arg1) {
// data
volatile s32 sLogScheduler = false;
// bss
OSTime sRSPGFXStartTime;
OSTime sRSPAudioStartTime;
OSTime sRSPOtherStartTime;
OSTime sRDPStartTime;
void Sched_SwapFrameBuffer(CfbInfo* cfbInfo) {
u16 width;
LogUtils_CheckValidPointer("cfbinfo->swapbuffer", cfbInfo->swapBuffer, "../sched.c", 340);
if (cfbInfo->swapBuffer != NULL) {
osViSwapBuffer(cfbInfo->swapBuffer);
cfbInfo->updateRate2 = cfbInfo->updateRate;
if (sLogScheduler) {
osSyncPrintf("osViSwapBuffer %08x %08x %08x\n", osViGetCurrentFramebuffer(), osViGetNextFramebuffer(),
(cfbInfo != NULL ? cfbInfo->swapBuffer : NULL));
}
width = cfbInfo->viMode != NULL ? cfbInfo->viMode->comRegs.width : gScreenWidth;
Fault_SetFB(cfbInfo->swapBuffer, width, 0x10);
if (HREG(80) == 0xD && HREG(95) != 0xD) {
HREG(81) = 0;
HREG(82) = 0;
HREG(83) = 1;
HREG(84) = 0;
HREG(85) = 1;
HREG(86) = 0;
HREG(87) = 0;
HREG(88) = 0;
HREG(89) = 0;
HREG(90) = 0;
HREG(91) = 0;
HREG(92) = 0;
HREG(93) = 0;
HREG(94) = 0;
HREG(95) = 0xD;
}
if (HREG(80) == 0xD && HREG(81) == 2) {
osViSetSpecialFeatures(HREG(82) != 0 ? 1 : 2);
osViSetSpecialFeatures(HREG(83) != 0 ? 0x40 : 0x80);
osViSetSpecialFeatures(HREG(84) != 0 ? 0x4 : 0x8);
osViSetSpecialFeatures(HREG(85) != 0 ? 0x10 : 0x20);
}
}
cfbInfo->unk_10 = 0;
}
void func_800C84E4(SchedContext* sc, CfbInfo* cfbInfo) {
if (sc->unk_24C != 0) {
sc->unk_24C = 0;
@ -12,67 +62,189 @@ void func_800C84E4(SchedContext* sc, UNK_TYPE arg1) {
}
}
func_800C82A0(arg1);
Sched_SwapFrameBuffer(cfbInfo);
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8534.s")
void Sched_HandleReset(SchedContext* sc) {
OSTime now;
if (sc->curRSPTask != NULL) {
now = osGetTime();
if (sc->curRSPTask->framebuffer == NULL) {
LOG_TIME("(((u64)(now - audio_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
OS_CYCLES_TO_USEC(now - sRSPAudioStartTime), "../sched.c", 421);
} else if (OS_CYCLES_TO_USEC(now - sRSPGFXStartTime) > 1000000 ||
OS_CYCLES_TO_USEC(now - sRDPStartTime) > 1000000) {
func_800FBFD8();
if (sc->curRSPTask != NULL) {
LOG_TIME("(((u64)(now - graph_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
OS_CYCLES_TO_USEC(now - sRSPGFXStartTime), "../sched.c", 427);
osSendMesg(&sc->interruptQ, RSP_DONE_MSG, OS_MESG_NOBLOCK);
}
if (sc->curRDPTask != NULL) {
LOG_TIME("(((u64)(now - rdp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
OS_CYCLES_TO_USEC(now - sRDPStartTime), "../sched.c", 431);
osSendMesg(&sc->interruptQ, RDP_DONE_MSG, 0);
}
}
}
}
void func_800C87CC(SchedContext* sc) {
void Sched_HandleStart(SchedContext* sc) {
ViConfig_UpdateVi(1);
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C87F0.s")
void Sched_QueueTask(SchedContext* sc, OSScTask* task) {
s32 type = task->list.t.type;
if (!((type == M_AUDTASK) || (type == M_GFXTASK) || (type == M_NJPEGTASK) || (type == M_NULTASK))) {
__assert("(type == M_AUDTASK) || (type == M_GFXTASK) || (type == M_NJPEGTASK) || (type == M_NULTASK)",
"../sched.c", 463);
}
void func_800C8910(SchedContext* sc) {
if (!(sc->curRSPTask->state & 0x10)) {
if (type == M_AUDTASK) {
if (sLogScheduler) {
// You have entered an audio task
osSyncPrintf("オーディオタスクをエントリしました\n");
}
if (sc->audioListTail != NULL) {
sc->audioListTail->next = task;
} else {
sc->audioListHead = task;
}
sc->audioListTail = task;
sc->doAudio = 1;
} else {
if (sLogScheduler) {
// Entered graph task
osSyncPrintf("グラフタスクをエントリしました\n");
}
if (sc->gfxListTail != NULL) {
sc->gfxListTail->next = task;
} else {
sc->gfxListHead = task;
}
sc->gfxListTail = task;
}
task->next = NULL;
task->state = task->flags & (OS_SC_NEEDS_RDP | OS_SC_NEEDS_RSP);
}
void Sched_Yield(SchedContext* sc) {
if (!(sc->curRSPTask->state & OS_SC_YIELD)) {
if (sc->curRSPTask->list.t.type == M_AUDTASK) {
__assert("sc->curRSPTask->list.t.type != M_AUDTASK", "../sched.c", 496);
}
sc->curRSPTask->state |= 0x10;
sc->curRSPTask->state |= OS_SC_YIELD;
osSpTaskYield();
if (D_8012D290 != 0) {
if (sLogScheduler) {
osSyncPrintf("%08d:osSpTaskYield\n", (u32)(OS_CYCLES_TO_USEC(osGetTime())));
}
}
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C89D4.s")
OSScTask* func_800C89D4(SchedContext* sc, OSScTask* task) {
if (task == NULL) {
return NULL;
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8A94.s")
if (sc->pendingSwapBuf1 != NULL) {
if (0) {
__assert("sc->pending_swapbuffer1", "../sched.c", UNK_LINE);
}
return NULL;
}
typedef struct {
/* 0x00 */ char unk_00[0x04];
/* 0x00 */ u32 unk_04;
/* 0x00 */ u32 unk_08;
/* 0x0C */ UNK_TYPE unk_0C;
/* 0x10 */ char unk_10[0x40];
/* 0x50 */ OSMesgQueue* msgQ;
/* 0x54 */ OSMesg msg;
} struct_800C8C40;
if (sc->pendingSwapBuf2 != NULL) {
if (0) {
__assert("sc->pending_swapbuffer2", "../sched.c", UNK_LINE);
}
return NULL;
}
void func_800C8BC4(SchedContext* sc, struct_800C8C40* arg1) {
if (sc->pendingSwapBuf1 == 0) {
sc->pendingSwapBuf1 = arg1->unk_0C;
if ((sc->pendingSwapBuf2 != NULL ? sc->pendingSwapBuf2->swapBuffer : NULL) == task->framebuffer->fb1) {
return NULL;
}
if ((sc->pendingSwapBuf1 != NULL ? sc->pendingSwapBuf1->swapBuffer : NULL) == task->framebuffer->fb1) {
return NULL;
}
if (osViGetCurrentFramebuffer() == (u32*)task->framebuffer->fb1) {
return NULL;
}
return task;
}
#ifdef NON_MATCHING
// regalloc
s32 Sched_Schedule(SchedContext* sc, OSScTask** sp, OSScTask** dp, s32 state) {
s32 ret = state;
OSScTask* gfxTask = sc->gfxListHead;
OSScTask* audioTask = sc->audioListHead;
if (sc->doAudio && ret & OS_SC_SP) {
*sp = audioTask;
ret &= ~OS_SC_SP;
sc->doAudio = 0;
sc->audioListHead = sc->audioListHead->next;
if (sc->audioListHead == NULL) {
sc->audioListTail = NULL;
}
} else {
if (gfxTask != NULL) {
if (gfxTask->state & OS_SC_YIELDED || !(sc->gfxListHead->flags & OS_SC_NEEDS_RDP)) {
if (ret & OS_SC_SP) {
*sp = gfxTask;
ret &= ~OS_SC_SP;
sc->gfxListHead = sc->gfxListHead->next;
if (sc->gfxListHead == NULL) {
sc->gfxListTail = NULL;
}
}
} else {
if (ret == (OS_SC_SP | OS_SC_DP)) {
if (sc->gfxListHead->framebuffer == NULL || func_800C89D4(sc, gfxTask) != NULL) {
*sp = *dp = gfxTask;
ret &= ~(OS_SC_SP | OS_SC_DP);
sc->gfxListHead = sc->gfxListHead->next;
if (sc->gfxListHead == NULL) {
sc->gfxListTail = NULL;
}
}
}
}
}
}
return ret;
}
#else
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/Sched_Schedule.s")
#endif
void func_800C8BC4(SchedContext* sc, OSScTask* task) {
if (sc->pendingSwapBuf1 == NULL) {
sc->pendingSwapBuf1 = task->framebuffer;
LogUtils_CheckValidPointer("sc->pending_swapbuffer1", sc->pendingSwapBuf1, "../sched.c", 618);
if ((sc->unk_240 == NULL) || (sc->unk_240->unk_12 < 1)) {
func_800C84E4(sc, arg1->unk_0C);
if ((sc->curBuf == NULL) || (sc->curBuf->updateRate2 < 1)) {
func_800C84E4(sc, task->framebuffer);
}
}
}
u32 func_800C8C40(SchedContext* sc, struct_800C8C40* arg1) {
if (!(arg1->unk_04 & 3)) {
if (arg1->msgQ != NULL) {
osSendMesg(arg1->msgQ, arg1->msg, OS_MESG_BLOCK);
u32 Sched_IsComplete(SchedContext* sc, OSScTask* task) {
if (!(task->state & (OS_SC_DP | OS_SC_SP))) {
if (task->msgQ != NULL) {
osSendMesg(task->msgQ, task->msg, OS_MESG_BLOCK);
}
if (arg1->unk_08 & 0x40) {
func_800C8BC4(sc, arg1);
if (task->flags & OS_SC_SWAPBUFFER) {
func_800C8BC4(sc, task);
}
return 1;
@ -81,34 +253,259 @@ u32 func_800C8C40(SchedContext* sc, struct_800C8C40* arg1) {
return 0;
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8CB8.s")
void Sched_RunTask(SchedContext* sc, OSScTask* spTask, OSScTask* dpTask) {
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8EDC.s")
if (sc->curRSPTask != NULL) {
__assert("sc->curRSPTask == NULL", "../sched.c", 663);
}
if (spTask != NULL) {
if (spTask->list.t.type == 0) {
if (spTask->flags & OS_SC_NEEDS_RSP) {
spTask->state &= ~OS_SC_SP;
sc->curRSPTask = NULL;
}
if (spTask->flags & OS_SC_NEEDS_RDP) {
spTask->state &= ~OS_SC_DP;
sc->curRDPTask = NULL;
}
Sched_IsComplete(sc, spTask);
return;
}
spTask->state &= ~(OS_SC_YIELD | OS_SC_YIELDED);
osWritebackDCacheAll();
osSpTaskLoad(&spTask->list);
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C9018.s")
if (spTask->list.t.type == M_AUDTASK) {
sRSPAudioStartTime = osGetTime();
} else if (spTask->list.t.type == M_GFXTASK) {
sRSPGFXStartTime = osGetTime();
} else {
sRSPOtherStartTime = osGetTime();
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C91BC.s")
osSpTaskStartGo(&spTask->list);
if (sLogScheduler) {
osSyncPrintf(
"%08d:osSpTaskStartGo(%08x) %s\n", (u32)OS_CYCLES_TO_USEC(osGetTime()), &spTask->list,
(spTask->list.t.type == M_AUDTASK ? "AUDIO" : (spTask->list.t.type == M_GFXTASK ? "GRAPH" : "OTHER")));
}
sc->curRSPTask = spTask;
if (spTask == dpTask && sc->curRDPTask == NULL) {
sc->curRDPTask = dpTask;
sRDPStartTime = sRSPGFXStartTime;
}
}
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C94B4.s")
void Sched_HandleEntry(SchedContext* sc) {
OSScTask* nextRSP;
OSScTask* nextRDP;
u32 state;
OSMesg msg;
void func_800C95F8(OSMesgQueue* mq) {
if (D_8012D290 != 0) {
nextRSP = NULL;
nextRDP = NULL;
msg = NULL;
while (osRecvMesg(&sc->cmdQ, &msg, OS_MESG_NOBLOCK) != -1) {
Sched_QueueTask(sc, msg);
}
if (sc->doAudio != 0 && sc->curRSPTask != NULL) {
if (sLogScheduler) {
osSyncPrintf("[YIELD B]");
}
Sched_Yield(sc);
return;
}
state = ((sc->curRSPTask == 0) * 2) | (sc->curRDPTask == 0);
if (Sched_Schedule(sc, &nextRSP, &nextRDP, state) != state) {
Sched_RunTask(sc, nextRSP, nextRDP);
}
if (sLogScheduler) {
osSyncPrintf("EN sc:%08x sp:%08x dp:%08x state:%x\n", sc, nextRSP, nextRDP, state);
}
}
void Sched_HandleRetrace(SchedContext* sc) {
if (sLogScheduler) {
osSyncPrintf("%08d:scHandleRetrace %08x\n", (u32)OS_CYCLES_TO_USEC(osGetTime()), osViGetCurrentFramebuffer());
}
ViConfig_UpdateBlack();
sc->retraceCnt++;
if (osViGetCurrentFramebuffer() == (u32*)(sc->pendingSwapBuf1 != NULL ? sc->pendingSwapBuf1->swapBuffer : NULL)) {
if (sc->curBuf != NULL) {
sc->curBuf->unk_10 = 0;
}
if (sc->pendingSwapBuf1 != NULL) {
sc->pendingSwapBuf1->unk_10 = 0;
}
sc->curBuf = sc->pendingSwapBuf1;
sc->pendingSwapBuf1 = sc->pendingSwapBuf2;
sc->pendingSwapBuf2 = NULL;
}
if (sc->curBuf != NULL) {
if (sc->curBuf->updateRate2 > 0) {
sc->curBuf->updateRate2--;
}
if ((sc->curBuf->updateRate2 <= 0) && (sc->pendingSwapBuf1 != NULL)) {
func_800C84E4(sc, sc->pendingSwapBuf1);
}
}
if (sLogScheduler) {
osSyncPrintf("%08x %08x %08x %d\n", osViGetCurrentFramebuffer(), osViGetNextFramebuffer(),
sc->pendingSwapBuf1 != NULL ? sc->pendingSwapBuf1->swapBuffer : NULL,
sc->curBuf != NULL ? sc->curBuf->updateRate2 : 0);
}
Sched_HandleEntry(sc);
}
void Sched_HandleRSPDone(SchedContext* sc) {
OSScTask* curRSPTask;
OSScTask* nextRSP;
OSScTask* nextRDP;
s32 state;
nextRSP = NULL;
nextRDP = NULL;
if (sc->curRSPTask == NULL) {
__assert("sc->curRSPTask", "../sched.c", 819);
}
if (sc->curRSPTask->list.t.type == M_AUDTASK) {
gRSPAudioTotalTime += osGetTime() - sRSPAudioStartTime;
} else if (sc->curRSPTask->list.t.type == M_GFXTASK) {
gRSPGFXTotalTime += osGetTime() - sRSPGFXStartTime;
} else {
gRSPOtherTotalTime += osGetTime() - sRSPOtherStartTime;
}
curRSPTask = sc->curRSPTask;
sc->curRSPTask = NULL;
if (sLogScheduler) {
osSyncPrintf("RSP DONE %d %d", curRSPTask->state & 0x10, osSpTaskYielded(&curRSPTask->list));
}
if (curRSPTask->state & OS_SC_YIELD && osSpTaskYielded(&curRSPTask->list)) {
if (sLogScheduler) {
osSyncPrintf("[YIELDED]\n");
}
curRSPTask->state |= OS_SC_YIELDED;
curRSPTask->next = sc->gfxListHead;
sc->gfxListHead = curRSPTask;
if (sc->gfxListTail == NULL) {
sc->gfxListTail = curRSPTask;
}
} else {
if (sLogScheduler) {
osSyncPrintf("[NOT YIELDED]\n");
}
curRSPTask->state &= ~OS_SC_SP;
Sched_IsComplete(sc, curRSPTask);
}
state = ((sc->curRSPTask == NULL) << 1) | (sc->curRDPTask == NULL);
if (Sched_Schedule(sc, &nextRSP, &nextRDP, state) != state) {
Sched_RunTask(sc, nextRSP, nextRDP);
}
if (sLogScheduler) {
osSyncPrintf("SP sc:%08x sp:%08x dp:%08x state:%x\n", sc, nextRSP, nextRDP, state);
}
}
void Sched_HandleRDPDone(SchedContext* sc) {
OSScTask* curTask;
OSScTask* nextRSP;
OSScTask* nextRDP;
s32 state;
nextRSP = NULL;
nextRDP = NULL;
gRDPTotalTime = osGetTime() - sRDPStartTime;
if (sc->curRDPTask == NULL) {
__assert("sc->curRDPTask", "../sched.c", 878);
}
if (sc->curRDPTask->list.t.type != M_GFXTASK) {
__assert("sc->curRDPTask->list.t.type == M_GFXTASK", "../sched.c", 879);
}
curTask = sc->curRDPTask;
sc->curRDPTask = NULL;
curTask->state &= ~OS_SC_DP;
Sched_IsComplete(sc, curTask);
state = ((sc->curRSPTask == NULL) << 1) | (sc->curRDPTask == NULL);
if (Sched_Schedule(sc, &nextRSP, &nextRDP, state) != state) {
Sched_RunTask(sc, nextRSP, nextRDP);
}
if (sLogScheduler) {
osSyncPrintf("DP sc:%08x sp:%08x dp:%08x state:%x\n", sc, nextRSP, nextRDP, state);
}
}
void Sched_SendEntryMsg(OSMesgQueue* mq) {
if (sLogScheduler) {
osSyncPrintf("osScKickEntryMsg\n");
}
osSendMesg(mq, 670, OS_MESG_BLOCK);
osSendMesg(mq, ENTRY_MSG, OS_MESG_BLOCK);
}
#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C9644.s")
void Sched_ThreadEntry(void* arg) {
void* msg;
SchedContext* sc = (SchedContext*)arg;
void func_800C9874(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, UNK_TYPE arg5) {
msg = NULL;
while (1) {
if (sLogScheduler) {
// %08d: standby
osSyncPrintf("%08d:待機中\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
}
osRecvMesg(&sc->interruptQ, &msg, OS_MESG_BLOCK);
switch ((s32)msg) {
case ENTRY_MSG:
if (sLogScheduler) {
osSyncPrintf("%08d:ENTRY_MSG\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
}
Sched_HandleEntry(sc);
continue;
case RSP_DONE_MSG:
if (sLogScheduler) {
osSyncPrintf("%08d:RSP_DONE_MSG\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
}
Sched_HandleRSPDone(sc);
continue;
case RDP_DONE_MSG:
if (sLogScheduler) {
osSyncPrintf("%08d:RDP_DONE_MSG\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
}
Sched_HandleRDPDone(sc);
continue;
default:
break;
}
switch (((OSScMsg*)msg)->type) {
case 1:
Sched_HandleRetrace(sc);
continue;
case 4:
Sched_HandleReset(sc);
continue;
case 3:
Sched_HandleStart(sc);
continue;
}
}
}
void Sched_Init(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, IrqMgr* irqMgr) {
bzero(sc, sizeof(SchedContext));
sc->unk_24C = 1;
osCreateMesgQueue(&sc->interruptQ, sc->intBuf, 8);
osCreateMesgQueue(&sc->cmdQ, sc->cmdMsgBuf, 8);
osSetEventMesg(4, &sc->interruptQ, 667);
osSetEventMesg(9, &sc->interruptQ, 668);
IrqMgr_AddClient(arg5, &sc->unk_250, sc);
osCreateThread(&sc->thread, 5, func_800C9644, sc, stack, priority);
osSetEventMesg(OS_EVENT_SP, &sc->interruptQ, RSP_DONE_MSG);
osSetEventMesg(OS_EVENT_DP, &sc->interruptQ, RDP_DONE_MSG);
IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQ);
osCreateThread(&sc->thread, 5, Sched_ThreadEntry, sc, stack, priority);
osStartThread(&sc->thread);
}

15
src/code/speed_meter.c
View file

@ -2,6 +2,21 @@
#include <global.h>
#include <vt.h>
volatile OSTime D_8016A520;
volatile OSTime D_8016A528;
volatile OSTime D_8016A530;
volatile OSTime D_8016A538;
volatile OSTime D_8016A540;
volatile OSTime D_8016A548;
volatile OSTime D_8016A550;
volatile OSTime D_8016A558;
volatile OSTime gRSPAudioTotalTime;
volatile OSTime gRSPGFXTotalTime;
volatile OSTime gRSPOtherTotalTime;
volatile OSTime D_8016A578;
volatile OSTime gRDPTotalTime;
SpeedMeterTimeEntry* gSpeedMeterTimeEntryPtr;
SpeedMeterTimeEntry sSpeedMeterTimeEntryArray[] = {
{ &D_8016A520, 0, 0, GPACK_RGBA5551(0xFF, 0x00, 0x00, 1) },
{ &D_8016A528, 0, 2, GPACK_RGBA5551(0xFF, 0xFF, 0x00, 1) },

2
src/code/sys_matrix.c
View file

@ -21,7 +21,7 @@ MtxF* sMatrixStack; // "Matrix_stack"
MtxF* sCurrentMatrix; // "Matrix_now"
void Matrix_Init(GameState* gameState) {
sCurrentMatrix = GameState_AllocEnd(gameState, 20 * sizeof(MtxF), "../sys_matrix.c", 153);
sCurrentMatrix = GameState_Alloc(gameState, 20 * sizeof(MtxF), "../sys_matrix.c", 153);
sMatrixStack = sCurrentMatrix;
}

8
src/code/z_construct.c
View file

@ -40,7 +40,7 @@ void func_801109B0(GlobalContext* globalCtx) {
// Translates to: "Permanent PARAMETER Segment = %x"
osSyncPrintf("常駐ＰＡＲＡＭＥＴＥＲセグメント=%x\n", parameterSize);
interfaceCtx->parameterSegment = GameState_AllocEnd(&globalCtx->state, parameterSize, "../z_construct.c", 159);
interfaceCtx->parameterSegment = GameState_Alloc(&globalCtx->state, parameterSize, "../z_construct.c", 159);
osSyncPrintf("parameter->parameterSegment=%x", interfaceCtx->parameterSegment);
@ -50,7 +50,7 @@ void func_801109B0(GlobalContext* globalCtx) {
DmaMgr_SendRequest1(interfaceCtx->parameterSegment, parameterStart, parameterSize, "../z_construct.c", 162);
interfaceCtx->do_actionSegment = GameState_AllocEnd(&globalCtx->state, 0x480, "../z_construct.c", 166);
interfaceCtx->do_actionSegment = GameState_Alloc(&globalCtx->state, 0x480, "../z_construct.c", 166);
// Translates to: "DO Action Texture Initialization"
osSyncPrintf("ＤＯアクション テクスチャ初期=%x\n", 0x480);
@ -84,7 +84,7 @@ void func_801109B0(GlobalContext* globalCtx) {
DmaMgr_SendRequest1((void*)((u32)interfaceCtx->do_actionSegment + 0x300), do_actionStart + do_actionOffset, 0x180,
"../z_construct.c", 178);
interfaceCtx->icon_itemSegment = GameState_AllocEnd(&globalCtx->state, 0x4000, "../z_construct.c", 190);
interfaceCtx->icon_itemSegment = GameState_Alloc(&globalCtx->state, 0x4000, "../z_construct.c", 190);
// Translates to: "Icon Item Texture Initialization = %x"
osSyncPrintf("アイコンアイテム テクスチャ初期=%x\n", 0x4000);
@ -201,7 +201,7 @@ void func_80110F68(GlobalContext* globalCtx) {
View_Init(&msgCtx->view, globalCtx->state.gfxCtx);
msgCtx->textboxSegment = GameState_AllocEnd(&globalCtx->state, 0x2200, "../z_construct.c", 349);
msgCtx->textboxSegment = GameState_Alloc(&globalCtx->state, 0x2200, "../z_construct.c", 349);
osSyncPrintf("message->fukidashiSegment=%x\n", msgCtx->textboxSegment);

2
src/code/z_effect_soft_sprite.c
View file

@ -16,7 +16,7 @@ void EffectSs_InitInfo(GlobalContext* globalCtx, s32 tableSize) {
}
sEffectSsInfo.table =
GameState_AllocEnd(&globalCtx->state, tableSize * sizeof(EffectSs), "../z_effect_soft_sprite.c", 289);
GameState_Alloc(&globalCtx->state, tableSize * sizeof(EffectSs), "../z_effect_soft_sprite.c", 289);
if (sEffectSsInfo.table == NULL) {
__assert("EffectSS2Info.data_table != NULL", "../z_effect_soft_sprite.c", 290);
}

2
src/code/z_jpeg.c
View file

@ -60,7 +60,7 @@ u32 Jpeg_SendTask(JpegContext* ctx) {
ctx->scTask.list.t = sJpegTask;
osSendMesg(&gSchedContext.cmdQ, (OSMesg)&ctx->scTask, OS_MESG_BLOCK);
func_800C95F8(&gSchedContext); // osScKickEntryMsg
Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
osRecvMesg(&ctx->mq, NULL, OS_MESG_BLOCK);
}

2
src/code/z_kaleido_manager.c
View file

@ -53,7 +53,7 @@ void KaleidoManager_Init(GlobalContext* globalCtx) {
osSyncPrintf(VT_FGCOL(GREEN));
osSyncPrintf("KaleidoArea の最大サイズは %d バイトを確保します\n", largestOvl);
osSyncPrintf(VT_RST);
sKaleidoAreaPtr = GameState_AllocEnd(&globalCtx->state, largestOvl, "../z_kaleido_manager.c", 150);
sKaleidoAreaPtr = GameState_Alloc(&globalCtx->state, largestOvl, "../z_kaleido_manager.c", 150);
LogUtils_CheckNullPointer("KaleidoArea_allocp", sKaleidoAreaPtr, "../z_kaleido_manager.c", 151);
osSyncPrintf(VT_FGCOL(GREEN));
osSyncPrintf("KaleidoArea %08x - %08x\n", sKaleidoAreaPtr, (u32)sKaleidoAreaPtr + largestOvl);

2
src/code/z_map_exp.c
View file

@ -232,7 +232,7 @@ void Map_Init(GlobalContext* globalCtx) {
interfaceCtx->unk_258 = -1;
interfaceCtx->unk_25A = -1;
interfaceCtx->mapSegment = GameState_AllocEnd(&globalCtx->state, 0x1000, "../z_map_exp.c", 457);
interfaceCtx->mapSegment = GameState_Alloc(&globalCtx->state, 0x1000, "../z_map_exp.c", 457);
// Translates to "ＭＡＰ TEXTURE INITIALIZATION scene_data_ID=%d mapSegment=%x"
osSyncPrintf("\n\n\nＭＡＰ テクスチャ初期化 scene_data_ID=%d\nmapSegment=%x\n\n", globalCtx->sceneNum,
interfaceCtx->mapSegment, globalCtx);

2
src/code/z_map_mark.c
View file

@ -57,7 +57,7 @@ void MapMark_Init(GlobalContext* globalCtx) {
MapMarkDataOverlay* overlay = &sMapMarkDataOvl;
u32 overlaySize = (u32)overlay->vramEnd - (u32)overlay->vramStart;
overlay->loadedRamAddr = GameState_AllocEnd(&globalCtx->state, overlaySize, "../z_map_mark.c", 235);
overlay->loadedRamAddr = GameState_Alloc(&globalCtx->state, overlaySize, "../z_map_mark.c", 235);
LogUtils_CheckNullPointer("dlftbl->allocp", overlay->loadedRamAddr, "../z_map_mark.c", 236);
Overlay_Load(overlay->vromStart, overlay->vromEnd, overlay->vramStart, overlay->vramEnd, overlay->loadedRamAddr);

2
src/code/z_msgevent.c
View file

@ -16,6 +16,6 @@ void MsgEvent_SendNullTask() {
task.list.t.type = M_NULTASK;
osCreateMesgQueue(task.msgQ, &msg, 1);
osSendMesg(&gSchedContext.cmdQ, &task, OS_MESG_BLOCK);
func_800C95F8(&gSchedContext); // osScKickEntryMsg
Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
}

4
src/code/z_play.c
View file

@ -371,7 +371,7 @@ void Gameplay_Init(GlobalContext* globalCtx) {
osSyncPrintf("ZELDA ALLOC SIZE=%x\n", THA_GetSize(&globalCtx->state.tha));
zAllocSize = THA_GetSize(&globalCtx->state.tha);
zAlloc = GameState_AllocEnd(&globalCtx->state, zAllocSize, "../z_play.c", 2918);
zAlloc = GameState_Alloc(&globalCtx->state, zAllocSize, "../z_play.c", 2918);
zAllocAligned = (void*)(((u32)zAlloc + 8) & ~0xF);
ZeldaArena_Init(zAllocAligned, zAllocSize - (u32)zAllocAligned + (u32)zAlloc);
osSyncPrintf("ゼルダヒープ %08x-%08x\n", zAllocAligned,
@ -1457,7 +1457,7 @@ void* Gameplay_LoadFile(GlobalContext* globalCtx, RomFile* file) {
void* allocp;
size = file->vromEnd - file->vromStart;
allocp = GameState_AllocEnd(&globalCtx->state, size, "../z_play.c", 4692);
allocp = GameState_Alloc(&globalCtx->state, size, "../z_play.c", 4692);
DmaMgr_SendRequest1(allocp, file->vromStart, size, "../z_play.c", 4694);
return allocp;

2
src/code/z_room.c
View file

@ -566,7 +566,7 @@ u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx) {
osSyncPrintf(VT_FGCOL(YELLOW));
// Translates to: "ROOM BUFFER SIZE=%08x(%5.1fK)"
osSyncPrintf("部屋バッファサイズ=%08x(%5.1fK)\n", maxRoomSize, (f64)(maxRoomSize * 0.0009765625f));
roomCtx->bufPtrs[0] = GameState_AllocEnd(&globalCtx->state, maxRoomSize, "../z_room.c", 946);
roomCtx->bufPtrs[0] = GameState_Alloc(&globalCtx->state, maxRoomSize, "../z_room.c", 946);
// Translates to: "ROOM BUFFER INITIAL POINTER=%08x"
osSyncPrintf("部屋バッファ開始ポインタ=%08x\n", roomCtx->bufPtrs[0]);
roomCtx->bufPtrs[1] = (void*)((s32)roomCtx->bufPtrs[0] + maxRoomSize);

2
src/code/z_sample.c
View file

@ -82,7 +82,7 @@ void Sample_SetupView(SampleContext* this) {
void Sample_LoadTitleStatic(SampleContext* this) {
u32 size = _title_staticSegmentRomEnd - _title_staticSegmentRomStart;
this->staticSegment = GameState_AllocEnd(&this->state, size, "../z_sample.c", 163);
this->staticSegment = GameState_Alloc(&this->state, size, "../z_sample.c", 163);
DmaMgr_SendRequest1(this->staticSegment, _title_staticSegmentRomStart, size, "../z_sample.c", 164);
}

2
src/code/z_scene.c
View file

@ -72,7 +72,7 @@ void Object_InitBank(GlobalContext* globalCtx, ObjectContext* objectCtx) {
osSyncPrintf(VT_RST);
objectCtx->spaceStart = objectCtx->status[0].segment =
GameState_AllocEnd(&globalCtx->state, spaceSize, "../z_scene.c", 219);
GameState_Alloc(&globalCtx->state, spaceSize, "../z_scene.c", 219);
objectCtx->spaceEnd = (void*)((s32)objectCtx->spaceStart + spaceSize);
objectCtx->mainKeepIndex = Object_Spawn(objectCtx, OBJECT_GAMEPLAY_KEEP);