Merge pull request #54 from gamemasterplc/main
Clean up and label armem.c
This commit is contained in:
gamemasterplc
GitHub
commit
08c91ca972
7 changed files with 234 additions and 240 deletions
|
|
@ -251,7 +251,7 @@ config.libs = [
|
|||
Object(NonMatching, "game/hsfmotion.c"),
|
||||
Object(NonMatching, "game/hsfanim.c"),
|
||||
Object(NonMatching, "game/hsfex.c"),
|
||||
Object(NonMatching, "game/perf.c"),
|
||||
Object(Matching, "game/perf.c"),
|
||||
Object(Matching, "game/objmain.c"),
|
||||
Object(NonMatching, "game/fault.c"),
|
||||
Object(Matching, "game/gamework.c"),
|
||||
|
|
@ -270,7 +270,7 @@ config.libs = [
|
|||
Object(Matching, "game/window.c"),
|
||||
Object(Matching, "game/messdata.c"),
|
||||
Object(NonMatching, "game/card.c"),
|
||||
Object(NonMatching, "game/armem.c"),
|
||||
Object(Matching, "game/armem.c"),
|
||||
Object(NonMatching, "game/code_800498F0.c"),
|
||||
Object(NonMatching, "game/mapspace.c"),
|
||||
Object(NonMatching, "game/THPSimple.c"),
|
||||
|
|
|
|||
|
|
@ -3,19 +3,20 @@
|
|||
|
||||
#include "common.h"
|
||||
#include "game/memory.h"
|
||||
#include "game/data.h"
|
||||
|
||||
void HuARInit(void);
|
||||
void *HuARMalloc(u32 arg0);
|
||||
void HuARFree(void *arg0);
|
||||
u32 HuARMalloc(u32 size);
|
||||
void HuARFree(u32 amemptr);
|
||||
void HuAMemDump(void);
|
||||
void *HuAR_DVDtoARAM(u32 arg0);
|
||||
void HuAR_MRAMtoARAM(s32 arg0);
|
||||
void *HuAR_MRAMtoARAM2(void *arg0);
|
||||
void HuAR_ARAMtoMRAM(void *dst);
|
||||
void *HuAR_ARAMtoMRAMNum(void *dst, s32 num);
|
||||
BOOL HuARDMACheck(void);
|
||||
void *HuARDirCheck(u32 dir);
|
||||
void HuARDirFree(u32 arg0);
|
||||
void *HuAR_ARAMtoMRAMFileRead(u32 arg0, u32 arg1, HeapID arg2);
|
||||
u32 HuAR_DVDtoARAM(u32 dir);
|
||||
u32 HuAR_MRAMtoARAM(s32 dir);
|
||||
u32 HuAR_MRAMtoARAM2(void *dir_ptr);
|
||||
void HuAR_ARAMtoMRAM(u32 amemptr);
|
||||
void *HuAR_ARAMtoMRAMNum(u32 amemptr, s32 num);
|
||||
s32 HuARDMACheck(void);
|
||||
u32 HuARDirCheck(u32 dir);
|
||||
void HuARDirFree(u32 dir);
|
||||
void *HuAR_ARAMtoMRAMFileRead(u32 dir, u32 num, HeapID heap);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -63,10 +63,5 @@ void *HuDataReadNumHeapShortForce(s32 data_id, s32 num, HeapID heap);
|
|||
|
||||
void HuDecodeData(void *src, void *dst, u32 size, int decode_type);
|
||||
|
||||
void *HuARDirCheck(u32 dir);
|
||||
void HuAR_ARAMtoMRAM(void *dst);
|
||||
void *HuAR_ARAMtoMRAMNum(void *dst, s32 num);
|
||||
BOOL HuARDMACheck();
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
#ifndef _GAME_PERF_H
|
||||
#define _GAME_PERF_H
|
||||
|
||||
#include "common.h"
|
||||
#include "dolphin.h"
|
||||
|
||||
void HuPerfInit(void);
|
||||
s32 HuPerfCreate(char *arg0, u8 arg1, u8 arg2, u8 arg3, u8 arg4);
|
||||
|
|
|
|||
431
src/game/armem.c
431
src/game/armem.c
|
|
@ -1,36 +1,35 @@
|
|||
#include "game/armem.h"
|
||||
#include "game/data.h"
|
||||
|
||||
typedef struct some_armem_struct0 {
|
||||
/* 0x00 */ u8 unk00;
|
||||
/* 0x01 */ char unk01[1];
|
||||
/* 0x02 */ u16 unk02;
|
||||
/* 0x04 */ void *unk04;
|
||||
/* 0x08 */ u32 unk08;
|
||||
/* 0x0C */ struct some_armem_struct0 *unk0C;
|
||||
} SomeArmemStruct0; // Size 0x10
|
||||
typedef struct armem_block {
|
||||
/* 0x00 */ u8 flag;
|
||||
/* 0x02 */ u16 dir;
|
||||
/* 0x04 */ u32 amemptr;
|
||||
/* 0x08 */ u32 size;
|
||||
/* 0x0C */ struct armem_block *next;
|
||||
} ARMemBlock; // Size 0x10
|
||||
|
||||
typedef struct {
|
||||
/* 0x00 */ ARQRequest unk00;
|
||||
/* 0x20 */ s32 unk20;
|
||||
/* 0x24 */ void *unk24;
|
||||
} SomeArmemStruct1; // Size 0x28
|
||||
typedef struct ar_que_req {
|
||||
/* 0x00 */ ARQRequest req;
|
||||
/* 0x20 */ s32 dir;
|
||||
/* 0x24 */ void *dst;
|
||||
} ARQueReq; // Size 0x28
|
||||
|
||||
static void ArqCallBack(u32 pointerToARQRequest);
|
||||
static void ArqCallBackAM(u32 pointerToARQRequest);
|
||||
static void ArqCallBackAMFileRead(u32 pointerToARQRequest);
|
||||
|
||||
static s32 ATTRIBUTE_ALIGN(32) preLoadBuf[16];
|
||||
static SomeArmemStruct1 ARQueBuf[16];
|
||||
static ARQueReq ARQueBuf[16];
|
||||
static ARQRequest arqReq;
|
||||
static SomeArmemStruct0 ARInfo[64];
|
||||
static ARMemBlock ARInfo[64];
|
||||
|
||||
static s32 ARBase;
|
||||
static s32 arqCnt;
|
||||
static s16 arqIdx;
|
||||
|
||||
void HuARInit(void) {
|
||||
s32 temp_r30;
|
||||
s32 size;
|
||||
s16 i;
|
||||
|
||||
if (!ARCheckInit()) {
|
||||
|
|
@ -38,185 +37,183 @@ void HuARInit(void) {
|
|||
ARQInit();
|
||||
}
|
||||
for (i = 0; i < 64; i++) {
|
||||
ARInfo[i].unk04 = 0;
|
||||
ARInfo[i].amemptr = 0;
|
||||
}
|
||||
temp_r30 = ARGetSize() - 0x808000;
|
||||
size = ARGetSize() - 0x808000;
|
||||
ARBase = 0x808000;
|
||||
ARInfo[0].unk04 = (void*) ARBase;
|
||||
ARInfo[0].unk08 = temp_r30;
|
||||
ARInfo[0].unk00 = 0;
|
||||
ARInfo[0].unk0C = &ARInfo[1];
|
||||
ARInfo[0].unk02 = 0xFFFF;
|
||||
ARInfo[1].unk04 = (void*) -1;
|
||||
ARInfo[1].unk08 = 0;
|
||||
ARInfo[1].unk00 = 1;
|
||||
ARInfo[1].unk0C = 0;
|
||||
ARInfo[1].unk02 = 0xFFFF;
|
||||
ARInfo[0].amemptr = ARBase;
|
||||
ARInfo[0].size = size;
|
||||
ARInfo[0].flag = 0;
|
||||
ARInfo[0].next = &ARInfo[1];
|
||||
ARInfo[0].dir = 0xFFFF;
|
||||
ARInfo[1].amemptr = -1;
|
||||
ARInfo[1].size = 0;
|
||||
ARInfo[1].flag = 1;
|
||||
ARInfo[1].next = 0;
|
||||
ARInfo[1].dir = 0xFFFF;
|
||||
arqCnt = 0;
|
||||
}
|
||||
|
||||
void *HuARMalloc(u32 arg0) {
|
||||
SomeArmemStruct0 *var_r27;
|
||||
SomeArmemStruct0 *var_r30;
|
||||
SomeArmemStruct0 *var_r31;
|
||||
u32 HuARMalloc(u32 size) {
|
||||
ARMemBlock *prev;
|
||||
ARMemBlock *next;
|
||||
ARMemBlock *curr;
|
||||
s16 i;
|
||||
|
||||
arg0 = (arg0 + 0x1F) & ~0x1F;
|
||||
var_r31 = var_r27 = ARInfo;
|
||||
while (var_r31->unk0C != 0) {
|
||||
if (var_r31->unk00 == 0 && var_r31->unk08 >= arg0) {
|
||||
size = OSRoundUp32B(size);
|
||||
curr = prev = ARInfo;
|
||||
while (curr->next != 0) {
|
||||
if (curr->flag == 0 && curr->size >= size) {
|
||||
break;
|
||||
}
|
||||
var_r27 = var_r31;
|
||||
var_r31 = var_r31->unk0C;
|
||||
prev = curr;
|
||||
curr = curr->next;
|
||||
}
|
||||
if (var_r31->unk0C == 0) {
|
||||
OSReport("Can't ARAM Allocated %x\n", arg0);
|
||||
if (curr->next == 0) {
|
||||
OSReport("Can't ARAM Allocated %x\n", size);
|
||||
HuAMemDump();
|
||||
return 0;
|
||||
}
|
||||
var_r31->unk00 = 1;
|
||||
if (var_r31->unk08 == arg0 && var_r27 != var_r31) {
|
||||
var_r31->unk02 = 0xFFFF;
|
||||
curr->flag = 1;
|
||||
if (curr->size == size && prev != curr) {
|
||||
curr->dir = 0xFFFF;
|
||||
} else {
|
||||
var_r30 = &ARInfo[1];
|
||||
for (i = 0; i < 63; i++, var_r30++) {
|
||||
if (var_r30->unk04 == 0) {
|
||||
next = &ARInfo[1];
|
||||
for (i = 0; i < 63; i++, next++) {
|
||||
if (!next->amemptr) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (i == 63) {
|
||||
OSReport("Can't ARAM Allocated %x\n", arg0);
|
||||
OSReport("Can't ARAM Allocated %x\n", size);
|
||||
return 0;
|
||||
}
|
||||
var_r30->unk0C = var_r31->unk0C;
|
||||
var_r31->unk0C = var_r30;
|
||||
var_r30->unk08 = var_r31->unk08 - arg0;
|
||||
var_r30->unk04 = (u8*) var_r31->unk04 + arg0;
|
||||
var_r31->unk08 = arg0;
|
||||
var_r31->unk02 = var_r30->unk02 = 0xFFFF;
|
||||
var_r30->unk00 = 0;
|
||||
next->next = curr->next;
|
||||
curr->next = next;
|
||||
next->size = curr->size - size;
|
||||
next->amemptr = curr->amemptr + size;
|
||||
curr->size = size;
|
||||
curr->dir = next->dir = 0xFFFF;
|
||||
next->flag = 0;
|
||||
}
|
||||
return var_r31->unk04;
|
||||
return curr->amemptr;
|
||||
}
|
||||
|
||||
void HuARFree(void *arg0) {
|
||||
SomeArmemStruct0 *var_r30;
|
||||
SomeArmemStruct0 *temp_r29;
|
||||
SomeArmemStruct0 *var_r31;
|
||||
void HuARFree(u32 amemptr) {
|
||||
ARMemBlock *prev;
|
||||
ARMemBlock *next;
|
||||
ARMemBlock *curr;
|
||||
|
||||
var_r31 = var_r30 = ARInfo;
|
||||
while (var_r31->unk0C != 0) {
|
||||
if (var_r31->unk04 == arg0) {
|
||||
curr = prev = ARInfo;
|
||||
while (curr->next) {
|
||||
if (curr->amemptr == amemptr) {
|
||||
break;
|
||||
}
|
||||
var_r30 = var_r31;
|
||||
var_r31 = var_r31->unk0C;
|
||||
prev = curr;
|
||||
curr = curr->next;
|
||||
}
|
||||
if (var_r31->unk00 != 0) {
|
||||
if (var_r31->unk0C == 0 && var_r31->unk04 != arg0) {
|
||||
OSReport("Can't ARAM Free %x\n", arg0);
|
||||
if (curr->flag != 0) {
|
||||
if (!curr->next && curr->amemptr != amemptr) {
|
||||
OSReport("Can't ARAM Free %x\n", amemptr);
|
||||
return;
|
||||
}
|
||||
temp_r29 = var_r31->unk0C;
|
||||
if (temp_r29->unk0C != 0 && temp_r29->unk00 == 0) {
|
||||
if (var_r31->unk04 > temp_r29->unk04) {
|
||||
var_r31->unk04 = temp_r29->unk04;
|
||||
next = curr->next;
|
||||
if (next->next && next->flag == 0) {
|
||||
if (curr->amemptr > next->amemptr) {
|
||||
curr->amemptr = next->amemptr;
|
||||
}
|
||||
var_r31->unk08 += temp_r29->unk08;
|
||||
var_r31->unk0C = temp_r29->unk0C;
|
||||
temp_r29->unk04 = 0;
|
||||
curr->size += next->size;
|
||||
curr->next = next->next;
|
||||
next->amemptr = 0;
|
||||
}
|
||||
if (var_r30 != var_r31 && var_r30->unk0C != 0 && var_r30->unk00 == 0) {
|
||||
if (var_r30->unk04 > var_r31->unk04) {
|
||||
var_r30->unk04 = var_r31->unk04;
|
||||
if (prev != curr && prev->next != 0 && prev->flag == 0) {
|
||||
if (prev->amemptr > curr->amemptr) {
|
||||
prev->amemptr = curr->amemptr;
|
||||
}
|
||||
var_r30->unk08 += var_r31->unk08;
|
||||
var_r30->unk0C = var_r31->unk0C;
|
||||
var_r31->unk04 = 0;
|
||||
prev->size += curr->size;
|
||||
prev->next = curr->next;
|
||||
curr->amemptr = 0;
|
||||
}
|
||||
var_r31->unk00 = 0;
|
||||
var_r31->unk02 = 0xFFFF;
|
||||
curr->flag = 0;
|
||||
curr->dir = 0xFFFF;
|
||||
}
|
||||
}
|
||||
|
||||
static char lbl_80130705[] = "Can't Find ARAM %x\n";
|
||||
static u32 HuARSizeGet(u32 amemptr) {
|
||||
ARMemBlock *curr;
|
||||
ARMemBlock *prev;
|
||||
|
||||
static inline SomeArmemStruct0 *ArmemInlineFunc1(void *arg0) {
|
||||
SomeArmemStruct0 *temp_var1;
|
||||
SomeArmemStruct0 *temp_var2;
|
||||
|
||||
temp_var1 = temp_var2 = ARInfo;
|
||||
while (temp_var1->unk0C != 0) {
|
||||
if (temp_var1->unk04 == arg0) {
|
||||
curr = prev = ARInfo;
|
||||
while (curr->next != 0) {
|
||||
if (curr->amemptr == amemptr) {
|
||||
break;
|
||||
}
|
||||
temp_var2 = temp_var1;
|
||||
temp_var1 = temp_var1->unk0C;
|
||||
prev = curr;
|
||||
curr = curr->next;
|
||||
}
|
||||
if (temp_var1->unk0C == 0 && temp_var1->unk04 != arg0) {
|
||||
OSReport(lbl_80130705, arg0);
|
||||
return NULL;
|
||||
} else {
|
||||
return temp_var1;
|
||||
}
|
||||
}
|
||||
|
||||
static inline u32 ArmemInlineFunc2(void *arg0) {
|
||||
SomeArmemStruct0 *temp_var1;
|
||||
SomeArmemStruct0 *temp_var2;
|
||||
|
||||
temp_var1 = temp_var2 = ARInfo;
|
||||
while (temp_var1->unk0C != 0) {
|
||||
if (temp_var1->unk04 == arg0) {
|
||||
break;
|
||||
}
|
||||
temp_var2 = temp_var1;
|
||||
temp_var1 = temp_var1->unk0C;
|
||||
}
|
||||
if (temp_var1->unk0C == 0 && temp_var1->unk04 != arg0) {
|
||||
OSReport(lbl_80130705, arg0);
|
||||
if (curr->next == 0 && curr->amemptr != amemptr) {
|
||||
OSReport("Can't Find ARAM %x\n", amemptr);
|
||||
return 0;
|
||||
} else {
|
||||
return temp_var1->unk08;
|
||||
return curr->size;
|
||||
}
|
||||
}
|
||||
|
||||
static ARMemBlock *HuARInfoGet(u32 amemptr) {
|
||||
ARMemBlock *curr;
|
||||
ARMemBlock *prev;
|
||||
|
||||
curr = prev = ARInfo;
|
||||
while (curr->next != 0) {
|
||||
if (curr->amemptr == amemptr) {
|
||||
break;
|
||||
}
|
||||
prev = curr;
|
||||
curr = curr->next;
|
||||
}
|
||||
if (curr->next == 0 && curr->amemptr != amemptr) {
|
||||
OSReport("Can't Find ARAM %x\n", amemptr);
|
||||
return NULL;
|
||||
} else {
|
||||
return curr;
|
||||
}
|
||||
}
|
||||
|
||||
void HuAMemDump(void) {
|
||||
SomeArmemStruct0 *var_r31;
|
||||
ARMemBlock *curr;
|
||||
|
||||
OSReport("ARAM DUMP ======================\n");
|
||||
OSReport("AMemPtr Stat Length\n");
|
||||
for (var_r31 = ARInfo; var_r31->unk0C != 0; var_r31 = var_r31->unk0C) {
|
||||
OSReport("%08x:%04x,%08x,%08x\n", var_r31->unk04, var_r31->unk00, var_r31->unk08, var_r31->unk02);
|
||||
for (curr = ARInfo; curr->next; curr = curr->next) {
|
||||
OSReport("%08x:%04x,%08x,%08x\n", curr->amemptr, curr->flag, curr->size, curr->dir);
|
||||
}
|
||||
OSReport("%08x:%04x,%08x\n", var_r31->unk04, var_r31->unk00, var_r31->unk08);
|
||||
OSReport("%08x:%04x,%08x\n", curr->amemptr, curr->flag, curr->size);
|
||||
OSReport("================================\n");
|
||||
}
|
||||
|
||||
void *HuAR_DVDtoARAM(u32 arg0) {
|
||||
DataReadStat *temp_r28;
|
||||
SomeArmemStruct0 *var_r27;
|
||||
void *temp_r3;
|
||||
u32 HuAR_DVDtoARAM(u32 dir) {
|
||||
DataReadStat *stat;
|
||||
ARMemBlock *block;
|
||||
u32 amemptr;
|
||||
|
||||
temp_r3 = HuARDirCheck(arg0);
|
||||
if (temp_r3 != 0) {
|
||||
return temp_r3;
|
||||
amemptr = HuARDirCheck(dir);
|
||||
if (amemptr) {
|
||||
return amemptr;
|
||||
}
|
||||
temp_r28 = HuDataDirRead(arg0);
|
||||
DirDataSize = (DirDataSize + 0x1F) & ~0x1F;
|
||||
temp_r3 = HuARMalloc(DirDataSize);
|
||||
if (temp_r3 == 0) {
|
||||
stat = HuDataDirRead(dir);
|
||||
DirDataSize = OSRoundUp32B(DirDataSize);
|
||||
amemptr = HuARMalloc(DirDataSize);
|
||||
if (!amemptr) {
|
||||
return 0;
|
||||
}
|
||||
var_r27 = ArmemInlineFunc1(temp_r3);
|
||||
var_r27->unk02 = (arg0 >> 16);
|
||||
block = HuARInfoGet(amemptr);
|
||||
block->dir = (dir >> 16);
|
||||
arqCnt++;
|
||||
ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32) temp_r28->dir, (u32) temp_r3, DirDataSize, ArqCallBack);
|
||||
OSReport("ARAM Trans %x\n", temp_r3);
|
||||
ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32) stat->dir, amemptr, DirDataSize, ArqCallBack);
|
||||
OSReport("ARAM Trans %x\n", amemptr);
|
||||
while (HuARDMACheck());
|
||||
HuDataDirClose(arg0);
|
||||
return temp_r3;
|
||||
HuDataDirClose(dir);
|
||||
return amemptr;
|
||||
}
|
||||
|
||||
static void ArqCallBack(u32 pointerToARQRequest) {
|
||||
|
|
@ -224,151 +221,151 @@ static void ArqCallBack(u32 pointerToARQRequest) {
|
|||
(void)pointerToARQRequest; // required to match (return?)
|
||||
}
|
||||
|
||||
void HuAR_MRAMtoARAM(s32 arg0) {
|
||||
HuAR_MRAMtoARAM2(HuDataGetDirPtr(arg0));
|
||||
u32 HuAR_MRAMtoARAM(s32 dir) {
|
||||
return HuAR_MRAMtoARAM2(HuDataGetDirPtr(dir));
|
||||
}
|
||||
|
||||
void *HuAR_MRAMtoARAM2(void *arg0) {
|
||||
SomeArmemStruct0 *var_r27;
|
||||
DataReadStat *temp_r3_3;
|
||||
u32 temp_r28;
|
||||
void *temp_r3;
|
||||
u32 HuAR_MRAMtoARAM2(void *dir_ptr) {
|
||||
ARMemBlock *block;
|
||||
DataReadStat *status;
|
||||
u32 size;
|
||||
u32 amemptr;
|
||||
|
||||
temp_r3_3 = HuDataGetStatus(arg0);
|
||||
temp_r3 = HuARDirCheck(temp_r3_3->dir_id << 16);
|
||||
if (temp_r3 != 0) {
|
||||
return temp_r3;
|
||||
status = HuDataGetStatus(dir_ptr);
|
||||
amemptr = HuARDirCheck(status->dir_id << 16);
|
||||
if (amemptr) {
|
||||
return amemptr;
|
||||
}
|
||||
temp_r28 = HuMemMemorySizeGet(arg0);
|
||||
temp_r28 = (temp_r28 + 0x1F) & ~0x1F;
|
||||
temp_r3 = HuARMalloc(temp_r28);
|
||||
if (temp_r3 == 0) {
|
||||
size = HuMemMemorySizeGet(dir_ptr);
|
||||
size = OSRoundUp32B(size);
|
||||
amemptr = HuARMalloc(size);
|
||||
if (!amemptr) {
|
||||
return 0;
|
||||
}
|
||||
var_r27 = ArmemInlineFunc1(temp_r3);
|
||||
var_r27->unk02 = temp_r3_3->dir_id;
|
||||
block = HuARInfoGet(amemptr);
|
||||
block->dir = status->dir_id;
|
||||
arqCnt++;
|
||||
ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32) arg0, (u32) temp_r3, temp_r28, ArqCallBack);
|
||||
return temp_r3;
|
||||
ARQPostRequest(&arqReq, 0x1234, 0, 0, (u32)dir_ptr, amemptr, size, ArqCallBack);
|
||||
return amemptr;
|
||||
}
|
||||
|
||||
void HuAR_ARAMtoMRAM(void *dst) {
|
||||
HuAR_ARAMtoMRAMNum(dst, 0);
|
||||
void HuAR_ARAMtoMRAM(u32 src) {
|
||||
HuAR_ARAMtoMRAMNum(src, 0);
|
||||
}
|
||||
|
||||
void *HuAR_ARAMtoMRAMNum(void *dst, s32 num) {
|
||||
SomeArmemStruct0 *var_r25;
|
||||
s32 var_r26;
|
||||
void *temp_r3;
|
||||
void *HuAR_ARAMtoMRAMNum(u32 src, s32 num) {
|
||||
ARMemBlock *block;
|
||||
s32 size;
|
||||
void *dst;
|
||||
|
||||
var_r25 = ArmemInlineFunc1(dst);
|
||||
if (HuDataReadChk(var_r25->unk02 << 16) >= 0) {
|
||||
block = HuARInfoGet(src);
|
||||
if (HuDataReadChk(block->dir << 16) >= 0) {
|
||||
return;
|
||||
}
|
||||
var_r26 = ArmemInlineFunc2(dst);
|
||||
temp_r3 = HuMemDirectMallocNum(HEAP_DVD, var_r26, num);
|
||||
if (temp_r3 == 0) {
|
||||
size = HuARSizeGet(src);
|
||||
dst = HuMemDirectMallocNum(HEAP_DVD, size, num);
|
||||
if (!dst) {
|
||||
return 0;
|
||||
}
|
||||
DCFlushRangeNoSync(temp_r3, var_r26);
|
||||
ARQueBuf[arqIdx].unk20 = (var_r25->unk02 << 16);
|
||||
ARQueBuf[arqIdx].unk24 = temp_r3;
|
||||
DCFlushRangeNoSync(dst, size);
|
||||
ARQueBuf[arqIdx].dir = (block->dir << 16);
|
||||
ARQueBuf[arqIdx].dst = dst;
|
||||
arqCnt++;
|
||||
PPCSync();
|
||||
ARQPostRequest(&ARQueBuf[arqIdx].unk00, 0x1234, 1, 0, (u32) dst, (u32) temp_r3, var_r26, ArqCallBackAM);
|
||||
ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, src, (u32) dst, size, ArqCallBackAM);
|
||||
arqIdx++;
|
||||
arqIdx &= 0xF;
|
||||
return temp_r3;
|
||||
return dst;
|
||||
}
|
||||
|
||||
static void ArqCallBackAM(u32 pointerToARQRequest) {
|
||||
SomeArmemStruct1 *sp8 = (SomeArmemStruct1*) pointerToARQRequest;
|
||||
ARQueReq *req_ptr = (ARQueReq*) pointerToARQRequest;
|
||||
|
||||
arqCnt--;
|
||||
HuDataDirSet(sp8->unk24, sp8->unk20);
|
||||
HuDataDirSet(req_ptr->dst, req_ptr->dir);
|
||||
}
|
||||
|
||||
BOOL HuARDMACheck(void) {
|
||||
s32 HuARDMACheck(void) {
|
||||
return arqCnt;
|
||||
}
|
||||
|
||||
void *HuARDirCheck(u32 dir) {
|
||||
SomeArmemStruct0 *var_r31;
|
||||
u32 HuARDirCheck(u32 dir) {
|
||||
ARMemBlock *curr;
|
||||
|
||||
var_r31 = ARInfo;
|
||||
curr = ARInfo;
|
||||
dir >>= 16;
|
||||
while (var_r31->unk0C != 0) {
|
||||
if (var_r31->unk00 == 1 && var_r31->unk02 == dir) {
|
||||
return var_r31->unk04;
|
||||
while (curr->next != 0) {
|
||||
if (curr->flag == 1 && curr->dir == dir) {
|
||||
return curr->amemptr;
|
||||
}
|
||||
var_r31 = var_r31->unk0C;
|
||||
curr = curr->next;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void HuARDirFree(u32 arg0) {
|
||||
SomeArmemStruct0 *var_r31;
|
||||
void HuARDirFree(u32 dir) {
|
||||
ARMemBlock *curr;
|
||||
|
||||
var_r31 = ARInfo;
|
||||
arg0 >>= 16;
|
||||
while (var_r31->unk0C != 0) {
|
||||
if (var_r31->unk02 == arg0) {
|
||||
HuARFree(var_r31->unk04);
|
||||
curr = ARInfo;
|
||||
dir >>= 16;
|
||||
while (curr->next != 0) {
|
||||
if (curr->dir == dir) {
|
||||
HuARFree(curr->amemptr);
|
||||
break;
|
||||
}
|
||||
var_r31 = var_r31->unk0C;
|
||||
curr = curr->next;
|
||||
}
|
||||
}
|
||||
|
||||
void *HuAR_ARAMtoMRAMFileRead(u32 arg0, u32 arg1, HeapID arg2) {
|
||||
s32 *temp_r29;
|
||||
void *temp_r3;
|
||||
void *temp_r3_2;
|
||||
void *var_r20;
|
||||
s32 temp_r24;
|
||||
s32 var_r22;
|
||||
u8 *var_r17;
|
||||
void *HuAR_ARAMtoMRAMFileRead(u32 dir, u32 num, HeapID heap) {
|
||||
s32 *dir_data;
|
||||
void *dst;
|
||||
void *dvd_data;
|
||||
u32 amem_src;
|
||||
s32 count;
|
||||
s32 size;
|
||||
u32 amemptr;
|
||||
|
||||
if ((var_r17 = HuARDirCheck(arg0)) == 0) {
|
||||
OSReport("Error: data none on ARAM %0x\n", arg0);
|
||||
if ((amemptr = HuARDirCheck(dir)) == 0) {
|
||||
OSReport("Error: data none on ARAM %0x\n", dir);
|
||||
HuAMemDump();
|
||||
return 0;
|
||||
}
|
||||
DCInvalidateRange(&preLoadBuf, sizeof(preLoadBuf));
|
||||
var_r20 = var_r17 + ((u32) (((u16) arg0 + 1) * 4) & 0xFFFFFFFE0);
|
||||
amem_src = amemptr + (u32)((u32)(((u16)dir + 1) * 4) & 0xFFFFFFFE0);
|
||||
arqCnt++;
|
||||
ARQPostRequest(&ARQueBuf[arqIdx].unk00, 0x1234, 1, 0, (u32) var_r20, (u32) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
|
||||
ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (u32) &preLoadBuf, sizeof(preLoadBuf), ArqCallBackAMFileRead);
|
||||
arqIdx++;
|
||||
arqIdx &= 0xF;
|
||||
while (HuARDMACheck());
|
||||
temp_r29 = &preLoadBuf[(arg0 + 1) & 7];
|
||||
temp_r24 = temp_r29[0];
|
||||
var_r20 = var_r17 + (temp_r24 & 0xFFFFFFFE0);
|
||||
if (temp_r29[1] - temp_r24 < 0) {
|
||||
var_r22 = (ArmemInlineFunc2(var_r17) - temp_r24 + 0x3F) & 0xFFFFFFFE0;
|
||||
dir_data = &preLoadBuf[(dir + 1) & 7];
|
||||
count = dir_data[0];
|
||||
amem_src = amemptr + (u32)(count & 0xFFFFFFFE0);
|
||||
if (dir_data[1] - count < 0) {
|
||||
size = (HuARSizeGet(amemptr) - count + 0x3F) & 0xFFFFFFFE0;
|
||||
} else {
|
||||
var_r22 = (temp_r29[1] - temp_r24 + 0x3F) & 0xFFFFFFFE0;
|
||||
size = (dir_data[1] - count + 0x3F) & 0xFFFFFFFE0;
|
||||
}
|
||||
temp_r3_2 = HuMemDirectMalloc(HEAP_DVD, var_r22);
|
||||
if (temp_r3_2 == 0) {
|
||||
dvd_data = HuMemDirectMalloc(HEAP_DVD, size);
|
||||
if (!dvd_data) {
|
||||
return 0;
|
||||
}
|
||||
DCFlushRangeNoSync(temp_r3_2, var_r22);
|
||||
DCFlushRangeNoSync(dvd_data, size);
|
||||
arqCnt++;
|
||||
PPCSync();
|
||||
ARQPostRequest(&ARQueBuf[arqIdx].unk00, 0x1234, 1, 0, (u32) var_r20, (u32) temp_r3_2, (u32) var_r22, ArqCallBackAMFileRead);
|
||||
ARQPostRequest(&ARQueBuf[arqIdx].req, 0x1234, 1, 0, amem_src, (u32) dvd_data, (u32) size, ArqCallBackAMFileRead);
|
||||
arqIdx++;
|
||||
arqIdx &= 0xF;
|
||||
while (HuARDMACheck());
|
||||
temp_r29 = (s32*) ((u8*) temp_r3_2 + (temp_r24 & 0x1F));
|
||||
temp_r3 = HuMemDirectMallocNum(arg2, (temp_r29[0] + 1) & ~1, arg1);
|
||||
if (temp_r3 == 0) {
|
||||
dir_data = (s32*) ((u8*) dvd_data + (count & 0x1F));
|
||||
dst = HuMemDirectMallocNum(heap, (dir_data[0] + 1) & ~1, num);
|
||||
if (!dst) {
|
||||
return 0;
|
||||
}
|
||||
HuDecodeData(&temp_r29[2], temp_r3, temp_r29[0], temp_r29[1]);
|
||||
HuMemDirectFree(temp_r3_2);
|
||||
return temp_r3;
|
||||
HuDecodeData(&dir_data[2], dst, dir_data[0], dir_data[1]);
|
||||
HuMemDirectFree(dvd_data);
|
||||
return dst;
|
||||
}
|
||||
|
||||
static void ArqCallBackAMFileRead(u32 pointerToARQRequest) {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#include "common.h"
|
||||
#include "game/data.h"
|
||||
#include "game/armem.h"
|
||||
#include "dolphin/dvd.h"
|
||||
|
||||
#define PTR_OFFSET(ptr, offset) (void *)(((u8 *)(ptr)+(u32)(offset)))
|
||||
|
|
@ -108,7 +109,7 @@ DataReadStat *HuDataDirRead(s32 data_num)
|
|||
}
|
||||
|
||||
if((status = HuDataReadChk(data_num)) < 0) {
|
||||
void *dir_aram;
|
||||
u32 dir_aram;
|
||||
if(dir_aram = HuARDirCheck(data_num)) {
|
||||
HuAR_ARAMtoMRAM(dir_aram);
|
||||
while(HuARDMACheck());
|
||||
|
|
@ -144,7 +145,7 @@ DataReadStat *HuDataDirReadNum(s32 data_num, s32 num)
|
|||
}
|
||||
|
||||
if((status = HuDataReadChk(data_num)) < 0) {
|
||||
void *dir_aram;
|
||||
u32 dir_aram;
|
||||
if((dir_aram = HuARDirCheck(data_num))) {
|
||||
OSReport("ARAM data num %x\n", data_num);
|
||||
HuAR_ARAMtoMRAMNum(dir_aram, num);
|
||||
|
|
@ -220,7 +221,7 @@ s32 HuDataDirReadAsync(s32 data_num)
|
|||
return -1;
|
||||
}
|
||||
if((status = HuDataReadChk(data_num)) < 0) {
|
||||
void *dir_aram;
|
||||
u32 dir_aram;
|
||||
if(dir_aram = HuARDirCheck(data_num)) {
|
||||
OSReport("ARAM data num %x\n", data_num);
|
||||
HuAR_ARAMtoMRAM(dir_aram);
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ static s16 winMaxHeight;
|
|||
static u8 mesWInsert[8];
|
||||
static u8 winTabSize;
|
||||
static u8 winInsertF;
|
||||
static void *winAMemP;
|
||||
static u32 winAMemP;
|
||||
static u8 *fontWidthP;
|
||||
static s32 cancelCRF;
|
||||
static s16 mesCharCnt;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue