From 2854294009725379c73e121671f7f3b0dadfed67 Mon Sep 17 00:00:00 2001 From: Anghelo Carvajal Date: Fri, 19 Nov 2021 17:34:45 -0300 Subject: [PATCH] `z_jpeg`, `jpegutils` and `jpegdecoder` OK (#322) * this is a disaster * two more * func_800F470C * split and rename jpegutils and jpegdecoder * match jpegutils * match jpegdecoder.c * audio_rodata * data split * Split rsp * Steal documentation from OoT * cleanup * Format * remove removed members in JpegContext * Update include/z64.h Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com> * Update src/code/jpegdecoder.c Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com> * Update include/functions.h Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com> * Apply suggestions from code review Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com> * Update src/code/jpegutils.c Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com> * review renames * true * Some type fixes * Update include/z64.h Co-authored-by: EllipticEllipsis <73679967+EllipticEllipsis@users.noreply.github.com> * add comment * Update src/code/z_jpeg.c Co-authored-by: EllipticEllipsis <73679967+EllipticEllipsis@users.noreply.github.com> * format * bss fix * decr * format * z64jpeg.h * Add stdbool * Rename audio_init_params * whoops * whoops++ * whoops# * remove extra dumb variables in variables.txt * fix Co-authored-by: engineer124 <47598039+engineer124@users.noreply.github.com> Co-authored-by: EllipticEllipsis <73679967+EllipticEllipsis@users.noreply.github.com> --- Makefile | 5 + include/functions.h | 23 +-- include/macros.h | 2 +- include/variables.h | 9 +- include/z64jpeg.h | 99 +++++++++++ spec | 10 +- src/code/code_8010C1B0.c | 2 +- src/code/code_801AA020.c | 9 - src/code/jpegdecoder.c | 193 +++++++++++++++++++++ src/code/jpegutils.c | 156 ++++++++++++++++- src/code/z_jpeg.c | 305 ++++++++++++++++++++++++++++++++- tools/disasm/files.txt | 9 +- tools/disasm/functions.txt | 36 ++-- tools/disasm/variables.txt | 28 +-- tools/sizes/code_functions.csv | 44 ++--- 15 files changed, 809 insertions(+), 121 deletions(-) create mode 100644 include/z64jpeg.h delete mode 100644 src/code/code_801AA020.c create mode 100644 src/code/jpegdecoder.c diff --git a/Makefile b/Makefile index 827f15c77d..a65a8713d2 100644 --- a/Makefile +++ b/Makefile @@ -162,6 +162,11 @@ build/src/code/audio/%.o: OPTFLAGS := -O2 build/src/boot_O2_g3/fault.o: CFLAGS += -trapuv build/src/boot_O2_g3/fault_drawer.o: CFLAGS += -trapuv +build/src/code/jpegutils.o: OPTFLAGS := -O2 +build/src/code/jpegdecoder.o: OPTFLAGS := -O2 +build/src/code/jpegutils.o: CC := $(CC_OLD) +build/src/code/jpegdecoder.o: CC := $(CC_OLD) + build/src/libultra/libc/ll.o: OPTFLAGS := -O1 build/src/libultra/libc/ll.o: MIPS_VERSION := -mips3 -32 build/src/libultra/libc/llcvt.o: OPTFLAGS := -O1 diff --git a/include/functions.h b/include/functions.h index ca04a6c470..f60c0326e7 100644 --- a/include/functions.h +++ b/include/functions.h @@ -1696,11 +1696,7 @@ void FireObj_Update(GlobalContext* globalCtx, FireObj* fire, Actor* actor); void func_800F40A0(GlobalContext* globalCtx, s32 param_2); // void func_800F415C(void); UNK_TYPE func_800F41E4(GlobalContext* globalCtx, ActorContext* actorCtx); -// void func_800F42A0(void); -// void func_800F43BC(void); -// void func_800F44F4(void); -// void func_800F4540(void); -// s32 func_800F470C(UNK_TYPE4 param_1, UNK_TYPE4 param_2, s32 param_3, u32 param_4); + void func_800F4A10(GlobalContext* globalCtx); void func_800F4C0C(GlobalContext* globalCtx); void func_800F4E20(GlobalContext* globalCtx); @@ -2067,7 +2063,7 @@ s32 func_8010BF58(Actor* actor, GlobalContext* globalCtx, s32* param_3, UNK_PTR void Nmi_Init(void); void Nmi_SetPrenmiStart(void); // s32 Nmi_GetPrenmiHasStarted(void); -// void func_8010C1B0(void); +void MsgEvent_SendNullTask(void); f32 OLib_Vec3fDist(Vec3f* a, Vec3f* b); f32 OLib_Vec3fDistOutDiff(Vec3f* a, Vec3f* b, Vec3f* dest); f32 OLib_Vec3fDistXZ(Vec3f* a, Vec3f* b); @@ -3413,10 +3409,12 @@ void func_8018219C(MtxF* pfParm1, Vec3s* psParm2, s32 iParm3); // void func_801822C4(void); void Matrix_InsertRotationAroundUnitVector_f(f32 rotation, Vec3f* vector, s32 appendToState); void Matrix_InsertRotationAroundUnitVector_s(s16 rotation, Vec3f* vector, s32 appendToState); + u64* SysUcode_GetUCodeBoot(void); u32 SysUcode_GetUCodeBootSize(void); u64* SysUcode_GetUCode(void); u64* SysUcode_GetUCodeData(void); + // void func_80182CE0(void); // void func_80183020(void); // void func_80183058(void); @@ -4025,18 +4023,7 @@ s32 func_801A8A50(s32 param1); // void func_801A982C(void); // void func_801A99B8(void); // void func_801A9A74(void); -// void func_801A9B10(void); -// void func_801A9B78(void); -// void func_801A9BFC(void); -// void func_801A9C68(void); -// void func_801A9D10(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE1 param_5); -// void func_801A9DCC(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE1 param_5); -// void func_801A9EA4(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE2 param_5, UNK_TYPE1 param_6); -// void func_801A9F4C(void); -// void func_801AA020(UNK_TYPE1 param_1, UNK_TYPE1 param_2, UNK_TYPE1 param_3, UNK_TYPE1 param_4, UNK_TYPE4 param_5); -// void func_801AA248(void); -// void func_801AA3E4(void); -// void func_801AA520(void); + void GameOver_Init(GlobalContext* globalCtx); void GameOver_FadeLights(GlobalContext* globalCtx); void GameOver_Update(GlobalContext* globalCtx); diff --git a/include/macros.h b/include/macros.h index 15adcc6976..6dc1e5e4e4 100644 --- a/include/macros.h +++ b/include/macros.h @@ -130,7 +130,7 @@ extern GraphicsContext* __gfxCtx; #define SQ(x) ((x) * (x)) #define ABS(x) ((x) >= 0 ? (x) : -(x)) #define ABS_ALT(x) ((x) < 0 ? -(x) : (x)) -#define DECR(x) ((x) == 0 ? 0 : ((x) -= 1)) +#define DECR(x) ((x) == 0 ? 0 : --(x)) #define CLAMP(x, min, max) ((x) < (min) ? (min) : (x) > (max) ? (max) : (x)) #define CLAMP_MAX(x, max) ((x) > (max) ? (max) : (x)) diff --git a/include/variables.h b/include/variables.h index bc6cef1b42..af0f323d9c 100644 --- a/include/variables.h +++ b/include/variables.h @@ -360,7 +360,7 @@ extern u16 viRetrace; extern DmaEntry dmadata[1568]; // extern UNK_TYPE1 D_80186028; // extern UNK_TYPE1 D_801AAAB0; -// extern UNK_TYPE1 D_801AD370; +extern u64 gJpegUCode[]; extern ActorInit En_A_Obj_InitVars; extern ColliderCylinderInit enAObjCylinderInit; extern InitChainEntry enAObjInitVar; @@ -3107,7 +3107,7 @@ extern UNK_PTR D_801E10B0; // extern UNK_TYPE1 D_801E1E80; // extern UNK_TYPE1 D_801E2160; // extern UNK_TYPE1 D_801E3790; -// extern UNK_TYPE1 D_801E3F40; +extern u64 gJpegUCodeData[]; // extern UNK_TYPE1 D_801E3FA0; // bss @@ -3789,11 +3789,6 @@ extern OSMesg D_80203290[1]; // extern UNK_TYPE4 D_80208E6C; // extern UNK_TYPE4 D_80208E70; // extern UNK_TYPE4 D_80208E74; -// extern UNK_TYPE1 D_80208E90; -// extern UNK_TYPE1 D_80208E94; -// extern UNK_TYPE1 D_80208E98; -// extern UNK_TYPE1 D_80208E99; -// extern UNK_TYPE1 D_80208E9C; // post-code buffers extern u8 gGfxSPTaskYieldBuffer[OS_YIELD_DATA_SIZE]; diff --git a/include/z64jpeg.h b/include/z64jpeg.h new file mode 100644 index 0000000000..38183bfa90 --- /dev/null +++ b/include/z64jpeg.h @@ -0,0 +1,99 @@ +#ifndef Z64_JPEG_H +#define Z64_JPEG_H + +#include "PR/ultratypes.h" +#include "ultra64/message.h" +#include "PR/sched.h" + +typedef struct { + /* 0x00 */ u16 table[8*8]; +} JpegQuantizationTable; // size = 0x80 + +typedef struct { + /* 0x00 */ u8 codeOffs[16]; + /* 0x10 */ u16 codesA[16]; + /* 0x30 */ u16 codesB[16]; + /* 0x50 */ u8* symbols; +} JpegHuffmanTable; // size = 0x54 + +// this struct might be inaccurate but it's not used outside jpegutils.c +typedef struct { + /* 0x000 */ u8 codeOffs[16]; + /* 0x010 */ u16 dcCodes[120]; + /* 0x100 */ u16 acCodes[256]; +} JpegHuffmanTableOld; // size = 0x300 + +typedef struct { + /* 0x00 */ void* address; + /* 0x04 */ u32 mbCount; + /* 0x08 */ u32 mode; + /* 0x0C */ void* qTableYPtr; + /* 0x10 */ void* qTableUPtr; + /* 0x14 */ void* qTableVPtr; + /* 0x18 */ char unk_18[0x8]; +} JpegTaskData; // size = 0x20 + +typedef struct { + /* 0x000 */ JpegTaskData taskData; + /* 0x020 */ char yieldData[0x200]; + /* 0x220 */ JpegQuantizationTable qTableY; + /* 0x2A0 */ JpegQuantizationTable qTableU; + /* 0x320 */ JpegQuantizationTable qTableV; + /* 0x3A0 */ u8 codesLengths[0x110]; + /* 0x4B0 */ u16 codes[0x108]; + /* 0x6C0 */ u16 data[4][0x180]; +} JpegWork; // size = 0x12C0 + +typedef struct { + /* 0x00 */ void* imageData; + /* 0x04 */ u8 mode; + /* 0x05 */ u8 unk_05; + /* 0x08 */ JpegHuffmanTable* hTablePtrs[4]; + /* 0x18 */ u8 unk_18; +} JpegDecoder; // size = 0x1C + +typedef struct { + /* 0x00 */ u8 dqtCount; + /* 0x04 */ u8* dqtPtr[3]; + /* 0x10 */ u8 dhtCount; + /* 0x14 */ u8* dhtPtr[4]; + /* 0x24 */ void* imageData; + /* 0x28 */ u8 mode; // 0 if Y V0 is 1 and 2 if Y V0 is 2 + /* 0x30 */ OSScTask scTask; + /* 0x98 */ OSMesgQueue mq; + /* 0xB0 */ OSMesg msg; + /* 0xB4 */ JpegWork* workBuf; +} JpegContext; // size = 0xB8 + +typedef struct { + /* 0x00 */ u32 byteIdx; + /* 0x04 */ u8 bitIdx; + /* 0x05 */ u8 dontSkip; + /* 0x08 */ u32 curWord; + /* 0x0C */ s16 unk_0C; + /* 0x0E */ s16 unk_0E; + /* 0x10 */ s16 unk_10; +} JpegDecoderState; // size = 0x14 + + +void Jpeg_ScheduleDecoderTask(JpegContext* jpegCtx); +void Jpeg_CopyToZbuffer(u16* src, u16* zbuffer, s32 x, s32 y); +u16 Jpeg_GetUnalignedU16(u8* ptr); +void Jpeg_ParseMarkers(u8* ptr, JpegContext* jpegCtx); +s32 Jpeg_Decode(void* data, void* zbuffer, void* work, u32 workSize); + +void JpegUtils_ProcessQuantizationTable(u8* dqt, JpegQuantizationTable* qt, u8 count); +s32 JpegUtils_ParseHuffmanCodesLengths(u8* ptr, u8* codesLengths); +s32 JpegUtils_GetHuffmanCodes(u8* codesLengths, u16* codes); +s32 JpegUtils_SetHuffmanTable(u8* data, JpegHuffmanTable* ht, u16* codes); +u32 JpegUtils_ProcessHuffmanTableImpl(u8* data, JpegHuffmanTable* ht, u8* codesLengths, u16* codes, u8 isAc); +u32 JpegUtils_ProcessHuffmanTable(u8* dht, JpegHuffmanTable* ht, u8* codesLengths, u16* codes, u8 count); +void JpegUtils_SetHuffmanTableOld(u8* data, JpegHuffmanTableOld* ht, u8* codesLengths, u16* codes, s16 count, u8 isAc); +u32 JpegUtils_ProcessHuffmanTableImplOld(u8* dht, JpegHuffmanTableOld* ht, u8* codesLengths, u16* codes); + +s32 JpegDecoder_Decode(JpegDecoder* decoder, u16* mcuBuff, s32 count, u8 isFollowing, JpegDecoderState* state); +s32 JpegDecoder_ProcessMcu(JpegHuffmanTable* hTable0, JpegHuffmanTable* hTable1, u16* mcu, s16* unk); +s32 JpegDecoder_ParseNextSymbol(JpegHuffmanTable* hTable, s16* outCoeff, s8* outZeroCount); +u16 JpegDecoder_ReadBits(u8 len); + +#endif diff --git a/spec b/spec index b50573ebc7..d8a68f89c1 100644 --- a/spec +++ b/spec @@ -428,7 +428,7 @@ beginseg compress after "dmadata" include "build/src/code/z_en_a_keep.o" - include "build/data/code/z_en_a_keep.data.o" + include "build/data/code/rsp.data.o" include "build/data/code/code_801ADE60.data.o" include "build/data/code/code_801E3FA0.bss.o" include "build/src/code/z_en_item00.o" @@ -492,8 +492,8 @@ beginseg include "build/src/code/z_horse.o" include "build/data/code/z_horse.data.o" include "build/src/code/z_jpeg.o" - include "build/data/code/z_jpeg.data.o" include "build/src/code/z_kaleido_setup.o" + include "build/data/code/z_kaleido_setup.data.o" include "build/src/code/z_kanfont.o" include "build/src/code/z_kankyo.o" include "build/data/code/z_kankyo.data.o" @@ -679,11 +679,11 @@ beginseg include "build/data/code/code_801A7B10.bss.o" include "build/data/code/audio_init_params.rodata.o" include "build/src/code/jpegutils.o" - include "build/src/code/code_801AA020.o" - include "build/data/code/code_801AA020.bss.o" + include "build/src/code/jpegdecoder.o" include_readonly "build/src/code/z_game_over.o" include "build/src/code/z_construct.o" - include "build/data/code/code_801E1180.rodata.o" + include "build/data/code/audio_sound_params.data.o" + include "build/data/code/rsp.rodata.o" endseg beginseg diff --git a/src/code/code_8010C1B0.c b/src/code/code_8010C1B0.c index 12e0eadb47..2c1fd410f7 100644 --- a/src/code/code_8010C1B0.c +++ b/src/code/code_8010C1B0.c @@ -1,7 +1,7 @@ #include "global.h" // Blocks the current thread until all currently queued scheduler tasks have been completed -void func_8010C1B0(void) { +void MsgEvent_SendNullTask(void) { OSScTask task; OSMesgQueue queue; OSMesg msg; diff --git a/src/code/code_801AA020.c b/src/code/code_801AA020.c deleted file mode 100644 index 6cefc66d9f..0000000000 --- a/src/code/code_801AA020.c +++ /dev/null @@ -1,9 +0,0 @@ -#include "global.h" - -#pragma GLOBAL_ASM("asm/non_matchings/code/code_801AA020/func_801AA020.s") - -#pragma GLOBAL_ASM("asm/non_matchings/code/code_801AA020/func_801AA248.s") - -#pragma GLOBAL_ASM("asm/non_matchings/code/code_801AA020/func_801AA3E4.s") - -#pragma GLOBAL_ASM("asm/non_matchings/code/code_801AA020/func_801AA520.s") diff --git a/src/code/jpegdecoder.c b/src/code/jpegdecoder.c new file mode 100644 index 0000000000..336e381f9e --- /dev/null +++ b/src/code/jpegdecoder.c @@ -0,0 +1,193 @@ +#include "z64jpeg.h" +#include "libc/stdbool.h" +#include "macros.h" + +u8* sJpegBitStreamPtr; +u32 sJpegBitStreamByteIdx; +u8 sJpegBitStreamBitIdx; +u8 sJpegBitStreamDontSkip; +u32 sJpegBitStreamCurWord; + +s32 JpegDecoder_Decode(JpegDecoder* decoder, u16* mcuBuff, s32 count, u8 isFollowing, JpegDecoderState* state) { + s16 pad; + s16 unk0; + s16 unk1; + s16 unk2; + u32 idx; + s32 inc; + u16 unkCount; + + JpegHuffmanTable* hTable0; + JpegHuffmanTable* hTable1; + JpegHuffmanTable* hTable2; + JpegHuffmanTable* hTable3; + + inc = 0; + sJpegBitStreamPtr = decoder->imageData; + if (decoder->mode == 0) { + unkCount = 2; + } else { + unkCount = 4; + if (decoder->unk_05 == 1) { + inc = 8 * 8 * 2; + } + } + + hTable0 = decoder->hTablePtrs[0]; + hTable1 = decoder->hTablePtrs[1]; + hTable2 = decoder->hTablePtrs[2]; + hTable3 = decoder->hTablePtrs[3]; + + if (!isFollowing) { + sJpegBitStreamByteIdx = 0; + sJpegBitStreamBitIdx = 32; + sJpegBitStreamCurWord = 0; + sJpegBitStreamDontSkip = 0; + unk0 = 0; + unk1 = 0; + unk2 = 0; + } else { + sJpegBitStreamByteIdx = state->byteIdx; + sJpegBitStreamBitIdx = state->bitIdx; + sJpegBitStreamCurWord = state->curWord; + sJpegBitStreamDontSkip = state->dontSkip; + unk0 = state->unk_0C; + unk1 = state->unk_0E; + unk2 = state->unk_10; + } + + while (count != 0) { + for (idx = 0; idx < unkCount; idx++) { + if (JpegDecoder_ProcessMcu(hTable0, hTable1, mcuBuff, &unk0)) { + return 2; + } + mcuBuff += 8 * 8; + } + + if (JpegDecoder_ProcessMcu(hTable2, hTable3, mcuBuff, &unk1)) { + return 2; + } + mcuBuff += 8 * 8; + + if (JpegDecoder_ProcessMcu(hTable2, hTable3, mcuBuff, &unk2)) { + return 2; + } + + count--; + mcuBuff += 8 * 8; + mcuBuff += inc; + } + + state->byteIdx = sJpegBitStreamByteIdx; + state->bitIdx = sJpegBitStreamBitIdx; + state->curWord = sJpegBitStreamCurWord; + state->dontSkip = sJpegBitStreamDontSkip; + state->unk_0C = unk0; + state->unk_0E = unk1; + state->unk_10 = unk2; + return 0; +} + +s32 JpegDecoder_ProcessMcu(JpegHuffmanTable* hTable0, JpegHuffmanTable* hTable1, u16* mcu, s16* unk) { + s8 i = 0; + s8 zeroCount; + s16 coeff; + + if (JpegDecoder_ParseNextSymbol(hTable0, &coeff, &zeroCount)) { + return true; + } + + *unk += coeff; + mcu[i++] = *unk; + while (i < 8 * 8) { + if (JpegDecoder_ParseNextSymbol(hTable1, &coeff, &zeroCount)) { + return true; + } + + if (coeff == 0) { + if (zeroCount == 0xF) { + while (zeroCount-- >= 0) { + mcu[i++] = 0; + } + } else { + while (i < 8 * 8) { + mcu[i++] = 0; + } + break; + } + } else { + while (0 < zeroCount--) { + mcu[i++] = 0; + } + mcu[i++] = coeff; + } + } + + return false; +} + +s32 JpegDecoder_ParseNextSymbol(JpegHuffmanTable* hTable, s16* outCoeff, s8* outZeroCount) { + u8 codeIdx; + u8 sym; + u16 codeOff = 0; + u16 buff = JpegDecoder_ReadBits(16); + + for (codeIdx = 0; codeIdx < ARRAY_COUNT(hTable->codesB); codeIdx++) { + if (hTable->codesB[codeIdx] == 0xFFFF) { + continue; + } + + codeOff = buff >> (15 - codeIdx); + if (codeOff <= hTable->codesB[codeIdx]) { + break; + } + } + + if (codeIdx >= ARRAY_COUNT(hTable->codesB)) { + return true; + } + + sym = hTable->symbols[hTable->codeOffs[codeIdx] + codeOff - hTable->codesA[codeIdx]]; + *outZeroCount = sym >> 4; + sym &= 0xF; + + sJpegBitStreamBitIdx += codeIdx - 15; + *outCoeff = 0; + if (sym) { + *outCoeff = JpegDecoder_ReadBits(sym); + if (*outCoeff < (1 << (sym - 1))) { + *outCoeff += (-1 << sym) + 1; + } + } + + return false; +} + +u16 JpegDecoder_ReadBits(u8 len) { + u8 byteCount; + u8 data; + s32 ret; + u32 temp; + ret = 0; // this is required for some reason + + for (byteCount = sJpegBitStreamBitIdx >> 3; byteCount > 0; byteCount--) { + data = sJpegBitStreamPtr[sJpegBitStreamByteIdx++]; + if (sJpegBitStreamDontSkip) { + if (data == 0) { + data = sJpegBitStreamPtr[sJpegBitStreamByteIdx++]; + } + } + + sJpegBitStreamDontSkip = (data == 0xFF) ? true : false; + + sJpegBitStreamCurWord <<= 8; + sJpegBitStreamCurWord |= data; + sJpegBitStreamBitIdx -= 8; + } + + ret = (sJpegBitStreamCurWord << (sJpegBitStreamBitIdx)); + temp = ret; + ret = temp >> -len; + sJpegBitStreamBitIdx += len; + return ret; +} diff --git a/src/code/jpegutils.c b/src/code/jpegutils.c index 89ed4e97d6..904643f46f 100644 --- a/src/code/jpegutils.c +++ b/src/code/jpegutils.c @@ -1,17 +1,155 @@ -#include "global.h" +#include "z64jpeg.h" +#include "libc/stdbool.h" +#include "macros.h" -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9B10.s") +void JpegUtils_ProcessQuantizationTable(u8* dqt, JpegQuantizationTable* qt, u8 count) { + u8 i; -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9B78.s") + for (i = 0; i < count; i++) { + u8 j; -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9BFC.s") + dqt++; + for (j = 0; j < ARRAY_COUNT(qt[i].table); j++) { + qt[i].table[j] = *dqt++; + } + } +} -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9C68.s") +s32 JpegUtils_ParseHuffmanCodesLengths(u8* ptr, u8* codesLengths) { + u8 off = 1; + s16 count = 0; + s16 idx = 1; -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9D10.s") + while (off <= 16) { + while (idx <= ptr[off - 1]) { + codesLengths[count++] = off; + idx++; + } + idx = 1; + off++; + } -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9DCC.s") + codesLengths[count] = 0; + return count; +} -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9EA4.s") +s32 JpegUtils_GetHuffmanCodes(u8* codesLengths, u16* codes) { + s16 idx = 0; + u16 code = 0; + u8 lastLen = codesLengths[0]; -#pragma GLOBAL_ASM("asm/non_matchings/code/jpegutils/func_801A9F4C.s") + while (true) { + while (true) { + codes[idx++] = code++; + + if (codesLengths[idx] != lastLen) { + break; + } + } + + if (codesLengths[idx] == 0) { + break; + } + + while (true) { + if (code <<= 1, codesLengths[idx] == ++lastLen) { + break; + } + } + } + + return idx; +} + +s32 JpegUtils_SetHuffmanTable(u8* data, JpegHuffmanTable* ht, u16* codes) { + u8 idx; + u16 codeOff = 0; + + for (idx = 0; idx < 16; idx++) { + if (data[idx]) { + ht->codeOffs[idx] = codeOff; + ht->codesA[idx] = codes[codeOff]; + codeOff += data[idx] - 1; + ht->codesB[idx] = codes[codeOff]; + codeOff++; + } else { + ht->codesB[idx] = 0xFFFF; + } + } + + return codeOff; +} + +u32 JpegUtils_ProcessHuffmanTableImpl(u8* data, JpegHuffmanTable* ht, u8* codesLengths, u16* codes, u8 isAc) { + s16 ret; + s32 count = JpegUtils_ParseHuffmanCodesLengths(data, codesLengths); + s32 temp; + + ret = count; + if (count == 0 || (isAc && count > 0x100) || (!isAc && count > 0x10)) { + return 0; + } + if (ret != JpegUtils_GetHuffmanCodes(codesLengths, codes)) { + return 0; + } + if (temp = JpegUtils_SetHuffmanTable(data, ht, codes), temp != ret) { + return 0; + } + + return ret; +} + +u32 JpegUtils_ProcessHuffmanTable(u8* dht, JpegHuffmanTable* ht, u8* codesLengths, u16* codes, u8 count) { + u8 idx; + u32 codeCount; + + for (idx = 0; idx < count; idx++) { + u32 ac = (*dht++ >> 4); + + codeCount = JpegUtils_ProcessHuffmanTableImpl(dht, &ht[idx], codesLengths, codes, ac); + if (codeCount == 0) { + return true; + } + + dht += 16; + ht[idx].symbols = dht; + dht += codeCount; + } + return false; +} + +void JpegUtils_SetHuffmanTableOld(u8* data, JpegHuffmanTableOld* ht, u8* codesLengths, u16* codes, s16 count, u8 isAc) { + s16 idx; + u8 a; + + for (idx = 0; idx < count; idx++) { + a = data[idx]; + if (isAc) { + ht->acCodes[a] = codes[idx]; + ht->codeOffs[a] = codesLengths[idx]; + } else { + ht->dcCodes[a] = codes[idx]; + ht->codeOffs[a] = codesLengths[idx]; + } + } +} + +u32 JpegUtils_ProcessHuffmanTableImplOld(u8* dht, JpegHuffmanTableOld* ht, u8* codesLengths, u16* codes) { + u8 isAc = *dht++ >> 4; + s16 count2; + s32 count; + + count2 = count = JpegUtils_ParseHuffmanCodesLengths(dht, codesLengths); + + if (count == 0 || (isAc && count > 0x100) || (!isAc && count > 0x10)) { + return true; + } + + if (JpegUtils_GetHuffmanCodes(codesLengths, codes) != count2) { + return true; + } + + JpegUtils_SetHuffmanTableOld(dht + 0x10, ht, codesLengths, codes, count2, isAc); + + return false; +} diff --git a/src/code/z_jpeg.c b/src/code/z_jpeg.c index 395a458350..c611ab1f87 100644 --- a/src/code/z_jpeg.c +++ b/src/code/z_jpeg.c @@ -1,11 +1,304 @@ -#include "global.h" +#include "z64jpeg.h" +#include "libc/stdbool.h" +#include "variables.h" +#include "functions.h" -#pragma GLOBAL_ASM("asm/non_matchings/code/z_jpeg/func_800F42A0.s") +#define MARKER_ESCAPE 0x00 +#define MARKER_SOI 0xD8 +#define MARKER_SOF 0xC0 +#define MARKER_DHT 0xC4 +#define MARKER_DQT 0xDB +#define MARKER_DRI 0xDD +#define MARKER_SOS 0xDA +#define MARKER_APP0 0xE0 +#define MARKER_APP1 0xE1 +#define MARKER_APP2 0xE2 +#define MARKER_COM 0xFE +#define MARKER_EOI 0xD9 -#pragma GLOBAL_ASM("asm/non_matchings/code/z_jpeg/func_800F43BC.s") +/** + * Configures and schedules a JPEG decoder task and waits for it to finish. + */ +void Jpeg_ScheduleDecoderTask(JpegContext* jpegCtx) { + static OSTask_t sJpegTask = { + M_NJPEGTASK, // type + 0, // flags + NULL, // ucode_boot + 0, // ucode_boot_size + gJpegUCode, // ucode + 0x1000, // ucode_size + gJpegUCodeData, // ucode_data + 0x800, // ucode_data_size + NULL, // dram_stack + 0, // dram_stack_size + NULL, // output_buff + NULL, // output_buff_size + NULL, // data_ptr + sizeof(JpegTaskData), // data_size + NULL, // yield_data_ptr + 0x200, // yield_data_size + }; -#pragma GLOBAL_ASM("asm/non_matchings/code/z_jpeg/func_800F44F4.s") + JpegWork* workBuf = jpegCtx->workBuf; + s32 pad[2]; -#pragma GLOBAL_ASM("asm/non_matchings/code/z_jpeg/func_800F4540.s") + workBuf->taskData.address = &workBuf->data; + workBuf->taskData.mode = jpegCtx->mode; + workBuf->taskData.mbCount = 4; + workBuf->taskData.qTableYPtr = &workBuf->qTableY; + workBuf->taskData.qTableUPtr = &workBuf->qTableU; + workBuf->taskData.qTableVPtr = &workBuf->qTableV; -#pragma GLOBAL_ASM("asm/non_matchings/code/z_jpeg/func_800F470C.s") + sJpegTask.flags = 0; + sJpegTask.ucodeBoot = SysUcode_GetUCodeBoot(); + sJpegTask.ucodeBootSize = SysUcode_GetUCodeBootSize(); + sJpegTask.yieldDataPtr = (u64*)&workBuf->yieldData; + sJpegTask.dataPtr = (u64*)&workBuf->taskData; + + jpegCtx->scTask.next = NULL; + jpegCtx->scTask.flags = OS_SC_NEEDS_RSP; + jpegCtx->scTask.msgQ = &jpegCtx->mq; + jpegCtx->scTask.msg = NULL; + jpegCtx->scTask.framebuffer = NULL; + jpegCtx->scTask.list.t = sJpegTask; + + osSendMesg(&gSchedContext.cmdQ, (OSMesg)&jpegCtx->scTask, OS_MESG_BLOCK); + Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg + osRecvMesg(&jpegCtx->mq, NULL, OS_MESG_BLOCK); +} + +/** + * Copies a 16x16 block of decoded image data to the Z-buffer. + */ +void Jpeg_CopyToZbuffer(u16* src, u16* zbuffer, s32 x, s32 y) { + u16* dst = zbuffer + (((y * SCREEN_WIDTH) + x) * 16); + s32 i; + + for (i = 0; i < 16; i++) { + dst[0] = src[0]; + dst[1] = src[1]; + dst[2] = src[2]; + dst[3] = src[3]; + dst[4] = src[4]; + dst[5] = src[5]; + dst[6] = src[6]; + dst[7] = src[7]; + dst[8] = src[8]; + dst[9] = src[9]; + dst[10] = src[10]; + dst[11] = src[11]; + dst[12] = src[12]; + dst[13] = src[13]; + dst[14] = src[14]; + dst[15] = src[15]; + + src += 16; + dst += SCREEN_WIDTH; + } +} + +/** + * Reads an u16 from a possibly unaligned address in memory. + * + * Replaces unaligned 16-bit reads with a pair of aligned reads, allowing for reading the possibly + * unaligned values in JPEG header files. + */ +u16 Jpeg_GetUnalignedU16(u8* ptr) { + if (((u32)ptr & 1) == 0) { + // Read the value normally if it's aligned to a 16-bit address. + return *(u16*)ptr; + } else { + // Read unaligned values using two separate aligned memory accesses when it's not. + return *(u16*)(ptr - 1) << 8 | (*(u16*)(ptr + 1) >> 8); + } +} + +/** + * Parses the markers in the JPEG file, storing information such as the pointer to the image data + * in `jpegCtx` for later processing. + */ +void Jpeg_ParseMarkers(u8* ptr, JpegContext* jpegCtx) { + u32 exit = false; + + jpegCtx->dqtCount = 0; + jpegCtx->dhtCount = 0; + + while (true) { + if (exit) { + break; + } + + // 0xFF indicates the start of a JPEG marker, so look for the next. + if (*ptr++ == 0xFF) { + switch (*ptr++) { + case MARKER_ESCAPE: { + // Compressed value 0xFF is stored as 0xFF00 to escape it, so ignore it. + break; + } + case MARKER_SOI: { + // Start of Image + break; + } + case MARKER_APP0: { + // Application marker for JFIF + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + case MARKER_APP1: { + // Application marker for EXIF + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + case MARKER_APP2: { + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + case MARKER_DQT: { + // Define Quantization Table, stored for later processing + jpegCtx->dqtPtr[jpegCtx->dqtCount++] = ptr + 2; + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + case MARKER_DHT: { + // Define Huffman Table, stored for later processing + jpegCtx->dhtPtr[jpegCtx->dhtCount++] = ptr + 2; + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + case MARKER_DRI: { + // Define Restart Interval + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + case MARKER_SOF: { + // Start of Frame, stores important metadata of the image. + // Only used for extracting the sampling factors (jpegCtx->mode). + + if (ptr[9] == 0x21) { + // component Y : V0 == 1 + jpegCtx->mode = 0; + } else if (ptr[9] == 0x22) { + // component Y : V0 == 2 + jpegCtx->mode = 2; + } + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + case MARKER_SOS: { + // Start of Scan marker, indicates the start of the image data. + ptr += Jpeg_GetUnalignedU16(ptr); + jpegCtx->imageData = ptr; + break; + } + case MARKER_EOI: { + // End of Image + exit = true; + break; + } + default: { + ptr += Jpeg_GetUnalignedU16(ptr); + break; + } + } + } + } +} + +s32 Jpeg_Decode(void* data, void* zbuffer, void* work, u32 workSize) { + s32 y; + s32 x; + s32 j; + s32 i; + JpegContext jpegCtx; + JpegHuffmanTable hTables[4]; + JpegDecoder decoder; + JpegDecoderState state; + JpegWork* workBuff = work; + + if (workSize < sizeof(JpegWork)) { + return -1; + } + + osCreateMesgQueue(&jpegCtx.mq, &jpegCtx.msg, 1); + MsgEvent_SendNullTask(); + + jpegCtx.workBuf = workBuff; + + Jpeg_ParseMarkers(data, &jpegCtx); + + switch (jpegCtx.dqtCount) { + case 1: + JpegUtils_ProcessQuantizationTable(jpegCtx.dqtPtr[0], &workBuff->qTableY, 3); + break; + + case 2: + JpegUtils_ProcessQuantizationTable(jpegCtx.dqtPtr[0], &workBuff->qTableY, 1); + JpegUtils_ProcessQuantizationTable(jpegCtx.dqtPtr[1], &workBuff->qTableU, 1); + JpegUtils_ProcessQuantizationTable(jpegCtx.dqtPtr[1], &workBuff->qTableV, 1); + break; + + case 3: + JpegUtils_ProcessQuantizationTable(jpegCtx.dqtPtr[0], &workBuff->qTableY, 1); + JpegUtils_ProcessQuantizationTable(jpegCtx.dqtPtr[1], &workBuff->qTableU, 1); + JpegUtils_ProcessQuantizationTable(jpegCtx.dqtPtr[2], &workBuff->qTableV, 1); + break; + + default: + return -1; + } + + switch (jpegCtx.dhtCount) { + case 1: + if (JpegUtils_ProcessHuffmanTable(jpegCtx.dhtPtr[0], &hTables[0], workBuff->codesLengths, workBuff->codes, + 4)) { + return -1; + } + break; + + case 4: + // This chained if-else has printfs inside it on debug + if (JpegUtils_ProcessHuffmanTable(jpegCtx.dhtPtr[0], &hTables[0], workBuff->codesLengths, workBuff->codes, + 1)) { + } else if (JpegUtils_ProcessHuffmanTable(jpegCtx.dhtPtr[1], &hTables[1], workBuff->codesLengths, + workBuff->codes, 1)) { + } else if (JpegUtils_ProcessHuffmanTable(jpegCtx.dhtPtr[2], &hTables[2], workBuff->codesLengths, + workBuff->codes, 1)) { + } else if (!JpegUtils_ProcessHuffmanTable(jpegCtx.dhtPtr[3], &hTables[3], workBuff->codesLengths, + workBuff->codes, 1)) { + break; + } + return -1; + + default: + return -1; + } + + decoder.imageData = jpegCtx.imageData; + decoder.mode = jpegCtx.mode; + decoder.unk_05 = 2; + + decoder.hTablePtrs[0] = &hTables[0]; + decoder.hTablePtrs[1] = &hTables[1]; + decoder.hTablePtrs[2] = &hTables[2]; + decoder.hTablePtrs[3] = &hTables[3]; + decoder.unk_18 = 0; + + x = y = 0; + for (i = 0; i < 300; i += 4) { + if (!JpegDecoder_Decode(&decoder, (u16*)workBuff->data, 4, (i != 0), &state)) { + Jpeg_ScheduleDecoderTask(&jpegCtx); + + for (j = 0; j < 4; j++) { + Jpeg_CopyToZbuffer(workBuff->data[j], zbuffer, x, y); + x++; + + if (x >= 20) { + x = 0; + y++; + } + } + } + } + + return 0; +} diff --git a/tools/disasm/files.txt b/tools/disasm/files.txt index 2c22781ba1..86f3f7f74f 100644 --- a/tools/disasm/files.txt +++ b/tools/disasm/files.txt @@ -498,12 +498,12 @@ 0x801A5BD0 : "code_801A5BD0", 0x801A7B10 : "code_801A7B10", 0x801A9B10 : "jpegutils", - 0x801AA020 : "code_801AA020", + 0x801AA020 : "jpegdecoder", 0x801AA610 : "z_game_over", 0x801AAAA0 : "z_construct", # .data section - 0x801AAAB0 : "z_en_a_keep", + 0x801AAAB0 : "rsp", 0x801ADE60 : "", 0x801ADEC0 : "z_en_item00", 0x801AE240 : "z_eff_blure", @@ -530,6 +530,7 @@ 0x801BD910 : "", 0x801BDA70 : "z_horse", 0x801BDAC0 : "z_jpeg", + 0x801BDB00 : "z_kaleido_setup", 0x801BDB30 : "z_kanfont", 0x801BDB90 : "z_kankyo", 0x801BE960 : "z_lib", @@ -672,7 +673,7 @@ 0x801E1070 : "code_801A7B10", 0x801E1100 : "audio_init_params", 0x801E1110 : "z_game_over", - 0x801E1180 : "", + 0x801E1180 : "rsp", # .bss section 0x801E3FA0 : "code_801E3FA0", @@ -728,7 +729,7 @@ 0x801FD5A0 : "code_801A51F0", 0x801FD710 : "code_801A5BD0", 0x801FFD00 : "code_801A7B10", - 0x80208E90 : "code_801AA020", + 0x80208E90 : "jpegdecoder", 0x80208EA0 : "gfxbuffers", 0x8024A4C0 : "buffers", }, diff --git a/tools/disasm/functions.txt b/tools/disasm/functions.txt index 43024464d5..6eabbe56dd 100644 --- a/tools/disasm/functions.txt +++ b/tools/disasm/functions.txt @@ -1693,11 +1693,11 @@ 0x800F40A0:("func_800F40A0",), 0x800F415C:("func_800F415C",), 0x800F41E4:("func_800F41E4",), - 0x800F42A0:("func_800F42A0",), - 0x800F43BC:("func_800F43BC",), - 0x800F44F4:("func_800F44F4",), - 0x800F4540:("func_800F4540",), - 0x800F470C:("func_800F470C",), + 0x800F42A0:("Jpeg_ScheduleDecoderTask",), + 0x800F43BC:("Jpeg_CopyToZbuffer",), + 0x800F44F4:("Jpeg_GetUnalignedU16",), + 0x800F4540:("Jpeg_ParseMarkers",), + 0x800F470C:("Jpeg_Decode",), 0x800F4A10:("func_800F4A10",), 0x800F4C0C:("func_800F4C0C",), 0x800F4E20:("func_800F4E20",), @@ -2064,7 +2064,7 @@ 0x8010C0C0:("Nmi_Init",), 0x8010C164:("Nmi_SetPrenmiStart",), 0x8010C19C:("Nmi_GetPrenmiHasStarted",), - 0x8010C1B0:("func_8010C1B0",), + 0x8010C1B0:("MsgEvent_SendNullTask",), 0x8010C230:("OLib_Vec3fDist",), 0x8010C274:("OLib_Vec3fDistOutDiff",), 0x8010C2D0:("OLib_Vec3fDistXZ",), @@ -4067,18 +4067,18 @@ 0x801A982C:("func_801A982C",), 0x801A99B8:("func_801A99B8",), 0x801A9A74:("func_801A9A74",), - 0x801A9B10:("func_801A9B10",), - 0x801A9B78:("func_801A9B78",), - 0x801A9BFC:("func_801A9BFC",), - 0x801A9C68:("func_801A9C68",), - 0x801A9D10:("func_801A9D10",), - 0x801A9DCC:("func_801A9DCC",), - 0x801A9EA4:("func_801A9EA4",), - 0x801A9F4C:("func_801A9F4C",), - 0x801AA020:("func_801AA020",), - 0x801AA248:("func_801AA248",), - 0x801AA3E4:("func_801AA3E4",), - 0x801AA520:("func_801AA520",), + 0x801A9B10:("JpegUtils_ProcessQuantizationTable",), + 0x801A9B78:("JpegUtils_ParseHuffmanCodesLengths",), + 0x801A9BFC:("JpegUtils_GetHuffmanCodes",), + 0x801A9C68:("JpegUtils_SetHuffmanTable",), + 0x801A9D10:("JpegUtils_ProcessHuffmanTableImpl",), + 0x801A9DCC:("JpegUtils_ProcessHuffmanTable",), + 0x801A9EA4:("JpegUtils_SetHuffmanTableOld",), + 0x801A9F4C:("JpegUtils_ProcessHuffmanTableImplOld",), + 0x801AA020:("JpegDecoder_Decode",), + 0x801AA248:("JpegDecoder_ProcessMcu",), + 0x801AA3E4:("JpegDecoder_ParseNextSymbol",), + 0x801AA520:("JpegDecoder_ReadBits",), 0x801AA610:("GameOver_Init",), 0x801AA624:("GameOver_FadeLights",), 0x801AA68C:("GameOver_Update",), diff --git a/tools/disasm/variables.txt b/tools/disasm/variables.txt index d04d30b7f0..b633dd2922 100644 --- a/tools/disasm/variables.txt +++ b/tools/disasm/variables.txt @@ -367,7 +367,7 @@ 0x80186028:("D_80186028","s16","[1316]",0xa48), 0x801AAAB0:("D_801AAAB0","UNK_TYPE1","",0x1), 0x801ABAB0:("D_801ABAB0","UNK_TYPE1","",0x1), - 0x801AD370:("D_801AD370","UNK_TYPE1","",0x1), + 0x801AD370:("gJpegUCode","UNK_TYPE1","",0x1), 0x801ADE60:("En_A_Obj_InitVars","ActorInit","",0x20), 0x801ADE80:("enAObjCylinderInit","ColliderCylinderInit","",0x2c), 0x801ADEAC:("enAObjInitVar","ActorInitVar","",0x4), @@ -3894,7 +3894,7 @@ 0x801E2160:("D_801E2160","UNK_TYPE1","",0x1), 0x801E3790:("D_801E3790","UNK_TYPE1","",0x1), 0x801E3BB0:("D_801E3BB0","UNK_TYPE1","",0x1), - 0x801E3F40:("D_801E3F40","UNK_TYPE1","",0x1), + 0x801E3F40:("gJpegUCodeData","UNK_TYPE1","",0x1), 0x801E3FA0:("D_801E3FA0","UNK_TYPE1","",0x1), 0x801E3FB0:("sEffTable","EffTables","",0x98e0), 0x801E4514:("D_801E4514","UNK_TYPE1","",0x1), @@ -4585,11 +4585,11 @@ 0x80208E6C:("D_80208E6C","UNK_TYPE4","",0x4), 0x80208E70:("D_80208E70","UNK_TYPE4","",0x4), 0x80208E74:("D_80208E74","UNK_TYPE4","",0x4), - 0x80208E90:("D_80208E90","UNK_TYPE1","",0x1), - 0x80208E94:("D_80208E94","UNK_TYPE1","",0x1), - 0x80208E98:("D_80208E98","UNK_TYPE1","",0x1), - 0x80208E99:("D_80208E99","UNK_TYPE1","",0x1), - 0x80208E9C:("D_80208E9C","UNK_TYPE1","",0x1), + 0x80208E90:("sJpegBitStreamPtr","UNK_TYPE1","",0x1), + 0x80208E94:("sJpegBitStreamByteIdx","UNK_TYPE1","",0x1), + 0x80208E98:("sJpegBitStreamBitIdx","UNK_TYPE1","",0x1), + 0x80208E99:("sJpegBitStreamDontSkip","UNK_TYPE1","",0x1), + 0x80208E9C:("sJpegBitStreamCurWord","UNK_TYPE1","",0x1), 0x80208EA0:("gGfxSPTaskYieldBuffer","u8","[OS_YIELD_DATA_SIZE]",0xC00), 0x80209AA0:("gGfxSPTaskStack","u8","[0x400]",0x400), 0x80209EA0:("gGfxPools","GfxPool","[2]",0x40620), @@ -7917,11 +7917,6 @@ 0x8090DC1C:("D_8090DC1C","f32","",0x4), 0x8090DC20:("D_8090DC20","f32","",0x4), 0x8090DC24:("D_8090DC24","f32","",0x4), - 0x8090DC30:("enFishingOverlayInfo","OverlayRelocationSection","",0x14), - 0x8090DC44:("enFishingOverlayRelocations","u32","[2393]",0x2564), - 0x809101AC:("enFishingOverlayInfoOffset","u32","",0x4), - 0x80910000:("D_80910000","UNK_TYPE1","",0x1), - 0x80910001:("D_80910001","UNK_TYPE1","",0x1), 0x809101B0:("D_809101B0","f32","",0x4), 0x809101B4:("D_809101B4","f32","",0x4), 0x809101B8:("D_809101B8","UNK_TYPE1","",0x1), @@ -10994,9 +10989,6 @@ 0x80A0C55C:("D_80A0C55C","f32","",0x4), 0x80A0C560:("D_80A0C560","f32","",0x4), 0x80A0C7C0:("En_Boj_05_InitVars","UNK_TYPE1","",0x1), - 0x80A0C7E0:("enBoj05OverlayInfo","OverlayRelocationSection","",0x14), - 0x80A0C7F4:("enBoj05OverlayRelocations","u32","[4]",0x10), - 0x80A0C80C:("enBoj05OverlayInfoOffset","u32","",0x4), 0x80A10860:("sAnimationsBombShopkeeper","UNK_PTR","",0x4), 0x80A10890:("En_Sob1_InitVars","UNK_TYPE1","",0x1), 0x80A108B0:("sObjectIds","UNK_TYPE2","",0x2), @@ -12656,9 +12648,6 @@ 0x80A8B440:("jtbl_D_80A8B440","UNK_PTR","",0x4), 0x80A8B478:("jtbl_D_80A8B478","UNK_PTR","",0x4), 0x80A8B48C:("jtbl_D_80A8B48C","UNK_PTR","",0x4), - 0x80A8B4A0:("enTruOverlayInfo","OverlayRelocationSection","",0x14), - 0x80A8B4B4:("enTruOverlayRelocations","u32","[174]",0x2b8), - 0x80A8B76C:("enTruOverlayInfoOffset","u32","",0x4), 0x80A8FE10:("sAnimations","UNK_TYPE1","",0x1), 0x80A8FEB0:("En_Trt_InitVars","UNK_TYPE1","",0x1), 0x80A8FED0:("sActorScale","UNK_TYPE4","",0x4), @@ -13140,9 +13129,6 @@ 0x80AC027C:("jtbl_80AC027C","UNK_PTR","",0x4), 0x80AC0300:("jtbl_80AC0300","UNK_PTR","",0x4), 0x80AC03E4:("jtbl_80AC03E4","UNK_PTR","",0x4), - 0x80AC0400:("enMa4OverlayInfo","OverlayRelocationSection","",0x14), - 0x80AC0414:("enMa4OverlayRelocations","u32","[262]",0x418), - 0x80AC082C:("enMa4OverlayInfoOffset","u32","",0x4), 0x80AC1090:("En_Twig_InitVars","UNK_TYPE1","",0x1), 0x80AC10B0:("D_80AC10B0","UNK_TYPE1","",0x1), 0x80AC10BC:("D_80AC10BC","UNK_TYPE2","",0x2), diff --git a/tools/sizes/code_functions.csv b/tools/sizes/code_functions.csv index 44250fc0c4..681b1cd4ee 100644 --- a/tools/sizes/code_functions.csv +++ b/tools/sizes/code_functions.csv @@ -1207,11 +1207,11 @@ asm/non_matchings/code/z_horse/func_800F3ED4.s,func_800F3ED4,0x800F3ED4,0x73 asm/non_matchings/code/z_horse/func_800F40A0.s,func_800F40A0,0x800F40A0,0x2F asm/non_matchings/code/z_horse/func_800F415C.s,func_800F415C,0x800F415C,0x22 asm/non_matchings/code/z_horse/func_800F41E4.s,func_800F41E4,0x800F41E4,0x2F -asm/non_matchings/code/z_jpeg/func_800F42A0.s,func_800F42A0,0x800F42A0,0x47 -asm/non_matchings/code/z_jpeg/func_800F43BC.s,func_800F43BC,0x800F43BC,0x4E -asm/non_matchings/code/z_jpeg/func_800F44F4.s,func_800F44F4,0x800F44F4,0x13 -asm/non_matchings/code/z_jpeg/func_800F4540.s,func_800F4540,0x800F4540,0x73 -asm/non_matchings/code/z_jpeg/func_800F470C.s,func_800F470C,0x800F470C,0xC1 +asm/non_matchings/code/z_jpeg/Jpeg_ScheduleDecoderTask.s,Jpeg_ScheduleDecoderTask,0x800F42A0,0x47 +asm/non_matchings/code/z_jpeg/Jpeg_CopyToZbuffer.s,Jpeg_CopyToZbuffer,0x800F43BC,0x4E +asm/non_matchings/code/z_jpeg/Jpeg_GetUnalignedU16.s,Jpeg_GetUnalignedU16,0x800F44F4,0x13 +asm/non_matchings/code/z_jpeg/Jpeg_ParseMarkers.s,Jpeg_ParseMarkers,0x800F4540,0x73 +asm/non_matchings/code/z_jpeg/Jpeg_Decode.s,Jpeg_Decode,0x800F470C,0xC1 asm/non_matchings/code/z_kaleido_setup/func_800F4A10.s,func_800F4A10,0x800F4A10,0x7F asm/non_matchings/code/z_kaleido_setup/func_800F4C0C.s,func_800F4C0C,0x800F4C0C,0x85 asm/non_matchings/code/z_kaleido_setup/func_800F4E20.s,func_800F4E20,0x800F4E20,0x42 @@ -1578,7 +1578,7 @@ asm/non_matchings/code/z_msgevent/func_8010BF58.s,func_8010BF58,0x8010BF58,0x5A asm/non_matchings/code/z_nmi_buff/Nmi_Init.s,Nmi_Init,0x8010C0C0,0x29 asm/non_matchings/code/z_nmi_buff/Nmi_SetPrenmiStart.s,Nmi_SetPrenmiStart,0x8010C164,0xE asm/non_matchings/code/z_nmi_buff/Nmi_GetPrenmiHasStarted.s,Nmi_GetPrenmiHasStarted,0x8010C19C,0x5 -asm/non_matchings/code/z_nmi_buff/func_8010C1B0.s,func_8010C1B0,0x8010C1B0,0x20 +asm/non_matchings/code/z_nmi_buff/MsgEvent_SendNullTask.s,MsgEvent_SendNullTask,0x8010C1B0,0x20 asm/non_matchings/code/z_olib/OLib_Vec3fDist.s,OLib_Vec3fDist,0x8010C230,0x11 asm/non_matchings/code/z_olib/OLib_Vec3fDistOutDiff.s,OLib_Vec3fDistOutDiff,0x8010C274,0x17 asm/non_matchings/code/z_olib/OLib_Vec3fDistXZ.s,OLib_Vec3fDistXZ,0x8010C2D0,0xD @@ -2907,10 +2907,10 @@ asm/non_matchings/code/sys_matrix/func_8018219C.s,func_8018219C,0x8018219C,0x4A asm/non_matchings/code/sys_matrix/func_801822C4.s,func_801822C4,0x801822C4,0x4A asm/non_matchings/code/sys_matrix/Matrix_InsertRotationAroundUnitVector_f.s,Matrix_InsertRotationAroundUnitVector_f,0x801823EC,0x118 asm/non_matchings/code/sys_matrix/Matrix_InsertRotationAroundUnitVector_s.s,Matrix_InsertRotationAroundUnitVector_s,0x8018284C,0x111 -asm/non_matchings/code/sys_matrix/SysUcode_GetUCodeBoot.s,SysUcode_GetUCodeBoot,0x80182C90,0x4 -asm/non_matchings/code/sys_matrix/SysUcode_GetUCodeBootSize.s,SysUcode_GetUCodeBootSize,0x80182CA0,0x7 -asm/non_matchings/code/sys_matrix/SysUcode_GetUCode.s,SysUcode_GetUCode,0x80182CBC,0x4 -asm/non_matchings/code/sys_matrix/SysUcode_GetUCodeData.s,SysUcode_GetUCodeData,0x80182CCC,0x5 +asm/non_matchings/code/sys_ucode/SysUcode_GetUCodeBoot.s,SysUcode_GetUCodeBoot,0x80182C90,0x4 +asm/non_matchings/code/sys_ucode/SysUcode_GetUCodeBootSize.s,SysUcode_GetUCodeBootSize,0x80182CA0,0x7 +asm/non_matchings/code/sys_ucode/SysUcode_GetUCode.s,SysUcode_GetUCode,0x80182CBC,0x4 +asm/non_matchings/code/sys_ucode/SysUcode_GetUCodeData.s,SysUcode_GetUCodeData,0x80182CCC,0x5 asm/non_matchings/code/sys_ucode/func_80182CE0.s,func_80182CE0,0x80182CE0,0xD0 asm/non_matchings/code/sys_ucode/func_80183020.s,func_80183020,0x80183020,0xE asm/non_matchings/code/sys_ucode/func_80183058.s,func_80183058,0x80183058,0x6 @@ -3585,18 +3585,18 @@ asm/non_matchings/code/code_801A7B10/func_801A9768.s,func_801A9768,0x801A9768,0x asm/non_matchings/code/code_801A7B10/func_801A982C.s,func_801A982C,0x801A982C,0x63 asm/non_matchings/code/code_801A7B10/func_801A99B8.s,func_801A99B8,0x801A99B8,0x2F asm/non_matchings/code/code_801A7B10/func_801A9A74.s,func_801A9A74,0x801A9A74,0x27 -asm/non_matchings/code/code_801A7B10/func_801A9B10.s,func_801A9B10,0x801A9B10,0x1A -asm/non_matchings/code/code_801A7B10/func_801A9B78.s,func_801A9B78,0x801A9B78,0x21 -asm/non_matchings/code/code_801A7B10/func_801A9BFC.s,func_801A9BFC,0x801A9BFC,0x1B -asm/non_matchings/code/code_801A7B10/func_801A9C68.s,func_801A9C68,0x801A9C68,0x2A -asm/non_matchings/code/code_801A7B10/func_801A9D10.s,func_801A9D10,0x801A9D10,0x2F -asm/non_matchings/code/code_801A7B10/func_801A9DCC.s,func_801A9DCC,0x801A9DCC,0x36 -asm/non_matchings/code/code_801A7B10/func_801A9EA4.s,func_801A9EA4,0x801A9EA4,0x2A -asm/non_matchings/code/code_801A7B10/func_801A9F4C.s,func_801A9F4C,0x801A9F4C,0x35 -asm/non_matchings/code/code_801AA020/func_801AA020.s,func_801AA020,0x801AA020,0x8A -asm/non_matchings/code/code_801AA020/func_801AA248.s,func_801AA248,0x801AA248,0x67 -asm/non_matchings/code/code_801AA020/func_801AA3E4.s,func_801AA3E4,0x801AA3E4,0x4F -asm/non_matchings/code/code_801AA020/func_801AA520.s,func_801AA520,0x801AA520,0x3C +asm/non_matchings/code/jpegutils/JpegUtils_ProcessQuantizationTable.s,JpegUtils_ProcessQuantizationTable,0x801A9B10,0x1A +asm/non_matchings/code/jpegutils/JpegUtils_ParseHuffmanCodesLengths.s,JpegUtils_ParseHuffmanCodesLengths,0x801A9B78,0x21 +asm/non_matchings/code/jpegutils/JpegUtils_GetHuffmanCodes.s,JpegUtils_GetHuffmanCodes,0x801A9BFC,0x1B +asm/non_matchings/code/jpegutils/JpegUtils_SetHuffmanTable.s,JpegUtils_SetHuffmanTable,0x801A9C68,0x2A +asm/non_matchings/code/jpegutils/JpegUtils_ProcessHuffmanTableImpl.s,JpegUtils_ProcessHuffmanTableImpl,0x801A9D10,0x2F +asm/non_matchings/code/jpegutils/JpegUtils_ProcessHuffmanTable.s,JpegUtils_ProcessHuffmanTable,0x801A9DCC,0x36 +asm/non_matchings/code/jpegutils/JpegUtils_SetHuffmanTableOld.s,JpegUtils_SetHuffmanTableOld,0x801A9EA4,0x2A +asm/non_matchings/code/jpegutils/JpegUtils_ProcessHuffmanTableImplOld.s,JpegUtils_ProcessHuffmanTableImplOld,0x801A9F4C,0x35 +asm/non_matchings/code/jpegdecoder/JpegDecoder_Decode.s,JpegDecoder_Decode,0x801AA020,0x8A +asm/non_matchings/code/jpegdecoder/JpegDecoder_ProcessMcu.s,JpegDecoder_ProcessMcu,0x801AA248,0x67 +asm/non_matchings/code/jpegdecoder/JpegDecoder_ParseNextSymbol.s,JpegDecoder_ParseNextSymbol,0x801AA3E4,0x4F +asm/non_matchings/code/jpegdecoder/JpegDecoder_ReadBits.s,JpegDecoder_ReadBits,0x801AA520,0x3C asm/non_matchings/code/z_game_over/GameOver_Init.s,GameOver_Init,0x801AA610,0x5 asm/non_matchings/code/z_game_over/GameOver_FadeLights.s,GameOver_FadeLights,0x801AA624,0x1A asm/non_matchings/code/z_game_over/GameOver_Update.s,GameOver_Update,0x801AA68C,0x105