falso
/
tp
mirror of https://github.com/zeldaret/tp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/zeldaret/tp into d_menu_skill

This commit is contained in:
Trueffeloot 2023-07-22 16:01:41 +02:00
parent 4682deae99 21c01d5efd
commit 5be7e910cc
22 changed files with 416 additions and 1665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Progress.md
View File

@ -7,22 +7,22 @@ Section | Percentage | Decompiled (bytes) | Total (bytes)
.init | 97.972973% | 9280 | 9472
.extab | 100.000000% | 96 | 96
.extabindex | 100.000000% | 96 | 96
.text | 29.535576% | 1062260 | 3596544
.text | 29.650687% | 1066400 | 3596544
.ctors | 100.000000% | 448 | 448
.dtors | 100.000000% | 32 | 32
.rodata | 100.000000% | 193856 | 193856
.data | 100.000000% | 197632 | 197632
.sdata | 100.000000% | 1408 | 1408
.sdata2 | 100.000000% | 20832 | 20832
Total | 36.963871% | 1486196 | 4020672
Total | 37.066839% | 1490336 | 4020672
## Total
Section | Percentage | Decompiled (bytes) | Total (bytes)
---|---|---|---
main.dol | 36.963871% | 1486196 | 4020672
main.dol | 37.066839% | 1490336 | 4020672
RELs | 33.938592% | 3903048 | 11500324
Total | 34.722282% | 5389244 | 15520996
Total | 34.748956% | 5393384 | 15520996
## RELs

226
asm/JSystem/JKernel/JKRAramArchive/open__14JKRAramArchiveFl.s
View File

@ -1,226 +0,0 @@
lbl_802D72A8:
/* 802D72A8 94 21 FF D0 */ stwu r1, -0x30(r1)
/* 802D72AC 7C 08 02 A6 */ mflr r0
/* 802D72B0 90 01 00 34 */ stw r0, 0x34(r1)
/* 802D72B4 39 61 00 30 */ addi r11, r1, 0x30
/* 802D72B8 48 08 AF 1D */ bl _savegpr_27
/* 802D72BC 7C 7F 1B 78 */ mr r31, r3
/* 802D72C0 7C 9C 23 78 */ mr r28, r4
/* 802D72C4 38 00 00 00 */ li r0, 0
/* 802D72C8 90 03 00 44 */ stw r0, 0x44(r3)
/* 802D72CC 90 03 00 48 */ stw r0, 0x48(r3)
/* 802D72D0 90 03 00 4C */ stw r0, 0x4c(r3)
/* 802D72D4 90 03 00 54 */ stw r0, 0x54(r3)
/* 802D72D8 90 03 00 64 */ stw r0, 0x64(r3)
/* 802D72DC 38 60 00 F8 */ li r3, 0xf8
/* 802D72E0 80 8D 8D F0 */ lwz r4, sSystemHeap__7JKRHeap(r13)
/* 802D72E4 80 1F 00 60 */ lwz r0, 0x60(r31)
/* 802D72E8 2C 00 00 01 */ cmpwi r0, 1
/* 802D72EC 38 A0 FF FC */ li r5, -4
/* 802D72F0 40 82 00 08 */ bne lbl_802D72F8
/* 802D72F4 38 A0 00 04 */ li r5, 4
lbl_802D72F8:
/* 802D72F8 4B FF 79 A1 */ bl __nw__FUlP7JKRHeapi
/* 802D72FC 7C 60 1B 79 */ or. r0, r3, r3
/* 802D7300 41 82 00 10 */ beq lbl_802D7310
/* 802D7304 7F 84 E3 78 */ mr r4, r28
/* 802D7308 48 00 23 99 */ bl __ct__10JKRDvdFileFl
/* 802D730C 7C 60 1B 78 */ mr r0, r3
lbl_802D7310:
/* 802D7310 90 1F 00 68 */ stw r0, 0x68(r31)
/* 802D7314 80 1F 00 68 */ lwz r0, 0x68(r31)
/* 802D7318 28 00 00 00 */ cmplwi r0, 0
/* 802D731C 40 82 00 14 */ bne lbl_802D7330
/* 802D7320 38 00 00 00 */ li r0, 0
/* 802D7324 98 1F 00 3C */ stb r0, 0x3c(r31)
/* 802D7328 38 60 00 00 */ li r3, 0
/* 802D732C 48 00 02 9C */ b lbl_802D75C8
lbl_802D7330:
/* 802D7330 80 6D 8D F0 */ lwz r3, sSystemHeap__7JKRHeap(r13)
/* 802D7334 38 80 00 20 */ li r4, 0x20
/* 802D7338 38 A0 FF E0 */ li r5, -32
/* 802D733C 4B FF 71 99 */ bl alloc__7JKRHeapFUli
/* 802D7340 7C 7D 1B 79 */ or. r29, r3, r3
/* 802D7344 40 82 00 10 */ bne lbl_802D7354
/* 802D7348 38 00 00 00 */ li r0, 0
/* 802D734C 98 1F 00 3C */ stb r0, 0x3c(r31)
/* 802D7350 48 00 02 28 */ b lbl_802D7578
lbl_802D7354:
/* 802D7354 38 00 00 00 */ li r0, 0
/* 802D7358 90 01 00 08 */ stw r0, 8(r1)
/* 802D735C 7F 83 E3 78 */ mr r3, r28
/* 802D7360 7F A4 EB 78 */ mr r4, r29
/* 802D7364 38 A0 00 01 */ li r5, 1
/* 802D7368 38 C0 00 20 */ li r6, 0x20
/* 802D736C 38 E0 00 00 */ li r7, 0
/* 802D7370 39 00 00 01 */ li r8, 1
/* 802D7374 39 20 00 00 */ li r9, 0
/* 802D7378 39 5F 00 5C */ addi r10, r31, 0x5c
/* 802D737C 48 00 28 D9 */ bl loadToMainRAM__12JKRDvdRipperFlPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
/* 802D7380 7F A3 EB 78 */ mr r3, r29
/* 802D7384 38 80 00 20 */ li r4, 0x20
/* 802D7388 48 06 41 F9 */ bl DCInvalidateRange
/* 802D738C 80 1F 00 60 */ lwz r0, 0x60(r31)
/* 802D7390 2C 00 00 01 */ cmpwi r0, 1
/* 802D7394 3B C0 FF E0 */ li r30, -32
/* 802D7398 40 82 00 08 */ bne lbl_802D73A0
/* 802D739C 3B C0 00 20 */ li r30, 0x20
lbl_802D73A0:
/* 802D73A0 80 7D 00 0C */ lwz r3, 0xc(r29)
/* 802D73A4 38 03 00 1F */ addi r0, r3, 0x1f
/* 802D73A8 54 1B 00 34 */ rlwinm r27, r0, 0, 0, 0x1a
/* 802D73AC 7F 63 DB 78 */ mr r3, r27
/* 802D73B0 7F C4 F3 78 */ mr r4, r30
/* 802D73B4 80 BF 00 38 */ lwz r5, 0x38(r31)
/* 802D73B8 4B FF 70 BD */ bl alloc__7JKRHeapFUliP7JKRHeap
/* 802D73BC 90 7F 00 44 */ stw r3, 0x44(r31)
/* 802D73C0 80 9F 00 44 */ lwz r4, 0x44(r31)
/* 802D73C4 28 04 00 00 */ cmplwi r4, 0
/* 802D73C8 40 82 00 10 */ bne lbl_802D73D8
/* 802D73CC 38 00 00 00 */ li r0, 0
/* 802D73D0 98 1F 00 3C */ stb r0, 0x3c(r31)
/* 802D73D4 48 00 01 A4 */ b lbl_802D7578
lbl_802D73D8:
/* 802D73D8 38 00 00 00 */ li r0, 0
/* 802D73DC 90 01 00 08 */ stw r0, 8(r1)
/* 802D73E0 7F 83 E3 78 */ mr r3, r28
/* 802D73E4 38 A0 00 01 */ li r5, 1
/* 802D73E8 7F 66 DB 78 */ mr r6, r27
/* 802D73EC 38 E0 00 00 */ li r7, 0
/* 802D73F0 39 00 00 01 */ li r8, 1
/* 802D73F4 39 20 00 20 */ li r9, 0x20
/* 802D73F8 39 40 00 00 */ li r10, 0
/* 802D73FC 48 00 28 59 */ bl loadToMainRAM__12JKRDvdRipperFlPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
/* 802D7400 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D7404 7F 64 DB 78 */ mr r4, r27
/* 802D7408 48 06 41 79 */ bl DCInvalidateRange
/* 802D740C 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D7410 80 03 00 04 */ lwz r0, 4(r3)
/* 802D7414 7C 03 02 14 */ add r0, r3, r0
/* 802D7418 90 1F 00 48 */ stw r0, 0x48(r31)
/* 802D741C 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D7420 80 03 00 0C */ lwz r0, 0xc(r3)
/* 802D7424 7C 03 02 14 */ add r0, r3, r0
/* 802D7428 90 1F 00 4C */ stw r0, 0x4c(r31)
/* 802D742C 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D7430 80 03 00 14 */ lwz r0, 0x14(r3)
/* 802D7434 7C 03 02 14 */ add r0, r3, r0
/* 802D7438 90 1F 00 54 */ stw r0, 0x54(r31)
/* 802D743C 38 00 00 00 */ li r0, 0
/* 802D7440 90 1F 00 50 */ stw r0, 0x50(r31)
/* 802D7444 38 80 00 00 */ li r4, 0
/* 802D7448 80 BF 00 4C */ lwz r5, 0x4c(r31)
/* 802D744C 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D7450 80 03 00 08 */ lwz r0, 8(r3)
/* 802D7454 7C 09 03 A6 */ mtctr r0
/* 802D7458 28 00 00 00 */ cmplwi r0, 0
/* 802D745C 40 81 00 28 */ ble lbl_802D7484
lbl_802D7460:
/* 802D7460 80 05 00 04 */ lwz r0, 4(r5)
/* 802D7464 54 03 46 3E */ srwi r3, r0, 0x18
/* 802D7468 54 00 47 FF */ rlwinm. r0, r0, 8, 0x1f, 0x1f
/* 802D746C 41 82 00 10 */ beq lbl_802D747C
/* 802D7470 54 60 07 7A */ rlwinm r0, r3, 0, 0x1d, 0x1d
/* 802D7474 7C 80 03 78 */ or r0, r4, r0
/* 802D7478 54 04 06 3E */ clrlwi r4, r0, 0x18
lbl_802D747C:
/* 802D747C 38 A5 00 14 */ addi r5, r5, 0x14
/* 802D7480 42 00 FF E0 */ bdnz lbl_802D7460
lbl_802D7484:
/* 802D7484 54 80 06 3F */ clrlwi. r0, r4, 0x18
/* 802D7488 41 82 00 60 */ beq lbl_802D74E8
/* 802D748C 7F C3 F3 78 */ mr r3, r30
/* 802D7490 48 08 DC 41 */ bl abs
/* 802D7494 7C 64 1B 78 */ mr r4, r3
/* 802D7498 80 BF 00 38 */ lwz r5, 0x38(r31)
/* 802D749C 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D74A0 80 03 00 08 */ lwz r0, 8(r3)
/* 802D74A4 54 03 10 3A */ slwi r3, r0, 2
/* 802D74A8 4B FF 6F CD */ bl alloc__7JKRHeapFUliP7JKRHeap
/* 802D74AC 90 7F 00 50 */ stw r3, 0x50(r31)
/* 802D74B0 80 7F 00 50 */ lwz r3, 0x50(r31)
/* 802D74B4 28 03 00 00 */ cmplwi r3, 0
/* 802D74B8 40 82 00 1C */ bne lbl_802D74D4
/* 802D74BC 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D74C0 38 80 00 00 */ li r4, 0
/* 802D74C4 4B FF 70 3D */ bl free__7JKRHeapFPvP7JKRHeap
/* 802D74C8 38 00 00 00 */ li r0, 0
/* 802D74CC 98 1F 00 3C */ stb r0, 0x3c(r31)
/* 802D74D0 48 00 00 A8 */ b lbl_802D7578
lbl_802D74D4:
/* 802D74D4 38 80 00 00 */ li r4, 0
/* 802D74D8 80 BF 00 44 */ lwz r5, 0x44(r31)
/* 802D74DC 80 05 00 08 */ lwz r0, 8(r5)
/* 802D74E0 54 05 10 3A */ slwi r5, r0, 2
/* 802D74E4 4B D2 BF 75 */ bl memset
lbl_802D74E8:
/* 802D74E8 80 7D 00 10 */ lwz r3, 0x10(r29)
/* 802D74EC 38 03 00 1F */ addi r0, r3, 0x1f
/* 802D74F0 54 04 00 34 */ rlwinm r4, r0, 0, 0, 0x1a
/* 802D74F4 80 6D 8E 48 */ lwz r3, sAramObject__7JKRAram(r13)
/* 802D74F8 80 63 00 94 */ lwz r3, 0x94(r3)
/* 802D74FC 80 1F 00 60 */ lwz r0, 0x60(r31)
/* 802D7500 20 A0 00 01 */ subfic r5, r0, 1
/* 802D7504 30 05 FF FF */ addic r0, r5, -1
/* 802D7508 7C A0 29 10 */ subfe r5, r0, r5
/* 802D750C 4B FF BA B1 */ bl alloc__11JKRAramHeapFUlQ211JKRAramHeap10EAllocMode
/* 802D7510 90 7F 00 64 */ stw r3, 0x64(r31)
/* 802D7514 80 7F 00 64 */ lwz r3, 0x64(r31)
/* 802D7518 28 03 00 00 */ cmplwi r3, 0
/* 802D751C 40 82 00 38 */ bne lbl_802D7554
/* 802D7520 80 7F 00 44 */ lwz r3, 0x44(r31)
/* 802D7524 28 03 00 00 */ cmplwi r3, 0
/* 802D7528 41 82 00 0C */ beq lbl_802D7534
/* 802D752C 38 80 00 00 */ li r4, 0
/* 802D7530 4B FF 6F D1 */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802D7534:
/* 802D7534 80 7F 00 50 */ lwz r3, 0x50(r31)
/* 802D7538 28 03 00 00 */ cmplwi r3, 0
/* 802D753C 41 82 00 0C */ beq lbl_802D7548
/* 802D7540 38 80 00 00 */ li r4, 0
/* 802D7544 4B FF 6F BD */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802D7548:
/* 802D7548 38 00 00 00 */ li r0, 0
/* 802D754C 98 1F 00 3C */ stb r0, 0x3c(r31)
/* 802D7550 48 00 00 28 */ b lbl_802D7578
lbl_802D7554:
/* 802D7554 80 83 00 14 */ lwz r4, 0x14(r3)
/* 802D7558 7F 83 E3 78 */ mr r3, r28
/* 802D755C 38 A0 00 01 */ li r5, 1
/* 802D7560 80 DD 00 08 */ lwz r6, 8(r29)
/* 802D7564 80 1D 00 0C */ lwz r0, 0xc(r29)
/* 802D7568 7C C6 02 14 */ add r6, r6, r0
/* 802D756C 38 E0 00 00 */ li r7, 0
/* 802D7570 39 00 00 00 */ li r8, 0
/* 802D7574 48 00 33 01 */ bl loadToAram__16JKRDvdAramRipperFlUl15JKRExpandSwitchUlUlPUl
lbl_802D7578:
/* 802D7578 28 1D 00 00 */ cmplwi r29, 0
/* 802D757C 41 82 00 10 */ beq lbl_802D758C
/* 802D7580 80 6D 8D F0 */ lwz r3, sSystemHeap__7JKRHeap(r13)
/* 802D7584 7F A4 EB 78 */ mr r4, r29
/* 802D7588 4B FF 6F C1 */ bl free__7JKRHeapFPv
lbl_802D758C:
/* 802D758C 88 1F 00 3C */ lbz r0, 0x3c(r31)
/* 802D7590 28 00 00 00 */ cmplwi r0, 0
/* 802D7594 40 82 00 30 */ bne lbl_802D75C4
/* 802D7598 80 7F 00 68 */ lwz r3, 0x68(r31)
/* 802D759C 28 03 00 00 */ cmplwi r3, 0
/* 802D75A0 41 82 00 1C */ beq lbl_802D75BC
/* 802D75A4 41 82 00 18 */ beq lbl_802D75BC
/* 802D75A8 38 80 00 01 */ li r4, 1
/* 802D75AC 81 83 00 00 */ lwz r12, 0(r3)
/* 802D75B0 81 8C 00 08 */ lwz r12, 8(r12)
/* 802D75B4 7D 89 03 A6 */ mtctr r12
/* 802D75B8 4E 80 04 21 */ bctrl
lbl_802D75BC:
/* 802D75BC 38 60 00 00 */ li r3, 0
/* 802D75C0 48 00 00 08 */ b lbl_802D75C8
lbl_802D75C4:
/* 802D75C4 38 60 00 01 */ li r3, 1
lbl_802D75C8:
/* 802D75C8 39 61 00 30 */ addi r11, r1, 0x30
/* 802D75CC 48 08 AC 55 */ bl _restgpr_27
/* 802D75D0 80 01 00 34 */ lwz r0, 0x34(r1)
/* 802D75D4 7C 08 03 A6 */ mtlr r0
/* 802D75D8 38 21 00 30 */ addi r1, r1, 0x30
/* 802D75DC 4E 80 00 20 */ blr

46
asm/JSystem/JKernel/JKRAramHeap/__dt__11JKRAramHeapFv.s
View File

@ -1,46 +0,0 @@
lbl_802D2F14:
/* 802D2F14 94 21 FF E0 */ stwu r1, -0x20(r1)
/* 802D2F18 7C 08 02 A6 */ mflr r0
/* 802D2F1C 90 01 00 24 */ stw r0, 0x24(r1)
/* 802D2F20 39 61 00 20 */ addi r11, r1, 0x20
/* 802D2F24 48 08 F2 B9 */ bl _savegpr_29
/* 802D2F28 7C 7D 1B 79 */ or. r29, r3, r3
/* 802D2F2C 7C 9E 23 78 */ mr r30, r4
/* 802D2F30 41 82 00 70 */ beq lbl_802D2FA0
/* 802D2F34 3C 60 80 3D */ lis r3, __vt__11JKRAramHeap@ha /* 0x803CC168@ha */
/* 802D2F38 38 03 C1 68 */ addi r0, r3, __vt__11JKRAramHeap@l /* 0x803CC168@l */
/* 802D2F3C 90 1D 00 00 */ stw r0, 0(r29)
/* 802D2F40 3C 60 80 43 */ lis r3, sAramList__11JKRAramHeap@ha /* 0x8043430C@ha */
/* 802D2F44 83 E3 43 0C */ lwz r31, sAramList__11JKRAramHeap@l(r3) /* 0x8043430C@l */
/* 802D2F48 48 00 00 34 */ b lbl_802D2F7C
lbl_802D2F4C:
/* 802D2F4C 93 E1 00 08 */ stw r31, 8(r1)
/* 802D2F50 83 FF 00 0C */ lwz r31, 0xc(r31)
/* 802D2F54 80 61 00 08 */ lwz r3, 8(r1)
/* 802D2F58 90 61 00 0C */ stw r3, 0xc(r1)
/* 802D2F5C 80 63 00 00 */ lwz r3, 0(r3)
/* 802D2F60 28 03 00 00 */ cmplwi r3, 0
/* 802D2F64 41 82 00 18 */ beq lbl_802D2F7C
/* 802D2F68 38 80 00 01 */ li r4, 1
/* 802D2F6C 81 83 00 00 */ lwz r12, 0(r3)
/* 802D2F70 81 8C 00 08 */ lwz r12, 8(r12)
/* 802D2F74 7D 89 03 A6 */ mtctr r12
/* 802D2F78 4E 80 04 21 */ bctrl
lbl_802D2F7C:
/* 802D2F7C 28 1F 00 00 */ cmplwi r31, 0
/* 802D2F80 40 82 FF CC */ bne lbl_802D2F4C
/* 802D2F84 7F A3 EB 78 */ mr r3, r29
/* 802D2F88 38 80 00 00 */ li r4, 0
/* 802D2F8C 4B FF E5 59 */ bl __dt__11JKRDisposerFv
/* 802D2F90 7F C0 07 35 */ extsh. r0, r30
/* 802D2F94 40 81 00 0C */ ble lbl_802D2FA0
/* 802D2F98 7F A3 EB 78 */ mr r3, r29
/* 802D2F9C 4B FF BD A1 */ bl __dl__FPv
lbl_802D2FA0:
/* 802D2FA0 7F A3 EB 78 */ mr r3, r29
/* 802D2FA4 39 61 00 20 */ addi r11, r1, 0x20
/* 802D2FA8 48 08 F2 81 */ bl _restgpr_29
/* 802D2FAC 80 01 00 24 */ lwz r0, 0x24(r1)
/* 802D2FB0 7C 08 03 A6 */ mtlr r0
/* 802D2FB4 38 21 00 20 */ addi r1, r1, 0x20
/* 802D2FB8 4E 80 00 20 */ blr

125
asm/JSystem/JKernel/JKRDecomp/decodeSZP__9JKRDecompFPUcPUcUlUl.s
View File

@ -1,125 +0,0 @@
lbl_802DBA58:
/* 802DBA58 94 21 FF E0 */ stwu r1, -0x20(r1)
/* 802DBA5C 7C 08 02 A6 */ mflr r0
/* 802DBA60 90 01 00 24 */ stw r0, 0x24(r1)
/* 802DBA64 39 61 00 20 */ addi r11, r1, 0x20
/* 802DBA68 48 08 67 6D */ bl _savegpr_27
/* 802DBA6C 89 23 00 07 */ lbz r9, 7(r3)
/* 802DBA70 89 03 00 06 */ lbz r8, 6(r3)
/* 802DBA74 88 E3 00 04 */ lbz r7, 4(r3)
/* 802DBA78 88 03 00 05 */ lbz r0, 5(r3)
/* 802DBA7C 54 00 80 1E */ slwi r0, r0, 0x10
/* 802DBA80 50 E0 C0 0E */ rlwimi r0, r7, 0x18, 0, 7
/* 802DBA84 51 00 44 2E */ rlwimi r0, r8, 8, 0x10, 0x17
/* 802DBA88 7D 20 03 78 */ or r0, r9, r0
/* 802DBA8C 89 43 00 0B */ lbz r10, 0xb(r3)
/* 802DBA90 89 23 00 0A */ lbz r9, 0xa(r3)
/* 802DBA94 89 03 00 08 */ lbz r8, 8(r3)
/* 802DBA98 88 E3 00 09 */ lbz r7, 9(r3)
/* 802DBA9C 54 E7 80 1E */ slwi r7, r7, 0x10
/* 802DBAA0 51 07 C0 0E */ rlwimi r7, r8, 0x18, 0, 7
/* 802DBAA4 51 27 44 2E */ rlwimi r7, r9, 8, 0x10, 0x17
/* 802DBAA8 7D 49 3B 78 */ or r9, r10, r7
/* 802DBAAC 89 83 00 0F */ lbz r12, 0xf(r3)
/* 802DBAB0 89 43 00 0E */ lbz r10, 0xe(r3)
/* 802DBAB4 89 03 00 0C */ lbz r8, 0xc(r3)
/* 802DBAB8 88 E3 00 0D */ lbz r7, 0xd(r3)
/* 802DBABC 54 E7 80 1E */ slwi r7, r7, 0x10
/* 802DBAC0 51 07 C0 0E */ rlwimi r7, r8, 0x18, 0, 7
/* 802DBAC4 51 47 44 2E */ rlwimi r7, r10, 8, 0x10, 0x17
/* 802DBAC8 7D 8C 3B 78 */ or r12, r12, r7
/* 802DBACC 39 00 00 00 */ li r8, 0
/* 802DBAD0 39 40 00 00 */ li r10, 0
/* 802DBAD4 38 E0 00 10 */ li r7, 0x10
/* 802DBAD8 28 05 00 00 */ cmplwi r5, 0
/* 802DBADC 41 82 01 20 */ beq lbl_802DBBFC
/* 802DBAE0 7C 06 00 40 */ cmplw r6, r0
/* 802DBAE4 41 81 01 18 */ bgt lbl_802DBBFC
/* 802DBAE8 7C 9F 23 78 */ mr r31, r4
/* 802DBAEC 7D 83 62 14 */ add r12, r3, r12
lbl_802DBAF0:
/* 802DBAF0 28 0A 00 00 */ cmplwi r10, 0
/* 802DBAF4 40 82 00 30 */ bne lbl_802DBB24
/* 802DBAF8 7D 43 3A 14 */ add r10, r3, r7
/* 802DBAFC 8B CA 00 03 */ lbz r30, 3(r10)
/* 802DBB00 8B AA 00 02 */ lbz r29, 2(r10)
/* 802DBB04 89 6A 00 00 */ lbz r11, 0(r10)
/* 802DBB08 89 4A 00 01 */ lbz r10, 1(r10)
/* 802DBB0C 55 4A 80 1E */ slwi r10, r10, 0x10
/* 802DBB10 51 6A C0 0E */ rlwimi r10, r11, 0x18, 0, 7
/* 802DBB14 53 AA 44 2E */ rlwimi r10, r29, 8, 0x10, 0x17
/* 802DBB18 7F CB 53 78 */ or r11, r30, r10
/* 802DBB1C 39 40 00 20 */ li r10, 0x20
/* 802DBB20 38 E7 00 04 */ addi r7, r7, 4
lbl_802DBB24:
/* 802DBB24 55 7D 00 01 */ rlwinm. r29, r11, 0, 0, 0
/* 802DBB28 41 82 00 34 */ beq lbl_802DBB5C
/* 802DBB2C 28 06 00 00 */ cmplwi r6, 0
/* 802DBB30 40 82 00 18 */ bne lbl_802DBB48
/* 802DBB34 8B AC 00 00 */ lbz r29, 0(r12)
/* 802DBB38 9B BF 00 00 */ stb r29, 0(r31)
/* 802DBB3C 34 A5 FF FF */ addic. r5, r5, -1
/* 802DBB40 40 82 00 0C */ bne lbl_802DBB4C
/* 802DBB44 48 00 00 B8 */ b lbl_802DBBFC
lbl_802DBB48:
/* 802DBB48 38 C6 FF FF */ addi r6, r6, -1
lbl_802DBB4C:
/* 802DBB4C 39 08 00 01 */ addi r8, r8, 1
/* 802DBB50 3B FF 00 01 */ addi r31, r31, 1
/* 802DBB54 39 8C 00 01 */ addi r12, r12, 1
/* 802DBB58 48 00 00 94 */ b lbl_802DBBEC
lbl_802DBB5C:
/* 802DBB5C 7F A3 4A 14 */ add r29, r3, r9
/* 802DBB60 8B DD 00 00 */ lbz r30, 0(r29)
/* 802DBB64 8B 9D 00 01 */ lbz r28, 1(r29)
/* 802DBB68 53 DC 44 2E */ rlwimi r28, r30, 8, 0x10, 0x17
/* 802DBB6C 57 9D 05 3E */ clrlwi r29, r28, 0x14
/* 802DBB70 7F 7D 40 50 */ subf r27, r29, r8
/* 802DBB74 7F 9C 66 71 */ srawi. r28, r28, 0xc
/* 802DBB78 39 29 00 02 */ addi r9, r9, 2
/* 802DBB7C 40 82 00 14 */ bne lbl_802DBB90
/* 802DBB80 8B AC 00 00 */ lbz r29, 0(r12)
/* 802DBB84 3B 9D 00 12 */ addi r28, r29, 0x12
/* 802DBB88 39 8C 00 01 */ addi r12, r12, 1
/* 802DBB8C 48 00 00 08 */ b lbl_802DBB94
lbl_802DBB90:
/* 802DBB90 3B 9C 00 02 */ addi r28, r28, 2
lbl_802DBB94:
/* 802DBB94 7F A8 00 50 */ subf r29, r8, r0
/* 802DBB98 7C 1C E8 00 */ cmpw r28, r29
/* 802DBB9C 40 81 00 08 */ ble lbl_802DBBA4
/* 802DBBA0 7F BC EB 78 */ mr r28, r29
lbl_802DBBA4:
/* 802DBBA4 7F C4 42 14 */ add r30, r4, r8
/* 802DBBA8 7F 89 03 A6 */ mtctr r28
/* 802DBBAC 2C 1C 00 00 */ cmpwi r28, 0
/* 802DBBB0 40 81 00 3C */ ble lbl_802DBBEC
lbl_802DBBB4:
/* 802DBBB4 28 06 00 00 */ cmplwi r6, 0
/* 802DBBB8 40 82 00 1C */ bne lbl_802DBBD4
/* 802DBBBC 3B BB FF FF */ addi r29, r27, -1
/* 802DBBC0 7F A4 E8 AE */ lbzx r29, r4, r29
/* 802DBBC4 9B BE 00 00 */ stb r29, 0(r30)
/* 802DBBC8 34 A5 FF FF */ addic. r5, r5, -1
/* 802DBBCC 40 82 00 0C */ bne lbl_802DBBD8
/* 802DBBD0 48 00 00 2C */ b lbl_802DBBFC
lbl_802DBBD4:
/* 802DBBD4 38 C6 FF FF */ addi r6, r6, -1
lbl_802DBBD8:
/* 802DBBD8 39 08 00 01 */ addi r8, r8, 1
/* 802DBBDC 3B FF 00 01 */ addi r31, r31, 1
/* 802DBBE0 3B DE 00 01 */ addi r30, r30, 1
/* 802DBBE4 3B 7B 00 01 */ addi r27, r27, 1
/* 802DBBE8 42 00 FF CC */ bdnz lbl_802DBBB4
lbl_802DBBEC:
/* 802DBBEC 55 6B 08 3C */ slwi r11, r11, 1
/* 802DBBF0 7C 08 00 00 */ cmpw r8, r0
/* 802DBBF4 39 4A FF FF */ addi r10, r10, -1
/* 802DBBF8 41 80 FE F8 */ blt lbl_802DBAF0
lbl_802DBBFC:
/* 802DBBFC 39 61 00 20 */ addi r11, r1, 0x20
/* 802DBC00 48 08 66 21 */ bl _restgpr_27
/* 802DBC04 80 01 00 24 */ lwz r0, 0x24(r1)
/* 802DBC08 7C 08 03 A6 */ mtlr r0
/* 802DBC0C 38 21 00 20 */ addi r1, r1, 0x20
/* 802DBC10 4E 80 00 20 */ blr

103
asm/JSystem/JKernel/JKRDvdRipper/JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl.s
View File

@ -1,103 +0,0 @@
lbl_802DA1E4:
/* 802DA1E4 94 21 FF D0 */ stwu r1, -0x30(r1)
/* 802DA1E8 7C 08 02 A6 */ mflr r0
/* 802DA1EC 90 01 00 34 */ stw r0, 0x34(r1)
/* 802DA1F0 39 61 00 30 */ addi r11, r1, 0x30
/* 802DA1F4 48 08 7F D5 */ bl _savegpr_24
/* 802DA1F8 7C 79 1B 78 */ mr r25, r3
/* 802DA1FC 7C 9A 23 78 */ mr r26, r4
/* 802DA200 7C BB 2B 78 */ mr r27, r5
/* 802DA204 7C DC 33 78 */ mr r28, r6
/* 802DA208 7C FD 3B 78 */ mr r29, r7
/* 802DA20C 7D 1E 43 78 */ mr r30, r8
/* 802DA210 7D 3F 4B 78 */ mr r31, r9
/* 802DA214 48 06 34 E1 */ bl OSDisableInterrupts
/* 802DA218 7C 78 1B 78 */ mr r24, r3
/* 802DA21C 88 0D 8E D8 */ lbz r0, data_80451458(r13)
/* 802DA220 28 00 00 00 */ cmplwi r0, 0
/* 802DA224 40 82 00 18 */ bne lbl_802DA23C
/* 802DA228 3C 60 80 43 */ lis r3, decompMutex@ha /* 0x80434390@ha */
/* 802DA22C 38 63 43 90 */ addi r3, r3, decompMutex@l /* 0x80434390@l */
/* 802DA230 48 06 4D D9 */ bl OSInitMutex
/* 802DA234 38 00 00 01 */ li r0, 1
/* 802DA238 98 0D 8E D8 */ stb r0, data_80451458(r13)
lbl_802DA23C:
/* 802DA23C 7F 03 C3 78 */ mr r3, r24
/* 802DA240 48 06 34 DD */ bl OSRestoreInterrupts
/* 802DA244 3C 60 80 43 */ lis r3, decompMutex@ha /* 0x80434390@ha */
/* 802DA248 38 63 43 90 */ addi r3, r3, decompMutex@l /* 0x80434390@l */
/* 802DA24C 48 06 4D F5 */ bl OSLockMutex
/* 802DA250 83 0D 83 4C */ lwz r24, sSZSBufferSize__12JKRDvdRipper(r13)
/* 802DA254 80 6D 8D F0 */ lwz r3, sSystemHeap__7JKRHeap(r13)
/* 802DA258 7F 04 C3 78 */ mr r4, r24
/* 802DA25C 38 A0 FF E0 */ li r5, -32
/* 802DA260 4B FF 42 75 */ bl alloc__7JKRHeapFUli
/* 802DA264 90 6D 8E A8 */ stw r3, szpBuf(r13)
/* 802DA268 7C 03 C2 14 */ add r0, r3, r24
/* 802DA26C 90 0D 8E AC */ stw r0, szpEnd(r13)
/* 802DA270 28 1D 00 00 */ cmplwi r29, 0
/* 802DA274 41 82 00 28 */ beq lbl_802DA29C
/* 802DA278 80 6D 8D F0 */ lwz r3, sSystemHeap__7JKRHeap(r13)
/* 802DA27C 38 80 11 20 */ li r4, 0x1120
/* 802DA280 38 A0 FF FC */ li r5, -4
/* 802DA284 4B FF 42 51 */ bl alloc__7JKRHeapFUli
/* 802DA288 90 6D 8E B0 */ stw r3, refBuf(r13)
/* 802DA28C 38 03 11 20 */ addi r0, r3, 0x1120
/* 802DA290 90 0D 8E B4 */ stw r0, refEnd(r13)
/* 802DA294 90 6D 8E B8 */ stw r3, refCurrent(r13)
/* 802DA298 48 00 00 0C */ b lbl_802DA2A4
lbl_802DA29C:
/* 802DA29C 38 00 00 00 */ li r0, 0
/* 802DA2A0 90 0D 8E B0 */ stw r0, refBuf(r13)
lbl_802DA2A4:
/* 802DA2A4 93 2D 8E C8 */ stw r25, srcFile(r13)
/* 802DA2A8 93 CD 8E BC */ stw r30, srcOffset(r13)
/* 802DA2AC 7C 1E D8 50 */ subf r0, r30, r27
/* 802DA2B0 90 0D 8E C0 */ stw r0, transLeft(r13)
/* 802DA2B4 93 AD 8E CC */ stw r29, fileOffset(r13)
/* 802DA2B8 38 00 00 00 */ li r0, 0
/* 802DA2BC 90 0D 8E D0 */ stw r0, readCount(r13)
/* 802DA2C0 93 8D 8E D4 */ stw r28, maxDest(r13)
/* 802DA2C4 28 1F 00 00 */ cmplwi r31, 0
/* 802DA2C8 41 82 00 0C */ beq lbl_802DA2D4
/* 802DA2CC 7F E3 FB 78 */ mr r3, r31
/* 802DA2D0 48 00 00 08 */ b lbl_802DA2D8
lbl_802DA2D4:
/* 802DA2D4 38 6D 8E E0 */ la r3, tsArea(r13) /* 80451460-_SDA_BASE_ */
lbl_802DA2D8:
/* 802DA2D8 90 6D 8E DC */ stw r3, tsPtr(r13)
/* 802DA2DC 38 00 00 00 */ li r0, 0
/* 802DA2E0 90 03 00 00 */ stw r0, 0(r3)
/* 802DA2E4 48 00 03 29 */ bl firstSrcData__Fv
/* 802DA2E8 28 03 00 00 */ cmplwi r3, 0
/* 802DA2EC 41 82 00 10 */ beq lbl_802DA2FC
/* 802DA2F0 7F 44 D3 78 */ mr r4, r26
/* 802DA2F4 48 00 00 69 */ bl decompSZS_subroutine__FPUcPUc
/* 802DA2F8 48 00 00 08 */ b lbl_802DA300
lbl_802DA2FC:
/* 802DA2FC 38 60 FF FF */ li r3, -1
lbl_802DA300:
/* 802DA300 7C 78 1B 78 */ mr r24, r3
/* 802DA304 80 6D 8E A8 */ lwz r3, szpBuf(r13)
/* 802DA308 38 80 00 00 */ li r4, 0
/* 802DA30C 4B FF 41 F5 */ bl free__7JKRHeapFPvP7JKRHeap
/* 802DA310 80 6D 8E B0 */ lwz r3, refBuf(r13)
/* 802DA314 28 03 00 00 */ cmplwi r3, 0
/* 802DA318 41 82 00 0C */ beq lbl_802DA324
/* 802DA31C 38 80 00 00 */ li r4, 0
/* 802DA320 4B FF 41 E1 */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802DA324:
/* 802DA324 7F 43 D3 78 */ mr r3, r26
/* 802DA328 80 8D 8E DC */ lwz r4, tsPtr(r13)
/* 802DA32C 80 84 00 00 */ lwz r4, 0(r4)
/* 802DA330 48 06 13 09 */ bl DCStoreRangeNoSync
/* 802DA334 3C 60 80 43 */ lis r3, decompMutex@ha /* 0x80434390@ha */
/* 802DA338 38 63 43 90 */ addi r3, r3, decompMutex@l /* 0x80434390@l */
/* 802DA33C 48 06 4D E1 */ bl OSUnlockMutex
/* 802DA340 7F 03 C3 78 */ mr r3, r24
/* 802DA344 39 61 00 30 */ addi r11, r1, 0x30
/* 802DA348 48 08 7E CD */ bl _restgpr_24
/* 802DA34C 80 01 00 34 */ lwz r0, 0x34(r1)
/* 802DA350 7C 08 03 A6 */ mtlr r0
/* 802DA354 38 21 00 30 */ addi r1, r1, 0x30
/* 802DA358 4E 80 00 20 */ blr

18
asm/JSystem/JKernel/JKRDvdRipper/__sinit_JKRDvdRipper_cpp.s
View File

@ -1,18 +0,0 @@
lbl_802DA7DC:
/* 802DA7DC 94 21 FF F0 */ stwu r1, -0x10(r1)
/* 802DA7E0 7C 08 02 A6 */ mflr r0
/* 802DA7E4 90 01 00 14 */ stw r0, 0x14(r1)
/* 802DA7E8 3C 60 80 43 */ lis r3, sDvdAsyncList__12JKRDvdRipper@ha /* 0x80434384@ha */
/* 802DA7EC 38 63 43 84 */ addi r3, r3, sDvdAsyncList__12JKRDvdRipper@l /* 0x80434384@l */
/* 802DA7F0 48 00 17 25 */ bl initiate__10JSUPtrListFv
/* 802DA7F4 3C 60 80 43 */ lis r3, sDvdAsyncList__12JKRDvdRipper@ha /* 0x80434384@ha */
/* 802DA7F8 38 63 43 84 */ addi r3, r3, sDvdAsyncList__12JKRDvdRipper@l /* 0x80434384@l */
/* 802DA7FC 3C 80 80 2E */ lis r4, func_802DA820@ha /* 0x802DA820@ha */
/* 802DA800 38 84 A8 20 */ addi r4, r4, func_802DA820@l /* 0x802DA820@l */
/* 802DA804 3C A0 80 43 */ lis r5, lit_491@ha /* 0x80434378@ha */
/* 802DA808 38 A5 43 78 */ addi r5, r5, lit_491@l /* 0x80434378@l */
/* 802DA80C 48 08 74 19 */ bl __register_global_object
/* 802DA810 80 01 00 14 */ lwz r0, 0x14(r1)
/* 802DA814 7C 08 03 A6 */ mtlr r0
/* 802DA818 38 21 00 10 */ addi r1, r1, 0x10
/* 802DA81C 4E 80 00 20 */ blr

196
asm/JSystem/JKernel/JKRDvdRipper/decompSZS_subroutine__FPUcPUc.s
View File

@ -1,196 +0,0 @@
lbl_802DA35C:
/* 802DA35C 94 21 FF E0 */ stwu r1, -0x20(r1)
/* 802DA360 7C 08 02 A6 */ mflr r0
/* 802DA364 90 01 00 24 */ stw r0, 0x24(r1)
/* 802DA368 39 61 00 20 */ addi r11, r1, 0x20
/* 802DA36C 48 08 7E 71 */ bl _savegpr_29
/* 802DA370 7C 9D 23 78 */ mr r29, r4
/* 802DA374 38 80 00 00 */ li r4, 0
/* 802DA378 38 00 00 00 */ li r0, 0
/* 802DA37C 3B C0 00 00 */ li r30, 0
/* 802DA380 88 A3 00 00 */ lbz r5, 0(r3)
/* 802DA384 2C 05 00 59 */ cmpwi r5, 0x59
/* 802DA388 40 82 00 28 */ bne lbl_802DA3B0
/* 802DA38C 88 A3 00 01 */ lbz r5, 1(r3)
/* 802DA390 2C 05 00 61 */ cmpwi r5, 0x61
/* 802DA394 40 82 00 1C */ bne lbl_802DA3B0
/* 802DA398 88 A3 00 02 */ lbz r5, 2(r3)
/* 802DA39C 2C 05 00 7A */ cmpwi r5, 0x7a
/* 802DA3A0 40 82 00 10 */ bne lbl_802DA3B0
/* 802DA3A4 88 A3 00 03 */ lbz r5, 3(r3)
/* 802DA3A8 2C 05 00 30 */ cmpwi r5, 0x30
/* 802DA3AC 41 82 00 0C */ beq lbl_802DA3B8
lbl_802DA3B0:
/* 802DA3B0 38 60 FF FF */ li r3, -1
/* 802DA3B4 48 00 02 40 */ b lbl_802DA5F4
lbl_802DA3B8:
/* 802DA3B8 80 CD 8E CC */ lwz r6, fileOffset(r13)
/* 802DA3BC 80 A3 00 04 */ lwz r5, 4(r3)
/* 802DA3C0 7C A6 28 50 */ subf r5, r6, r5
/* 802DA3C4 7F FD 2A 14 */ add r31, r29, r5
/* 802DA3C8 80 AD 8E D4 */ lwz r5, maxDest(r13)
/* 802DA3CC 7C BD 2A 14 */ add r5, r29, r5
/* 802DA3D0 7C 1F 28 40 */ cmplw r31, r5
/* 802DA3D4 40 81 00 08 */ ble lbl_802DA3DC
/* 802DA3D8 7C BF 2B 78 */ mr r31, r5
lbl_802DA3DC:
/* 802DA3DC 38 63 00 10 */ addi r3, r3, 0x10
lbl_802DA3E0:
/* 802DA3E0 2C 04 00 00 */ cmpwi r4, 0
/* 802DA3E4 40 82 00 3C */ bne lbl_802DA420
/* 802DA3E8 80 0D 8E C4 */ lwz r0, srcLimit(r13)
/* 802DA3EC 7C 03 00 40 */ cmplw r3, r0
/* 802DA3F0 40 81 00 24 */ ble lbl_802DA414
/* 802DA3F4 80 0D 8E C0 */ lwz r0, transLeft(r13)
/* 802DA3F8 28 00 00 00 */ cmplwi r0, 0
/* 802DA3FC 41 82 00 18 */ beq lbl_802DA414
/* 802DA400 48 00 02 D9 */ bl nextSrcData__FPUc
/* 802DA404 28 03 00 00 */ cmplwi r3, 0
/* 802DA408 40 82 00 0C */ bne lbl_802DA414
/* 802DA40C 38 60 FF FF */ li r3, -1
/* 802DA410 48 00 01 E4 */ b lbl_802DA5F4
lbl_802DA414:
/* 802DA414 88 03 00 00 */ lbz r0, 0(r3)
/* 802DA418 38 80 00 08 */ li r4, 8
/* 802DA41C 38 63 00 01 */ addi r3, r3, 1
lbl_802DA420:
/* 802DA420 54 05 06 31 */ rlwinm. r5, r0, 0, 0x18, 0x18
/* 802DA424 41 82 00 94 */ beq lbl_802DA4B8
/* 802DA428 80 CD 8E CC */ lwz r6, fileOffset(r13)
/* 802DA42C 28 06 00 00 */ cmplwi r6, 0
/* 802DA430 41 82 00 5C */ beq lbl_802DA48C
/* 802DA434 80 AD 8E D0 */ lwz r5, readCount(r13)
/* 802DA438 7C 05 30 40 */ cmplw r5, r6
/* 802DA43C 41 80 00 1C */ blt lbl_802DA458
/* 802DA440 88 A3 00 00 */ lbz r5, 0(r3)
/* 802DA444 98 BD 00 00 */ stb r5, 0(r29)
/* 802DA448 3B BD 00 01 */ addi r29, r29, 1
/* 802DA44C 7C 1D F8 40 */ cmplw r29, r31
/* 802DA450 3B DE 00 01 */ addi r30, r30, 1
/* 802DA454 41 82 01 94 */ beq lbl_802DA5E8
lbl_802DA458:
/* 802DA458 88 E3 00 00 */ lbz r7, 0(r3)
/* 802DA45C 80 CD 8E B8 */ lwz r6, refCurrent(r13)
/* 802DA460 38 A6 00 01 */ addi r5, r6, 1
/* 802DA464 90 AD 8E B8 */ stw r5, refCurrent(r13)
/* 802DA468 98 E6 00 00 */ stb r7, 0(r6)
/* 802DA46C 80 CD 8E B8 */ lwz r6, refCurrent(r13)
/* 802DA470 80 AD 8E B4 */ lwz r5, refEnd(r13)
/* 802DA474 7C 06 28 40 */ cmplw r6, r5
/* 802DA478 40 82 00 0C */ bne lbl_802DA484
/* 802DA47C 80 AD 8E B0 */ lwz r5, refBuf(r13)
/* 802DA480 90 AD 8E B8 */ stw r5, refCurrent(r13)
lbl_802DA484:
/* 802DA484 38 63 00 01 */ addi r3, r3, 1
/* 802DA488 48 00 00 20 */ b lbl_802DA4A8
lbl_802DA48C:
/* 802DA48C 88 A3 00 00 */ lbz r5, 0(r3)
/* 802DA490 98 BD 00 00 */ stb r5, 0(r29)
/* 802DA494 3B BD 00 01 */ addi r29, r29, 1
/* 802DA498 7C 1D F8 40 */ cmplw r29, r31
/* 802DA49C 38 63 00 01 */ addi r3, r3, 1
/* 802DA4A0 3B DE 00 01 */ addi r30, r30, 1
/* 802DA4A4 41 82 01 44 */ beq lbl_802DA5E8
lbl_802DA4A8:
/* 802DA4A8 80 AD 8E D0 */ lwz r5, readCount(r13)
/* 802DA4AC 38 A5 00 01 */ addi r5, r5, 1
/* 802DA4B0 90 AD 8E D0 */ stw r5, readCount(r13)
/* 802DA4B4 48 00 01 24 */ b lbl_802DA5D8
lbl_802DA4B8:
/* 802DA4B8 88 C3 00 00 */ lbz r6, 0(r3)
/* 802DA4BC 88 E3 00 01 */ lbz r7, 1(r3)
/* 802DA4C0 50 C7 45 2E */ rlwimi r7, r6, 8, 0x14, 0x17
/* 802DA4C4 7C C5 26 70 */ srawi r5, r6, 4
/* 802DA4C8 81 0D 8E CC */ lwz r8, fileOffset(r13)
/* 802DA4CC 28 08 00 00 */ cmplwi r8, 0
/* 802DA4D0 38 63 00 02 */ addi r3, r3, 2
/* 802DA4D4 41 82 00 2C */ beq lbl_802DA500
/* 802DA4D8 80 CD 8E B8 */ lwz r6, refCurrent(r13)
/* 802DA4DC 7C C7 30 50 */ subf r6, r7, r6
/* 802DA4E0 39 26 FF FF */ addi r9, r6, -1
/* 802DA4E4 80 ED 8E B0 */ lwz r7, refBuf(r13)
/* 802DA4E8 7C 09 38 40 */ cmplw r9, r7
/* 802DA4EC 40 80 00 1C */ bge lbl_802DA508
/* 802DA4F0 80 CD 8E B4 */ lwz r6, refEnd(r13)
/* 802DA4F4 7C C7 30 50 */ subf r6, r7, r6
/* 802DA4F8 7D 29 32 14 */ add r9, r9, r6
/* 802DA4FC 48 00 00 0C */ b lbl_802DA508
lbl_802DA500:
/* 802DA500 7C C7 E8 50 */ subf r6, r7, r29
/* 802DA504 39 26 FF FF */ addi r9, r6, -1
lbl_802DA508:
/* 802DA508 2C 05 00 00 */ cmpwi r5, 0
/* 802DA50C 40 82 00 14 */ bne lbl_802DA520
/* 802DA510 88 A3 00 00 */ lbz r5, 0(r3)
/* 802DA514 38 A5 00 12 */ addi r5, r5, 0x12
/* 802DA518 38 63 00 01 */ addi r3, r3, 1
/* 802DA51C 48 00 00 08 */ b lbl_802DA524
lbl_802DA520:
/* 802DA520 38 A5 00 02 */ addi r5, r5, 2
lbl_802DA524:
/* 802DA524 28 08 00 00 */ cmplwi r8, 0
/* 802DA528 41 82 00 80 */ beq lbl_802DA5A8
lbl_802DA52C:
/* 802DA52C 80 ED 8E D0 */ lwz r7, readCount(r13)
/* 802DA530 80 CD 8E CC */ lwz r6, fileOffset(r13)
/* 802DA534 7C 07 30 40 */ cmplw r7, r6
/* 802DA538 41 80 00 1C */ blt lbl_802DA554
/* 802DA53C 88 C9 00 00 */ lbz r6, 0(r9)
/* 802DA540 98 DD 00 00 */ stb r6, 0(r29)
/* 802DA544 3B BD 00 01 */ addi r29, r29, 1
/* 802DA548 7C 1D F8 40 */ cmplw r29, r31
/* 802DA54C 3B DE 00 01 */ addi r30, r30, 1
/* 802DA550 41 82 00 88 */ beq lbl_802DA5D8
lbl_802DA554:
/* 802DA554 89 09 00 00 */ lbz r8, 0(r9)
/* 802DA558 80 ED 8E B8 */ lwz r7, refCurrent(r13)
/* 802DA55C 38 C7 00 01 */ addi r6, r7, 1
/* 802DA560 90 CD 8E B8 */ stw r6, refCurrent(r13)
/* 802DA564 99 07 00 00 */ stb r8, 0(r7)
/* 802DA568 80 CD 8E B8 */ lwz r6, refCurrent(r13)
/* 802DA56C 80 ED 8E B4 */ lwz r7, refEnd(r13)
/* 802DA570 7C 06 38 40 */ cmplw r6, r7
/* 802DA574 40 82 00 0C */ bne lbl_802DA580
/* 802DA578 80 CD 8E B0 */ lwz r6, refBuf(r13)
/* 802DA57C 90 CD 8E B8 */ stw r6, refCurrent(r13)
lbl_802DA580:
/* 802DA580 39 29 00 01 */ addi r9, r9, 1
/* 802DA584 7C 09 38 40 */ cmplw r9, r7
/* 802DA588 40 82 00 08 */ bne lbl_802DA590
/* 802DA58C 81 2D 8E B0 */ lwz r9, refBuf(r13)
lbl_802DA590:
/* 802DA590 80 CD 8E D0 */ lwz r6, readCount(r13)
/* 802DA594 38 C6 00 01 */ addi r6, r6, 1
/* 802DA598 90 CD 8E D0 */ stw r6, readCount(r13)
/* 802DA59C 34 A5 FF FF */ addic. r5, r5, -1
/* 802DA5A0 40 82 FF 8C */ bne lbl_802DA52C
/* 802DA5A4 48 00 00 34 */ b lbl_802DA5D8
lbl_802DA5A8:
/* 802DA5A8 88 C9 00 00 */ lbz r6, 0(r9)
/* 802DA5AC 98 DD 00 00 */ stb r6, 0(r29)
/* 802DA5B0 3B BD 00 01 */ addi r29, r29, 1
/* 802DA5B4 7C 1D F8 40 */ cmplw r29, r31
/* 802DA5B8 3B DE 00 01 */ addi r30, r30, 1
/* 802DA5BC 41 82 00 1C */ beq lbl_802DA5D8
/* 802DA5C0 80 CD 8E D0 */ lwz r6, readCount(r13)
/* 802DA5C4 38 C6 00 01 */ addi r6, r6, 1
/* 802DA5C8 90 CD 8E D0 */ stw r6, readCount(r13)
/* 802DA5CC 34 A5 FF FF */ addic. r5, r5, -1
/* 802DA5D0 39 29 00 01 */ addi r9, r9, 1
/* 802DA5D4 40 82 FF D4 */ bne lbl_802DA5A8
lbl_802DA5D8:
/* 802DA5D8 54 00 08 3C */ slwi r0, r0, 1
/* 802DA5DC 7C 1D F8 40 */ cmplw r29, r31
/* 802DA5E0 38 84 FF FF */ addi r4, r4, -1
/* 802DA5E4 41 80 FD FC */ blt lbl_802DA3E0
lbl_802DA5E8:
/* 802DA5E8 80 6D 8E DC */ lwz r3, tsPtr(r13)
/* 802DA5EC 93 C3 00 00 */ stw r30, 0(r3)
/* 802DA5F0 38 60 00 00 */ li r3, 0
lbl_802DA5F4:
/* 802DA5F4 39 61 00 20 */ addi r11, r1, 0x20
/* 802DA5F8 48 08 7C 31 */ bl _restgpr_29
/* 802DA5FC 80 01 00 24 */ lwz r0, 0x24(r1)
/* 802DA600 7C 08 03 A6 */ mtlr r0
/* 802DA604 38 21 00 20 */ addi r1, r1, 0x20
/* 802DA608 4E 80 00 20 */ blr

356
asm/JSystem/JKernel/JKRDvdRipper/func_802D9D10.s
View File

@ -1,356 +0,0 @@
lbl_802D9D10:
/* 802D9D10 94 21 FF 40 */ stwu r1, -0xc0(r1)
/* 802D9D14 7C 08 02 A6 */ mflr r0
/* 802D9D18 90 01 00 C4 */ stw r0, 0xc4(r1)
/* 802D9D1C 39 61 00 C0 */ addi r11, r1, 0xc0
/* 802D9D20 48 08 84 91 */ bl _savegpr_18
/* 802D9D24 7C 76 1B 78 */ mr r22, r3
/* 802D9D28 7C 9C 23 78 */ mr r28, r4
/* 802D9D2C 7C B5 2B 78 */ mr r21, r5
/* 802D9D30 7C DF 33 78 */ mr r31, r6
/* 802D9D34 7C F4 3B 78 */ mr r20, r7
/* 802D9D38 7D 12 43 78 */ mr r18, r8
/* 802D9D3C 7D 3E 4B 78 */ mr r30, r9
/* 802D9D40 7D 53 53 78 */ mr r19, r10
/* 802D9D44 82 E1 00 C8 */ lwz r23, 0xc8(r1)
/* 802D9D48 3B 20 00 00 */ li r25, 0
/* 802D9D4C 3B 60 00 00 */ li r27, 0
/* 802D9D50 3B A0 00 00 */ li r29, 0
/* 802D9D54 81 83 00 00 */ lwz r12, 0(r3)
/* 802D9D58 81 8C 00 1C */ lwz r12, 0x1c(r12)
/* 802D9D5C 7D 89 03 A6 */ mtctr r12
/* 802D9D60 4E 80 04 21 */ bctrl
/* 802D9D64 38 03 00 1F */ addi r0, r3, 0x1f
/* 802D9D68 54 18 00 34 */ rlwinm r24, r0, 0, 0, 0x1a
/* 802D9D6C 2C 15 00 01 */ cmpwi r21, 1
/* 802D9D70 40 82 00 94 */ bne lbl_802D9E04
/* 802D9D74 38 01 00 67 */ addi r0, r1, 0x67
/* 802D9D78 54 1A 00 34 */ rlwinm r26, r0, 0, 0, 0x1a
lbl_802D9D7C:
/* 802D9D7C 38 76 00 5C */ addi r3, r22, 0x5c
/* 802D9D80 7F 44 D3 78 */ mr r4, r26
/* 802D9D84 38 A0 00 20 */ li r5, 0x20
/* 802D9D88 38 C0 00 00 */ li r6, 0
/* 802D9D8C 38 E0 00 02 */ li r7, 2
/* 802D9D90 48 06 F0 B5 */ bl DVDReadPrio
/* 802D9D94 2C 03 00 00 */ cmpwi r3, 0
/* 802D9D98 40 80 00 28 */ bge lbl_802D9DC0
/* 802D9D9C 2C 03 FF FD */ cmpwi r3, -3
/* 802D9DA0 41 82 00 10 */ beq lbl_802D9DB0
/* 802D9DA4 88 0D 83 48 */ lbz r0, data_804508C8(r13)
/* 802D9DA8 28 00 00 00 */ cmplwi r0, 0
/* 802D9DAC 40 82 00 0C */ bne lbl_802D9DB8
lbl_802D9DB0:
/* 802D9DB0 38 60 00 00 */ li r3, 0
/* 802D9DB4 48 00 04 18 */ b lbl_802DA1CC
lbl_802D9DB8:
/* 802D9DB8 48 07 2C 0D */ bl VIWaitForRetrace
/* 802D9DBC 4B FF FF C0 */ b lbl_802D9D7C
lbl_802D9DC0:
/* 802D9DC0 7F 43 D3 78 */ mr r3, r26
/* 802D9DC4 38 80 00 20 */ li r4, 0x20
/* 802D9DC8 48 06 17 B9 */ bl DCInvalidateRange
/* 802D9DCC 7F 43 D3 78 */ mr r3, r26
/* 802D9DD0 48 00 1F 29 */ bl checkCompressed__9JKRDecompFPUc
/* 802D9DD4 2C 03 00 03 */ cmpwi r3, 3
/* 802D9DD8 40 82 00 08 */ bne lbl_802D9DE0
/* 802D9DDC 38 60 00 00 */ li r3, 0
lbl_802D9DE0:
/* 802D9DE0 7C 7B 1B 78 */ mr r27, r3
/* 802D9DE4 88 BA 00 07 */ lbz r5, 7(r26)
/* 802D9DE8 88 9A 00 06 */ lbz r4, 6(r26)
/* 802D9DEC 88 7A 00 04 */ lbz r3, 4(r26)
/* 802D9DF0 88 1A 00 05 */ lbz r0, 5(r26)
/* 802D9DF4 54 00 80 1E */ slwi r0, r0, 0x10
/* 802D9DF8 50 60 C0 0E */ rlwimi r0, r3, 0x18, 0, 7
/* 802D9DFC 50 80 44 2E */ rlwimi r0, r4, 8, 0x10, 0x17
/* 802D9E00 7C BA 03 78 */ or r26, r5, r0
lbl_802D9E04:
/* 802D9E04 28 13 00 00 */ cmplwi r19, 0
/* 802D9E08 41 82 00 08 */ beq lbl_802D9E10
/* 802D9E0C 93 73 00 00 */ stw r27, 0(r19)
lbl_802D9E10:
/* 802D9E10 2C 15 00 01 */ cmpwi r21, 1
/* 802D9E14 40 82 00 9C */ bne lbl_802D9EB0
/* 802D9E18 2C 1B 00 00 */ cmpwi r27, 0
/* 802D9E1C 41 82 00 94 */ beq lbl_802D9EB0
/* 802D9E20 28 1F 00 00 */ cmplwi r31, 0
/* 802D9E24 41 82 00 10 */ beq lbl_802D9E34
/* 802D9E28 7C 1A F8 40 */ cmplw r26, r31
/* 802D9E2C 40 81 00 08 */ ble lbl_802D9E34
/* 802D9E30 7F FA FB 78 */ mr r26, r31
lbl_802D9E34:
/* 802D9E34 28 1C 00 00 */ cmplwi r28, 0
/* 802D9E38 40 82 00 28 */ bne lbl_802D9E60
/* 802D9E3C 7F 43 D3 78 */ mr r3, r26
/* 802D9E40 2C 12 00 01 */ cmpwi r18, 1
/* 802D9E44 38 80 FF E0 */ li r4, -32
/* 802D9E48 40 82 00 08 */ bne lbl_802D9E50
/* 802D9E4C 38 80 00 20 */ li r4, 0x20
lbl_802D9E50:
/* 802D9E50 7E 85 A3 78 */ mr r5, r20
/* 802D9E54 4B FF 46 21 */ bl alloc__7JKRHeapFUliP7JKRHeap
/* 802D9E58 7C 7C 1B 78 */ mr r28, r3
/* 802D9E5C 3B 20 00 01 */ li r25, 1
lbl_802D9E60:
/* 802D9E60 28 1C 00 00 */ cmplwi r28, 0
/* 802D9E64 40 82 00 0C */ bne lbl_802D9E70
/* 802D9E68 38 60 00 00 */ li r3, 0
/* 802D9E6C 48 00 03 60 */ b lbl_802DA1CC
lbl_802D9E70:
/* 802D9E70 2C 1B 00 01 */ cmpwi r27, 1
/* 802D9E74 40 82 00 8C */ bne lbl_802D9F00
/* 802D9E78 7F 03 C3 78 */ mr r3, r24
/* 802D9E7C 38 80 00 20 */ li r4, 0x20
/* 802D9E80 7E 85 A3 78 */ mr r5, r20
/* 802D9E84 4B FF 45 F1 */ bl alloc__7JKRHeapFUliP7JKRHeap
/* 802D9E88 7C 7D 1B 79 */ or. r29, r3, r3
/* 802D9E8C 40 82 00 74 */ bne lbl_802D9F00
/* 802D9E90 57 20 06 3E */ clrlwi r0, r25, 0x18
/* 802D9E94 28 00 00 01 */ cmplwi r0, 1
/* 802D9E98 40 82 00 68 */ bne lbl_802D9F00
/* 802D9E9C 7F 83 E3 78 */ mr r3, r28
/* 802D9EA0 38 80 00 00 */ li r4, 0
/* 802D9EA4 4B FF 46 5D */ bl free__7JKRHeapFPvP7JKRHeap
/* 802D9EA8 38 60 00 00 */ li r3, 0
/* 802D9EAC 48 00 03 20 */ b lbl_802DA1CC
lbl_802D9EB0:
/* 802D9EB0 28 1C 00 00 */ cmplwi r28, 0
/* 802D9EB4 40 82 00 3C */ bne lbl_802D9EF0
/* 802D9EB8 7C 7E C0 50 */ subf r3, r30, r24
/* 802D9EBC 28 1F 00 00 */ cmplwi r31, 0
/* 802D9EC0 41 82 00 10 */ beq lbl_802D9ED0
/* 802D9EC4 7C 03 F8 40 */ cmplw r3, r31
/* 802D9EC8 40 81 00 08 */ ble lbl_802D9ED0
/* 802D9ECC 7F E3 FB 78 */ mr r3, r31
lbl_802D9ED0:
/* 802D9ED0 2C 12 00 01 */ cmpwi r18, 1
/* 802D9ED4 38 80 FF E0 */ li r4, -32
/* 802D9ED8 40 82 00 08 */ bne lbl_802D9EE0
/* 802D9EDC 38 80 00 20 */ li r4, 0x20
lbl_802D9EE0:
/* 802D9EE0 7E 85 A3 78 */ mr r5, r20
/* 802D9EE4 4B FF 45 91 */ bl alloc__7JKRHeapFUliP7JKRHeap
/* 802D9EE8 7C 7C 1B 78 */ mr r28, r3
/* 802D9EEC 3B 20 00 01 */ li r25, 1
lbl_802D9EF0:
/* 802D9EF0 28 1C 00 00 */ cmplwi r28, 0
/* 802D9EF4 40 82 00 0C */ bne lbl_802D9F00
/* 802D9EF8 38 60 00 00 */ li r3, 0
/* 802D9EFC 48 00 02 D0 */ b lbl_802DA1CC
lbl_802D9F00:
/* 802D9F00 2C 1B 00 00 */ cmpwi r27, 0
/* 802D9F04 40 82 01 8C */ bne lbl_802DA090
/* 802D9F08 38 60 00 00 */ li r3, 0
/* 802D9F0C 28 1E 00 00 */ cmplwi r30, 0
/* 802D9F10 41 82 00 8C */ beq lbl_802D9F9C
/* 802D9F14 38 01 00 27 */ addi r0, r1, 0x27
/* 802D9F18 54 13 00 34 */ rlwinm r19, r0, 0, 0, 0x1a
/* 802D9F1C 7F D2 F3 78 */ mr r18, r30
lbl_802D9F20:
/* 802D9F20 38 76 00 5C */ addi r3, r22, 0x5c
/* 802D9F24 7E 64 9B 78 */ mr r4, r19
/* 802D9F28 38 A0 00 20 */ li r5, 0x20
/* 802D9F2C 7E 46 93 78 */ mr r6, r18
/* 802D9F30 38 E0 00 02 */ li r7, 2
/* 802D9F34 48 06 EF 11 */ bl DVDReadPrio
/* 802D9F38 2C 03 00 00 */ cmpwi r3, 0
/* 802D9F3C 40 80 00 40 */ bge lbl_802D9F7C
/* 802D9F40 2C 03 FF FD */ cmpwi r3, -3
/* 802D9F44 41 82 00 10 */ beq lbl_802D9F54
/* 802D9F48 88 0D 83 48 */ lbz r0, data_804508C8(r13)
/* 802D9F4C 28 00 00 00 */ cmplwi r0, 0
/* 802D9F50 40 82 00 24 */ bne lbl_802D9F74
lbl_802D9F54:
/* 802D9F54 57 20 06 3E */ clrlwi r0, r25, 0x18
/* 802D9F58 28 00 00 01 */ cmplwi r0, 1
/* 802D9F5C 40 82 00 10 */ bne lbl_802D9F6C
/* 802D9F60 7F 83 E3 78 */ mr r3, r28
/* 802D9F64 38 80 00 00 */ li r4, 0
/* 802D9F68 4B FF 45 99 */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802D9F6C:
/* 802D9F6C 38 60 00 00 */ li r3, 0
/* 802D9F70 48 00 02 5C */ b lbl_802DA1CC
lbl_802D9F74:
/* 802D9F74 48 07 2A 51 */ bl VIWaitForRetrace
/* 802D9F78 4B FF FF A8 */ b lbl_802D9F20
lbl_802D9F7C:
/* 802D9F7C 7E 63 9B 78 */ mr r3, r19
/* 802D9F80 38 80 00 20 */ li r4, 0x20
/* 802D9F84 48 06 15 FD */ bl DCInvalidateRange
/* 802D9F88 7E 63 9B 78 */ mr r3, r19
/* 802D9F8C 48 00 1D 6D */ bl checkCompressed__9JKRDecompFPUc
/* 802D9F90 2C 03 00 03 */ cmpwi r3, 3
/* 802D9F94 40 82 00 08 */ bne lbl_802D9F9C
/* 802D9F98 38 60 00 00 */ li r3, 0
lbl_802D9F9C:
/* 802D9F9C 2C 03 00 00 */ cmpwi r3, 0
/* 802D9FA0 41 82 00 14 */ beq lbl_802D9FB4
/* 802D9FA4 2C 15 00 02 */ cmpwi r21, 2
/* 802D9FA8 41 82 00 0C */ beq lbl_802D9FB4
/* 802D9FAC 2C 15 00 00 */ cmpwi r21, 0
/* 802D9FB0 40 82 00 90 */ bne lbl_802DA040
lbl_802D9FB4:
/* 802D9FB4 7E 7E C0 50 */ subf r19, r30, r24
/* 802D9FB8 28 1F 00 00 */ cmplwi r31, 0
/* 802D9FBC 41 82 00 10 */ beq lbl_802D9FCC
/* 802D9FC0 7C 1F 98 40 */ cmplw r31, r19
/* 802D9FC4 40 80 00 08 */ bge lbl_802D9FCC
/* 802D9FC8 7F F3 FB 78 */ mr r19, r31
lbl_802D9FCC:
/* 802D9FCC 7F D2 F3 78 */ mr r18, r30
lbl_802D9FD0:
/* 802D9FD0 38 76 00 5C */ addi r3, r22, 0x5c
/* 802D9FD4 7F 84 E3 78 */ mr r4, r28
/* 802D9FD8 7E 65 9B 78 */ mr r5, r19
/* 802D9FDC 7E 46 93 78 */ mr r6, r18
/* 802D9FE0 38 E0 00 02 */ li r7, 2
/* 802D9FE4 48 06 EE 61 */ bl DVDReadPrio
/* 802D9FE8 2C 03 00 00 */ cmpwi r3, 0
/* 802D9FEC 40 80 00 40 */ bge lbl_802DA02C
/* 802D9FF0 2C 03 FF FD */ cmpwi r3, -3
/* 802D9FF4 41 82 00 10 */ beq lbl_802DA004
/* 802D9FF8 88 0D 83 48 */ lbz r0, data_804508C8(r13)
/* 802D9FFC 28 00 00 00 */ cmplwi r0, 0
/* 802DA000 40 82 00 24 */ bne lbl_802DA024
lbl_802DA004:
/* 802DA004 57 20 06 3E */ clrlwi r0, r25, 0x18
/* 802DA008 28 00 00 01 */ cmplwi r0, 1
/* 802DA00C 40 82 00 10 */ bne lbl_802DA01C
/* 802DA010 7F 83 E3 78 */ mr r3, r28
/* 802DA014 38 80 00 00 */ li r4, 0
/* 802DA018 4B FF 44 E9 */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802DA01C:
/* 802DA01C 38 60 00 00 */ li r3, 0
/* 802DA020 48 00 01 AC */ b lbl_802DA1CC
lbl_802DA024:
/* 802DA024 48 07 29 A1 */ bl VIWaitForRetrace
/* 802DA028 4B FF FF A8 */ b lbl_802D9FD0
lbl_802DA02C:
/* 802DA02C 28 17 00 00 */ cmplwi r23, 0
/* 802DA030 41 82 00 08 */ beq lbl_802DA038
/* 802DA034 92 77 00 00 */ stw r19, 0(r23)
lbl_802DA038:
/* 802DA038 7F 83 E3 78 */ mr r3, r28
/* 802DA03C 48 00 01 90 */ b lbl_802DA1CC
lbl_802DA040:
/* 802DA040 2C 03 00 02 */ cmpwi r3, 2
/* 802DA044 40 82 00 28 */ bne lbl_802DA06C
/* 802DA048 7E C3 B3 78 */ mr r3, r22
/* 802DA04C 7F 84 E3 78 */ mr r4, r28
/* 802DA050 7F 05 C3 78 */ mr r5, r24
/* 802DA054 7F E6 FB 78 */ mr r6, r31
/* 802DA058 38 E0 00 00 */ li r7, 0
/* 802DA05C 7F C8 F3 78 */ mr r8, r30
/* 802DA060 7E E9 BB 78 */ mr r9, r23
/* 802DA064 48 00 01 81 */ bl JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl
/* 802DA068 48 00 00 20 */ b lbl_802DA088
lbl_802DA06C:
/* 802DA06C 3C 60 80 3A */ lis r3, JKRDvdRipper__stringBase0@ha /* 0x8039D290@ha */
/* 802DA070 38 63 D2 90 */ addi r3, r3, JKRDvdRipper__stringBase0@l /* 0x8039D290@l */
/* 802DA074 38 80 01 43 */ li r4, 0x143
/* 802DA078 38 A3 00 11 */ addi r5, r3, 0x11
/* 802DA07C 38 C3 00 14 */ addi r6, r3, 0x14
/* 802DA080 4C C6 31 82 */ crclr 6
/* 802DA084 48 00 81 79 */ bl panic_f__12JUTExceptionFPCciPCce
lbl_802DA088:
/* 802DA088 7F 83 E3 78 */ mr r3, r28
/* 802DA08C 48 00 01 40 */ b lbl_802DA1CC
lbl_802DA090:
/* 802DA090 2C 1B 00 01 */ cmpwi r27, 1
/* 802DA094 40 82 00 D0 */ bne lbl_802DA164
/* 802DA098 28 1E 00 00 */ cmplwi r30, 0
/* 802DA09C 41 82 00 20 */ beq lbl_802DA0BC
/* 802DA0A0 3C 60 80 3A */ lis r3, JKRDvdRipper__stringBase0@ha /* 0x8039D290@ha */
/* 802DA0A4 38 63 D2 90 */ addi r3, r3, JKRDvdRipper__stringBase0@l /* 0x8039D290@l */
/* 802DA0A8 38 80 01 4D */ li r4, 0x14d
/* 802DA0AC 38 A3 00 11 */ addi r5, r3, 0x11
/* 802DA0B0 38 C3 00 38 */ addi r6, r3, 0x38
/* 802DA0B4 4C C6 31 82 */ crclr 6
/* 802DA0B8 48 00 81 45 */ bl panic_f__12JUTExceptionFPCciPCce
lbl_802DA0BC:
/* 802DA0BC 38 76 00 5C */ addi r3, r22, 0x5c
/* 802DA0C0 7F A4 EB 78 */ mr r4, r29
/* 802DA0C4 7F 05 C3 78 */ mr r5, r24
/* 802DA0C8 38 C0 00 00 */ li r6, 0
/* 802DA0CC 38 E0 00 02 */ li r7, 2
/* 802DA0D0 48 06 ED 75 */ bl DVDReadPrio
/* 802DA0D4 2C 03 00 00 */ cmpwi r3, 0
/* 802DA0D8 40 80 00 4C */ bge lbl_802DA124
/* 802DA0DC 2C 03 FF FD */ cmpwi r3, -3
/* 802DA0E0 41 82 00 10 */ beq lbl_802DA0F0
/* 802DA0E4 88 0D 83 48 */ lbz r0, data_804508C8(r13)
/* 802DA0E8 28 00 00 00 */ cmplwi r0, 0
/* 802DA0EC 40 82 00 30 */ bne lbl_802DA11C
lbl_802DA0F0:
/* 802DA0F0 57 20 06 3E */ clrlwi r0, r25, 0x18
/* 802DA0F4 28 00 00 01 */ cmplwi r0, 1
/* 802DA0F8 40 82 00 10 */ bne lbl_802DA108
/* 802DA0FC 7F 83 E3 78 */ mr r3, r28
/* 802DA100 38 80 00 00 */ li r4, 0
/* 802DA104 4B FF 43 FD */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802DA108:
/* 802DA108 7F A3 EB 78 */ mr r3, r29
/* 802DA10C 38 80 00 00 */ li r4, 0
/* 802DA110 4B FF 43 F1 */ bl free__7JKRHeapFPvP7JKRHeap
/* 802DA114 38 60 00 00 */ li r3, 0
/* 802DA118 48 00 00 B4 */ b lbl_802DA1CC
lbl_802DA11C:
/* 802DA11C 48 07 28 A9 */ bl VIWaitForRetrace
/* 802DA120 4B FF FF 9C */ b lbl_802DA0BC
lbl_802DA124:
/* 802DA124 7F A3 EB 78 */ mr r3, r29
/* 802DA128 7F 04 C3 78 */ mr r4, r24
/* 802DA12C 48 06 14 55 */ bl DCInvalidateRange
/* 802DA130 7F A3 EB 78 */ mr r3, r29
/* 802DA134 7F 84 E3 78 */ mr r4, r28
/* 802DA138 7F 45 D3 78 */ mr r5, r26
/* 802DA13C 7F C6 F3 78 */ mr r6, r30
/* 802DA140 48 00 18 49 */ bl orderSync__9JKRDecompFPUcPUcUlUl
/* 802DA144 7F A3 EB 78 */ mr r3, r29
/* 802DA148 38 80 00 00 */ li r4, 0
/* 802DA14C 4B FF 43 B5 */ bl free__7JKRHeapFPvP7JKRHeap
/* 802DA150 28 17 00 00 */ cmplwi r23, 0
/* 802DA154 41 82 00 08 */ beq lbl_802DA15C
/* 802DA158 93 57 00 00 */ stw r26, 0(r23)
lbl_802DA15C:
/* 802DA15C 7F 83 E3 78 */ mr r3, r28
/* 802DA160 48 00 00 6C */ b lbl_802DA1CC
lbl_802DA164:
/* 802DA164 2C 1B 00 02 */ cmpwi r27, 2
/* 802DA168 40 82 00 4C */ bne lbl_802DA1B4
/* 802DA16C 7E C3 B3 78 */ mr r3, r22
/* 802DA170 7F 84 E3 78 */ mr r4, r28
/* 802DA174 7F 05 C3 78 */ mr r5, r24
/* 802DA178 7F 46 D3 78 */ mr r6, r26
/* 802DA17C 7F C7 F3 78 */ mr r7, r30
/* 802DA180 39 00 00 00 */ li r8, 0
/* 802DA184 7E E9 BB 78 */ mr r9, r23
/* 802DA188 48 00 00 5D */ bl JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl
/* 802DA18C 28 03 00 00 */ cmplwi r3, 0
/* 802DA190 41 82 00 1C */ beq lbl_802DA1AC
/* 802DA194 57 20 06 3F */ clrlwi. r0, r25, 0x18
/* 802DA198 41 82 00 10 */ beq lbl_802DA1A8
/* 802DA19C 7F 83 E3 78 */ mr r3, r28
/* 802DA1A0 38 80 00 00 */ li r4, 0
/* 802DA1A4 4B FF 43 5D */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802DA1A8:
/* 802DA1A8 3B 80 00 00 */ li r28, 0
lbl_802DA1AC:
/* 802DA1AC 7F 83 E3 78 */ mr r3, r28
/* 802DA1B0 48 00 00 1C */ b lbl_802DA1CC
lbl_802DA1B4:
/* 802DA1B4 57 20 06 3F */ clrlwi. r0, r25, 0x18
/* 802DA1B8 41 82 00 10 */ beq lbl_802DA1C8
/* 802DA1BC 7F 83 E3 78 */ mr r3, r28
/* 802DA1C0 38 80 00 00 */ li r4, 0
/* 802DA1C4 4B FF 43 3D */ bl free__7JKRHeapFPvP7JKRHeap
lbl_802DA1C8:
/* 802DA1C8 38 60 00 00 */ li r3, 0
lbl_802DA1CC:
/* 802DA1CC 39 61 00 C0 */ addi r11, r1, 0xc0
/* 802DA1D0 48 08 80 2D */ bl _restgpr_18
/* 802DA1D4 80 01 00 C4 */ lwz r0, 0xc4(r1)
/* 802DA1D8 7C 08 03 A6 */ mtlr r0
/* 802DA1DC 38 21 00 C0 */ addi r1, r1, 0xc0
/* 802DA1E0 4E 80 00 20 */ blr

23
asm/JSystem/JKernel/JKRDvdRipper/func_802DA820.s
View File

@ -1,23 +0,0 @@
lbl_802DA820:
/* 802DA820 94 21 FF F0 */ stwu r1, -0x10(r1)
/* 802DA824 7C 08 02 A6 */ mflr r0
/* 802DA828 90 01 00 14 */ stw r0, 0x14(r1)
/* 802DA82C 93 E1 00 0C */ stw r31, 0xc(r1)
/* 802DA830 93 C1 00 08 */ stw r30, 8(r1)
/* 802DA834 7C 7E 1B 79 */ or. r30, r3, r3
/* 802DA838 7C 9F 23 78 */ mr r31, r4
/* 802DA83C 41 82 00 1C */ beq lbl_802DA858
/* 802DA840 38 80 00 00 */ li r4, 0
/* 802DA844 48 00 16 69 */ bl __dt__10JSUPtrListFv
/* 802DA848 7F E0 07 35 */ extsh. r0, r31
/* 802DA84C 40 81 00 0C */ ble lbl_802DA858
/* 802DA850 7F C3 F3 78 */ mr r3, r30
/* 802DA854 4B FF 44 E9 */ bl __dl__FPv
lbl_802DA858:
/* 802DA858 7F C3 F3 78 */ mr r3, r30
/* 802DA85C 83 E1 00 0C */ lwz r31, 0xc(r1)
/* 802DA860 83 C1 00 08 */ lwz r30, 8(r1)
/* 802DA864 80 01 00 14 */ lwz r0, 0x14(r1)
/* 802DA868 7C 08 03 A6 */ mtlr r0
/* 802DA86C 38 21 00 10 */ addi r1, r1, 0x10
/* 802DA870 4E 80 00 20 */ blr

73
asm/JSystem/JKernel/JKRDvdRipper/nextSrcData__FPUc.s
View File

@ -1,73 +0,0 @@
lbl_802DA6D8:
/* 802DA6D8 94 21 FF E0 */ stwu r1, -0x20(r1)
/* 802DA6DC 7C 08 02 A6 */ mflr r0
/* 802DA6E0 90 01 00 24 */ stw r0, 0x24(r1)
/* 802DA6E4 39 61 00 20 */ addi r11, r1, 0x20
/* 802DA6E8 48 08 7A F1 */ bl _savegpr_28
/* 802DA6EC 7C 64 1B 78 */ mr r4, r3
/* 802DA6F0 80 0D 8E AC */ lwz r0, szpEnd(r13)
/* 802DA6F4 7F A4 00 50 */ subf r29, r4, r0
/* 802DA6F8 57 A5 06 FF */ clrlwi. r5, r29, 0x1b
/* 802DA6FC 41 82 00 14 */ beq lbl_802DA710
/* 802DA700 80 6D 8E A8 */ lwz r3, szpBuf(r13)
/* 802DA704 38 03 00 20 */ addi r0, r3, 0x20
/* 802DA708 7F 85 00 50 */ subf r28, r5, r0
/* 802DA70C 48 00 00 08 */ b lbl_802DA714
lbl_802DA710:
/* 802DA710 83 8D 8E A8 */ lwz r28, szpBuf(r13)
lbl_802DA714:
/* 802DA714 7F 83 E3 78 */ mr r3, r28
/* 802DA718 7F A5 EB 78 */ mr r5, r29
/* 802DA71C 4B D2 8E 25 */ bl memcpy
/* 802DA720 7F BC EA 14 */ add r29, r28, r29
/* 802DA724 80 0D 8E AC */ lwz r0, szpEnd(r13)
/* 802DA728 7F DD 00 50 */ subf r30, r29, r0
/* 802DA72C 80 0D 8E C0 */ lwz r0, transLeft(r13)
/* 802DA730 7C 1E 00 40 */ cmplw r30, r0
/* 802DA734 40 81 00 08 */ ble lbl_802DA73C
/* 802DA738 7C 1E 03 78 */ mr r30, r0
lbl_802DA73C:
/* 802DA73C 3C 60 80 2E */ lis r3, isErrorRetry__12JKRDvdRipperFv@ha /* 0x802DA7D4@ha */
/* 802DA740 3B E3 A7 D4 */ addi r31, r3, isErrorRetry__12JKRDvdRipperFv@l /* 0x802DA7D4@l */
lbl_802DA744:
/* 802DA744 80 6D 8E C8 */ lwz r3, srcFile(r13)
/* 802DA748 38 63 00 5C */ addi r3, r3, 0x5c
/* 802DA74C 7F A4 EB 78 */ mr r4, r29
/* 802DA750 7F C5 F3 78 */ mr r5, r30
/* 802DA754 80 CD 8E BC */ lwz r6, srcOffset(r13)
/* 802DA758 38 E0 00 02 */ li r7, 2
/* 802DA75C 48 06 E6 E9 */ bl DVDReadPrio
/* 802DA760 2C 03 00 00 */ cmpwi r3, 0
/* 802DA764 40 80 00 24 */ bge lbl_802DA788
/* 802DA768 2C 03 FF FD */ cmpwi r3, -3
/* 802DA76C 41 82 00 0C */ beq lbl_802DA778
/* 802DA770 28 1F 00 00 */ cmplwi r31, 0
/* 802DA774 40 82 00 0C */ bne lbl_802DA780
lbl_802DA778:
/* 802DA778 38 60 00 00 */ li r3, 0
/* 802DA77C 48 00 00 40 */ b lbl_802DA7BC
lbl_802DA780:
/* 802DA780 48 07 22 45 */ bl VIWaitForRetrace
/* 802DA784 4B FF FF C0 */ b lbl_802DA744
lbl_802DA788:
/* 802DA788 7F A3 EB 78 */ mr r3, r29
/* 802DA78C 7F C4 F3 78 */ mr r4, r30
/* 802DA790 48 06 0D F1 */ bl DCInvalidateRange
/* 802DA794 80 0D 8E BC */ lwz r0, srcOffset(r13)
/* 802DA798 7C 00 F2 14 */ add r0, r0, r30
/* 802DA79C 90 0D 8E BC */ stw r0, srcOffset(r13)
/* 802DA7A0 80 0D 8E C0 */ lwz r0, transLeft(r13)
/* 802DA7A4 7C 1E 00 51 */ subf. r0, r30, r0
/* 802DA7A8 90 0D 8E C0 */ stw r0, transLeft(r13)
/* 802DA7AC 40 82 00 0C */ bne lbl_802DA7B8
/* 802DA7B0 7C 1D F2 14 */ add r0, r29, r30
/* 802DA7B4 90 0D 8E C4 */ stw r0, srcLimit(r13)
lbl_802DA7B8:
/* 802DA7B8 7F 83 E3 78 */ mr r3, r28
lbl_802DA7BC:
/* 802DA7BC 39 61 00 20 */ addi r11, r1, 0x20
/* 802DA7C0 48 08 7A 65 */ bl _restgpr_28
/* 802DA7C4 80 01 00 24 */ lwz r0, 0x24(r1)
/* 802DA7C8 7C 08 03 A6 */ mtlr r0
/* 802DA7CC 38 21 00 20 */ addi r1, r1, 0x20
/* 802DA7D0 4E 80 00 20 */ blr

4
defs/module0.py
View File

@ -22084,7 +22084,7 @@ SYMBOLS = [
{'addr':0x804508B0,'size':8,'pad':0,'label':"data_804508B0",'name':None,'lib':15,'tu':426,'section':6,'class_template':None,'static':False,'is_reachable':True,'r':[0,2,0],'sh':[0,0,0],'type':"ArbitraryData"},
{'addr':0x804508B8,'size':4,'pad':4,'label':"sSZSBufferSize__7JKRAram",'name':"sSZSBufferSize__7JKRAram",'lib':16,'tu':436,'section':6,'class_template':False,'static':False,'is_reachable':True,'r':[1,1,0],'sh':[0,0,0],'type':"Integer"},
{'addr':0x804508C0,'size':2,'pad':6,'label':"rootPath",'name':"rootPath$2498",'lib':16,'tu':441,'section':6,'class_template':None,'static':True,'is_reachable':True,'r':[1,0,0],'sh':[0,0,0],'type':"ArbitraryData"},
{'addr':0x804508C8,'size':4,'pad':0,'label':"data_804508C8",'name':None,'lib':16,'tu':452,'section':6,'class_template':None,'static':True,'is_reachable':True,'r':[3,0,0],'sh':[0,0,0],'type':"Integer"},
{'addr':0x804508C8,'size':4,'pad':0,'label':"errorRetry",'name':None,'lib':16,'tu':452,'section':6,'class_template':None,'static':True,'is_reachable':True,'r':[3,0,0],'sh':[0,0,0],'type':"Integer"},
{'addr':0x804508CC,'size':4,'pad':0,'label':"sSZSBufferSize__12JKRDvdRipper",'name':"sSZSBufferSize__12JKRDvdRipper",'lib':16,'tu':452,'section':6,'class_template':False,'static':False,'is_reachable':True,'r':[1,1,0],'sh':[0,0,0],'type':"Integer"},
{'addr':0x804508D0,'size':4,'pad':0,'label':"data_804508D0",'name':None,'lib':16,'tu':453,'section':6,'class_template':None,'static':True,'is_reachable':True,'r':[3,0,0],'sh':[0,0,0],'type':"Integer"},
{'addr':0x804508D4,'size':4,'pad':0,'label':"sSZSBufferSize__16JKRDvdAramRipper",'name':"sSZSBufferSize__16JKRDvdAramRipper",'lib':16,'tu':453,'section':6,'class_template':False,'static':False,'is_reachable':True,'r':[1,1,0],'sh':[0,0,0],'type':"Integer"},
@ -48576,7 +48576,7 @@ SYMBOL_NAMES = {
"data_804508B0":21301,
"sSZSBufferSize__7JKRAram":21302,
"rootPath":21303,
"data_804508C8":21304,
"errorRetry":21304,
"sSZSBufferSize__12JKRDvdRipper":21305,
"data_804508D0":21306,
"sSZSBufferSize__16JKRDvdAramRipper":21307,

5
include/JSystem/JKernel/JKRArchive.h
View File

@ -40,9 +40,8 @@ inline u16 read_big_endian_u16(void* ptr) {
return ((u16)uptr[0] << 8) | ((u16)uptr[1]);
}
inline u32 JKRDecompExpandSize(SArcHeader* header) {
u8* fileLength = (u8*)&header->file_length;
return read_big_endian_u32(fileLength);
inline u32 JKRDecompExpandSize(u8 * pBuf) {
return (pBuf[4] << 0x18) | (pBuf[5] << 0x10) | (pBuf[6] << 8) | pBuf[7];
}
extern u32 sCurrentDirID__10JKRArchive; // JKRArchive::sCurrentDirID

7
include/JSystem/JKernel/JKRDecomp.h
View File

@ -63,4 +63,11 @@ inline JKRDecomp* JKRCreateDecompManager(long priority) {
return JKRDecomp::create(priority);
}
inline JKRCompression JKRCheckCompressed_noASR(u8 *pBuf) {
JKRCompression compression = JKRDecomp::checkCompressed(pBuf);
if (compression == COMPRESSION_ASR) // ternary i had before was either incorrect, or was not a ternary at all
compression = COMPRESSION_NONE;
return compression;
}
#endif /* JKRDECOMP_H */

4
include/JSystem/JKernel/JKRDvdAramRipper.h
View File

@ -50,4 +50,8 @@ public:
static u32 sSZSBufferSize;
};
inline JKRAramBlock *JKRDvdToAram(s32 entrynum, u32 p2, JKRExpandSwitch expSwitch, u32 p4, u32 p5, u32 *p6) {
return JKRDvdAramRipper::loadToAram(entrynum, p2, expSwitch, p4, p5, p6);
}
#endif /* JKRDVDARAMRIPPER_H */

10
include/JSystem/JKernel/JKRDvdRipper.h
View File

@ -2,6 +2,7 @@
#define JKRDVDRIPPER_H
#include "JSystem/JKernel/JKRCompression.h"
#include "JSystem/JSupport/JSUList.h"
#include "dolphin/types.h"
enum JKRExpandSwitch {
@ -15,12 +16,16 @@ struct SYaz0Header {
u32 length;
};
class JKRDMCommand {
JKRDMCommand();
~JKRDMCommand();
};
class JKRHeap;
class JKRDvdFile;
class JKRDvdRipper {
public:
// TODO: fix type
static u8 sDvdAsyncList[12];
static JSUList<JKRDMCommand> sDvdAsyncList;
static u32 sSZSBufferSize;
enum EAllocDirection {
@ -39,6 +44,7 @@ public:
u32, JKRCompression*, u32*);
static u8 isErrorRetry(void);
inline static u32 getSZSBufferSize() { return sSZSBufferSize; }
};
// void JKRDecompressFromDVD(JKRDvdFile*, void*, u32, u32, u32, u32, u32*);

3
include/dolphin/types.h
View File

@ -29,6 +29,9 @@ typedef int BOOL;
#define TRUE 1
#define FALSE 0
#define READU32_BE(ptr, offset) \
(((u32)ptr[offset] << 24) | ((u32)ptr[offset + 1] << 16) | ((u32)ptr[offset + 2] << 8) | (u32)ptr[offset + 3]);
#include "MSL_C/MSL_Common/Src/stddef.h"
#define INT32_MAX (0x7fffffff)

151
libs/JSystem/JKernel/JKRAramArchive.cpp
View File

@ -154,107 +154,100 @@ inline u32 alignNext(u32 var, u32 align) {
}
/* 802D72A8-802D75E0 2D1BE8 0338+00 1/1 0/0 0/0 .text open__14JKRAramArchiveFl */
#ifdef NONMATCHING
// r30 <-> r29
bool JKRAramArchive::open(s32 entryNum) {
mArcInfoBlock = NULL;
mNodes = NULL;
mFiles = NULL;
mStringTable = NULL;
mBlock = NULL;
// int align;
// int align = -4;
// if (mMountDirection == MOUNT_DIRECTION_HEAD) {
// align = 4;
// }
int align;
align = mMountDirection == MOUNT_DIRECTION_HEAD ? 4 : -4;
mDvdFile = new (JKRGetSystemHeap(), align) JKRDvdFile(entryNum);
if (mDvdFile == NULL) {
mMountMode = UNKNOWN_MOUNT_MODE;
return false;
mDvdFile = new (JKRGetSystemHeap(), mMountDirection == MOUNT_DIRECTION_HEAD ? 4 : -4) JKRDvdFile(entryNum);
if (mDvdFile == NULL)
{
mMountMode = 0;
return 0;
}
SArcHeader* header = static_cast<SArcHeader*>(JKRAllocFromSysHeap(0x20, -0x20));
if (header == NULL) {
mMountMode = UNKNOWN_MOUNT_MODE;
} else {
JKRDvdToMainRam(entryNum, (u8*)header, EXPAND_SWITCH_UNKNOWN1, 0x20, NULL,
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 0, &mCompression, NULL);
DCInvalidateRange(header, 0x20);
align = mMountDirection == MOUNT_DIRECTION_HEAD ? 0x20 : -0x20;
u32 blockSize = alignNext(header->file_data_offset, 0x20);
mArcInfoBlock = static_cast<SArcDataInfo*>(JKRAllocFromHeap(mHeap, blockSize, align));
// NOTE: a different struct is used here for sure, unfortunately i can't get any hits on this address, so gonna leave it like this for now
SArcHeader *mem = (SArcHeader *)JKRAllocFromSysHeap(32, -32);
if (mem == NULL) {
mMountMode = 0;
}
else {
JKRDvdToMainRam(entryNum, (u8 *)mem, EXPAND_SWITCH_UNKNOWN1, 32, NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 0, &mCompression, NULL);
DCInvalidateRange(mem, 32);
int alignment = mMountDirection == MOUNT_DIRECTION_HEAD ? 32 : -32;
u32 alignedSize = ALIGN_NEXT(mem->file_data_offset, 32);
mArcInfoBlock = (SArcDataInfo *)JKRAllocFromHeap(mHeap, alignedSize, alignment);
if (mArcInfoBlock == NULL) {
mMountMode = UNKNOWN_MOUNT_MODE;
} else {
JKRDvdToMainRam(entryNum, (u8*)mArcInfoBlock, EXPAND_SWITCH_UNKNOWN1, blockSize, NULL,
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 0x20, NULL, NULL);
DCInvalidateRange(mArcInfoBlock, blockSize);
mNodes = (SDIDirEntry*)((s32)mArcInfoBlock + mArcInfoBlock->node_offset);
mFiles = (SDIFileEntry*)((s32)mArcInfoBlock + mArcInfoBlock->file_entry_offset);
mStringTable = (char*)((s32)mArcInfoBlock + mArcInfoBlock->string_table_offset);
mMountMode = 0;
}
else {
JKRDvdToMainRam(entryNum, (u8 *)mArcInfoBlock, EXPAND_SWITCH_UNKNOWN1, alignedSize, NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 32, NULL, NULL);
DCInvalidateRange(mArcInfoBlock, alignedSize);
mNodes = (SDIDirEntry *)((u8 *)mArcInfoBlock + mArcInfoBlock->node_offset);
mFiles = (SDIFileEntry *)((u8 *)mArcInfoBlock + mArcInfoBlock->file_entry_offset);
mStringTable = (char *)((u8 *)mArcInfoBlock + mArcInfoBlock->string_table_offset);
mExpandedSize = NULL;
u8 isAnyFileCompressed = 0;
SDIFileEntry* file = mFiles;
for (int i = 0; i < mArcInfoBlock->num_file_entries; file++, i++) {
if (file->isUnknownFlag1()) {
isAnyFileCompressed |= file->getCompressFlag();
u8 compressedFiles = 0; // maybe a check for if the last file is compressed?
SDIFileEntry *fileEntry = mFiles;
for (int i = 0; i < mArcInfoBlock->num_file_entries; i++)
{
u8 flag = fileEntry->type_flags_and_name_offset >> 24;
if ((flag & 1))
{
compressedFiles |= (flag & JKRARCHIVE_ATTR_COMPRESSION);
}
fileEntry++;
}
if (isAnyFileCompressed != 0) {
mExpandedSize =
(s32*)JKRAllocFromHeap(mHeap, mArcInfoBlock->num_file_entries * 4, abs(align));
if (mExpandedSize == NULL) {
if (compressedFiles != 0)
{
mExpandedSize = (s32 *)JKRAllocFromHeap(mHeap, mArcInfoBlock->num_file_entries << 2, abs(alignment));
if (mExpandedSize == NULL)
{
i_JKRFree(mArcInfoBlock);
mMountMode = UNKNOWN_MOUNT_MODE;
goto end;
} else {
memset(mExpandedSize, 0, mArcInfoBlock->num_file_entries * 4);
mMountMode = 0;
goto cleanup;
}
memset(mExpandedSize, 0, mArcInfoBlock->num_file_entries << 2);
}
u32 fileDataLength = alignNext(header->file_data_length, 0x20);
mBlock = static_cast<JKRAramBlock*>(JKRAllocFromAram(
fileDataLength,
mMountDirection == MOUNT_DIRECTION_HEAD ? JKRAramHeap::HEAD : JKRAramHeap::TAIL));
if (mBlock == NULL) {
if (mArcInfoBlock != NULL) {
u32 aramSize = ALIGN_NEXT(mem->file_data_length, 32);
mBlock = (JKRAramBlock*) JKRAllocFromAram(aramSize, mMountDirection == MOUNT_DIRECTION_HEAD ? JKRAramHeap::HEAD : JKRAramHeap::TAIL);
if(mBlock == NULL) {
if (mArcInfoBlock) {
i_JKRFree(mArcInfoBlock);
}
if (mExpandedSize != NULL) {
if(mExpandedSize) {
i_JKRFree(mExpandedSize);
}
mMountMode = UNKNOWN_MOUNT_MODE;
} else {
JKRDvdAramRipper::loadToAram(entryNum, mBlock->getAddress(), EXPAND_SWITCH_UNKNOWN1,
header->header_length + header->file_data_offset, 0,
NULL);
mMountMode = 0;
}
else {
JKRDvdToAram(entryNum, mBlock->getAddress(), EXPAND_SWITCH_UNKNOWN1, mem->header_length + mem->file_data_offset, 0, NULL);
}
}
}
end:
if (header != NULL) {
JKRFreeToSysHeap(header);
cleanup:
if (mem != NULL)
{
JKRFreeToSysHeap(mem);
}
if (mMountMode == UNKNOWN_MOUNT_MODE) {
if (mDvdFile != NULL) {
if (mMountMode == 0)
{
if (mDvdFile != NULL)
{
delete mDvdFile;
}
return false;
} else {
return true;
}
return true;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm bool JKRAramArchive::open(s32 param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRAramArchive/open__14JKRAramArchiveFl.s"
}
#pragma pop
#endif
/* 802D75E0-802D76F4 2D1F20 0114+00 1/0 0/0 0/0 .text
* fetchResource__14JKRAramArchiveFPQ210JKRArchive12SDIFileEntryPUl */
@ -396,10 +389,10 @@ u32 JKRAramArchive::fetchResource_subroutine(u32 entryNum, u32 length, JKRHeap*
case COMPRESSION_YAY0:
case COMPRESSION_YAZ0:
u8 tmpBuf[0x40];
SArcHeader* buf = (SArcHeader*)ALIGN_PREV((s32)&tmpBuf[0x1F], 0x20);
JKRAramToMainRam(entryNum, (u8*)buf, 0x20, EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL);
length = alignNext(JKRDecompExpandSize(buf), 0x20);
tmpBufAligned = static_cast<u8*>(JKRAllocFromHeap(pHeap, length, 0x20));
u8* buf = (u8*)ALIGN_PREV((s32)&tmpBuf[0x1F], sizeof(SArcHeader));
JKRAramToMainRam(entryNum, buf, sizeof(SArcHeader), EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL);
length = alignNext(JKRDecompExpandSize(buf), sizeof(SArcHeader));
tmpBufAligned = static_cast<u8*>(JKRAllocFromHeap(pHeap, length, sizeof(SArcHeader)));
JKRAramToMainRam(entryNum, tmpBufAligned, alignedLen, EXPAND_SWITCH_UNKNOWN1, length, pHeap,
-1, &readLen);
@ -443,8 +436,8 @@ u32 JKRAramArchive::getExpandedResSize(void const* ptr) const {
}
u8 tmpBuf[0x40];
SArcHeader* buf = (SArcHeader*)ALIGN_PREV((s32)&tmpBuf[0x1F], 0x20);
JKRAramToMainRam(entry->data_offset + mBlock->getAddress(), (u8*)buf, 0x20,
u8* buf = (u8*)ALIGN_PREV((s32)&tmpBuf[0x1F], 0x20);
JKRAramToMainRam(entry->data_offset + mBlock->getAddress(), buf, 0x20,
EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL);
expandSize = JKRDecompExpandSize(buf);
// ??? casting away const?

31
libs/JSystem/JKernel/JKRAramHeap.cpp
View File

@ -11,18 +11,10 @@
// Forward References:
//
extern "C" u8 sAramList__11JKRAramHeap[12];
extern "C" void* __vt__11JKRAramHeap;
//
// External References:
//
extern "C" void __dl__FPv();
extern "C" void __dt__11JKRDisposerFv();
extern "C" void _savegpr_29();
extern "C" void _restgpr_29();
//
// Declarations:
//
@ -45,28 +37,13 @@ JKRAramHeap::JKRAramHeap(u32 startAddress, u32 size) {
}
/* 802D2F14-802D2FBC 2CD854 00A8+00 1/0 0/0 0/0 .text __dt__11JKRAramHeapFv */
// close match, regalloc problem in the beginning of the while loop
#ifdef NONMATCHING
JKRAramHeap::~JKRAramHeap() {
JSUList<JKRAramBlock>* list = &sAramList;
JSUListIterator<JKRAramBlock> iterator = list;
while (iterator != list->getEnd()) {
JSUListIterator<JKRAramBlock> prev = iterator;
JKRAramBlock* block = prev.getObject();
delete block;
JSUListIterator<JKRAramBlock> iterator(sAramList.getFirst());
while (iterator != sAramList.getEnd())
{
delete (iterator++).getObject();
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm JKRAramHeap::~JKRAramHeap() {
nofralloc
#include "asm/JSystem/JKernel/JKRAramHeap/__dt__11JKRAramHeapFv.s"
}
#pragma pop
#endif
/* 802D2FBC-802D3034 2CD8FC 0078+00 0/0 5/5 0/0 .text
* alloc__11JKRAramHeapFUlQ211JKRAramHeap10EAllocMode */

77
libs/JSystem/JKernel/JKRDecomp.cpp
View File

@ -171,20 +171,18 @@ void JKRDecomp::decode(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 dstLengt
}
/* 802DBA58-802DBC14 2D6398 01BC+00 1/1 0/0 0/0 .text decodeSZP__9JKRDecompFPUcPUcUlUl */
// 2 extra mr instructions
#ifdef NONMATCHING
void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
// s32 decodedSize;
s32 srcChunkOffset;
u32 count;
s32 dstOffset;
u32 length;
s32 linkInfo;
s32 offset;
s32 i;
s32 decodedSize = read_big_endian_u32(src + 4);
s32 linkTableOffset = read_big_endian_u32(src + 8);
s32 srcDataOffset = read_big_endian_u32(src + 12);
int srcChunkOffset;
int count;
int dstOffset;
u32 length = srcLength;
int linkInfo;
int offset;
int i;
int decodedSize = READU32_BE(src, 4);
int linkTableOffset = READU32_BE(src, 8);
int srcDataOffset = READU32_BE(src, 12);
dstOffset = 0;
u32 counter = 0;
@ -196,47 +194,58 @@ void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
if (dstLength > decodedSize)
return;
length = srcLength;
do {
if (counter == 0) {
chunkBits = read_big_endian_u32(src + srcChunkOffset);
do
{
if (counter == 0)
{
chunkBits = READU32_BE(src, srcChunkOffset);
srcChunkOffset += sizeof(u32);
counter = sizeof(u32) * 8;
}
if (chunkBits & 0x80000000) {
if (dstLength == 0) {
if (chunkBits & 0x80000000)
{
if (dstLength == 0)
{
dst[dstOffset] = src[srcDataOffset];
length--;
if (length == 0)
return;
} else {
}
else
{
dstLength--;
}
dstOffset++;
srcDataOffset++;
} else {
}
else
{
linkInfo = src[linkTableOffset] << 8 | src[linkTableOffset + 1];
linkTableOffset += sizeof(u16);
offset = dstOffset - (linkInfo & 0xFFF);
count = (linkInfo >> 12);
if (count == 0) {
count = (u32)src[srcDataOffset] + 0x12;
srcDataOffset++;
} else
if (count == 0)
{
count = (u32)src[srcDataOffset++] + 0x12;
}
else
count += 2;
if ((s32)count > decodedSize - dstOffset)
if (count > decodedSize - dstOffset)
count = decodedSize - dstOffset;
for (i = 0; i < (s32)count; i++, dstOffset++, offset++) {
if (dstLength == 0) {
for (i = 0; i < count; i++, dstOffset++, offset++)
{
if (dstLength == 0)
{
dst[dstOffset] = dst[offset - 1];
length--;
if (length == 0)
return;
} else
}
else
dstLength--;
}
}
@ -245,16 +254,6 @@ void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
counter--;
} while (dstOffset < decodedSize);
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void JKRDecomp::decodeSZP(u8* param_0, u8* param_1, u32 param_2, u32 param_3) {
nofralloc
#include "asm/JSystem/JKernel/JKRDecomp/decodeSZP__9JKRDecompFPUcPUcUlUl.s"
}
#pragma pop
#endif
/* 802DBC14-802DBCF8 2D6554 00E4+00 1/1 0/0 0/0 .text decodeSZS__9JKRDecompFPUcPUcUlUl */
#ifdef NONMATCHING

14
libs/JSystem/JKernel/JKRDvdArchive.cpp
View File

@ -313,8 +313,8 @@ u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size,
// The dst pointer to JKRDvdToMainRam should be aligned to 32 bytes. This will align
// arcHeader to 32 bytes on the stack.
char arcHeaderBuffer[64];
SArcHeader* arcHeader = (SArcHeader*)ALIGN_NEXT((u32)arcHeaderBuffer, 0x20);
JKRDvdToMainRam(entryNum, (u8*)arcHeader, EXPAND_SWITCH_UNKNOWN2, sizeof(SArcHeader),
u8* arcHeader = (u8*)ALIGN_NEXT((u32)arcHeaderBuffer, 0x20);
JKRDvdToMainRam(entryNum, arcHeader, EXPAND_SWITCH_UNKNOWN2, sizeof(SArcHeader),
NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
DCInvalidateRange(arcHeader, sizeof(SArcHeader));
@ -380,8 +380,8 @@ u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size,
// The dst pointer to JKRDvdToMainRam should be aligned to 32 bytes. This will align
// arcHeader to 32 bytes on the stack.
char arcHeaderBuffer[64];
SArcHeader* arcHeader = (SArcHeader*)ALIGN_NEXT((u32)arcHeaderBuffer, 0x20);
JKRDvdToMainRam(entryNum, (u8*)arcHeader, EXPAND_SWITCH_UNKNOWN2, sizeof(SArcHeader),
u8* arcHeader = (u8*)ALIGN_NEXT((u32)arcHeaderBuffer, 0x20);
JKRDvdToMainRam(entryNum, arcHeader, EXPAND_SWITCH_UNKNOWN2, sizeof(SArcHeader),
NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
DCInvalidateRange(arcHeader, sizeof(SArcHeader));
@ -444,11 +444,11 @@ u32 JKRDvdArchive::getExpandedResSize(const void* resource) const {
// The dst pointer to JKRDvdToMainRam should be aligned to 32 bytes. This will align arcHeader
// to 32 bytes on the stack.
char buffer[64];
SArcHeader* arcHeader = (SArcHeader*)ALIGN_NEXT((u32)buffer, 0x20);
JKRDvdToMainRam(mEntryNum, (u8*)arcHeader, EXPAND_SWITCH_UNKNOWN2, sizeof(*arcHeader), NULL,
u8* arcHeader = (u8*)ALIGN_NEXT((u32)buffer, 0x20);
JKRDvdToMainRam(mEntryNum, arcHeader, EXPAND_SWITCH_UNKNOWN2, sizeof(SArcHeader), NULL,
JKRDvdRipper::ALLOC_DIRECTION_FORWARD,
this->field_0x64 + fileEntry->data_offset, NULL, NULL);
DCInvalidateRange(arcHeader, sizeof(*arcHeader));
DCInvalidateRange(arcHeader, sizeof(SArcHeader));
resourceSize = JKRDecompExpandSize(arcHeader);
// ???

597
libs/JSystem/JKernel/JKRDvdRipper.cpp
View File

@ -5,11 +5,14 @@
#include "JSystem/JKernel/JKRDvdRipper.h"
#include "JSystem/JKernel/JKRDvdFile.h"
#include "JSystem/JKernel/JKRDecomp.h"
#include "JSystem/JUtility/JUTException.h"
#include "JSystem/JKernel/JKRArchive.h"
#include "MSL_C/string.h"
#include "dol2asm.h"
#include "dolphin/os/OSCache.h"
#include "dolphin/os/OSInterrupt.h"
#include "dolphin/vi/vi.h"
#include "global.h"
//
@ -21,54 +24,10 @@ static int decompSZS_subroutine(u8*, u8*);
static u8* firstSrcData();
static u8* nextSrcData(u8*);
extern "C" void
loadToMainRAM__12JKRDvdRipperFPCcPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl();
extern "C" void
loadToMainRAM__12JKRDvdRipperFlPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl();
extern "C" void
loadToMainRAM__12JKRDvdRipperFP10JKRDvdFilePUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl();
extern "C" static int JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl();
extern "C" static int decompSZS_subroutine__FPUcPUc();
extern "C" static u8* firstSrcData__Fv();
extern "C" static u8* nextSrcData__FPUc();
extern "C" u8 isErrorRetry__12JKRDvdRipperFv();
extern "C" void __sinit_JKRDvdRipper_cpp();
extern "C" void func_802DA820(void* _this);
extern "C" extern char const* const JKRDvdRipper__stringBase0;
extern "C" u8 sDvdAsyncList__12JKRDvdRipper[12];
extern "C" u32 sSZSBufferSize__12JKRDvdRipper;
//
// External References:
//
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void alloc__7JKRHeapFUli();
extern "C" void free__7JKRHeapFPvP7JKRHeap();
extern "C" void __dl__FPv();
extern "C" void __ct__10JKRDvdFileFv();
extern "C" void __dt__10JKRDvdFileFv();
extern "C" void open__10JKRDvdFileFPCc();
extern "C" void open__10JKRDvdFileFl();
extern "C" void orderSync__9JKRDecompFPUcPUcUlUl();
extern "C" void checkCompressed__9JKRDecompFPUc();
extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void panic_f__12JUTExceptionFPCciPCce();
extern "C" void VIWaitForRetrace();
extern "C" void __register_global_object();
extern "C" void _savegpr_18();
extern "C" void _savegpr_23();
extern "C" void _savegpr_24();
extern "C" void _savegpr_28();
extern "C" void _savegpr_29();
extern "C" void _restgpr_18();
extern "C" void _restgpr_23();
extern "C" void _restgpr_24();
extern "C" void _restgpr_28();
extern "C" void _restgpr_29();
extern "C" u8 sSystemHeap__7JKRHeap[4];
//
// Declarations:
//
@ -116,208 +75,204 @@ SECTION_DEAD static char const* const pad_8039D2E9 = "\0\0\0\0\0\0";
#pragma pop
/* 804508C8-804508CC 000348 0004+00 3/2 0/0 0/0 .sdata None */
SECTION_SDATA static u8 data_804508C8 = 0x01;
SECTION_SDATA static u8 errorRetry = 0x01;
/* 802D9D10-802DA1E4 2D4650 04D4+00 2/2 0/0 0/0 .text
* loadToMainRAM__12JKRDvdRipperFP10JKRDvdFilePUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
*/
#ifdef NONMATCHING
void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch expandSwitch,
u32 dstLength, JKRHeap* heap,
JKRDvdRipper::EAllocDirection allocDirection, u32 offset,
int* pCompression, u32* param_8) {
bool did_alloc = false;
int compression = 0;
u8* mem = NULL;
u32 fileSizeAligned = ALIGN_NEXT(dvdFile->getFileSize(), 0x20);
u32 r26;
if (expandSwitch == EXPAND_SWITCH_UNKNOWN1) {
s32 fileSizeAligned;
bool hasAllocated = false;
JKRCompression compression = COMPRESSION_NONE;
u32 expandSize;
u8 *mem = NULL;
fileSizeAligned = ALIGN_NEXT(dvdFile->getFileSize(), 32);
if (expandSwitch == EXPAND_SWITCH_UNKNOWN1)
{
u8 buffer[0x40];
u8* bufPtr = (u8*)ALIGN_NEXT((u32)buffer, 0x20);
while (true) {
s32 count = DVDReadPrio(dvdFile->getFileInfo(), bufPtr, 0x20, 0, 2);
if (count >= 0) {
u8 *bufPtr = (u8 *)ALIGN_NEXT((u32)buffer, 32);
while (true)
{
int readBytes = DVDReadPrio(dvdFile->getFileInfo(), bufPtr, 0x20, 0, 2);
if (readBytes >= 0)
break;
}
if (count == -3 || !data_804508C8) {
if (readBytes == -3 || errorRetry == false)
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(bufPtr, 0x20);
compression = JKRDecomp::checkCompressed(bufPtr);
if (compression == 3) {
compression = 0;
}
r26 = (bufPtr[4] << 0x18) | (bufPtr[5] << 0x10) | (bufPtr[6] << 0x08) | (bufPtr[7]);
compression = JKRCheckCompressed_noASR(bufPtr);
expandSize = JKRDecompExpandSize(bufPtr);
}
if (pCompression) {
*pCompression = compression;
}
if (pCompression)
*pCompression = (int)compression;
if (expandSwitch == EXPAND_SWITCH_UNKNOWN1 && compression) {
if (dstLength != 0 && r26 > dstLength) {
r26 = dstLength;
}
if (!dst) {
dst = (u8*)JKRHeap::alloc(r26, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20,
heap);
did_alloc = true;
}
if (!dst) {
return NULL;
}
if (compression == 1) {
mem = (u8*)JKRHeap::alloc(fileSizeAligned, 0x20, heap);
if (mem == NULL && did_alloc == true) {
JKRHeap::free(dst, NULL);
return NULL;
}
}
} else {
if (!dst) {
u32 var2 = fileSizeAligned - offset;
if (dstLength != 0 && var2 > dstLength) {
var2 = dstLength;
}
dst = (u8*)JKRHeap::alloc(
var2, allocDirection == ALLOC_DIRECTION_FORWARD ? 0x20 : -0x20, heap);
did_alloc = true;
}
if (!dst) {
return NULL;
}
}
if (compression == 0) {
int count = 0;
if (offset != 0) {
u8 buffer[0x40];
u8* bufPtr = (u8*)ALIGN_NEXT((u32)buffer, 0x20);
while (true) {
count = DVDReadPrio(dvdFile->getFileInfo(), bufPtr, 0x20, offset, 2);
if (count >= 0) {
break;
}
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
}
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(bufPtr, 0x20);
count = JKRDecomp::checkCompressed(bufPtr);
if (count == 3) {
count = 0;
}
}
if (count == 0 || expandSwitch == EXPAND_SWITCH_UNKNOWN2 ||
expandSwitch == EXPAND_SWITCH_UNKNOWN0)
if (expandSwitch == EXPAND_SWITCH_UNKNOWN1 && compression != COMPRESSION_NONE)
{
if (dstLength != 0 && expandSize > dstLength)
{
fileSizeAligned -= offset;
if (dstLength != 0 && dstLength < fileSizeAligned) {
fileSizeAligned = dstLength;
}
while (true) {
count = DVDReadPrio(dvdFile->getFileInfo(), dst, fileSizeAligned, offset, 2);
if (count >= 0) {
break;
expandSize = dstLength;
}
if (dst == NULL)
{
dst = (u8 *)JKRAllocFromHeap(heap, expandSize, allocDirection == ALLOC_DIRECTION_FORWARD ? 32 : -32);
hasAllocated = true;
}
if (dst == NULL)
return NULL;
if (compression == COMPRESSION_YAY0)
{
mem = (u8 *)JKRAllocFromHeap((heap), fileSizeAligned, 32);
if (mem == NULL)
{
if (hasAllocated == true)
{
i_JKRFree(dst);
return NULL;
}
}
}
}
else
{
if (dst == NULL)
{
u32 size = fileSizeAligned - offset;
if ((dstLength != 0) && (size > dstLength))
size = dstLength;
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
dst = (u8 *)JKRAllocFromHeap(heap, size, allocDirection == ALLOC_DIRECTION_FORWARD ? 32 : -32);
hasAllocated = true;
}
if (dst == NULL)
return NULL;
}
if (compression == COMPRESSION_NONE)
{
JKRCompression compression2 = COMPRESSION_NONE; // maybe for a sub archive?
if (offset != 0)
{
u8 buffer[0x40];
u8 *bufPtr = (u8 *)ALIGN_NEXT((u32)buffer, 32);
while (true)
{
int readBytes = DVDReadPrio(dvdFile->getFileInfo(), bufPtr, 32, (s32)offset, 2);
if (readBytes >= 0)
break;
if (readBytes == -3 || !errorRetry)
{
if (hasAllocated == true)
{
i_JKRFree(dst);
}
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(bufPtr, 32);
if (param_8) {
*param_8 = fileSizeAligned;
compression2 = JKRCheckCompressed_noASR(bufPtr);
}
if ((compression2 == COMPRESSION_NONE || expandSwitch == EXPAND_SWITCH_UNKNOWN2) || expandSwitch == EXPAND_SWITCH_UNKNOWN0)
{
s32 size = fileSizeAligned - offset;
if (dstLength != 0 && dstLength < size)
size = dstLength; // probably a ternary
while (true)
{
int readBytes = DVDReadPrio(dvdFile->getFileInfo(), dst, size, (s32)offset, 2);
if (readBytes >= 0)
break;
if (readBytes == -3 || !errorRetry)
{
if (hasAllocated == true)
i_JKRFree(dst);
return NULL;
}
VIWaitForRetrace();
}
if (param_8)
{
*param_8 = size;
}
return dst;
} else if (count == 2) {
}
else if (compression2 == COMPRESSION_YAZ0)
{
JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, dstLength, 0, offset, param_8);
} else {
JUTException::panic_f(__FILE__, 0x143, "%s", "Sorry, not applied for SZP archive.");
}
return dst;
} else if (compression == 1) {
if (offset) {
}
else if (compression == COMPRESSION_YAY0)
{
// SZP decompression
// s32 readoffset = startOffset;
if (offset != 0)
{
JUTException::panic_f(__FILE__, 0x14d, "%s", "Not support SZP with offset read");
}
while (true) {
int count = DVDReadPrio(dvdFile->getFileInfo(), mem, fileSizeAligned, 0, 2);
if (count >= 0) {
while (true)
{
int readBytes = DVDReadPrio(dvdFile->getFileInfo(), mem, fileSizeAligned, 0, 2);
if (readBytes >= 0)
break;
}
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
}
if (readBytes == -3 || !errorRetry)
{
if (hasAllocated == true)
i_JKRFree(dst);
JKRHeap::free(mem, NULL);
i_JKRFree(mem);
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(mem, fileSizeAligned);
JKRDecomp::orderSync(mem, dst, r26, offset);
JKRHeap::free(mem, NULL);
if (param_8) {
*param_8 = r26;
JKRDecompress(mem, dst, expandSize, offset);
i_JKRFree(mem);
if (param_8)
{
*param_8 = expandSize;
}
return dst;
} else if (compression == 2) {
if (JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, r26, offset, 0, param_8)) {
if (did_alloc) {
JKRHeap::free(dst, NULL);
}
}
else if (compression == COMPRESSION_YAZ0)
{
if (JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, expandSize, offset, 0, param_8) != 0u)
{
if (hasAllocated)
i_JKRFree(dst);
dst = NULL;
}
return dst;
} else {
if (did_alloc) {
JKRHeap::free(dst, NULL);
}
return NULL;
}
else if (hasAllocated)
{
i_JKRFree(dst);
dst = NULL;
}
return NULL;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* param_0, u8* param_1, JKRExpandSwitch param_2,
u32 param_3, JKRHeap* param_4,
JKRDvdRipper::EAllocDirection param_5, u32 param_6,
int* param_7, u32* param_8) {
nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/func_802D9D10.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 80434378-80434384 061098 000C+00 1/1 0/0 0/0 .bss @491 */
static u8 lit_491[12];
/* 80434384-80434390 0610A4 000C+00 1/1 0/0 0/0 .bss sDvdAsyncList__12JKRDvdRipper */
u8 JKRDvdRipper::sDvdAsyncList[12];
JSUList<JKRDMCommand> JKRDvdRipper::sDvdAsyncList;
/* 80434390-804343A8 0610B0 0018+00 1/1 0/0 0/0 .bss decompMutex */
static OSMutex decompMutex;
@ -372,91 +327,86 @@ static u32 tsArea;
/* 802DA1E4-802DA35C 2D4B24 0178+00 1/1 0/0 0/0 .text
* JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl */
// wrong reg at the end
#ifdef NONMATCHING
static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u32 param_3,
u32 param_4, u32 param_5, u32* param_6) {
BOOL level = OSDisableInterrupts();
if (!data_80451458) {
static int JKRDecompressFromDVD(JKRDvdFile* dvdFile, void* dst, u32 fileSize, u32 inMaxDest,
u32 inFileOffset, u32 inSrcOffset, u32* inTsPtr) {
BOOL interrupts = OSDisableInterrupts();
if (data_80451458 == false)
{
OSInitMutex(&decompMutex);
data_80451458 = true;
}
OSRestoreInterrupts(level);
OSRestoreInterrupts(interrupts);
OSLockMutex(&decompMutex);
u32 bufferSize = JKRDvdRipper::sSZSBufferSize;
szpBuf = (u8*)JKRHeap::sSystemHeap->alloc(bufferSize, -0x20);
szpEnd = szpBuf + bufferSize;
int bufSize = JKRDvdRipper::getSZSBufferSize();
szpBuf = (u8 *)JKRAllocFromSysHeap(bufSize, -0x20);
if (param_4) {
refBuf = (u8*)JKRHeap::sSystemHeap->alloc(0x1120, -4);
szpEnd = szpBuf + bufSize;
if (inFileOffset != 0)
{
refBuf = (u8 *)JKRAllocFromSysHeap(0x1120, -4);
refEnd = refBuf + 0x1120;
refCurrent = refBuf;
} else {
}
else
{
refBuf = NULL;
}
srcFile = dvdFile;
srcOffset = param_5;
transLeft = fileSize - param_5;
fileOffset = param_4;
srcOffset = inSrcOffset;
transLeft = fileSize - inSrcOffset;
fileOffset = inFileOffset;
readCount = 0;
maxDest = param_3;
if (!param_6) {
maxDest = inMaxDest;
if (!inTsPtr)
{
tsPtr = &tsArea;
} else {
tsPtr = param_6;
}
else
{
tsPtr = inTsPtr;
}
*tsPtr = 0;
u8* first = firstSrcData();
int result = first ? decompSZS_subroutine(first, (u8*)dst) : -1;
u8 *data = firstSrcData();
u32 result = (data != NULL) ? decompSZS_subroutine(data, (u8 *)dst) : -1; // figure out correct datatypes
i_JKRFree(szpBuf);
if (refBuf) {
if (refBuf)
{
i_JKRFree(refBuf);
}
DCStoreRangeNoSync(dst, *tsPtr);
OSUnlockMutex(&decompMutex);
return result;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm int JKRDecompressFromDVD(JKRDvdFile* param_0, void* param_1, u32 param_2, u32 param_3,
u32 param_4, u32 param_5, u32* param_6) {
nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl.s"
}
#pragma pop
#endif
/* 802DA35C-802DA60C 2D4C9C 02B0+00 1/1 0/0 0/0 .text decompSZS_subroutine__FPUcPUc */
#ifdef NONMATCHING
int decompSZS_subroutine(u8* src, u8* dest) {
int validBitCount = 0;
u32 currCodeByte = 0;
u8 *endPtr;
s32 validBitCount = 0;
s32 currCodeByte = 0;
u32 ts = 0;
if (src[0] != 'Y' || src[1] != 'a' || src[2] != 'z' || src[3] != '0') {
if (src[0] != 'Y' || src[1] != 'a' || src[2] != 'z' || src[3] != '0')
{
return -1;
}
SYaz0Header* header = (SYaz0Header*)src;
u8* endPtr = dest + (header->length - fileOffset);
if (endPtr > dest + maxDest) {
SYaz0Header *header = (SYaz0Header *)src;
endPtr = dest + (header->length - fileOffset);
if (endPtr > dest + maxDest)
{
endPtr = dest + maxDest;
}
src += 0x10;
do {
if (validBitCount == 0) {
if ((src > srcLimit) && transLeft) {
do
{
if (validBitCount == 0)
{
if ((src > srcLimit) && transLeft)
{
src = nextSrcData(src);
if (!src) {
if (!src)
{
return -1;
}
}
@ -464,77 +414,104 @@ int decompSZS_subroutine(u8* src, u8* dest) {
validBitCount = 8;
src++;
}
if (currCodeByte & 0x80) {
if (fileOffset != 0) {
if (readCount >= fileOffset) {
if (currCodeByte & 0x80)
{
if (fileOffset != 0)
{
if (readCount >= fileOffset)
{
*dest = *src;
dest++;
ts++;
if (dest == endPtr) {
if (dest == endPtr)
{
break;
}
}
*(refCurrent++) = *src;
if (refCurrent == refEnd) {
if (refCurrent == refEnd)
{
refCurrent = refBuf;
}
src++;
} else {
}
else
{
*dest = *src;
dest++;
src++;
ts++;
if (dest == endPtr) {
if (dest == endPtr)
{
break;
}
}
readCount++;
} else {
}
else
{
u32 dist = ((src[0] & 0x0f) << 8) | src[1];
s32 numBytes = src[0] >> 4;
src += 2;
u8* copySource;
if (fileOffset != 0) {
u8 *copySource;
if (fileOffset != 0)
{
copySource = refCurrent - dist - 1;
if (copySource < refBuf) {
if (copySource < refBuf)
{
copySource += refEnd - refBuf;
}
} else {
}
else
{
copySource = dest - dist - 1;
}
if (numBytes == 0) {
if (numBytes == 0)
{
numBytes = *src + 0x12;
src += 1;
} else {
}
else
{
numBytes += 2;
}
if (fileOffset != 0) {
do {
if (readCount >= fileOffset) {
if (fileOffset != 0)
{
do
{
if (readCount >= fileOffset)
{
*dest = *copySource;
dest++;
ts++;
if (dest == endPtr) {
if (dest == endPtr)
{
break;
}
}
*(refCurrent++) = *copySource;
if (refCurrent == refEnd) {
if (refCurrent == refEnd)
{
refCurrent = refBuf;
}
copySource++;
if (copySource == refEnd) {
if (copySource == refEnd)
{
copySource = refBuf;
}
readCount++;
numBytes--;
} while (numBytes != 0);
} else {
do {
}
else
{
do
{
*dest = *copySource;
dest++;
ts++;
if (dest == endPtr) {
if (dest == endPtr)
{
break;
}
readCount++;
@ -549,16 +526,6 @@ int decompSZS_subroutine(u8* src, u8* dest) {
*tsPtr = ts;
return 0;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm int decompSZS_subroutine(u8* param_0, u8* param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/decompSZS_subroutine__FPUcPUc.s"
}
#pragma pop
#endif
/* 802DA60C-802DA6D8 2D4F4C 00CC+00 1/1 0/0 0/0 .text firstSrcData__Fv */
static u8* firstSrcData() {
@ -573,7 +540,7 @@ static u8* firstSrcData() {
break;
}
if (result == -3 || !data_804508C8) {
if (result == -3 || !errorRetry) {
return NULL;
}
VIWaitForRetrace();
@ -586,77 +553,39 @@ static u8* firstSrcData() {
}
/* 802DA6D8-802DA7D4 2D5018 00FC+00 1/1 0/0 0/0 .text nextSrcData__FPUc */
#ifdef NONMATCHING
static u8* nextSrcData(u8* param_0) {
u32 size = szpEnd - param_0;
u8* dest = IS_NOT_ALIGNED(size, 0x20) ? szpBuf + 0x20 - (size & (0x20 - 1)) : szpBuf;
memcpy(dest, param_0, size);
u8* end = dest + size;
u32 transSize = szpEnd - end;
static u8* nextSrcData(u8* src) {
u32 limit = szpEnd - src;
u8 *buf;
if (IS_NOT_ALIGNED(limit, 0x20))
buf = szpBuf + 0x20 - (limit & (0x20 - 1));
else
buf = szpBuf;
if (transSize > transLeft) {
memcpy(buf, src, limit);
u32 transSize = (u32)(szpEnd - (buf + limit));
if (transSize > transLeft)
transSize = transLeft;
}
while (true) {
s32 result = DVDReadPrio(srcFile->getFileInfo(), end, transSize, srcOffset, 2);
if (result >= 0) {
while (true)
{
s32 result = DVDReadPrio(srcFile->getFileInfo(), (buf + limit), transSize, srcOffset, 2);
if (result >= 0)
break;
}
// bug: supposed to call isErrorRetry, but didn't
if (result == -3 || !JKRDvdRipper::isErrorRetry) {
if (result == -3 || !JKRDvdRipper::isErrorRetry)
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(end, transSize);
DCInvalidateRange((buf + limit), transSize);
srcOffset += transSize;
transLeft -= transSize;
if (transLeft == 0)
srcLimit = transSize + (buf + limit);
if (transLeft == 0) {
srcLimit = end + transSize;
}
return dest;
return buf;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm u8* nextSrcData(u8* param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/nextSrcData__FPUc.s"
}
#pragma pop
#endif
/* 802DA7D4-802DA7DC -00001 0008+00 0/0 0/0 0/0 .text isErrorRetry__12JKRDvdRipperFv */
u8 JKRDvdRipper::isErrorRetry() {
return data_804508C8;
return errorRetry;
}
/* 802DA7DC-802DA820 2D511C 0044+00 0/0 1/0 0/0 .text __sinit_JKRDvdRipper_cpp */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __sinit_JKRDvdRipper_cpp(){nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/__sinit_JKRDvdRipper_cpp.s"
}
#pragma pop
#pragma push
#pragma force_active on
REGISTER_CTORS(0x802DA7DC, __sinit_JKRDvdRipper_cpp);
#pragma pop
/* 802DA820-802DA874 2D5160 0054+00 1/1 0/0 0/0 .text __dt__23JSUList<12JKRDMCommand>Fv
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
extern "C" asm void func_802DA820(void* _this) {
nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/func_802DA820.s"
}
#pragma pop

4
libs/JSystem/JKernel/JKRMemArchive.cpp
View File

@ -293,7 +293,7 @@ u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32
case COMPRESSION_YAY0:
case COMPRESSION_YAZ0:
u32 expendedSize = JKRDecompExpandSize((SArcHeader*)src);
u32 expendedSize = JKRDecompExpandSize(src);
srcLength = expendedSize;
if (expendedSize > dstLength) {
srcLength = dstLength;
@ -319,6 +319,6 @@ u32 JKRMemArchive::getExpandedResSize(const void* resource) const {
if (fileEntry->isCompressed() == false) {
return getResSize(resource);
} else {
return JKRDecompExpandSize((SArcHeader*)resource);
return JKRDecompExpandSize((u8*)resource);
}
}