mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-06-16 14:50:21 -04:00
Code Issues Packages Projects Releases Wiki Activity

JKRDvdRipper, JKRSolidHeap (#199)

Browse Source
This commit is contained in:
Jcw87
2022-06-07 13:03:27 -07:00
committed by GitHub
parent 3c962112db
commit fb9dd3cdee
17 changed files with 491 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/JSystem/J3DGraphAnimator/J3DModel.cpp
-1
View File
@@ -80,7 +80,6 @@ extern "C" void calc__15J3DVtxColorCalcFP8J3DModel();
extern "C" void offAllFlag__13J3DDeformDataFUl();
extern "C" void deform__13J3DDeformDataFP8J3DModel();
extern "C" void entryIn__8J3DJointFv();
extern "C" void DCStoreRangeNoSync();
extern "C" void __construct_new_array();
extern "C" void _savegpr_23();
extern "C" void _savegpr_25();
libs/JSystem/JKernel/JKRAram.cpp
+13 -13
View File
@@ -252,13 +252,13 @@ static u8* szpBuf;
static u8* szpEnd;
/* 804513D4-804513D8 0008D4 0004+00 2/2 0/0 0/0 .sbss refBuf */
static u8 refBuf[4];
static u8* refBuf;
/* 804513D8-804513DC 0008D8 0004+00 2/2 0/0 0/0 .sbss refEnd */
static u8 refEnd[4];
static u8* refEnd;
/* 804513DC-804513E0 0008DC 0004+00 2/2 0/0 0/0 .sbss refCurrent */
static u8 refCurrent[4];
static u8* refCurrent;
/* 804513E0-804513E4 0008E0 0004+00 3/3 0/0 0/0 .sbss srcOffset */
static u32 srcOffset;
@@ -267,28 +267,28 @@ static u32 srcOffset;
static u32 transLeft;
/* 804513E8-804513EC 0008E8 0004+00 3/3 0/0 0/0 .sbss srcLimit */
static u32 srcLimit;
static u8* srcLimit;
/* 804513EC-804513F0 0008EC 0004+00 3/3 0/0 0/0 .sbss srcAddress */
static u32 srcAddress;
/* 804513F0-804513F4 0008F0 0004+00 2/2 0/0 0/0 .sbss fileOffset */
static u8 fileOffset[4];
static u32 fileOffset;
/* 804513F4-804513F8 0008F4 0004+00 2/2 0/0 0/0 .sbss readCount */
static u8 readCount[4];
static u32 readCount;
/* 804513F8-804513FC 0008F8 0004+00 2/2 0/0 0/0 .sbss maxDest */
static u8 maxDest[4];
static u32 maxDest;
/* 804513FC-80451400 0008FC 0004+00 1/1 0/0 0/0 .sbss None */
static u8 data_804513FC[4];
/* 80451400-80451404 000900 0004+00 2/2 0/0 0/0 .sbss tsPtr */
static u8 tsPtr[4];
static u32* tsPtr;
/* 80451404-80451408 000904 0004+00 1/1 0/0 0/0 .sbss tsArea */
static u8 tsArea[4];
static u32 tsArea;
/* 802D2830-802D29A0 2CD170 0170+00 1/1 0/0 0/0 .text
* JKRDecompressFromAramToMainRam__FUlPvUlUlUlPUl */
@@ -371,7 +371,7 @@ static asm void JKRDecompressFromAramToMainRam(u32 param_0, void* param_1, u32 p
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void decompSZS_subroutine(u8* param_0, u8* param_1) {
static asm int decompSZS_subroutine(u8* param_0, u8* param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRAram/decompSZS_subroutine__FPUcPUc.s"
}
@@ -379,7 +379,7 @@ static asm void decompSZS_subroutine(u8* param_0, u8* param_1) {
/* 802D2C40-802D2CE4 2CD580 00A4+00 1/1 0/0 0/0 .text firstSrcData__Fv */
static u8* firstSrcData(void) {
srcLimit = (u32)(szpEnd - 0x19);
srcLimit = szpEnd - 0x19;
u8* buffer = szpBuf;
u32 length;
@@ -398,7 +398,7 @@ static u8* firstSrcData(void) {
srcOffset += length;
transLeft -= length;
if (!transLeft) {
srcLimit = (u32)(buffer + length);
srcLimit = buffer + length;
}
return buffer;
@@ -441,7 +441,7 @@ static u8* nextSrcData(u8* current) {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void nextSrcData(u8* param_0) {
static asm u8* nextSrcData(u8* param_0) {
nofralloc
#include "asm/JSystem/JKernel/JKRAram/nextSrcData__FPUc.s"
}
libs/JSystem/JKernel/JKRDvdRipper.cpp
+429 -56
View File
@@ -4,23 +4,33 @@
//
#include "JSystem/JKernel/JKRDvdRipper.h"
#include "JSystem/JKernel/JKRDvdFile.h"
#include "JSystem/JUtility/JUTException.h"
#include "MSL_C/MSL_Common/Src/string.h"
#include "dol2asm.h"
#include "dolphin/os/OSCache.h"
#include "dolphin/types.h"
#include "global.h"
//
// Forward References:
//
static int JKRDecompressFromDVD(JKRDvdFile*, void*, u32, u32, u32, u32, u32*);
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 void JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl();
extern "C" static void decompSZS_subroutine__FPUcPUc();
extern "C" static void firstSrcData__Fv();
extern "C" static void nextSrcData__FPUc();
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);
@@ -32,7 +42,6 @@ extern "C" u32 sSZSBufferSize__12JKRDvdRipper;
// External References:
//
SECTION_INIT void memcpy();
extern "C" void alloc__7JKRHeapFUliP7JKRHeap();
extern "C" void alloc__7JKRHeapFUli();
extern "C" void free__7JKRHeapFPvP7JKRHeap();
@@ -46,8 +55,6 @@ extern "C" void checkCompressed__9JKRDecompFPUc();
extern "C" void __dt__10JSUPtrListFv();
extern "C" void initiate__10JSUPtrListFv();
extern "C" void panic_f__12JUTExceptionFPCciPCce();
extern "C" void DCInvalidateRange();
extern "C" void DCStoreRangeNoSync();
extern "C" void VIWaitForRetrace();
extern "C" void __register_global_object();
extern "C" void _savegpr_18();
@@ -69,32 +76,32 @@ extern "C" u8 sSystemHeap__7JKRHeap[4];
/* 802D9B98-802D9C54 2D44D8 00BC+00 0/0 1/1 0/0 .text
* loadToMainRAM__12JKRDvdRipperFPCcPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void* JKRDvdRipper::loadToMainRAM(char const* 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_802D9B98.s"
void* JKRDvdRipper::loadToMainRAM(char const* name, u8* dst, JKRExpandSwitch expandSwitch,
u32 dstLength, JKRHeap* heap,
JKRDvdRipper::EAllocDirection allocDirection, u32 offset,
int* pCompression, u32* param_8) {
JKRDvdFile file;
if (!file.open(name)) {
return NULL;
}
return loadToMainRAM(&file, dst, expandSwitch, dstLength, heap, allocDirection, offset,
pCompression, param_8);
}
#pragma pop
/* 802D9C54-802D9D10 2D4594 00BC+00 0/0 9/9 0/0 .text
* loadToMainRAM__12JKRDvdRipperFlPUc15JKRExpandSwitchUlP7JKRHeapQ212JKRDvdRipper15EAllocDirectionUlPiPUl
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void* JKRDvdRipper::loadToMainRAM(s32 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_802D9C54.s"
void* JKRDvdRipper::loadToMainRAM(s32 entryNumber, u8* dst, JKRExpandSwitch expandSwitch,
u32 dstLength, JKRHeap* heap,
JKRDvdRipper::EAllocDirection allocDirection, u32 offset,
int* pCompression, u32* param_8) {
JKRDvdFile file;
if (!file.open(entryNumber)) {
return NULL;
}
return loadToMainRAM(&file, dst, expandSwitch, dstLength, heap, allocDirection, offset,
pCompression, param_8);
}
#pragma pop
/* ############################################################################################## */
/* 8039D290-8039D290 0298F0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
@@ -109,11 +116,173 @@ 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 u32 data_804508C8 = 0x01000000;
SECTION_SDATA static u8 data_804508C8 = 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) {
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) {
break;
}
if (count == -3 || !data_804508C8) {
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]);
}
if (pCompression) {
*pCompression = 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) {
fileSizeAligned -= offset;
if (dstLength != 0 && dstLength < fileSizeAligned) {
fileSizeAligned = dstLength;
}
while (true) {
count = DVDReadPrio(dvdFile->getFileInfo(), dst, fileSizeAligned, offset, 2);
if (count >= 0) {
break;
}
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
}
return NULL;
}
VIWaitForRetrace();
}
if (param_8) {
*param_8 = fileSizeAligned;
}
return dst;
} else if (count == 2) {
JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, dstLength, 0, offset, param_8);
} else {
JUTException::panic_f("JKRDvdRipper.cpp", 0x143, "%s",
"Sorry, not applied for SZP archive.");
}
return dst;
} else if (compression == 1) {
if (offset) {
JUTException::panic_f("JKRDvdRipper.cpp", 0x14d, "%s",
"Not support SZP with offset read");
}
while (true) {
int count = DVDReadPrio(dvdFile->getFileInfo(), mem, fileSizeAligned, 0, 2);
if (count >= 0) {
break;
}
if (count == -3 || !data_804508C8) {
if (did_alloc == true) {
JKRHeap::free(dst, NULL);
}
JKRHeap::free(mem, NULL);
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(mem, fileSizeAligned);
JKRDecomp::orderSync(mem, dst, r26, offset);
JKRHeap::free(mem, NULL);
if (param_8) {
*param_8 = r26;
}
return dst;
} else if (compression == 2) {
if (JKRDecompressFromDVD(dvdFile, dst, fileSizeAligned, r26, offset, 0, param_8)) {
if (did_alloc) {
JKRHeap::free(dst, NULL);
}
dst = NULL;
}
return dst;
} else {
if (did_alloc) {
JKRHeap::free(dst, NULL);
}
return NULL;
}
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
@@ -125,6 +294,7 @@ asm void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* param_0, u8* param_1, JKRExpan
#include "asm/JSystem/JKernel/JKRDvdRipper/func_802D9D10.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 80434378-80434384 061098 000C+00 1/1 0/0 0/0 .bss @491 */
@@ -134,101 +304,304 @@ static u8 lit_491[12];
u8 JKRDvdRipper::sDvdAsyncList[12];
/* 80434390-804343A8 0610B0 0018+00 1/1 0/0 0/0 .bss decompMutex */
static u8 decompMutex[24];
static OSMutex decompMutex;
/* 804508CC-804508D0 00034C 0004+00 1/1 1/1 0/0 .sdata sSZSBufferSize__12JKRDvdRipper */
SECTION_SDATA u32 JKRDvdRipper::sSZSBufferSize = 0x00000400;
/* 80451428-8045142C 000928 0004+00 3/3 0/0 0/0 .sbss szpBuf */
static u8 szpBuf[4];
static u8* szpBuf;
/* 8045142C-80451430 00092C 0004+00 3/3 0/0 0/0 .sbss szpEnd */
static u8 szpEnd[4];
static u8* szpEnd;
/* 80451430-80451434 000930 0004+00 2/2 0/0 0/0 .sbss refBuf */
static u8 refBuf[4];
static u8* refBuf;
/* 80451434-80451438 000934 0004+00 2/2 0/0 0/0 .sbss refEnd */
static u8 refEnd[4];
static u8* refEnd;
/* 80451438-8045143C 000938 0004+00 2/2 0/0 0/0 .sbss refCurrent */
static u8 refCurrent[4];
static u8* refCurrent;
/* 8045143C-80451440 00093C 0004+00 3/3 0/0 0/0 .sbss srcOffset */
static u8 srcOffset[4];
static u32 srcOffset;
/* 80451440-80451444 000940 0004+00 4/4 0/0 0/0 .sbss transLeft */
static u8 transLeft[4];
static u32 transLeft;
/* 80451444-80451448 000944 0004+00 3/3 0/0 0/0 .sbss srcLimit */
static u8 srcLimit[4];
static u8* srcLimit;
/* 80451448-8045144C 000948 0004+00 3/3 0/0 0/0 .sbss srcFile */
static u8 srcFile[4];
static JKRDvdFile* srcFile;
/* 8045144C-80451450 00094C 0004+00 2/2 0/0 0/0 .sbss fileOffset */
static u8 fileOffset[4];
static u32 fileOffset;
/* 80451450-80451454 000950 0004+00 2/2 0/0 0/0 .sbss readCount */
static u8 readCount[4];
static u32 readCount;
/* 80451454-80451458 000954 0004+00 2/2 0/0 0/0 .sbss maxDest */
static u8 maxDest[4];
static u32 maxDest;
/* 80451458-8045145C 000958 0004+00 1/1 0/0 0/0 .sbss None */
static u8 data_80451458[4];
static bool data_80451458;
/* 8045145C-80451460 00095C 0004+00 2/2 0/0 0/0 .sbss tsPtr */
static u8 tsPtr[4];
static u32* tsPtr;
/* 80451460-80451468 000960 0004+04 1/1 0/0 0/0 .sbss tsArea */
static u8 tsArea[4 + 4 /* padding */];
static u32 tsArea;
/* 802DA1E4-802DA35C 2D4B24 0178+00 1/1 0/0 0/0 .text
* JKRDecompressFromDVD__FP10JKRDvdFilePvUlUlUlUlPUl */
#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) {
OSInitMutex(&decompMutex);
data_80451458 = true;
}
OSRestoreInterrupts(level);
OSLockMutex(&decompMutex);
u32 bufferSize = JKRDvdRipper::sSZSBufferSize;
szpBuf = (u8*)JKRHeap::sSystemHeap->alloc(bufferSize, -0x20);
szpEnd = szpBuf + bufferSize;
if (param_4) {
refBuf = (u8*)JKRHeap::sSystemHeap->alloc(0x1120, -4);
refEnd = refBuf + 0x1120;
refCurrent = refBuf;
} else {
refBuf = NULL;
}
srcFile = dvdFile;
srcOffset = param_5;
transLeft = fileSize - param_5;
fileOffset = param_4;
readCount = 0;
maxDest = param_3;
if (!param_6) {
tsPtr = &tsArea;
} else {
tsPtr = param_6;
}
*tsPtr = 0;
u8* first = firstSrcData();
int result = first ? decompSZS_subroutine(first, (u8*)dst) : -1;
JKRHeap::free(szpBuf, 0);
if (refBuf) {
JKRHeap::free(refBuf, 0);
}
DCStoreRangeNoSync(dst, *tsPtr);
OSUnlockMutex(&decompMutex);
return result;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void JKRDecompressFromDVD(JKRDvdFile* param_0, void* param_1, u32 param_2, u32 param_3,
u32 param_4, u32 param_5, u32* param_6) {
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;
u32 ts = 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) {
endPtr = dest + maxDest;
}
src += 0x10;
do {
if (validBitCount == 0) {
if ((src > srcLimit) && transLeft) {
src = nextSrcData(src);
if (!src) {
return -1;
}
}
currCodeByte = *src;
validBitCount = 8;
src++;
}
if (currCodeByte & 0x80) {
if (fileOffset != 0) {
if (readCount >= fileOffset) {
*dest = *src;
dest++;
ts++;
if (dest == endPtr) {
break;
}
}
*(refCurrent++) = *src;
if (refCurrent == refEnd) {
refCurrent = refBuf;
}
src++;
} else {
*dest = *src;
dest++;
src++;
ts++;
if (dest == endPtr) {
break;
}
}
readCount++;
} else {
u32 dist = ((src[0] & 0x0f) << 8) | src[1];
s32 numBytes = src[0] >> 4;
src += 2;
u8* copySource;
if (fileOffset != 0) {
copySource = refCurrent - dist - 1;
if (copySource < refBuf) {
copySource += refEnd - refBuf;
}
} else {
copySource = dest - dist - 1;
}
if (numBytes == 0) {
numBytes = *src + 0x12;
src += 1;
} else {
numBytes += 2;
}
if (fileOffset != 0) {
do {
if (readCount >= fileOffset) {
*dest = *copySource;
dest++;
ts++;
if (dest == endPtr) {
break;
}
}
*(refCurrent++) = *copySource;
if (refCurrent == refEnd) {
refCurrent = refBuf;
}
copySource++;
if (copySource == refEnd) {
copySource = refBuf;
}
readCount++;
numBytes--;
} while (numBytes != 0);
} else {
do {
*dest = *copySource;
dest++;
ts++;
if (dest == endPtr) {
break;
}
readCount++;
numBytes--;
copySource++;
} while (numBytes != 0);
}
}
currCodeByte <<= 1;
validBitCount--;
} while (dest < endPtr);
*tsPtr = ts;
return 0;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void decompSZS_subroutine(u8* param_0, u8* param_1) {
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 */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm u8* firstSrcData() {
nofralloc
#include "asm/JSystem/JKernel/JKRDvdRipper/firstSrcData__Fv.s"
static u8* firstSrcData() {
srcLimit = szpEnd - 0x19;
u8* buffer = szpBuf;
u32 bufSize = szpEnd - buffer;
u32 length = transLeft < bufSize ? transLeft : bufSize;
while (true) {
int result = DVDReadPrio(srcFile->getFileInfo(), buffer, length, srcOffset, 2);
if (result >= 0) {
break;
}
if (result == -3 || !data_804508C8) {
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(buffer, length);
srcOffset += length;
transLeft -= length;
return buffer;
}
#pragma pop
/* 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;
if (transSize > transLeft) {
transSize = transLeft;
}
while (true) {
s32 result = DVDReadPrio(srcFile->getFileInfo(), end, transSize, srcOffset, 2);
if (result >= 0) {
break;
}
// bug: supposed to call isErrorRetry, but didn't
if (result == -3 || !JKRDvdRipper::isErrorRetry) {
return NULL;
}
VIWaitForRetrace();
}
DCInvalidateRange(end, transSize);
srcOffset += transSize;
transLeft -= transSize;
if (transLeft == 0) {
srcLimit = end + transSize;
}
return dest;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
static asm void nextSrcData(u8* param_0) {
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 *(u8*)(&data_804508C8);
return data_804508C8;
}
/* 802DA7DC-802DA820 2D511C 0044+00 0/0 1/0 0/0 .text __sinit_JKRDvdRipper_cpp */
libs/JSystem/JKernel/JKRFileCache.cpp
+3 -3
View File
@@ -222,14 +222,14 @@ void* JKRFileCache::getResource(const char* path) {
CCacheBlock* cacheBlock = findCacheBlock(dvdFile.getFileID());
if (!cacheBlock) {
// dvdFile.getFileSize() not inlined
u32 fileSize = dvdFile.getFileInfo().length;
u32 fileSize = dvdFile.getFileInfo()->length;
u32 alignedSize = ALIGN_NEXT(fileSize, 0x20);
buffer = JKRAllocFromHeap(mParentHeap, alignedSize, 0x20);
if (buffer) {
dvdFile.read(buffer, alignedSize, 0);
cacheBlock = new (JKRHeap::getSystemHeap(), 0)
CCacheBlock(dvdFile.getFileID(), dvdFile.getFileInfo().length, buffer);
CCacheBlock(dvdFile.getFileID(), dvdFile.getFileInfo()->length, buffer);
mCacheBlockList.append(&cacheBlock->mCacheBlockLink);
}
} else {
@@ -273,7 +273,7 @@ u32 JKRFileCache::readResource(void* dst, u32 dstLength, const char* path) {
loop:
if (dvdFile.isAvailable()) {
// dvdFile.getFileSize() not inlined
u32 fileSize = dvdFile.getFileInfo().length;
u32 fileSize = dvdFile.getFileInfo()->length;
resourceSize = ALIGN_NEXT(fileSize, 0x20);
dstLength = ALIGN_PREV(dstLength, 0x20);
if (resourceSize > dstLength) {
libs/JSystem/JKernel/JKRSolidHeap.cpp
+28 -64
View File
@@ -121,40 +121,27 @@ JKRSolidHeap::~JKRSolidHeap(void) {
}
/* 802D0BF4-802D0CB0 2CB534 00BC+00 0/0 5/5 1/1 .text adjustSize__12JKRSolidHeapFv */
#ifdef NONMATCHING
s32 JKRSolidHeap::adjustSize(void) {
JKRHeap* parent = getParent();
if (parent) {
lock();
s32 start = mStart;
s32 newSize = (s32)this->mSolidHead - ALIGN_NEXT(start, 0x20);
s32 newSizeThis = newSize + (start - (s32)this);
s32 actualSize = parent->resize(this, newSizeThis);
if (actualSize != -1) {
u32 thisSize = (u32)mStart - (u32)this;
u32 newSize = ALIGN_NEXT(mSolidHead - mStart, 0x20);
if (parent->resize(this, thisSize + newSize) != -1) {
mFreeSize = 0;
mSize = newSize;
mEnd = mStart + mSize;
mSolidHead = (void*)mEnd;
mSolidTail = (void*)mEnd;
mSolidHead = mEnd;
mSolidTail = mEnd;
}
unlock();
return newSizeThis;
return thisSize + newSize;
}
return -1;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm s32 JKRSolidHeap::adjustSize() {
nofralloc
#include "asm/JSystem/JKernel/JKRSolidHeap/adjustSize__12JKRSolidHeapFv.s"
}
#pragma pop
#endif
/* 802D0CB0-802D0D58 2CB5F0 00A8+00 1/0 0/0 0/0 .text do_alloc__12JKRSolidHeapFUli */
void* JKRSolidHeap::do_alloc(u32 size, int alignment) {
@@ -190,28 +177,14 @@ void* JKRSolidHeap::do_alloc(u32 size, int alignment) {
return ptr;
}
/* ############################################################################################## */
/* 8039CE50-8039CE50 0294B0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CE50 =
"allocFromHead: cannot alloc memory (0x%x byte).\n";
#pragma pop
/* 802D0D58-802D0E20 2CB698 00C8+00 1/1 0/0 0/0 .text allocFromHead__12JKRSolidHeapFUli
*/
#ifdef NONMATCHING
void* JKRSolidHeap::allocFromHead(u32 size, int alignment) {
void* ptr;
u32 offset;
u32 alignedSize;
u32 alignedStart;
u32 totalSize;
alignedSize = ALIGN_NEXT(size, 0x4);
ptr = NULL;
alignedStart = (alignment - 1 + (u32)mSolidHead) & ~(alignment - 1);
offset = alignedStart - (u32)mSolidHead;
totalSize = alignedSize + offset;
size = ALIGN_NEXT(size, 0x4);
void* ptr = NULL;
u32 alignedStart = (alignment - 1 + (u32)mSolidHead) & ~(alignment - 1);
u32 offset = alignedStart - (u32)mSolidHead;
u32 totalSize = size + offset;
if (totalSize <= mFreeSize) {
ptr = (void*)alignedStart;
mSolidHead += totalSize;
@@ -219,41 +192,32 @@ void* JKRSolidHeap::allocFromHead(u32 size, int alignment) {
} else {
JUTWarningConsole_f("allocFromHead: cannot alloc memory (0x%x byte).\n", totalSize);
if (getErrorFlag() == true) {
callErrorHandler(this, alignedSize, alignment);
callErrorHandler(this, size, alignment);
}
}
return ptr;
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void* JKRSolidHeap::allocFromHead(u32 param_0, int param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRSolidHeap/allocFromHead__12JKRSolidHeapFUli.s"
}
#pragma pop
#endif
/* ############################################################################################## */
/* 8039CE50-8039CE50 0294B0 0000+00 0/0 0/0 0/0 .rodata @stringBase0 */
#pragma push
#pragma force_active on
SECTION_DEAD static char const* const stringBase_8039CE81 =
"allocFromTail: cannot alloc memory (0x%x byte).\n";
#pragma pop
/* 802D0E20-802D0EE4 2CB760 00C4+00 1/1 0/0 0/0 .text allocFromTail__12JKRSolidHeapFUli
*/
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void* JKRSolidHeap::allocFromTail(u32 param_0, int param_1) {
nofralloc
#include "asm/JSystem/JKernel/JKRSolidHeap/allocFromTail__12JKRSolidHeapFUli.s"
void* JKRSolidHeap::allocFromTail(u32 size, int alignment) {
size = ALIGN_NEXT(size, 4);
void* ptr = NULL;
u32 alignedStart = ALIGN_PREV((u32)mSolidTail - size, alignment);
u32 totalSize = (u32)mSolidTail - (u32)alignedStart;
if (totalSize <= mFreeSize) {
ptr = (void*)alignedStart;
mSolidTail -= totalSize;
mFreeSize -= totalSize;
} else {
JUTWarningConsole_f("allocFromTail: cannot alloc memory (0x%x byte).\n", totalSize);
if (getErrorFlag() == true) {
callErrorHandler(this, size, alignment);
}
}
return ptr;
}
#pragma pop
/* 802D0EE4-802D0F14 2CB824 0030+00 1/0 0/0 0/0 .text do_free__12JKRSolidHeapFPv */
void JKRSolidHeap::do_free(void* ptr) {
libs/dolphin/os/OSCache.cpp
+1 -2
View File
@@ -15,7 +15,6 @@
extern "C" static void DCEnable();
extern "C" void DCFlushRange();
extern "C" void DCFlushRangeNoSync();
extern "C" void DCStoreRangeNoSync();
extern "C" void DCZeroRange();
extern "C" void ICInvalidateRange();
extern "C" void ICFlashInvalidate();
@@ -106,7 +105,7 @@ asm void DCFlushRangeNoSync() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void DCStoreRangeNoSync() {
asm void DCStoreRangeNoSync(void*, u32) {
nofralloc
#include "asm/dolphin/os/OSCache/DCStoreRangeNoSync.s"
}