mirror of
https://github.com/encounter/tp.git
synced 2026-07-11 06:18:46 -07:00
JKRAram and JKRAramStream (#80)
* before __register_global_object * JKRThread::sThreadList, JKRHeap::sSystemHeap, etc. * cleanup and started on JKRDvdArchive * before changing JKRCompression * more JKRDvdArchive, abs, and memset * fixed JKRArchive::setExpandSize split * JKRArchive::sCurrentDirID, JKRDvdFile::sDvdList, and matching JKRDvdFile constructors * problems * merge fixes and formatting * updated clang version in clang-format-all to version 10 * Added OSPhysicalToCached and struct for global memory * remove useless __attribute__ * changed from defines and macros to const variable and function * changed FLAG_HAS to FLAG_ON * JKRAram, linking problems * fix JKRAram * remove nonmatching stuff * renamed static data * more static class members * JKRAramStream OK * formatting Co-authored-by: Julgodis <> Co-authored-by: Pheenoh <pheenoh@gmail.com>
This commit is contained in:
Jonathan Wase
co-authored by
Julgodis <>
Pheenoh
Julgodis <>
Pheenoh
parent
8bd3d07e23
commit
82d5e0f796
@@ -1,34 +1,132 @@
|
||||
#include "JSystem/JKernel/JKRAram/JKRAram.h"
|
||||
#include "JSystem/JKernel/JKRAramBlock/JKRAramBlock.h"
|
||||
#include "JSystem/JKernel/JKRAramHeap/JKRAramHeap.h"
|
||||
#include "JSystem/JKernel/JKRAramPiece/JKRAramPiece.h"
|
||||
#include "JSystem/JKernel/JKRAramStream/JKRAramStream.h"
|
||||
#include "JSystem/JKernel/JKRDecomp/JKRDecomp.h"
|
||||
#include "JSystem/JKernel/JKRExpHeap/JKRExpHeap.h"
|
||||
#include "JSystem/JKernel/JKRHeap/JKRHeap.h"
|
||||
#include "global.h"
|
||||
|
||||
asm void JKRAram::create(u32, u32, long, long, long) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D1FA4.s"
|
||||
// Uncomment when static initialization is working
|
||||
// JKRAram* JKRAram::sAramObject = NULL;
|
||||
// u32 JKRAram::sSZSBufferSize = 0x400;
|
||||
|
||||
static void decompSZS_subroutine(u8*, u8*);
|
||||
static u8* firstSrcData(void);
|
||||
static u8* nextSrcData(u8*);
|
||||
|
||||
// The prefix JKRAram__ is for now used to skip name collision in 'sbss.s'. All of these variables
|
||||
// are probably defined as static and only visible in this translation unit.
|
||||
extern u8* JKRAram__szpBuf;
|
||||
extern u8* JKRAram__szpEnd;
|
||||
extern u8* JKRAram__refBuf;
|
||||
extern u8* JKRAram__refEnd;
|
||||
extern u8* JKRAram__refCurrent;
|
||||
extern u32 JKRAram__srcOffset;
|
||||
extern u32 JKRAram__transLeft;
|
||||
extern u32 JKRAram__srcLimit;
|
||||
extern u32 JKRAram__srcAddress;
|
||||
extern u32 JKRAram__fileOffset;
|
||||
extern u32 JKRAram__readCount;
|
||||
extern u32 JKRAram__maxDest;
|
||||
extern u32* JKRAram__tsPtr;
|
||||
extern u32 JKRAram__tsArea;
|
||||
|
||||
JKRAram* JKRAram::create(u32 aram_audio_buffer_size, u32 aram_audio_graph_size,
|
||||
long stream_priority, long decomp_priority, long piece_priority) {
|
||||
if (!sAramObject) {
|
||||
sAramObject = new (JKRHeap::getSystemHeap(), 0)
|
||||
JKRAram(aram_audio_buffer_size, aram_audio_graph_size, piece_priority);
|
||||
}
|
||||
|
||||
JKRCreateAramStreamManager(stream_priority);
|
||||
JKRCreateDecompManager(decomp_priority);
|
||||
sAramObject->resume();
|
||||
return sAramObject;
|
||||
}
|
||||
|
||||
asm JKRAram::JKRAram(u32, u32, long) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D2040.s"
|
||||
JKRAram::JKRAram(u32 audio_buffer_size, u32 audio_graph_size, long priority)
|
||||
: JKRThread(0xC00, 0x10, priority) {
|
||||
u32 aramBase = ARInit(mStackArray, ARRAY_SIZE(mStackArray));
|
||||
ARQInit();
|
||||
|
||||
u32 aramSize = ARGetSize();
|
||||
|
||||
mAudioMemorySize = audio_buffer_size;
|
||||
if (audio_graph_size == 0xffffffff) {
|
||||
mGraphMemorySize = (aramSize - audio_buffer_size) - aramBase;
|
||||
mAramMemorySize = 0;
|
||||
} else {
|
||||
mGraphMemorySize = audio_graph_size;
|
||||
mAramMemorySize = (aramSize - (audio_buffer_size + audio_graph_size)) - aramBase;
|
||||
}
|
||||
|
||||
mAudioMemoryPtr = ARAlloc(mAudioMemorySize);
|
||||
mGraphMemoryPtr = ARAlloc(mGraphMemorySize);
|
||||
|
||||
if (mAramMemorySize) {
|
||||
mAramMemoryPtr = ARAlloc(mAramMemorySize);
|
||||
} else {
|
||||
mAramMemoryPtr = NULL;
|
||||
}
|
||||
|
||||
mAramHeap = new (JKRHeap::getSystemHeap(), 0) JKRAramHeap(mGraphMemoryPtr, mGraphMemorySize);
|
||||
}
|
||||
|
||||
asm JKRAram::~JKRAram() {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D214C.s"
|
||||
JKRAram::~JKRAram() {
|
||||
sAramObject = NULL;
|
||||
if (mAramHeap)
|
||||
delete mAramHeap;
|
||||
}
|
||||
|
||||
// almost full match
|
||||
#ifdef NONMATCHING
|
||||
void* JKRAram::run(void) {
|
||||
int result;
|
||||
JKRAMCommand* command;
|
||||
JKRAMCommand::Message* message;
|
||||
OSInitMessageQueue(&sMessageQueue, sMessageBuffer, 4);
|
||||
do {
|
||||
OSReceiveMessage(&sMessageQueue, &message, OS_MESSAGE_BLOCKING);
|
||||
result = message->field_0x0;
|
||||
command = message->command;
|
||||
delete message;
|
||||
|
||||
if (result == 1) {
|
||||
JKRAramPiece::startDMA(command);
|
||||
}
|
||||
} while (true);
|
||||
}
|
||||
#else
|
||||
asm void* JKRAram::run(void) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D21DC.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
asm void JKRAram::checkOkAddress(u8*, u32, JKRAramBlock*, u32) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D2248.s"
|
||||
void JKRAram::checkOkAddress(u8* addr, u32 size, JKRAramBlock* block, u32 param_4) {
|
||||
if (!IS_ALIGNED((u32)addr, 0x20) && !IS_ALIGNED(size, 0x20)) {
|
||||
const char* file = lbl_8039D078;
|
||||
const char* format = lbl_8039D078 + 0xc;
|
||||
const char* arg1 = lbl_8039D078 + 0xc + 0x3;
|
||||
JUTException_NS_panic_f(file, 0xdb, format, arg1);
|
||||
}
|
||||
|
||||
if (block && !IS_ALIGNED((u32)block->getAddress() + param_4, 0x20)) {
|
||||
const char* file = lbl_8039D078;
|
||||
const char* format = lbl_8039D078 + 0xc;
|
||||
const char* arg1 = lbl_8039D078 + 0xc + 0x3;
|
||||
JUTException_NS_panic_f(file, 0xe3, format, arg1);
|
||||
}
|
||||
}
|
||||
|
||||
asm void JKRAram::changeGroupIdIfNeed(u8*, int) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D22DC.s"
|
||||
void JKRAram::changeGroupIdIfNeed(u8* data, int groupId) {
|
||||
JKRHeap* currentHeap = JKRHeap::getCurrentHeap();
|
||||
if (currentHeap->getHeapType() == 'EXPH' && groupId >= 0) {
|
||||
JKRExpHeap::CMemBlock* block = JKRExpHeap::CMemBlock::getBlock(data);
|
||||
block->newGroupId(groupId);
|
||||
}
|
||||
}
|
||||
|
||||
asm void JKRAram::mainRamToAram(u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*) {
|
||||
@@ -41,25 +139,145 @@ asm void JKRAram::aramToMainRam(u32, u8*, u32, JKRExpandSwitch, u32, JKRHeap*, i
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D25B4.s"
|
||||
}
|
||||
|
||||
asm void JKRDecompressFromAramToMainRam(u32, void*, u32, u32, u32, u32*) {
|
||||
#ifdef NONMATCHING
|
||||
// full match, except:
|
||||
// tsPtr = &tsArea;
|
||||
// doesn't use r13
|
||||
void JKRDecompressFromAramToMainRam(u32 src, void* dst, u32 srcLength, u32 dstLength, u32 offset,
|
||||
u32* resourceSize) {
|
||||
#define s_is_decompress_mutex_initialized lbl_804513FC
|
||||
#define decompMutex lbl_804343C0
|
||||
|
||||
// STATIC BEGIN
|
||||
// This code is probably generated by the compiler for a static variable
|
||||
BOOL enable = OSDisableInterrupts();
|
||||
if (s_is_decompress_mutex_initialized == false) {
|
||||
OSInitMutex(&decompMutex);
|
||||
s_is_decompress_mutex_initialized = true;
|
||||
}
|
||||
OSRestoreInterrupts(enable);
|
||||
// STATIC END
|
||||
|
||||
OSLockMutex(&decompMutex);
|
||||
u32 szpSize = getSZSBufferSize();
|
||||
szpBuf = (u8*)JKRAllocFromSysHeap(szpSize, 0x20);
|
||||
ASSERT(szpBuf != 0);
|
||||
szpEnd = szpBuf + szpSize;
|
||||
|
||||
if (offset != 0) {
|
||||
refBuf = (u8*)JKRAllocFromSysHeap(0x1120, 0);
|
||||
ASSERT(refBuf != 0);
|
||||
refEnd = refBuf + 0x1120;
|
||||
refCurrent = refBuf;
|
||||
} else {
|
||||
refBuf = NULL;
|
||||
}
|
||||
|
||||
srcAddress = src;
|
||||
srcOffset = 0;
|
||||
if (srcLength == 0) {
|
||||
transLeft = -1;
|
||||
} else {
|
||||
transLeft = srcLength;
|
||||
}
|
||||
|
||||
fileOffset = offset;
|
||||
readCount = 0;
|
||||
maxDest = dstLength;
|
||||
if (!resourceSize) {
|
||||
tsPtr = &tsArea;
|
||||
} else {
|
||||
tsPtr = resourceSize;
|
||||
}
|
||||
|
||||
*tsPtr = 0;
|
||||
|
||||
decompSZS_subroutine(firstSrcData(), (u8*)dst);
|
||||
JKRFreeToSysHeap(szpBuf);
|
||||
if (refBuf) {
|
||||
JKRFreeToSysHeap(refBuf);
|
||||
}
|
||||
DCStoreRangeNoSync(dst, *tsPtr);
|
||||
OSUnlockMutex(&decompMutex);
|
||||
#undef s_is_decompress_mutex_initialized
|
||||
#undef decompMutex
|
||||
}
|
||||
#else
|
||||
asm void JKRDecompressFromAramToMainRam(u32 src, void* dst, u32 srcLength, u32 dstLength,
|
||||
u32 offset, u32* resourceSize) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D2830.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
asm void decompSZS_subroutine(u8*, u8*) {
|
||||
nofralloc
|
||||
asm void decompSZS_subroutine(u8*, u8*){nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D29A0.s"
|
||||
}
|
||||
|
||||
asm void firstSrcData(void) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D2C40.s"
|
||||
u8* firstSrcData(void) {
|
||||
JKRAram__srcLimit = (u32)(JKRAram__szpEnd - 0x19);
|
||||
u8* buffer = JKRAram__szpBuf;
|
||||
|
||||
u32 length;
|
||||
u32 size = JKRAram__szpEnd - JKRAram__szpBuf;
|
||||
if (JKRAram__transLeft < size) {
|
||||
length = JKRAram__transLeft;
|
||||
} else {
|
||||
length = size;
|
||||
}
|
||||
|
||||
u32 src = (u32)(JKRAram__srcAddress + JKRAram__srcOffset);
|
||||
u32 dst = (u32)buffer;
|
||||
u32 alignedLength = ALIGN_NEXT(length, 0x20);
|
||||
JKRAramPcs(1, src, dst, alignedLength, NULL);
|
||||
|
||||
JKRAram__srcOffset += length;
|
||||
JKRAram__transLeft -= length;
|
||||
if (!JKRAram__transLeft) {
|
||||
JKRAram__srcLimit = (u32)(buffer + length);
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
asm void nextSrcData(u8*) {
|
||||
// missing one add instruction
|
||||
#ifdef NONMATCHING
|
||||
inline u32 nextSrcData_MIN(u32 A, u32 B) {
|
||||
if (A > B)
|
||||
return B;
|
||||
return A;
|
||||
}
|
||||
|
||||
static u8* nextSrcData(u8* current) {
|
||||
u8* dest;
|
||||
u32 left = (u32)(szpEnd - current);
|
||||
if (!IS_NOT_ALIGNED(left, 0x20)) {
|
||||
dest = szpBuf;
|
||||
} else {
|
||||
dest = szpBuf + 0x20 - (left & 0x1f);
|
||||
}
|
||||
|
||||
memcpy(dest, current, left);
|
||||
u32 transSize = nextSrcData_MIN(transLeft, szpEnd - (dest + left));
|
||||
ASSERT(transSize > 0);
|
||||
|
||||
JKRAramPcs(1, (u32)(srcAddress + srcOffset), (u32)(dest + left), ALIGN_NEXT(transSize, 0x20),
|
||||
NULL);
|
||||
srcOffset += transSize;
|
||||
transLeft -= transSize;
|
||||
|
||||
if (transLeft == 0) {
|
||||
srcLimit = (u32)(dest + left) + transSize;
|
||||
}
|
||||
|
||||
return dest;
|
||||
}
|
||||
#else
|
||||
asm u8* nextSrcData(u8* current) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAram/asm/func_802D2CE4.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
asm void __sinit_JKRAram_cpp {
|
||||
|
||||
@@ -48,7 +48,7 @@ asm void JKRAramArchive::fetchResource_subroutine(u32, u32, JKRHeap*, int, u8**)
|
||||
#include "JSystem/JKernel/JKRAramArchive/asm/func_802D7914.s"
|
||||
}
|
||||
|
||||
asm u32 JKRAramArchive::getExpandedResSize(void const*) const {
|
||||
asm u32 JKRAramArchive::getExpandedResSize(void const*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramArchive/asm/func_802D7A64.s"
|
||||
}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#include "JSystem/JKernel/JKRAramPiece/JKRAramPiece.h"
|
||||
#include "global.h"
|
||||
|
||||
#include "JSystem/JKernel/JKRAram/JKRAram.h"
|
||||
#include "JSystem/JKernel/JKRDecomp/JKRDecomp.h"
|
||||
#include "global.h"
|
||||
|
||||
JKRAMCommand* JKRAramPiece::prepareCommand(int direction, u32 src, u32 dst, u32 length,
|
||||
JKRAramBlock* block,
|
||||
@@ -41,7 +41,7 @@ JKRAMCommand* JKRAramPiece::orderAsync(int direction, u32 source, u32 destinatio
|
||||
message->field_0x00 = 1;
|
||||
message->command = command;
|
||||
|
||||
OSSendMessage(&lbl_803CC138, message, OS_MESSAGE_BLOCKING);
|
||||
OSSendMessage(&JKRAram::sMessageQueue, message, OS_MESSAGE_BLOCKING);
|
||||
if (command->mCallback != NULL) {
|
||||
lbl_80434324.append(&command->mPieceLink);
|
||||
}
|
||||
@@ -51,7 +51,7 @@ JKRAMCommand* JKRAramPiece::orderAsync(int direction, u32 source, u32 destinatio
|
||||
}
|
||||
|
||||
BOOL JKRAramPiece::sync(JKRAMCommand* command, int is_non_blocking) {
|
||||
OSMessage* message;
|
||||
OSMessage message;
|
||||
|
||||
lock();
|
||||
if (is_non_blocking == 0) {
|
||||
|
||||
@@ -1,57 +1,210 @@
|
||||
#include "JSystem/JKernel/JKRAramStream/JKRAramStream.h"
|
||||
#include "JSystem/JKernel/JKRAramPiece/JKRAramPiece.h"
|
||||
#include "global.h"
|
||||
|
||||
asm void JKRAramStream::create(long) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3B48.s"
|
||||
JKRAramStream* JKRAramStream::create(long priority) {
|
||||
if (!sAramStreamObject) {
|
||||
sAramStreamObject = new (JKRGetSystemHeap(), 0) JKRAramStream(priority);
|
||||
setTransBuffer(NULL, 0, NULL);
|
||||
}
|
||||
|
||||
return sAramStreamObject;
|
||||
}
|
||||
|
||||
asm JKRAramStream::JKRAramStream(long) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3BB8.s"
|
||||
JKRAramStream::JKRAramStream(long priority) : JKRThread(0xc00, 0x10, priority) {
|
||||
resume();
|
||||
}
|
||||
|
||||
asm JKRAramStream::~JKRAramStream() {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3C08.s"
|
||||
JKRAramStream::~JKRAramStream() {}
|
||||
|
||||
void* JKRAramStream::run(void) {
|
||||
OSInitMessageQueue(&sMessageQueue, sMessageBuffer, ARRAY_SIZE(sMessageBuffer));
|
||||
|
||||
for (;;) {
|
||||
OSMessage message;
|
||||
OSReceiveMessage(&sMessageQueue, &message, OS_MESSAGE_BLOCKING);
|
||||
JKRAramStreamCommand* command = (JKRAramStreamCommand*)message;
|
||||
|
||||
switch (command->mType) {
|
||||
case JKRAramStreamCommand::READ:
|
||||
readFromAram();
|
||||
break;
|
||||
case JKRAramStreamCommand::WRITE:
|
||||
writeToAram(command);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
asm void* JKRAramStream::run(void) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3C68.s"
|
||||
s32 JKRAramStream::readFromAram(void) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
asm void JKRAramStream::readFromAram(void) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3CD8.s"
|
||||
}
|
||||
// regalloc problems
|
||||
#ifdef NONMATCHING
|
||||
s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
|
||||
u32 size;
|
||||
u32 dstSize = command->mDstLength;
|
||||
u32 offset = command->mOffset;
|
||||
u32 writtenLength = 0;
|
||||
u32 destination = command->mDst;
|
||||
u8* buffer = command->mTransferBuffer;
|
||||
u32 bufferSize = command->mTransferBufferSize;
|
||||
JKRHeap* heap = command->mHeap;
|
||||
if (buffer) {
|
||||
if (bufferSize) {
|
||||
size = bufferSize;
|
||||
} else {
|
||||
size = 0x8000;
|
||||
}
|
||||
|
||||
asm void JKRAramStream::writeToAram(JKRAramStreamCommand*) {
|
||||
command->mTransferBufferSize = size;
|
||||
command->mAllocatedTransferBuffer = false;
|
||||
} else {
|
||||
if (bufferSize) {
|
||||
size = bufferSize;
|
||||
} else {
|
||||
size = 0x8000;
|
||||
}
|
||||
|
||||
if (heap) {
|
||||
buffer = (u8*)JKRAllocFromHeap(heap, size, -0x20);
|
||||
command->mTransferBuffer = buffer;
|
||||
} else {
|
||||
buffer = (u8*)JKRAllocFromSysHeap(size, -0x20);
|
||||
command->mTransferBuffer = buffer;
|
||||
}
|
||||
|
||||
command->mTransferBufferSize = size;
|
||||
command->mAllocatedTransferBuffer = true;
|
||||
}
|
||||
|
||||
if (!buffer) {
|
||||
if (!heap) {
|
||||
JKRGetCurrentHeap()->dump();
|
||||
} else {
|
||||
heap->dump();
|
||||
}
|
||||
|
||||
const char* file = lbl_8039D120; // "JKRAramStream.cpp";
|
||||
const char* format = lbl_8039D120 + 0x12; // "%s";
|
||||
const char* arg1 = lbl_8039D120 + 0x15; // ":::Cannot alloc memory\n";
|
||||
JUTException_NS_panic_f(file, 0xac, format, arg1);
|
||||
}
|
||||
|
||||
if (buffer) {
|
||||
JSURandomInputStream_NS_seek((JSURandomInputStream*)command->mStream, offset, 0);
|
||||
while (dstSize != 0) {
|
||||
u32 length;
|
||||
if (dstSize > size) {
|
||||
length = size;
|
||||
} else {
|
||||
length = dstSize;
|
||||
}
|
||||
|
||||
s32 readLength =
|
||||
JSUInputStream_NS_read((JSUInputStream*)command->mStream, buffer, length);
|
||||
if (readLength == 0) {
|
||||
writtenLength = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
JKRAramPcs(0, (u32)buffer, destination, length, NULL);
|
||||
dstSize -= length;
|
||||
writtenLength += writtenLength;
|
||||
destination += length;
|
||||
|
||||
if (command->mReturnSize) {
|
||||
*command->mReturnSize += length;
|
||||
}
|
||||
}
|
||||
|
||||
if (command->mAllocatedTransferBuffer) {
|
||||
JKRFree(buffer);
|
||||
command->mAllocatedTransferBuffer = false;
|
||||
}
|
||||
}
|
||||
|
||||
OSSendMessage(&command->mMessageQueue, (OSMessage)writtenLength, OS_MESSAGE_NON_BLOCKING);
|
||||
return writtenLength;
|
||||
}
|
||||
#else
|
||||
asm s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3CE0.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
asm void JKRAramStream::write_StreamToAram_Async(JSUFileInputStream*, u32, u32, u32, u32*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3ED0.s"
|
||||
JKRAramStreamCommand* JKRAramStream::write_StreamToAram_Async(JSUFileInputStream* stream, u32 addr,
|
||||
u32 size, u32 offset,
|
||||
u32* returnSize) {
|
||||
JKRAramStreamCommand* command = new (JKRGetSystemHeap(), -4) JKRAramStreamCommand();
|
||||
command->mType = JKRAramStreamCommand::WRITE;
|
||||
command->mAddress = addr;
|
||||
command->mSize = size;
|
||||
command->mStream = stream;
|
||||
command->field_0x2c = 0;
|
||||
command->mOffset = offset;
|
||||
command->mTransferBuffer = transBuffer;
|
||||
command->mHeap = transHeap;
|
||||
command->mTransferBufferSize = transSize;
|
||||
command->mReturnSize = returnSize;
|
||||
if (returnSize) {
|
||||
*returnSize = 0;
|
||||
}
|
||||
|
||||
OSInitMessageQueue(&command->mMessageQueue, &command->mMessage, 1);
|
||||
OSSendMessage(&sMessageQueue, command, OS_MESSAGE_BLOCKING);
|
||||
return command;
|
||||
}
|
||||
|
||||
asm void JKRAramStream::sync(JKRAramStreamCommand*, int) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D3FA0.s"
|
||||
JKRAramStreamCommand* JKRAramStream::sync(JKRAramStreamCommand* command, BOOL isNonBlocking) {
|
||||
OSMessage message;
|
||||
if (isNonBlocking == 0) {
|
||||
OSReceiveMessage(&command->mMessageQueue, &message, OS_MESSAGE_BLOCKING);
|
||||
if (message == NULL) {
|
||||
command = NULL;
|
||||
return command;
|
||||
} else {
|
||||
return command;
|
||||
}
|
||||
} else {
|
||||
BOOL receiveResult =
|
||||
OSReceiveMessage(&command->mMessageQueue, &message, OS_MESSAGE_NON_BLOCKING);
|
||||
if (receiveResult == FALSE) {
|
||||
command = NULL;
|
||||
return command;
|
||||
} else if (message == NULL) {
|
||||
command = NULL;
|
||||
return command;
|
||||
} else {
|
||||
return command;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
asm void JKRAramStream::setTransBuffer(u8*, u32, JKRHeap*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D4034.s"
|
||||
void JKRAramStream::setTransBuffer(u8* buffer, u32 bufferSize, JKRHeap* heap) {
|
||||
transBuffer = NULL;
|
||||
transSize = 0x8000;
|
||||
transHeap = NULL;
|
||||
|
||||
if (buffer) {
|
||||
transBuffer = (u8*)ALIGN_NEXT((u32)buffer, 0x20);
|
||||
}
|
||||
|
||||
if (bufferSize) {
|
||||
transSize = ALIGN_PREV(bufferSize, 0x20);
|
||||
}
|
||||
|
||||
if (heap && !buffer) {
|
||||
transHeap = heap;
|
||||
}
|
||||
}
|
||||
|
||||
asm JKRAramStreamCommand::JKRAramStreamCommand(void) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D4088.s"
|
||||
JKRAramStreamCommand::JKRAramStreamCommand() {
|
||||
mAllocatedTransferBuffer = false;
|
||||
}
|
||||
|
||||
asm void JSURandomInputStream::getAvailable(void) const {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRAramStream/asm/func_802D4094.s"
|
||||
s32 JSURandomInputStream::getAvailable() const {
|
||||
return getLength() - getPosition();
|
||||
}
|
||||
|
||||
@@ -194,29 +194,18 @@ const char* JKRArchive::CArcName::store(const char* name, char endChar) {
|
||||
return name + 1;
|
||||
}
|
||||
|
||||
// using include vs the JKRArchivePri.s file yields different code
|
||||
// super weird...
|
||||
#if 0
|
||||
#if NONMATCHING
|
||||
void JKRArchive::setExpandSize(SDIFileEntry* fileEntry, u32 expandSize) {
|
||||
int index = fileEntry - mFiles;
|
||||
if (!mExpandedSize)
|
||||
return;
|
||||
|
||||
if (index <= mArcInfoBlock->num_file_entries)
|
||||
if (!mExpandedSize || index >= mArcInfoBlock->num_file_entries)
|
||||
return;
|
||||
|
||||
mExpandedSize[index] = expandSize;
|
||||
}
|
||||
#else
|
||||
asm void JKRArchive::setExpandSize(SDIFileEntry* fileEntry, u32 expandSize) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRArchive/asm/func_802D693C.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
asm void JKRArchive::getExpandSize(SDIFileEntry*) const {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRArchive/asm/func_802D6978.s"
|
||||
u32 JKRArchive::getExpandSize(SDIFileEntry* fileEntry) const {
|
||||
int index = fileEntry - mFiles;
|
||||
if (!mExpandedSize || index >= mArcInfoBlock->num_file_entries)
|
||||
return 0;
|
||||
|
||||
return mExpandedSize[index];
|
||||
}
|
||||
#endif
|
||||
@@ -44,7 +44,7 @@ JKRArchive* JKRArchive::mount(void* ptr, JKRHeap* heap,
|
||||
return archive;
|
||||
|
||||
int alignment;
|
||||
if (mountDirection == JKRArchive::HEAD) {
|
||||
if (mountDirection == JKRArchive::MOUNT_DIRECTION_HEAD) {
|
||||
alignment = 4;
|
||||
} else {
|
||||
alignment = -4;
|
||||
@@ -61,7 +61,7 @@ JKRArchive* JKRArchive::mount(s32 entryNum, JKRArchive::EMountMode mountMode, JK
|
||||
return archive;
|
||||
} else {
|
||||
int alignment;
|
||||
if (mountDirection == JKRArchive::HEAD) {
|
||||
if (mountDirection == JKRArchive::MOUNT_DIRECTION_HEAD) {
|
||||
alignment = 4;
|
||||
} else {
|
||||
alignment = -4;
|
||||
|
||||
@@ -36,7 +36,7 @@ asm bool JKRCompArchive::removeResource(void*) {
|
||||
#include "JSystem/JKernel/JKRCompArchive/asm/func_802D92F4.s"
|
||||
}
|
||||
|
||||
asm u32 JKRCompArchive::getExpandedResSize(void const*) const {
|
||||
asm u32 JKRCompArchive::getExpandedResSize(void const*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRCompArchive/asm/func_802D9360.s"
|
||||
}
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
#include "JSystem/JKernel/JKRDecomp/JKRDecomp.h"
|
||||
#include "global.h"
|
||||
|
||||
#include "JSystem/JKernel/JKRAramPiece/JKRAramPiece.h"
|
||||
#include "global.h"
|
||||
|
||||
JKRDecomp* JKRDecomp::create(long priority) {
|
||||
if (!lbl_804514B0) {
|
||||
@@ -114,9 +113,9 @@ void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
|
||||
s32 offset;
|
||||
s32 i;
|
||||
|
||||
decodedSize = READ_BIG_ENDIAN_U32(src + 4);
|
||||
linkTableOffset = READ_BIG_ENDIAN_U32(src + 8);
|
||||
srcDataOffset = READ_BIG_ENDIAN_U32(src + 12);
|
||||
decodedSize = read_big_endian_u32(src + 4);
|
||||
linkTableOffset = read_big_endian_u32(src + 8);
|
||||
srcDataOffset = read_big_endian_u32(src + 12);
|
||||
|
||||
dstOffset = 0;
|
||||
counter = 0;
|
||||
@@ -131,7 +130,7 @@ void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
|
||||
length = srcLength;
|
||||
do {
|
||||
if (counter == 0) {
|
||||
chunkBits = READ_BIG_ENDIAN_U32(src + srcChunkOffset);
|
||||
chunkBits = read_big_endian_u32(src + srcChunkOffset);
|
||||
srcChunkOffset += 4;
|
||||
counter = 32;
|
||||
}
|
||||
@@ -149,7 +148,7 @@ void JKRDecomp::decodeSZP(u8* src, u8* dst, u32 srcLength, u32 dstLength) {
|
||||
dstOffset++;
|
||||
srcDataOffset++;
|
||||
} else {
|
||||
u32 linkInfo = READ_BIG_ENDIAN_U16(src + linkTableOffset);
|
||||
u32 linkInfo = read_big_endian_u16(src + linkTableOffset);
|
||||
linkTableOffset += 2;
|
||||
|
||||
offset = dstOffset - (linkInfo & 0xFFF);
|
||||
|
||||
@@ -2,6 +2,10 @@
|
||||
#include "dvd/dvd.h"
|
||||
#include "global.h"
|
||||
|
||||
static void decompSZS_subroutine(u8*, u32);
|
||||
static u8* firstSrcData(void);
|
||||
static u8* nextSrcData(u8*);
|
||||
|
||||
asm void JKRDvdAramRipper::loadToAram(long, u32, JKRExpandSwitch, u32, u32, u32*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdAramRipper/asm/func_802DA874.s"
|
||||
@@ -53,12 +57,12 @@ asm void decompSZS_subroutine(u8*, u32) {
|
||||
#include "JSystem/JKernel/JKRDvdAramRipper/asm/func_802DB160.s"
|
||||
}
|
||||
|
||||
asm void firstSrcData(void) {
|
||||
asm u8* firstSrcData(void) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdAramRipper/asm/func_802DB3E8.s"
|
||||
}
|
||||
|
||||
asm void nextSrcData(u8*) {
|
||||
asm u8* nextSrcData(u8*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdAramRipper/asm/func_802DB49C.s"
|
||||
}
|
||||
|
||||
@@ -1,42 +1,387 @@
|
||||
#include "JSystem/JKernel/JKRDvdArchive/JKRDvdArchive.h"
|
||||
#include "JSystem/JKernel/JKRDvdFile/JKRDvdFile.h"
|
||||
#include "JSystem/JKernel/JKRDvdRipper/JKRDvdRipper.h"
|
||||
#include "global.h"
|
||||
|
||||
asm JKRDvdArchive::JKRDvdArchive(long, JKRArchive::EMountDirection) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D7BF0.s"
|
||||
JKRDvdArchive::JKRDvdArchive(s32 entryNum, JKRArchive::EMountDirection mountDirection)
|
||||
: JKRArchive(entryNum, MOUNT_DVD), mMountDirection(mountDirection) {
|
||||
if (!open(entryNum))
|
||||
return;
|
||||
|
||||
mVolumeType = 'RARC';
|
||||
mVolumeName = mStringTable + (u32)mNodes->name;
|
||||
getVolumeList().prepend(&mFileLoaderLink);
|
||||
mIsMounted = true;
|
||||
}
|
||||
|
||||
asm JKRDvdArchive::~JKRDvdArchive() {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D7C98.s"
|
||||
JKRDvdArchive::~JKRDvdArchive() {
|
||||
if (mIsMounted == true) {
|
||||
if (mArcInfoBlock) {
|
||||
SDIFileEntry* fileEntry = mFiles;
|
||||
int i = 0;
|
||||
for (; i < mArcInfoBlock->num_file_entries; fileEntry++, i++) {
|
||||
if (fileEntry->data) {
|
||||
JKRFreeToHeap(mHeap, fileEntry->data);
|
||||
}
|
||||
}
|
||||
|
||||
JKRFreeToHeap(mHeap, mArcInfoBlock);
|
||||
mArcInfoBlock = NULL;
|
||||
}
|
||||
|
||||
if (mExpandedSize) {
|
||||
JKRFree(mExpandedSize);
|
||||
mExpandedSize = NULL;
|
||||
}
|
||||
|
||||
if (mDvdFile) {
|
||||
delete mDvdFile;
|
||||
}
|
||||
|
||||
getVolumeList().remove(&mFileLoaderLink);
|
||||
mIsMounted = false;
|
||||
}
|
||||
}
|
||||
|
||||
asm void JKRDvdArchive::open(long) {
|
||||
#ifdef NONMATCHING
|
||||
bool JKRDvdArchive::open(s32 entryNum) {
|
||||
mArcInfoBlock = NULL;
|
||||
field_0x64 = NULL;
|
||||
mNodes = NULL;
|
||||
mFiles = NULL;
|
||||
mStringTable = NULL;
|
||||
|
||||
mDvdFile = new (JKRHeap::getSystemHeap(), 0) JKRDvdFile(entryNum);
|
||||
if (!mDvdFile) {
|
||||
mMountMode = UNKNOWN_MOUNT_MODE;
|
||||
return false;
|
||||
}
|
||||
|
||||
SArcHeader* arcHeader = (SArcHeader*)JKRAllocFromSysHeap(sizeof(SArcHeader), 0x20);
|
||||
if (!arcHeader) {
|
||||
mMountMode = UNKNOWN_MOUNT_MODE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
JKRDvdToMainRam(entryNum, (u8*)arcHeader, EXPAND_SWITCH_UNKNOWN1, sizeof(SArcHeader), NULL,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 0, &mCompression, NULL);
|
||||
DCInvalidateRange(arcHeader, sizeof(SArcHeader));
|
||||
|
||||
int alignment;
|
||||
if (mMountDirection == MOUNT_DIRECTION_HEAD) {
|
||||
alignment = 0x20;
|
||||
} else {
|
||||
alignment = -0x20;
|
||||
}
|
||||
|
||||
mArcInfoBlock = (SArcDataInfo*)JKRAllocFromHeap(mHeap, arcHeader->file_data_offset, alignment);
|
||||
if (!mArcInfoBlock) {
|
||||
mMountMode = UNKNOWN_MOUNT_MODE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
JKRDvdToMainRam(entryNum, (u8*)mArcInfoBlock, EXPAND_SWITCH_UNKNOWN1,
|
||||
arcHeader->file_data_offset, NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD,
|
||||
sizeof(SArcHeader), NULL, NULL);
|
||||
DCInvalidateRange(mArcInfoBlock, arcHeader->file_data_offset);
|
||||
|
||||
mNodes = (SDirEntry*)((int)&mArcInfoBlock->num_nodes + mArcInfoBlock->node_offset);
|
||||
mFiles = (SDIFileEntry*)((int)&mArcInfoBlock->num_nodes + mArcInfoBlock->file_entry_offset);
|
||||
mStringTable = (char*)((int)&mArcInfoBlock->num_nodes + mArcInfoBlock->string_table_offset);
|
||||
mExpandedSize = NULL;
|
||||
|
||||
bool useCompression = false;
|
||||
SDIFileEntry* fileEntry = mFiles;
|
||||
for (u32 i = 0; i < mArcInfoBlock->num_file_entries; fileEntry++, i++) {
|
||||
if (!fileEntry->isUnknownFlag1()) {
|
||||
useCompression |= fileEntry->isCompressed();
|
||||
}
|
||||
}
|
||||
|
||||
if (useCompression) {
|
||||
mExpandedSize = (s32*)JKRAllocFromHeap(mHeap, sizeof(s32) * mArcInfoBlock->num_file_entries,
|
||||
abs(alignment));
|
||||
if (mExpandedSize) {
|
||||
// !@bug: mArcInfoBlock is allocated from mHeap but free'd to sSystemHeap. I don't know
|
||||
// what will happen if mHeap != sSystemHeap, but it's still a bug to free to the wrong
|
||||
// allocator.
|
||||
JKRFreeToSysHeap(mArcInfoBlock);
|
||||
mMountMode = UNKNOWN_MOUNT_MODE;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
memset(mExpandedSize, 0, sizeof(s32) * mArcInfoBlock->num_file_entries);
|
||||
}
|
||||
|
||||
field_0x64 = arcHeader->header_length + arcHeader->file_data_offset;
|
||||
|
||||
cleanup:
|
||||
if (arcHeader) {
|
||||
JKRFreeToSysHeap(arcHeader);
|
||||
}
|
||||
|
||||
if (mMountMode == UNKNOWN_MOUNT_MODE) {
|
||||
if (mDvdFile) {
|
||||
delete mDvdFile;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
#else
|
||||
asm bool JKRDvdArchive::open(s32 entryNum) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D7DB4.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
asm void* JKRDvdArchive::fetchResource(SDIFileEntry*, u32*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D8050.s"
|
||||
void* JKRDvdArchive::fetchResource(SDIFileEntry* fileEntry, u32* returnSize) {
|
||||
u32 tempReturnSize;
|
||||
if (returnSize == NULL) {
|
||||
returnSize = &tempReturnSize;
|
||||
}
|
||||
|
||||
JKRCompression fileCompression = JKRConvertAttrToCompressionType(fileEntry->getAttr());
|
||||
if (!fileEntry->data) {
|
||||
u8* resourcePtr;
|
||||
u32 resourceSize = fetchResource_subroutine(
|
||||
mEntryNum, this->field_0x64 + fileEntry->data_offset, fileEntry->data_size, mHeap,
|
||||
fileCompression, mCompression, &resourcePtr);
|
||||
*returnSize = resourceSize;
|
||||
if (resourceSize == 0) {
|
||||
return NULL;
|
||||
}
|
||||
fileEntry->data = resourcePtr;
|
||||
if (fileCompression == COMPRESSION_YAZ0) {
|
||||
setExpandSize(fileEntry, *returnSize);
|
||||
}
|
||||
} else {
|
||||
if (fileCompression == COMPRESSION_YAZ0) {
|
||||
u32 resourceSize = getExpandSize(fileEntry);
|
||||
*returnSize = resourceSize;
|
||||
} else {
|
||||
*returnSize = fileEntry->data_size;
|
||||
}
|
||||
}
|
||||
|
||||
return fileEntry->data;
|
||||
}
|
||||
|
||||
asm void* JKRDvdArchive::fetchResource(void*, u32, SDIFileEntry*, u32*) {
|
||||
// ALIGN_PREV(bufferSize, 0x20) is "inlined" in the function parameter.
|
||||
#ifdef NONMATCHING
|
||||
void* JKRDvdArchive::fetchResource(void* buffer, u32 bufferSize, SDIFileEntry* fileEntry,
|
||||
u32* returnSize) {
|
||||
ASSERT(isMounted());
|
||||
u32 otherSize;
|
||||
u32 size = fileEntry->data_size;
|
||||
u32 dstSize = bufferSize;
|
||||
JKRCompression fileCompression = JKRConvertAttrToCompressionType(fileEntry->getAttr());
|
||||
|
||||
if (!fileEntry->data) {
|
||||
dstSize = ALIGN_PREV(bufferSize, 0x20);
|
||||
size = fetchResource_subroutine(mEntryNum, field_0x64 + fileEntry->data_offset,
|
||||
fileEntry->data_size, (u8*)buffer, dstSize, fileCompression,
|
||||
mCompression);
|
||||
} else {
|
||||
if (fileCompression == COMPRESSION_YAZ0) {
|
||||
otherSize = getExpandSize(fileEntry);
|
||||
if (otherSize) {
|
||||
size = otherSize;
|
||||
}
|
||||
}
|
||||
|
||||
if (size > bufferSize) {
|
||||
size = bufferSize;
|
||||
}
|
||||
|
||||
JKRHeap::copyMemory(buffer, fileEntry->data, size);
|
||||
}
|
||||
|
||||
if (returnSize) {
|
||||
*returnSize = size;
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
#else
|
||||
asm void* JKRDvdArchive::fetchResource(void* buffer, u32 bufferSize, SDIFileEntry* fileEntry,
|
||||
u32* returnSize) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D8168.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
asm void JKRDvdArchive::fetchResource_subroutine(long, u32, u32, u8*, u32, int, int) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D826C.s"
|
||||
u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size, u8* dst,
|
||||
u32 dstLength, JKRCompression fileCompression,
|
||||
JKRCompression archiveCompression) {
|
||||
u32 alignedSize = ALIGN_NEXT(size, 0x20);
|
||||
u32 alignedDstLength = ALIGN_PREV(dstLength, 0x20);
|
||||
|
||||
switch (archiveCompression) {
|
||||
case COMPRESSION_NONE: {
|
||||
switch (fileCompression) {
|
||||
case COMPRESSION_NONE:
|
||||
if (alignedSize > alignedDstLength) {
|
||||
alignedSize = alignedDstLength;
|
||||
}
|
||||
|
||||
JKRDvdToMainRam(entryNum, dst, EXPAND_SWITCH_UNKNOWN0, alignedSize, NULL,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(dst, alignedSize);
|
||||
return alignedSize;
|
||||
case COMPRESSION_YAY0:
|
||||
case COMPRESSION_YAZ0:
|
||||
// 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),
|
||||
NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(arcHeader, sizeof(SArcHeader));
|
||||
|
||||
u32 decompressedSize = JKRDecompExpandSize(arcHeader);
|
||||
u32 alignedDecompressedSize = ALIGN_NEXT(decompressedSize, 0x20);
|
||||
if (alignedDecompressedSize > alignedDstLength) {
|
||||
alignedDecompressedSize = alignedDstLength;
|
||||
}
|
||||
|
||||
JKRDvdToMainRam(entryNum, dst, EXPAND_SWITCH_UNKNOWN1, alignedDecompressedSize, NULL,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(dst, alignedDecompressedSize);
|
||||
return decompressedSize;
|
||||
}
|
||||
}
|
||||
|
||||
case COMPRESSION_YAZ0: {
|
||||
if (size > alignedDstLength) {
|
||||
size = alignedDstLength;
|
||||
}
|
||||
|
||||
JKRDvdToMainRam(entryNum, dst, EXPAND_SWITCH_UNKNOWN1, size, NULL,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(dst, size);
|
||||
return size;
|
||||
}
|
||||
|
||||
case COMPRESSION_YAY0: {
|
||||
const char* file = lbl_8039D1B0; // "JKRDvdArchive.cpp"
|
||||
const char* format = lbl_8039D1B0 + 0x12; // "%s"
|
||||
const char* arg1 = lbl_8039D1B0 + 0x15; // "Sorry, not applied for SZP archive.\n"
|
||||
JUTException_NS_panic_f(file, 0x289, format, arg1);
|
||||
}
|
||||
|
||||
default: {
|
||||
const char* file = lbl_8039D1B0; // "JKRDvdArchive.cpp"
|
||||
const char* format = lbl_8039D1B0 + 0x12; // "%s"
|
||||
const char* arg1 = lbl_8039D1B0 + 0x3A; // "??? bad sequence\n"
|
||||
JUTException_NS_panic_f(file, 0x28d, format, arg1);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
asm void JKRDvdArchive::fetchResource_subroutine(long, u32, u32, JKRHeap*, int, int, u8**) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D8474.s"
|
||||
u32 JKRDvdArchive::fetchResource_subroutine(s32 entryNum, u32 offset, u32 size, JKRHeap* heap,
|
||||
JKRCompression fileCompression,
|
||||
JKRCompression archiveCompression,
|
||||
u8** returnResource) {
|
||||
u32 alignedSize = ALIGN_NEXT(size, 0x20);
|
||||
u8* buffer;
|
||||
|
||||
switch (archiveCompression) {
|
||||
case COMPRESSION_NONE: {
|
||||
switch (fileCompression) {
|
||||
case COMPRESSION_NONE:
|
||||
buffer = (u8*)JKRAllocFromHeap(heap, alignedSize, sizeof(SArcHeader));
|
||||
ASSERT(buffer);
|
||||
|
||||
JKRDvdToMainRam(entryNum, buffer, EXPAND_SWITCH_UNKNOWN0, alignedSize, NULL,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(buffer, alignedSize);
|
||||
|
||||
*returnResource = buffer;
|
||||
return alignedSize;
|
||||
case COMPRESSION_YAY0:
|
||||
case COMPRESSION_YAZ0:
|
||||
// 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),
|
||||
NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(arcHeader, sizeof(SArcHeader));
|
||||
|
||||
alignedSize = JKRDecompExpandSize(arcHeader);
|
||||
buffer = (u8*)JKRAllocFromHeap(heap, alignedSize, sizeof(SArcHeader));
|
||||
ASSERT(buffer);
|
||||
JKRDvdToMainRam(entryNum, buffer, EXPAND_SWITCH_UNKNOWN1, alignedSize, NULL,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(buffer, alignedSize);
|
||||
|
||||
*returnResource = buffer;
|
||||
return alignedSize;
|
||||
}
|
||||
}
|
||||
|
||||
case COMPRESSION_YAZ0: {
|
||||
buffer = (u8*)JKRAllocFromHeap(heap, alignedSize, sizeof(SArcHeader));
|
||||
ASSERT(buffer);
|
||||
|
||||
JKRDvdToMainRam(entryNum, buffer, EXPAND_SWITCH_UNKNOWN1, size, NULL,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD, offset, NULL, NULL);
|
||||
DCInvalidateRange(buffer, size);
|
||||
|
||||
*returnResource = buffer;
|
||||
return alignedSize;
|
||||
}
|
||||
|
||||
case COMPRESSION_YAY0: {
|
||||
const char* file = lbl_8039D1B0; // "JKRDvdArchive.cpp"
|
||||
const char* format = lbl_8039D1B0 + 0x12; // "%s"
|
||||
const char* arg1 = lbl_8039D1B0 + 0x4c; // "Sorry, not applied SZP archive.\n"
|
||||
JUTException_NS_panic_f(file, 0x2f2, format, arg1);
|
||||
}
|
||||
|
||||
default: {
|
||||
const char* file = lbl_8039D1B0; // "JKRDvdArchive.cpp"
|
||||
const char* format = lbl_8039D1B0 + 0x12; // "%s"
|
||||
const char* arg1 = lbl_8039D1B0 + 0x3A; // "??? bad sequence\n"
|
||||
JUTException_NS_panic_f(file, 0x2f6, format, arg1);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
asm u32 JKRDvdArchive::getExpandedResSize(void const*) const {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdArchive/asm/func_802D8698.s"
|
||||
u32 JKRDvdArchive::getExpandedResSize(const void* resource) {
|
||||
u32 resourceSize;
|
||||
if (!mExpandedSize) {
|
||||
return getResSize(resource);
|
||||
}
|
||||
|
||||
SDIFileEntry* fileEntry = findPtrResource(resource);
|
||||
if (!fileEntry) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!fileEntry->isCompressed()) {
|
||||
return getResSize(resource);
|
||||
}
|
||||
|
||||
resourceSize = getExpandSize(fileEntry);
|
||||
if (resourceSize) {
|
||||
return resourceSize;
|
||||
}
|
||||
|
||||
// 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,
|
||||
JKRDvdRipper::ALLOC_DIRECTION_FORWARD,
|
||||
this->field_0x64 + fileEntry->data_offset, NULL, NULL);
|
||||
DCInvalidateRange(arcHeader, sizeof(*arcHeader));
|
||||
|
||||
resourceSize = JKRDecompExpandSize(arcHeader);
|
||||
setExpandSize(fileEntry, resourceSize);
|
||||
|
||||
return resourceSize;
|
||||
}
|
||||
|
||||
@@ -5,32 +5,27 @@ JKRDvdFile::JKRDvdFile() : JKRFile(), mDvdLink(this) {
|
||||
initiate();
|
||||
}
|
||||
|
||||
// end of fuctions is weird. instructions which should have been optimized out.
|
||||
#ifdef NONMATCHING
|
||||
JKRDvdFile::JKRDvdFile(const char* name) : JKRFile(), mDvdLink(this) {
|
||||
initiate();
|
||||
bool result = open(name);
|
||||
mIsAvailable = result;
|
||||
// weird code. doesn't match without this, maybe remains from assert or something?
|
||||
if (mIsAvailable)
|
||||
return;
|
||||
else
|
||||
return;
|
||||
}
|
||||
#else
|
||||
asm JKRDvdFile::JKRDvdFile(char const*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdFile/asm/func_802D95F8.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef NONMATHCING
|
||||
JKRDvdFile::JKRDvdFile(long param_1) : JKRFile(), mDvdLink(this) {
|
||||
JKRDvdFile::JKRDvdFile(long entryNum) : JKRFile(), mDvdLink(this) {
|
||||
initiate();
|
||||
bool result = open(param_1);
|
||||
bool result = open(entryNum);
|
||||
mIsAvailable = result;
|
||||
// weird code. doesn't match without this, maybe remains from assert or something?
|
||||
if (mIsAvailable)
|
||||
return;
|
||||
else
|
||||
return;
|
||||
}
|
||||
#else
|
||||
asm JKRDvdFile::JKRDvdFile(long) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdFile/asm/func_802D96A0.s"
|
||||
}
|
||||
#endif
|
||||
|
||||
JKRDvdFile::~JKRDvdFile() {
|
||||
close();
|
||||
@@ -51,18 +46,18 @@ bool JKRDvdFile::open(const char* param_1) {
|
||||
if (!mIsAvailable) {
|
||||
mIsAvailable = DVDOpen(param_1, &mFileInfo);
|
||||
if (mIsAvailable) {
|
||||
lbl_8043436C.append(&mDvdLink);
|
||||
getDvdList().append(&mDvdLink);
|
||||
getStatus();
|
||||
}
|
||||
}
|
||||
return mIsAvailable;
|
||||
}
|
||||
|
||||
bool JKRDvdFile::open(long param_1) {
|
||||
bool JKRDvdFile::open(long entryNum) {
|
||||
if (!mIsAvailable) {
|
||||
mIsAvailable = DVDFastOpen(param_1, &mFileInfo);
|
||||
mIsAvailable = DVDFastOpen(entryNum, &mFileInfo);
|
||||
if (mIsAvailable) {
|
||||
lbl_8043436C.append(&mDvdLink);
|
||||
getDvdList().append(&mDvdLink);
|
||||
getStatus();
|
||||
}
|
||||
}
|
||||
@@ -74,7 +69,7 @@ void JKRDvdFile::close() {
|
||||
s32 result = DVDClose(&mFileInfo);
|
||||
if (result != 0) {
|
||||
mIsAvailable = false;
|
||||
lbl_8043436C.remove(&mDvdLink);
|
||||
getDvdList().remove(&mDvdLink);
|
||||
} else {
|
||||
const char* filename = lbl_8039D260; // "JKRDvdFile.cpp"
|
||||
const char* format = lbl_8039D260 + 0x0F; // "%s"
|
||||
|
||||
@@ -2,6 +2,11 @@
|
||||
#include "dvd/dvd.h"
|
||||
#include "global.h"
|
||||
|
||||
static void decompSZS_subroutine(u8*, u8*);
|
||||
static u8* firstSrcData(void);
|
||||
static u8* nextSrcData(u8*);
|
||||
extern "C" void firstSrcData__Fv();
|
||||
|
||||
asm void* JKRDvdRipper::loadToMainRAM(const char*, u8*, JKRExpandSwitch, u32, JKRHeap*,
|
||||
JKRDvdRipper::EAllocDirection, u32, JKRCompression*, u32*) {
|
||||
nofralloc
|
||||
@@ -30,12 +35,12 @@ asm void decompSZS_subroutine(u8*, u8*) {
|
||||
#include "JSystem/JKernel/JKRDvdRipper/asm/func_802DA35C.s"
|
||||
}
|
||||
|
||||
asm void firstSrcData(void) {
|
||||
asm u8* firstSrcData(void) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdRipper/asm/func_802DA60C.s"
|
||||
}
|
||||
|
||||
asm void nextSrcData(u8*) {
|
||||
asm u8* nextSrcData(u8*) {
|
||||
nofralloc
|
||||
#include "JSystem/JKernel/JKRDvdRipper/asm/func_802DA6D8.s"
|
||||
}
|
||||
|
||||
@@ -1,16 +1,15 @@
|
||||
#include "JSystem/JKernel/JKRFileLoader/JKRFileLoader.h"
|
||||
#include "global.h"
|
||||
|
||||
JKRFileLoader::JKRFileLoader(void) : mFileLoaderLink(this) {
|
||||
mVolumeName = NULL;
|
||||
mVolumeType = 0;
|
||||
mMountCount = 0;
|
||||
}
|
||||
// todo: static initialization is working uncomment this
|
||||
// JSUList<JKRFileLoader> JKRFileLoader::sVolumeList;
|
||||
|
||||
JKRFileLoader::JKRFileLoader(void)
|
||||
: mFileLoaderLink(this), mVolumeName(NULL), mVolumeType(0), mMountCount(0) {}
|
||||
|
||||
JKRFileLoader::~JKRFileLoader() {
|
||||
// lbl_80451418 = JKRFileLoader::sCurrentVolume
|
||||
if (lbl_80451418 == this) {
|
||||
lbl_80451418 = NULL;
|
||||
if (getCurrentVolume() == this) {
|
||||
setCurrentVolume(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -41,15 +40,14 @@ void* JKRFileLoader::getGlbResource(const char* name) {
|
||||
}
|
||||
|
||||
void* JKRFileLoader::getGlbResource(const char* name, JKRFileLoader* fileLoader) {
|
||||
// lbl_80434354 = JKRFileLoader::sVolumeList
|
||||
|
||||
void* resource = NULL;
|
||||
if (fileLoader) {
|
||||
return fileLoader->getResource(0, name);
|
||||
}
|
||||
|
||||
JSUList<JKRFileLoader>& volumeList = getVolumeList();
|
||||
JSUListIterator<JKRFileLoader> iterator;
|
||||
for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
|
||||
for (iterator = volumeList.getFirst(); iterator != volumeList.getEnd(); ++iterator) {
|
||||
resource = iterator->getResource(0, name);
|
||||
if (resource)
|
||||
break;
|
||||
@@ -58,14 +56,13 @@ void* JKRFileLoader::getGlbResource(const char* name, JKRFileLoader* fileLoader)
|
||||
}
|
||||
|
||||
bool JKRFileLoader::removeResource(void* resource, JKRFileLoader* fileLoader) {
|
||||
// lbl_80434354 = JKRFileLoader::sVolumeList
|
||||
|
||||
if (fileLoader) {
|
||||
return fileLoader->removeResource(resource);
|
||||
}
|
||||
|
||||
JSUList<JKRFileLoader>& volumeList = getVolumeList();
|
||||
JSUListIterator<JKRFileLoader> iterator;
|
||||
for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
|
||||
for (iterator = volumeList.getFirst(); iterator != volumeList.getEnd(); ++iterator) {
|
||||
if (iterator->removeResource(resource)) {
|
||||
return true;
|
||||
}
|
||||
@@ -75,14 +72,13 @@ bool JKRFileLoader::removeResource(void* resource, JKRFileLoader* fileLoader) {
|
||||
}
|
||||
|
||||
bool JKRFileLoader::detachResource(void* resource, JKRFileLoader* fileLoader) {
|
||||
// lbl_80434354 = JKRFileLoader::sVolumeList
|
||||
|
||||
if (fileLoader) {
|
||||
return fileLoader->detachResource(resource);
|
||||
}
|
||||
|
||||
JSUList<JKRFileLoader>& volumeList = getVolumeList();
|
||||
JSUListIterator<JKRFileLoader> iterator;
|
||||
for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
|
||||
for (iterator = volumeList.getFirst(); iterator != volumeList.getEnd(); ++iterator) {
|
||||
if (iterator->detachResource(resource)) {
|
||||
return true;
|
||||
}
|
||||
@@ -92,17 +88,16 @@ bool JKRFileLoader::detachResource(void* resource, JKRFileLoader* fileLoader) {
|
||||
}
|
||||
|
||||
JKRFileLoader* JKRFileLoader::findVolume(const char** volumeName) {
|
||||
// lbl_80451418 = JKRFileLoader::sCurrentVolume
|
||||
|
||||
if (*volumeName[0] != '/') {
|
||||
return lbl_80451418;
|
||||
return getCurrentVolume();
|
||||
}
|
||||
|
||||
char volumeNameBuffer[0x101];
|
||||
*volumeName = fetchVolumeName(volumeNameBuffer, ARRAY_SIZE(volumeNameBuffer), *volumeName);
|
||||
|
||||
JSUList<JKRFileLoader>& volumeList = getVolumeList();
|
||||
JSUListIterator<JKRFileLoader> iterator;
|
||||
for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
|
||||
for (iterator = volumeList.getFirst(); iterator != volumeList.getEnd(); ++iterator) {
|
||||
if (strcmp(volumeNameBuffer, iterator->mVolumeName) == 0) {
|
||||
return iterator.getObject();
|
||||
}
|
||||
|
||||
@@ -14,10 +14,10 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
|
||||
} else {
|
||||
parent->mChildTree.appendChild(&mChildTree);
|
||||
|
||||
if (lbl_80451370 == lbl_80451378) {
|
||||
if (getSystemHeap() == getRootHeap()) {
|
||||
becomeSystemHeap();
|
||||
}
|
||||
if (lbl_80451374 == lbl_80451378) {
|
||||
if (getCurrentHeap() == getRootHeap()) {
|
||||
becomeCurrentHeap();
|
||||
}
|
||||
}
|
||||
@@ -33,16 +33,15 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool errorFlag)
|
||||
}
|
||||
|
||||
// using the wrong register for storing the results
|
||||
// lbl_80451370 = systemHeap;
|
||||
#ifdef NONMATCHING
|
||||
JKRHeap::~JKRHeap() {
|
||||
JSUTree<JKRHeap>* parent = mChildTree.getParent();
|
||||
parent->removeChild(&mChildTree);
|
||||
|
||||
JSUTree<JKRHeap>* nextRootHeap = lbl_80451378->mChildTree.getFirstChild();
|
||||
JSUTree<JKRHeap>* nextRootHeap = getRootHeap()->mChildTree.getFirstChild();
|
||||
|
||||
JKRHeap* rootHeap = lbl_80451378;
|
||||
JKRHeap* currentHeap = lbl_80451374;
|
||||
JKRHeap* rootHeap = getRootHeap();
|
||||
JKRHeap* currentHeap = getCurrentHeap();
|
||||
if (currentHeap == this) {
|
||||
if (!nextRootHeap) {
|
||||
currentHeap = rootHeap;
|
||||
@@ -50,9 +49,9 @@ JKRHeap::~JKRHeap() {
|
||||
currentHeap = nextRootHeap->getObject();
|
||||
}
|
||||
}
|
||||
lbl_80451374 = currentHeap;
|
||||
setCurrentHeap(currentHeap);
|
||||
|
||||
JKRHeap* systemHeap = lbl_80451370;
|
||||
JKRHeap* systemHeap = getSystemHeap();
|
||||
if (systemHeap == this) {
|
||||
if (!nextRootHeap) {
|
||||
systemHeap = rootHeap;
|
||||
@@ -60,7 +59,7 @@ JKRHeap::~JKRHeap() {
|
||||
systemHeap = nextRootHeap->getObject();
|
||||
}
|
||||
}
|
||||
lbl_80451370 = systemHeap;
|
||||
setSystemHeap(systemHeap);
|
||||
}
|
||||
#else
|
||||
asm JKRHeap::~JKRHeap() {
|
||||
@@ -80,13 +79,14 @@ bool JKRHeap::initArena(char** memory, u32* size, int param_3) {
|
||||
return false;
|
||||
|
||||
ram = OSInitAlloc(low, high, param_3);
|
||||
ram_start = (ram + 0x1fU & 0xffffffe0);
|
||||
ram_end = (high & 0xffffffe0);
|
||||
lbl_80451384 = OS_GLOBAL_ADDR(void, 0x80000000);
|
||||
lbl_80451388 = (void*)ram_start;
|
||||
lbl_8045138C = (void*)ram_start;
|
||||
lbl_80451390 = (void*)ram_end;
|
||||
lbl_80451394 = OS_GLOBAL(u32, 0x80000028);
|
||||
ram_start = ALIGN_NEXT(ram, 0x20);
|
||||
ram_end = ALIGN_PREV(high, 0x20);
|
||||
GLOBAL_MEMORY* globalMemory = (GLOBAL_MEMORY*)OSPhysicalToCached(0);
|
||||
mCodeStart = globalMemory;
|
||||
mCodeEnd = (void*)ram_start;
|
||||
mUserRamStart = (void*)ram_start;
|
||||
mUserRamEnd = (void*)ram_end;
|
||||
mMemorySize = globalMemory->memory_size;
|
||||
OSSetArenaLo(ram_end);
|
||||
OSSetArenaHi(ram_end);
|
||||
*memory = (char*)ram_start;
|
||||
@@ -95,14 +95,14 @@ bool JKRHeap::initArena(char** memory, u32* size, int param_3) {
|
||||
}
|
||||
|
||||
JKRHeap* JKRHeap::becomeSystemHeap() {
|
||||
JKRHeap* prev = lbl_80451370;
|
||||
lbl_80451370 = this;
|
||||
JKRHeap* prev = JKRHeap::getSystemHeap();
|
||||
setSystemHeap(this);
|
||||
return prev;
|
||||
}
|
||||
|
||||
JKRHeap* JKRHeap::becomeCurrentHeap() {
|
||||
JKRHeap* prev = lbl_80451374;
|
||||
lbl_80451374 = this;
|
||||
JKRHeap* prev = getCurrentHeap();
|
||||
setCurrentHeap(this);
|
||||
return prev;
|
||||
}
|
||||
|
||||
@@ -115,8 +115,8 @@ void* JKRHeap::alloc(u32 size, int alignment, JKRHeap* heap) {
|
||||
return heap->alloc(size, alignment);
|
||||
}
|
||||
|
||||
if (lbl_80451374 != NULL) {
|
||||
return lbl_80451374->alloc(size, alignment);
|
||||
if (getCurrentHeap() != NULL) {
|
||||
return getCurrentHeap()->alloc(size, alignment);
|
||||
}
|
||||
|
||||
return NULL;
|
||||
@@ -216,15 +216,16 @@ asm u32 JKRHeap::getMaxAllocatableSize(int alignment) const {
|
||||
#endif
|
||||
|
||||
JKRHeap* JKRHeap::findFromRoot(void* ptr) {
|
||||
if (lbl_80451378 == NULL) {
|
||||
JKRHeap* rootHeap = getRootHeap();
|
||||
if (rootHeap == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (lbl_80451378->getStartAddr() <= ptr && ptr < lbl_80451378->getEndAddr()) {
|
||||
return lbl_80451378->find(ptr);
|
||||
if (rootHeap->getStartAddr() <= ptr && ptr < rootHeap->getEndAddr()) {
|
||||
return rootHeap->find(ptr);
|
||||
}
|
||||
|
||||
return lbl_80451378->findAllHeap(ptr);
|
||||
return rootHeap->findAllHeap(ptr);
|
||||
}
|
||||
|
||||
JKRHeap* JKRHeap::find(void* ptr) const {
|
||||
@@ -241,6 +242,7 @@ JKRHeap* JKRHeap::find(void* ptr) const {
|
||||
}
|
||||
}
|
||||
|
||||
// todo: not sure about this... casting away const for now.
|
||||
return (JKRHeap*)this;
|
||||
}
|
||||
|
||||
@@ -261,7 +263,7 @@ JKRHeap* JKRHeap::findAllHeap(void* ptr) const {
|
||||
}
|
||||
|
||||
if (getStartAddr() <= ptr && ptr < getEndAddr()) {
|
||||
// not sure about this... casting away const for now.
|
||||
// todo: not sure about this... casting away const for now.
|
||||
return (JKRHeap*)this;
|
||||
}
|
||||
|
||||
@@ -306,13 +308,11 @@ void JKRHeap::dispose(void* begin, void* end) {
|
||||
// missing stack variable?
|
||||
#ifdef NONMATCHING
|
||||
void JKRHeap::dispose() {
|
||||
JKRDisposer* disposer;
|
||||
const JSUList<JKRDisposer>& list = mDisposerList;
|
||||
JSUListIterator<JKRDisposer> iterator;
|
||||
|
||||
JSUList<JKRDisposer>* list = &mDisposerList;
|
||||
while (iterator = list->getFirst(), iterator != list->getEnd()) {
|
||||
disposer = iterator.getObject();
|
||||
disposer->~JKRDisposer();
|
||||
while (list.getFirst() != list.getEnd()) {
|
||||
iterator = list.getFirst();
|
||||
iterator->~JKRDisposer();
|
||||
}
|
||||
}
|
||||
#else
|
||||
|
||||
@@ -146,15 +146,7 @@ void* JKRMemArchive::fetchResource(void* buffer, u32 bufferSize, SDIFileEntry* f
|
||||
if (fileEntry->data != NULL) {
|
||||
memcpy(buffer, fileEntry->data, srcLength);
|
||||
} else {
|
||||
JKRCompression compression;
|
||||
if (!fileEntry->isCompressed()) {
|
||||
compression = COMPRESSION_NONE;
|
||||
} else if (fileEntry->isYAZ0Compressed()) {
|
||||
compression = COMPRESSION_YAZ0;
|
||||
} else {
|
||||
compression = COMPRESSION_YAY0;
|
||||
}
|
||||
|
||||
JKRCompression compression = JKRConvertAttrToCompressionType(fileEntry->getAttr());
|
||||
void* data = mArchiveData + fileEntry->data_offset;
|
||||
srcLength =
|
||||
fetchResource_subroutine((u8*)data, srcLength, (u8*)buffer, bufferSize, compression);
|
||||
@@ -209,7 +201,7 @@ u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32
|
||||
|
||||
case COMPRESSION_YAY0:
|
||||
case COMPRESSION_YAZ0:
|
||||
u32 expendedSize = JKRDecompExpandSize(src);
|
||||
u32 expendedSize = JKRDecompExpandSize((SArcHeader*)src);
|
||||
srcLength = expendedSize;
|
||||
if (expendedSize > dstLength) {
|
||||
srcLength = dstLength;
|
||||
@@ -229,14 +221,14 @@ u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32
|
||||
return 0;
|
||||
}
|
||||
|
||||
u32 JKRMemArchive::getExpandedResSize(const void* resource) const {
|
||||
u32 JKRMemArchive::getExpandedResSize(const void* resource) {
|
||||
SDIFileEntry* fileEntry = findPtrResource(resource);
|
||||
if (fileEntry == NULL)
|
||||
return 0xFFFFFFFF;
|
||||
return -1;
|
||||
|
||||
if (fileEntry->isCompressed() == false) {
|
||||
return getResSize(resource);
|
||||
} else {
|
||||
return JKRDecompExpandSize(resource);
|
||||
return JKRDecompExpandSize((SArcHeader*)resource);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@ JKRThread::JKRThread(u32 stack_size, int message_count, int param_3) : mThreadLi
|
||||
|
||||
JKRHeap* heap = JKRHeap::findFromRoot(this);
|
||||
if (heap == NULL) {
|
||||
heap = lbl_80451370;
|
||||
heap = JKRHeap::getSystemHeap();
|
||||
}
|
||||
|
||||
setCommon_heapSpecified(heap, stack_size, param_3);
|
||||
@@ -27,7 +27,7 @@ JKRThread::JKRThread(JKRHeap* heap, u32 stack_size, int message_count, int param
|
||||
field_0x70 = 0;
|
||||
|
||||
if (heap == NULL) {
|
||||
heap = lbl_80451374;
|
||||
heap = JKRHeap::getCurrentHeap();
|
||||
}
|
||||
|
||||
setCommon_heapSpecified(heap, stack_size, param_4);
|
||||
@@ -49,8 +49,7 @@ JKRThread::JKRThread(OSThread* thread, int message_count) : mThreadListLink(this
|
||||
}
|
||||
|
||||
JKRThread::~JKRThread() {
|
||||
// lbl_8043428C = JKRThread::sThreadList
|
||||
lbl_8043428C.remove(&mThreadListLink);
|
||||
getList().remove(&mThreadListLink);
|
||||
|
||||
if (mHeap) {
|
||||
BOOL result = OSIsThreadTerminated(mThreadRecord);
|
||||
@@ -69,7 +68,7 @@ void JKRThread::setCommon_mesgQueue(JKRHeap* heap, int message_count) {
|
||||
mMessages = (OSMessage*)JKRHeap::alloc(mMessageCount * sizeof(OSMessage), 0, heap);
|
||||
|
||||
OSInitMessageQueue(&mMessageQueue, mMessages, mMessageCount);
|
||||
lbl_8043428C.append(&mThreadListLink);
|
||||
getList().append(&mThreadListLink);
|
||||
|
||||
mCurrentHeap = NULL;
|
||||
mCurrentHeapError = NULL;
|
||||
@@ -91,9 +90,9 @@ void* JKRThread::start(void* param) {
|
||||
}
|
||||
|
||||
JKRThread* JKRThread::searchThread(OSThread* thread) {
|
||||
JSUList<JKRThread>* threadList = JKRThread::getList();
|
||||
JSUList<JKRThread>& threadList = getList();
|
||||
JSUListIterator<JKRThread> iterator;
|
||||
for (iterator = threadList; iterator != threadList->getEnd(); ++iterator) {
|
||||
for (iterator = threadList.getFirst(); iterator != threadList.getEnd(); ++iterator) {
|
||||
if (iterator->getThreadRecord() == thread) {
|
||||
return iterator.getObject();
|
||||
}
|
||||
|
||||
@@ -64,7 +64,7 @@ void JUTXfb::destroyManager() {
|
||||
|
||||
void JUTXfb::initiate(u16 width, u16 height, JKRHeap* heap, JUTXfb::EXfbNumber xfb_number) {
|
||||
if (heap == NULL) {
|
||||
heap = /* sSystemHeap */ lbl_80451370;
|
||||
heap = JKRHeap::getSystemHeap();
|
||||
}
|
||||
|
||||
int size = ((u32)width + 0xf & 0xfff0) * (u32)height * 2;
|
||||
|
||||
Reference in New Issue
Block a user