Decompile jpegutils.c (#75)

* Decompile jpegutils.c

jpegutils.c : OK

* Fix a typo

* Fixes in PR #75

- Fix a type in JpegWork
- Remove clang-format off/on in z_quake.c
- Move the jpegutils rule at the end of makefile

3 files changed, 174 insertions, 14 deletions

diff --git a/src/code/jpegutils.c b/src/code/jpegutils.c
new file mode 100644
index 000000000..ae23da852
--- /dev/null
+++ b/src/code/jpegutils.c
@@ -0,0 +1,155 @@
+#include <global.h>
+
+void JpegUtils_ProcessQuantizationTable(u8* dqt, JpegQuantizationTable* qt, u8 count) {
+    u8 i;
+
+    for (i = 0; i < count; i++) {
+        u8 j;
+        dqt++;
+        for (j = 0; j < 64; j++) {
+            qt[i].table[j] = *dqt++;
+        }
+    }
+}
+
+s32 JpegUtils_ParseHuffmancodesLengths(u8* ptr, u8* codesLengths) {
+    u8 off = 1;
+    s16 count = 0;
+    s16 idx = 1;
+
+    while (off < 0x11) {
+        while (idx <= ptr[off - 1]) {
+            codesLengths[count++] = off;
+            idx++;
+        }
+        idx = 1;
+        off++;
+    }
+
+    codesLengths[count] = 0;
+    return count;
+}
+
+s32 JpegUtils_GetHuffmanCodes(u8* codesLengths, u16* codes) {
+    s16 idx = 0;
+    u16 code = 0;
+    u8 lastLen = codesLengths[0];
+
+    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;
+
+    codeOff = 0;
+
+    for (idx = 0; idx < 0x10; 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;
+    s32 temp;
+
+    count = JpegUtils_ParseHuffmancodesLengths(data, codesLengths);
+    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 1;
+        }
+
+        dht += 0x10;
+        ht[idx].symbols = dht;
+        dht += codeCount;
+    }
+    return 0;
+}
+
+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;
+    s16 count2;
+    s32 count;
+
+    isAc = *dht++ >> 4;
+
+    count2 = count = JpegUtils_ParseHuffmancodesLengths(dht, codesLengths);
+
+    if (count == 0 || (isAc && count > 0x100) || (!isAc && count > 0x10)) {
+        return 1;
+    }
+
+    if (JpegUtils_GetHuffmanCodes(codesLengths, codes) != count2) {
+        return 1;
+    }
+
+    JpegUtils_SetHuffmanTableOld(dht + 0x10, ht, codesLengths, codes, count2, isAc);
+
+    return 0;
+}
diff --git a/src/code/z_jpeg.c b/src/code/z_jpeg.c
index 2cbd3191b..c18a8c869 100644
--- a/src/code/z_jpeg.c
+++ b/src/code/z_jpeg.c
@@ -97,8 +97,7 @@ void Jpeg_CopyToZbuffer(u16* src, u16* zbuffer, s32 x, s32 y) {
 u16 Jpeg_GetU16(u8* ptr) {
     if (((u32)ptr & 1) == 0) { // if the address is aligned to 2
         return *(u16*)ptr;
-    }
-    else {
+    } else {
         return *(u16*)(ptr - 1) << 8 | (*(u16*)(ptr + 1) >> 8); // ?? it's exactly like *(16*)ptr
     }
 }
@@ -250,19 +249,19 @@ s32 Jpeg_Decode(void* data, u16* zbuffer, JpegWork* workBuff, u32 workSize) {
 
     switch (ctx.dqtCount) {
         case 1: {
-            func_800FF540(ctx.dqtPtr[0], &workBuff->qTables[0], 3);
+            JpegUtils_ProcessQuantizationTable(ctx.dqtPtr[0], &workBuff->qTables[0], 3);
             break;
         }
         case 2: {
-            func_800FF540(ctx.dqtPtr[0], &workBuff->qTables[0], 1);
-            func_800FF540(ctx.dqtPtr[1], &workBuff->qTables[1], 1);
-            func_800FF540(ctx.dqtPtr[1], &workBuff->qTables[2], 1);
+            JpegUtils_ProcessQuantizationTable(ctx.dqtPtr[0], &workBuff->qTables[0], 1);
+            JpegUtils_ProcessQuantizationTable(ctx.dqtPtr[1], &workBuff->qTables[1], 1);
+            JpegUtils_ProcessQuantizationTable(ctx.dqtPtr[1], &workBuff->qTables[2], 1);
             break;
         }
         case 3: {
-            func_800FF540(ctx.dqtPtr[0], &workBuff->qTables[0], 1);
-            func_800FF540(ctx.dqtPtr[1], &workBuff->qTables[1], 1);
-            func_800FF540(ctx.dqtPtr[2], &workBuff->qTables[2], 1);
+            JpegUtils_ProcessQuantizationTable(ctx.dqtPtr[0], &workBuff->qTables[0], 1);
+            JpegUtils_ProcessQuantizationTable(ctx.dqtPtr[1], &workBuff->qTables[1], 1);
+            JpegUtils_ProcessQuantizationTable(ctx.dqtPtr[2], &workBuff->qTables[2], 1);
             break;
         }
         default:
@@ -277,22 +276,27 @@ s32 Jpeg_Decode(void* data, u16* zbuffer, JpegWork* workBuff, u32 workSize) {
 
     switch (ctx.dhtCount) {
         case 1: {
-            if (func_800FF7FC(ctx.dhtPtr[0], &hTables[0], &workBuff->codesLenghts, &workBuff->codes, 4)) {
+            if (JpegUtils_ProcessHuffmanTable(ctx.dhtPtr[0], &hTables[0], &workBuff->codesLengths, &workBuff->codes,
+                                              4)) {
                 osSyncPrintf("Error : Cant' make huffman table.\n");
             }
             break;
         }
         case 4: {
-            if (func_800FF7FC(ctx.dhtPtr[0], &hTables[0], &workBuff->codesLenghts, &workBuff->codes, 1)) {
+            if (JpegUtils_ProcessHuffmanTable(ctx.dhtPtr[0], &hTables[0], &workBuff->codesLengths, &workBuff->codes,
+                                              1)) {
                 osSyncPrintf("Error : Cant' make huffman table.\n");
             }
-            if (func_800FF7FC(ctx.dhtPtr[1], &hTables[1], &workBuff->codesLenghts, &workBuff->codes, 1)) {
+            if (JpegUtils_ProcessHuffmanTable(ctx.dhtPtr[1], &hTables[1], &workBuff->codesLengths, &workBuff->codes,
+                                              1)) {
                 osSyncPrintf("Error : Cant' make huffman table.\n");
             }
-            if (func_800FF7FC(ctx.dhtPtr[2], &hTables[2], &workBuff->codesLenghts, &workBuff->codes, 1)) {
+            if (JpegUtils_ProcessHuffmanTable(ctx.dhtPtr[2], &hTables[2], &workBuff->codesLengths, &workBuff->codes,
+                                              1)) {
                 osSyncPrintf("Error : Cant' make huffman table.\n");
             }
-            if (func_800FF7FC(ctx.dhtPtr[3], &hTables[3], &workBuff->codesLenghts, &workBuff->codes, 1)) {
+            if (JpegUtils_ProcessHuffmanTable(ctx.dhtPtr[3], &hTables[3], &workBuff->codesLengths, &workBuff->codes,
+                                              1)) {
                 osSyncPrintf("Error : Cant' make huffman table.\n");
             }
             break;
diff --git a/src/code/z_quake.c b/src/code/z_quake.c
index 50db67ec5..78c05be34 100644
--- a/src/code/z_quake.c
+++ b/src/code/z_quake.c
@@ -4,6 +4,7 @@
 QuakeRequest sQuakeRequest[4];
 s16 D_80126250 = 1;
 s16 sQuakeRequestCount = 0;
+
 s16 (*sQuakeCallbacks[])(QuakeRequest*, ShakeInfo*) = {
     NULL, Quake_Callback1, Quake_Callback2, Quake_Callback3, Quake_Callback4, Quake_Callback5, Quake_Callback6,
 };