mirror/ac-decomp
1
0
Fork 0
mirror of https://github.com/ACreTeam/ac-decomp synced 2026-08-08 18:13:05 -04:00
Code Issues Packages Projects Releases Wiki Activity

clean up and format code

Browse Source
This commit is contained in:
SwareJonge
2025-06-17 23:46:35 +02:00
parent c5e5f47880
commit c545a42c15
93 changed files with 7033 additions and 7909 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/JSystem/JKernel/JKRAram.h
+217 -218
View File
@@ -25,291 +25,290 @@ class JKRAramHeap;
class JKRDecompCommand;
class JKRAMCommand;
class JKRAramBlock
{
public:
JKRAramBlock(u32 address, u32 size, u32 freeSize, u8 groupID, bool tempMemory);
class JKRAramBlock {
public:
JKRAramBlock(u32 address, u32 size, u32 freeSize, u8 groupID, bool tempMemory);
virtual ~JKRAramBlock();
virtual ~JKRAramBlock();
JKRAramBlock* allocHead(u32 size, u8 groupID, JKRAramHeap* heap);
JKRAramBlock* allocTail(u32 size, u8 groupID, JKRAramHeap* heap);
JKRAramBlock* allocHead(u32 size, u8 groupID, JKRAramHeap* heap);
JKRAramBlock* allocTail(u32 size, u8 groupID, JKRAramHeap* heap);
u32 getAddress() const { return this->mAddress; }
u32 getSize() const { return this->mSize; }
u32 getFreeSize() const { return this->mFreeSize; }
bool isTempMemory() const { return this->mIsTempMemory; }
void newGroupID(u8 groupID) { this->mGroupID = groupID; }
u32 getAddress() const {
return this->mAddress;
}
u32 getSize() const {
return this->mSize;
}
u32 getFreeSize() const {
return this->mFreeSize;
}
bool isTempMemory() const {
return this->mIsTempMemory;
}
void newGroupID(u8 groupID) {
this->mGroupID = groupID;
}
JSULink<JKRAramBlock> mLink;
u32 mAddress;
u32 mSize;
u32 mFreeSize;
u8 mGroupID;
bool mIsTempMemory;
JSULink<JKRAramBlock> mLink;
u32 mAddress;
u32 mSize;
u32 mFreeSize;
u8 mGroupID;
bool mIsTempMemory;
friend class JKRAramHeap;
friend class JKRAramHeap;
};
class JKRAramHeap : public JKRDisposer
{
public:
enum EAllocMode
{
Head = 0,
Tail = 1
};
class JKRAramHeap : public JKRDisposer {
public:
enum EAllocMode { Head = 0, Tail = 1 };
JKRAramHeap(u32 baseAddress, u32 size);
JKRAramHeap(u32 baseAddress, u32 size);
virtual ~JKRAramHeap();
virtual ~JKRAramHeap();
JKRAramBlock* alloc(u32 size, EAllocMode mode);
void free(JKRAramBlock* block);
JKRAramBlock* allocFromHead(u32 size);
JKRAramBlock* allocFromTail(u32 size);
u32 getFreeSize();
u32 getTotalFreeSize();
u32 getUsedSize(u8 groupID);
void dump();
JKRAramBlock* alloc(u32 size, EAllocMode mode);
void free(JKRAramBlock* block);
JKRAramBlock* allocFromHead(u32 size);
JKRAramBlock* allocFromTail(u32 size);
u32 getFreeSize();
u32 getTotalFreeSize();
u32 getUsedSize(u8 groupID);
void dump();
u8 getCurrentGroupID() const { return this->mGroupID; }
JKRHeap* getMgrHeap() const { return this->mHeap; }
u8 getCurrentGroupID() const {
return this->mGroupID;
}
JKRHeap* getMgrHeap() const {
return this->mHeap;
}
void lock() { OSLockMutex(&this->mMutex); }
void unlock() { OSUnlockMutex(&this->mMutex); }
void lock() {
OSLockMutex(&this->mMutex);
}
void unlock() {
OSUnlockMutex(&this->mMutex);
}
static JSUList<JKRAramBlock> sAramList;
static JSUList<JKRAramBlock> sAramList;
OSMutex mMutex;
JKRHeap* mHeap;
u32 mHeadAddress;
u32 mTailAddress;
u32 mSize;
u8 mGroupID;
OSMutex mMutex;
JKRHeap* mHeap;
u32 mHeadAddress;
u32 mTailAddress;
u32 mSize;
u8 mGroupID;
friend class JKRAramBlock;
friend class JKRAramBlock;
};
class JKRAram : public JKRThread
{
public:
JKRAram(u32, u32, long);
class JKRAram : public JKRThread {
public:
JKRAram(u32, u32, long);
virtual ~JKRAram(); // _08
virtual void* run(); // _0C
virtual ~JKRAram(); // _08
virtual void* run(); // _0C
static bool checkOkAddress(u8* addr, u32 size, JKRAramBlock* block, u32 param_4);
static void changeGroupIdIfNeed(u8* data, int groupId);
static bool checkOkAddress(u8* addr, u32 size, JKRAramBlock* block, u32 param_4);
static void changeGroupIdIfNeed(u8* data, int groupId);
static JKRAram* create(u32, u32, long, long, long);
static JKRAramBlock* mainRamToAram(u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int);
static JKRAramBlock* mainRamToAram(u8*, JKRAramBlock* block, u32, JKRExpandSwitch, u32, JKRHeap*, int);
static u8* aramToMainRam(u32, u8*, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
static u8* aramToMainRam(JKRAramBlock*, u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
static JKRAram* create(u32, u32, long, long, long);
static JKRAramBlock* mainRamToAram(u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int);
static JKRAramBlock* mainRamToAram(u8*, JKRAramBlock* block, u32, JKRExpandSwitch, u32, JKRHeap*, int);
static u8* aramToMainRam(u32, u8*, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
static u8* aramToMainRam(JKRAramBlock*, u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
void aramSync(JKRAMCommand*, int);
void aramSync(JKRAMCommand*, int);
u32 getAudioMemory() const
{
return mAudioMemoryPtr;
}
u32 getAudioMemory() const {
return mAudioMemoryPtr;
}
u32 getAudioMemSize() const
{
return mAudioMemorySize;
}
u32 getAudioMemSize() const {
return mAudioMemorySize;
}
static u32 getSZSBufferSize()
{
return sSZSBufferSize;
}
static u32 getSZSBufferSize() {
return sSZSBufferSize;
}
static JKRAramHeap* getAramHeap()
{
return sAramObject->mAramHeap;
}
static JKRAramHeap* getAramHeap() {
return sAramObject->mAramHeap;
}
static JKRAram* getManager()
{
return sAramObject;
}
static JKRAram* getManager() {
return sAramObject;
}
static u8 decideAramGroupId(int id)
{
if (id < 0)
return getAramHeap()->getCurrentGroupID();
else
return id;
}
static u8 decideAramGroupId(int id) {
if (id < 0)
return getAramHeap()->getCurrentGroupID();
else
return id;
}
static u32 sSZSBufferSize;
static u32 sSZSBufferSize;
static JKRAram* sAramObject;
static OSMessage sMessageBuffer[4];
static OSMessageQueue sMessageQueue;
static JSUList<JKRAMCommand> sAramCommandList;
static JKRAram* sAramObject;
static OSMessage sMessageBuffer[4];
static OSMessageQueue sMessageQueue;
static JSUList<JKRAMCommand> sAramCommandList;
u32 mAudioMemoryPtr; // _7C
u32 mAudioMemorySize; // _80
u32 mGraphMemoryPtr; // _84
u32 mGraphMemorySize; // _88
u32 mUserMemoryPtr; // _8C
u32 mUserMemorySize; // _90
JKRAramHeap* mAramHeap; // _94
u32 mStackArray[3]; // _98
u32 mAudioMemoryPtr; // _7C
u32 mAudioMemorySize; // _80
u32 mGraphMemoryPtr; // _84
u32 mGraphMemorySize; // _88
u32 mUserMemoryPtr; // _8C
u32 mUserMemorySize; // _90
JKRAramHeap* mAramHeap; // _94
u32 mStackArray[3]; // _98
};
class JKRAMCommand : public ARQRequest
{
public:
typedef void (*AMCommandCallback)(u32);
class JKRAMCommand : public ARQRequest {
public:
typedef void (*AMCommandCallback)(u32);
JKRAMCommand();
~JKRAMCommand();
JKRAMCommand();
~JKRAMCommand();
JSULink<JKRAMCommand> mAramPieceCommandLink;
JSULink<JKRAMCommand> mLink30;
s32 mDirection;
u32 mLength;
u32 mSource;
u32 mDestination;
JKRAramBlock* mAramBlock;
u8 _54[4];
AMCommandCallback mCallback;
OSMessageQueue* mCompletedMesgQueue;
s32 mCallbackType;
JKRDecompCommand* mDecompCommand;
OSMessageQueue mMesgQueue;
OSMessage mMesgBuffer[1];
void* _8C;
void* _90;
void* _94;
JSULink<JKRAMCommand> mAramPieceCommandLink;
JSULink<JKRAMCommand> mLink30;
s32 mDirection;
u32 mLength;
u32 mSource;
u32 mDestination;
JKRAramBlock* mAramBlock;
u8 _54[4];
AMCommandCallback mCallback;
OSMessageQueue* mCompletedMesgQueue;
s32 mCallbackType;
JKRDecompCommand* mDecompCommand;
OSMessageQueue mMesgQueue;
OSMessage mMesgBuffer[1];
void* _8C;
void* _90;
void* _94;
};
class JKRAramCommand
{
public:
inline void setting(BOOL active, void* arg)
{
this->mActive = active;
this->mArg = arg;
}
class JKRAramCommand {
public:
inline void setting(BOOL active, void* arg) {
this->mActive = active;
this->mArg = arg;
}
BOOL mActive;
void* mArg;
BOOL mActive;
void* mArg;
};
class JKRAramPiece
{
public:
static JKRAMCommand* prepareCommand(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* aramBlock, JKRAMCommand::AMCommandCallback callback);
static void sendCommand(JKRAMCommand* cmd);
static JKRAMCommand* orderAsync(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* aramBlock, JKRAMCommand::AMCommandCallback callback);
static bool sync(JKRAMCommand* cmd, BOOL noBlock);
static bool orderSync(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* aramBlock);
static void startDMA(JKRAMCommand* cmd);
static void doneDMA(u32 arg);
class JKRAramPiece {
public:
static JKRAMCommand* prepareCommand(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* aramBlock,
JKRAMCommand::AMCommandCallback callback);
static void sendCommand(JKRAMCommand* cmd);
static JKRAMCommand* orderAsync(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* aramBlock,
JKRAMCommand::AMCommandCallback callback);
static bool sync(JKRAMCommand* cmd, BOOL noBlock);
static bool orderSync(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* aramBlock);
static void startDMA(JKRAMCommand* cmd);
static void doneDMA(u32 arg);
static OSMutex mMutex;
static JSUList<JKRAMCommand> sAramPieceCommandList;
static OSMutex mMutex;
static JSUList<JKRAMCommand> sAramPieceCommandList;
private:
static void lock() { OSLockMutex(&mMutex); }
static void unlock() { OSUnlockMutex(&mMutex); }
private:
static void lock() {
OSLockMutex(&mMutex);
}
static void unlock() {
OSUnlockMutex(&mMutex);
}
};
class JKRAramStreamCommand
{
public:
enum ECommandType
{
ECT_UNK = 0,
ECT_READ = 1,
ECT_WRITE = 2,
};
class JKRAramStreamCommand {
public:
enum ECommandType {
ECT_UNK = 0,
ECT_READ = 1,
ECT_WRITE = 2,
};
JKRAramStreamCommand();
JKRAramStreamCommand();
ECommandType type; // _00
u32 mAddress; // _04
u32 mSize; // _08
u32 _0C; // _0C
JSUFileInputStream* mStream; // _10
u32 mOffset; // _14
u8* mTransferBuffer; // _18
u32 mTransferBufferSize; // _1C
JKRHeap* mHeap; // _20
bool mAllocatedTransferBuffer; // _24
u32 _28; // _28
OSMessageQueue mMessageQueue; // _2C
void* mMessage; // _4C
u32 _50; // _50
u32 _54; // _54
ECommandType type; // _00
u32 mAddress; // _04
u32 mSize; // _08
u32 _0C; // _0C
JSUFileInputStream* mStream; // _10
u32 mOffset; // _14
u8* mTransferBuffer; // _18
u32 mTransferBufferSize; // _1C
JKRHeap* mHeap; // _20
bool mAllocatedTransferBuffer; // _24
u32 _28; // _28
OSMessageQueue mMessageQueue; // _2C
void* mMessage; // _4C
u32 _50; // _50
u32 _54; // _54
};
class JKRAramStream : public JKRThread
{
public:
JKRAramStream(long);
class JKRAramStream : public JKRThread {
public:
JKRAramStream(long);
virtual ~JKRAramStream(); // _08
virtual void* run(); // _0C
virtual ~JKRAramStream(); // _08
virtual void* run(); // _0C
static JKRAramStream* create(s32);
static JKRAramStream* create(s32);
static u32 readFromAram();
static s32 writeToAram(JKRAramStreamCommand*);
static JKRAramStreamCommand* write_StreamToAram_Async(JSUFileInputStream*, JKRAramBlock*, u32, u32);
static JKRAramStreamCommand* write_StreamToAram_Async(JSUFileInputStream*, u32, u32, u32);
static JKRAramStreamCommand* sync(JKRAramStreamCommand*, BOOL);
static void setTransBuffer(u8*, u32, JKRHeap*);
static u32 readFromAram();
static s32 writeToAram(JKRAramStreamCommand*);
static JKRAramStreamCommand* write_StreamToAram_Async(JSUFileInputStream*, JKRAramBlock*, u32, u32);
static JKRAramStreamCommand* write_StreamToAram_Async(JSUFileInputStream*, u32, u32, u32);
static JKRAramStreamCommand* sync(JKRAramStreamCommand*, BOOL);
static void setTransBuffer(u8*, u32, JKRHeap*);
static JKRAramStream* sAramStreamObject;
static OSMessage sMessageBuffer[4];
static OSMessageQueue sMessageQueue;
static JKRAramStream* sAramStreamObject;
static OSMessage sMessageBuffer[4];
static OSMessageQueue sMessageQueue;
static u8* transBuffer;
static JKRHeap* transHeap;
static u32 transSize;
static u8* transBuffer;
static JKRHeap* transHeap;
static u32 transSize;
// _00 = VTBL
// _00-_7C = JKRThread
// _00 = VTBL
// _00-_7C = JKRThread
};
inline JKRAramBlock* JKRAllocFromAram(u32 size, JKRAramHeap::EAllocMode allocMode)
{
return JKRAram::getAramHeap()->alloc(size, allocMode);
inline JKRAramBlock* JKRAllocFromAram(u32 size, JKRAramHeap::EAllocMode allocMode) {
return JKRAram::getAramHeap()->alloc(size, allocMode);
}
inline void JKRFreeToAram(JKRAramBlock* block)
{
JKRAram::getAramHeap()->free(block);
inline void JKRFreeToAram(JKRAramBlock* block) {
JKRAram::getAramHeap()->free(block);
}
inline u8* JKRAramToMainRam(u32 address, u8* buf, u32 bufSize, JKRExpandSwitch expandSwitch, u32 p5, JKRHeap* heap, int id, u32* pSize)
{
return JKRAram::aramToMainRam(address, buf, bufSize, expandSwitch, p5, heap, id, pSize);
inline u8* JKRAramToMainRam(u32 address, u8* buf, u32 bufSize, JKRExpandSwitch expandSwitch, u32 p5, JKRHeap* heap,
int id, u32* pSize) {
return JKRAram::aramToMainRam(address, buf, bufSize, expandSwitch, p5, heap, id, pSize);
}
inline JKRAramBlock* JKRMainRamToAram(u8* buf, u32 bufSize, u32 alignedSize, JKRExpandSwitch expandSwitch, u32 fileSize, JKRHeap* heap, int id, u32)
{
return JKRAram::mainRamToAram(buf, bufSize, alignedSize, expandSwitch, fileSize, heap, id);
inline JKRAramBlock* JKRMainRamToAram(u8* buf, u32 bufSize, u32 alignedSize, JKRExpandSwitch expandSwitch, u32 fileSize,
JKRHeap* heap, int id, u32) {
return JKRAram::mainRamToAram(buf, bufSize, alignedSize, expandSwitch, fileSize, heap, id);
}
inline JKRAramStream* JKRCreateAramStreamManager(s32 priority)
{
return JKRAramStream::create(priority);
inline JKRAramStream* JKRCreateAramStreamManager(s32 priority) {
return JKRAramStream::create(priority);
}
inline bool JKRAramPcs(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* block)
{
return JKRAramPiece::orderSync(direction, source, destination, length, block);
inline bool JKRAramPcs(int direction, u32 source, u32 destination, u32 length, JKRAramBlock* block) {
return JKRAramPiece::orderSync(direction, source, destination, length, block);
}
inline void JKRAramPcs_SendCommand(JKRAMCommand* cmd)
{
JKRAramPiece::sendCommand(cmd);
inline void JKRAramPcs_SendCommand(JKRAMCommand* cmd) {
JKRAramPiece::sendCommand(cmd);
}
#endif
include/JSystem/JKernel/JKRArchive.h
+142 -111
View File
@@ -12,17 +12,14 @@
#define JKRARCHIVE_ATTR_COMPRESSION 0x04
#define JKRARCHIVE_ATTR_YAY0 0x80
inline u32 read_big_endian_u32(void* ptr)
{
inline u32 read_big_endian_u32(void* ptr) {
u8* uptr = (u8*)ptr;
return ((u32)uptr[0] << 0x18) | ((u32)uptr[1] << 0x10) | ((u32)uptr[2] << 8) | (u32)uptr[3];
}
class JKRArchive : public JKRFileLoader
{
public:
enum EMountMode
{
class JKRArchive : public JKRFileLoader {
public:
enum EMountMode {
UNKNOWN_MOUNT_MODE = 0,
MOUNT_MEM = 1,
MOUNT_ARAM = 2,
@@ -30,26 +27,33 @@ public:
MOUNT_COMP = 4,
};
enum EMountDirection
{
enum EMountDirection {
UNKNOWN_MOUNT_DIRECTION = 0,
MOUNT_DIRECTION_HEAD = 1,
MOUNT_DIRECTION_TAIL = 2,
};
class CArcName
{
public:
CArcName(const char** p1, char p2) { p1[0] = store(p1[0], p2); }
class CArcName {
public:
CArcName(const char** p1, char p2) {
p1[0] = store(p1[0], p2);
}
const char* getString() const { return mString; }
u16 getHash() const { return mHash; }
const char* getString() const {
return mString;
}
u16 getHash() const {
return mHash;
}
void store(const char*);
const char* store(const char*, char);
// Unused/inlined:
CArcName() {}
CArcName(const char* data) { store(data); }
CArcName() {
}
CArcName(const char* data) {
store(data);
}
u16 mHash; // _00
u16 _02; // _02
@@ -57,23 +61,50 @@ public:
u8 _104[4]; // _104, unknown, used to fix stack size
};
struct SDIFileEntry
{
u16 getNameHash() const { return mHash; }
u32 getNameOffset() const { return mFlag & 0xFFFFFF; }
u32 getFlags() const { return mFlag >> 24; }
u32 getAttr() const { return getFlags(); }
u32 getSize() { return mSize; }
u16 getFileID() const { return mFileID; }
bool isDirectory() const { return (getFlags() & 0x02) != 0; }
bool isCompressed() const { return (getFlags() & 0x04) != 0; }
u8 getCompressFlag() const { return (getFlags() & 0x04); } // apparently both necessary?
bool isYAZ0Compressed() const { return (getFlags() & 0x80) != 0; }
struct SDIFileEntry {
u16 getNameHash() const {
return mHash;
}
u32 getNameOffset() const {
return mFlag & 0xFFFFFF;
}
u32 getFlags() const {
return mFlag >> 24;
}
u32 getAttr() const {
return getFlags();
}
u32 getSize() {
return mSize;
}
u16 getFileID() const {
return mFileID;
}
bool isDirectory() const {
return (getFlags() & 0x02) != 0;
}
bool isCompressed() const {
return (getFlags() & 0x04) != 0;
}
u8 getCompressFlag() const {
return (getFlags() & 0x04);
} // apparently both necessary?
bool isYAZ0Compressed() const {
return (getFlags() & 0x80) != 0;
}
bool getFlag01() const { return (getFlags() & 0x01) != 0; }
bool getFlag04() { return mFlag >> 0x18 & 0x04; }
bool getFlag10() { return mFlag >> 0x18 & 0x10; }
bool getFlag80() { return mFlag >> 0x18 & 0x80; }
bool getFlag01() const {
return (getFlags() & 0x01) != 0;
}
bool getFlag04() {
return mFlag >> 0x18 & 0x04;
}
bool getFlag10() {
return mFlag >> 0x18 & 0x10;
}
bool getFlag80() {
return mFlag >> 0x18 & 0x80;
}
u16 mFileID; // _00
u16 mHash; // _02
@@ -83,16 +114,14 @@ public:
void* mData; // _10
};
struct SDirEntry
{
struct SDirEntry {
u8 mFlags; // _00
u8 _01; // _01
u16 mID; // _02
char* mName; // _04
};
struct SDIDirEntry
{
struct SDIDirEntry {
u32 mType; // _00
u32 mOffset; // _04
u16 _08; // _08
@@ -101,8 +130,7 @@ public:
};
// NB: Fabricated name
struct SArcDataInfo
{
struct SArcDataInfo {
u32 num_nodes; // _00
u32 node_offset; // _04
u32 num_file_entries; // _08
@@ -115,8 +143,7 @@ public:
};
// NB: Fabricated name - need to check size
struct SArcHeader
{
struct SArcHeader {
u32 signature; // _00
u32 file_length; // _04
u32 header_length; // _08
@@ -127,26 +154,28 @@ public:
u32 _1C; // _1C
};
public:
virtual bool becomeCurrent(const char*); // _10
virtual void* getResource(const char* path); // _14
virtual void* getResource(u32 type, const char* name); // _18
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, const char* path, JKRExpandSwitch expandSwitch); // _1C
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, u32 type, const char* name); // _20
virtual void removeResourceAll(); // _24
virtual bool removeResource(void*); // _28
virtual bool detachResource(void*); // _2C
virtual s32 getResSize(const void*) const; // _30
virtual u32 countFile(const char*) const; // _34
virtual JKRFileFinder* getFirstFile(const char*) const; // _38
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize) = 0; // _40
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize, JKRExpandSwitch expandSwitch) = 0; // _44
public:
virtual bool becomeCurrent(const char*); // _10
virtual void* getResource(const char* path); // _14
virtual void* getResource(u32 type, const char* name); // _18
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, const char* path,
JKRExpandSwitch expandSwitch); // _1C
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, u32 type, const char* name); // _20
virtual void removeResourceAll(); // _24
virtual bool removeResource(void*); // _28
virtual bool detachResource(void*); // _2C
virtual s32 getResSize(const void*) const; // _30
virtual u32 countFile(const char*) const; // _34
virtual JKRFileFinder* getFirstFile(const char*) const; // _38
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize) = 0; // _40
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize,
JKRExpandSwitch expandSwitch) = 0; // _44
JKRArchive(s32, EMountMode);
JKRArchive();
JKRArchive(const char* p1, EMountMode mountMode);
~JKRArchive();
SDIDirEntry* findDirectory(const char*, u32) const;
SDIFileEntry* findFsResource(const char*, u32) const;
SDIFileEntry* findIdResource(u16) const;
@@ -170,8 +199,7 @@ public:
SDIDirEntry* findResType(u32) const;
SDIFileEntry* findTypeResource(u32, u32) const;
static int convertAttrToCompressionType(int attr)
{
static int convertAttrToCompressionType(int attr) {
int compression;
if (FLAG_ON(attr, JKRARCHIVE_ATTR_COMPRESSION))
compression = JKRCOMPRESSION_NONE;
@@ -183,15 +211,25 @@ public:
return compression;
}
u32 getMountMode() const { return mMountMode; }
u32 countFile() const { return mArcInfoBlock->num_file_entries; }
int countDirectory() const { return mArcInfoBlock->num_nodes; }
static u32 getCurrentDirID() { return sCurrentDirID; }
static void setCurrentDirID(u32 dirID) { sCurrentDirID = dirID; }
u32 getMountMode() const {
return mMountMode;
}
u32 countFile() const {
return mArcInfoBlock->num_file_entries;
}
int countDirectory() const {
return mArcInfoBlock->num_nodes;
}
static u32 getCurrentDirID() {
return sCurrentDirID;
}
static void setCurrentDirID(u32 dirID) {
sCurrentDirID = dirID;
}
static u32 sCurrentDirID;
protected:
protected:
// _00 = VTBL
// _00-_38 = JKRFileLoader
JKRHeap* mHeap; // _38
@@ -206,20 +244,15 @@ protected:
EMountDirection mMountDirection; // _5C
};
enum JKRMemBreakFlag
{
MBF_0 = 0,
MBF_1 = 1
};
enum JKRMemBreakFlag { MBF_0 = 0, MBF_1 = 1 };
class JKRAramArchive : public JKRArchive
{
public:
class JKRAramArchive : public JKRArchive {
public:
JKRAramArchive();
JKRAramArchive(s32, EMountDirection);
virtual ~JKRAramArchive(); // _08
virtual void* fetchResource(SDIFileEntry*, u32*); // _40
virtual ~JKRAramArchive(); // _08
virtual void* fetchResource(SDIFileEntry*, u32*); // _40
virtual void* fetchResource(void*, u32, SDIFileEntry*, u32*, JKRExpandSwitch expandSwitch); // _44
bool open(s32);
@@ -239,15 +272,15 @@ public:
JKRFile* mDvdFile; // _64
};
struct JKRCompArchive : public JKRArchive
{
struct JKRCompArchive : public JKRArchive {
JKRCompArchive(s32, EMountDirection);
virtual ~JKRCompArchive(); // _08
virtual void removeResourceAll(); // _24
virtual bool removeResource(void*); // _28
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize); // _40
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize, JKRExpandSwitch expandSwitch); // _44
virtual ~JKRCompArchive(); // _08
virtual void removeResourceAll(); // _24
virtual bool removeResource(void*); // _28
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize); // _40
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize,
JKRExpandSwitch expandSwitch); // _44
bool open(s32);
@@ -259,23 +292,23 @@ struct JKRCompArchive : public JKRArchive
// _00 = VTBL
// _00-_5C = JKRArchive
u32 _60; // _60
JKRAramBlock* mAramPart; // _64
u32 _68; // _68
JKRFile* mDvdFile; // _6C
u32 mSizeOfMemPart; // _70
u32 mSizeOfAramPart; // _74
u32 _78; // _78
u32 _60; // _60
JKRAramBlock* mAramPart; // _64
u32 _68; // _68
JKRFile* mDvdFile; // _6C
u32 mSizeOfMemPart; // _70
u32 mSizeOfAramPart; // _74
u32 _78; // _78
};
struct JKRDvdArchive : public JKRArchive
{
struct JKRDvdArchive : public JKRArchive {
JKRDvdArchive();
JKRDvdArchive(s32, JKRArchive::EMountDirection);
virtual ~JKRDvdArchive(); // _00
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize); // _38
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize, JKRExpandSwitch expandSwitch); // _3C
virtual ~JKRDvdArchive(); // _00
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize); // _38
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize,
JKRExpandSwitch expandSwitch); // _3C
bool open(s32);
static u32 fetchResource_subroutine(s32, u32, u32, u8*, u32, int, int);
@@ -289,22 +322,22 @@ struct JKRDvdArchive : public JKRArchive
// _00 = VTBL
// _00-_5C = JKRArchive
int _60; // _60
JKRFile* mDvdFile; // _64
int _60; // _60
JKRFile* mDvdFile; // _64
};
struct JKRMemArchive : public JKRArchive
{
struct JKRMemArchive : public JKRArchive {
JKRMemArchive(); // unused/inlined
JKRMemArchive(s32, EMountDirection);
JKRMemArchive(void*, u32, JKRMemBreakFlag);
JKRMemArchive(const char*, EMountDirection); // unused/inlined
virtual ~JKRMemArchive(); // _08
virtual void removeResourceAll(); // _24
virtual bool removeResource(void*); // _28
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize); // _40
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize, JKRExpandSwitch expandSwitch); // _44
virtual ~JKRMemArchive(); // _08
virtual void removeResourceAll(); // _24
virtual bool removeResource(void*); // _28
virtual void* fetchResource(SDIFileEntry* entry, u32* outSize); // _40
virtual void* fetchResource(void* resourceBuffer, u32 bufferSize, SDIFileEntry* entry, u32* resSize,
JKRExpandSwitch expandSwitch); // _44
bool open(s32, EMountDirection);
bool open(void*, u32, JKRMemBreakFlag);
@@ -320,23 +353,21 @@ struct JKRMemArchive : public JKRArchive
// _00 = VTBL
// _00-_60 = JKRArchive
SArcHeader* mArcHeader; // _60
u8* mArchiveData; // _64
bool mIsOpen; // _68
SArcHeader* mArcHeader; // _60
u8* mArchiveData; // _64
bool mIsOpen; // _68
};
inline int JKRConvertAttrToCompressionType(int attr)
{
inline int JKRConvertAttrToCompressionType(int attr) {
return JKRArchive::convertAttrToCompressionType(attr);
}
inline JKRArchive* JKRMountArchive(const char* path, JKRArchive::EMountMode mountMode, JKRHeap* heap, JKRArchive::EMountDirection mountDirection)
{
inline JKRArchive* JKRMountArchive(const char* path, JKRArchive::EMountMode mountMode, JKRHeap* heap,
JKRArchive::EMountDirection mountDirection) {
return JKRArchive::mount(path, mountMode, heap, mountDirection);
}
inline JKRArchive* JKRMountArchive(void* inBuf, JKRHeap* heap, JKRArchive::EMountDirection mountDirection)
{
inline JKRArchive* JKRMountArchive(void* inBuf, JKRHeap* heap, JKRArchive::EMountDirection mountDirection) {
return JKRArchive::mount(inBuf, heap, mountDirection);
}
include/JSystem/JKernel/JKRDecomp.h
+50 -54
View File
@@ -13,96 +13,92 @@
#define JKRDECOMP_STACK_SIZE 0x4000
#define JKRDECOMP_THREAD_MSG_BUF_COUNT 16
#define JKRDECOMP_READU32BE(ptr, offset) (((u32)ptr[offset] << 24) | ((u32)ptr[offset + 1] << 16) | ((u32)ptr[offset + 2] << 8) | (u32)ptr[offset + 3])
#define JKRDECOMP_READU32BE(ptr, offset) \
(((u32)ptr[offset] << 24) | ((u32)ptr[offset + 1] << 16) | ((u32)ptr[offset + 2] << 8) | (u32)ptr[offset + 3])
#define SZ_MIN_BACKSIZE 3
#define SZ_DEFAULT_BACKSIZE 15 + SZ_MIN_BACKSIZE
#define SZP_GETBACKOFS(buf) (((*((u8*)buf) & 0xF) << 8) | (*(((u8*)buf)+1)))
#define SZP_GETBACKOFS(buf) (((*((u8*)buf) & 0xF) << 8) | (*(((u8*)buf) + 1)))
#define SZP_GETCOUNT(buf) (*((u16*)buf) >> 12)
typedef void DecompCallback(u32);
class JKRDecompCommand {
public:
enum TransferType {
MRAM = 0,
ARAM = 1
};
public:
enum TransferType { MRAM = 0, ARAM = 1 };
JKRDecompCommand();
~JKRDecompCommand();
JKRDecompCommand();
~JKRDecompCommand();
u8 _00[4];
u8* mSrcBuffer;
u8* mDstBuffer;
u32 mSrcLength;
u32 mSkipCount;
DecompCallback* mCallback;
JKRDecompCommand* mCmd;
OSMessageQueue* pMesgQueue1C;
TransferType transferType;
JKRAMCommand* mAMCommand;
OSMessageQueue mMesgQueue;
OSMessage mMesgBuffer[1];
u8 _00[4];
u8* mSrcBuffer;
u8* mDstBuffer;
u32 mSrcLength;
u32 mSkipCount;
DecompCallback* mCallback;
JKRDecompCommand* mCmd;
OSMessageQueue* pMesgQueue1C;
TransferType transferType;
JKRAMCommand* mAMCommand;
OSMessageQueue mMesgQueue;
OSMessage mMesgBuffer[1];
};
class JKRDecomp : public JKRThread {
public:
enum CompressionMode {
NONE = 0,
SZP = 1,
SZS = 2
};
public:
enum CompressionMode { NONE = 0, SZP = 1, SZS = 2 };
JKRDecomp(s32 decompPriority);
JKRDecomp(s32 decompPriority);
virtual ~JKRDecomp();
virtual ~JKRDecomp();
virtual void* run();
virtual void* run();
static JKRDecompCommand* prepareCommand(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount, DecompCallback* callback);
static CompressionMode checkCompressed(u8* buf);
static JKRDecomp* create(s32 decompPriority);
static void decode(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static void decodeSZP(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static void decodeSZS(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static bool orderSync(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static JKRDecompCommand* orderAsync(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount, DecompCallback* callback);
static bool sync(JKRDecompCommand* cmd, BOOL noBlock);
static BOOL sendCommand(JKRDecompCommand* cmd);
static JKRDecompCommand* prepareCommand(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount,
DecompCallback* callback);
static CompressionMode checkCompressed(u8* buf);
static JKRDecomp* create(s32 decompPriority);
static void decode(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static void decodeSZP(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static void decodeSZS(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static bool orderSync(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount);
static JKRDecompCommand* orderAsync(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 skipCount,
DecompCallback* callback);
static bool sync(JKRDecompCommand* cmd, BOOL noBlock);
static BOOL sendCommand(JKRDecompCommand* cmd);
static OSMessageQueue sMessageQueue;
static OSMessage sMessageBuffer[JKRDECOMP_MSG_BUF_COUNT];
static JKRDecomp* sDecompObject;
static OSMessageQueue sMessageQueue;
static OSMessage sMessageBuffer[JKRDECOMP_MSG_BUF_COUNT];
static JKRDecomp* sDecompObject;
};
inline JKRDecomp* JKRCreateDecompManager(s32 priority) {
return JKRDecomp::create(priority);
return JKRDecomp::create(priority);
}
inline int JKRCheckCompressed_noASR(u8* pBuf)
{
int compression = JKRDecomp::checkCompressed(pBuf);
if (compression == JKRCOMPRESSION_ASR)
compression = JKRCOMPRESSION_NONE;
return compression;
inline int JKRCheckCompressed_noASR(u8* pBuf) {
int compression = JKRDecomp::checkCompressed(pBuf);
if (compression == JKRCOMPRESSION_ASR)
compression = JKRCOMPRESSION_NONE;
return compression;
}
inline JKRDecomp::CompressionMode JKRCheckCompressed(u8* buf) {
return JKRDecomp::checkCompressed(buf);
return JKRDecomp::checkCompressed(buf);
}
inline u32 JKRDecompExpandSize(u8* buf) {
return (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
return (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
}
inline void JKRDecompress(u8* src, u8* dst, u32 srcLength, u32 skipCount) {
JKRDecomp::orderSync(src, dst, srcLength, skipCount);
JKRDecomp::orderSync(src, dst, srcLength, skipCount);
}
int JKRDecompressFromDVD(JKRDvdFile* srcFile, void* buf, u32 size, u32 maxDest, u32 fileOffset, u32 srcOffset);
int JKRDecompressFromDVDToAram(JKRDvdFile* srcFile, u32 address, u32 fileSize, u32 maxDest, u32 fileOffset, u32 srcOffset);
int JKRDecompressFromDVDToAram(JKRDvdFile* srcFile, u32 address, u32 fileSize, u32 maxDest, u32 fileOffset,
u32 srcOffset);
int JKRDecompressFromAramToMainRam(u32 srcAddress, void* dst, u32 fileSize, u32 maxDest, u32 fileOffset);
#endif
include/JSystem/JKernel/JKRDisposer.h
+3 -5
View File
@@ -9,17 +9,15 @@ extern "C" {
class JKRHeap;
class JKRDisposer
{
public:
class JKRDisposer {
public:
JKRDisposer();
virtual ~JKRDisposer();
public:
public:
JKRHeap* mRootHeap; // _4
JSULink<JKRDisposer> mPointerLinks; // _8
};
}
#endif
include/JSystem/JKernel/JKRDvdAramRipper.h
+11 -10
View File
@@ -7,9 +7,8 @@
#include "types.h"
#ifdef __cplusplus
class JKRADCommand
{
public:
class JKRADCommand {
public:
typedef void (*LoadCallback)(u32);
JKRADCommand();
~JKRADCommand();
@@ -30,9 +29,8 @@ public:
JKRAramStreamCommand* mStreamCommand; // _48
};
class JKRDvdAramRipper
{
public:
class JKRDvdAramRipper {
public:
static JKRAramBlock* loadToAram(char const*, u32, JKRExpandSwitch, u32, u32);
static JKRAramBlock* loadToAram(s32, u32, JKRExpandSwitch, u32, u32);
static JKRAramBlock* loadToAram(JKRDvdFile*, u32, JKRExpandSwitch, u32, u32);
@@ -47,16 +45,19 @@ public:
static void countLeftSync();
static void afterAramAsync(JKRADCommand*);
static int getSZSBufferSize() { return sSZSBufferSize; }
static bool isErrorRetry() { return errorRetry; }
static int getSZSBufferSize() {
return sSZSBufferSize;
}
static bool isErrorRetry() {
return errorRetry;
}
static bool errorRetry;
static int sSZSBufferSize;
static JSUList<JKRADCommand> sDvdAramAsyncList;
};
inline JKRAramBlock* JKRDvdToAram(s32 entrynum, u32 p2, JKRExpandSwitch expSwitch, u32 p4, u32 p5)
{
inline JKRAramBlock* JKRDvdToAram(s32 entrynum, u32 p2, JKRExpandSwitch expSwitch, u32 p4, u32 p5) {
return JKRDvdAramRipper::loadToAram(entrynum, p2, expSwitch, p4, p5);
}
include/JSystem/JKernel/JKRDvdFile.h
+56 -53
View File
@@ -9,73 +9,76 @@
class JKRDvdFile;
struct JKRDvdFileInfo : public DVDFileInfo {
JKRDvdFile* mFile;
JKRDvdFile* mFile;
};
class JKRDvdFile : public JKRFile {
public:
JKRDvdFile();
JKRDvdFile(const char* filename);
JKRDvdFile(s32 entrynum);
public:
JKRDvdFile();
JKRDvdFile(const char* filename);
JKRDvdFile(s32 entrynum);
virtual ~JKRDvdFile();
virtual ~JKRDvdFile();
virtual bool open(const char* filename);
virtual bool close();
virtual int readData(void* data, s32 length, s32 ofs);
virtual int writeData(const void* data, s32 length, s32 ofs);
virtual u32 getFileSize() const { return this->mDvdFileInfo.length; }
virtual bool open(s32 entrynum);
inline DVDFileInfo* getFileInfo() {
return &this->mDvdFileInfo;
}
inline int readDataAsync(void* addr, s32 length, s32 offset) {
OSLockMutex(&this->mDvdMutex);
s32 retAddr;
if (this->mDvdThread != nullptr) {
OSUnlockMutex(&this->mDvdMutex);
retAddr = -1;
virtual bool open(const char* filename);
virtual bool close();
virtual int readData(void* data, s32 length, s32 ofs);
virtual int writeData(const void* data, s32 length, s32 ofs);
virtual u32 getFileSize() const {
return this->mDvdFileInfo.length;
}
else {
this->mDvdThread = OSGetCurrentThread();
retAddr = -1;
if (DVDReadAsync(&this->mDvdFileInfo, addr, length, offset, JKRDvdFile::doneProcess)) {
retAddr = this->sync();
}
virtual bool open(s32 entrynum);
this->mDvdThread = nullptr;
OSUnlockMutex(&this->mDvdMutex);
inline DVDFileInfo* getFileInfo() {
return &this->mDvdFileInfo;
}
return retAddr;
}
inline int readDataAsync(void* addr, s32 length, s32 offset) {
OSLockMutex(&this->mDvdMutex);
s32 retAddr;
inline int writeDataAsync(const void* data, s32 length, s32 offset) { return -1; }
if (this->mDvdThread != nullptr) {
OSUnlockMutex(&this->mDvdMutex);
retAddr = -1;
} else {
this->mDvdThread = OSGetCurrentThread();
retAddr = -1;
if (DVDReadAsync(&this->mDvdFileInfo, addr, length, offset, JKRDvdFile::doneProcess)) {
retAddr = this->sync();
}
void initiate();
s32 sync();
this->mDvdThread = nullptr;
OSUnlockMutex(&this->mDvdMutex);
}
static void doneProcess(s32 result, DVDFileInfo* info);
return retAddr;
}
static JSUList<JKRDvdFile> sDvdList;
inline int writeDataAsync(const void* data, s32 length, s32 offset) {
return -1;
}
public:
OSMutex mDvdMutex;
OSMutex mAramMutex;
JKRAramBlock* mAramBlock;
OSThread* mAramThread;
JSUFileInputStream* mInputStream;
u32 _58;
JKRDvdFileInfo mDvdFileInfo;
OSMessageQueue mAramMessageQueue;
OSMessage mAramMessage;
OSMessageQueue mDvdMessageQueue;
OSMessage mDvdMessage;
JSULink<JKRDvdFile> mLink;
OSThread* mDvdThread;
void initiate();
s32 sync();
static void doneProcess(s32 result, DVDFileInfo* info);
static JSUList<JKRDvdFile> sDvdList;
public:
OSMutex mDvdMutex;
OSMutex mAramMutex;
JKRAramBlock* mAramBlock;
OSThread* mAramThread;
JSUFileInputStream* mInputStream;
u32 _58;
JKRDvdFileInfo mDvdFileInfo;
OSMessageQueue mAramMessageQueue;
OSMessage mAramMessage;
OSMessageQueue mDvdMessageQueue;
OSMessage mDvdMessage;
JSULink<JKRDvdFile> mLink;
OSThread* mDvdThread;
};
#endif
include/JSystem/JKernel/JKRDvdRipper.h
+27 -24
View File
@@ -12,47 +12,50 @@
#define DMA_BUFFERSIZE 0x100
struct SZPHeader {
u32 magic;
u32 decompSize;
u32 magic;
u32 decompSize;
};
struct SYaz0Header {
u32 signature;
u32 length;
u32 signature;
u32 length;
};
class JKRDMCommand {
JKRDMCommand();
~JKRDMCommand();
JKRDMCommand();
~JKRDMCommand();
};
class JKRDvdRipper {
public:
enum EAllocDirection {
ALLOC_DIR_DEFAULT = 0,
ALLOC_DIR_TOP = 1,
ALLOC_DIR_BOTTOM = 2
};
public:
enum EAllocDirection { ALLOC_DIR_DEFAULT = 0, ALLOC_DIR_TOP = 1, ALLOC_DIR_BOTTOM = 2 };
static void* loadToMainRAM(const char* file, u8* buf, JKRExpandSwitch expandSwitch, u32 maxDest, JKRHeap* heap, EAllocDirection allocDir, u32 offset, int* compressMode);
static void* loadToMainRAM(s32 entrynum, u8* buf, JKRExpandSwitch expandSwitch, u32 maxDest, JKRHeap* heap, EAllocDirection allocDir, u32 offset, int* compressMode);
static void* loadToMainRAM(JKRDvdFile* file, u8* buf, JKRExpandSwitch expandSwitch, u32 maxDest, JKRHeap* heap, EAllocDirection allocDir, u32 offset, int* compressMode);
static void* loadToMainRAM(const char* file, u8* buf, JKRExpandSwitch expandSwitch, u32 maxDest, JKRHeap* heap,
EAllocDirection allocDir, u32 offset, int* compressMode);
static void* loadToMainRAM(s32 entrynum, u8* buf, JKRExpandSwitch expandSwitch, u32 maxDest, JKRHeap* heap,
EAllocDirection allocDir, u32 offset, int* compressMode);
static void* loadToMainRAM(JKRDvdFile* file, u8* buf, JKRExpandSwitch expandSwitch, u32 maxDest, JKRHeap* heap,
EAllocDirection allocDir, u32 offset, int* compressMode);
static inline bool isErrorRetry() { return JKRDvdRipper::errorRetry; }
static inline bool isErrorRetry() {
return JKRDvdRipper::errorRetry;
}
static JSUList<JKRDMCommand> sDvdAsyncList;
static JSUList<JKRDMCommand> sDvdAsyncList;
static bool errorRetry;
static bool errorRetry;
};
inline void* JKRDvdToMainRam(long entryNum, u8* dst, JKRExpandSwitch expandSwitch, u32 fileSize, JKRHeap* heap, JKRDvdRipper::EAllocDirection allocDirection, u32 startOffset, int* pCompression)
{
return JKRDvdRipper::loadToMainRAM(entryNum, dst, expandSwitch, fileSize, heap, allocDirection, startOffset, pCompression);
inline void* JKRDvdToMainRam(long entryNum, u8* dst, JKRExpandSwitch expandSwitch, u32 fileSize, JKRHeap* heap,
JKRDvdRipper::EAllocDirection allocDirection, u32 startOffset, int* pCompression) {
return JKRDvdRipper::loadToMainRAM(entryNum, dst, expandSwitch, fileSize, heap, allocDirection, startOffset,
pCompression);
}
inline void* JKRDvdToMainRam(const char* path, u8* dst, JKRExpandSwitch expandSwitch, u32 fileSize, JKRHeap* heap, JKRDvdRipper::EAllocDirection allocDirection, u32 startOffset, int* pCompression)
{
return JKRDvdRipper::loadToMainRAM(path, dst, expandSwitch, fileSize, heap, allocDirection, startOffset, pCompression);
inline void* JKRDvdToMainRam(const char* path, u8* dst, JKRExpandSwitch expandSwitch, u32 fileSize, JKRHeap* heap,
JKRDvdRipper::EAllocDirection allocDirection, u32 startOffset, int* pCompression) {
return JKRDvdRipper::loadToMainRAM(path, dst, expandSwitch, fileSize, heap, allocDirection, startOffset,
pCompression);
}
#endif
include/JSystem/JKernel/JKREnum.h
+4 -5
View File
@@ -12,11 +12,10 @@ extern "C" {
#define JKRCOMPRESSION_YAZ0 2
#define JKRCOMPRESSION_ASR 3
typedef enum JKRExpandSwitch
{
EXPAND_SWITCH_DEFAULT, /* Do nothing? treated same as 2 */
EXPAND_SWITCH_DECOMPRESS, /* Check for compression and decompress */
EXPAND_SWITCH_NONE /* Do nothing */
typedef enum JKRExpandSwitch {
EXPAND_SWITCH_DEFAULT, /* Do nothing? treated same as 2 */
EXPAND_SWITCH_DECOMPRESS, /* Check for compression and decompress */
EXPAND_SWITCH_NONE /* Do nothing */
} JKRExpandSwitch;
#ifdef __cplusplus
include/JSystem/JKernel/JKRExpHeap.h
+67 -41
View File
@@ -5,28 +5,46 @@
#include "types.h"
#ifdef __cplusplus
class JKRExpHeap : public JKRHeap
{
public:
class CMemBlock
{
public:
class JKRExpHeap : public JKRHeap {
public:
class CMemBlock {
public:
CMemBlock* allocBack(u32, u8, u8, u8, u8);
CMemBlock* allocFore(u32, u8, u8, u8, u8);
void* free(JKRExpHeap*);
static CMemBlock* getHeapBlock(void*);
void initiate(CMemBlock*, CMemBlock*, u32, u8, u8);
void newGroupId(u8 groupId) { mGroupID = groupId; }
bool isValid() const { return mUsageHeader == 'HM'; }
bool _isTempMemBlock() const { return (mFlags & 0x80) ? true : false; }
int getAlignment() const { return mFlags & 0x7f; }
void* getContent() const { return (void*)(this + 1); }
CMemBlock* getPrevBlock() const { return mPrev; }
CMemBlock* getNextBlock() const { return mNext; }
u32 getSize() const { return mAllocatedSpace; }
u8 getGroupId() const { return mGroupID; }
static CMemBlock* getBlock(void* data) { return (CMemBlock*)((u32)data + -0x10); }
void newGroupId(u8 groupId) {
mGroupID = groupId;
}
bool isValid() const {
return mUsageHeader == 'HM';
}
bool _isTempMemBlock() const {
return (mFlags & 0x80) ? true : false;
}
int getAlignment() const {
return mFlags & 0x7f;
}
void* getContent() const {
return (void*)(this + 1);
}
CMemBlock* getPrevBlock() const {
return mPrev;
}
CMemBlock* getNextBlock() const {
return mNext;
}
u32 getSize() const {
return mAllocatedSpace;
}
u8 getGroupId() const {
return mGroupID;
}
static CMemBlock* getBlock(void* data) {
return (CMemBlock*)((u32)data + -0x10);
}
u16 mUsageHeader; // _00
u8 mFlags; // _02, a|bbbbbbb = a=temp, b=aln
@@ -38,24 +56,28 @@ public:
JKRExpHeap(void*, u32, JKRHeap*, bool);
virtual ~JKRExpHeap(); // _08
virtual void* do_alloc(u32, int); // _10
virtual void do_free(void*); // _14
virtual void do_freeTail(); // _18
virtual void do_freeAll(); // _1C
virtual s32 do_resize(void*, u32); // _20
virtual s32 do_getSize(void*); // _24
virtual s32 do_getFreeSize(); // _28
virtual s32 do_getTotalFreeSize(); // _2C
virtual bool check(); // _34
virtual bool dump_sort(); // _38
virtual bool dump(); // _3C
virtual s32 do_changeGroupID(u8); // _40
virtual void state_register(TState*, u32) const; // _48
virtual bool state_compare(const TState&, const TState&) const; // _4C
virtual ~JKRExpHeap(); // _08
virtual void* do_alloc(u32, int); // _10
virtual void do_free(void*); // _14
virtual void do_freeTail(); // _18
virtual void do_freeAll(); // _1C
virtual s32 do_resize(void*, u32); // _20
virtual s32 do_getSize(void*); // _24
virtual s32 do_getFreeSize(); // _28
virtual s32 do_getTotalFreeSize(); // _2C
virtual bool check(); // _34
virtual bool dump_sort(); // _38
virtual bool dump(); // _3C
virtual s32 do_changeGroupID(u8); // _40
virtual void state_register(TState*, u32) const; // _48
virtual bool state_compare(const TState&, const TState&) const; // _4C
virtual u8 do_getCurrentGroupId() { return mCurrentGroupID; } // _44 (weak)
virtual u32 getHeapType() { return 'EXPH'; } // _30 (weak)
virtual u8 do_getCurrentGroupId() {
return mCurrentGroupID;
} // _44 (weak)
virtual u32 getHeapType() {
return 'EXPH';
} // _30 (weak)
void* allocFromHead(u32, int);
void* allocFromHead(u32);
@@ -76,17 +98,22 @@ public:
bool isEmpty();
s32 getUsedSize(u8 groupId) const;
CMemBlock* getHeadUsedList() const { return mHeadUsedList; }
void setAllocationMode(EAllocMode mode) { mCurrentAllocMode = mode; }
CMemBlock* getHeadUsedList() const {
return mHeadUsedList;
}
void setAllocationMode(EAllocMode mode) {
mCurrentAllocMode = mode;
}
static s32 getUsedSize_(JKRExpHeap* expHeap)
{
static s32 getUsedSize_(JKRExpHeap* expHeap) {
// s32 totalFreeSize = expHeap->getTotalFreeSize();
return expHeap->mSize - expHeap->getTotalFreeSize();
}
static u32 getState_(TState* state) { return getState_buf_(state); } // might instead be a pointer to a next state?
static u32 getState_(TState* state) {
return getState_buf_(state);
} // might instead be a pointer to a next state?
private:
private:
// _00 = VTBL
// _00-_6C = JKRHeap
u8 mCurrentAllocMode; // _6C
@@ -100,8 +127,7 @@ private:
CMemBlock* mTailUsedList; // _84
};
inline JKRExpHeap* JKRCreateExpHeap(u32 size, JKRHeap* parent, bool errorFlag)
{
inline JKRExpHeap* JKRCreateExpHeap(u32 size, JKRHeap* parent, bool errorFlag) {
return JKRExpHeap::create(size, parent, errorFlag);
}
#endif
include/JSystem/JKernel/JKRFile.h
+16 -16
View File
@@ -10,25 +10,25 @@
#ifdef __cplusplus
class JKRFile : public JKRDisposer {
public:
inline JKRFile()
: JKRDisposer()
, mFileOpen(false)
{
}
public:
inline JKRFile() : JKRDisposer(), mFileOpen(false) {
}
virtual ~JKRFile() { }
virtual bool open(const char* path) = 0;
virtual bool close() = 0;
virtual int readData(void* data, s32 length, s32 ofs) = 0;
virtual int writeData(const void* data, s32 length, s32 ofs) = 0;
virtual u32 getFileSize() const = 0;
virtual ~JKRFile() {
}
virtual bool open(const char* path) = 0;
virtual bool close() = 0;
virtual int readData(void* data, s32 length, s32 ofs) = 0;
virtual int writeData(const void* data, s32 length, s32 ofs) = 0;
virtual u32 getFileSize() const = 0;
void read(void* data, s32 length, s32 ofs);
bool isAvailable() { return this->mFileOpen; }
void read(void* data, s32 length, s32 ofs);
bool isAvailable() {
return this->mFileOpen;
}
protected:
bool mFileOpen;
protected:
bool mFileOpen;
};
#endif
include/JSystem/JKernel/JKRFileFinder.h
+15 -21
View File
@@ -8,44 +8,40 @@
#ifdef __cplusplus
class JKRArchive;
struct JKRFileFinderBase
{
struct JKRFileFinderBase {
char* mFileName; // _00
int mFileIndex; // _04
u16 mFileID; // _08
u16 mFileTypeFlags; // _0A
};
class JKRFileFinder
{
public:
JKRFileFinder()
: mIsAvailable(false), mIsDir(false)
{
class JKRFileFinder {
public:
JKRFileFinder() : mIsAvailable(false), mIsDir(false) {
}
JKRFileFinderBase mBase;
virtual ~JKRFileFinder() {} // _08 (weak)
virtual ~JKRFileFinder() {
} // _08 (weak)
virtual bool findNextFile() = 0; // _0C
bool isAvailable() const
{
bool isAvailable() const {
return mIsAvailable;
}
// _00 = VTBL
bool mIsAvailable; // _10
bool mIsDir; // _11
bool mIsDir; // _11
};
class JKRArcFinder : public JKRFileFinder
{
public:
class JKRArcFinder : public JKRFileFinder {
public:
JKRArcFinder(JKRArchive*, long, long);
virtual ~JKRArcFinder() {} // _08 (weak)
virtual ~JKRArcFinder() {
} // _08 (weak)
virtual bool findNextFile(); // _0C
// _00 = VTBL
@@ -56,15 +52,13 @@ public:
long mNextIndex; // _20
};
class JKRDvdFinder : public JKRFileFinder
{
public:
class JKRDvdFinder : public JKRFileFinder {
public:
JKRDvdFinder(const char*);
virtual ~JKRDvdFinder() // _08 (weak)
{
if (mIsDvdOpen)
{
if (mIsDvdOpen) {
DVDCloseDir(&mDir);
}
}
include/JSystem/JKernel/JKRFileLoader.h
+32 -22
View File
@@ -7,27 +7,31 @@
#ifdef __cplusplus
class JKRFileFinder;
class JKRFileLoader : public JKRDisposer
{
public:
class JKRFileLoader : public JKRDisposer {
public:
JKRFileLoader();
virtual ~JKRFileLoader(); // _08
virtual void unmount(); // _0C
virtual bool becomeCurrent(const char*) = 0; // _10
virtual void* getResource(const char* path) = 0; // _14
virtual void* getResource(u32 type, const char* name) = 0; // _18
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, const char* path, JKRExpandSwitch expandSwitch) = 0; // _1C
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, u32 type, const char* name) = 0; // _20
virtual void removeResourceAll() = 0; // _24
virtual bool removeResource(void*) = 0; // _28
virtual bool detachResource(void*) = 0; // _2C
virtual long getResSize(const void*) const = 0; // _30
virtual u32 countFile(const char*) const = 0; // _34
virtual JKRFileFinder* getFirstFile(const char*) const = 0; // _38
virtual ~JKRFileLoader(); // _08
virtual void unmount(); // _0C
virtual bool becomeCurrent(const char*) = 0; // _10
virtual void* getResource(const char* path) = 0; // _14
virtual void* getResource(u32 type, const char* name) = 0; // _18
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, const char* path,
JKRExpandSwitch expandSwitch) = 0; // _1C
virtual size_t readResource(void* resourceBuffer, u32 bufferSize, u32 type, const char* name) = 0; // _20
virtual void removeResourceAll() = 0; // _24
virtual bool removeResource(void*) = 0; // _28
virtual bool detachResource(void*) = 0; // _2C
virtual long getResSize(const void*) const = 0; // _30
virtual u32 countFile(const char*) const = 0; // _34
virtual JKRFileFinder* getFirstFile(const char*) const = 0; // _38
bool isMounted() const { return mIsMounted; }
u32 getVolumeType() const { return mVolumeType; }
bool isMounted() const {
return mIsMounted;
}
u32 getVolumeType() const {
return mVolumeType;
}
static void changeDirectory(const char* dir);
@@ -42,14 +46,20 @@ public:
static JKRFileFinder* findFirstFile(const char*);
static const char* fetchVolumeName(char*, long, const char*);
static JKRFileLoader* getCurrentVolume() { return sCurrentVolume; }
static void setCurrentVolume(JKRFileLoader* fileLoader) { sCurrentVolume = fileLoader; }
static JSUList<JKRFileLoader>& getVolumeList() { return sVolumeList; }
static JKRFileLoader* getCurrentVolume() {
return sCurrentVolume;
}
static void setCurrentVolume(JKRFileLoader* fileLoader) {
sCurrentVolume = fileLoader;
}
static JSUList<JKRFileLoader>& getVolumeList() {
return sVolumeList;
}
static JKRFileLoader* sCurrentVolume;
static JSUList<JKRFileLoader> sVolumeList;
protected:
protected:
/* 0x00 */ // vtable
/* 0x04 */ // JKRDisposer
JSULink<JKRFileLoader> mFileLoaderLink; // 0x18
include/JSystem/JKernel/JKRHeap.h
+101 -93
View File
@@ -9,31 +9,24 @@
#ifdef __cplusplus
typedef void JKRHeapErrorHandler(void*, u32, int);
class JKRHeap : public JKRDisposer
{
public:
enum EAllocMode
{
class JKRHeap : public JKRDisposer {
public:
enum EAllocMode {
HEAPALLOC_Unk1 = 1,
};
struct TState
{ // NB: this struct doesn't agree with TP's struct
struct TLocation
{
TLocation() : _00(nullptr), _04(-1)
{
struct TState { // NB: this struct doesn't agree with TP's struct
struct TLocation {
TLocation() : _00(nullptr), _04(-1) {
}
void* _00; // _00
int _04; // _04
};
struct TArgument
{
struct TArgument {
TArgument(const JKRHeap* heap, u32 p2, bool p3)
: mHeap((heap) ? heap : JKRHeap::sCurrentHeap), mId(p2), mIsCompareOnDestructed(p3)
{
: mHeap((heap) ? heap : JKRHeap::sCurrentHeap), mId(p2), mIsCompareOnDestructed(p3) {
}
const JKRHeap* mHeap; // _00
@@ -42,24 +35,35 @@ public:
};
TState(const JKRHeap* heap, u32 id, bool isCompareOnDestructed)
: mUsedSize(0), mCheckCode(0), mArgument(heap, id, isCompareOnDestructed)
{
: mUsedSize(0), mCheckCode(0), mArgument(heap, id, isCompareOnDestructed) {
mArgument.mHeap->state_register(this, mArgument.mId);
}
TState(JKRHeap* heap)
: mUsedSize(0), mCheckCode(0), mArgument(heap, 0xFFFFFFFF, true)
{
TState(JKRHeap* heap) : mUsedSize(0), mCheckCode(0), mArgument(heap, 0xFFFFFFFF, true) {
}
~TState();
void dump() const { mArgument.mHeap->state_dump(*this); }
bool isVerbose() { return bVerbose_; };
bool isCompareOnDestructed() const { return mArgument.mIsCompareOnDestructed; };
u32 getUsedSize() const { return mUsedSize; }
u32 getCheckCode() const { return mCheckCode; }
const JKRHeap* getHeap() const { return mArgument.mHeap; }
u32 getId() const { return mArgument.mId; }
void dump() const {
mArgument.mHeap->state_dump(*this);
}
bool isVerbose() {
return bVerbose_;
};
bool isCompareOnDestructed() const {
return mArgument.mIsCompareOnDestructed;
};
u32 getUsedSize() const {
return mUsedSize;
}
u32 getCheckCode() const {
return mCheckCode;
}
const JKRHeap* getHeap() const {
return mArgument.mHeap;
}
u32 getId() const {
return mArgument.mId;
}
// unused/inlined:
TState(const JKRHeap::TState::TArgument& arg, const JKRHeap::TState::TLocation& location);
@@ -76,7 +80,7 @@ public:
TLocation mLocation; // _1C
};
public:
public:
JKRHeap(void*, u32, JKRHeap*, bool);
bool setErrorFlag(bool errorFlag);
@@ -94,10 +98,16 @@ public:
virtual s32 do_getTotalFreeSize() = 0;
virtual u32 getHeapType() = 0;
virtual bool check() = 0;
virtual bool dump_sort() { return true; }
virtual bool dump_sort() {
return true;
}
virtual bool dump() = 0;
virtual s32 do_changeGroupID(u8 newGroupID) { return 0; }
virtual u8 do_getCurrentGroupId() { return 0; }
virtual s32 do_changeGroupID(u8 newGroupID) {
return 0;
}
virtual u8 do_getCurrentGroupId() {
return 0;
}
virtual void state_register(JKRHeap::TState*, u32) const;
virtual bool state_compare(JKRHeap::TState const&, JKRHeap::TState const&) const;
virtual void state_dump(JKRHeap::TState const&) const;
@@ -125,56 +135,68 @@ public:
JKRHeap* find(void*) const; // 0x80084640
JKRHeap* findAllHeap(void*) const; // 0x8008492c
void dispose_subroutine(u32 begin, u32 end);
bool dispose(void*, u32); // 0x80084b9c
bool dispose(void*, u32); // 0x80084b9c
void dispose(void*, void*); // 0x80084c2c
void dispose(); // 0x80084cb8
void dispose(); // 0x80084cb8
void appendDisposer(JKRDisposer* disposer)
{
void appendDisposer(JKRDisposer* disposer) {
mDisposerList.append(&disposer->mPointerLinks);
}
void removeDisposer(JKRDisposer* disposer)
{
void removeDisposer(JKRDisposer* disposer) {
mDisposerList.remove(&disposer->mPointerLinks);
}
void setDebugFill(bool debugFill) { mDebugFill = debugFill; }
bool getDebugFill() const { return mDebugFill; }
void* getStartAddr() const { return (void*)mStart; }
void* getEndAddr() const { return (void*)mEnd; }
u32 getHeapSize() const { return mSize; }
bool getErrorFlag() const { return mErrorFlag; }
void callErrorHandler(JKRHeap* heap, u32 size, int alignment)
{
if (mErrorHandler)
{
void setDebugFill(bool debugFill) {
mDebugFill = debugFill;
}
bool getDebugFill() const {
return mDebugFill;
}
void* getStartAddr() const {
return (void*)mStart;
}
void* getEndAddr() const {
return (void*)mEnd;
}
u32 getHeapSize() const {
return mSize;
}
bool getErrorFlag() const {
return mErrorFlag;
}
void callErrorHandler(JKRHeap* heap, u32 size, int alignment) {
if (mErrorHandler) {
(*mErrorHandler)(heap, size, alignment);
}
}
// TState related
static u32 getState_buf_(TState* state) { return state->mBuf; } // might instead be a pointer to a next state?
static void setState_u32ID_(TState* state, u32 id)
{
static u32 getState_buf_(TState* state) {
return state->mBuf;
} // might instead be a pointer to a next state?
static void setState_u32ID_(TState* state, u32 id) {
state->mArgument.mId = id;
}
static void setState_uUsedSize_(TState* state, u32 usedSize)
{
static void setState_uUsedSize_(TState* state, u32 usedSize) {
state->mUsedSize = usedSize;
}
static void setState_u32CheckCode_(TState* state, u32 checkCode) { state->mCheckCode = checkCode; }
static void setState_u32CheckCode_(TState* state, u32 checkCode) {
state->mCheckCode = checkCode;
}
void lock() const { OSLockMutex(const_cast<OSMutex*>(&mMutex)); }
void unlock() const { OSUnlockMutex(const_cast<OSMutex*>(&mMutex)); }
void lock() const {
OSLockMutex(const_cast<OSMutex*>(&mMutex));
}
void unlock() const {
OSUnlockMutex(const_cast<OSMutex*>(&mMutex));
}
JKRHeap* getParent()
{
JKRHeap* getParent() {
return mChildTree.getParent()->getObject();
}
const JSUTree<JKRHeap>& getHeapTree()
{
const JSUTree<JKRHeap>& getHeapTree() {
return mChildTree;
}
@@ -190,43 +212,35 @@ public:
static JKRHeap* findFromRoot(void*);
static JKRHeapErrorHandler* setErrorHandler(JKRHeapErrorHandler*);
static void* getCodeStart()
{
static void* getCodeStart() {
return mCodeStart;
}
static void* getCodeEnd()
{
static void* getCodeEnd() {
return mCodeEnd;
}
static void* getUserRamStart()
{
static void* getUserRamStart() {
return mUserRamStart;
}
static void* getUserRamEnd()
{
static void* getUserRamEnd() {
return mUserRamEnd;
}
static u32 getMemorySize()
{
static u32 getMemorySize() {
return mMemorySize;
}
static JKRHeap* getCurrentHeap()
{
static JKRHeap* getCurrentHeap() {
return sCurrentHeap;
}
static JKRHeap* getRootHeap()
{
static JKRHeap* getRootHeap() {
return sRootHeap;
}
static JKRHeap* getSystemHeap()
{
static JKRHeap* getSystemHeap() {
return sSystemHeap;
}
@@ -245,7 +259,7 @@ public:
static JKRHeapErrorHandler* mErrorHandler;
protected:
protected:
/* 0x00 */ // vtable
/* 0x04 */ // JKRDisposer
/* 0x18 */ OSMutex mMutex;
@@ -263,43 +277,35 @@ protected:
/* 0x6A */ u8 padding_0x6a[2];
};
inline JKRHeap* JKRGetCurrentHeap()
{
inline JKRHeap* JKRGetCurrentHeap() {
return JKRHeap::getCurrentHeap();
}
inline JKRHeap* JKRGetSystemHeap()
{
inline JKRHeap* JKRGetSystemHeap() {
return JKRHeap::getSystemHeap();
}
inline JKRHeap* JKRGetRootHeap()
{
inline JKRHeap* JKRGetRootHeap() {
return JKRHeap::getRootHeap();
}
inline void* JKRAllocFromSysHeap(u32 size, int alignment)
{
inline void* JKRAllocFromSysHeap(u32 size, int alignment) {
return JKRHeap::getSystemHeap()->alloc(size, alignment);
}
inline void* JKRAllocFromHeap(JKRHeap* heap, u32 size, int alignment)
{
inline void* JKRAllocFromHeap(JKRHeap* heap, u32 size, int alignment) {
return JKRHeap::alloc(size, alignment, heap);
}
inline void JKRFree(void* pBuf)
{
inline void JKRFree(void* pBuf) {
JKRHeap::free(pBuf, nullptr);
}
inline void JKRFreeToHeap(JKRHeap* heap, void* ptr)
{
inline void JKRFreeToHeap(JKRHeap* heap, void* ptr) {
JKRHeap::free(ptr, heap);
}
inline void JKRFreeToSysHeap(void* buf)
{
inline void JKRFreeToSysHeap(void* buf) {
JKRHeap::getSystemHeap()->free(buf);
}
@@ -308,7 +314,9 @@ void JKRDefaultMemoryErrorRoutine(void*, u32, int);
void* operator new(size_t);
void* operator new(size_t, s32);
void* operator new(size_t, JKRHeap*, int);
inline void* operator new(size_t, void* buf) { return buf; } // i believe this is actually part of MSL_C?
inline void* operator new(size_t, void* buf) {
return buf;
} // i believe this is actually part of MSL_C?
void* operator new[](size_t);
void* operator new[](size_t, s32);
include/JSystem/JKernel/JKRMacro.h
+3 -3
View File
@@ -2,13 +2,13 @@
#define JKRMACRO_H
#ifdef __cplusplus
#define JKR_ISALIGNED(addr, alignment) ((((u32)addr) & (((u32)alignment)-1)) == 0)
#define JKR_ISALIGNED(addr, alignment) ((((u32)addr) & (((u32)alignment) - 1)) == 0)
#define JKR_ISALIGNED32(addr) (JKR_ISALIGNED(addr, 32))
#define JKR_ISNOTALIGNED(addr, alignment) ((((u32)addr) & (((u32)alignment)-1)) != 0)
#define JKR_ISNOTALIGNED(addr, alignment) ((((u32)addr) & (((u32)alignment) - 1)) != 0)
#define JKR_ISNOTALIGNED32(addr) (JKR_ISNOTALIGNED(addr, 32))
#define JKR_ALIGN(addr, alignment) (((u32)addr) & (~(((u32)alignment)-1)))
#define JKR_ALIGN(addr, alignment) (((u32)addr) & (~(((u32)alignment) - 1)))
#define JKR_ALIGN32(addr) (JKR_ALIGN(addr, 32))
#endif
include/JSystem/JKernel/JKRThread.h
+133 -124
View File
@@ -12,169 +12,178 @@
#ifdef __cplusplus
struct JKRThread;
//class JUTConsole;
// class JUTConsole;
struct JKRThreadName_
{
s32 id;
char* name;
struct JKRThreadName_ {
s32 id;
char* name;
};
typedef void (*JKRThreadSwitch_PreCallback)(OSThread* current, OSThread* next);
typedef void (*JKRThreadSwitch_PostCallback)(OSThread* current, OSThread* next);
class JKRThreadSwitch
{
public:
JKRThreadSwitch(JKRHeap*);
virtual void draw(JKRThreadName_* param_1, JUTConsole* param_2);
virtual void draw(JKRThreadName_* param_1);
virtual ~JKRThreadSwitch();
class JKRThreadSwitch {
public:
JKRThreadSwitch(JKRHeap*);
virtual void draw(JKRThreadName_* param_1, JUTConsole* param_2);
virtual void draw(JKRThreadName_* param_1);
virtual ~JKRThreadSwitch();
static JKRThreadSwitch* createManager(JKRHeap* heap);
static JKRThreadSwitch* createManager(JKRHeap* heap);
JKRThread* enter(JKRThread* param_1, int param_2);
static void callback(OSThread* param_1, OSThread* param_2);
JKRThread* enter(JKRThread* param_1, int param_2);
static void callback(OSThread* param_1, OSThread* param_2);
static u32 getTotalCount() { return sTotalCount; }
static u32 getTotalCount() {
return sTotalCount;
}
private:
static JKRThreadSwitch* sManager;
static u32 sTotalCount;
static u64 sTotalStart;
static JKRThreadSwitch_PreCallback mUserPreCallback;
static JKRThreadSwitch_PostCallback mUserPostCallback;
private:
static JKRThreadSwitch* sManager;
static u32 sTotalCount;
static u64 sTotalStart;
static JKRThreadSwitch_PreCallback mUserPreCallback;
static JKRThreadSwitch_PostCallback mUserPostCallback;
private:
JKRHeap* mHeap; // _04
bool mSetNextHeap; // _08
u8 _09[3]; // _09, padding?
u32 _0C; // _0C
u32 _10; // _10
u8 _14[4]; // _14 - unknown/padding
s64 _18; // _18
JUTConsole* mConsole; // _20
JKRThreadName_* mThreadName; // _24
private:
JKRHeap* mHeap; // _04
bool mSetNextHeap; // _08
u8 _09[3]; // _09, padding?
u32 _0C; // _0C
u32 _10; // _10
u8 _14[4]; // _14 - unknown/padding
s64 _18; // _18
JUTConsole* mConsole; // _20
JKRThreadName_* mThreadName; // _24
};
class JKRThread : public JKRDisposer {
public:
JKRThread(u32 stackSize, int msgCount, int threadPrio);
JKRThread(OSThread* osThread, int msgCount);
public:
JKRThread(u32 stackSize, int msgCount, int threadPrio);
JKRThread(OSThread* osThread, int msgCount);
virtual ~JKRThread();
virtual void* run() { return nullptr; }
static void* start(void* param);
static JSUList<JKRThread>* getList() { return &JKRThread::sThreadList; }
OSThread* getThreadRecord() const { return this->mThreadRecord; }
void* getStack() const { return this->mStackMemory; }
void resume() { OSResumeThread(this->mThreadRecord); }
void jamMessageBlock(OSMessage msg) { OSJamMessage(&this->mMesgQueue, msg, OS_MESSAGE_BLOCK); }
void sendMessage(OSMessage msg) { OSSendMessage(&this->mMesgQueue, msg, OS_MESSAGE_NOBLOCK); }
OSMessage waitMessage(int* received) {
OSMessage mesg;
BOOL retrieved = OSReceiveMessage(&this->mMesgQueue, &mesg, OS_MESSAGE_NOBLOCK);
if (received != nullptr) {
*received = retrieved;
virtual ~JKRThread();
virtual void* run() {
return nullptr;
}
return mesg;
}
OSMessage waitMeessageBlock() {
OSMessage mesg;
OSReceiveMessage(&this->mMesgQueue, &mesg, OS_MESSAGE_BLOCK);
return mesg;
}
static void* start(void* param);
static JSUList<JKRThread>* getList() {
return &JKRThread::sThreadList;
}
static JSUList<JKRThread> sThreadList;
OSThread* getThreadRecord() const {
return this->mThreadRecord;
}
void* getStack() const {
return this->mStackMemory;
}
protected:
JSULink<JKRThread> mLink;
JKRHeap* mHeap;
OSThread* mThreadRecord;
OSMessageQueue mMesgQueue;
OSMessage* mMesgBuffer;
int mMesgCount;
void* mStackMemory;
u32 mStackSize;
void resume() {
OSResumeThread(this->mThreadRecord);
}
void jamMessageBlock(OSMessage msg) {
OSJamMessage(&this->mMesgQueue, msg, OS_MESSAGE_BLOCK);
}
void sendMessage(OSMessage msg) {
OSSendMessage(&this->mMesgQueue, msg, OS_MESSAGE_NOBLOCK);
}
OSMessage waitMessage(int* received) {
OSMessage mesg;
BOOL retrieved = OSReceiveMessage(&this->mMesgQueue, &mesg, OS_MESSAGE_NOBLOCK);
if (received != nullptr) {
*received = retrieved;
}
return mesg;
}
OSMessage waitMeessageBlock() {
OSMessage mesg;
OSReceiveMessage(&this->mMesgQueue, &mesg, OS_MESSAGE_BLOCK);
return mesg;
}
static JSUList<JKRThread> sThreadList;
protected:
JSULink<JKRThread> mLink;
JKRHeap* mHeap;
OSThread* mThreadRecord;
OSMessageQueue mMesgQueue;
OSMessage* mMesgBuffer;
int mMesgCount;
void* mStackMemory;
u32 mStackSize;
};
// Unused class, function definitions from Sunshine and MKDD
class JKRTask : public JKRThread
{
typedef void (*RequestCallback)(void*);
class JKRTask : public JKRThread {
typedef void (*RequestCallback)(void*);
/**
* @fabricated
* @size{0xC}
*/
struct Request
{
RequestCallback mCb;
void* mArg;
void* mMsg;
};
/**
* @fabricated
* @size{0xC}
*/
struct Request {
RequestCallback mCb;
void* mArg;
void* mMsg;
};
JKRTask(); // unused/inlined
JKRTask(); // unused/inlined
virtual ~JKRTask(); // _08
virtual void* run(); // _0C
virtual ~JKRTask(); // _08
virtual void* run(); // _0C
bool request(RequestCallback, void*, void*);
bool request(RequestCallback, void*, void*);
static JKRTask* create();
static JKRTask* create();
// unused/inlined:
Request* searchBlank();
void requestJam(RequestCallback, void*, void*);
void cancelAll();
void createTaskEndMessageQueue(int, JKRHeap*);
void destroyTaskEndMessageQueue();
void waitQueueMessageBlock(OSMessageQueue*, int*);
void waitQueueMessage(OSMessageQueue*, int*);
// unused/inlined:
Request* searchBlank();
void requestJam(RequestCallback, void*, void*);
void cancelAll();
void createTaskEndMessageQueue(int, JKRHeap*);
void destroyTaskEndMessageQueue();
void waitQueueMessageBlock(OSMessageQueue*, int*);
void waitQueueMessage(OSMessageQueue*, int*);
OSMessage waitMessageBlock()
{
OSMessage msg;
OSReceiveMessage(&mMesgQueue, &msg, OS_MESSAGE_BLOCK);
return msg;
}
OSMessage waitMessageBlock() {
OSMessage msg;
OSReceiveMessage(&mMesgQueue, &msg, OS_MESSAGE_BLOCK);
return msg;
}
void destroy();
void destroy();
// Unused
static OSMessage* sEndMesgBuffer;
static u32 sEndMesgBufSize;
// Unused
static OSMessage* sEndMesgBuffer;
static u32 sEndMesgBufSize;
// u32 _78; // _78
//JSULink<JKRTask> mTaskLink; // _7C, this didn't exist yet
Request* mRequest; // _8C - ptr to request array
u32 mRequestCnt; // _90 - amount of requests
OSMessageQueue* mTaskMsgQueue; // _94
// u32 _78; // _78
// JSULink<JKRTask> mTaskLink; // _7C, this didn't exist yet
Request* mRequest; // _8C - ptr to request array
u32 mRequestCnt; // _90 - amount of requests
OSMessageQueue* mTaskMsgQueue; // _94
static JSUList<JKRTask> sTaskList;
static u8 sEndMesgQueue[32]; // Unused
static JSUList<JKRTask> sTaskList;
static u8 sEndMesgQueue[32]; // Unused
};
/** @unused */
struct JKRIdleThread : public JKRThread
{
virtual ~JKRIdleThread() {}; // _08
virtual void* run() // _0C
{
while (true)
struct JKRIdleThread : public JKRThread {
virtual ~JKRIdleThread() {}; // _08
virtual void* run() // _0C
{
}
};
virtual void destroy() {} // 0x10
while (true) {}
};
virtual void destroy() {
} // 0x10
static void create(JKRHeap*, int, u32);
static void create(JKRHeap*, int, u32);
static JKRIdleThread* sThread;
static JKRIdleThread* sThread;
};
#endif