1 : /*
2 : * jdhuff.c
3 : *
4 : * Copyright (C) 1991-1997, Thomas G. Lane.
5 : * Copyright (C) 2009-2011, D. R. Commander.
6 : * This file is part of the Independent JPEG Group's software.
7 : * For conditions of distribution and use, see the accompanying README file.
8 : *
9 : * This file contains Huffman entropy decoding routines.
10 : *
11 : * Much of the complexity here has to do with supporting input suspension.
12 : * If the data source module demands suspension, we want to be able to back
13 : * up to the start of the current MCU. To do this, we copy state variables
14 : * into local working storage, and update them back to the permanent
15 : * storage only upon successful completion of an MCU.
16 : */
17 :
18 : #define JPEG_INTERNALS
19 : #include "jinclude.h"
20 : #include "jpeglib.h"
21 : #include "jdhuff.h" /* Declarations shared with jdphuff.c */
22 : #include "jpegcomp.h"
23 :
24 :
25 : /*
26 : * Expanded entropy decoder object for Huffman decoding.
27 : *
28 : * The savable_state subrecord contains fields that change within an MCU,
29 : * but must not be updated permanently until we complete the MCU.
30 : */
31 :
32 : typedef struct {
33 : int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
34 : } savable_state;
35 :
36 : /* This macro is to work around compilers with missing or broken
37 : * structure assignment. You'll need to fix this code if you have
38 : * such a compiler and you change MAX_COMPS_IN_SCAN.
39 : */
40 :
41 : #ifndef NO_STRUCT_ASSIGN
42 : #define ASSIGN_STATE(dest,src) ((dest) = (src))
43 : #else
44 : #if MAX_COMPS_IN_SCAN == 4
45 : #define ASSIGN_STATE(dest,src) \
46 : ((dest).last_dc_val[0] = (src).last_dc_val[0], \
47 : (dest).last_dc_val[1] = (src).last_dc_val[1], \
48 : (dest).last_dc_val[2] = (src).last_dc_val[2], \
49 : (dest).last_dc_val[3] = (src).last_dc_val[3])
50 : #endif
51 : #endif
52 :
53 :
54 : typedef struct {
55 : struct jpeg_entropy_decoder pub; /* public fields */
56 :
57 : /* These fields are loaded into local variables at start of each MCU.
58 : * In case of suspension, we exit WITHOUT updating them.
59 : */
60 : bitread_perm_state bitstate; /* Bit buffer at start of MCU */
61 : savable_state saved; /* Other state at start of MCU */
62 :
63 : /* These fields are NOT loaded into local working state. */
64 : unsigned int restarts_to_go; /* MCUs left in this restart interval */
65 :
66 : /* Pointers to derived tables (these workspaces have image lifespan) */
67 : d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
68 : d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
69 :
70 : /* Precalculated info set up by start_pass for use in decode_mcu: */
71 :
72 : /* Pointers to derived tables to be used for each block within an MCU */
73 : d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
74 : d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
75 : /* Whether we care about the DC and AC coefficient values for each block */
76 : boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
77 : boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
78 : } huff_entropy_decoder;
79 :
80 : typedef huff_entropy_decoder * huff_entropy_ptr;
81 :
82 :
83 : /*
84 : * Initialize for a Huffman-compressed scan.
85 : */
86 :
87 : METHODDEF(void)
88 5 : start_pass_huff_decoder (j_decompress_ptr cinfo)
89 : {
90 5 : huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
91 : int ci, blkn, dctbl, actbl;
92 : jpeg_component_info * compptr;
93 :
94 : /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
95 : * This ought to be an error condition, but we make it a warning because
96 : * there are some baseline files out there with all zeroes in these bytes.
97 : */
98 10 : if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
99 10 : cinfo->Ah != 0 || cinfo->Al != 0)
100 0 : WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
101 :
102 20 : for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
103 15 : compptr = cinfo->cur_comp_info[ci];
104 15 : dctbl = compptr->dc_tbl_no;
105 15 : actbl = compptr->ac_tbl_no;
106 : /* Compute derived values for Huffman tables */
107 : /* We may do this more than once for a table, but it's not expensive */
108 30 : jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
109 30 : & entropy->dc_derived_tbls[dctbl]);
110 30 : jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
111 30 : & entropy->ac_derived_tbls[actbl]);
112 : /* Initialize DC predictions to 0 */
113 15 : entropy->saved.last_dc_val[ci] = 0;
114 : }
115 :
116 : /* Precalculate decoding info for each block in an MCU of this scan */
117 35 : for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
118 30 : ci = cinfo->MCU_membership[blkn];
119 30 : compptr = cinfo->cur_comp_info[ci];
120 : /* Precalculate which table to use for each block */
121 30 : entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
122 30 : entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
123 : /* Decide whether we really care about the coefficient values */
124 30 : if (compptr->component_needed) {
125 30 : entropy->dc_needed[blkn] = TRUE;
126 : /* we don't need the ACs if producing a 1/8th-size image */
127 30 : entropy->ac_needed[blkn] = (compptr->_DCT_scaled_size > 1);
128 : } else {
129 0 : entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
130 : }
131 : }
132 :
133 : /* Initialize bitread state variables */
134 5 : entropy->bitstate.bits_left = 0;
135 5 : entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
136 5 : entropy->pub.insufficient_data = FALSE;
137 :
138 : /* Initialize restart counter */
139 5 : entropy->restarts_to_go = cinfo->restart_interval;
140 5 : }
141 :
142 :
143 : /*
144 : * Compute the derived values for a Huffman table.
145 : * This routine also performs some validation checks on the table.
146 : *
147 : * Note this is also used by jdphuff.c.
148 : */
149 :
150 : GLOBAL(void)
151 30 : jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
152 : d_derived_tbl ** pdtbl)
153 : {
154 : JHUFF_TBL *htbl;
155 : d_derived_tbl *dtbl;
156 : int p, i, l, si, numsymbols;
157 : int lookbits, ctr;
158 : char huffsize[257];
159 : unsigned int huffcode[257];
160 : unsigned int code;
161 :
162 : /* Note that huffsize[] and huffcode[] are filled in code-length order,
163 : * paralleling the order of the symbols themselves in htbl->huffval[].
164 : */
165 :
166 : /* Find the input Huffman table */
167 30 : if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
168 0 : ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
169 30 : htbl =
170 30 : isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
171 30 : if (htbl == NULL)
172 0 : ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
173 :
174 : /* Allocate a workspace if we haven't already done so. */
175 30 : if (*pdtbl == NULL)
176 20 : *pdtbl = (d_derived_tbl *)
177 20 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
178 : SIZEOF(d_derived_tbl));
179 30 : dtbl = *pdtbl;
180 30 : dtbl->pub = htbl; /* fill in back link */
181 :
182 : /* Figure C.1: make table of Huffman code length for each symbol */
183 :
184 30 : p = 0;
185 510 : for (l = 1; l <= 16; l++) {
186 480 : i = (int) htbl->bits[l];
187 480 : if (i < 0 || p + i > 256) /* protect against table overrun */
188 0 : ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
189 3570 : while (i--)
190 2610 : huffsize[p++] = (char) l;
191 : }
192 30 : huffsize[p] = 0;
193 30 : numsymbols = p;
194 :
195 : /* Figure C.2: generate the codes themselves */
196 : /* We also validate that the counts represent a legal Huffman code tree. */
197 :
198 30 : code = 0;
199 30 : si = huffsize[0];
200 30 : p = 0;
201 425 : while (huffsize[p]) {
202 3340 : while (((int) huffsize[p]) == si) {
203 2610 : huffcode[p++] = code;
204 2610 : code++;
205 : }
206 : /* code is now 1 more than the last code used for codelength si; but
207 : * it must still fit in si bits, since no code is allowed to be all ones.
208 : */
209 365 : if (((INT32) code) >= (((INT32) 1) << si))
210 0 : ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
211 365 : code <<= 1;
212 365 : si++;
213 : }
214 :
215 : /* Figure F.15: generate decoding tables for bit-sequential decoding */
216 :
217 30 : p = 0;
218 510 : for (l = 1; l <= 16; l++) {
219 480 : if (htbl->bits[l]) {
220 : /* valoffset[l] = huffval[] index of 1st symbol of code length l,
221 : * minus the minimum code of length l
222 : */
223 345 : dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
224 345 : p += htbl->bits[l];
225 345 : dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
226 : } else {
227 135 : dtbl->maxcode[l] = -1; /* -1 if no codes of this length */
228 : }
229 : }
230 30 : dtbl->valoffset[17] = 0;
231 30 : dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
232 :
233 : /* Compute lookahead tables to speed up decoding.
234 : * First we set all the table entries to 0, indicating "too long";
235 : * then we iterate through the Huffman codes that are short enough and
236 : * fill in all the entries that correspond to bit sequences starting
237 : * with that code.
238 : */
239 :
240 7710 : for (i = 0; i < (1 << HUFF_LOOKAHEAD); i++)
241 7680 : dtbl->lookup[i] = (HUFF_LOOKAHEAD + 1) << HUFF_LOOKAHEAD;
242 :
243 30 : p = 0;
244 270 : for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
245 675 : for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
246 : /* l = current code's length, p = its index in huffcode[] & huffval[]. */
247 : /* Generate left-justified code followed by all possible bit sequences */
248 435 : lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
249 8015 : for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
250 7580 : dtbl->lookup[lookbits] = (l << HUFF_LOOKAHEAD) | htbl->huffval[p];
251 7580 : lookbits++;
252 : }
253 : }
254 : }
255 :
256 : /* Validate symbols as being reasonable.
257 : * For AC tables, we make no check, but accept all byte values 0..255.
258 : * For DC tables, we require the symbols to be in range 0..15.
259 : * (Tighter bounds could be applied depending on the data depth and mode,
260 : * but this is sufficient to ensure safe decoding.)
261 : */
262 30 : if (isDC) {
263 195 : for (i = 0; i < numsymbols; i++) {
264 180 : int sym = htbl->huffval[i];
265 180 : if (sym < 0 || sym > 15)
266 0 : ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
267 : }
268 : }
269 30 : }
270 :
271 :
272 : /*
273 : * Out-of-line code for bit fetching (shared with jdphuff.c).
274 : * See jdhuff.h for info about usage.
275 : * Note: current values of get_buffer and bits_left are passed as parameters,
276 : * but are returned in the corresponding fields of the state struct.
277 : *
278 : * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
279 : * of get_buffer to be used. (On machines with wider words, an even larger
280 : * buffer could be used.) However, on some machines 32-bit shifts are
281 : * quite slow and take time proportional to the number of places shifted.
282 : * (This is true with most PC compilers, for instance.) In this case it may
283 : * be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the
284 : * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
285 : */
286 :
287 : #ifdef SLOW_SHIFT_32
288 : #define MIN_GET_BITS 15 /* minimum allowable value */
289 : #else
290 : #define MIN_GET_BITS (BIT_BUF_SIZE-7)
291 : #endif
292 :
293 :
294 : GLOBAL(boolean)
295 1059 : jpeg_fill_bit_buffer (bitread_working_state * state,
296 : register bit_buf_type get_buffer, register int bits_left,
297 : int nbits)
298 : /* Load up the bit buffer to a depth of at least nbits */
299 : {
300 : /* Copy heavily used state fields into locals (hopefully registers) */
301 1059 : register const JOCTET * next_input_byte = state->next_input_byte;
302 1059 : register size_t bytes_in_buffer = state->bytes_in_buffer;
303 1059 : j_decompress_ptr cinfo = state->cinfo;
304 :
305 : /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
306 : /* (It is assumed that no request will be for more than that many bits.) */
307 : /* We fail to do so only if we hit a marker or are forced to suspend. */
308 :
309 1059 : if (cinfo->unread_marker == 0) { /* cannot advance past a marker */
310 5392 : while (bits_left < MIN_GET_BITS) {
311 : register int c;
312 :
313 : /* Attempt to read a byte */
314 3293 : if (bytes_in_buffer == 0) {
315 2 : if (! (*cinfo->src->fill_input_buffer) (cinfo))
316 1 : return FALSE;
317 1 : next_input_byte = cinfo->src->next_input_byte;
318 1 : bytes_in_buffer = cinfo->src->bytes_in_buffer;
319 : }
320 3292 : bytes_in_buffer--;
321 3292 : c = GETJOCTET(*next_input_byte++);
322 :
323 : /* If it's 0xFF, check and discard stuffed zero byte */
324 3292 : if (c == 0xFF) {
325 : /* Loop here to discard any padding FF's on terminating marker,
326 : * so that we can save a valid unread_marker value. NOTE: we will
327 : * accept multiple FF's followed by a 0 as meaning a single FF data
328 : * byte. This data pattern is not valid according to the standard.
329 : */
330 : do {
331 50 : if (bytes_in_buffer == 0) {
332 2 : if (! (*cinfo->src->fill_input_buffer) (cinfo))
333 1 : return FALSE;
334 1 : next_input_byte = cinfo->src->next_input_byte;
335 1 : bytes_in_buffer = cinfo->src->bytes_in_buffer;
336 : }
337 49 : bytes_in_buffer--;
338 49 : c = GETJOCTET(*next_input_byte++);
339 49 : } while (c == 0xFF);
340 :
341 49 : if (c == 0) {
342 : /* Found FF/00, which represents an FF data byte */
343 46 : c = 0xFF;
344 : } else {
345 : /* Oops, it's actually a marker indicating end of compressed data.
346 : * Save the marker code for later use.
347 : * Fine point: it might appear that we should save the marker into
348 : * bitread working state, not straight into permanent state. But
349 : * once we have hit a marker, we cannot need to suspend within the
350 : * current MCU, because we will read no more bytes from the data
351 : * source. So it is OK to update permanent state right away.
352 : */
353 3 : cinfo->unread_marker = c;
354 : /* See if we need to insert some fake zero bits. */
355 3 : goto no_more_bytes;
356 : }
357 : }
358 :
359 : /* OK, load c into get_buffer */
360 3288 : get_buffer = (get_buffer << 8) | c;
361 3288 : bits_left += 8;
362 : } /* end while */
363 : } else {
364 : no_more_bytes:
365 : /* We get here if we've read the marker that terminates the compressed
366 : * data segment. There should be enough bits in the buffer register
367 : * to satisfy the request; if so, no problem.
368 : */
369 10 : if (nbits > bits_left) {
370 : /* Uh-oh. Report corrupted data to user and stuff zeroes into
371 : * the data stream, so that we can produce some kind of image.
372 : * We use a nonvolatile flag to ensure that only one warning message
373 : * appears per data segment.
374 : */
375 0 : if (! cinfo->entropy->insufficient_data) {
376 0 : WARNMS(cinfo, JWRN_HIT_MARKER);
377 0 : cinfo->entropy->insufficient_data = TRUE;
378 : }
379 : /* Fill the buffer with zero bits */
380 0 : get_buffer <<= MIN_GET_BITS - bits_left;
381 0 : bits_left = MIN_GET_BITS;
382 : }
383 : }
384 :
385 : /* Unload the local registers */
386 1057 : state->next_input_byte = next_input_byte;
387 1057 : state->bytes_in_buffer = bytes_in_buffer;
388 1057 : state->get_buffer = get_buffer;
389 1057 : state->bits_left = bits_left;
390 :
391 1057 : return TRUE;
392 : }
393 :
394 :
395 : /* Macro version of the above, which performs much better but does not
396 : handle markers. We have to hand off any blocks with markers to the
397 : slower routines. */
398 :
399 : #define GET_BYTE \
400 : { \
401 : register int c0, c1; \
402 : c0 = GETJOCTET(*buffer++); \
403 : c1 = GETJOCTET(*buffer); \
404 : /* Pre-execute most common case */ \
405 : get_buffer = (get_buffer << 8) | c0; \
406 : bits_left += 8; \
407 : if (c0 == 0xFF) { \
408 : /* Pre-execute case of FF/00, which represents an FF data byte */ \
409 : buffer++; \
410 : if (c1 != 0) { \
411 : /* Oops, it's actually a marker indicating end of compressed data. */ \
412 : cinfo->unread_marker = c1; \
413 : /* Back out pre-execution and fill the buffer with zero bits */ \
414 : buffer -= 2; \
415 : get_buffer &= ~0xFF; \
416 : } \
417 : } \
418 : }
419 :
420 : #if __WORDSIZE == 64 || defined(_WIN64)
421 :
422 : /* Pre-fetch 48 bytes, because the holding register is 64-bit */
423 : #define FILL_BIT_BUFFER_FAST \
424 : if (bits_left < 16) { \
425 : GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE \
426 : }
427 :
428 : #else
429 :
430 : /* Pre-fetch 16 bytes, because the holding register is 32-bit */
431 : #define FILL_BIT_BUFFER_FAST \
432 : if (bits_left < 16) { \
433 : GET_BYTE GET_BYTE \
434 : }
435 :
436 : #endif
437 :
438 :
439 : /*
440 : * Out-of-line code for Huffman code decoding.
441 : * See jdhuff.h for info about usage.
442 : */
443 :
444 : GLOBAL(int)
445 370 : jpeg_huff_decode (bitread_working_state * state,
446 : register bit_buf_type get_buffer, register int bits_left,
447 : d_derived_tbl * htbl, int min_bits)
448 : {
449 370 : register int l = min_bits;
450 : register INT32 code;
451 :
452 : /* HUFF_DECODE has determined that the code is at least min_bits */
453 : /* bits long, so fetch that many bits in one swoop. */
454 :
455 370 : CHECK_BIT_BUFFER(*state, l, return -1);
456 370 : code = GET_BITS(l);
457 :
458 : /* Collect the rest of the Huffman code one bit at a time. */
459 : /* This is per Figure F.16 in the JPEG spec. */
460 :
461 2468 : while (code > htbl->maxcode[l]) {
462 1728 : code <<= 1;
463 1728 : CHECK_BIT_BUFFER(*state, 1, return -1);
464 1728 : code |= GET_BITS(1);
465 1728 : l++;
466 : }
467 :
468 : /* Unload the local registers */
469 370 : state->get_buffer = get_buffer;
470 370 : state->bits_left = bits_left;
471 :
472 : /* With garbage input we may reach the sentinel value l = 17. */
473 :
474 370 : if (l > 16) {
475 0 : WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
476 0 : return 0; /* fake a zero as the safest result */
477 : }
478 :
479 370 : return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
480 : }
481 :
482 :
483 : /*
484 : * Figure F.12: extend sign bit.
485 : * On some machines, a shift and add will be faster than a table lookup.
486 : */
487 :
488 : #define AVOID_TABLES
489 : #ifdef AVOID_TABLES
490 :
491 : #define HUFF_EXTEND(x,s) ((x) + ((((x) - (1<<((s)-1))) >> 31) & (((-1)<<(s)) + 1)))
492 :
493 : #else
494 :
495 : #define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
496 :
497 : static const int extend_test[16] = /* entry n is 2**(n-1) */
498 : { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
499 : 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
500 :
501 : static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
502 : { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
503 : ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
504 : ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
505 : ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
506 :
507 : #endif /* AVOID_TABLES */
508 :
509 :
510 : /*
511 : * Check for a restart marker & resynchronize decoder.
512 : * Returns FALSE if must suspend.
513 : */
514 :
515 : LOCAL(boolean)
516 0 : process_restart (j_decompress_ptr cinfo)
517 : {
518 0 : huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
519 : int ci;
520 :
521 : /* Throw away any unused bits remaining in bit buffer; */
522 : /* include any full bytes in next_marker's count of discarded bytes */
523 0 : cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
524 0 : entropy->bitstate.bits_left = 0;
525 :
526 : /* Advance past the RSTn marker */
527 0 : if (! (*cinfo->marker->read_restart_marker) (cinfo))
528 0 : return FALSE;
529 :
530 : /* Re-initialize DC predictions to 0 */
531 0 : for (ci = 0; ci < cinfo->comps_in_scan; ci++)
532 0 : entropy->saved.last_dc_val[ci] = 0;
533 :
534 : /* Reset restart counter */
535 0 : entropy->restarts_to_go = cinfo->restart_interval;
536 :
537 : /* Reset out-of-data flag, unless read_restart_marker left us smack up
538 : * against a marker. In that case we will end up treating the next data
539 : * segment as empty, and we can avoid producing bogus output pixels by
540 : * leaving the flag set.
541 : */
542 0 : if (cinfo->unread_marker == 0)
543 0 : entropy->pub.insufficient_data = FALSE;
544 :
545 0 : return TRUE;
546 : }
547 :
548 :
549 : LOCAL(boolean)
550 27 : decode_mcu_slow (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
551 : {
552 27 : huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
553 : BITREAD_STATE_VARS;
554 : int blkn;
555 : savable_state state;
556 : /* Outer loop handles each block in the MCU */
557 :
558 : /* Load up working state */
559 27 : BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
560 27 : ASSIGN_STATE(state, entropy->saved);
561 :
562 185 : for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
563 160 : JBLOCKROW block = MCU_data[blkn];
564 160 : d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
565 160 : d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
566 : register int s, k, r;
567 :
568 : /* Decode a single block's worth of coefficients */
569 :
570 : /* Section F.2.2.1: decode the DC coefficient difference */
571 160 : HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
572 160 : if (s) {
573 37 : CHECK_BIT_BUFFER(br_state, s, return FALSE);
574 37 : r = GET_BITS(s);
575 37 : s = HUFF_EXTEND(r, s);
576 : }
577 :
578 160 : if (entropy->dc_needed[blkn]) {
579 : /* Convert DC difference to actual value, update last_dc_val */
580 160 : int ci = cinfo->MCU_membership[blkn];
581 160 : s += state.last_dc_val[ci];
582 160 : state.last_dc_val[ci] = s;
583 : /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
584 160 : (*block)[0] = (JCOEF) s;
585 : }
586 :
587 160 : if (entropy->ac_needed[blkn]) {
588 :
589 : /* Section F.2.2.2: decode the AC coefficients */
590 : /* Since zeroes are skipped, output area must be cleared beforehand */
591 2522 : for (k = 1; k < DCTSIZE2; k++) {
592 2489 : HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
593 :
594 2487 : r = s >> 4;
595 2487 : s &= 15;
596 :
597 2487 : if (s) {
598 2362 : k += r;
599 2362 : CHECK_BIT_BUFFER(br_state, s, return FALSE);
600 2362 : r = GET_BITS(s);
601 2362 : s = HUFF_EXTEND(r, s);
602 : /* Output coefficient in natural (dezigzagged) order.
603 : * Note: the extra entries in jpeg_natural_order[] will save us
604 : * if k >= DCTSIZE2, which could happen if the data is corrupted.
605 : */
606 2362 : (*block)[jpeg_natural_order[k]] = (JCOEF) s;
607 : } else {
608 125 : if (r != 15)
609 125 : break;
610 0 : k += 15;
611 : }
612 : }
613 :
614 : } else {
615 :
616 : /* Section F.2.2.2: decode the AC coefficients */
617 : /* In this path we just discard the values */
618 0 : for (k = 1; k < DCTSIZE2; k++) {
619 0 : HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
620 :
621 0 : r = s >> 4;
622 0 : s &= 15;
623 :
624 0 : if (s) {
625 0 : k += r;
626 0 : CHECK_BIT_BUFFER(br_state, s, return FALSE);
627 0 : DROP_BITS(s);
628 : } else {
629 0 : if (r != 15)
630 0 : break;
631 0 : k += 15;
632 : }
633 : }
634 : }
635 : }
636 :
637 : /* Completed MCU, so update state */
638 25 : BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
639 25 : ASSIGN_STATE(entropy->saved, state);
640 25 : return TRUE;
641 : }
642 :
643 :
644 : LOCAL(boolean)
645 4 : decode_mcu_fast (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
646 : {
647 4 : huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
648 : BITREAD_STATE_VARS;
649 : JOCTET *buffer;
650 : int blkn;
651 : savable_state state;
652 : /* Outer loop handles each block in the MCU */
653 :
654 : /* Load up working state */
655 4 : BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
656 4 : buffer = (JOCTET *) br_state.next_input_byte;
657 4 : ASSIGN_STATE(state, entropy->saved);
658 :
659 28 : for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
660 24 : JBLOCKROW block = MCU_data[blkn];
661 24 : d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
662 24 : d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
663 : register int s, k, r, l;
664 :
665 24 : HUFF_DECODE_FAST(s, l, dctbl);
666 24 : if (s) {
667 24 : FILL_BIT_BUFFER_FAST
668 24 : r = GET_BITS(s);
669 24 : s = HUFF_EXTEND(r, s);
670 : }
671 :
672 24 : if (entropy->dc_needed[blkn]) {
673 24 : int ci = cinfo->MCU_membership[blkn];
674 24 : s += state.last_dc_val[ci];
675 24 : state.last_dc_val[ci] = s;
676 24 : (*block)[0] = (JCOEF) s;
677 : }
678 :
679 24 : if (entropy->ac_needed[blkn]) {
680 :
681 1497 : for (k = 1; k < DCTSIZE2; k++) {
682 1473 : HUFF_DECODE_FAST(s, l, actbl);
683 1473 : r = s >> 4;
684 1473 : s &= 15;
685 :
686 1473 : if (s) {
687 1473 : k += r;
688 1473 : FILL_BIT_BUFFER_FAST
689 1473 : r = GET_BITS(s);
690 1473 : s = HUFF_EXTEND(r, s);
691 1473 : (*block)[jpeg_natural_order[k]] = (JCOEF) s;
692 : } else {
693 0 : if (r != 15) break;
694 0 : k += 15;
695 : }
696 : }
697 :
698 : } else {
699 :
700 0 : for (k = 1; k < DCTSIZE2; k++) {
701 0 : HUFF_DECODE_FAST(s, l, actbl);
702 0 : r = s >> 4;
703 0 : s &= 15;
704 :
705 0 : if (s) {
706 0 : k += r;
707 0 : FILL_BIT_BUFFER_FAST
708 0 : DROP_BITS(s);
709 : } else {
710 0 : if (r != 15) break;
711 0 : k += 15;
712 : }
713 : }
714 : }
715 : }
716 :
717 4 : if (cinfo->unread_marker != 0) {
718 0 : cinfo->unread_marker = 0;
719 0 : return FALSE;
720 : }
721 :
722 4 : br_state.bytes_in_buffer -= (buffer - br_state.next_input_byte);
723 4 : br_state.next_input_byte = buffer;
724 4 : BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
725 4 : ASSIGN_STATE(entropy->saved, state);
726 4 : return TRUE;
727 : }
728 :
729 :
730 : /*
731 : * Decode and return one MCU's worth of Huffman-compressed coefficients.
732 : * The coefficients are reordered from zigzag order into natural array order,
733 : * but are not dequantized.
734 : *
735 : * The i'th block of the MCU is stored into the block pointed to by
736 : * MCU_data[i]. WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
737 : * (Wholesale zeroing is usually a little faster than retail...)
738 : *
739 : * Returns FALSE if data source requested suspension. In that case no
740 : * changes have been made to permanent state. (Exception: some output
741 : * coefficients may already have been assigned. This is harmless for
742 : * this module, since we'll just re-assign them on the next call.)
743 : */
744 :
745 : #define BUFSIZE (DCTSIZE2 * 2)
746 :
747 : METHODDEF(boolean)
748 31 : decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
749 : {
750 31 : huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
751 31 : int usefast = 1;
752 :
753 : /* Process restart marker if needed; may have to suspend */
754 31 : if (cinfo->restart_interval) {
755 0 : if (entropy->restarts_to_go == 0)
756 0 : if (! process_restart(cinfo))
757 0 : return FALSE;
758 0 : usefast = 0;
759 : }
760 :
761 31 : if (cinfo->src->bytes_in_buffer < BUFSIZE * (size_t)cinfo->blocks_in_MCU
762 4 : || cinfo->unread_marker != 0)
763 27 : usefast = 0;
764 :
765 : /* If we've run out of data, just leave the MCU set to zeroes.
766 : * This way, we return uniform gray for the remainder of the segment.
767 : */
768 31 : if (! entropy->pub.insufficient_data) {
769 :
770 31 : if (usefast) {
771 4 : if (!decode_mcu_fast(cinfo, MCU_data)) goto use_slow;
772 : }
773 : else {
774 : use_slow:
775 27 : if (!decode_mcu_slow(cinfo, MCU_data)) return FALSE;
776 : }
777 :
778 : }
779 :
780 : /* Account for restart interval (no-op if not using restarts) */
781 29 : entropy->restarts_to_go--;
782 :
783 29 : return TRUE;
784 : }
785 :
786 :
787 : /*
788 : * Module initialization routine for Huffman entropy decoding.
789 : */
790 :
791 : GLOBAL(void)
792 5 : jinit_huff_decoder (j_decompress_ptr cinfo)
793 : {
794 : huff_entropy_ptr entropy;
795 : int i;
796 :
797 5 : entropy = (huff_entropy_ptr)
798 5 : (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
799 : SIZEOF(huff_entropy_decoder));
800 5 : cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
801 5 : entropy->pub.start_pass = start_pass_huff_decoder;
802 5 : entropy->pub.decode_mcu = decode_mcu;
803 :
804 : /* Mark tables unallocated */
805 25 : for (i = 0; i < NUM_HUFF_TBLS; i++) {
806 20 : entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
807 : }
808 5 : }
|