diff --git a/config/SOUE01/splits.txt b/config/SOUE01/splits.txt index b1f0165e..bedcd3d5 100644 --- a/config/SOUE01/splits.txt +++ b/config/SOUE01/splits.txt @@ -213,6 +213,14 @@ m/m_angle.cpp: .ctors start:0x804DB8CC end:0x804DB8D0 .sbss start:0x80575C08 end:0x80575C10 +m/m_dvd.cpp: + .text start:0x802EEBA0 end:0x802F0494 + .ctors start:0x804DB8D0 end:0x804DB8D4 + .data start:0x80542870 end:0x80542968 + .sdata start:0x80573FD0 end:0x80573FF8 + .sbss start:0x80575C10 end:0x80575C38 + .bss start:0x805B85C0 end:0x805CB078 + m/m_heap.cpp: .text start:0x802F0F00 end:0x802F1660 .rodata start:0x804F0570 end:0x804F0580 diff --git a/config/SOUE01/symbols.txt b/config/SOUE01/symbols.txt index 48b7e544..1a34ef73 100644 --- a/config/SOUE01/symbols.txt +++ b/config/SOUE01/symbols.txt @@ -17718,86 +17718,86 @@ fn_802EE830 = .text:0x802EE830; // type:function size:0x58 fn_802EE890 = .text:0x802EE890; // type:function size:0x38 fn_802EE8D0 = .text:0x802EE8D0; // type:function size:0xB0 fn_802EE980 = .text:0x802EE980; // type:function size:0x214 -fn_802EEBA0 = .text:0x802EEBA0; // type:function size:0x40 -fn_802EEBE0 = .text:0x802EEBE0; // type:function size:0x40 -fn_802EEC20 = .text:0x802EEC20; // type:function size:0x40 -fn_802EEC60 = .text:0x802EEC60; // type:function size:0x40 -fn_802EECA0 = .text:0x802EECA0; // type:function size:0x40 +__dt__Q24mDvd42TUncompressInfo_cFv = .text:0x802EEBA0; // type:function size:0x40 +__dt__Q24mDvd41TUncompressInfo_cFv = .text:0x802EEBE0; // type:function size:0x40 +__dt__Q24mDvd41TUncompressInfo_cFv = .text:0x802EEC20; // type:function size:0x40 +__dt__Q24mDvd42TUncompressInfo_cFv = .text:0x802EEC60; // type:function size:0x40 +__dt__Q24mDvd41TUncompressInfo_cFv = .text:0x802EECA0; // type:function size:0x40 fn_802EECE0 = .text:0x802EECE0; // type:function size:0xC fn_802EECF0 = .text:0x802EECF0; // type:function size:0x40 -fn_802EED30 = .text:0x802EED30; // type:function size:0x3C -fn_802EED70 = .text:0x802EED70; // type:function size:0x40 -fn_802EEDB0 = .text:0x802EEDB0; // type:function size:0x38 -fn_802EEDF0 = .text:0x802EEDF0; // type:function size:0x8 -fn_802EEE00 = .text:0x802EEE00; // type:function size:0x8 -fn_802EEE10 = .text:0x802EEE10; // type:function size:0x24 -fn_802EEE40 = .text:0x802EEE40; // type:function size:0x4C -fn_802EEE90 = .text:0x802EEE90; // type:function size:0x8 -fn_802EEEA0 = .text:0x802EEEA0; // type:function size:0x88 -fn_802EEF30 = .text:0x802EEF30; // type:function size:0x158 -fn_802EF090 = .text:0x802EF090; // type:function size:0x8 -fn_802EF0A0 = .text:0x802EF0A0; // type:function size:0x30 -fn_802EF0D0 = .text:0x802EF0D0; // type:function size:0x60 -fn_802EF130 = .text:0x802EF130; // type:function size:0xC -fn_802EF140 = .text:0x802EF140; // type:function size:0x8 -fn_802EF150 = .text:0x802EF150; // type:function size:0x10 -fn_802EF160 = .text:0x802EF160; // type:function size:0x4 -fn_802EF170 = .text:0x802EF170; // type:function size:0x14 -fn_802EF190 = .text:0x802EF190; // type:function size:0x44 -fn_802EF1E0 = .text:0x802EF1E0; // type:function size:0x50 -fn_802EF230 = .text:0x802EF230; // type:function size:0x8 -fn_802EF240 = .text:0x802EF240; // type:function size:0x8 -fn_802EF250 = .text:0x802EF250; // type:function size:0x8 -fn_802EF260 = .text:0x802EF260; // type:function size:0xA8 -fn_802EF310 = .text:0x802EF310; // type:function size:0xB8 -fn_802EF3D0 = .text:0x802EF3D0; // type:function size:0x34 -fn_802EF410 = .text:0x802EF410; // type:function size:0x4C -fn_802EF460 = .text:0x802EF460; // type:function size:0x1C +findUncompressInfo__4mDvdFUc = .text:0x802EED30; // type:function size:0x3C +newUncompressObj__4mDvdFUc = .text:0x802EED70; // type:function size:0x40 +deleteUncompressObj__4mDvdFUc = .text:0x802EEDB0; // type:function size:0x38 +getOSThread__4mDvdFv = .text:0x802EEDF0; // type:function size:0x8 +getArchiveHeap__4mDvdFv = .text:0x802EEE00; // type:function size:0x8 +run__Q24mDvd10MyThread_cFP12mDvd_param_c = .text:0x802EEE10; // type:function size:0x24 +__ct__Q24mDvd10MyThread_cFiPQ23EGG4Heap = .text:0x802EEE40; // type:function size:0x4C +run__Q24mDvd10MyThread_cFv = .text:0x802EEE90; // type:function size:0x8 +create__4mDvdFiPQ23EGG4HeapPQ23EGG4HeapPQ23EGG4Heap = .text:0x802EEEA0; // type:function size:0x88 +loadToMainRAM__4mDvdFiPcPQ23EGG4HeapQ33EGG9DvdRipper15EAllocDirectionUlPUlPUlUl = .text:0x802EEF30; // type:function size:0x158 +ConvertPathToEntrynum__4mDvdFPCc = .text:0x802EF090; // type:function size:0x8 +IsExistPath__4mDvdFPCc = .text:0x802EF0A0; // type:function size:0x30 +__dt__14mDvd_command_cFv = .text:0x802EF0D0; // type:function size:0x60 +__nw__14mDvd_command_cFUl = .text:0x802EF130; // type:function size:0xC +__dl__14mDvd_command_cFPv = .text:0x802EF140; // type:function size:0x8 +doClear__14mDvd_command_cFv = .text:0x802EF150; // type:function size:0x10 +done__14mDvd_command_cFv = .text:0x802EF160; // type:function size:0x4 +waitDone__14mDvd_command_cFv = .text:0x802EF170; // type:function size:0x14 +waitUntilDone__14mDvd_command_cFv = .text:0x802EF190; // type:function size:0x44 +__ct__12mDvd_param_cFv = .text:0x802EF1E0; // type:function size:0x50 +kick__12mDvd_param_cFv = .text:0x802EF230; // type:function size:0x8 +waitForKick__12mDvd_param_cFv = .text:0x802EF240; // type:function size:0x8 +getFirstCommand__12mDvd_param_cFv = .text:0x802EF250; // type:function size:0x8 +addCommand__12mDvd_param_cFP14mDvd_command_c = .text:0x802EF260; // type:function size:0xA8 +removeCommand__12mDvd_param_cFP14mDvd_command_c = .text:0x802EF310; // type:function size:0xB8 +executeCB__12mDvd_param_cFPP14mDvd_command_c = .text:0x802EF3D0; // type:function size:0x34 +mainLoop__12mDvd_param_cFv = .text:0x802EF410; // type:function size:0x4C +__ct__14mDvd_command_cFv = .text:0x802EF460; // type:function size:0x1C fn_802EF480 = .text:0x802EF480; // type:function size:0x20 -fn_802EF4A0 = .text:0x802EF4A0; // type:function size:0x54 -fn_802EF500 = .text:0x802EF500; // type:function size:0x58 -fn_802EF560 = .text:0x802EF560; // type:function size:0x64 -fn_802EF5D0 = .text:0x802EF5D0; // type:function size:0x78 +destroy__14mDvd_command_cFPP14mDvd_command_c = .text:0x802EF4A0; // type:function size:0x54 +__dt__25mDvdCommandReadCallback_cFv = .text:0x802EF500; // type:function size:0x58 +__ct__25mDvdCommandReadCallback_cFPFPv_PvPv = .text:0x802EF560; // type:function size:0x64 +create__25mDvdCommandReadCallback_cFPFPv_PvPv = .text:0x802EF5D0; // type:function size:0x78 fn_802EF650 = .text:0x802EF650; // type:function size:0x30 -fn_802EF680 = .text:0x802EF680; // type:function size:0x54 -fn_802EF6E0 = .text:0x802EF6E0; // type:function size:0x58 -fn_802EF740 = .text:0x802EF740; // type:function size:0x74 -fn_802EF7C0 = .text:0x802EF7C0; // type:function size:0x16C -fn_802EF930 = .text:0x802EF930; // type:function size:0x8 -fn_802EF940 = .text:0x802EF940; // type:function size:0x8 -fn_802EF950 = .text:0x802EF950; // type:function size:0x80 -fn_802EF9D0 = .text:0x802EF9D0; // type:function size:0x4 -fn_802EF9E0 = .text:0x802EF9E0; // type:function size:0xA0 -fn_802EFA80 = .text:0x802EFA80; // type:function size:0xF8 -fn_802EFB80 = .text:0x802EFB80; // type:function size:0x18 -fn_802EFBA0 = .text:0x802EFBA0; // type:function size:0x64 -fn_802EFC10 = .text:0x802EFC10; // type:function size:0x6C -fn_802EFC80 = .text:0x802EFC80; // type:function size:0x58 -fn_802EFCE0 = .text:0x802EFCE0; // type:function size:0x58 -fn_802EFD40 = .text:0x802EFD40; // type:function size:0x60 -fn_802EFDA0 = .text:0x802EFDA0; // type:function size:0x80 -fn_802EFE20 = .text:0x802EFE20; // type:function size:0x64 +execute__25mDvdCommandReadCallback_cFv = .text:0x802EF680; // type:function size:0x54 +__dt__22mDvd_mountMemArchive_cFv = .text:0x802EF6E0; // type:function size:0x58 +__ct__22mDvd_mountMemArchive_cFi = .text:0x802EF740; // type:function size:0x74 +findPathWithCompressedExtension__FPCcPUc = .text:0x802EF7C0; // type:function size:0x16C +setAutoStreamDecomp__Fb = .text:0x802EF930; // type:function size:0x8 +getAutoStreamDecomp__Fv = .text:0x802EF940; // type:function size:0x8 +ConvertPathToEntrynum__FPCcPUc = .text:0x802EF950; // type:function size:0x80 +ConvertPathToEntrynum_Thunk__FPCcPUc = .text:0x802EF9D0; // type:function size:0x4 +create__22mDvd_mountMemArchive_cFPCcUcPQ23EGG4Heap = .text:0x802EF9E0; // type:function size:0xA0 +execute__22mDvd_mountMemArchive_cFv = .text:0x802EFA80; // type:function size:0xF8 +getArcBinary__22mDvd_mountMemArchive_cFv = .text:0x802EFB80; // type:function size:0x18 +onComplete__22mDvd_mountMemArchive_cFv = .text:0x802EFBA0; // type:function size:0x64 +__ct__21mDvd_toMainRam_base_cFi = .text:0x802EFC10; // type:function size:0x6C +__dt__21mDvd_toMainRam_base_cFv = .text:0x802EFC80; // type:function size:0x58 +__dt__20mDvd_toMainRam_arc_cFv = .text:0x802EFCE0; // type:function size:0x58 +__ct__20mDvd_toMainRam_arc_cFPQ23EGG7Archiveii = .text:0x802EFD40; // type:function size:0x60 +makeRequest__20mDvd_toMainRam_arc_cFPQ23EGG7ArchiveiiPQ23EGG4Heap = .text:0x802EFDA0; // type:function size:0x80 +create__FPQ23EGG7ArchivePCciPQ23EGG4Heap = .text:0x802EFE20; // type:function size:0x64 fn_802EFE90 = .text:0x802EFE90; // type:function size:0x30 -fn_802EFEC0 = .text:0x802EFEC0; // type:function size:0x78 -fn_802EFF40 = .text:0x802EFF40; // type:function size:0x4C -fn_802EFF90 = .text:0x802EFF90; // type:function size:0x9C +execute__20mDvd_toMainRam_arc_cFv = .text:0x802EFEC0; // type:function size:0x78 +__ct__23mDvd_toMainRam_normal_cFi = .text:0x802EFF40; // type:function size:0x4C +create__23mDvd_toMainRam_normal_cFPCciPQ23EGG4Heap = .text:0x802EFF90; // type:function size:0x9C fn_802F0030 = .text:0x802F0030; // type:function size:0x30 -fn_802F0060 = .text:0x802F0060; // type:function size:0x48 -fn_802F00B0 = .text:0x802F00B0; // type:function size:0x58 -fn_802F0110 = .text:0x802F0110; // type:function size:0xA0 -fn_802F01B0 = .text:0x802F01B0; // type:function size:0x18 -fn_802F01D0 = .text:0x802F01D0; // type:function size:0x58 -fn_802F0230 = .text:0x802F0230; // type:function size:0xE0 -fn_802F0310 = .text:0x802F0310; // type:function size:0x3C -fn_802F0350 = .text:0x802F0350; // type:function size:0x4 -fn_802F0360 = .text:0x802F0360; // type:function size:0x40 -fn_802F03A0 = .text:0x802F03A0; // type:function size:0x4 -fn_802F03B0 = .text:0x802F03B0; // type:function size:0x3C -fn_802F03F0 = .text:0x802F03F0; // type:function size:0x4 -fn_802F0400 = .text:0x802F0400; // type:function size:0x3C -fn_802F0440 = .text:0x802F0440; // type:function size:0x4 -fn_802F0450 = .text:0x802F0450; // type:function size:0x3C -fn_802F0490 = .text:0x802F0490; // type:function size:0x4 +create2__23mDvd_toMainRam_normal_cFPP23mDvd_toMainRam_normal_cPCciPQ23EGG4Heap = .text:0x802F0060; // type:function size:0x48 +__dt__23mDvd_toMainRam_normal_cFv = .text:0x802F00B0; // type:function size:0x58 +execute__23mDvd_toMainRam_normal_cFv = .text:0x802F0110; // type:function size:0xA0 +onComplete__23mDvd_toMainRam_normal_cFv = .text:0x802F01B0; // type:function size:0x18 +__dt__Q24mDvd10MyThread_cFv = .text:0x802F01D0; // type:function size:0x58 +__sinit_\m_dvd_cpp = .text:0x802F0230; // type:function size:0xE0 +Construct__Q24mDvd41TUncompressInfo_cCFv = .text:0x802F0310; // type:function size:0x3C +Destruct__Q24mDvd41TUncompressInfo_cCFv = .text:0x802F0350; // type:function size:0x4 +Construct__Q24mDvd42TUncompressInfo_cCFv = .text:0x802F0360; // type:function size:0x40 +Destruct__Q24mDvd42TUncompressInfo_cCFv = .text:0x802F03A0; // type:function size:0x4 +Construct__Q24mDvd41TUncompressInfo_cCFv = .text:0x802F03B0; // type:function size:0x3C +Destruct__Q24mDvd41TUncompressInfo_cCFv = .text:0x802F03F0; // type:function size:0x4 +Construct__Q24mDvd41TUncompressInfo_cCFv = .text:0x802F0400; // type:function size:0x3C +Destruct__Q24mDvd41TUncompressInfo_cCFv = .text:0x802F0440; // type:function size:0x4 +Construct__Q24mDvd42TUncompressInfo_cCFv = .text:0x802F0450; // type:function size:0x3C +Destruct__Q24mDvd42TUncompressInfo_cCFv = .text:0x802F0490; // type:function size:0x4 fn_802F04A0 = .text:0x802F04A0; // type:function size:0x48 fn_802F04F0 = .text:0x802F04F0; // type:function size:0x12C fn_802F0620 = .text:0x802F0620; // type:function size:0x9C @@ -22049,7 +22049,7 @@ fn_803ACF10 = .text:0x803ACF10; // type:function size:0xE4 OSCancelThread = .text:0x803AD000; // type:function size:0x1D4 scope:global fn_803AD1E0 = .text:0x803AD1E0; // type:function size:0x144 OSDetachThread = .text:0x803AD330; // type:function size:0xA0 -fn_803AD3D0 = .text:0x803AD3D0; // type:function size:0x29C +OSResumeThread = .text:0x803AD3D0; // type:function size:0x29C fn_803AD670 = .text:0x803AD670; // type:function size:0x18C OSSleepThread = .text:0x803AD800; // type:function size:0xF0 scope:global OSWakeupThread = .text:0x803AD8F0; // type:function size:0xF8 @@ -26137,7 +26137,7 @@ unmount__Q23EGG7ArchiveFv = .text:0x80493B80; // type:function size:0x94 getFile__Q23EGG7ArchiveFPCcPQ33EGG7Archive8FileInfo = .text:0x80493C20; // type:function size:0xC4 convertPathToEntryID__Q23EGG7ArchiveFPCc = .text:0x80493CF0; // type:function size:0x8 getFileFast__Q23EGG7ArchiveFlPQ33EGG7Archive8FileInfo = .text:0x80493D00; // type:function size:0xB8 -loadFromDiscFast__EGG__Archive = .text:0x80493DC0; // type:function size:0x148 +getFileFast__Q23EGG7ArchiveFlPQ23EGG4Heapl = .text:0x80493DC0; // type:function size:0x148 countFileCallbackFunc__3EGGFPvPvUlPC11ARCDirEntryPCc = .text:0x80493F10; // type:function size:0x18 countFile__Q23EGG7ArchiveFv = .text:0x80493F30; // type:function size:0x38 searchInsideWithPath__3EGGFPQ23EGG7ArchiveP9ARCHandlePFPvPvUlPC11ARCDirEntryPCc_vPvPcUl = .text:0x80493F70; // type:function size:0x144 @@ -35717,18 +35717,18 @@ lbl_805427F0 = .data:0x805427F0; // type:object size:0x30 lbl_80542820 = .data:0x80542820; // type:object size:0x14 lbl_80542834 = .data:0x80542834; // type:object size:0x14 lbl_80542848 = .data:0x80542848; // type:object size:0x28 -lbl_80542870 = .data:0x80542870; // type:object size:0x18 -lbl_80542888 = .data:0x80542888; // type:object size:0x14 -lbl_8054289C = .data:0x8054289C; // type:object size:0x14 -lbl_805428B0 = .data:0x805428B0; // type:object size:0x14 -lbl_805428C4 = .data:0x805428C4; // type:object size:0x14 -lbl_805428D8 = .data:0x805428D8; // type:object size:0x14 -lbl_805428EC = .data:0x805428EC; // type:object size:0x14 -lbl_80542900 = .data:0x80542900; // type:object size:0x14 -lbl_80542914 = .data:0x80542914; // type:object size:0x14 -lbl_80542928 = .data:0x80542928; // type:object size:0x14 -lbl_8054293C = .data:0x8054293C; // type:object size:0x14 -lbl_80542950 = .data:0x80542950; // type:object size:0x18 +__vt__Q24mDvd10MyThread_c = .data:0x80542870; // type:object size:0x18 +__vt__23mDvd_toMainRam_normal_c = .data:0x80542888; // type:object size:0x14 +__vt__20mDvd_toMainRam_arc_c = .data:0x8054289C; // type:object size:0x14 +__vt__21mDvd_toMainRam_base_c = .data:0x805428B0; // type:object size:0x14 +__vt__22mDvd_mountMemArchive_c = .data:0x805428C4; // type:object size:0x14 +__vt__25mDvdCommandReadCallback_c = .data:0x805428D8; // type:object size:0x14 +__vt__14mDvd_command_c = .data:0x805428EC; // type:object size:0x14 +__vt__Q24mDvd41TUncompressInfo_c = .data:0x80542900; // type:object size:0x14 +__vt__Q24mDvd42TUncompressInfo_c = .data:0x80542914; // type:object size:0x14 +__vt__Q24mDvd41TUncompressInfo_c = .data:0x80542928; // type:object size:0x14 +__vt__Q24mDvd41TUncompressInfo_c = .data:0x8054293C; // type:object size:0x14 +__vt__Q24mDvd42TUncompressInfo_c = .data:0x80542950; // type:object size:0x18 lbl_80542968 = .data:0x80542968; // type:object size:0x28 lbl_80542990 = .data:0x80542990; // type:object size:0x29 lbl_805429BC = .data:0x805429BC; // type:object size:0x29 @@ -37092,11 +37092,11 @@ lbl_8056E7F8 = .data:0x8056E7F8; // type:object size:0x14 lbl_8056E80C = .data:0x8056E80C; // type:object size:0x14 lbl_8056E820 = .data:0x8056E820; // type:object size:0x10 lbl_8056E830 = .data:0x8056E830; // type:object size:0x28 -lbl_8056E858 = .data:0x8056E858; // type:object size:0x18 -lbl_8056E870 = .data:0x8056E870; // type:object size:0x18 -lbl_8056E888 = .data:0x8056E888; // type:object size:0x18 -lbl_8056E8A0 = .data:0x8056E8A0; // type:object size:0x18 -lbl_8056E8B8 = .data:0x8056E8B8; // type:object size:0x18 +__vt__Q23EGG15StreamDecompSZS = .data:0x8056E858; // type:object size:0x18 +__vt__Q23EGG15StreamDecompLRC = .data:0x8056E870; // type:object size:0x18 +__vt__Q23EGG14StreamDecompLH = .data:0x8056E888; // type:object size:0x18 +__vt__Q23EGG14StreamDecompRL = .data:0x8056E8A0; // type:object size:0x18 +__vt__Q23EGG14StreamDecompLZ = .data:0x8056E8B8; // type:object size:0x18 __vt__Q23EGG9Allocator = .data:0x8056E8D0; // type:object size:0x14 lbl_8056E8E8 = .data:0x8056E8E8; // type:object size:0x68 __vt__Q23EGG4Heap = .data:0x8056E950; // type:object size:0x30 @@ -40260,17 +40260,17 @@ lbl_80575BF8 = .sbss:0x80575BF8; // type:object size:0x4 data:4byte lbl_80575BFC = .sbss:0x80575BFC; // type:object size:0x1 data:byte lbl_80575C00 = .sbss:0x80575C00; // type:object size:0x8 data:4byte Zero__7mAng3_c = .sbss:0x80575C08; // type:object size:0x6 data:2byte -lbl_80575C10 = .sbss:0x80575C10; // type:object size:0x4 data:4byte -lbl_80575C14 = .sbss:0x80575C14; // type:object size:0x4 data:4byte -lbl_80575C18 = .sbss:0x80575C18; // type:object size:0x4 data:4byte -lbl_80575C1C = .sbss:0x80575C1C; // type:object size:0x4 data:4byte -lbl_80575C20 = .sbss:0x80575C20; // type:object size:0x4 data:4byte -lbl_80575C24 = .sbss:0x80575C24; // type:object size:0x4 data:4byte -lbl_80575C28 = .sbss:0x80575C28; // type:object size:0x4 data:4byte -lbl_80575C2C = .sbss:0x80575C2C; // type:object size:0x4 data:4byte -lbl_80575C30 = .sbss:0x80575C30; // type:object size:0x1 data:byte -lbl_80575C31 = .sbss:0x80575C31; // type:object size:0x1 data:byte -lbl_80575C34 = .sbss:0x80575C34; // type:object size:0x4 data:4byte +somePtr__4mDvd = .sbss:0x80575C10; // type:object size:0x4 data:4byte +someNumber__4mDvd = .sbss:0x80575C14; // type:object size:0x4 data:4byte +compressors_ptr__4mDvd = .sbss:0x80575C18; // type:object size:0x4 data:4byte +compressors_last__4mDvd = .sbss:0x80575C1C; // type:object size:0x4 data:4byte +sOsThread__4mDvd = .sbss:0x80575C20; // type:object size:0x4 data:4byte +sThread__4mDvd = .sbss:0x80575C24; // type:object size:0x4 data:4byte +sCommandHeap__4mDvd = .sbss:0x80575C28; // type:object size:0x4 data:4byte +sArchiveHeap__4mDvd = .sbss:0x80575C2C; // type:object size:0x4 data:4byte +isAutoStreamDecomp__4mDvd = .sbss:0x80575C30; // type:object size:0x1 data:byte +isRegistered__4mDvd = .sbss:0x80575C31; // type:object size:0x1 data:byte +mInstance__12mDvd_param_c = .sbss:0x80575C34; // type:object size:0x4 data:4byte s_SavedCurrentHeap__5mHeap = .sbss:0x80575C38; // type:object size:0x4 data:4byte g_archiveHeap__5mHeap = .sbss:0x80575C3C; // type:object size:0x4 data:4byte g_commandHeap__5mHeap = .sbss:0x80575C40; // type:object size:0x4 data:4byte @@ -49068,13 +49068,17 @@ m_searchManage__10fManager_c = .bss:0x805B8548; // type:object size:0x40 lbl_805B8588 = .bss:0x805B8588; // type:object size:0xC lbl_805B8594 = .bss:0x805B8594; // type:object size:0xC lbl_805B85A0 = .bss:0x805B85A0; // type:object size:0x20 data:4byte -lbl_805B85C0 = .bss:0x805B85C0; // type:object size:0xC data:4byte -lbl_805B85CC = .bss:0x805B85CC; // type:object size:0x6772 -lbl_805BED3E = .bss:0x805BED3E; // type:object size:0x28FA -lbl_805C1638 = .bss:0x805C1638; // type:object size:0x9930 -lbl_805CAF68 = .bss:0x805CAF68; // type:object size:0x30 -lbl_805CAF98 = .bss:0x805CAF98; // type:object size:0x10 -lbl_805CAFA8 = .bss:0x805CAFA8; // type:object size:0xD0 +DECOMP_SZS__4mDvd = .bss:0x805B85C0; // type:object size:0xC data:4byte +DECOMP_LZ__4mDvd = .bss:0x805B85CC; // type:object size:0xC data:4byte +DECOMP_LH__4mDvd = .bss:0x805B85D8; // type:object size:0xC data:4byte +DECOMP_LRC__4mDvd = .bss:0x805B85E4; // type:object size:0xC data:4byte +DECOMP_RL__4mDvd = .bss:0x805B85F0; // type:object size:0xC data:4byte +likely_align__4mDvd = .bss:0x805B85FC; // type:object size:0x7A04 +more_empty_space__4mDvd = .bss:0x805C0000; // type:object size:0x1638 +decompressor_alloc_space__4mDvd = .bss:0x805C1638; // type:object size:0x9930 +DVD_MANAGER__4mDvd = .bss:0x805CAF68; // type:object size:0x30 +lbl_805CAF98 = .bss:0x805CAF98; // type:object size:0xC +@LOCAL@loadToMainRAM__4mDvdFUiPcPQ23EGG4HeapUiUiPUiPUiUi@DvdFile = .bss:0x805CAFA8; // type:object size:0xD0 g_gameHeaps__5mHeap = .bss:0x805CB078; // type:object size:0x10 data:4byte lbl_805CB088 = .bss:0x805CB088; // type:object size:0x30 data:4byte lbl_805CB0B8 = .bss:0x805CB0B8; // type:object size:0x10 data:4byte diff --git a/configure.py b/configure.py index 8b572602..30824191 100644 --- a/configure.py +++ b/configure.py @@ -301,6 +301,7 @@ config.libs = [ Object(Matching, "f/f_list.cpp"), Object(Matching, "f/f_manager.cpp"), Object(Matching, "m/m_angle.cpp"), + Object(NonMatching, "m/m_dvd.cpp"), Object(Matching, "m/m_heap.cpp"), Object(NonMatching, "m/m_mtx.cpp"), # framework (f_name) diff --git a/include/egg/core/eggDecomp.h b/include/egg/core/eggDecomp.h index 46b8f11f..83248930 100644 --- a/include/egg/core/eggDecomp.h +++ b/include/egg/core/eggDecomp.h @@ -70,7 +70,7 @@ public: private: // NON-OFFICIAL struct SZSCompContext { - u8 _[0x18]; + u8 _[0x14]; /* 80494e00 */ static u32 getUncompressedSize(const void *src); /* 80494e30 */ void init(u32 maxCompSize); /* 80494e60 */ static int readSzsHeader(/* unk params*/); diff --git a/include/egg/core/eggDvdFile.h b/include/egg/core/eggDvdFile.h index 8d7c13da..a9e9ef2b 100644 --- a/include/egg/core/eggDvdFile.h +++ b/include/egg/core/eggDvdFile.h @@ -32,8 +32,8 @@ public: /* vt 0x0C | 80494450 */ virtual bool open(const char *path); /* vt 0x10 | 804944b0 */ virtual void close(); /* vt 0x14 | 80494510 */ virtual s32 readData(void *buffer, s32 length, s32 offset); - /* vt 0x18 | 804945e0 */ virtual s32 writeData(void *buffer, s32 length, s32 offset); - /* vt 0x1C | 80494670 */ virtual u32 getFileSize(); + /* vt 0x18 | 804945e0 */ virtual s32 writeData(const void *buffer, s32 length, s32 offset); + /* vt 0x1C | 80494670 */ virtual u32 getFileSize() const; /* vt 0x20 | 804943d0 */ virtual bool open(s32 entryNum); /* vt 0x24 | 804944a0 */ virtual bool open(const char *path, void *); diff --git a/include/m/m_dvd.h b/include/m/m_dvd.h new file mode 100644 index 00000000..1493e9d7 --- /dev/null +++ b/include/m/m_dvd.h @@ -0,0 +1,190 @@ +#ifndef M_DVD_H +#define M_DVD_H + +#include +#include +#include + +// TODO these are scattered +int findPathWithCompressedExtension(const char *name, u8 *outType); +int ConvertPathToEntrynum(const char *path, u8 *outType); + +// TODO onComplete -> doClear? + +namespace mDvd { + +extern void *somePtr; + +class TUncompressInfo_Base_c { +public: + TUncompressInfo_Base_c(u8 type, const char *extension) : mType(type), mExtension(extension) {} + virtual ~TUncompressInfo_Base_c() {} + virtual EGG::StreamDecomp *Construct() const { + return nullptr; + } + virtual void Destruct() const {} + + u8 mType; + const char *mExtension; +}; + +template +class TUncompressInfo_c : public TUncompressInfo_Base_c { +public: + TUncompressInfo_c(u8 type, const char *extension) : TUncompressInfo_Base_c(type, extension) {} + virtual T *Construct() const { + return new (somePtr) T(); + } + virtual void Destruct() const {} +}; + +class MyThread_c; + +TUncompressInfo_Base_c *findUncompressInfo(u8 type); + +void create(int priority, EGG::Heap *commandHeap, EGG::Heap *archiveHeap, EGG::Heap *threadHeap); +void *loadToMainRAM(u32 entryNum, char *dst, EGG::Heap *heap, EGG::DvdRipper::EAllocDirection allocDir, u32 offset, u32 *p6, u32 *p7, + u32 decompressorType); + +u32 IsExistPath(const char *path); + +OSThread *getOSThread(); +EGG::Heap *getArchiveHeap(); +} // namespace mDvd + +class mDvd_command_c { +public: + mDvd_command_c(); + virtual ~mDvd_command_c(); + + virtual u32 execute() = 0; + virtual void onComplete(); + + void doClear(); + void done(); + void waitDone(); + void waitUntilDone(); + static void destroy(mDvd_command_c **cmd); + + void *operator new(size_t size); + void operator delete(void *ptr); + + mDvd_command_c *mNext; + u8 mStatus; + u8 mMountDirection; + u8 mCompressionType; +}; + +typedef void *(*dvdReadCallback)(void *); + +class mDvdCommandReadCallback_c : public mDvd_command_c { +public: + mDvdCommandReadCallback_c(dvdReadCallback cb, void *cbData); + virtual ~mDvdCommandReadCallback_c(); + virtual u32 execute() override; + + static mDvdCommandReadCallback_c *create(dvdReadCallback cb, void *cbData); + + dvdReadCallback mCallback; + void *mCallbackData; + void *mDataPtr; +}; + +class mDvd_mountMemArchive_c : public mDvd_command_c { +public: + mDvd_mountMemArchive_c(int mountDirection); + virtual ~mDvd_mountMemArchive_c(); + virtual u32 execute(); + virtual void onComplete(); + + static mDvd_mountMemArchive_c *create(const char *path, u8 mountDirection, EGG::Heap *heap); + void *getArcBinary(); + + int mEntryNum; + EGG::Archive *mDataPtr; + EGG::Heap *mHeap; + u32 field_0x18; +}; + +class mDvd_toMainRam_base_c : public mDvd_command_c { +public: + mDvd_toMainRam_base_c(int mountDirection); + virtual ~mDvd_toMainRam_base_c(); + virtual u32 execute() = 0; + + void *mDataPtr; + int field_0x10; + u32 field_0x14; + EGG::Heap *mHeap; +}; + +class mDvd_toMainRam_arc_c : public mDvd_toMainRam_base_c { +public: + mDvd_toMainRam_arc_c(EGG::Archive *arc, int entryNum, int mountDirection); + virtual ~mDvd_toMainRam_arc_c(); + virtual u32 execute(); + + static mDvd_toMainRam_arc_c *makeRequest(EGG::Archive *arc, int entryNum, int mountDirection, EGG::Heap *heap); + static mDvd_toMainRam_arc_c *create(EGG::Archive *arc, const char *path, int mountDirection, EGG::Heap *heap); + + EGG::Archive *mArcPtr; + int mEntryNum; +}; + +class mDvd_toMainRam_normal_c : public mDvd_toMainRam_base_c { +public: + mDvd_toMainRam_normal_c(int mountDirection); + ~mDvd_toMainRam_normal_c(); + virtual u32 execute(); + virtual void onComplete(); + + static mDvd_toMainRam_normal_c *create(const char *path, int mountDirection, EGG::Heap *heap); + static void create2(mDvd_toMainRam_normal_c **cmd, const char *path, int mountDirection, EGG::Heap *heap); + + u8 mCompressionType2; + int mEntryNum; +}; + +class mDvd_param_c { +public: + mDvd_param_c(); + + OSMutex mMutex; + mDvd_command_c *mFirstRequest; + mDvd_command_c *mLastRequest; + OSThreadQueue mThreadQueue1; + OSThreadQueue mThreadQueue2; + + void kick(); + void waitForKick(); + + mDvd_command_c *getFirstCommand(); + void addCommand(mDvd_command_c *cmd); + void removeCommand(mDvd_command_c *cmd); + static u32 executeCB(mDvd_command_c **cmd); + void mainLoop(); + + static mDvd_param_c *mInstance; +}; + +namespace mDvd { + +class MyThread_c : EGG::Thread { +public: + MyThread_c(int priority, EGG::Heap *heap); + + virtual void *run() override; + + OSThread *getMyOsThread() { + return mOSThread; + } + + void setThreadHeap(EGG::Heap *heap) { + setThreadCurrentHeap(heap); + } + + static void *run(mDvd_param_c *dvd); +}; +} // namespace mDvd + +#endif diff --git a/src/m/m_dvd.cpp b/src/m/m_dvd.cpp new file mode 100644 index 00000000..ed486c44 --- /dev/null +++ b/src/m/m_dvd.cpp @@ -0,0 +1,564 @@ +#include +#include +#include +#include +#include +#include +#include + +namespace mDvd { + +TUncompressInfo_c DECOMP_SZS(3, ".szs"); +TUncompressInfo_c DECOMP_LZ(5, ".LZ"); +TUncompressInfo_c DECOMP_LH(7, ".LH"); +TUncompressInfo_c DECOMP_LRC(8, ".LRC"); +TUncompressInfo_c DECOMP_RL(4, ".RL"); + +// TODO This the space within which the actual decompressors +// are allocated. +char likely_align[0x7A04]; +char more_empty_space[0x1638]; +char decompressor_alloc_space[0x9930]; + +mDvd_param_c DVD_MANAGER; + +TUncompressInfo_Base_c *decompressorPtrs[1] = { + &DECOMP_LZ, +}; + +u8 g_mountDirection = 1; +int maxChunkSize = 0x10000; + +void *somePtr; +u32 someNumber; +TUncompressInfo_Base_c **compressors_ptr; +TUncompressInfo_Base_c **compressors_last; +OSThread *sOsThread; +mDvd::MyThread_c *sThread; +EGG::Heap *sCommandHeap; +EGG::Heap *sArchiveHeap; +bool isAutoStreamDecomp; +bool isRegistered; + +/** 802eece0 */ +extern "C" void fn_802EECE0(TUncompressInfo_Base_c **ptr, TUncompressInfo_Base_c **last) { + compressors_ptr = ptr; + compressors_last = last; +} + +/** 802eecf0 */ +extern "C" void fn_802EECF0() { + fn_802EECE0(decompressorPtrs, &decompressorPtrs[1]); + somePtr = decompressor_alloc_space; + someNumber = 0x24; +} + +/** 802eed30 */ +TUncompressInfo_Base_c *findUncompressInfo(u8 type) { + TUncompressInfo_Base_c **ptr = compressors_ptr; + while (ptr != compressors_last) { + if ((*ptr)->mType == type) { + return *ptr; + } + ptr++; + } + return nullptr; +} + +/** 802eed70 */ +EGG::StreamDecomp *newUncompressObj(u8 type) { + TUncompressInfo_Base_c *factory = findUncompressInfo(type); + if (factory != nullptr) { + return factory->Construct(); + } else { + return nullptr; + } +} + +/** 802eedb0 */ +void deleteUncompressObj(u8 type) { + TUncompressInfo_Base_c *factory = findUncompressInfo(type); + if (factory != nullptr) { + factory->Destruct(); + } +} + +OSThread *getOSThread() { + return sOsThread; +} + +EGG::Heap *getArchiveHeap() { + return sArchiveHeap; +} + +/** 802eee10 */ +void *MyThread_c::run(mDvd_param_c *dvd) { + dvd->mainLoop(); + return nullptr; +} + +/** 802eee40 */ +MyThread_c::MyThread_c(int priority, EGG::Heap *heap) : EGG::Thread(0x4000, 0, priority, heap) {} + +/** 802eee90 */ +void *MyThread_c::run() { + return run(mDvd_param_c::mInstance); +} + +/** 802eeea0 */ +void create(int priority, EGG::Heap *commandHeap, EGG::Heap *archiveHeap, EGG::Heap *threadHeap) { + sCommandHeap = commandHeap; + sArchiveHeap = archiveHeap; + mDvd::MyThread_c *thread = new (threadHeap, 0x04) mDvd::MyThread_c(priority, threadHeap); + sThread = thread; + sOsThread = thread->getMyOsThread(); + if (mHeap::g_assertHeap != nullptr) { + thread->setThreadHeap((EGG::Heap *)mHeap::g_assertHeap); + } + OSResumeThread(sThread->getMyOsThread()); +} + +/** 802eef30 */ +void *loadToMainRAM(int entryNum, char *dst, EGG::Heap *heap, EGG::DvdRipper::EAllocDirection allocDir, u32 offset, + u32 *p6, u32 *p7, u32 decompressorType) { + // TODO + + if (decompressorType == 0) { + } else { + extern EGG::DvdFile DvdFile; + if (mDvd::isRegistered == false) { + static EGG::DvdFile DvdFile; + + isRegistered = true; + } + } +} + +int ConvertPathToEntrynum(const char *path) { + return ::ConvertPathToEntrynum(path, nullptr); +} + +u32 IsExistPath(const char *path) { + u32 entry = ConvertPathToEntrynum(path); + // TODO fake match + return (((-entry - 1) | (entry + 1)) >> 0x1f); +} + +} // namespace mDvd + +mDvd_param_c *mDvd_param_c::mInstance; + +/** 802ef0d0 */ +mDvd_command_c::~mDvd_command_c() { + waitDone(); +} + +/** 802ef130 */ +void *mDvd_command_c::operator new(size_t size) { + return EGG::Heap::alloc(size, -4, mDvd::sCommandHeap); +} + +void mDvd_command_c::operator delete(void *ptr) { + EGG::Heap::free(ptr, mDvd::sCommandHeap); +} + +/** 802ef150 */ +void mDvd_command_c::doClear() { + onComplete(); +} + +/** 802ef170 */ +void mDvd_command_c::done() {} + +void mDvd_command_c::waitDone() { + mStatus = 1; + OSWakeupThread(&mDvd_param_c::mInstance->mThreadQueue2); +} + +/** 802ef190 */ +void mDvd_command_c::waitUntilDone() { + while (mStatus == 0) { + OSSleepThread(&mDvd_param_c::mInstance->mThreadQueue2); + } +} + +/** 802ef1e0 */ +mDvd_param_c::mDvd_param_c() { + mFirstRequest = nullptr; + mLastRequest = nullptr; + OSInitMutex(&mMutex); + OSInitThreadQueue(&mThreadQueue1); + OSInitThreadQueue(&mThreadQueue2); + mDvd_param_c::mInstance = this; +} + +/** 802ef230 */ +void mDvd_param_c::kick() { + OSWakeupThread(&mThreadQueue1); +} + +/** 802ef240 */ +void mDvd_param_c::waitForKick() { + OSSleepThread(&mThreadQueue1); +} + +/** 802ef250 */ +mDvd_command_c *mDvd_param_c::getFirstCommand() { + return mFirstRequest; +} + +/** 802ef260 */ +void mDvd_param_c::addCommand(mDvd_command_c *cmd) { + OSThread *dvdThread = mDvd::getOSThread(); + OSThread *currThread = OSGetCurrentThread(); + if (currThread == dvdThread) { + cmd->execute(); + } else { + OSLockMutex(&mMutex); + cmd->mNext = nullptr; + if (mLastRequest == nullptr) { + mLastRequest = cmd; + mFirstRequest = cmd; + } else { + mLastRequest->mNext = cmd; + mLastRequest = cmd; + } + OSUnlockMutex(&mMutex); + kick(); + } +} + +/** 802ef310 */ +void mDvd_param_c::removeCommand(mDvd_command_c *toRemove) { + OSLockMutex(&mMutex); + mDvd_command_c *prev = nullptr; + + for (mDvd_command_c *cmd = mFirstRequest; cmd != nullptr; cmd = cmd->mNext) { + if (cmd == toRemove) { + if (prev != nullptr) { + prev->mNext = cmd->mNext; + if (mLastRequest == cmd) { + mLastRequest = prev; + } + } else { + if (mFirstRequest == mLastRequest) { + mFirstRequest = nullptr; + mLastRequest = nullptr; + } else { + mFirstRequest = cmd->mNext; + } + } + } + + prev = cmd; + } + + OSUnlockMutex(&mMutex); + kick(); +} + +u32 mDvd_param_c::executeCB(mDvd_command_c **cmd) { + (*cmd)->execute(); + return 0; +} + +/** 802ef410 */ +void mDvd_param_c::mainLoop() { + mDvd_command_c *cmd; + while (true) { + waitForKick(); + while ((cmd = getFirstCommand()) != nullptr) { + removeCommand(cmd); + executeCB(&cmd); + } + } +} + +/** 802ef460 */ +mDvd_command_c::mDvd_command_c() { + mNext = nullptr; + mStatus = 0; +} + +/** 802ef480 */ +extern "C" void fn_802EF480(mDvd_command_c *cmd) { + delete cmd; +} + +/** 802ef4a0 */ +void mDvd_command_c::destroy(mDvd_command_c **cmd) { + if (cmd != nullptr && *cmd != nullptr) { + (*cmd)->doClear(); + // TODO + delete *cmd; + *cmd = nullptr; + } +} + +/** 802ef500 */ +mDvdCommandReadCallback_c::~mDvdCommandReadCallback_c() {} + +/** 802ef560 */ +mDvdCommandReadCallback_c::mDvdCommandReadCallback_c(dvdReadCallback cb, void *cbData) { + mCallback = cb; + mCallbackData = cbData; + mDataPtr = nullptr; +} + +/* 802ef5d0 */ +mDvdCommandReadCallback_c *mDvdCommandReadCallback_c::create(dvdReadCallback cb, void *cbData) { + // TODO instshuffle + mDvdCommandReadCallback_c *cmd = new mDvdCommandReadCallback_c(cb, cbData); + if (cmd != nullptr) { + mDvd_param_c::mInstance->addCommand(cmd); + } + return cmd; +} + +/** 802ef650 */ +extern "C" void fn_802EF650() {} + +/** 802ef680 */ +u32 mDvdCommandReadCallback_c::execute() { + mDataPtr = (mCallback)(mCallbackData); + waitDone(); + return (bool)mDataPtr; +} + +/** 802ef6e0 */ +mDvd_mountMemArchive_c::~mDvd_mountMemArchive_c() {} + +/** 802ef740 */ +mDvd_mountMemArchive_c::mDvd_mountMemArchive_c(int mountDirection) { + if (mountDirection == 0) { + mountDirection = mDvd::g_mountDirection; + } + mMountDirection = mountDirection; + mCompressionType = 0; + mEntryNum = -1; + mDataPtr = nullptr; + mHeap = nullptr; + field_0x18 = 0; +} + +/** 802ef7c0 */ +int findPathWithCompressedExtension(const char *name, u8 *outType) { + return 0; // TODO +} + +/** 802ef930 */ +void setAutoStreamDecomp(bool arg) { + mDvd::isAutoStreamDecomp = arg; +} + +/** 802ef940 */ +bool getAutoStreamDecomp() { + return mDvd::isAutoStreamDecomp; +} + +// TODO maybe weak +/** 802ef950 */ +int ConvertPathToEntrynum(const char *path, u8 *outType) { + return 0; // TODO +} + +// TODO thunk +/** 802ef950 */ +int ConvertPathToEntrynum_Thunk(const char *path, u8 *outType) { + return ConvertPathToEntrynum(path, outType); +} + +/** 802ef9e0 */ +mDvd_mountMemArchive_c *mDvd_mountMemArchive_c::create(const char *path, u8 mountDirection, EGG::Heap *heap) { + u8 type; + mDvd_mountMemArchive_c *cmd = nullptr; + int entryNum = ConvertPathToEntrynum_Thunk(path, &type); + if (entryNum != -1) { + cmd = new mDvd_mountMemArchive_c(mountDirection); + if (cmd != nullptr) { + cmd->mEntryNum = entryNum; + cmd->mHeap = heap; + cmd->mCompressionType = type; + mDvd_param_c::mInstance->addCommand(cmd); + } + } + + return cmd; +} + +/** 802efa80 */ +u32 mDvd_mountMemArchive_c::execute() { + void *data; + int align; + EGG::DvdRipper::EAllocDirection allocDirection; + EGG::Archive *archive; + EGG::Heap *heap; + + heap = mHeap != nullptr ? mHeap : mDvd::sArchiveHeap; + archive = nullptr; + + allocDirection = mMountDirection == 1 ? EGG::DvdRipper::ALLOC_DIR_TOP : EGG::DvdRipper::ALLOC_DIR_BOTTOM; + data = mDvd::loadToMainRAM(mEntryNum, nullptr, heap, allocDirection, 0, (u32 *)field_0x18, 0, mCompressionType); + if (data != nullptr) { + align = -4; + if (mMountDirection == 1) { + align = 4; + } + archive = EGG::Archive::mount(data, heap, align); + } + + if (archive == nullptr) { + if (data != nullptr) { + delete data; + } + field_0x18 = 0; + } else { + mDataPtr = archive; + } + waitDone(); + return (bool)mDataPtr; +} + +/** 802efb80 */ +void *mDvd_mountMemArchive_c::getArcBinary() { + void *result = nullptr; + if (mDataPtr != nullptr) { + result = mDataPtr->mHandle.header; + } + return result; +} + +/** 802efba0 */ +void mDvd_mountMemArchive_c::onComplete() { + if (mDataPtr != nullptr) { + void *data = mDataPtr->mHandle.header; + mDataPtr->unmount(); + mDataPtr = nullptr; + if (data != nullptr) { + EGG::Heap::free(data, nullptr); + } + } +} + +/** 802efc10 */ +mDvd_toMainRam_base_c::mDvd_toMainRam_base_c(int mountDirection) { + if (mountDirection == 0) { + mountDirection = mDvd::g_mountDirection; + } + mMountDirection = mountDirection; + mDataPtr = nullptr; + field_0x10 = 0; + field_0x14 = 0; + mHeap = nullptr; +} + +/** 802efc80 */ +mDvd_toMainRam_base_c::~mDvd_toMainRam_base_c() {} + +/** 802efce0 */ +mDvd_toMainRam_arc_c::~mDvd_toMainRam_arc_c() {} + +/** 802efd40 */ +mDvd_toMainRam_arc_c::mDvd_toMainRam_arc_c(EGG::Archive *arc, int entryNum, int mountDirection) + : mDvd_toMainRam_base_c(mountDirection), mArcPtr(arc) { + mEntryNum = entryNum; +} + +/** 802efda0 */ +mDvd_toMainRam_arc_c *mDvd_toMainRam_arc_c::makeRequest(EGG::Archive *arc, int entryNum, int mountDirection, + EGG::Heap *heap) { + mDvd_toMainRam_arc_c *cmd = new mDvd_toMainRam_arc_c(arc, entryNum, mountDirection); + if (cmd != nullptr) { + cmd->mHeap = heap; + mDvd_param_c::mInstance->addCommand(cmd); + } + return cmd; +} + +/** 802efe20 */ +mDvd_toMainRam_arc_c *create(EGG::Archive *arc, const char *path, int mountDirection, EGG::Heap *heap) { + int entryNum = arc->convertPathToEntryID(path); + mDvd_toMainRam_arc_c *cmd = nullptr; + if (entryNum != -1) { + cmd = mDvd_toMainRam_arc_c::makeRequest(arc, entryNum, mountDirection, heap); + } + return cmd; +} + +/** 802efe90 */ +extern "C" void fn_802EFE90() { + // TODO +} + +/** 802efec0 */ +u32 mDvd_toMainRam_arc_c::execute() { + EGG::Heap *heap = mHeap != nullptr ? mHeap : mDvd::sArchiveHeap; + mDataPtr = mArcPtr->getFileFast(mEntryNum, heap, mMountDirection == 1 ? 0x20 : -0x20); + waitDone(); + return (bool)mDataPtr; +} + +/** 802eff40 */ +mDvd_toMainRam_normal_c::mDvd_toMainRam_normal_c(int mountDirection) : mDvd_toMainRam_base_c(mountDirection) { + mCompressionType2 = 0; + mEntryNum = -1; +} + +/** 802eff90 */ +mDvd_toMainRam_normal_c *mDvd_toMainRam_normal_c::create(const char *path, int mountDirection, EGG::Heap *heap) { + u8 type; + int entryNum = ConvertPathToEntrynum(path, &type); + mDvd_toMainRam_normal_c *cmd; + if (entryNum == -1) { + cmd = nullptr; + } else { + cmd = new mDvd_toMainRam_normal_c(mountDirection); + if (cmd != nullptr) { + cmd->mEntryNum = entryNum; + cmd->mHeap = heap; + cmd->mCompressionType2 = type; + mDvd_param_c::mInstance->addCommand(cmd); + } + } + return cmd; +} + +/** 802f0030 */ +extern "C" void fn_802F0030() { + // TODO +} + +/** 802f0060 */ +void mDvd_toMainRam_normal_c::create2(mDvd_toMainRam_normal_c **cmd, const char *path, int mountDirection, + EGG::Heap *heap) { + if (*cmd == nullptr) { + *cmd = mDvd_toMainRam_normal_c::create(path, mountDirection, heap); + } +} + +/** 802f00b0 */ +mDvd_toMainRam_normal_c::~mDvd_toMainRam_normal_c() {} + +/** 802f0110 */ +u32 mDvd_toMainRam_normal_c::execute() { + // TODO + u32 p6; + u32 p7; + EGG::Heap *heap = mHeap != nullptr ? mHeap : mDvd::sArchiveHeap; + EGG::DvdRipper::EAllocDirection allocDirection = mMountDirection == 1 ? EGG::DvdRipper::ALLOC_DIR_TOP : EGG::DvdRipper::ALLOC_DIR_BOTTOM; + mDataPtr = mDvd::loadToMainRAM(mEntryNum, 0, heap, allocDirection, 0, &p6, &p7, mCompressionType2); + if (mDataPtr != nullptr) { + field_0x10 = p6; + field_0x14 = p7; + } + waitDone(); + return (bool)mDataPtr; +} + +/** 802f01b0 */ +void mDvd_toMainRam_normal_c::onComplete() { + if (mDataPtr == nullptr) { + return; + } + EGG::Heap::free(mDataPtr, nullptr); +}