Kill AC_END_OF_BLOCK as well.

diff --git a/dehuff.c b/dehuff.c
index f08dd881adee0bab2256f8b171f1423821a1f331..5574e27184b8de5961b01f1f76cbf0e27688c89b 100644 (file)
--- a/dehuff.c
+++ b/dehuff.c
@@ -133,9 +133,9 @@ void read_huffman_tables(huffman_tables_t* dst, input_func_t* input_func, void*
                        }
                        if (rs == 0x00) {
                                // End of block.
-                               tbl->ac_table_codes[i] = AC_END_OF_BLOCK;
+                               tbl->ac_table_codes[i] = 0;
                                tbl->ac_table_length[i] = length;
-                               tbl->ac_table_skip[i] = 1;
+                               tbl->ac_table_skip[i] = 64;
                                continue;
                        }
                        if (rs == 0xf0) {

diff --git a/dehuff.h b/dehuff.h
index 92c2affb5a810eab89c214ce031482961b55a799..c54f68a55bf38528c629131b7802e71c3b9eda5d 100644 (file)
--- a/dehuff.h
+++ b/dehuff.h
@@ -20,7 +20,6 @@ static const int DEHUF_SLOW_PATH = -1;
 #define DEHUF_AC_TABLE_BITS 10
 #define DEHUF_AC_TABLE_SIZE (1 << DEHUF_AC_TABLE_BITS)
 static const int AC_DEHUF_SLOW_PATH = 0xf0000000;
-static const int AC_END_OF_BLOCK = 0xf0000001;
 
 struct huffman_table {
        unsigned num_codes[17];     // BITS

diff --git a/driver.c b/driver.c
index f24b0f50964d18d4271fc1f104f59597f9928f4f..f07e63e2679edc37263dddeafeb3a71071d712c0 100644 (file)
--- a/driver.c
+++ b/driver.c
@@ -116,38 +116,33 @@ void read_sof(struct byte_source* source, struct jpeg_image* image)
 
 void decode_ac_coefficients(const struct huffman_table* tbl, struct bit_source* bits, int16_t* coeff)
 {
+       possibly_refill(bits, DEHUF_AC_TABLE_BITS);
        for (unsigned i = 0; i < DCTSIZE2 - 1; ) {
-               possibly_refill(bits, DEHUF_AC_TABLE_BITS);
                unsigned lookup = peek_bits(bits, DEHUF_AC_TABLE_BITS);
                int code = tbl->ac_table_codes[lookup];
+               unsigned length = tbl->ac_table_length[lookup];
+               unsigned r = tbl->ac_table_skip[lookup];
 
                if (__builtin_expect(code == AC_DEHUF_SLOW_PATH, 0)) {
                        unsigned rs = read_huffman_symbol_no_refill(tbl, bits);
-                       unsigned r = rs >> 4;
-                       unsigned s = rs & 0xf;
-                       i += r + 1;
-                       possibly_refill(bits, s);
-
                        if (rs == 0x00) {
                                /* end of block */
                                break;
                        }
-                       if (rs == 0xf0) {
-                               /* 16 zero coefficients */
-                               continue;
-                       }
 
+                       unsigned r = rs >> 4;
+                       unsigned s = rs & 0xf;
+                       i += r + 1;
+                       possibly_refill(bits, s);
                        coeff[unzigzag[i]] = extend(read_bits(bits, s), s);
+                       possibly_refill(bits, DEHUF_AC_TABLE_BITS);
                } else {
-                       unsigned length = tbl->ac_table_length[lookup];
-                       int r = tbl->ac_table_skip[lookup];
-                       assert(r >= 1);
-                       i += r;
                        assert(bits->bits_available >= length);
                        read_bits(bits, length);
-                       if (code == AC_END_OF_BLOCK) {
-                               break;
-                       }
+                       possibly_refill(bits, DEHUF_AC_TABLE_BITS);
+
+                       assert(r >= 1);
+                       i += r;
                        coeff[unzigzag[i]] = code;
                }
        }

diff --git a/zigzag.h b/zigzag.h
index 3fc137710581211a137edc7d84633bee0c653b1e..5d9df28ec457e9a048587d14ae81321d714a5b98 100644 (file)
--- a/zigzag.h
+++ b/zigzag.h
@@ -4,10 +4,10 @@
 #include "idct.h"
 
 // Table for transforming from zig-zag order to natural order.
-// We use the same trick as libjpeg here; there are 16 extra entries
+// We use the same trick as libjpeg here; there are 64 extra entries
 // after the end of the table, since the run-length decoder could
 // potentially cause entries indices >= 64 to be decoded.
-static const unsigned unzigzag[DCTSIZE2 + 16] = {
+static const unsigned unzigzag[DCTSIZE2 * 2] = {
        // Regular entries.
         0,  1,  8, 16,  9,  2,  3, 10,
        17, 24, 32, 25, 18, 11,  4,  5,
@@ -18,7 +18,14 @@ static const unsigned unzigzag[DCTSIZE2 + 16] = {
        58, 59, 52, 45, 38, 31, 39, 46,
        53, 60, 61, 54, 47, 55, 62, 63,
 
-       // Extra padding entries; should never be referenced in well-formed data.
+       // Extra padding entries.
+       // May get referenced by malformed data or during end-of-block processing.
+       63, 63, 63, 63, 63, 63, 63, 63,
+       63, 63, 63, 63, 63, 63, 63, 63,
+       63, 63, 63, 63, 63, 63, 63, 63,
+       63, 63, 63, 63, 63, 63, 63, 63,
+       63, 63, 63, 63, 63, 63, 63, 63,
+       63, 63, 63, 63, 63, 63, 63, 63,
        63, 63, 63, 63, 63, 63, 63, 63,
        63, 63, 63, 63, 63, 63, 63, 63,
 };