5 unsigned num_codes[17]; /* BITS */
6 unsigned char codes[256]; /* HUFFVAL */
9 unsigned huffsize[256];
10 unsigned huffcode[256];
15 struct huffman_table huffman_tables[2][4];
21 struct mem_stream streams[128];
22 char huge[1048576 * 100];
25 void *xmalloc(size_t size)
27 void *buf = malloc(size);
38 unsigned char mygetc()
44 fprintf(stderr, "Error: Unexpected end of file.\n");
52 return ((unsigned char)ch);
55 void putchar_stream(int stream, unsigned char ch)
57 int used = streams[stream].used;
59 if (streams[stream].used == streams[stream].room) {
60 streams[stream].room <<= 1;
61 streams[stream].buf = (unsigned char *)realloc(streams[stream].buf, streams[stream].room);
64 streams[stream].buf[streams[stream].used++] = ch;
67 void flush_stream(int stream)
69 fwrite(streams[stream].buf, streams[stream].used, 1, stdout);
70 streams[stream].used = 0;
73 unsigned char mygetc_limit(unsigned *len)
76 fprintf(stderr, "Error: Premature end of segment\n");
83 unsigned read_length()
85 unsigned char len1 = mygetc();
86 unsigned char len2 = mygetc();
87 unsigned len = (len1 << 8) | len2;
90 fprintf(stderr, "Error: Got length %u, expected at least 2\n", len);
97 void copy_segment(unsigned char marker_code)
99 unsigned len = read_length();
102 /* marker segment header */
104 putchar(marker_code);
108 for (i = 0; i < len - 2; ++i) {
113 void read_huffman_tables()
115 unsigned len = read_length() - 2;
123 unsigned char tc_th = mygetc_limit(&len);
124 unsigned table_class = tc_th >> 4;
125 unsigned table_dest = tc_th & 0x0f;
126 unsigned i, j, k, si;
127 struct huffman_table *tbl;
129 if (table_class != 0 && table_class != 1) {
130 fprintf(stderr, "Error: Unknown table class %u\n", table_class);
133 if (table_dest >= 4) {
134 fprintf(stderr, "Error: Unknown table destination %u\n", table_dest);
139 tbl = &huffman_tables[table_class][table_dest];
141 for (i = 0; i < 16; ++i) {
142 tbl->num_codes[i] = mygetc_limit(&len);
143 putchar(tbl->num_codes[i]);
144 fprintf(stderr, "%u ", tbl->num_codes[i]);
146 fprintf(stderr, "\ndumping tc=%u td=%u\n", table_class, table_dest);
147 for (i = 0, k = 0; i < 16; ++i) {
148 for (j = 0; j < tbl->num_codes[i]; ++j, ++k) {
149 tbl->codes[k] = mygetc_limit(&len);
150 putchar(tbl->codes[k]);
151 fprintf(stderr, "%u: len=%u, ind=%u: code=0x%02x\n", k, i+1, j, tbl->codes[k]);
155 /* generate derived tables */
157 /* generate_size_table (figure C.1) */
159 for (i = 0; i < 16; ++i) {
160 for (j = 0; j < tbl->num_codes[i]; ++j, ++k) {
161 tbl->huffsize[k] = i+1;
164 tbl->huffsize[k] = 0;
165 fprintf(stderr, "k=%u\n", k);
167 /* generate_code_table (figure C.2) */
168 si = tbl->huffsize[0];
169 for (i = 0, j = 0;; ) {
170 fprintf(stderr, "%u = %u [si=%u]\n", i, j, si);
172 tbl->huffcode[i++] = j++;
173 if (tbl->huffsize[i] == si) {
177 if (tbl->huffsize[i] == 0) {
183 } while (++si != tbl->huffsize[i]);
186 /* decoder_tables (figure F.15) */
187 for (i = 0, j = 0; i < 16; ++i) {
188 if (tbl->num_codes[i] == 0) {
189 tbl->maxcode[i] = -1;
194 //fprintf(stderr, "minind=%u\n", j);
195 tbl->mincode[i] = tbl->huffcode[j];
196 j += tbl->num_codes[i];
197 //fprintf(stderr, "maxind=%u\n", j-1);
198 tbl->maxcode[i] = tbl->huffcode[j - 1];
200 //fprintf(stderr, "%u: min=%u, max=%u\n", i, tbl->mincode[i], tbl->maxcode[i]);
209 /* procedure NEXTBIT */
210 unsigned get_bit(unsigned *bits_available, unsigned char *bit_reservoir)
214 if (*bits_available == 0) {
215 *bit_reservoir = mygetc();
216 //fprintf(stderr, "Read byte (0x%02x)\n", *bit_reservoir);
217 if (*bit_reservoir == 0xff) {
218 unsigned char ch = mygetc();
221 for (i = 0; i < 128; ++i) {
225 fprintf(stderr, "Error: Couldn't handle marker 0x%02x\n", ch);
228 //fprintf(stderr, "Read stuff byte (%u)\n", ch);
234 bit = *bit_reservoir >> 7;
235 *bit_reservoir = (*bit_reservoir & 0x7f) << 1;
238 //fprintf(stderr, "%u\n", bit);
243 /* procedure DECODE (figure F.16) */
244 unsigned char get_huffman_byte(unsigned *bits_available, unsigned char *bit_reservoir, struct huffman_table* huff_tbl)
246 unsigned code = get_bit(bits_available, bit_reservoir);
249 while (code > huff_tbl->maxcode[i - 1] || huff_tbl->maxcode[i - 1] == -1) {
250 code = (code << 1) | get_bit(bits_available, bit_reservoir);
254 fprintf(stderr, "Error in Huffman decoding: Too long code (%x).numch=%u\n", code, numch);
259 /*fprintf(stderr, "h=%d => code=0x%02x\n", huff_tbl->valptr[i - 1] + code - huff_tbl->mincode[i - 1],
260 huff_tbl->codes[huff_tbl->valptr[i - 1] + code - huff_tbl->mincode[i - 1]]);*/
261 return huff_tbl->codes[huff_tbl->valptr[i - 1] + code - huff_tbl->mincode[i - 1]];
264 /* procedure RECEIVE */
265 unsigned get_bits(unsigned num_bits, unsigned *bits_available, unsigned char *bit_reservoir)
269 for (i = 0; i < num_bits; ++i) {
271 val |= get_bit(bits_available, bit_reservoir);
277 /* procedure EXTEND (figure F.12) */
278 unsigned extend(int val, int bits)
280 if (val < (1 << (bits - 1))) {
281 return val + (-1 << bits) + 1;
289 unsigned len = read_length() - 2;
290 unsigned bits_available;
291 unsigned char bit_reservoir;
292 unsigned num_components = mygetc_limit(&len);
294 unsigned component_num[256];
295 unsigned dc_huffman_table[256], ac_huffman_table[256];
296 unsigned ss, se, ah_al;
300 for (i = 0; i < num_components; ++i) {
302 component_num[i] = mygetc_limit(&len);
303 td_ta = mygetc_limit(&len);
304 dc_huffman_table[i] = td_ta >> 4;
305 ac_huffman_table[i] = td_ta & 0x0f;
310 for (j = 0; j < 64; ++j) {
316 ss = mygetc_limit(&len);
317 se = mygetc_limit(&len);
318 ah_al = mygetc_limit(&len);
321 fprintf(stderr, "Error: %u unused bytes at end of SOS segment\n", len);
327 //fprintf(stderr, "new scan, now\n");
330 for (c = 0; c < num_components; ++c) {
332 //fprintf(stderr, "coeff %u\n", c);
333 //fprintf(stderr, "getting dc (table %u)\n", dc_huffman_table[c]);
335 /* decode DC component */
336 unsigned char dc_category = get_huffman_byte(&bits_available, &bit_reservoir, &huffman_tables[0][dc_huffman_table[c]]);
340 dc_diff = get_bits(dc_category, &bits_available, &bit_reservoir);
341 last_dc[c] += extend(dc_diff, dc_category);
343 /*putchar_stream(0, last_dc[c] >> 8);
344 putchar_stream(0, last_dc[c] & 0xff); */
345 huge[num_huge++] = dc_diff >> 8;
346 huge[num_huge++] = dc_diff & 0xff;
348 for (i = 0; i < 63; ++i) {
352 for (i = 0; i < 63; ++i) {
353 unsigned char rs = get_huffman_byte(&bits_available, &bit_reservoir, &huffman_tables[1][ac_huffman_table[c]]);
354 unsigned char r = rs >> 4;
355 unsigned char s = rs & 0xf;
362 /* 16 zero coefficients */
368 zz[i] = extend(get_bits(s, &bits_available, &bit_reservoir), s);
371 for (i = 0; i < 63; ++i) {
383 huge[num_huge++] = m >> 8;
384 huge[num_huge++] = m & 0xff;
393 for (i = 0; i < 128; ++i) {
394 streams[i].buf = (unsigned char *)malloc(4096);
396 streams[i].room = 4096;
400 unsigned char m1 = mygetc();
401 unsigned char m2 = mygetc();
404 fprintf(stderr, "Error: Expected marker (0xff), got 0x%02x\n", m1);
425 /* APP0 through APPF */
429 /* SOF0 (baseline DCT, Huffman encoded) */
438 /* DHT (define Huffman tables) */
439 read_huffman_tables();
442 /* SOS (start of scan) */
446 fprintf(stderr, "Error: Unknown marker 0x%02x\n", m2);