More debug code moving.

[fjl] / dehuff.c

diff --git a/dehuff.c b/dehuff.c
index 0a9fbbcf1a4bcf1b2eb9f413eca7f1784503397e..5574e27184b8de5961b01f1f76cbf0e27688c89b 100644 (file)
--- a/dehuff.c
+++ b/dehuff.c
@@ -2,41 +2,13 @@
 #include <stdlib.h>
 #include <assert.h>
 
+#include "bytesource.h"
 #include "dehuff.h"
+#include "input.h"
 
-void reliable_read(raw_input_func_t* input_func, void* userdata, uint8_t* buf, size_t len)
+void read_huffman_tables(huffman_tables_t* dst, input_func_t* input_func, void* userdata)
 {
-       while (len > 0) {
-               ssize_t bytes_read = input_func(userdata, buf, len);
-               assert(bytes_read <= len);
-
-               // TODO: We need better error handling here. setjmp()/longjmp()
-               // should hopefully do the trick, but we need to take care for
-               // suspension.
-               if (bytes_read == (ssize_t)-1) {
-                       fprintf(stderr, "Input function returned error\n");
-                       exit(1);
-               }
-               if (bytes_read == 0) {
-                       fprintf(stderr, "Premature EOF\n");
-                       exit(1);
-               }
-
-               buf += bytes_read;
-               len -= bytes_read;
-       }
-}
-
-uint16_t read_length(raw_input_func_t* input_func, void* userdata)
-{
-       uint8_t buf[2];
-       reliable_read(input_func, userdata, buf, 2);
-       return (buf[0] << 8) | buf[1];
-}
-
-void read_huffman_tables(huffman_tables_t* dst, raw_input_func_t* input_func, void* userdata)
-{
-       size_t len = read_length(input_func, userdata);
+       size_t len = read_uint16(input_func, userdata);
        assert(len > 2);
        len -= 2;
 
@@ -60,7 +32,7 @@ void read_huffman_tables(huffman_tables_t* dst, raw_input_func_t* input_func, vo
                        exit(1);
                }
 
-               struct huffman_table* tbl = dst[table_class][table_dest];
+               struct huffman_table* tbl = &((*dst)[table_class][table_dest]);
                if (len < 16) {
                        fprintf(stderr, "Short read for num_codes\n");
                        exit(1);
@@ -142,11 +114,53 @@ void read_huffman_tables(huffman_tables_t* dst, raw_input_func_t* input_func, vo
                                for (unsigned elem = prefix_min; elem < prefix_max; ++elem) {
                                        assert(tbl->lookup_table_codes[elem] == DEHUF_SLOW_PATH);
                                        assert(tbl->lookup_table_length[elem] == DEHUF_SLOW_PATH);
-                                       tbl->lookup_table_codes[elem] = k;
+                                       tbl->lookup_table_codes[elem] = tbl->codes[k];
                                        tbl->lookup_table_length[elem] = length;
                                }
                        }
                }       
+               
+               // Generate the AC lookup tables.
+               for (unsigned i = 0; i < DEHUF_AC_TABLE_SIZE; ++i) {
+                       tbl->ac_table_codes[i] = AC_DEHUF_SLOW_PATH;
+
+                       int lookup = i >> (DEHUF_AC_TABLE_BITS - DEHUF_TABLE_BITS);
+                       int rs = tbl->lookup_table_codes[lookup];
+                       unsigned length = tbl->lookup_table_length[lookup];
+                       if (rs == DEHUF_SLOW_PATH) {
+                               // Not enough bits to decode even the length.
+                               continue;
+                       }
+                       if (rs == 0x00) {
+                               // End of block.
+                               tbl->ac_table_codes[i] = 0;
+                               tbl->ac_table_length[i] = length;
+                               tbl->ac_table_skip[i] = 64;
+                               continue;
+                       }
+                       if (rs == 0xf0) {
+                               // 16 zero coefficients.
+                               tbl->ac_table_codes[i] = 0;
+                               tbl->ac_table_length[i] = length;
+                               tbl->ac_table_skip[i] = 16;
+                               continue;
+                       }
+                       
+                       unsigned r = rs >> 4;
+                       unsigned s = rs & 0xf;
+                       if (s > DEHUF_AC_TABLE_BITS - length) {
+                               // Not enough bits to decode this coefficient.
+                               continue;
+                       }
+
+                       unsigned bits = (i >> (DEHUF_AC_TABLE_BITS - length - s)) & ((1 << s) - 1);
+
+                       tbl->ac_table_codes[i] = extend(bits, s);
+                       tbl->ac_table_length[i] = length + s;
+                       tbl->ac_table_skip[i] = r + 1;
+
+                       assert(tbl->ac_table_length[i] <= DEHUF_AC_TABLE_BITS);
+               }       
        }
 
        free(buf);
@@ -158,7 +172,7 @@ unsigned read_huffman_symbol_slow_path(const struct huffman_table* table,
        unsigned code = read_bits(source, 1);
        int i = 0;
 
-       while (code > table->maxcode[i] || table->maxcode[i] == -1) {
+       while (table->maxcode[i] == -1 || code > (unsigned)table->maxcode[i]) {
                possibly_refill(source, 1);
                code = (code << 1) | read_bits(source, 1);
                ++i;