mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-07-09 12:37:18 -04:00
Copy JKernel (#126)
* start JSystem * JKRAram and JUTGamePad * started heap and thread * more JKernel * mostly finished JKernel * delete unused asm * JKRFileFinder * delete unused asm and match findNextFile * format * fix mtx_vec
This commit is contained in:
lepelog
@@ -3,4 +3,72 @@
|
||||
|
||||
#include "dolphin/types.h"
|
||||
|
||||
#include "JSystem/JKernel/JKRAramHeap.h"
|
||||
#include "JSystem/JKernel/JKRDvdRipper.h"
|
||||
#include "JSystem/JKernel/JKRThread.h"
|
||||
|
||||
class JKRHeap;
|
||||
class JKRAramBlock;
|
||||
class JKRAram : public JKRThread {
|
||||
private:
|
||||
JKRAram(u32, u32, long);
|
||||
virtual ~JKRAram();
|
||||
|
||||
/* vt[03] */ void* run(void); /* override */
|
||||
|
||||
public:
|
||||
u32 getAudioMemory() const { return mAudioMemoryPtr; }
|
||||
u32 getAudioMemSize() const { return mAudioMemorySize; }
|
||||
u32 getGraphMemory() const { return mGraphMemoryPtr; }
|
||||
u32 getGraphMemSize() const { return mGraphMemorySize; }
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRThread
|
||||
/* 0x7C */ u32 mAudioMemoryPtr;
|
||||
/* 0x80 */ u32 mAudioMemorySize;
|
||||
/* 0x84 */ u32 mGraphMemoryPtr;
|
||||
/* 0x88 */ u32 mGraphMemorySize;
|
||||
/* 0x8C */ u32 mAramMemoryPtr;
|
||||
/* 0x90 */ u32 mAramMemorySize;
|
||||
/* 0x94 */ JKRAramHeap* mAramHeap;
|
||||
/* 0x98 */ u32 mStackArray[3];
|
||||
|
||||
public:
|
||||
static JKRAram* create(u32, u32, long, long, long);
|
||||
static void checkOkAddress(u8*, u32, JKRAramBlock*, u32);
|
||||
static void changeGroupIdIfNeed(u8*, int);
|
||||
static void mainRamToAram(u8*, u32, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
|
||||
static void aramToMainRam(u32, u8*, u32, JKRExpandSwitch, u32, JKRHeap*, int, u32*);
|
||||
static void dump(void);
|
||||
|
||||
static JKRAram* getManager() { return sAramObject; }
|
||||
static JKRAramHeap* getAramHeap() { return getManager()->mAramHeap; }
|
||||
static JSUList<JKRAMCommand>& getCommandList() { return sAramCommandList; }
|
||||
|
||||
static u8 decideAramGroupId(int groupId) {
|
||||
JKRAramHeap* heap;
|
||||
u8 finalGroupId;
|
||||
|
||||
if (groupId < 0) {
|
||||
return getAramHeap()->getCurrentGroupID();
|
||||
}
|
||||
|
||||
return (u8)groupId;
|
||||
}
|
||||
|
||||
static u32 getSZSBufferSize() { return sSZSBufferSize; }
|
||||
static void setSZSBufferSize(u32 size) { sSZSBufferSize = size; }
|
||||
|
||||
static OSMessageQueue sMessageQueue;
|
||||
|
||||
private:
|
||||
static JKRAram* sAramObject;
|
||||
static u32 sSZSBufferSize;
|
||||
static OSMessage sMessageBuffer[4];
|
||||
static JSUList<JKRAMCommand> sAramCommandList;
|
||||
};
|
||||
|
||||
// void JKRDecompressFromAramToMainRam(u32, void*, u32, u32, u32, u32*);
|
||||
|
||||
#endif /* JKRARAM_H */
|
||||
|
||||
@@ -1,6 +1,30 @@
|
||||
#ifndef JKRARAMARCHIVE_H
|
||||
#define JKRARAMARCHIVE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRArchive.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRAramArchive : public JKRArchive {
|
||||
public:
|
||||
JKRAramArchive(long, JKRArchive::EMountDirection);
|
||||
virtual ~JKRAramArchive();
|
||||
|
||||
void open(long);
|
||||
void getAramAddress_Entry(SDIFileEntry*);
|
||||
void getAramAddress(char const*);
|
||||
|
||||
/* vt[15] */ u32 getExpandedResSize(const void*); /* override */
|
||||
/* vt[16] */ void* fetchResource(SDIFileEntry*, u32*); /* override */
|
||||
/* vt[17] */ void* fetchResource(void*, u32, SDIFileEntry*, u32*); /* override */
|
||||
|
||||
public:
|
||||
static void fetchResource_subroutine(u32, u32, u8*, u32, int);
|
||||
static void fetchResource_subroutine(u32, u32, JKRHeap*, int, u8**);
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRArchive
|
||||
u8 unk[16];
|
||||
};
|
||||
|
||||
#endif /* JKRARAMARCHIVE_H */
|
||||
|
||||
@@ -3,4 +3,37 @@
|
||||
|
||||
#include "dolphin/types.h"
|
||||
|
||||
#include "JSystem/JSupport/JSUList.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRAramHeap;
|
||||
class JKRAramBlock {
|
||||
public:
|
||||
JKRAramBlock(u32, u32, u32, u8, bool);
|
||||
virtual ~JKRAramBlock();
|
||||
|
||||
JKRAramBlock* allocHead(u32, u8, JKRAramHeap*);
|
||||
JKRAramBlock* allocTail(u32, u8, JKRAramHeap*);
|
||||
|
||||
void* getAddress() const { return (void*)mAddress; }
|
||||
|
||||
u32 getSize() const { return mSize; }
|
||||
|
||||
u32 getFreeSize() const { return mFreeSize; }
|
||||
|
||||
bool isTempMemory() const { return mIsTempMemory; }
|
||||
|
||||
void newGroupID(u8 groupId) { mGroupId = groupId; }
|
||||
|
||||
public:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ JSULink<JKRAramBlock> mBlockLink;
|
||||
/* 0x14 */ u32 mAddress;
|
||||
/* 0x18 */ u32 mSize;
|
||||
/* 0x1C */ u32 mFreeSize;
|
||||
/* 0x20 */ u8 mGroupId;
|
||||
/* 0x21 */ u8 mIsTempMemory;
|
||||
/* 0x22 */ u8 padding[2];
|
||||
};
|
||||
|
||||
#endif /* JKRARAMBLOCK_H */
|
||||
|
||||
@@ -1,6 +1,52 @@
|
||||
#ifndef JKRARAMHEAP_H
|
||||
#define JKRARAMHEAP_H
|
||||
|
||||
#include "JSystem/JKernel/JKRAramBlock.h"
|
||||
#include "JSystem/JKernel/JKRDisposer.h"
|
||||
#include "dolphin/os/OS.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRAramHeap : public JKRDisposer {
|
||||
public:
|
||||
enum EAllocMode {
|
||||
HEAD = 0,
|
||||
TAIL = 1,
|
||||
};
|
||||
|
||||
public:
|
||||
// TODO: fix type
|
||||
static JSUList<JKRAramBlock> sAramList;
|
||||
|
||||
JKRAramHeap(u32, u32);
|
||||
virtual ~JKRAramHeap();
|
||||
|
||||
JKRAramBlock* alloc(u32, EAllocMode);
|
||||
JKRAramBlock* allocFromHead(u32);
|
||||
JKRAramBlock* allocFromTail(u32);
|
||||
u32 getFreeSize(void);
|
||||
u32 getTotalFreeSize(void);
|
||||
// u32 getUsedSize(void);
|
||||
void dump(void);
|
||||
|
||||
u8 getCurrentGroupID() const { return mGroupId; }
|
||||
|
||||
JKRHeap* getMgrHeap() const { return mHeap; }
|
||||
|
||||
private:
|
||||
void lock() { OSLockMutex(&mMutex); }
|
||||
|
||||
void unlock() { OSUnlockMutex(&mMutex); }
|
||||
|
||||
public:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRDisposer
|
||||
/* 0x18 */ OSMutex mMutex;
|
||||
/* 0x30 */ JKRHeap* mHeap;
|
||||
/* 0x34 */ u32 mHeadAddress;
|
||||
/* 0x38 */ u32 mTailAddress;
|
||||
/* 0x3C */ u32 mSize;
|
||||
/* 0x40 */ u8 mGroupId;
|
||||
/* 0x41 */ u8 padding_0x41[3];
|
||||
};
|
||||
|
||||
#endif /* JKRARAMHEAP_H */
|
||||
|
||||
@@ -1,6 +1,73 @@
|
||||
#ifndef JKRARAMPIECE_H
|
||||
#define JKRARAMPIECE_H
|
||||
|
||||
#include "JSystem/JSupport/JSUList.h"
|
||||
#include "dolphin/ar/arq.h"
|
||||
#include "dolphin/os/OS.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRAramBlock;
|
||||
class JKRDecompCommand;
|
||||
class JKRAMCommand {
|
||||
public:
|
||||
typedef void (*AsyncCallback)(u32);
|
||||
|
||||
JKRAMCommand();
|
||||
~JKRAMCommand();
|
||||
|
||||
public:
|
||||
/* 0x00 */ ARQRequest mRequest;
|
||||
/* 0x20 */ JSULink<JKRAMCommand> mPieceLink;
|
||||
/* 0x30 */ JSULink<JKRAMCommand> field_0x30;
|
||||
|
||||
/* 0x40 */ s32 mTransferDirection;
|
||||
/* 0x44 */ u32 mDataLength;
|
||||
/* 0x48 */ u32 mSrc;
|
||||
/* 0x4C */ u32 mDst;
|
||||
/* 0x50 */ JKRAramBlock* mAramBlock;
|
||||
/* 0x54 */ u32 field_0x54;
|
||||
/* 0x58 */ AsyncCallback mCallback;
|
||||
/* 0x5C */ OSMessageQueue* field_0x5C;
|
||||
/* 0x60 */ s32 field_0x60;
|
||||
/* 0x64 */ JKRDecompCommand* mDecompCommand;
|
||||
/* 0x68 */ OSMessageQueue mMessageQueue;
|
||||
/* 0x88 */ OSMessage mMessage;
|
||||
/* 0x8C */ void* field_0x8C;
|
||||
/* 0x90 */ void* field_0x90;
|
||||
/* 0x94 */ void* field_0x94;
|
||||
};
|
||||
|
||||
class JKRAramPiece {
|
||||
public:
|
||||
static OSMutex mMutex;
|
||||
// TODO: fix type
|
||||
static JSUList<JKRAMCommand> sAramPieceCommandList;
|
||||
|
||||
public:
|
||||
struct Message {
|
||||
s32 field_0x00;
|
||||
JKRAMCommand* command;
|
||||
};
|
||||
|
||||
public:
|
||||
static JKRAMCommand* prepareCommand(int, u32, u32, u32, JKRAramBlock*,
|
||||
JKRAMCommand::AsyncCallback);
|
||||
static void sendCommand(JKRAMCommand*);
|
||||
|
||||
static JKRAMCommand* orderAsync(int, u32, u32, u32, JKRAramBlock*, JKRAMCommand::AsyncCallback);
|
||||
static BOOL sync(JKRAMCommand*, int);
|
||||
static BOOL orderSync(int, u32, u32, u32, JKRAramBlock*);
|
||||
static void startDMA(JKRAMCommand*);
|
||||
static void doneDMA(u32);
|
||||
|
||||
private:
|
||||
static void lock() { OSLockMutex(&mMutex); }
|
||||
static void unlock() { OSUnlockMutex(&mMutex); }
|
||||
};
|
||||
|
||||
inline BOOL JKRAramPcs(int direction, u32 source, u32 destination, u32 length,
|
||||
JKRAramBlock* block) {
|
||||
return JKRAramPiece::orderSync(direction, source, destination, length, block);
|
||||
}
|
||||
|
||||
#endif /* JKRARAMPIECE_H */
|
||||
|
||||
@@ -1,6 +1,69 @@
|
||||
#ifndef JKRARAMSTREAM_H
|
||||
#define JKRARAMSTREAM_H
|
||||
|
||||
#include "JSystem/JKernel/JKRThread.h"
|
||||
#include "JSystem/JSupport/JSUFileStream.h"
|
||||
#include "JSystem/JSupport/JSURandomInputStream.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRAramStreamCommand {
|
||||
public:
|
||||
enum Type {
|
||||
UNKNOWN = 0,
|
||||
READ = 1,
|
||||
WRITE = 2,
|
||||
};
|
||||
|
||||
JKRAramStreamCommand();
|
||||
|
||||
public:
|
||||
/* 0x00 */ Type mType;
|
||||
/* 0x04 */ u32 mAddress;
|
||||
/* 0x08 */ u32 mSize;
|
||||
/* 0x0C */ u32 field_0x0c;
|
||||
/* 0x10 */ JSUFileInputStream* mStream;
|
||||
/* 0x14 */ u32 mOffset;
|
||||
/* 0x18 */ u32* mReturnSize;
|
||||
/* 0x1C */ u8* mTransferBuffer;
|
||||
/* 0x20 */ u32 mTransferBufferSize;
|
||||
/* 0x24 */ JKRHeap* mHeap;
|
||||
/* 0x28 */ bool mAllocatedTransferBuffer;
|
||||
/* 0x29 */ u8 padding_0x29[3];
|
||||
/* 0x2C */ u32 field_0x2c;
|
||||
/* 0x30 */ OSMessageQueue mMessageQueue;
|
||||
/* 0x50 */ OSMessage mMessage;
|
||||
/* 0x54 */ u32 field_0x54;
|
||||
/* 0x58 */ u32 field_0x58;
|
||||
};
|
||||
|
||||
class JKRAramStream : public JKRThread {
|
||||
private:
|
||||
JKRAramStream(long);
|
||||
virtual ~JKRAramStream();
|
||||
|
||||
/* vt[03] */ void* run(void); /* override */
|
||||
|
||||
public:
|
||||
static JKRAramStream* create(long);
|
||||
|
||||
static s32 readFromAram(void);
|
||||
static s32 writeToAram(JKRAramStreamCommand*);
|
||||
static JKRAramStreamCommand* write_StreamToAram_Async(JSUFileInputStream*, u32, u32, u32, u32*);
|
||||
static JKRAramStreamCommand* sync(JKRAramStreamCommand*, BOOL);
|
||||
static void setTransBuffer(u8*, u32, JKRHeap*);
|
||||
|
||||
private:
|
||||
static JKRAramStream* sAramStreamObject;
|
||||
static OSMessage sMessageBuffer[4];
|
||||
static OSMessageQueue sMessageQueue;
|
||||
|
||||
static u8* transBuffer;
|
||||
static u32 transSize;
|
||||
static JKRHeap* transHeap;
|
||||
};
|
||||
|
||||
inline JKRAramStream* JKRCreateAramStreamManager(long priority) {
|
||||
return JKRAramStream::create(priority);
|
||||
}
|
||||
|
||||
#endif /* JKRARAMSTREAM_H */
|
||||
|
||||
@@ -0,0 +1,213 @@
|
||||
#ifndef JKRARCHIVE_H
|
||||
#define JKRARCHIVE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRCompression.h"
|
||||
#include "JSystem/JKernel/JKRDecomp.h"
|
||||
#include "JSystem/JKernel/JKRFileLoader.h"
|
||||
#include "global.h"
|
||||
|
||||
struct SArcHeader {
|
||||
u32 signature;
|
||||
u32 file_length;
|
||||
u32 header_length;
|
||||
u32 file_data_offset;
|
||||
u32 file_data_length;
|
||||
u32 field_0x14;
|
||||
u32 field_0x18;
|
||||
u32 field_0x1c;
|
||||
};
|
||||
|
||||
struct SArcDataInfo {
|
||||
u32 num_nodes;
|
||||
u32 node_offset;
|
||||
u32 num_file_entries;
|
||||
u32 file_entry_offset;
|
||||
u32 string_table_length;
|
||||
u32 string_table_offset;
|
||||
u16 next_free_file_id;
|
||||
bool sync_file_ids_and_indices;
|
||||
u8 field_1b[5];
|
||||
};
|
||||
|
||||
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];
|
||||
}
|
||||
|
||||
inline u16 read_big_endian_u16(void* ptr) {
|
||||
u8* uptr = (u8*)ptr;
|
||||
return ((u16)uptr[0] << 8) | ((u16)uptr[1]);
|
||||
}
|
||||
|
||||
inline u32 JKRDecompExpandSize(SArcHeader* header) {
|
||||
u8* fileLength = (u8*)&header->file_length;
|
||||
return read_big_endian_u32(fileLength);
|
||||
}
|
||||
|
||||
extern u32 sCurrentDirID__10JKRArchive; // JKRArchive::sCurrentDirID
|
||||
|
||||
class JKRHeap;
|
||||
class JKRDvdFile;
|
||||
class JKRArchive : public JKRFileLoader {
|
||||
public:
|
||||
struct SDirEntry {
|
||||
union {
|
||||
u32 type;
|
||||
struct {
|
||||
u8 flags;
|
||||
u8 padding;
|
||||
u16 id;
|
||||
} other;
|
||||
};
|
||||
|
||||
const char* name;
|
||||
u16 field_0x8;
|
||||
u16 num_entries;
|
||||
s32 first_file_index;
|
||||
};
|
||||
|
||||
struct SDIFileEntry {
|
||||
u16 file_id;
|
||||
u16 name_hash;
|
||||
u32 type_flags_and_name_offset;
|
||||
u32 data_offset;
|
||||
u32 data_size;
|
||||
void* data;
|
||||
|
||||
u32 getNameOffset() const { return type_flags_and_name_offset & 0xFFFFFF; }
|
||||
u16 getNameHash() const { return name_hash; }
|
||||
u32 getFlags() const { return type_flags_and_name_offset >> 24; }
|
||||
u32 getAttr() const { return getFlags(); }
|
||||
u16 getFileID() const { return file_id; }
|
||||
bool isDirectory() const { return (getFlags() & 0x02) != 0; }
|
||||
bool isUnknownFlag1() const { return (getFlags() & 0x01) != 0; }
|
||||
bool isCompressed() const { return (getFlags() & 0x04) != 0; }
|
||||
bool isYAZ0Compressed() const { return (getFlags() & 0x80) != 0; }
|
||||
};
|
||||
|
||||
enum EMountMode {
|
||||
UNKNOWN_MOUNT_MODE = 0,
|
||||
MOUNT_MEM = 1,
|
||||
MOUNT_ARAM = 2,
|
||||
MOUNT_DVD = 3,
|
||||
MOUNT_COMP = 4,
|
||||
};
|
||||
|
||||
enum EMountDirection {
|
||||
UNKNOWN_MOUNT_DIRECTION = 0,
|
||||
MOUNT_DIRECTION_HEAD = 1,
|
||||
MOUNT_DIRECTION_TAIL = 2,
|
||||
};
|
||||
|
||||
class CArcName {
|
||||
public:
|
||||
CArcName() {}
|
||||
CArcName(char const* data) { this->store(data); }
|
||||
CArcName(char const** data, char endChar) { *data = this->store(*data, endChar); }
|
||||
|
||||
void store(char const* data);
|
||||
const char* store(char const* data, char endChar);
|
||||
|
||||
u16 getHash() const { return mHash; }
|
||||
|
||||
const char* getString() const { return mData; }
|
||||
|
||||
private:
|
||||
u16 mHash;
|
||||
u16 mLength;
|
||||
char mData[256];
|
||||
};
|
||||
|
||||
protected:
|
||||
JKRArchive();
|
||||
JKRArchive(long, EMountMode);
|
||||
virtual ~JKRArchive();
|
||||
|
||||
public:
|
||||
bool getDirEntry(SDirEntry*, u32) const;
|
||||
void* getIdxResource(u32);
|
||||
void* getResource(u16);
|
||||
u32 readIdxResource(void*, u32, u32);
|
||||
u32 readResource(void*, u32, u16);
|
||||
u32 countResource(void) const;
|
||||
u32 getFileAttribute(u32) const;
|
||||
|
||||
u32 getMountMode() const { return mMountMode; }
|
||||
|
||||
protected:
|
||||
bool isSameName(CArcName&, u32, u16) const;
|
||||
SDirEntry* findResType(u32) const;
|
||||
SDirEntry* findDirectory(const char*, u32) const;
|
||||
SDIFileEntry* findTypeResource(u32, const char*) const;
|
||||
SDIFileEntry* findFsResource(const char*, u32) const;
|
||||
SDIFileEntry* findIdxResource(u32) const;
|
||||
SDIFileEntry* findNameResource(const char*) const;
|
||||
SDIFileEntry* findPtrResource(const void*) const;
|
||||
SDIFileEntry* findIdResource(u16) const;
|
||||
|
||||
public:
|
||||
/* vt[04] */ virtual bool becomeCurrent(const char*); /* override */
|
||||
/* vt[05] */ virtual void* getResource(const char*); /* override */
|
||||
/* vt[06] */ virtual void* getResource(u32, const char*); /* override */
|
||||
/* vt[07] */ virtual u32 readResource(void*, u32, const char*); /* override */
|
||||
/* vt[08] */ virtual u32 readResource(void*, u32, u32, const char*); /* override */
|
||||
/* vt[09] */ virtual void removeResourceAll(void); /* override */
|
||||
/* vt[10] */ virtual bool removeResource(void*); /* override */
|
||||
/* vt[11] */ virtual bool detachResource(void*); /* override */
|
||||
/* vt[12] */ virtual u32 getResSize(const void*) const; /* override */
|
||||
/* vt[13] */ virtual u32 countFile(const char*) const; /* override */
|
||||
/* vt[14] */ virtual JKRFileFinder* getFirstFile(const char*) const; /* override */
|
||||
/* vt[15] */ virtual u32 getExpandedResSize(const void*) const;
|
||||
/* vt[16] */ virtual void* fetchResource(SDIFileEntry*, u32*) = 0;
|
||||
/* vt[17] */ virtual void* fetchResource(void*, u32, SDIFileEntry*, u32*) = 0;
|
||||
/* vt[18] */ virtual void setExpandSize(SDIFileEntry*, u32);
|
||||
/* vt[19] */ virtual u32 getExpandSize(SDIFileEntry*) const;
|
||||
|
||||
protected:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRFileLoader
|
||||
/* 0x38 */ JKRHeap* mHeap;
|
||||
/* 0x3C */ u8 mMountMode;
|
||||
/* 0x3D */ u8 field_0x3d[3];
|
||||
/* 0x40 */ s32 mEntryNum;
|
||||
/* 0x44 */ SArcDataInfo* mArcInfoBlock;
|
||||
/* 0x48 */ SDirEntry* mNodes;
|
||||
/* 0x4C */ SDIFileEntry* mFiles;
|
||||
/* 0x50 */ s32* mExpandedSize;
|
||||
/* 0x54 */ char* mStringTable;
|
||||
/* 0x58 */ u32 field_0x58;
|
||||
|
||||
public:
|
||||
static JKRArchive* check_mount_already(s32, JKRHeap*);
|
||||
static JKRArchive* mount(const char*, EMountMode, JKRHeap*, EMountDirection);
|
||||
static JKRArchive* mount(void*, JKRHeap*, EMountDirection);
|
||||
static JKRArchive* mount(s32, EMountMode, JKRHeap*, EMountDirection);
|
||||
static void* getGlbResource(u32, const char*, JKRArchive*);
|
||||
|
||||
static JKRCompression convertAttrToCompressionType(u32 attr) {
|
||||
#define JKRARCHIVE_ATTR_COMPRESSION 0x04
|
||||
#define JKRARCHIVE_ATTR_YAY0 0x80
|
||||
|
||||
JKRCompression compression;
|
||||
if (FLAG_ON(attr, JKRARCHIVE_ATTR_COMPRESSION)) {
|
||||
compression = COMPRESSION_NONE;
|
||||
} else if (!FLAG_ON(attr, JKRARCHIVE_ATTR_YAY0)) {
|
||||
compression = COMPRESSION_YAZ0;
|
||||
} else {
|
||||
compression = COMPRESSION_YAY0;
|
||||
}
|
||||
return compression;
|
||||
}
|
||||
|
||||
static u32 getCurrentDirID() { return sCurrentDirID; }
|
||||
static void setCurrentDirID(u32 dirID) { sCurrentDirID = dirID; }
|
||||
|
||||
private:
|
||||
static u32 sCurrentDirID;
|
||||
};
|
||||
|
||||
inline JKRCompression JKRConvertAttrToCompressionType(u32 attr) {
|
||||
return JKRArchive::convertAttrToCompressionType(attr);
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -1,6 +1,35 @@
|
||||
#ifndef JKRASSERTHEAP_H
|
||||
#define JKRASSERTHEAP_H
|
||||
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRAssertHeap : public JKRHeap {
|
||||
protected:
|
||||
JKRAssertHeap(void*, unsigned long, JKRHeap*, bool);
|
||||
virtual ~JKRAssertHeap();
|
||||
|
||||
public:
|
||||
/* vt[04] */ virtual u32 getHeapType(void); /* override */
|
||||
/* vt[05] */ virtual bool check(void); /* override */
|
||||
/* vt[06] */ virtual bool dump_sort(void); /* override */
|
||||
/* vt[07] */ virtual bool dump(void); /* override */
|
||||
/* vt[08] */ virtual void do_destroy(void); /* override */
|
||||
/* vt[09] */ virtual void* do_alloc(u32, int); /* override */
|
||||
/* vt[10] */ virtual void do_free(void*); /* override */
|
||||
/* vt[11] */ virtual void do_freeAll(void); /* override */
|
||||
/* vt[12] */ virtual void do_freeTail(void); /* override */
|
||||
/* vt[13] */ virtual void do_fillFreeArea(void); /* override */
|
||||
/* vt[14] */ virtual s32 do_resize(void*, u32); /* override */
|
||||
/* vt[15] */ virtual s32 do_getSize(void*); /* override */
|
||||
/* vt[16] */ virtual s32 do_getFreeSize(void); /* override */
|
||||
/* vt[17] */ virtual void* do_getMaxFreeBlock(void); /* override */
|
||||
/* vt[18] */ virtual s32 do_getTotalFreeSize(void); /* override */
|
||||
/* vt[19] */ virtual u8 do_changeGroupID(u8 param_1); /* override */
|
||||
/* vt[20] */ virtual u8 do_getCurrentGroupId(void); /* override */
|
||||
|
||||
public:
|
||||
static JKRAssertHeap* create(JKRHeap*);
|
||||
};
|
||||
|
||||
#endif /* JKRASSERTHEAP_H */
|
||||
|
||||
@@ -1,6 +1,28 @@
|
||||
#ifndef JKRCOMPARCHIVE_H
|
||||
#define JKRCOMPARCHIVE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRArchive.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRCompArchive : public JKRArchive {
|
||||
public:
|
||||
JKRCompArchive(long, JKRArchive::EMountDirection);
|
||||
virtual ~JKRCompArchive();
|
||||
|
||||
void open(long);
|
||||
|
||||
/* vt[09] */ void removeResourceAll(void); /* override */
|
||||
/* vt[10] */ bool removeResource(void*); /* override */
|
||||
|
||||
/* vt[15] */ u32 getExpandedResSize(const void*); /* override */
|
||||
/* vt[16] */ void* fetchResource(SDIFileEntry*, u32*); /* override */
|
||||
/* vt[17] */ void* fetchResource(void*, u32, SDIFileEntry*, u32*); /* override */
|
||||
|
||||
public:
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRArchive
|
||||
u8 unk[36];
|
||||
};
|
||||
|
||||
#endif /* JKRCOMPARCHIVE_H */
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
#ifndef JKRCOMPREESION_H_
|
||||
#define JKRCOMPREESION_H_
|
||||
|
||||
typedef int JKRCompression;
|
||||
const JKRCompression COMPRESSION_NONE = 0;
|
||||
const JKRCompression COMPRESSION_YAY0 = 1;
|
||||
const JKRCompression COMPRESSION_YAZ0 = 2;
|
||||
const JKRCompression COMPRESSION_ASR = 3;
|
||||
|
||||
#endif
|
||||
@@ -1,6 +1,66 @@
|
||||
#ifndef JKRDECOMP_H
|
||||
#define JKRDECOMP_H
|
||||
|
||||
#include "JSystem/JKernel/JKRCompression.h"
|
||||
#include "JSystem/JKernel/JKRThread.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRAMCommand;
|
||||
class JKRDecompCommand {
|
||||
public:
|
||||
typedef void (*AsyncCallback)(u32);
|
||||
|
||||
JKRDecompCommand();
|
||||
~JKRDecompCommand();
|
||||
|
||||
public:
|
||||
/* 0x00 */ u32 field_0x0;
|
||||
/* 0x04 */ u8* mSrcBuffer;
|
||||
/* 0x08 */ u8* mDstBuffer;
|
||||
/* 0x0C */ u32 mSrcLength;
|
||||
/* 0x10 */ u32 mDstLength;
|
||||
/* 0x14 */ AsyncCallback mCallback;
|
||||
/* 0x18 */ JKRDecompCommand* mThis;
|
||||
/* 0x1C */ OSMessageQueue* field_0x1c;
|
||||
/* 0x20 */ s32 field_0x20;
|
||||
/* 0x24 */ JKRAMCommand* mAMCommand;
|
||||
/* 0x28 */ OSMessageQueue mMessageQueue;
|
||||
/* 0x48 */ OSMessage mMessage;
|
||||
};
|
||||
|
||||
#define JKRDECOMP_SYNC_BLOCKING 0
|
||||
#define JKRDECOMP_SYNC_NON_BLOCKING 1
|
||||
|
||||
class JKRDecomp : public JKRThread {
|
||||
private:
|
||||
JKRDecomp(long);
|
||||
virtual ~JKRDecomp();
|
||||
|
||||
/* vt[03] */ virtual void* run(); /* override */
|
||||
|
||||
public:
|
||||
static JKRDecomp* create(long);
|
||||
static JKRDecompCommand* prepareCommand(u8*, u8*, u32, u32, JKRDecompCommand::AsyncCallback);
|
||||
static void sendCommand(JKRDecompCommand*);
|
||||
static bool sync(JKRDecompCommand*, int);
|
||||
static JKRDecompCommand* orderAsync(u8*, u8*, u32, u32, JKRDecompCommand::AsyncCallback);
|
||||
static bool orderSync(u8*, u8*, u32, u32);
|
||||
static void decode(u8*, u8*, u32, u32);
|
||||
static void decodeSZP(u8*, u8*, u32, u32);
|
||||
static void decodeSZS(u8*, u8*, u32, u32);
|
||||
static JKRCompression checkCompressed(u8*);
|
||||
|
||||
static JKRDecomp* sDecompObject;
|
||||
static OSMessage sMessageBuffer[8];
|
||||
static OSMessageQueue sMessageQueue;
|
||||
};
|
||||
|
||||
inline void JKRDecompress(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 dstLength) {
|
||||
JKRDecomp::orderSync(srcBuffer, dstBuffer, srcLength, dstLength);
|
||||
}
|
||||
|
||||
inline JKRDecomp* JKRCreateDecompManager(long priority) {
|
||||
return JKRDecomp::create(priority);
|
||||
}
|
||||
|
||||
#endif /* JKRDECOMP_H */
|
||||
|
||||
@@ -1,6 +1,19 @@
|
||||
#ifndef JKRDISPOSER_H
|
||||
#define JKRDISPOSER_H
|
||||
|
||||
#include "JSystem/JSupport/JSUList.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRHeap;
|
||||
class JKRDisposer {
|
||||
public:
|
||||
JKRDisposer();
|
||||
virtual ~JKRDisposer();
|
||||
|
||||
public:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ JKRHeap* mHeap;
|
||||
/* 0x08 */ JSULink<JKRDisposer> mLink;
|
||||
};
|
||||
|
||||
#endif /* JKRDISPOSER_H */
|
||||
|
||||
@@ -1,6 +1,28 @@
|
||||
#ifndef JKRDVDARAMRIPPER_H
|
||||
#define JKRDVDARAMRIPPER_H
|
||||
|
||||
#include "JSystem/JKernel/JKRDvdRipper.h"
|
||||
#include "JSystem/JSupport/JSUFileStream.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRADCommand {
|
||||
public:
|
||||
JKRADCommand();
|
||||
~JKRADCommand();
|
||||
};
|
||||
|
||||
class JKRDvdFile;
|
||||
class JKRDvdAramRipper {
|
||||
public:
|
||||
static void loadToAram(long, u32, JKRExpandSwitch, u32, u32, u32*);
|
||||
static void loadToAram(JKRDvdFile*, u32, JKRExpandSwitch, u32, u32, u32*);
|
||||
static void loadToAram_Async(JKRDvdFile*, u32, JKRExpandSwitch, void (*)(u32), u32, u32, u32*);
|
||||
static void callCommand_Async(JKRADCommand*);
|
||||
static void syncAram(JKRADCommand*, int);
|
||||
|
||||
// TODO: fix type
|
||||
static u8 sDvdAramAsyncList[12];
|
||||
static u32 sSZSBufferSize;
|
||||
};
|
||||
|
||||
#endif /* JKRDVDARAMRIPPER_H */
|
||||
|
||||
@@ -1,6 +1,33 @@
|
||||
#ifndef JKRDVDARCHIVE_H
|
||||
#define JKRDVDARCHIVE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRArchive.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRDvdFile;
|
||||
class JKRDvdArchive : public JKRArchive {
|
||||
public:
|
||||
JKRDvdArchive(s32, JKRArchive::EMountDirection);
|
||||
virtual ~JKRDvdArchive();
|
||||
|
||||
bool open(s32);
|
||||
|
||||
/* vt[15] */ virtual u32 getExpandedResSize(const void*) const; /* override */
|
||||
/* vt[16] */ virtual void* fetchResource(SDIFileEntry*, u32*); /* override */
|
||||
/* vt[17] */ virtual void* fetchResource(void*, u32, SDIFileEntry*, u32*); /* override */
|
||||
|
||||
public:
|
||||
static u32 fetchResource_subroutine(s32, u32, u32, u8*, u32, JKRCompression, JKRCompression);
|
||||
static u32 fetchResource_subroutine(s32, u32, u32, JKRHeap*, JKRCompression, JKRCompression,
|
||||
u8**);
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRArchive
|
||||
/* 0x5C */ JKRCompression mCompression;
|
||||
/* 0x60 */ EMountDirection mMountDirection;
|
||||
/* 0x64 */ s32 field_0x64;
|
||||
/* 0x68 */ JKRDvdFile* mDvdFile;
|
||||
};
|
||||
|
||||
#endif /* JKRDVDARCHIVE_H */
|
||||
|
||||
@@ -1,6 +1,60 @@
|
||||
#ifndef JKRDVDFILE_H
|
||||
#define JKRDVDFILE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRFile.h"
|
||||
#include "dolphin/dvd/dvd.h"
|
||||
#include "dolphin/os/OS.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRADCommand;
|
||||
class JSUFileInputStream;
|
||||
class JKRDvdFile : public JKRFile {
|
||||
public:
|
||||
JKRDvdFile();
|
||||
JKRDvdFile(const char*);
|
||||
JKRDvdFile(long);
|
||||
virtual ~JKRDvdFile();
|
||||
|
||||
void initiate(void);
|
||||
s32 sync(void);
|
||||
|
||||
u32 getFileID() const { return mFileInfo.start_address; }
|
||||
const DVDFileInfo& getFileInfo() const { return mFileInfo; }
|
||||
int getStatus() { return DVDGetCommandBlockStatus(&mFileInfo.block); }
|
||||
|
||||
public:
|
||||
/* vt[03] */ virtual bool open(const char*); /* override */
|
||||
/* vt[04] */ virtual void close(void); /* override */
|
||||
/* vt[05] */ virtual s32 readData(void*, s32, s32); /* override */
|
||||
/* vt[06] */ virtual s32 writeData(const void*, s32, s32); /* override */
|
||||
/* vt[07] */ virtual s32 getFileSize(void) const; /* override */
|
||||
/* vt[08] */ virtual bool open(s32);
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRFile
|
||||
/* 0x1C */ OSMutex mMutex1;
|
||||
/* 0x34 */ OSMutex mMutex2;
|
||||
/* 0x4C */ u32 field_0x4c;
|
||||
/* 0x50 */ u32 field_0x50;
|
||||
/* 0x54 */ u32 field_0x54;
|
||||
/* 0x58 */ u32 field_0x58;
|
||||
/* 0x5C */ DVDFileInfo mFileInfo;
|
||||
/* 0x98 */ JKRDvdFile* mDvdFile;
|
||||
/* 0x9C */ OSMessageQueue mMessageQueue1;
|
||||
/* 0xBC */ OSMessage mMessage1;
|
||||
/* 0xC0 */ OSMessageQueue mMessageQueue2;
|
||||
/* 0xE0 */ OSMessage mMessage2;
|
||||
/* 0xE4 */ JSULink<JKRDvdFile> mDvdLink;
|
||||
/* 0xF4 */ OSThread* mOSThread;
|
||||
|
||||
public:
|
||||
static void doneProcess(long, DVDFileInfo*);
|
||||
|
||||
static JSUList<JKRDvdFile>& getDvdList() { return sDvdList; }
|
||||
|
||||
private:
|
||||
static JSUList<JKRDvdFile> sDvdList;
|
||||
};
|
||||
|
||||
#endif /* JKRDVDFILE_H */
|
||||
|
||||
@@ -1,6 +1,46 @@
|
||||
#ifndef JKRDVDRIPPER_H
|
||||
#define JKRDVDRIPPER_H
|
||||
|
||||
#include "JSystem/JKernel/JKRDecomp.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
enum JKRExpandSwitch {
|
||||
EXPAND_SWITCH_UNKNOWN0 = 0,
|
||||
EXPAND_SWITCH_UNKNOWN1 = 1,
|
||||
EXPAND_SWITCH_UNKNOWN2 = 2,
|
||||
};
|
||||
|
||||
class JKRHeap;
|
||||
class JKRDvdFile;
|
||||
class JKRDvdRipper {
|
||||
public:
|
||||
// TODO: fix type
|
||||
static u8 sDvdAsyncList[12];
|
||||
static u32 sSZSBufferSize;
|
||||
|
||||
enum EAllocDirection {
|
||||
UNKNOWN_EALLOC_DIRECTION = 0,
|
||||
ALLOC_DIRECTION_FORWARD = 1,
|
||||
ALLOC_DIRECTION_BACKWARD = 2,
|
||||
};
|
||||
|
||||
static void* loadToMainRAM(char const*, u8*, JKRExpandSwitch, u32, JKRHeap*, EAllocDirection,
|
||||
u32, JKRCompression*, u32*);
|
||||
static void* loadToMainRAM(long, u8*, JKRExpandSwitch, u32, JKRHeap*, EAllocDirection, u32,
|
||||
JKRCompression*, u32*);
|
||||
static void* loadToMainRAM(JKRDvdFile*, u8*, JKRExpandSwitch, u32, JKRHeap*, EAllocDirection,
|
||||
u32, JKRCompression*, u32*);
|
||||
|
||||
u8 isErrorRetry(void);
|
||||
};
|
||||
|
||||
// void JKRDecompressFromDVD(JKRDvdFile*, void*, u32, u32, u32, u32, u32*);
|
||||
|
||||
inline void* JKRDvdToMainRam(s32 entryNum, u8* dst, JKRExpandSwitch expandSwitch, u32 dstLength,
|
||||
JKRHeap* heap, JKRDvdRipper::EAllocDirection allocDirection,
|
||||
u32 offset, JKRCompression* compression, u32* returnSize) {
|
||||
return JKRDvdRipper::loadToMainRAM(entryNum, dst, expandSwitch, dstLength, heap, allocDirection,
|
||||
offset, compression, returnSize);
|
||||
}
|
||||
|
||||
#endif /* JKRDVDRIPPER_H */
|
||||
|
||||
@@ -1,6 +1,93 @@
|
||||
#ifndef JKREXPHEAP_H
|
||||
#define JKREXPHEAP_H
|
||||
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRExpHeap : public JKRHeap {
|
||||
public:
|
||||
class CMemBlock {
|
||||
public:
|
||||
void initiate(CMemBlock*, CMemBlock*, u32, u8, u8);
|
||||
void allocFore(u32, u8, u8, u8, u8);
|
||||
void allocBack(u32, u8, u8, u8, u8);
|
||||
void free(JKRExpHeap*);
|
||||
void getHeapBlock(void*);
|
||||
|
||||
void newGroupId(u8 groupId) { this->mGroupId = groupId; }
|
||||
bool isValid() const { return this->mMagic == 0x484d; }
|
||||
bool _isTempMemBlock() const { return (this->mFlags & 0x80) ? true : false; }
|
||||
int getAlignment() const { return this->mFlags & 0x7f; }
|
||||
void* getContent() const { return (void*)(this + 1); }
|
||||
CMemBlock* getPrevBlock() const { return this->mPrev; }
|
||||
CMemBlock* getNextBlock() const { return this->mNext; }
|
||||
u32 getSize() const { return this->size; }
|
||||
static CMemBlock* getBlock(void* data) { return (CMemBlock*)((u32)data + -0x10); }
|
||||
|
||||
private:
|
||||
u16 mMagic;
|
||||
u8 mFlags; // a|bbbbbbb a=temporary b=alignment
|
||||
u8 mGroupId;
|
||||
u32 size;
|
||||
CMemBlock* mPrev;
|
||||
CMemBlock* mNext;
|
||||
};
|
||||
|
||||
protected:
|
||||
JKRExpHeap(void*, u32, JKRHeap*, bool);
|
||||
virtual ~JKRExpHeap();
|
||||
|
||||
void allocFromHead(u32, int);
|
||||
void allocFromHead(u32);
|
||||
void allocFromTail(u32, int);
|
||||
void allocFromTail(u32);
|
||||
void appendUsedList(CMemBlock*);
|
||||
void setFreeBlock(CMemBlock*, CMemBlock*, CMemBlock*);
|
||||
void removeFreeBlock(CMemBlock*);
|
||||
void removeUsedBlock(CMemBlock*);
|
||||
void recycleFreeBlock(CMemBlock*);
|
||||
void joinTwoBlocks(CMemBlock*);
|
||||
|
||||
public:
|
||||
s32 getUsedSize(u8) const;
|
||||
s32 getTotalUsedSize(void) const;
|
||||
CMemBlock* getHeadUsedList() const { return mHeadUsedList; }
|
||||
|
||||
public:
|
||||
/* vt[04] */ virtual u32 getHeapType(); /* override */
|
||||
/* vt[05] */ virtual bool check(); /* override */
|
||||
/* vt[06] */ virtual bool dump_sort(); /* override */
|
||||
/* vt[07] */ virtual bool dump(); /* override */
|
||||
/* vt[08] */ virtual void do_destroy(); /* override */
|
||||
/* vt[09] */ virtual void* do_alloc(u32 size, int alignment); /* override */
|
||||
/* vt[10] */ virtual void do_free(void* ptr); /* override */
|
||||
/* vt[11] */ virtual void do_freeAll(); /* override */
|
||||
/* vt[12] */ virtual void do_freeTail(); /* override */
|
||||
/* vt[13] */ virtual void do_fillFreeArea(); /* override */
|
||||
/* vt[14] */ virtual s32 do_resize(void* ptr, u32 size); /* override */
|
||||
/* vt[15] */ virtual s32 do_getSize(void* ptr); /* override */
|
||||
/* vt[16] */ virtual s32 do_getFreeSize(); /* override */
|
||||
/* vt[17] */ virtual void* do_getMaxFreeBlock(); /* override */
|
||||
/* vt[18] */ virtual s32 do_getTotalFreeSize(); /* override */
|
||||
/* vt[19] */ virtual u8 do_changeGroupID(u8 newGroupID); /* override */
|
||||
/* vt[20] */ virtual u8 do_getCurrentGroupId(); /* override */
|
||||
/* vt[21] */ virtual void state_register(JKRHeap::TState*, u32) const; /* override */
|
||||
/* vt[22] */ virtual bool state_compare(JKRHeap::TState const&,
|
||||
JKRHeap::TState const&) const; /* override */
|
||||
|
||||
private:
|
||||
u32 field_0x6c;
|
||||
u32 field_0x70;
|
||||
u32 field_0x74;
|
||||
CMemBlock* mHeadFreeList;
|
||||
CMemBlock* mTailFreeList;
|
||||
CMemBlock* mHeadUsedList;
|
||||
CMemBlock* mTailUsedList;
|
||||
|
||||
public:
|
||||
static void createRoot(int, bool);
|
||||
static void create(u32, JKRHeap*, bool);
|
||||
static void create(void*, u32, JKRHeap*, bool);
|
||||
};
|
||||
|
||||
#endif /* JKREXPHEAP_H */
|
||||
|
||||
@@ -1,6 +1,30 @@
|
||||
#ifndef JKRFILE_H
|
||||
#define JKRFILE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRDisposer.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRFile : public JKRDisposer {
|
||||
public:
|
||||
JKRFile() : mIsAvailable(false) {}
|
||||
virtual ~JKRFile() {}
|
||||
|
||||
s32 read(void*, long, long);
|
||||
|
||||
bool isAvailable() const { return mIsAvailable; }
|
||||
|
||||
public:
|
||||
/* vt[03] */ virtual bool open(const char*) = 0;
|
||||
/* vt[04] */ virtual void close() = 0;
|
||||
/* vt[05] */ virtual s32 readData(void*, s32, s32) = 0;
|
||||
/* vt[06] */ virtual s32 writeData(const void*, s32, s32) = 0;
|
||||
/* vt[07] */ virtual s32 getFileSize() const = 0;
|
||||
|
||||
protected:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRDisposer
|
||||
/* 0x18 */ bool mIsAvailable;
|
||||
/* 0x19 */ u8 field_0x19[3];
|
||||
};
|
||||
|
||||
#endif /* JKRFILE_H */
|
||||
|
||||
@@ -1,6 +1,63 @@
|
||||
#ifndef JKRFILECACHE_H
|
||||
#define JKRFILECACHE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRFileLoader.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRHeap;
|
||||
class JKRFileCache : public JKRFileLoader {
|
||||
public:
|
||||
class CCacheBlock {
|
||||
public:
|
||||
CCacheBlock(u32, u32, const void*);
|
||||
~CCacheBlock() {}
|
||||
|
||||
public:
|
||||
/* 0x00 */ JSULink<CCacheBlock> mCacheBlockLink;
|
||||
/* 0x10 */ u32 mReferenceCount;
|
||||
/* 0x14 */ u32 mFileId;
|
||||
/* 0x18 */ u32 mFileSize;
|
||||
/* 0x1C */ void* mMemoryPtr;
|
||||
};
|
||||
|
||||
protected:
|
||||
JKRFileCache(const char*, const char*);
|
||||
virtual ~JKRFileCache();
|
||||
|
||||
CCacheBlock* findCacheBlock(const void*) const;
|
||||
CCacheBlock* findCacheBlock(u32) const;
|
||||
bool findFile(char*, const char*) const;
|
||||
char* getDvdPathName(const char*) const;
|
||||
void convStrLower(char*) const;
|
||||
|
||||
public:
|
||||
/* vt[04] */ virtual bool becomeCurrent(const char*); /* override */
|
||||
/* vt[05] */ virtual void* getResource(const char*); /* override */
|
||||
/* vt[06] */ virtual void* getResource(u32, const char*); /* override */
|
||||
/* vt[07] */ virtual u32 readResource(void*, u32, const char*); /* override */
|
||||
/* vt[08] */ virtual u32 readResource(void*, u32, u32, const char*); /* override */
|
||||
/* vt[09] */ virtual void removeResourceAll(void); /* override */
|
||||
/* vt[10] */ virtual bool removeResource(void*); /* override */
|
||||
/* vt[11] */ virtual bool detachResource(void*); /* override */
|
||||
/* vt[12] */ virtual u32 getResSize(const void*) const; /* override */
|
||||
/* vt[13] */ virtual u32 countFile(const char*) const; /* override */
|
||||
/* vt[14] */ virtual JKRFileFinder* getFirstFile(const char*) const; /* override */
|
||||
/* vt[15] */ virtual void* getFsResource(const char*);
|
||||
/* vt[16] */ virtual void* getNameResource(u32, const char*);
|
||||
/* vt[17] */ virtual u32 readFsResource(void*, u32, const char*);
|
||||
/* vt[18] */ virtual u32 readNameResource(void*, u32, u32, const char*);
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRFileLoader
|
||||
/* 0x38 */ JKRHeap* mParentHeap;
|
||||
/* 0x3C */ JSUList<CCacheBlock> mCacheBlockList;
|
||||
/* 0x48 */ char* mRootPath;
|
||||
/* 0x4C */ char* mCurrentPath;
|
||||
/* 0x50 */ char* mVolumePath;
|
||||
|
||||
public:
|
||||
static JKRFileCache* mount(const char*, JKRHeap*, const char*);
|
||||
};
|
||||
|
||||
#endif /* JKRFILECACHE_H */
|
||||
|
||||
@@ -1,6 +1,73 @@
|
||||
#ifndef JKRFILEFINDER_H
|
||||
#define JKRFILEFINDER_H
|
||||
|
||||
#include "dolphin/dvd/dvd.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
struct JKRFileFinder_UnknownBase {
|
||||
const char* mEntryName;
|
||||
s32 mEntryFileIndex;
|
||||
u16 mEntryId;
|
||||
u16 mEntryTypeFlags;
|
||||
};
|
||||
|
||||
class JKRFileFinder : public JKRFileFinder_UnknownBase {
|
||||
public:
|
||||
JKRFileFinder() {
|
||||
mIsAvailable = false;
|
||||
mIsFileOrDirectory = false;
|
||||
}
|
||||
inline virtual ~JKRFileFinder();
|
||||
|
||||
bool isAvailable() const { return mIsAvailable; }
|
||||
bool isFile() const { return mIsFileOrDirectory; }
|
||||
bool isDirectory() const { return mIsFileOrDirectory; }
|
||||
|
||||
public:
|
||||
/* vt[3] */ virtual bool findNextFile(void) = 0;
|
||||
|
||||
protected:
|
||||
/* 0x00 */ // JKRFileFinder_UnknownBase
|
||||
/* 0x0C */ // vtable
|
||||
/* 0x10 */ bool mIsAvailable;
|
||||
/* 0x11 */ bool mIsFileOrDirectory;
|
||||
/* 0x12 */ u8 field_0x12[2];
|
||||
};
|
||||
|
||||
class JKRArchive;
|
||||
class JKRArcFinder : public JKRFileFinder {
|
||||
public:
|
||||
JKRArcFinder(JKRArchive*, s32, s32);
|
||||
inline virtual ~JKRArcFinder();
|
||||
|
||||
public:
|
||||
/* vt[3] */ virtual bool findNextFile(void); /* override */
|
||||
|
||||
private:
|
||||
/* 0x00 */ // JKRFileFinder_UnknownBase
|
||||
/* 0x0C */ // vtable
|
||||
/* 0x10 */ // JKRFileFinder
|
||||
/* 0x14 */ JKRArchive* mArchive;
|
||||
/* 0x18 */ s32 mStartIndex;
|
||||
/* 0x1C */ s32 mEndIndex;
|
||||
/* 0x20 */ s32 mNextIndex;
|
||||
};
|
||||
|
||||
class JKRDvdFinder : public JKRFileFinder {
|
||||
public:
|
||||
JKRDvdFinder(const char*);
|
||||
virtual ~JKRDvdFinder();
|
||||
|
||||
public:
|
||||
/* vt[3] */ virtual bool findNextFile(void); /* override */
|
||||
|
||||
private:
|
||||
/* 0x00 */ // JKRFileFinder_UnknownBase
|
||||
/* 0x0C */ // vtable
|
||||
/* 0x10 */ // JKRFileFinder
|
||||
/* 0x14 */ DVDDirectory mDvdDirectory;
|
||||
/* 0x20 */ bool mDvdIsOpen;
|
||||
/* 0x21 */ u8 field_0x21[3];
|
||||
};
|
||||
|
||||
#endif /* JKRFILEFINDER_H */
|
||||
|
||||
@@ -1,6 +1,57 @@
|
||||
#ifndef JKRFILELOADER_H
|
||||
#define JKRFILELOADER_H
|
||||
|
||||
#include "JSystem/JKernel/JKRDisposer.h"
|
||||
#include "JSystem/JSupport/JSUList.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRFileFinder;
|
||||
class JKRFileLoader : public JKRDisposer {
|
||||
public:
|
||||
JKRFileLoader(void);
|
||||
virtual ~JKRFileLoader();
|
||||
|
||||
bool isMounted() const { return this->mIsMounted; }
|
||||
u32 getVolumeType() const { return this->mVolumeType; }
|
||||
|
||||
public:
|
||||
/* vt[03] */ virtual void unmount(void);
|
||||
/* vt[04] */ virtual bool becomeCurrent(const char*) = 0;
|
||||
/* vt[05] */ virtual void* getResource(const char*) = 0;
|
||||
/* vt[06] */ virtual void* getResource(u32, const char*) = 0;
|
||||
/* vt[07] */ virtual u32 readResource(void*, u32, const char*) = 0;
|
||||
/* vt[08] */ virtual u32 readResource(void*, u32, u32, const char*) = 0;
|
||||
/* vt[09] */ virtual void removeResourceAll(void) = 0;
|
||||
/* vt[10] */ virtual bool removeResource(void*) = 0;
|
||||
/* vt[11] */ virtual bool detachResource(void*) = 0;
|
||||
/* vt[12] */ virtual u32 getResSize(const void*) const = 0;
|
||||
/* vt[13] */ virtual u32 countFile(const char*) const = 0;
|
||||
/* vt[14] */ virtual JKRFileFinder* getFirstFile(const char*) const = 0;
|
||||
|
||||
protected:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRDisposer
|
||||
/* 0x18 */ JSULink<JKRFileLoader> mFileLoaderLink;
|
||||
/* 0x28 */ const char* mVolumeName;
|
||||
/* 0x2C */ u32 mVolumeType;
|
||||
/* 0x30 */ bool mIsMounted;
|
||||
/* 0x31 */ u8 field_0x31[3];
|
||||
/* 0x34 */ u32 mMountCount;
|
||||
|
||||
public:
|
||||
static void* getGlbResource(const char*);
|
||||
static void* getGlbResource(const char*, JKRFileLoader*);
|
||||
static bool removeResource(void*, JKRFileLoader*);
|
||||
static bool detachResource(void*, JKRFileLoader*);
|
||||
static JKRFileLoader* findVolume(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* sCurrentVolume;
|
||||
static JSUList<JKRFileLoader> sVolumeList;
|
||||
};
|
||||
|
||||
#endif /* JKRFILELOADER_H */
|
||||
|
||||
@@ -1,6 +1,215 @@
|
||||
#ifndef JKRHEAP_H
|
||||
#define JKRHEAP_H
|
||||
|
||||
#include "JSystem/JKernel/JKRDisposer.h"
|
||||
#include "dolphin/os/OS.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRHeap;
|
||||
typedef void (*JKRErrorHandler)(void*, u32, int);
|
||||
|
||||
class JKRHeap : public JKRDisposer {
|
||||
public:
|
||||
class TState {
|
||||
public:
|
||||
u32 mUsedSize;
|
||||
u32 mCheckCode;
|
||||
u32 mBuf;
|
||||
u32 field_0xc;
|
||||
JKRHeap* mHeap;
|
||||
u32 mId;
|
||||
|
||||
public:
|
||||
u32 getUsedSize() const { return mUsedSize; }
|
||||
u32 getCheckCode() const { return mCheckCode; }
|
||||
JKRHeap* getHeap() const { return mHeap; }
|
||||
u32 getId() const { return mId; }
|
||||
};
|
||||
|
||||
public:
|
||||
JKRHeap(void*, u32, JKRHeap*, bool);
|
||||
virtual ~JKRHeap();
|
||||
|
||||
JKRHeap* becomeSystemHeap();
|
||||
JKRHeap* becomeCurrentHeap();
|
||||
void destroy();
|
||||
|
||||
void* alloc(u32 size, int alignment);
|
||||
void free(void* ptr);
|
||||
void freeAll();
|
||||
void freeTail();
|
||||
s32 resize(void* ptr, u32 size);
|
||||
s32 getSize(void* ptr);
|
||||
s32 getFreeSize();
|
||||
void* getMaxFreeBlock();
|
||||
s32 getTotalFreeSize();
|
||||
u8 changeGroupID(u8 newGroupId);
|
||||
u32 getMaxAllocatableSize(int alignment);
|
||||
|
||||
JKRHeap* find(void* ptr) const;
|
||||
JKRHeap* findAllHeap(void* ptr) const;
|
||||
|
||||
void dispose_subroutine(u32 start, u32 end);
|
||||
bool dispose(void* ptr, u32 size);
|
||||
void dispose(void* begin, void* end);
|
||||
void dispose();
|
||||
|
||||
bool setErrorFlag(bool errorFlag);
|
||||
bool isSubHeap(JKRHeap* heap) const;
|
||||
|
||||
/* vt[03] */ virtual void callAllDisposer();
|
||||
/* vt[04] */ virtual u32 getHeapType() = 0;
|
||||
/* vt[05] */ virtual bool check() = 0;
|
||||
/* vt[06] */ virtual bool dump_sort();
|
||||
/* vt[07] */ virtual bool dump() = 0;
|
||||
/* vt[08] */ virtual void do_destroy() = 0;
|
||||
/* vt[09] */ virtual void* do_alloc(u32 size, int alignment) = 0;
|
||||
/* vt[10] */ virtual void do_free(void* ptr) = 0;
|
||||
/* vt[11] */ virtual void do_freeAll() = 0;
|
||||
/* vt[12] */ virtual void do_freeTail() = 0;
|
||||
/* vt[13] */ virtual void do_fillFreeArea() = 0;
|
||||
/* vt[14] */ virtual s32 do_resize(void* ptr, u32 size) = 0;
|
||||
/* vt[15] */ virtual s32 do_getSize(void* ptr) = 0;
|
||||
/* vt[16] */ virtual s32 do_getFreeSize() = 0;
|
||||
/* vt[17] */ virtual void* do_getMaxFreeBlock() = 0;
|
||||
/* vt[18] */ virtual s32 do_getTotalFreeSize() = 0;
|
||||
/* vt[19] */ virtual u8 do_changeGroupID(u8 newGroupID);
|
||||
/* vt[20] */ virtual u8 do_getCurrentGroupId();
|
||||
/* vt[21] */ virtual void state_register(JKRHeap::TState*, unsigned long) const;
|
||||
/* vt[22] */ virtual bool state_compare(JKRHeap::TState const&, JKRHeap::TState const&) const;
|
||||
/* vt[23] */ virtual void state_dump(JKRHeap::TState const&) const;
|
||||
|
||||
void setDebugFill(bool debugFill) { mDebugFill = debugFill; }
|
||||
bool getDebugFill() const { return mDebugFill; }
|
||||
void* getStartAddr() const { return (void*)mStart; }
|
||||
void* getEndAddr() const { return (void*)mEnd; }
|
||||
u32 getSize() const { return mSize; }
|
||||
bool getErrorFlag() const { return mErrorFlag; }
|
||||
void callErrorHandler(JKRHeap* heap, u32 size, int alignment) {
|
||||
if (mErrorHandler) {
|
||||
(*mErrorHandler)(heap, size, alignment);
|
||||
}
|
||||
}
|
||||
|
||||
JKRHeap* getParent() const {
|
||||
JSUTree<JKRHeap>* parent = mChildTree.getParent();
|
||||
return parent->getObject();
|
||||
}
|
||||
|
||||
JSUTree<JKRHeap>& getHeapTree() { return mChildTree; }
|
||||
void appendDisposer(JKRDisposer* disposer) { mDisposerList.append(&disposer->mLink); }
|
||||
void removeDisposer(JKRDisposer* disposer) { mDisposerList.remove(&disposer->mLink); }
|
||||
void lock() { OSLockMutex(&mMutex); }
|
||||
void unlock() { OSUnlockMutex(&mMutex); }
|
||||
|
||||
protected:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRDisposer
|
||||
/* 0x18 */ OSMutex mMutex;
|
||||
/* 0x30 */ u8* mStart;
|
||||
/* 0x34 */ u8* mEnd;
|
||||
/* 0x38 */ u32 mSize;
|
||||
/* 0x3C */ bool mDebugFill;
|
||||
/* 0x3D */ bool mCheckMemoryFilled;
|
||||
/* 0x3E */ u8 mAllocationMode; // EAllocMode?
|
||||
/* 0x3F */ u8 mGroupId;
|
||||
/* 0x40 */ JSUTree<JKRHeap> mChildTree;
|
||||
/* 0x5C */ JSUList<JKRDisposer> mDisposerList;
|
||||
/* 0x68 */ bool mErrorFlag;
|
||||
/* 0x69 */ bool mInitFlag;
|
||||
/* 0x6A */ u8 padding_0x6a[2];
|
||||
|
||||
public:
|
||||
static bool initArena(char**, u32*, int);
|
||||
static void* alloc(u32 size, int alignment, JKRHeap* heap);
|
||||
static void free(void* ptr, JKRHeap* heap);
|
||||
static s32 resize(void* ptr, u32 size, JKRHeap* heap);
|
||||
static s32 getSize(void* ptr, JKRHeap* heap);
|
||||
static JKRHeap* findFromRoot(void* ptr);
|
||||
|
||||
static void copyMemory(void* dst, void* src, u32 size);
|
||||
static void fillMemory(void* dst, u32 size, u8 value); // NOTE: never used
|
||||
static bool checkMemoryFilled(void* src, u32 size, u8 value);
|
||||
|
||||
static JKRErrorHandler setErrorHandler(JKRErrorHandler errorHandler);
|
||||
|
||||
static void* getCodeStart(void) { return mCodeStart; }
|
||||
static void* getCodeEnd(void) { return mCodeEnd; }
|
||||
static void* getUserRamStart(void) { return mUserRamStart; }
|
||||
static void* getUserRamEnd(void) { return mUserRamEnd; }
|
||||
static u32 getMemorySize(void) { return mMemorySize; }
|
||||
static JKRHeap* getRootHeap() { return sRootHeap; }
|
||||
static JKRHeap* getSystemHeap() { return sSystemHeap; }
|
||||
static JKRHeap* getCurrentHeap() { return sCurrentHeap; }
|
||||
static void setSystemHeap(JKRHeap* heap) { sSystemHeap = heap; }
|
||||
static void setCurrentHeap(JKRHeap* heap) { sCurrentHeap = heap; }
|
||||
|
||||
static void setState_u32ID_(TState* state, u32 id) { state->mId = id; }
|
||||
static void setState_uUsedSize_(TState* state, u32 usedSize) { state->mUsedSize = usedSize; }
|
||||
static void setState_u32CheckCode_(TState* state, u32 checkCode) {
|
||||
state->mCheckCode = checkCode;
|
||||
}
|
||||
static void* getState_buf_(TState* state) { return &state->mBuf; }
|
||||
static void* getState_(TState* state) { return getState_buf_(state); }
|
||||
|
||||
static void* mCodeStart;
|
||||
static void* mCodeEnd;
|
||||
static void* mUserRamStart;
|
||||
static void* mUserRamEnd;
|
||||
static u32 mMemorySize;
|
||||
|
||||
static JKRHeap* sRootHeap;
|
||||
static JKRHeap* sSystemHeap;
|
||||
static JKRHeap* sCurrentHeap;
|
||||
|
||||
static JKRErrorHandler mErrorHandler;
|
||||
};
|
||||
|
||||
void* operator new(u32 size);
|
||||
void* operator new(u32 size, int alignment);
|
||||
void* operator new(u32 size, JKRHeap* heap, int alignment);
|
||||
|
||||
void* operator new[](u32 size);
|
||||
void* operator new[](u32 size, int alignment);
|
||||
void* operator new[](u32 size, JKRHeap* heap, int alignment);
|
||||
|
||||
void operator delete(void* ptr);
|
||||
void operator delete[](void* ptr);
|
||||
|
||||
inline void* operator new(u32 size, void* ptr) {
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void JKRDefaultMemoryErrorRoutine(void* heap, u32 size, int alignment);
|
||||
|
||||
inline void* JKRAllocFromHeap(JKRHeap* heap, u32 size, int alignment) {
|
||||
return JKRHeap::alloc(size, alignment, heap);
|
||||
}
|
||||
|
||||
inline void* JKRAllocFromSysHeap(u32 size, int alignment) {
|
||||
JKRHeap* systemHeap = JKRHeap::getSystemHeap();
|
||||
return systemHeap->alloc(size, alignment);
|
||||
}
|
||||
|
||||
inline void JKRFreeToHeap(JKRHeap* heap, void* ptr) {
|
||||
JKRHeap::free(ptr, heap);
|
||||
}
|
||||
|
||||
inline void JKRFreeToSysHeap(void* ptr) {
|
||||
JKRHeap* systemHeap = JKRHeap::getSystemHeap();
|
||||
systemHeap->free(ptr);
|
||||
}
|
||||
|
||||
inline void JKRFree(void* ptr) {
|
||||
JKRHeap::free(ptr, NULL);
|
||||
}
|
||||
|
||||
inline JKRHeap* JKRGetSystemHeap() {
|
||||
return JKRHeap::getSystemHeap();
|
||||
}
|
||||
|
||||
inline JKRHeap* JKRGetCurrentHeap() {
|
||||
return JKRHeap::getCurrentHeap();
|
||||
}
|
||||
|
||||
#endif /* JKRHEAP_H */
|
||||
|
||||
@@ -1,6 +1,42 @@
|
||||
#ifndef JKRMEMARCHIVE_H
|
||||
#define JKRMEMARCHIVE_H
|
||||
|
||||
#include "JSystem/JKernel/JKRArchive.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
enum JKRMemBreakFlag {
|
||||
JKRMEMBREAK_FLAG_UNKNOWN0 = 0,
|
||||
JKRMEMBREAK_FLAG_UNKNOWN1 = 1,
|
||||
};
|
||||
|
||||
class JKRMemArchive : public JKRArchive {
|
||||
public:
|
||||
JKRMemArchive(long, JKRArchive::EMountDirection);
|
||||
JKRMemArchive(void*, u32, JKRMemBreakFlag);
|
||||
virtual ~JKRMemArchive();
|
||||
|
||||
bool open(long, JKRArchive::EMountDirection);
|
||||
bool open(void*, u32, JKRMemBreakFlag);
|
||||
|
||||
/* vt[09] */ void removeResourceAll(void); /* override */
|
||||
/* vt[10] */ bool removeResource(void*); /* override */
|
||||
|
||||
/* vt[15] */ u32 getExpandedResSize(const void*) const; /* override */
|
||||
/* vt[16] */ void* fetchResource(SDIFileEntry*, u32*); /* override */
|
||||
/* vt[17] */ void* fetchResource(void*, u32, SDIFileEntry*, u32*); /* override */
|
||||
|
||||
public:
|
||||
static u32 fetchResource_subroutine(u8*, u32, u8*, u32, JKRCompression);
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRArchive
|
||||
/* 0x5C */ JKRCompression mCompression;
|
||||
/* 0x60 */ EMountDirection mMountDirection;
|
||||
/* 0x64 */ SArcHeader* mArcHeader;
|
||||
/* 0x68 */ u8* mArchiveData;
|
||||
/* 0x6C */ bool mIsOpen;
|
||||
/* 0x6D */ u8 field_0x6d[3];
|
||||
};
|
||||
|
||||
#endif /* JKRMEMARCHIVE_H */
|
||||
|
||||
@@ -1,6 +1,60 @@
|
||||
#ifndef JKRSOLIDHEAP_H
|
||||
#define JKRSOLIDHEAP_H
|
||||
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRSolidHeap : public JKRHeap {
|
||||
public:
|
||||
struct Unknown {
|
||||
u32 field_0x0;
|
||||
u32 field_0x4;
|
||||
u32 field_0x8;
|
||||
void* field_0xc;
|
||||
Unknown* mNext;
|
||||
};
|
||||
|
||||
protected:
|
||||
JKRSolidHeap(void*, u32, JKRHeap*, bool);
|
||||
virtual ~JKRSolidHeap();
|
||||
|
||||
s32 adjustSize(void);
|
||||
void* allocFromHead(u32, int);
|
||||
void* allocFromTail(u32, int);
|
||||
|
||||
s32 getUsedSize() { return mSize - getTotalFreeSize(); }
|
||||
|
||||
public:
|
||||
/* vt[04] */ virtual u32 getHeapType(void); /* override */
|
||||
/* vt[05] */ virtual bool check(void); /* override */
|
||||
|
||||
/* vt[07] */ virtual bool dump(void); /* override */
|
||||
/* vt[08] */ virtual void do_destroy(void); /* override */
|
||||
/* vt[09] */ virtual void* do_alloc(u32, int); /* override */
|
||||
/* vt[10] */ virtual void do_free(void*); /* override */
|
||||
/* vt[11] */ virtual void do_freeAll(void); /* override */
|
||||
/* vt[12] */ virtual void do_freeTail(void); /* override */
|
||||
/* vt[13] */ virtual void do_fillFreeArea(void); /* override */
|
||||
/* vt[14] */ virtual s32 do_resize(void*, u32); /* override */
|
||||
/* vt[15] */ virtual s32 do_getSize(void*); /* override */
|
||||
/* vt[16] */ virtual s32 do_getFreeSize(void); /* override */
|
||||
/* vt[17] */ virtual void* do_getMaxFreeBlock(void); /* override */
|
||||
/* vt[18] */ virtual s32 do_getTotalFreeSize(void); /* override */
|
||||
|
||||
/* vt[21] */ virtual void state_register(JKRHeap::TState*, u32) const; /* override */
|
||||
/* vt[22] */ virtual bool state_compare(JKRHeap::TState const&,
|
||||
JKRHeap::TState const&) const; /* override */
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRHeap
|
||||
/* 0x6C */ u32 mFreeSize;
|
||||
/* 0x70 */ u8* mSolidHead;
|
||||
/* 0x74 */ u8* mSolidTail;
|
||||
/* 0x78 */ Unknown* field_0x78;
|
||||
|
||||
public:
|
||||
static JKRSolidHeap* create(u32, JKRHeap*, bool);
|
||||
};
|
||||
|
||||
#endif /* JKRSOLIDHEAP_H */
|
||||
|
||||
@@ -1,6 +1,116 @@
|
||||
#ifndef JKRTHREAD_H
|
||||
#define JKRTHREAD_H
|
||||
|
||||
#include "JSystem/JKernel/JKRDisposer.h"
|
||||
#include "JSystem/JSupport/JSUList.h"
|
||||
#include "dolphin/os/OS.h"
|
||||
#include "dolphin/types.h"
|
||||
|
||||
class JKRThreadName_;
|
||||
class JUTConsole;
|
||||
class JKRHeap;
|
||||
class JKRThread : JKRDisposer {
|
||||
public:
|
||||
JKRThread(u32 stack_size, int message_count, int param_3);
|
||||
JKRThread(JKRHeap* heap, u32 stack_size, int message_count, int param_4);
|
||||
JKRThread(OSThread* thread, int message_count);
|
||||
virtual ~JKRThread();
|
||||
|
||||
/* vt[03] */ virtual void* run();
|
||||
|
||||
void setCommon_mesgQueue(JKRHeap* heap, int message_count);
|
||||
void setCommon_heapSpecified(JKRHeap* heap, u32 stack_size, int param_3);
|
||||
|
||||
OSThread* getThreadRecord() const { return mThreadRecord; }
|
||||
void* getStack() const { return mStackMemory; }
|
||||
u8 getLoadInfo() const { return field_0x60; }
|
||||
JKRHeap* getCurrentHeap() const { return mCurrentHeap; }
|
||||
JKRHeap* getCurrentHeapError() const { return mCurrentHeapError; }
|
||||
|
||||
protected:
|
||||
void resume() { OSResumeThread(mThreadRecord); }
|
||||
void sendMessage(OSMessage message) {
|
||||
OSSendMessage(&mMessageQueue, message, OS_MESSAGE_NON_BLOCKING);
|
||||
}
|
||||
void sendMessageBlock(OSMessage message) {
|
||||
OSSendMessage(&mMessageQueue, message, OS_MESSAGE_BLOCKING);
|
||||
}
|
||||
OSMessage waitMessage() {
|
||||
OSMessage message;
|
||||
OSReceiveMessage(&mMessageQueue, &message, OS_MESSAGE_NON_BLOCKING);
|
||||
return message;
|
||||
}
|
||||
OSMessage waitMessageBlock() {
|
||||
OSMessage message;
|
||||
OSReceiveMessage(&mMessageQueue, &message, OS_MESSAGE_BLOCKING);
|
||||
return message;
|
||||
}
|
||||
void jamMessageBlock(OSMessage message) {
|
||||
OSJamMessage(&mMessageQueue, message, OS_MESSAGE_BLOCKING);
|
||||
}
|
||||
|
||||
private:
|
||||
/* 0x00 */ // vtable
|
||||
/* 0x04 */ // JKRDisposer
|
||||
/* 0x18 */ JSULink<JKRThread> mThreadListLink;
|
||||
/* 0x28 */ JKRHeap* mHeap;
|
||||
/* 0x2C */ OSThread* mThreadRecord;
|
||||
/* 0x30 */ OSMessageQueue mMessageQueue;
|
||||
/* 0x50 */ OSMessage* mMessages;
|
||||
/* 0x54 */ s32 mMessageCount;
|
||||
/* 0x58 */ void* mStackMemory;
|
||||
/* 0x5C */ u32 mStackSize;
|
||||
/* 0x60 */ u8 field_0x60;
|
||||
/* 0x61 */ u8 padding_0x61[3];
|
||||
/* 0x64 */ u32 mCost;
|
||||
/* 0x68 */ u32 mSwitchCount;
|
||||
/* 0x6C */ u32 field_0x6c;
|
||||
/* 0x70 */ u32 field_0x70;
|
||||
/* 0x74 */ JKRHeap* mCurrentHeap;
|
||||
/* 0x78 */ JKRHeap* mCurrentHeapError;
|
||||
|
||||
public:
|
||||
static void* start(void* param_1);
|
||||
static JKRThread* searchThread(OSThread* thread);
|
||||
static JSUList<JKRThread>& getList() { return (JSUList<JKRThread>&)sThreadList; }
|
||||
|
||||
static JSUList<JKRThread> sThreadList;
|
||||
// static u8 sThreadList[12];
|
||||
};
|
||||
|
||||
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);
|
||||
|
||||
JKRThread* enter(JKRThread* param_1, int param_2);
|
||||
static void callback(OSThread* param_1, OSThread* param_2);
|
||||
|
||||
// TODO: fix types
|
||||
static u8 sManager[4];
|
||||
static u8 sTotalCount[4];
|
||||
static u8 sTotalStart[4];
|
||||
static u8 mUserPreCallback[4];
|
||||
static u8 mUserPostCallback[4];
|
||||
|
||||
public:
|
||||
JKRHeap* heap;
|
||||
u8 field_0x8[4];
|
||||
u32 field_0xC[2];
|
||||
u8 field_0x14[4];
|
||||
u32 field_0x18;
|
||||
u32 field_0x1C;
|
||||
u32 field_0x20;
|
||||
u32 field_0x24;
|
||||
};
|
||||
|
||||
struct JKRTask {
|
||||
static JSUList<JKRTask> sTaskList;
|
||||
static u8 sEndMesgQueue[32];
|
||||
};
|
||||
|
||||
#endif /* JKRTHREAD_H */
|
||||
|
||||
Reference in New Issue
Block a user