From b4751c259e3bc0bb166cffc54061c7d9577ba0dc Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 24 Oct 2020 02:35:51 -0400 Subject: match first two functions in code_801DBE90 --- src/code_801DBE90.cpp | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 src/code_801DBE90.cpp (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp new file mode 100644 index 0000000..ba1678c --- /dev/null +++ b/src/code_801DBE90.cpp @@ -0,0 +1,55 @@ +#include "types.h" +#include "ctorStruct.h" +#include "SDK/mem.h" +#include "code_801DAAE0.h" + + +namespace +{ + //TODO: header/source + struct unkClass + { + u8 unk0; + u8 unk1[0x4F]; + }; +} + + +extern MEMHeapHandle lbl_8063E8EC; + + +//TODO: internal linkage +extern u32 lbl_8063F320; +extern unkClass* lbl_8063F324; + + +extern "C" +{ + +// TODO: return type +//static +void* func_801DBE90(u32 size) +{ +// void* func_801DAD08(MEMHeapHandle heap, u32 size, int alignment) + return func_801DAD08(lbl_8063E8EC, size, 0x20); +} + +//static +void func_801DBEA0(void) +{ + for (size_t i = 0; i < lbl_8063F320; i++) + lbl_8063F324[i].unk0 = 0; +} + +//static +func_801DBED0() +{ + +} + + + + + + +} //extern "C" -- cgit v1.2.3 From 8f73a39edf782bd2e6c91130aac685b8dd267001 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 24 Oct 2020 15:07:58 -0400 Subject: match up to func_801DC0C8 with two nonmatchings --- src/code_801DBE90.cpp | 202 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 197 insertions(+), 5 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index ba1678c..2f57aae 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -1,17 +1,37 @@ #include "types.h" #include "ctorStruct.h" #include "SDK/mem.h" +#include "SDK/os.h" +#include "SDK/dvd.h" +#include "SDK/nand.h" #include "code_801DAAE0.h" namespace { + struct unkClass; + typedef void (*funcPtr)(u32, unkClass*); + + struct unkClass2 + { + u8 unk0[0x40]; + funcPtr unk40; + void* unk44; //data cache start addr to invalidate + u32 unk48; // data cache region size + }; + //TODO: header/source struct unkClass { u8 unk0; - u8 unk1[0x4F]; + u8 unk1; + u8 unk2[0x2]; + unkClass2 unk4; }; + + + + } @@ -19,13 +39,16 @@ extern MEMHeapHandle lbl_8063E8EC; //TODO: internal linkage -extern u32 lbl_8063F320; +extern u8 lbl_8063F31E; +extern u8 lbl_8063F31F; +extern size_t lbl_8063F320; extern unkClass* lbl_8063F324; +extern u32 lbl_8063F338; + extern "C" { - // TODO: return type //static void* func_801DBE90(u32 size) @@ -41,12 +64,181 @@ void func_801DBEA0(void) lbl_8063F324[i].unk0 = 0; } +#ifdef NONMATCHING //static -func_801DBED0() +unkClass *func_801DBED0(void) { - + int new_var; + OSDisableInterrupts(); + unkClass *r31 = 0; + size_t i; + for (i = 0; i < lbl_8063F320; i++) + { + if (lbl_8063F324[i].unk0 != 1) + { + new_var = 1; + lbl_8063F324[i].unk0 = new_var; + lbl_8063F324[i].unk1 = 0; + r31 = &lbl_8063F324[i]; + break; + } + + } +OSRestoreInterrupts(); +return r31; +} +#else +asm unkClass* func_801DBED0(void) +{ +nofralloc +/* 801DBED0 001D7B30 94 21 FF F0 */ stwu r1, -0x10(r1) +/* 801DBED4 001D7B34 7C 08 02 A6 */ mflr r0 +/* 801DBED8 001D7B38 90 01 00 14 */ stw r0, 0x14(r1) +/* 801DBEDC 001D7B3C 93 E1 00 0C */ stw r31, 0xc(r1) +/* 801DBEE0 001D7B40 48 09 28 7D */ bl OSDisableInterrupts +/* 801DBEE4 001D7B44 80 ED A0 64 */ lwz r7, lbl_8063F324 +/* 801DBEE8 001D7B48 3B E0 00 00 */ li r31, 0 +/* 801DBEEC 001D7B4C 80 0D A0 60 */ lwz r0, lbl_8063F320 +/* 801DBEF0 001D7B50 38 A0 00 00 */ li r5, 0 +/* 801DBEF4 001D7B54 7C E4 3B 78 */ mr r4, r7 +/* 801DBEF8 001D7B58 7C 09 03 A6 */ mtctr r0 +/* 801DBEFC 001D7B5C 28 00 00 00 */ cmplwi r0, 0 +/* 801DBF00 001D7B60 40 81 00 44 */ ble lbl_801DBF44 +lbl_801DBF04: +/* 801DBF04 001D7B64 88 04 00 00 */ lbz r0, 0(r4) +/* 801DBF08 001D7B68 28 00 00 01 */ cmplwi r0, 1 +/* 801DBF0C 001D7B6C 41 82 00 2C */ beq lbl_801DBF38 +/* 801DBF10 001D7B70 1C C5 00 50 */ mulli r6, r5, 0x50 +/* 801DBF14 001D7B74 38 00 00 01 */ li r0, 1 +/* 801DBF18 001D7B78 38 A0 00 00 */ li r5, 0 +/* 801DBF1C 001D7B7C 7C 07 31 AE */ stbx r0, r7, r6 +/* 801DBF20 001D7B80 80 0D A0 64 */ lwz r0, lbl_8063F324 +/* 801DBF24 001D7B84 7C 80 32 14 */ add r4, r0, r6 +/* 801DBF28 001D7B88 98 A4 00 01 */ stb r5, 1(r4) +/* 801DBF2C 001D7B8C 80 0D A0 64 */ lwz r0, lbl_8063F324 +/* 801DBF30 001D7B90 7F E0 32 14 */ add r31, r0, r6 +/* 801DBF34 001D7B94 48 00 00 10 */ b lbl_801DBF44 +lbl_801DBF38: +/* 801DBF38 001D7B98 38 84 00 50 */ addi r4, r4, 0x50 +/* 801DBF3C 001D7B9C 38 A5 00 01 */ addi r5, r5, 1 +/* 801DBF40 001D7BA0 42 00 FF C4 */ bdnz lbl_801DBF04 +lbl_801DBF44: +/* 801DBF44 001D7BA4 48 09 28 41 */ bl OSRestoreInterrupts +/* 801DBF48 001D7BA8 7F E3 FB 78 */ mr r3, r31 +/* 801DBF4C 001D7BAC 83 E1 00 0C */ lwz r31, 0xc(r1) +/* 801DBF50 001D7BB0 80 01 00 14 */ lwz r0, 0x14(r1) +/* 801DBF54 001D7BB4 7C 08 03 A6 */ mtlr r0 +/* 801DBF58 001D7BB8 38 21 00 10 */ addi r1, r1, 0x10 +/* 801DBF5C 001D7BBC 4E 80 00 20 */ blr +} +#pragma peephole on +#endif + +//static +void func_801DBF60(unkClass* p1) +{ + OSDisableInterrupts(); + p1->unk0 = 0; + OSRestoreInterrupts(); +} + +#ifdef NONMATCHING2 +//static +unkClass* func_801DBF98(unkClass2* p1) +{ + unkClass* r4 = lbl_8063F324; + size_t i = 0; + for (; i < lbl_8063F320; r4++, i++) { + if (r4->unk0 != 0 && &r4->unk4 == p1) + return &lbl_8063F324[i]; + } + return 0; +} +#else +asm unkClass* func_801DBF98(unkClass2* p1) +{ +/* 801DBF98 001D7BF8 80 AD A0 64 */ lwz r5, lbl_8063F324 +/* 801DBF9C 001D7BFC 38 C0 00 00 */ li r6, 0 +/* 801DBFA0 001D7C00 80 0D A0 60 */ lwz r0, lbl_8063F320 +/* 801DBFA4 001D7C04 7C A4 2B 78 */ mr r4, r5 +/* 801DBFA8 001D7C08 7C 09 03 A6 */ mtctr r0 +/* 801DBFAC 001D7C0C 28 00 00 00 */ cmplwi r0, 0 +/* 801DBFB0 001D7C10 40 81 00 34 */ ble lbl_801DBFE4 +lbl_801DBFB4: +/* 801DBFB4 001D7C14 88 04 00 00 */ lbz r0, 0(r4) +/* 801DBFB8 001D7C18 2C 00 00 00 */ cmpwi r0, 0 +/* 801DBFBC 001D7C1C 41 82 00 1C */ beq lbl_801DBFD8 +/* 801DBFC0 001D7C20 38 04 00 04 */ addi r0, r4, 4 +/* 801DBFC4 001D7C24 7C 00 18 40 */ cmplw r0, r3 +/* 801DBFC8 001D7C28 40 82 00 10 */ bne lbl_801DBFD8 +/* 801DBFCC 001D7C2C 1C 06 00 50 */ mulli r0, r6, 0x50 +/* 801DBFD0 001D7C30 7C 65 02 14 */ add r3, r5, r0 +/* 801DBFD4 001D7C34 4E 80 00 20 */ blr +lbl_801DBFD8: +/* 801DBFD8 001D7C38 38 84 00 50 */ addi r4, r4, 0x50 +/* 801DBFDC 001D7C3C 38 C6 00 01 */ addi r6, r6, 1 +/* 801DBFE0 001D7C40 42 00 FF D4 */ bdnz lbl_801DBFB4 +lbl_801DBFE4: +/* 801DBFE4 001D7C44 38 60 00 00 */ li r3, 0 +/* 801DBFE8 001D7C48 4E 80 00 20 */ blr +} +#pragma peephole on +#endif + +//static +void lbl_801DBFEC(u32 p1, unkClass2* p2) +{ + if (lbl_8063F31F == 0) { + unkClass* r31 = func_801DBF98(p2); + if (r31 && r31->unk4.unk40) { + DCInvalidateRange(r31->unk4.unk44, r31->unk4.unk48); + r31->unk4.unk40(p1, r31); + } + } } +//static +void lbl_801DC068(u32 p1, unkClass2* p2) +{ + if (lbl_8063F31F == 0) { + unkClass* r3 = func_801DBF98(p2); + if (r3 && r3->unk4.unk40) + r3->unk4.unk40(p1, r3); + } +} + +BOOL func_801DC0C8(size_t p1) +{ + if (lbl_8063F31E != 1) { + lbl_8063F31F = 0; + lbl_8063F338 = 0; + NANDInit(); + if (!lbl_8063F338) { + // new , 801DCE7C constructor + } + } else { + return FALSE; + } +} + + + + + + + + + + + + + + + + + + + -- cgit v1.2.3 From 2e329c9f4832159aabdaedf9b9bbb9d1304b51a9 Mon Sep 17 00:00:00 2001 From: Max Date: Sat, 24 Oct 2020 17:05:32 -0400 Subject: match first three functions in code_801DCE6C --- src/code_801DBE90.cpp | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 2f57aae..6e7b54c 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -5,7 +5,7 @@ #include "SDK/dvd.h" #include "SDK/nand.h" #include "code_801DAAE0.h" - +#include "code_801DCE6C.h" namespace { @@ -68,24 +68,28 @@ void func_801DBEA0(void) //static unkClass *func_801DBED0(void) { - int new_var; - OSDisableInterrupts(); + + OSDisableInterrupts(); + unkClass *r31 = 0; size_t i; for (i = 0; i < lbl_8063F320; i++) { if (lbl_8063F324[i].unk0 != 1) { - new_var = 1; - lbl_8063F324[i].unk0 = new_var; + lbl_8063F324[i].unk0 = 1; lbl_8063F324[i].unk1 = 0; r31 = &lbl_8063F324[i]; break; } } -OSRestoreInterrupts(); -return r31; + + + OSRestoreInterrupts(); + return r31; + + } #else asm unkClass* func_801DBED0(void) @@ -133,7 +137,6 @@ lbl_801DBF44: } #pragma peephole on #endif - //static void func_801DBF60(unkClass* p1) { @@ -207,6 +210,7 @@ void lbl_801DC068(u32 p1, unkClass2* p2) } } +#if 0 BOOL func_801DC0C8(size_t p1) { if (lbl_8063F31E != 1) { @@ -214,14 +218,14 @@ BOOL func_801DC0C8(size_t p1) lbl_8063F338 = 0; NANDInit(); if (!lbl_8063F338) { + // lbl_8063F338 = new ...; // new , 801DCE7C constructor } } else { return FALSE; } } - - +#endif -- cgit v1.2.3 From b20f4b2f02dbc2421ec45cccbc55e732b094019e Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 01:18:43 -0400 Subject: match func_801DC0C8 --- src/code_801DBE90.cpp | 85 +++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 72 insertions(+), 13 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 6e7b54c..8519f21 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -1,5 +1,6 @@ #include "types.h" #include "ctorStruct.h" +#include "Runtime/__mem.h" #include "SDK/mem.h" #include "SDK/os.h" #include "SDK/dvd.h" @@ -35,20 +36,46 @@ namespace } -extern MEMHeapHandle lbl_8063E8EC; + //TODO: internal linkage + +// .sdata +extern char* lbl_8063D6D8; +extern char* lbl_8063D6E0; +extern char lbl_8063D6E4[8]; +extern char lbl_8063D6EC[8]; + + extern u8 lbl_8063F31E; extern u8 lbl_8063F31F; extern size_t lbl_8063F320; extern unkClass* lbl_8063F324; -extern u32 lbl_8063F338; +extern u32 lbl_8063F32C; +extern gUnkClass4* lbl_8063F338; +extern u8 lbl_804917F0[0x40]; extern "C" { + +//extern +extern MEMHeapHandle lbl_8063E8EC; +s32 func_80249BC8(void); +// code_80223C54 +u32 func_80223FD0(u32, u32, u32, void (*)(void)); + +void func_801DC9CC(void); +void func_8022408C(u32, const char*); + + + + + + + // TODO: return type //static void* func_801DBE90(u32 size) @@ -210,20 +237,52 @@ void lbl_801DC068(u32 p1, unkClass2* p2) } } -#if 0 -BOOL func_801DC0C8(size_t p1) +#if 1 +BOOL func_801DC0C8(size_t p1, u32 p2) { - if (lbl_8063F31E != 1) { - lbl_8063F31F = 0; - lbl_8063F338 = 0; - NANDInit(); - if (!lbl_8063F338) { - // lbl_8063F338 = new ...; - // new , 801DCE7C constructor - } - } else { + if (lbl_8063F31E == 1) + return FALSE; + lbl_8063F31F = 0; + lbl_8063F338 = NULL; + NANDInit(); + if (!lbl_8063F338) + lbl_8063F338 = new gUnkClass4; + lbl_8063F320 = p1; + lbl_8063F324 = (unkClass*)func_801DBE90(p1 * sizeof(unkClass)); + if (!lbl_8063F324) return FALSE; + func_801DBEA0(); + memset(lbl_804917F0, 0, sizeof(lbl_804917F0)); + DVDInit(); + if (p2) { + switch (func_80249BC8()) { + case 0: + lbl_8063D6D8 = lbl_8063D6E4; + break; + case 1: + lbl_8063D6D8 = lbl_8063D6E4; + break; + case 2: + lbl_8063D6D8 = lbl_8063D6EC; + break; + } + DVDDiskID* diskID = DVDGetCurrentDiskID(); + diskID->gameCode[0] = lbl_8063D6D8[0]; + diskID->gameCode[1] = lbl_8063D6D8[1]; + diskID->gameCode[2] = lbl_8063D6D8[2]; + diskID->gameCode[3] = lbl_8063D6D8[3]; + diskID->makerCode[0] = lbl_8063D6E0[0]; + diskID->makerCode[1] = lbl_8063D6E0[1]; + diskID->unk6 = 0; + diskID->unk7 = 0; } + DVDSetAutoFatalMessaging(FALSE); + + lbl_8063F32C = func_80223FD0(1, 19, 0, &func_801DC9CC); + func_8022408C(lbl_8063F32C, "GSdvdErrorTask"); + + lbl_8063F31E = 1; + return TRUE; } #endif -- cgit v1.2.3 From a1d40c31b8b84973fb7aaa24d2d90d8f55c4cdc6 Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 11:34:42 -0400 Subject: match func_801DC264 --- src/code_801DBE90.cpp | 33 ++++++++++++++++++++++++++++----- 1 file changed, 28 insertions(+), 5 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 8519f21..319f894 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -47,17 +47,20 @@ extern char* lbl_8063D6E0; extern char lbl_8063D6E4[8]; extern char lbl_8063D6EC[8]; - extern u8 lbl_8063F31E; extern u8 lbl_8063F31F; extern size_t lbl_8063F320; extern unkClass* lbl_8063F324; +extern u32 lbl_8063F328; extern u32 lbl_8063F32C; extern gUnkClass4* lbl_8063F338; extern u8 lbl_804917F0[0x40]; +extern void* lbl_8063F600; // initialized in func_8022410C + + extern "C" { @@ -65,10 +68,12 @@ extern "C" extern MEMHeapHandle lbl_8063E8EC; s32 func_80249BC8(void); // code_80223C54 -u32 func_80223FD0(u32, u32, u32, void (*)(void)); +u32 func_80223FD0(u32, u32, u32, void (*)(u32, u32)); -void func_801DC9CC(void); +void func_801DC9CC(u32, u32); void func_8022408C(u32, const char*); +u32 func_802245C4(void*); +void func_80224588(void*); @@ -237,7 +242,6 @@ void lbl_801DC068(u32 p1, unkClass2* p2) } } -#if 1 BOOL func_801DC0C8(size_t p1, u32 p2) { if (lbl_8063F31E == 1) @@ -265,6 +269,8 @@ BOOL func_801DC0C8(size_t p1, u32 p2) case 2: lbl_8063D6D8 = lbl_8063D6EC; break; + default: + break; } DVDDiskID* diskID = DVDGetCurrentDiskID(); diskID->gameCode[0] = lbl_8063D6D8[0]; @@ -284,7 +290,24 @@ BOOL func_801DC0C8(size_t p1, u32 p2) lbl_8063F31E = 1; return TRUE; } -#endif + +//static +void func_801DC264(void) +{ + BOOL r31 = OSDisableInterrupts(); + OSRestoreInterrupts(); + if (r31) { + while (TRUE) { + func_801DC9CC(lbl_8063F32C, 0); + if (lbl_8063F328 == 0) + break; + if (!func_802245C4(lbl_8063F600)) + break; + func_80224588(lbl_8063F600); + } + } +} + -- cgit v1.2.3 From 1f79672cc57db6176590219ec5e34bb6e077f03c Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 14:06:50 -0400 Subject: match up to func_801DC5FC --- src/code_801DBE90.cpp | 99 ++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 82 insertions(+), 17 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 319f894..10a6e29 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -10,16 +10,6 @@ namespace { - struct unkClass; - typedef void (*funcPtr)(u32, unkClass*); - - struct unkClass2 - { - u8 unk0[0x40]; - funcPtr unk40; - void* unk44; //data cache start addr to invalidate - u32 unk48; // data cache region size - }; //TODO: header/source struct unkClass @@ -27,7 +17,7 @@ namespace u8 unk0; u8 unk1; u8 unk2[0x2]; - unkClass2 unk4; + DVDFileInfo unk4; }; @@ -53,7 +43,6 @@ extern size_t lbl_8063F320; extern unkClass* lbl_8063F324; extern u32 lbl_8063F328; extern u32 lbl_8063F32C; - extern gUnkClass4* lbl_8063F338; extern u8 lbl_804917F0[0x40]; @@ -75,8 +64,14 @@ void func_8022408C(u32, const char*); u32 func_802245C4(void*); void func_80224588(void*); +//static +u32 func_801DCF74(gUnkClass4*, const char*, unkClass*); +//static +u32 func_801DCF48(gUnkClass4*, const char*); +//static +s32 func_801DD084(gUnkClass4* p1, unkClass* p2, void* addr, s32 length, s32 offset); - +void* func_801DD220(gUnkClass4*, unkClass*, void*, s32, s32); @@ -179,7 +174,7 @@ void func_801DBF60(unkClass* p1) #ifdef NONMATCHING2 //static -unkClass* func_801DBF98(unkClass2* p1) +unkClass* func_801DBF98(DVDFileInfo* p1) { unkClass* r4 = lbl_8063F324; size_t i = 0; @@ -190,7 +185,7 @@ unkClass* func_801DBF98(unkClass2* p1) return 0; } #else -asm unkClass* func_801DBF98(unkClass2* p1) +asm unkClass* func_801DBF98(DVDFileInfo* p1) { /* 801DBF98 001D7BF8 80 AD A0 64 */ lwz r5, lbl_8063F324 /* 801DBF9C 001D7BFC 38 C0 00 00 */ li r6, 0 @@ -221,7 +216,7 @@ lbl_801DBFE4: #endif //static -void lbl_801DBFEC(u32 p1, unkClass2* p2) +void func_801DBFEC(s32 p1, DVDFileInfo* p2) { if (lbl_8063F31F == 0) { unkClass* r31 = func_801DBF98(p2); @@ -233,7 +228,7 @@ void lbl_801DBFEC(u32 p1, unkClass2* p2) } //static -void lbl_801DC068(u32 p1, unkClass2* p2) +void lbl_801DC068(s32 p1, DVDFileInfo* p2) { if (lbl_8063F31F == 0) { unkClass* r3 = func_801DBF98(p2); @@ -308,9 +303,79 @@ void func_801DC264(void) } } +// DVDOpen wrapper? +unkClass* func_801DC2D0(const char* fileName) +{ + if (!lbl_8063F31E) + return NULL; + func_801DC264(); + unkClass* r31 = func_801DBED0(); + if (!r31) + return NULL; + if (lbl_8063F338 && func_801DCF74(lbl_8063F338, fileName, r31)) + return r31; + if (!DVDOpen(fileName, &r31->unk4)) { + func_801DBF60(r31); + return NULL; + } + return r31; +} +// indicate whether fileName exists +BOOL func_801DC380(const char* fileName) +{ + if (!lbl_8063F31E) + return FALSE; + if (lbl_8063F338 && func_801DCF48(lbl_8063F338, fileName)) + return TRUE; + if (DVDConvertPathToEntrynum(fileName) == -1) + return FALSE; + return TRUE; +} +// DVDReadPrio wrapper +s32 func_801DC3FC(unkClass* p1, void* addr, s32 length, s32 offset) +{ + if (!lbl_8063F31E) + return -1; + func_801DC264(); + if (!p1) + return -1; + if ((u32)addr & 0x1F) + return -1; + if (length & 0x1F) + return -1; + if (offset & 0x3) + return -1; + + if (lbl_8063F338 && p1->unk1) { + s32 r3 = func_801DD084(lbl_8063F338, p1, addr, length, offset); + if (r3 > 0) + return r3; + } + return DVDReadPrio(&p1->unk4, addr, length, offset, 2); +} +BOOL func_801DC4F0(unkClass* p1, void* p2, s32 p3, s32 p4, void (*p5)(s32, void*)) +{ + if (!lbl_8063F31E) + return FALSE; + func_801DC264(); + if (!p1) + return FALSE; + p1->unk4.unk40 = p5; + if ((u32)p2 & 0x1F) + return FALSE; + if (p3 & 0x1F) + return FALSE; + if (p4 & 0x3) + return FALSE; + p1->unk4.unk44 = p2; + p1->unk4.unk48 = p3; + if (lbl_8063F338 && p1->unk1 && func_801DD220(lbl_8063F338, p1, p2, p3, p4)) + return TRUE; + return DVDReadAsyncPrio(&p1->unk4, p2, p3, p4, &func_801DBFEC, 2) != 0; +} -- cgit v1.2.3 From 69dd6927a2ec6791639065a70da615228ae362f6 Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 15:09:41 -0400 Subject: match up to func_801DC7F8 --- src/code_801DBE90.cpp | 61 ++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 56 insertions(+), 5 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 10a6e29..c8c2ad1 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -14,7 +14,7 @@ namespace //TODO: header/source struct unkClass { - u8 unk0; + u8 unk0; // file open flag? u8 unk1; u8 unk2[0x2]; DVDFileInfo unk4; @@ -73,6 +73,9 @@ s32 func_801DD084(gUnkClass4* p1, unkClass* p2, void* addr, s32 length, s32 offs void* func_801DD220(gUnkClass4*, unkClass*, void*, s32, s32); +u32 func_801DCFE4(gUnkClass4*, unkClass*); + +u32 func_801DD03C(gUnkClass4*, unkClass*, u32*); @@ -370,6 +373,7 @@ BOOL func_801DC4F0(unkClass* p1, void* p2, s32 p3, s32 p4, void (*p5)(s32, void* return FALSE; if (p4 & 0x3) return FALSE; + p1->unk4.unk44 = p2; p1->unk4.unk48 = p3; if (lbl_8063F338 && p1->unk1 && func_801DD220(lbl_8063F338, p1, p2, p3, p4)) @@ -377,13 +381,60 @@ BOOL func_801DC4F0(unkClass* p1, void* p2, s32 p3, s32 p4, void (*p5)(s32, void* return DVDReadAsyncPrio(&p1->unk4, p2, p3, p4, &func_801DBFEC, 2) != 0; } +// DVDReadPrio wrapper +s32 func_801DC5FC(unkClass* p1, void* addr, s32 length, s32 offset, s32 prio) +{ + if (!lbl_8063F31E) + return -1; + func_801DC264(); + if (!p1) + return -1; + if ((u32)addr & 0x1F) + return -1; + if (length & 0x1F) + return -1; + if (offset & 0x3) + return -1; + + if (prio < 0 || prio > 3) + return -1; + return DVDReadPrio(&p1->unk4, addr, length, offset, prio); +} +BOOL func_801DC6C4(unkClass* p1) +{ + if (!lbl_8063F31E) + return FALSE; + func_801DC264(); + if (!p1) + return FALSE; + if (lbl_8063F338 && func_801DCFE4(lbl_8063F338, p1)) { + func_801DBF60(p1); + return TRUE; + } + BOOL result = DVDClose(&p1->unk4); + func_801DBF60(p1); + return result; +} +u32 func_801DC760(unkClass* p1) +{ + u32 sp8; // TODO: determine type + if (!lbl_8063F31E) + return 0; + func_801DC264(); + if (!p1) + return 0; + if (lbl_8063F338 && func_801DD03C(lbl_8063F338, p1, &sp8)) + return sp8; + return p1->unk4.unk34; +} - - - - +//static +s32 func_801DC7DC(void) +{ + return (!lbl_8063F31E) ? -1 : DVDGetDriveStatus(); +} -- cgit v1.2.3 From 126972af1a4ff9084cd48f9c57eb07f3951e5086 Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 16:13:32 -0400 Subject: match up to func_801DC9CC --- src/code_801DBE90.cpp | 83 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 82 insertions(+), 1 deletion(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index c8c2ad1..3826f7d 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -36,6 +36,8 @@ extern char* lbl_8063D6D8; extern char* lbl_8063D6E0; extern char lbl_8063D6E4[8]; extern char lbl_8063D6EC[8]; +extern s32 lbl_8063D6F4; + extern u8 lbl_8063F31E; extern u8 lbl_8063F31F; @@ -43,9 +45,15 @@ extern size_t lbl_8063F320; extern unkClass* lbl_8063F324; extern u32 lbl_8063F328; extern u32 lbl_8063F32C; + +extern void (*lbl_8063F330)(void); +extern void (*lbl_8063F334)(void); + extern gUnkClass4* lbl_8063F338; extern u8 lbl_804917F0[0x40]; +extern OSSemaphore lbl_80491830; +extern DVDCommandBlock lbl_80491840; extern void* lbl_8063F600; // initialized in func_8022410C @@ -231,7 +239,7 @@ void func_801DBFEC(s32 p1, DVDFileInfo* p2) } //static -void lbl_801DC068(s32 p1, DVDFileInfo* p2) +void func_801DC068(s32 p1, DVDFileInfo* p2) { if (lbl_8063F31F == 0) { unkClass* r3 = func_801DBF98(p2); @@ -436,11 +444,84 @@ s32 func_801DC7DC(void) return (!lbl_8063F31E) ? -1 : DVDGetDriveStatus(); } +BOOL func_801DC7F8(unkClass* p1, s32 offset, void (*p3)(s32, void*)) +{ + if (!lbl_8063F31E) + return FALSE; + func_801DC264(); + if (!p1) + return FALSE; + p1->unk4.unk40 = p3; + return DVDSeekAsyncPrio(&p1->unk4, offset, &func_801DC068, 2) != 0; +} + +//static +void func_801DC888(s32 p1) +{ + switch (p1) + { + case -1: + lbl_8063F328 = 9; + break; + case 5: + lbl_8063F328 = 1; + break; + case 4: + lbl_8063F328 = 3; + break; + case 6: + lbl_8063F328 = 5; + break; + case 11: + lbl_8063F328 = 7; + break; + default: + break; + } +} +//static +void func_801DC8E8(void) +{ + if (lbl_8063F330) + lbl_8063F330(); +} +//static +void func_801DC900(void) +{ + if (lbl_8063F334) + lbl_8063F334(); +} +//static +void func_801DC918(s32 p1, DVDCommandBlock*) +{ + lbl_8063D6F4 = p1; + OSSignalSemaphore(&lbl_80491830); +} +//static +BOOL func_801DC928(void) +{ + BOOL r31 = OSDisableInterrupts(); + OSRestoreInterrupts(); + if (!r31) + return TRUE; + OSInitSemaphore(&lbl_80491830, 0); + lbl_8063D6F4 = -1; + if (!DVDCheckDiskAsync(&lbl_80491840, &func_801DC918)) + lbl_8063D6F4 = 0; + if (lbl_8063D6F4 < 0) + OSWaitSemaphore(&lbl_80491830); + return lbl_8063D6F4 != 0; +} +//static +func_801DC9CC(u32 p1, u32 p2) +{ + +} -- cgit v1.2.3 From dfcd7d75a33c3706f0c0f3e58efd564fc578d8ec Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 18:07:56 -0400 Subject: match 801DC9CC --- src/code_801DBE90.cpp | 86 ++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 79 insertions(+), 7 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 3826f7d..8f8386f 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -46,7 +46,7 @@ extern unkClass* lbl_8063F324; extern u32 lbl_8063F328; extern u32 lbl_8063F32C; -extern void (*lbl_8063F330)(void); +extern void (*lbl_8063F330)(u32); extern void (*lbl_8063F334)(void); extern gUnkClass4* lbl_8063F338; @@ -458,8 +458,7 @@ BOOL func_801DC7F8(unkClass* p1, s32 offset, void (*p3)(s32, void*)) //static void func_801DC888(s32 p1) { - switch (p1) - { + switch (p1) { case -1: lbl_8063F328 = 9; break; @@ -481,10 +480,10 @@ void func_801DC888(s32 p1) } //static -void func_801DC8E8(void) +void func_801DC8E8(u32 p1) { if (lbl_8063F330) - lbl_8063F330(); + lbl_8063F330(p1); } //static @@ -518,9 +517,82 @@ BOOL func_801DC928(void) } //static -func_801DC9CC(u32 p1, u32 p2) +void func_801DC9CC(u32 p1, u32) { - + s32 driveStatus = func_801DC7DC(); + switch (lbl_8063F328) { + case 0: + func_801DC888(driveStatus); + break; + case 1: + func_801DC8E8(1); + lbl_8063F328 = 2; + break; + case 2: + if (driveStatus == 11) { + func_801DC900(); + func_801DC8E8(4); + lbl_8063F328 = 8; + } else if (driveStatus != 5 && func_801DC928()) { + func_801DC900(); + lbl_8063F328 = 0; + } + break; + case 3: + func_801DC8E8(2); + lbl_8063F328 = 4; + break; + case 4: + if (driveStatus == 11) { + func_801DC900(); + func_801DC8E8(4); + lbl_8063F328 = 8; + } else if (driveStatus != 4 && func_801DC928()) { + func_801DC900(); + lbl_8063F328 = 0; + } + break; + case 5: + func_801DC8E8(3); + lbl_8063F328 = 6; + break; + case 6: + if (driveStatus == 11) { + func_801DC900(); + func_801DC8E8(4); + lbl_8063F328 = 8; + } else if (driveStatus != 6 && func_801DC928()) { + func_801DC900(); + lbl_8063F328 = 0; + } + break; + case 7: + func_801DC8E8(4); + lbl_8063F328 = 8; + break; + case 8: + if (driveStatus == 5) { + func_801DC900(); + func_801DC8E8(1); + lbl_8063F328 = 2; + } else if (driveStatus == 4) { + func_801DC900(); + func_801DC8E8(2); + lbl_8063F328 = 4; + } else if ((driveStatus != 11 && func_801DC928()) || (u32)(driveStatus-4) <= 1) { + func_801DC900(); + lbl_8063F328 = 0; + } + break; + case 9: + func_801DC8E8(5); + lbl_8063F328 = 10; + break; + case 10: + break; + default: + break; + } } -- cgit v1.2.3 From 3512ee2e095d0aaa663b2feea4781f5199139d8f Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 20:00:40 -0400 Subject: match up to func_801DCE38 --- src/code_801DBE90.cpp | 91 ++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 87 insertions(+), 4 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 8f8386f..7e49642 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -43,7 +43,7 @@ extern u8 lbl_8063F31E; extern u8 lbl_8063F31F; extern size_t lbl_8063F320; extern unkClass* lbl_8063F324; -extern u32 lbl_8063F328; +extern s32 lbl_8063F328; extern u32 lbl_8063F32C; extern void (*lbl_8063F330)(u32); @@ -84,7 +84,9 @@ void* func_801DD220(gUnkClass4*, unkClass*, void*, s32, s32); u32 func_801DCFE4(gUnkClass4*, unkClass*); u32 func_801DD03C(gUnkClass4*, unkClass*, u32*); - + +BOOL func_801DD294(gUnkClass4*, const char*, u32); + // TODO: return type @@ -425,9 +427,10 @@ BOOL func_801DC6C4(unkClass* p1) return result; } -u32 func_801DC760(unkClass* p1) +// get file size +size_t func_801DC760(unkClass* p1) { - u32 sp8; // TODO: determine type + size_t sp8; if (!lbl_8063F31E) return 0; func_801DC264(); @@ -595,6 +598,86 @@ void func_801DC9CC(u32 p1, u32) } } +// Load entire file contents into buffer +u8* func_801DCBC0(const char* fileName, u32* fileSz) +{ + if (!func_801DC380(fileName)) + return NULL; + unkClass* fp = func_801DC2D0(fileName); + if (!fp) + return NULL; + size_t size = (func_801DC760(fp) + 0x1F) & ~0x1F; + if (!size) + return NULL; + u8* buf = (u8*)func_801DAD64(size); + if (!buf) + return NULL; + size_t bytesRead = func_801DC3FC(fp, buf, size, 0); + if (bytesRead != size) { + func_801DAEA4(buf); + return NULL; + } + func_801DC6C4(fp); + if (fileSz) + *fileSz = size; + return buf; +} + +void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) +{ + if (!func_801DC380(fileName)) + return NULL; + unkClass* fp = func_801DC2D0(fileName); + if (!fp) + return NULL; + size_t size = (func_801DC760(fp) + 0x1F) & ~0x1F; + if (!size) + return NULL; + u8* buf = (u8*)func_801DAC94(heap, size); + if (!buf) + return NULL; + size_t bytesRead = func_801DC3FC(fp, buf, size, 0); + if (bytesRead != size) { + func_801DAD48(heap, buf); + return NULL; + } + func_801DC6C4(fp); + if (fileSz) + *fileSz = size; + return buf; +} + +u32 func_801DCD94(const char* fileName) +{ + if (lbl_8063F338) + return func_801DD294(lbl_8063F338, fileName, 0); + return 0; +} + +void func_801DCDB8(void (*p1)(u32), void (*p2)(void)) +{ + lbl_8063F330 = p1; + lbl_8063F334 = p2; +} + +u32 func_801DCDC4(void) +{ + switch (lbl_8063F328) { + case 1: case 2: + return 1; + case 3: case 4: + return 2; + case 5: case 6: + return 3; + case 7: case 8: + return 4; + case 9: case 10: + return 5; + case 0: default: + return 0; + } +} + -- cgit v1.2.3 From c4dcd29c7708fc02463cf7e921f31ab404d88843 Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 20:37:19 -0400 Subject: match all of code_801DBE90 --- src/code_801DBE90.cpp | 148 +++++++++++--------------------------------------- 1 file changed, 33 insertions(+), 115 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 7e49642..be5efba 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -38,7 +38,7 @@ extern char lbl_8063D6E4[8]; extern char lbl_8063D6EC[8]; extern s32 lbl_8063D6F4; - +static ctorStruct gUnk8063F318(1, 4, 0); extern u8 lbl_8063F31E; extern u8 lbl_8063F31F; extern size_t lbl_8063F320; @@ -104,129 +104,41 @@ void func_801DBEA0(void) lbl_8063F324[i].unk0 = 0; } -#ifdef NONMATCHING //static unkClass *func_801DBED0(void) { - - OSDisableInterrupts(); - - unkClass *r31 = 0; - size_t i; - for (i = 0; i < lbl_8063F320; i++) - { - if (lbl_8063F324[i].unk0 != 1) - { - lbl_8063F324[i].unk0 = 1; - lbl_8063F324[i].unk1 = 0; - r31 = &lbl_8063F324[i]; - break; + BOOL enable = OSDisableInterrupts(); + unkClass* r31 = NULL; + size_t i; + for (i = 0; i < lbl_8063F320; i++) { + if (lbl_8063F324[i].unk0 != 1) { + lbl_8063F324[i].unk0 = 1; + lbl_8063F324[i].unk1 = 0; + r31 = &lbl_8063F324[i]; + break; + } } - - } - - - OSRestoreInterrupts(); + OSRestoreInterrupts(enable); return r31; - - -} -#else -asm unkClass* func_801DBED0(void) -{ -nofralloc -/* 801DBED0 001D7B30 94 21 FF F0 */ stwu r1, -0x10(r1) -/* 801DBED4 001D7B34 7C 08 02 A6 */ mflr r0 -/* 801DBED8 001D7B38 90 01 00 14 */ stw r0, 0x14(r1) -/* 801DBEDC 001D7B3C 93 E1 00 0C */ stw r31, 0xc(r1) -/* 801DBEE0 001D7B40 48 09 28 7D */ bl OSDisableInterrupts -/* 801DBEE4 001D7B44 80 ED A0 64 */ lwz r7, lbl_8063F324 -/* 801DBEE8 001D7B48 3B E0 00 00 */ li r31, 0 -/* 801DBEEC 001D7B4C 80 0D A0 60 */ lwz r0, lbl_8063F320 -/* 801DBEF0 001D7B50 38 A0 00 00 */ li r5, 0 -/* 801DBEF4 001D7B54 7C E4 3B 78 */ mr r4, r7 -/* 801DBEF8 001D7B58 7C 09 03 A6 */ mtctr r0 -/* 801DBEFC 001D7B5C 28 00 00 00 */ cmplwi r0, 0 -/* 801DBF00 001D7B60 40 81 00 44 */ ble lbl_801DBF44 -lbl_801DBF04: -/* 801DBF04 001D7B64 88 04 00 00 */ lbz r0, 0(r4) -/* 801DBF08 001D7B68 28 00 00 01 */ cmplwi r0, 1 -/* 801DBF0C 001D7B6C 41 82 00 2C */ beq lbl_801DBF38 -/* 801DBF10 001D7B70 1C C5 00 50 */ mulli r6, r5, 0x50 -/* 801DBF14 001D7B74 38 00 00 01 */ li r0, 1 -/* 801DBF18 001D7B78 38 A0 00 00 */ li r5, 0 -/* 801DBF1C 001D7B7C 7C 07 31 AE */ stbx r0, r7, r6 -/* 801DBF20 001D7B80 80 0D A0 64 */ lwz r0, lbl_8063F324 -/* 801DBF24 001D7B84 7C 80 32 14 */ add r4, r0, r6 -/* 801DBF28 001D7B88 98 A4 00 01 */ stb r5, 1(r4) -/* 801DBF2C 001D7B8C 80 0D A0 64 */ lwz r0, lbl_8063F324 -/* 801DBF30 001D7B90 7F E0 32 14 */ add r31, r0, r6 -/* 801DBF34 001D7B94 48 00 00 10 */ b lbl_801DBF44 -lbl_801DBF38: -/* 801DBF38 001D7B98 38 84 00 50 */ addi r4, r4, 0x50 -/* 801DBF3C 001D7B9C 38 A5 00 01 */ addi r5, r5, 1 -/* 801DBF40 001D7BA0 42 00 FF C4 */ bdnz lbl_801DBF04 -lbl_801DBF44: -/* 801DBF44 001D7BA4 48 09 28 41 */ bl OSRestoreInterrupts -/* 801DBF48 001D7BA8 7F E3 FB 78 */ mr r3, r31 -/* 801DBF4C 001D7BAC 83 E1 00 0C */ lwz r31, 0xc(r1) -/* 801DBF50 001D7BB0 80 01 00 14 */ lwz r0, 0x14(r1) -/* 801DBF54 001D7BB4 7C 08 03 A6 */ mtlr r0 -/* 801DBF58 001D7BB8 38 21 00 10 */ addi r1, r1, 0x10 -/* 801DBF5C 001D7BBC 4E 80 00 20 */ blr -} -#pragma peephole on -#endif +} + //static void func_801DBF60(unkClass* p1) { - OSDisableInterrupts(); + BOOL enable = OSDisableInterrupts(); p1->unk0 = 0; - OSRestoreInterrupts(); + OSRestoreInterrupts(enable); } -#ifdef NONMATCHING2 //static unkClass* func_801DBF98(DVDFileInfo* p1) { - unkClass* r4 = lbl_8063F324; - size_t i = 0; - for (; i < lbl_8063F320; r4++, i++) { - if (r4->unk0 != 0 && &r4->unk4 == p1) + for (size_t i = 0; i < lbl_8063F320; i++) { + if (lbl_8063F324[i].unk0 && &lbl_8063F324[i].unk4 == p1) return &lbl_8063F324[i]; } - return 0; + return NULL; } -#else -asm unkClass* func_801DBF98(DVDFileInfo* p1) -{ -/* 801DBF98 001D7BF8 80 AD A0 64 */ lwz r5, lbl_8063F324 -/* 801DBF9C 001D7BFC 38 C0 00 00 */ li r6, 0 -/* 801DBFA0 001D7C00 80 0D A0 60 */ lwz r0, lbl_8063F320 -/* 801DBFA4 001D7C04 7C A4 2B 78 */ mr r4, r5 -/* 801DBFA8 001D7C08 7C 09 03 A6 */ mtctr r0 -/* 801DBFAC 001D7C0C 28 00 00 00 */ cmplwi r0, 0 -/* 801DBFB0 001D7C10 40 81 00 34 */ ble lbl_801DBFE4 -lbl_801DBFB4: -/* 801DBFB4 001D7C14 88 04 00 00 */ lbz r0, 0(r4) -/* 801DBFB8 001D7C18 2C 00 00 00 */ cmpwi r0, 0 -/* 801DBFBC 001D7C1C 41 82 00 1C */ beq lbl_801DBFD8 -/* 801DBFC0 001D7C20 38 04 00 04 */ addi r0, r4, 4 -/* 801DBFC4 001D7C24 7C 00 18 40 */ cmplw r0, r3 -/* 801DBFC8 001D7C28 40 82 00 10 */ bne lbl_801DBFD8 -/* 801DBFCC 001D7C2C 1C 06 00 50 */ mulli r0, r6, 0x50 -/* 801DBFD0 001D7C30 7C 65 02 14 */ add r3, r5, r0 -/* 801DBFD4 001D7C34 4E 80 00 20 */ blr -lbl_801DBFD8: -/* 801DBFD8 001D7C38 38 84 00 50 */ addi r4, r4, 0x50 -/* 801DBFDC 001D7C3C 38 C6 00 01 */ addi r6, r6, 1 -/* 801DBFE0 001D7C40 42 00 FF D4 */ bdnz lbl_801DBFB4 -lbl_801DBFE4: -/* 801DBFE4 001D7C44 38 60 00 00 */ li r3, 0 -/* 801DBFE8 001D7C48 4E 80 00 20 */ blr -} -#pragma peephole on -#endif //static void func_801DBFEC(s32 p1, DVDFileInfo* p2) @@ -302,9 +214,9 @@ BOOL func_801DC0C8(size_t p1, u32 p2) //static void func_801DC264(void) { - BOOL r31 = OSDisableInterrupts(); - OSRestoreInterrupts(); - if (r31) { + BOOL enable = OSDisableInterrupts(); + OSRestoreInterrupts(enable); + if (enable) { while (TRUE) { func_801DC9CC(lbl_8063F32C, 0); if (lbl_8063F328 == 0) @@ -506,9 +418,9 @@ void func_801DC918(s32 p1, DVDCommandBlock*) //static BOOL func_801DC928(void) { - BOOL r31 = OSDisableInterrupts(); - OSRestoreInterrupts(); - if (!r31) + BOOL enable = OSDisableInterrupts(); + OSRestoreInterrupts(enable); + if (!enable) return TRUE; OSInitSemaphore(&lbl_80491830, 0); lbl_8063D6F4 = -1; @@ -678,8 +590,14 @@ u32 func_801DCDC4(void) } } +void func_801DCE38(void) +{ + lbl_8063F31F = 1; +} - - +u8 func_801DCE44(void) +{ + return lbl_8063F31F; +} } //extern "C" -- cgit v1.2.3 From 585b88fcba1dc639c859288a3df7f21a3b17bd4a Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 22:42:39 -0400 Subject: add headers and cleanup --- src/code_801DBE90.cpp | 214 ++++++++++++++++++-------------------------------- 1 file changed, 75 insertions(+), 139 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index be5efba..70253ac 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -7,108 +7,61 @@ #include "SDK/nand.h" #include "code_801DAAE0.h" #include "code_801DCE6C.h" - -namespace -{ - - //TODO: header/source - struct unkClass - { - u8 unk0; // file open flag? - u8 unk1; - u8 unk2[0x2]; - DVDFileInfo unk4; - }; - - - - -} - - - - - -//TODO: internal linkage - -// .sdata -extern char* lbl_8063D6D8; -extern char* lbl_8063D6E0; -extern char lbl_8063D6E4[8]; -extern char lbl_8063D6EC[8]; -extern s32 lbl_8063D6F4; - +#include "code_80223C54.h" +#include "code_80224104.h" +#include "code_80249BC8.h" +#include "code_801DBE90.h" + +static void* func_801DBE90(u32 size); +static void func_801DBEA0(void); +static gUnkClass5 *func_801DBED0(void); +static void func_801DBF60(gUnkClass5* p1); +static gUnkClass5* func_801DBF98(DVDFileInfo* p1); +static void func_801DBFEC(s32 p1, DVDFileInfo* p2); +static void func_801DC068(s32 p1, DVDFileInfo* p2); +static void func_801DC264(void); +static s32 func_801DC7DC(void); +static void func_801DC888(s32 p1); +static void func_801DC8E8(u32 p1); +static void func_801DC900(void); +static void func_801DC918(s32 p1, DVDCommandBlock*); +static BOOL func_801DC928(void); +static void func_801DC9CC(u32 p1, u32); + +static u8 lbl_804917F0[0x40]; +static OSSemaphore lbl_80491830; +static DVDCommandBlock lbl_80491840; +static const char* lbl_8063D6D8 = "RPBE"; +static const char* lbl_8063D6E0 = "01"; static ctorStruct gUnk8063F318(1, 4, 0); -extern u8 lbl_8063F31E; -extern u8 lbl_8063F31F; -extern size_t lbl_8063F320; -extern unkClass* lbl_8063F324; -extern s32 lbl_8063F328; -extern u32 lbl_8063F32C; - -extern void (*lbl_8063F330)(u32); -extern void (*lbl_8063F334)(void); - -extern gUnkClass4* lbl_8063F338; - -extern u8 lbl_804917F0[0x40]; -extern OSSemaphore lbl_80491830; -extern DVDCommandBlock lbl_80491840; - -extern void* lbl_8063F600; // initialized in func_8022410C - +static u8 lbl_8063F31E; +static u8 lbl_8063F31F; +static size_t lbl_8063F320; +static gUnkClass5* lbl_8063F324; +static s32 lbl_8063F328; +static u32 lbl_8063F32C; +static void (*lbl_8063F330)(u32); +static void (*lbl_8063F334)(void); +static gUnkClass4* lbl_8063F338; extern "C" { - -//extern -extern MEMHeapHandle lbl_8063E8EC; -s32 func_80249BC8(void); -// code_80223C54 -u32 func_80223FD0(u32, u32, u32, void (*)(u32, u32)); - -void func_801DC9CC(u32, u32); -void func_8022408C(u32, const char*); -u32 func_802245C4(void*); -void func_80224588(void*); - -//static -u32 func_801DCF74(gUnkClass4*, const char*, unkClass*); -//static -u32 func_801DCF48(gUnkClass4*, const char*); -//static -s32 func_801DD084(gUnkClass4* p1, unkClass* p2, void* addr, s32 length, s32 offset); - -void* func_801DD220(gUnkClass4*, unkClass*, void*, s32, s32); - -u32 func_801DCFE4(gUnkClass4*, unkClass*); - -u32 func_801DD03C(gUnkClass4*, unkClass*, u32*); -BOOL func_801DD294(gUnkClass4*, const char*, u32); - - - -// TODO: return type -//static -void* func_801DBE90(u32 size) +static void* func_801DBE90(u32 size) { -// void* func_801DAD08(MEMHeapHandle heap, u32 size, int alignment) return func_801DAD08(lbl_8063E8EC, size, 0x20); } -//static -void func_801DBEA0(void) +static void func_801DBEA0(void) { for (size_t i = 0; i < lbl_8063F320; i++) lbl_8063F324[i].unk0 = 0; } -//static -unkClass *func_801DBED0(void) +static gUnkClass5 *func_801DBED0(void) { BOOL enable = OSDisableInterrupts(); - unkClass* r31 = NULL; + gUnkClass5* r31 = NULL; size_t i; for (i = 0; i < lbl_8063F320; i++) { if (lbl_8063F324[i].unk0 != 1) { @@ -122,16 +75,14 @@ unkClass *func_801DBED0(void) return r31; } -//static -void func_801DBF60(unkClass* p1) +static void func_801DBF60(gUnkClass5* p1) { BOOL enable = OSDisableInterrupts(); p1->unk0 = 0; OSRestoreInterrupts(enable); } -//static -unkClass* func_801DBF98(DVDFileInfo* p1) +static gUnkClass5* func_801DBF98(DVDFileInfo* p1) { for (size_t i = 0; i < lbl_8063F320; i++) { if (lbl_8063F324[i].unk0 && &lbl_8063F324[i].unk4 == p1) @@ -140,11 +91,10 @@ unkClass* func_801DBF98(DVDFileInfo* p1) return NULL; } -//static -void func_801DBFEC(s32 p1, DVDFileInfo* p2) +static void func_801DBFEC(s32 p1, DVDFileInfo* p2) { if (lbl_8063F31F == 0) { - unkClass* r31 = func_801DBF98(p2); + gUnkClass5* r31 = func_801DBF98(p2); if (r31 && r31->unk4.unk40) { DCInvalidateRange(r31->unk4.unk44, r31->unk4.unk48); r31->unk4.unk40(p1, r31); @@ -152,11 +102,10 @@ void func_801DBFEC(s32 p1, DVDFileInfo* p2) } } -//static -void func_801DC068(s32 p1, DVDFileInfo* p2) +static void func_801DC068(s32 p1, DVDFileInfo* p2) { if (lbl_8063F31F == 0) { - unkClass* r3 = func_801DBF98(p2); + gUnkClass5* r3 = func_801DBF98(p2); if (r3 && r3->unk4.unk40) r3->unk4.unk40(p1, r3); } @@ -172,7 +121,7 @@ BOOL func_801DC0C8(size_t p1, u32 p2) if (!lbl_8063F338) lbl_8063F338 = new gUnkClass4; lbl_8063F320 = p1; - lbl_8063F324 = (unkClass*)func_801DBE90(p1 * sizeof(unkClass)); + lbl_8063F324 = (gUnkClass5*)func_801DBE90(p1 * sizeof(gUnkClass5)); if (!lbl_8063F324) return FALSE; func_801DBEA0(); @@ -181,13 +130,13 @@ BOOL func_801DC0C8(size_t p1, u32 p2) if (p2) { switch (func_80249BC8()) { case 0: - lbl_8063D6D8 = lbl_8063D6E4; + lbl_8063D6D8 = "RPBE"; break; case 1: - lbl_8063D6D8 = lbl_8063D6E4; + lbl_8063D6D8 = "RPBE"; break; case 2: - lbl_8063D6D8 = lbl_8063D6EC; + lbl_8063D6D8 = "RPBP"; break; default: break; @@ -211,8 +160,7 @@ BOOL func_801DC0C8(size_t p1, u32 p2) return TRUE; } -//static -void func_801DC264(void) +static void func_801DC264(void) { BOOL enable = OSDisableInterrupts(); OSRestoreInterrupts(enable); @@ -228,13 +176,12 @@ void func_801DC264(void) } } -// DVDOpen wrapper? -unkClass* func_801DC2D0(const char* fileName) +gUnkClass5* func_801DC2D0(const char* fileName) { if (!lbl_8063F31E) return NULL; func_801DC264(); - unkClass* r31 = func_801DBED0(); + gUnkClass5* r31 = func_801DBED0(); if (!r31) return NULL; if (lbl_8063F338 && func_801DCF74(lbl_8063F338, fileName, r31)) @@ -246,7 +193,6 @@ unkClass* func_801DC2D0(const char* fileName) return r31; } -// indicate whether fileName exists BOOL func_801DC380(const char* fileName) { if (!lbl_8063F31E) @@ -258,8 +204,7 @@ BOOL func_801DC380(const char* fileName) return TRUE; } -// DVDReadPrio wrapper -s32 func_801DC3FC(unkClass* p1, void* addr, s32 length, s32 offset) +s32 func_801DC3FC(gUnkClass5* p1, void* addr, s32 length, s32 offset) { if (!lbl_8063F31E) return -1; @@ -281,7 +226,7 @@ s32 func_801DC3FC(unkClass* p1, void* addr, s32 length, s32 offset) return DVDReadPrio(&p1->unk4, addr, length, offset, 2); } -BOOL func_801DC4F0(unkClass* p1, void* p2, s32 p3, s32 p4, void (*p5)(s32, void*)) +BOOL func_801DC4F0(gUnkClass5* p1, void* p2, u32 p3, s32 p4, void (*p5)(s32, void*)) { if (!lbl_8063F31E) return FALSE; @@ -300,11 +245,10 @@ BOOL func_801DC4F0(unkClass* p1, void* p2, s32 p3, s32 p4, void (*p5)(s32, void* p1->unk4.unk48 = p3; if (lbl_8063F338 && p1->unk1 && func_801DD220(lbl_8063F338, p1, p2, p3, p4)) return TRUE; - return DVDReadAsyncPrio(&p1->unk4, p2, p3, p4, &func_801DBFEC, 2) != 0; + return DVDReadAsyncPrio(&p1->unk4, p2, (s32)p3, p4, &func_801DBFEC, 2) != 0; } -// DVDReadPrio wrapper -s32 func_801DC5FC(unkClass* p1, void* addr, s32 length, s32 offset, s32 prio) +s32 func_801DC5FC(gUnkClass5* p1, void* addr, s32 length, s32 offset, s32 prio) { if (!lbl_8063F31E) return -1; @@ -323,7 +267,7 @@ s32 func_801DC5FC(unkClass* p1, void* addr, s32 length, s32 offset, s32 prio) return DVDReadPrio(&p1->unk4, addr, length, offset, prio); } -BOOL func_801DC6C4(unkClass* p1) +BOOL func_801DC6C4(gUnkClass5* p1) { if (!lbl_8063F31E) return FALSE; @@ -339,27 +283,25 @@ BOOL func_801DC6C4(unkClass* p1) return result; } -// get file size -size_t func_801DC760(unkClass* p1) +size_t func_801DC760(gUnkClass5* p1) { - size_t sp8; + size_t fileSz; if (!lbl_8063F31E) return 0; func_801DC264(); if (!p1) return 0; - if (lbl_8063F338 && func_801DD03C(lbl_8063F338, p1, &sp8)) - return sp8; + if (lbl_8063F338 && func_801DD03C(lbl_8063F338, p1, &fileSz)) + return fileSz; return p1->unk4.unk34; } -//static -s32 func_801DC7DC(void) +static s32 func_801DC7DC(void) { return (!lbl_8063F31E) ? -1 : DVDGetDriveStatus(); } -BOOL func_801DC7F8(unkClass* p1, s32 offset, void (*p3)(s32, void*)) +BOOL func_801DC7F8(gUnkClass5* p1, s32 offset, void (*p3)(s32, void*)) { if (!lbl_8063F31E) return FALSE; @@ -370,8 +312,7 @@ BOOL func_801DC7F8(unkClass* p1, s32 offset, void (*p3)(s32, void*)) return DVDSeekAsyncPrio(&p1->unk4, offset, &func_801DC068, 2) != 0; } -//static -void func_801DC888(s32 p1) +static void func_801DC888(s32 p1) { switch (p1) { case -1: @@ -394,29 +335,26 @@ void func_801DC888(s32 p1) } } -//static -void func_801DC8E8(u32 p1) +static void func_801DC8E8(u32 p1) { if (lbl_8063F330) lbl_8063F330(p1); } -//static -void func_801DC900(void) +static void func_801DC900(void) { if (lbl_8063F334) lbl_8063F334(); } -//static -void func_801DC918(s32 p1, DVDCommandBlock*) +static s32 lbl_8063D6F4 = -1; +static void func_801DC918(s32 p1, DVDCommandBlock*) { lbl_8063D6F4 = p1; OSSignalSemaphore(&lbl_80491830); } -//static -BOOL func_801DC928(void) +static BOOL func_801DC928(void) { BOOL enable = OSDisableInterrupts(); OSRestoreInterrupts(enable); @@ -431,8 +369,7 @@ BOOL func_801DC928(void) return lbl_8063D6F4 != 0; } -//static -void func_801DC9CC(u32 p1, u32) +static void func_801DC9CC(u32, u32) { s32 driveStatus = func_801DC7DC(); switch (lbl_8063F328) { @@ -510,12 +447,11 @@ void func_801DC9CC(u32 p1, u32) } } -// Load entire file contents into buffer u8* func_801DCBC0(const char* fileName, u32* fileSz) { if (!func_801DC380(fileName)) return NULL; - unkClass* fp = func_801DC2D0(fileName); + gUnkClass5* fp = func_801DC2D0(fileName); if (!fp) return NULL; size_t size = (func_801DC760(fp) + 0x1F) & ~0x1F; @@ -524,7 +460,7 @@ u8* func_801DCBC0(const char* fileName, u32* fileSz) u8* buf = (u8*)func_801DAD64(size); if (!buf) return NULL; - size_t bytesRead = func_801DC3FC(fp, buf, size, 0); + s32 bytesRead = func_801DC3FC(fp, buf, (s32)size, 0); if (bytesRead != size) { func_801DAEA4(buf); return NULL; @@ -539,7 +475,7 @@ void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) { if (!func_801DC380(fileName)) return NULL; - unkClass* fp = func_801DC2D0(fileName); + gUnkClass5* fp = func_801DC2D0(fileName); if (!fp) return NULL; size_t size = (func_801DC760(fp) + 0x1F) & ~0x1F; @@ -548,7 +484,7 @@ void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) u8* buf = (u8*)func_801DAC94(heap, size); if (!buf) return NULL; - size_t bytesRead = func_801DC3FC(fp, buf, size, 0); + s32 bytesRead = func_801DC3FC(fp, buf, (s32)size, 0); if (bytesRead != size) { func_801DAD48(heap, buf); return NULL; @@ -559,7 +495,7 @@ void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) return buf; } -u32 func_801DCD94(const char* fileName) +BOOL func_801DCD94(const char* fileName) { if (lbl_8063F338) return func_801DD294(lbl_8063F338, fileName, 0); -- cgit v1.2.3 From f4dbe9a90d572a904d3e0c8b6dae3b120e47ca34 Mon Sep 17 00:00:00 2001 From: Max Date: Tue, 27 Oct 2020 22:50:27 -0400 Subject: rename static objects --- src/code_801DBE90.cpp | 238 +++++++++++++++++++++++++------------------------- 1 file changed, 119 insertions(+), 119 deletions(-) (limited to 'src/code_801DBE90.cpp') diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp index 70253ac..5184c42 100644 --- a/src/code_801DBE90.cpp +++ b/src/code_801DBE90.cpp @@ -28,21 +28,21 @@ static void func_801DC918(s32 p1, DVDCommandBlock*); static BOOL func_801DC928(void); static void func_801DC9CC(u32 p1, u32); -static u8 lbl_804917F0[0x40]; -static OSSemaphore lbl_80491830; -static DVDCommandBlock lbl_80491840; -static const char* lbl_8063D6D8 = "RPBE"; -static const char* lbl_8063D6E0 = "01"; +static u8 gUnk804917F0[0x40]; +static OSSemaphore gUnk80491830; +static DVDCommandBlock gUnk80491840; +static const char* gUnk8063D6D8 = "RPBE"; +static const char* gUnk8063D6E0 = "01"; static ctorStruct gUnk8063F318(1, 4, 0); -static u8 lbl_8063F31E; -static u8 lbl_8063F31F; -static size_t lbl_8063F320; -static gUnkClass5* lbl_8063F324; -static s32 lbl_8063F328; -static u32 lbl_8063F32C; -static void (*lbl_8063F330)(u32); -static void (*lbl_8063F334)(void); -static gUnkClass4* lbl_8063F338; +static u8 gUnk8063F31E; +static u8 gUnk8063F31F; +static size_t gUnk8063F320; +static gUnkClass5* gUnk8063F324; +static s32 gUnk8063F328; +static u32 gUnk8063F32C; +static void (*gUnk8063F330)(u32); +static void (*gUnk8063F334)(void); +static gUnkClass4* gUnk8063F338; extern "C" { @@ -54,8 +54,8 @@ static void* func_801DBE90(u32 size) static void func_801DBEA0(void) { - for (size_t i = 0; i < lbl_8063F320; i++) - lbl_8063F324[i].unk0 = 0; + for (size_t i = 0; i < gUnk8063F320; i++) + gUnk8063F324[i].unk0 = 0; } static gUnkClass5 *func_801DBED0(void) @@ -63,11 +63,11 @@ static gUnkClass5 *func_801DBED0(void) BOOL enable = OSDisableInterrupts(); gUnkClass5* r31 = NULL; size_t i; - for (i = 0; i < lbl_8063F320; i++) { - if (lbl_8063F324[i].unk0 != 1) { - lbl_8063F324[i].unk0 = 1; - lbl_8063F324[i].unk1 = 0; - r31 = &lbl_8063F324[i]; + for (i = 0; i < gUnk8063F320; i++) { + if (gUnk8063F324[i].unk0 != 1) { + gUnk8063F324[i].unk0 = 1; + gUnk8063F324[i].unk1 = 0; + r31 = &gUnk8063F324[i]; break; } } @@ -84,16 +84,16 @@ static void func_801DBF60(gUnkClass5* p1) static gUnkClass5* func_801DBF98(DVDFileInfo* p1) { - for (size_t i = 0; i < lbl_8063F320; i++) { - if (lbl_8063F324[i].unk0 && &lbl_8063F324[i].unk4 == p1) - return &lbl_8063F324[i]; + for (size_t i = 0; i < gUnk8063F320; i++) { + if (gUnk8063F324[i].unk0 && &gUnk8063F324[i].unk4 == p1) + return &gUnk8063F324[i]; } return NULL; } static void func_801DBFEC(s32 p1, DVDFileInfo* p2) { - if (lbl_8063F31F == 0) { + if (gUnk8063F31F == 0) { gUnkClass5* r31 = func_801DBF98(p2); if (r31 && r31->unk4.unk40) { DCInvalidateRange(r31->unk4.unk44, r31->unk4.unk48); @@ -104,7 +104,7 @@ static void func_801DBFEC(s32 p1, DVDFileInfo* p2) static void func_801DC068(s32 p1, DVDFileInfo* p2) { - if (lbl_8063F31F == 0) { + if (gUnk8063F31F == 0) { gUnkClass5* r3 = func_801DBF98(p2); if (r3 && r3->unk4.unk40) r3->unk4.unk40(p1, r3); @@ -113,50 +113,50 @@ static void func_801DC068(s32 p1, DVDFileInfo* p2) BOOL func_801DC0C8(size_t p1, u32 p2) { - if (lbl_8063F31E == 1) + if (gUnk8063F31E == 1) return FALSE; - lbl_8063F31F = 0; - lbl_8063F338 = NULL; + gUnk8063F31F = 0; + gUnk8063F338 = NULL; NANDInit(); - if (!lbl_8063F338) - lbl_8063F338 = new gUnkClass4; - lbl_8063F320 = p1; - lbl_8063F324 = (gUnkClass5*)func_801DBE90(p1 * sizeof(gUnkClass5)); - if (!lbl_8063F324) + if (!gUnk8063F338) + gUnk8063F338 = new gUnkClass4; + gUnk8063F320 = p1; + gUnk8063F324 = (gUnkClass5*)func_801DBE90(p1 * sizeof(gUnkClass5)); + if (!gUnk8063F324) return FALSE; func_801DBEA0(); - memset(lbl_804917F0, 0, sizeof(lbl_804917F0)); + memset(gUnk804917F0, 0, sizeof(gUnk804917F0)); DVDInit(); if (p2) { switch (func_80249BC8()) { case 0: - lbl_8063D6D8 = "RPBE"; + gUnk8063D6D8 = "RPBE"; break; case 1: - lbl_8063D6D8 = "RPBE"; + gUnk8063D6D8 = "RPBE"; break; case 2: - lbl_8063D6D8 = "RPBP"; + gUnk8063D6D8 = "RPBP"; break; default: break; } DVDDiskID* diskID = DVDGetCurrentDiskID(); - diskID->gameCode[0] = lbl_8063D6D8[0]; - diskID->gameCode[1] = lbl_8063D6D8[1]; - diskID->gameCode[2] = lbl_8063D6D8[2]; - diskID->gameCode[3] = lbl_8063D6D8[3]; - diskID->makerCode[0] = lbl_8063D6E0[0]; - diskID->makerCode[1] = lbl_8063D6E0[1]; + diskID->gameCode[0] = gUnk8063D6D8[0]; + diskID->gameCode[1] = gUnk8063D6D8[1]; + diskID->gameCode[2] = gUnk8063D6D8[2]; + diskID->gameCode[3] = gUnk8063D6D8[3]; + diskID->makerCode[0] = gUnk8063D6E0[0]; + diskID->makerCode[1] = gUnk8063D6E0[1]; diskID->unk6 = 0; diskID->unk7 = 0; } DVDSetAutoFatalMessaging(FALSE); - lbl_8063F32C = func_80223FD0(1, 19, 0, &func_801DC9CC); - func_8022408C(lbl_8063F32C, "GSdvdErrorTask"); + gUnk8063F32C = func_80223FD0(1, 19, 0, &func_801DC9CC); + func_8022408C(gUnk8063F32C, "GSdvdErrorTask"); - lbl_8063F31E = 1; + gUnk8063F31E = 1; return TRUE; } @@ -166,8 +166,8 @@ static void func_801DC264(void) OSRestoreInterrupts(enable); if (enable) { while (TRUE) { - func_801DC9CC(lbl_8063F32C, 0); - if (lbl_8063F328 == 0) + func_801DC9CC(gUnk8063F32C, 0); + if (gUnk8063F328 == 0) break; if (!func_802245C4(lbl_8063F600)) break; @@ -178,26 +178,26 @@ static void func_801DC264(void) gUnkClass5* func_801DC2D0(const char* fileName) { - if (!lbl_8063F31E) + if (!gUnk8063F31E) return NULL; func_801DC264(); - gUnkClass5* r31 = func_801DBED0(); - if (!r31) + gUnkClass5* fp = func_801DBED0(); + if (!fp) return NULL; - if (lbl_8063F338 && func_801DCF74(lbl_8063F338, fileName, r31)) - return r31; - if (!DVDOpen(fileName, &r31->unk4)) { - func_801DBF60(r31); + if (gUnk8063F338 && func_801DCF74(gUnk8063F338, fileName, fp)) + return fp; + if (!DVDOpen(fileName, &fp->unk4)) { + func_801DBF60(fp); return NULL; } - return r31; + return fp; } BOOL func_801DC380(const char* fileName) { - if (!lbl_8063F31E) + if (!gUnk8063F31E) return FALSE; - if (lbl_8063F338 && func_801DCF48(lbl_8063F338, fileName)) + if (gUnk8063F338 && func_801DCF48(gUnk8063F338, fileName)) return TRUE; if (DVDConvertPathToEntrynum(fileName) == -1) return FALSE; @@ -206,7 +206,7 @@ BOOL func_801DC380(const char* fileName) s32 func_801DC3FC(gUnkClass5* p1, void* addr, s32 length, s32 offset) { - if (!lbl_8063F31E) + if (!gUnk8063F31E) return -1; func_801DC264(); if (!p1) @@ -218,39 +218,39 @@ s32 func_801DC3FC(gUnkClass5* p1, void* addr, s32 length, s32 offset) if (offset & 0x3) return -1; - if (lbl_8063F338 && p1->unk1) { - s32 r3 = func_801DD084(lbl_8063F338, p1, addr, length, offset); + if (gUnk8063F338 && p1->unk1) { + s32 r3 = func_801DD084(gUnk8063F338, p1, addr, length, offset); if (r3 > 0) return r3; } return DVDReadPrio(&p1->unk4, addr, length, offset, 2); } -BOOL func_801DC4F0(gUnkClass5* p1, void* p2, u32 p3, s32 p4, void (*p5)(s32, void*)) +BOOL func_801DC4F0(gUnkClass5* p1, void* addr, u32 len, s32 offset, void (*p5)(s32, void*)) { - if (!lbl_8063F31E) + if (!gUnk8063F31E) return FALSE; func_801DC264(); if (!p1) return FALSE; p1->unk4.unk40 = p5; - if ((u32)p2 & 0x1F) + if ((u32)addr & 0x1F) return FALSE; - if (p3 & 0x1F) + if (len & 0x1F) return FALSE; - if (p4 & 0x3) + if (offset & 0x3) return FALSE; - p1->unk4.unk44 = p2; - p1->unk4.unk48 = p3; - if (lbl_8063F338 && p1->unk1 && func_801DD220(lbl_8063F338, p1, p2, p3, p4)) + p1->unk4.unk44 = addr; + p1->unk4.unk48 = len; + if (gUnk8063F338 && p1->unk1 && func_801DD220(gUnk8063F338, p1, addr, len, offset)) return TRUE; - return DVDReadAsyncPrio(&p1->unk4, p2, (s32)p3, p4, &func_801DBFEC, 2) != 0; + return DVDReadAsyncPrio(&p1->unk4, addr, (s32)len, offset, &func_801DBFEC, 2) != 0; } s32 func_801DC5FC(gUnkClass5* p1, void* addr, s32 length, s32 offset, s32 prio) { - if (!lbl_8063F31E) + if (!gUnk8063F31E) return -1; func_801DC264(); if (!p1) @@ -269,12 +269,12 @@ s32 func_801DC5FC(gUnkClass5* p1, void* addr, s32 length, s32 offset, s32 prio) BOOL func_801DC6C4(gUnkClass5* p1) { - if (!lbl_8063F31E) + if (!gUnk8063F31E) return FALSE; func_801DC264(); if (!p1) return FALSE; - if (lbl_8063F338 && func_801DCFE4(lbl_8063F338, p1)) { + if (gUnk8063F338 && func_801DCFE4(gUnk8063F338, p1)) { func_801DBF60(p1); return TRUE; } @@ -286,24 +286,24 @@ BOOL func_801DC6C4(gUnkClass5* p1) size_t func_801DC760(gUnkClass5* p1) { size_t fileSz; - if (!lbl_8063F31E) + if (!gUnk8063F31E) return 0; func_801DC264(); if (!p1) return 0; - if (lbl_8063F338 && func_801DD03C(lbl_8063F338, p1, &fileSz)) + if (gUnk8063F338 && func_801DD03C(gUnk8063F338, p1, &fileSz)) return fileSz; return p1->unk4.unk34; } static s32 func_801DC7DC(void) { - return (!lbl_8063F31E) ? -1 : DVDGetDriveStatus(); + return (!gUnk8063F31E) ? -1 : DVDGetDriveStatus(); } BOOL func_801DC7F8(gUnkClass5* p1, s32 offset, void (*p3)(s32, void*)) { - if (!lbl_8063F31E) + if (!gUnk8063F31E) return FALSE; func_801DC264(); if (!p1) @@ -316,19 +316,19 @@ static void func_801DC888(s32 p1) { switch (p1) { case -1: - lbl_8063F328 = 9; + gUnk8063F328 = 9; break; case 5: - lbl_8063F328 = 1; + gUnk8063F328 = 1; break; case 4: - lbl_8063F328 = 3; + gUnk8063F328 = 3; break; case 6: - lbl_8063F328 = 5; + gUnk8063F328 = 5; break; case 11: - lbl_8063F328 = 7; + gUnk8063F328 = 7; break; default: break; @@ -337,21 +337,21 @@ static void func_801DC888(s32 p1) static void func_801DC8E8(u32 p1) { - if (lbl_8063F330) - lbl_8063F330(p1); + if (gUnk8063F330) + gUnk8063F330(p1); } static void func_801DC900(void) { - if (lbl_8063F334) - lbl_8063F334(); + if (gUnk8063F334) + gUnk8063F334(); } -static s32 lbl_8063D6F4 = -1; +static s32 gUnk8063D6F4 = -1; static void func_801DC918(s32 p1, DVDCommandBlock*) { - lbl_8063D6F4 = p1; - OSSignalSemaphore(&lbl_80491830); + gUnk8063D6F4 = p1; + OSSignalSemaphore(&gUnk80491830); } static BOOL func_801DC928(void) @@ -360,85 +360,85 @@ static BOOL func_801DC928(void) OSRestoreInterrupts(enable); if (!enable) return TRUE; - OSInitSemaphore(&lbl_80491830, 0); - lbl_8063D6F4 = -1; - if (!DVDCheckDiskAsync(&lbl_80491840, &func_801DC918)) - lbl_8063D6F4 = 0; - if (lbl_8063D6F4 < 0) - OSWaitSemaphore(&lbl_80491830); - return lbl_8063D6F4 != 0; + OSInitSemaphore(&gUnk80491830, 0); + gUnk8063D6F4 = -1; + if (!DVDCheckDiskAsync(&gUnk80491840, &func_801DC918)) + gUnk8063D6F4 = 0; + if (gUnk8063D6F4 < 0) + OSWaitSemaphore(&gUnk80491830); + return gUnk8063D6F4 != 0; } static void func_801DC9CC(u32, u32) { s32 driveStatus = func_801DC7DC(); - switch (lbl_8063F328) { + switch (gUnk8063F328) { case 0: func_801DC888(driveStatus); break; case 1: func_801DC8E8(1); - lbl_8063F328 = 2; + gUnk8063F328 = 2; break; case 2: if (driveStatus == 11) { func_801DC900(); func_801DC8E8(4); - lbl_8063F328 = 8; + gUnk8063F328 = 8; } else if (driveStatus != 5 && func_801DC928()) { func_801DC900(); - lbl_8063F328 = 0; + gUnk8063F328 = 0; } break; case 3: func_801DC8E8(2); - lbl_8063F328 = 4; + gUnk8063F328 = 4; break; case 4: if (driveStatus == 11) { func_801DC900(); func_801DC8E8(4); - lbl_8063F328 = 8; + gUnk8063F328 = 8; } else if (driveStatus != 4 && func_801DC928()) { func_801DC900(); - lbl_8063F328 = 0; + gUnk8063F328 = 0; } break; case 5: func_801DC8E8(3); - lbl_8063F328 = 6; + gUnk8063F328 = 6; break; case 6: if (driveStatus == 11) { func_801DC900(); func_801DC8E8(4); - lbl_8063F328 = 8; + gUnk8063F328 = 8; } else if (driveStatus != 6 && func_801DC928()) { func_801DC900(); - lbl_8063F328 = 0; + gUnk8063F328 = 0; } break; case 7: func_801DC8E8(4); - lbl_8063F328 = 8; + gUnk8063F328 = 8; break; case 8: if (driveStatus == 5) { func_801DC900(); func_801DC8E8(1); - lbl_8063F328 = 2; + gUnk8063F328 = 2; } else if (driveStatus == 4) { func_801DC900(); func_801DC8E8(2); - lbl_8063F328 = 4; + gUnk8063F328 = 4; } else if ((driveStatus != 11 && func_801DC928()) || (u32)(driveStatus-4) <= 1) { func_801DC900(); - lbl_8063F328 = 0; + gUnk8063F328 = 0; } break; case 9: func_801DC8E8(5); - lbl_8063F328 = 10; + gUnk8063F328 = 10; break; case 10: break; @@ -497,20 +497,20 @@ void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz) BOOL func_801DCD94(const char* fileName) { - if (lbl_8063F338) - return func_801DD294(lbl_8063F338, fileName, 0); + if (gUnk8063F338) + return func_801DD294(gUnk8063F338, fileName, 0); return 0; } void func_801DCDB8(void (*p1)(u32), void (*p2)(void)) { - lbl_8063F330 = p1; - lbl_8063F334 = p2; + gUnk8063F330 = p1; + gUnk8063F334 = p2; } u32 func_801DCDC4(void) { - switch (lbl_8063F328) { + switch (gUnk8063F328) { case 1: case 2: return 1; case 3: case 4: @@ -528,12 +528,12 @@ u32 func_801DCDC4(void) void func_801DCE38(void) { - lbl_8063F31F = 1; + gUnk8063F31F = 1; } u8 func_801DCE44(void) { - return lbl_8063F31F; + return gUnk8063F31F; } } //extern "C" -- cgit v1.2.3