Match `xlFileGCN.c and xlObject.c` (#51)

* start xlFileGCN.c

* xlFileGCN: progress

* improved xlList

* progress

* progress?

* progress

* xlFileGCN: ok

* format

* progress?

* xlObjectEvent ok, progress on xlObjectMake

* remove unused files

* review + xlObjectMake ok

* Delete xlObjectMake.s

include/xlFileGCN.h

@@ -3,11 +3,15 @@
 
 #include "dolphin.h"
 
-typedef enum __anon_0x2757 {
+typedef s32 (*DVDOpenCallback)(char*, DVDFileInfo*);
+typedef s32 (*DVDReadCallback)(DVDFileInfo*, void*, s32, s32, DVDCallback);
+
+// __anon_0x2757
+typedef enum XlFileType {
     XLFT_NONE = -1,
     XLFT_TEXT = 0,
     XLFT_BINARY = 1,
-} __anon_0x2757;
+} XlFileType;
 
 typedef struct tXL_FILE {
     /* 0x00 */ s32 iBuffer;
@@ -16,19 +20,17 @@ typedef struct tXL_FILE {
     /* 0x0C */ s32 nAttributes;
     /* 0x10 */ s32 nSize;
     /* 0x14 */ s32 nOffset;
-    /* 0x18 */ __anon_0x2757 eType;
+    /* 0x18 */ XlFileType eType;
     /* 0x1C */ DVDFileInfo info;
 } tXL_FILE; // size = 0x58
 
-s32 xlFileEvent(tXL_FILE* pFile, s32 nEvent);
-s32 xlFileSetPosition(tXL_FILE* pFile, s32 nOffset);
-s32 xlFileGet(tXL_FILE* pFile, void* pTarget, s32 nSizeBytes);
-s32 xlFileClose(tXL_FILE** ppFile);
-s32 xlFileOpen(tXL_FILE** ppFile, __anon_0x2757 eType, char* szFileName);
+s32 xlFileSetOpen(DVDOpenCallback pfOpen);
+s32 xlFileSetRead(DVDReadCallback pfRead);
 s32 xlFileGetSize(s32* pnSize, char* szFileName);
-s32 xlFileSetRead(s32 (*pfRead)(DVDFileInfo* /* unknown0 */, void* /* unknown1 */, s32 /* unknown2 */,
-                                s32 /* unknown3 */,
-                                void (* /* unknown4 */)(s32 /* unknown0 */, DVDFileInfo* /* unknown1 */)));
-s32 xlFileSetOpen(s32 (*pfOpen)(char* /* unknown0 */, DVDFileInfo* /* unknown1 */));
+s32 xlFileOpen(tXL_FILE** ppFile, XlFileType eType, char* szFileName);
+s32 xlFileClose(tXL_FILE** ppFile);
+s32 xlFileGet(tXL_FILE* pFile, void* pTarget, s32 nSizeBytes);
+s32 xlFileSetPosition(tXL_FILE* pFile, s32 nOffset);
+s32 xlFileEvent(tXL_FILE* pFile, s32 nEvent, void* pArgument);
 
 #endif

include/xlObject.h

@@ -14,6 +14,11 @@ struct _XL_OBJECTTYPE {
     /* 0xC */ EventFunc pfEvent;
 }; // size: 0x10
 
+typedef struct __anon_0x5062 {
+    /* 0x0 */ struct tXL_LIST* pList;
+    /* 0x4 */ _XL_OBJECTTYPE* pType;
+} __anon_0x5062; // size = 0x8
+
 s32 xlObjectReset(void);
 s32 xlObjectSetup(void);
 s32 xlObjectEvent(void* pObject, s32 nEvent, void* pArgument);

obj_files.mk

@@ -3,10 +3,10 @@
 O_FILES :=                                  \
     $(BUILD_DIR)/src/xlCoreGCN.o            \
     $(BUILD_DIR)/src/xlPostGCN.o            \
-    $(BUILD_DIR)/asm/xlFileGCN.o            \
+    $(BUILD_DIR)/src/xlFileGCN.o            \
     $(BUILD_DIR)/src/xlList.o               \
     $(BUILD_DIR)/src/xlHeap.o               \
-    $(BUILD_DIR)/asm/xlObject.o             \
+    $(BUILD_DIR)/src/xlObject.o             \
     $(BUILD_DIR)/src/simGCN.o               \
     $(BUILD_DIR)/src/movie.o                \
     $(BUILD_DIR)/src/THPPlayer.o            \

src/xlFileGCN.c

@@ -0,0 +1,150 @@
+#include "xlFileGCN.h"
+#include "dolphin.h"
+#include "xlHeap.h"
+#include "xlObject.h"
+
+_XL_OBJECTTYPE gTypeFile = {
+    "FILE",
+    sizeof(tXL_FILE),
+    NULL,
+    (EventFunc)xlFileEvent,
+};
+
+static DVDOpenCallback gpfOpen;
+static DVDReadCallback gpfRead;
+
+s32 xlFileSetOpen(DVDOpenCallback pfOpen) {
+    gpfOpen = pfOpen;
+    return 1;
+}
+
+s32 xlFileSetRead(DVDReadCallback pfRead) {
+    gpfRead = pfRead;
+    return 1;
+}
+
+s32 xlFileGetSize(s32* pnSize, char* szFileName) {
+    tXL_FILE* pFile;
+
+    if (xlFileOpen(&pFile, XLFT_BINARY, szFileName)) {
+        if (pnSize != NULL) {
+            *pnSize = pFile->nSize;
+        }
+
+        if (!xlFileClose(&pFile)) {
+            return 0;
+        }
+
+        return 1;
+    }
+
+    return 0;
+}
+
+inline s32 xlFileGetFile(tXL_FILE** ppFile, char* szFileName) {
+    if (gpfOpen != NULL) {
+        return gpfOpen(szFileName, &(*ppFile)->info);
+    } else {
+        return DVDOpen(szFileName, &(*ppFile)->info);
+    }
+}
+
+s32 xlFileOpen(tXL_FILE** ppFile, XlFileType eType, char* szFileName) {
+    if (!xlObjectMake(ppFile, NULL, &gTypeFile)) {
+        return 0;
+    }
+
+    if (xlFileGetFile(ppFile, szFileName)) {
+        (*ppFile)->eType = eType;
+        (*ppFile)->nSize = (*ppFile)->info.length;
+        (*ppFile)->pData = &(*ppFile)->info;
+
+        return 1;
+    }
+
+    xlObjectFree(ppFile);
+    return 0;
+}
+
+s32 xlFileClose(tXL_FILE** ppFile) {
+    if (!xlObjectFree(ppFile)) {
+        return 0;
+    }
+
+    return 1;
+}
+
+s32 xlFileGet(tXL_FILE* pFile, void* pTarget, s32 nSizeBytes) {
+    s32 nOffset;
+    s32 nOffsetExtra;
+    s32 nSize;
+    s32 nSizeUsed;
+
+    nOffset = pFile->nOffset;
+    nSize = pFile->nSize;
+    if (nOffset + nSizeBytes > nSize) {
+        nSizeBytes = nSize - nOffset;
+    }
+    if (nSizeBytes == 0) {
+        *(s8*)pTarget = 0xFF;
+        return 0;
+    }
+
+    while (nSizeBytes != 0) {
+        nSizeUsed = nSizeBytes;
+        if (nSizeUsed > 0x1000) {
+            nSizeUsed = 0x1000;
+        }
+        nOffset = pFile->nOffset & 0xFFFFFFFC;
+        nOffsetExtra = pFile->nOffset & 0x3;
+        nSize = (nSizeUsed + nOffsetExtra + 0x1F) & 0xFFFFFFE0;
+        if (gpfRead != NULL) {
+            gpfRead(pFile->pData, pFile->pBuffer, nSize, nOffset, NULL);
+        } else {
+            DVDReadPrio(pFile->pData, pFile->pBuffer, nSize, nOffset, 2);
+        }
+        if (!xlHeapCopy(pTarget, (void*)((u8*)pFile->pBuffer + nOffsetExtra), nSizeUsed)) {
+            return 0;
+        }
+        pTarget = (void*)((s32)pTarget + nSizeUsed);
+        nSizeBytes -= nSizeUsed;
+        pFile->nOffset += nSizeUsed;
+    }
+    return 1;
+}
+
+s32 xlFileSetPosition(tXL_FILE* pFile, s32 nOffset) {
+    if ((nOffset >= 0) && (nOffset < pFile->nSize)) {
+        pFile->nOffset = nOffset;
+        return 1;
+    }
+
+    return 0;
+}
+
+s32 xlFileEvent(tXL_FILE* pFile, s32 nEvent, void* pArgument) {
+    switch (nEvent) {
+        case 2:
+            pFile->nSize = 0;
+            pFile->nOffset = 0;
+            pFile->pData = NULL;
+            if (!xlHeapTake(&pFile->pBuffer, 0x1024 | 0x30000000)) {
+                return 0;
+            }
+            break;
+        case 3:
+            DVDClose(&pFile->info);
+            if (!xlHeapFree(&pFile->pBuffer)) {
+                return 0;
+            }
+            break;
+        case 0:
+        case 1:
+        case 4:
+            break;
+        default:
+            return 0;
+    }
+
+    return 1;
+}

src/xlObject.c

@@ -0,0 +1,148 @@
+#include "xlObject.h"
+#include "xlList.h"
+
+static tXL_LIST* gpListData;
+
+inline s32 xlObjectFindData(__anon_0x5062** ppData, _XL_OBJECTTYPE* pType) {
+    tXL_NODE* pListNode;
+
+    for (pListNode = (tXL_NODE*)gpListData->pNodeHead; pListNode != NULL; pListNode = pListNode->next) {
+        *ppData = (__anon_0x5062*)pListNode->data;
+        if ((*ppData)->pType == pType) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+inline s32 xlObjectMakeData(__anon_0x5062** ppData, _XL_OBJECTTYPE* pType) {
+    if (!xlListMakeItem(gpListData, ppData)) {
+        return 0;
+    }
+
+    (*ppData)->pType = pType;
+
+    if (!xlListMake((tXL_LIST**)*ppData, pType->nSizeObject + 4)) {
+        return 0;
+    }
+
+    return 1;
+}
+
+s32 xlObjectMake(void** ppObject, void* pArgument, _XL_OBJECTTYPE* pType) {
+    s32 bFlag;
+    __anon_0x5062* pData;
+    tXL_NODE* temp1;
+    tXL_NODE* temp2;
+
+    if (!xlObjectFindData(&pData, pType)) {
+        if (!xlObjectMakeData(&pData, pType)) {
+            return 0;
+        }
+        bFlag = 1;
+    } else {
+        bFlag = 0;
+    }
+
+    if (!xlListMakeItem(pData->pList, ppObject)) {
+        return 0;
+    }
+
+    temp1 = (tXL_NODE*)*ppObject;
+    temp2 = (tXL_NODE*)pData;
+    *ppObject = &temp1->data;
+    temp1->next = temp2;
+
+    if (bFlag != 0) {
+        pType->pfEvent(*ppObject, 0, NULL);
+    }
+
+    return pType->pfEvent(*ppObject, 2, pArgument);
+}
+
+s32 xlObjectFree(void** ppObject) {
+    if (ppObject != NULL && *ppObject != NULL) {
+        __anon_0x5062* pData = *(__anon_0x5062**)((u8*)*ppObject - 4);
+
+        pData->pType->pfEvent(*ppObject, 3, NULL);
+        *ppObject = (void*)((u8*)*ppObject - 4);
+
+        if (xlListFreeItem(pData->pList, ppObject) == 0) {
+            return 0;
+        }
+
+        *ppObject = NULL;
+        return 1;
+    }
+
+    return 0;
+}
+
+s32 xlObjectTest(void* pObject, _XL_OBJECTTYPE* pType) {
+    __anon_0x5062* pData;
+
+    if (pObject != NULL) {
+        pData = *(__anon_0x5062**)((u8*)pObject - 4);
+
+        if (xlListTestItem(gpListData, pData) && pData->pType == pType) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+inline s32 xlObjectFindType(void* pObject, _XL_OBJECTTYPE* pType) {
+    if (pObject != NULL) {
+        __anon_0x5062* pData = *(__anon_0x5062**)((u8*)pObject - 4);
+        if (xlListTestItem(gpListData, pData)) {
+            if (pData->pType == pType) {
+                return 1;
+            }
+        }
+    }
+
+    return 0;
+}
+
+s32 xlObjectEvent(void* pObject, s32 nEvent, void* pArgument) {
+    if (pObject != NULL) {
+        __anon_0x5062* pData = *(__anon_0x5062**)((u8*)pObject - 4);
+
+        if (xlListTestItem(gpListData, pData)) {
+            if (xlObjectFindType(pObject, pData->pType)) {
+                return pData->pType->pfEvent(pObject, nEvent, pArgument);
+            }
+        }
+    }
+
+    return 0;
+}
+
+s32 xlObjectSetup(void) {
+    if (!xlListMake(&gpListData, 8)) {
+        return 0;
+    }
+
+    return 1;
+}
+
+s32 xlObjectReset(void) {
+    void* pListNode;
+
+    pListNode = gpListData->pNodeHead;
+
+    while (pListNode != NULL) {
+        if (!xlListFree((void*)((s8*)pListNode + 4))) {
+            return 0;
+        }
+        pListNode = ((tXL_NODE*)pListNode)->next;
+    }
+
+    if (!xlListFree(&gpListData)) {
+        return 0;
+    }
+
+    return 1;
+}