4 * This file was part of the Independent JPEG Group's software:
5 * Copyright (C) 1991-1997, Thomas G. Lane.
6 * libjpeg-turbo Modifications:
7 * Copyright (C) 2009-2011, D. R. Commander.
8 * For conditions of distribution and use, see the accompanying README file.
10 * This file contains Huffman entropy decoding routines.
12 * Much of the complexity here has to do with supporting input suspension.
13 * If the data source module demands suspension, we want to be able to back
14 * up to the start of the current MCU. To do this, we copy state variables
15 * into local working storage, and update them back to the permanent
16 * storage only upon successful completion of an MCU.
19 #define JPEG_INTERNALS
22 #include "jdhuff.h" /* Declarations shared with jdphuff.c */
27 * Expanded entropy decoder object for Huffman decoding.
29 * The savable_state subrecord contains fields that change within an MCU,
30 * but must not be updated permanently until we complete the MCU.
34 int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
37 /* This macro is to work around compilers with missing or broken
38 * structure assignment. You'll need to fix this code if you have
39 * such a compiler and you change MAX_COMPS_IN_SCAN.
42 #ifndef NO_STRUCT_ASSIGN
43 #define ASSIGN_STATE(dest,src) ((dest) = (src))
45 #if MAX_COMPS_IN_SCAN == 4
46 #define ASSIGN_STATE(dest,src) \
47 ((dest).last_dc_val[0] = (src).last_dc_val[0], \
48 (dest).last_dc_val[1] = (src).last_dc_val[1], \
49 (dest).last_dc_val[2] = (src).last_dc_val[2], \
50 (dest).last_dc_val[3] = (src).last_dc_val[3])
56 struct jpeg_entropy_decoder pub; /* public fields */
58 /* These fields are loaded into local variables at start of each MCU.
59 * In case of suspension, we exit WITHOUT updating them.
61 bitread_perm_state bitstate; /* Bit buffer at start of MCU */
62 savable_state saved; /* Other state at start of MCU */
64 /* These fields are NOT loaded into local working state. */
65 unsigned int restarts_to_go; /* MCUs left in this restart interval */
67 /* Pointers to derived tables (these workspaces have image lifespan) */
68 d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
69 d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
71 /* Precalculated info set up by start_pass for use in decode_mcu: */
73 /* Pointers to derived tables to be used for each block within an MCU */
74 d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
75 d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
76 /* Whether we care about the DC and AC coefficient values for each block */
77 boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
78 boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
79 } huff_entropy_decoder;
81 typedef huff_entropy_decoder * huff_entropy_ptr;
85 * Initialize for a Huffman-compressed scan.
89 start_pass_huff_decoder (j_decompress_ptr cinfo)
91 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
92 int ci, blkn, dctbl, actbl;
93 jpeg_component_info * compptr;
95 /* Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
96 * This ought to be an error condition, but we make it a warning because
97 * there are some baseline files out there with all zeroes in these bytes.
99 if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
100 cinfo->Ah != 0 || cinfo->Al != 0)
101 WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
103 for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
104 compptr = cinfo->cur_comp_info[ci];
105 dctbl = compptr->dc_tbl_no;
106 actbl = compptr->ac_tbl_no;
107 /* Compute derived values for Huffman tables */
108 /* We may do this more than once for a table, but it's not expensive */
109 jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
110 & entropy->dc_derived_tbls[dctbl]);
111 jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
112 & entropy->ac_derived_tbls[actbl]);
113 /* Initialize DC predictions to 0 */
114 entropy->saved.last_dc_val[ci] = 0;
117 /* Precalculate decoding info for each block in an MCU of this scan */
118 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
119 ci = cinfo->MCU_membership[blkn];
120 compptr = cinfo->cur_comp_info[ci];
121 /* Precalculate which table to use for each block */
122 entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
123 entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
124 /* Decide whether we really care about the coefficient values */
125 if (compptr->component_needed) {
126 entropy->dc_needed[blkn] = TRUE;
127 /* we don't need the ACs if producing a 1/8th-size image */
128 entropy->ac_needed[blkn] = (compptr->_DCT_scaled_size > 1);
130 entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
134 /* Initialize bitread state variables */
135 entropy->bitstate.bits_left = 0;
136 entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
137 entropy->pub.insufficient_data = FALSE;
139 /* Initialize restart counter */
140 entropy->restarts_to_go = cinfo->restart_interval;
145 * Compute the derived values for a Huffman table.
146 * This routine also performs some validation checks on the table.
148 * Note this is also used by jdphuff.c.
152 jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
153 d_derived_tbl ** pdtbl)
157 int p, i, l, si, numsymbols;
160 unsigned int huffcode[257];
163 /* Note that huffsize[] and huffcode[] are filled in code-length order,
164 * paralleling the order of the symbols themselves in htbl->huffval[].
167 /* Find the input Huffman table */
168 if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
169 ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
171 isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
173 ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
175 /* Allocate a workspace if we haven't already done so. */
177 *pdtbl = (d_derived_tbl *)
178 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
179 SIZEOF(d_derived_tbl));
181 dtbl->pub = htbl; /* fill in back link */
183 /* Figure C.1: make table of Huffman code length for each symbol */
186 for (l = 1; l <= 16; l++) {
187 i = (int) htbl->bits[l];
188 if (i < 0 || p + i > 256) /* protect against table overrun */
189 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
191 huffsize[p++] = (char) l;
196 /* Figure C.2: generate the codes themselves */
197 /* We also validate that the counts represent a legal Huffman code tree. */
202 while (huffsize[p]) {
203 while (((int) huffsize[p]) == si) {
204 huffcode[p++] = code;
207 /* code is now 1 more than the last code used for codelength si; but
208 * it must still fit in si bits, since no code is allowed to be all ones.
210 if (((INT32) code) >= (((INT32) 1) << si))
211 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
216 /* Figure F.15: generate decoding tables for bit-sequential decoding */
219 for (l = 1; l <= 16; l++) {
221 /* valoffset[l] = huffval[] index of 1st symbol of code length l,
222 * minus the minimum code of length l
224 dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
226 dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
228 dtbl->maxcode[l] = -1; /* -1 if no codes of this length */
231 dtbl->valoffset[17] = 0;
232 dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
234 /* Compute lookahead tables to speed up decoding.
235 * First we set all the table entries to 0, indicating "too long";
236 * then we iterate through the Huffman codes that are short enough and
237 * fill in all the entries that correspond to bit sequences starting
241 for (i = 0; i < (1 << HUFF_LOOKAHEAD); i++)
242 dtbl->lookup[i] = (HUFF_LOOKAHEAD + 1) << HUFF_LOOKAHEAD;
245 for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
246 for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
247 /* l = current code's length, p = its index in huffcode[] & huffval[]. */
248 /* Generate left-justified code followed by all possible bit sequences */
249 lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
250 for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
251 dtbl->lookup[lookbits] = (l << HUFF_LOOKAHEAD) | htbl->huffval[p];
257 /* Validate symbols as being reasonable.
258 * For AC tables, we make no check, but accept all byte values 0..255.
259 * For DC tables, we require the symbols to be in range 0..15.
260 * (Tighter bounds could be applied depending on the data depth and mode,
261 * but this is sufficient to ensure safe decoding.)
264 for (i = 0; i < numsymbols; i++) {
265 int sym = htbl->huffval[i];
266 if (sym < 0 || sym > 15)
267 ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
274 * Out-of-line code for bit fetching (shared with jdphuff.c).
275 * See jdhuff.h for info about usage.
276 * Note: current values of get_buffer and bits_left are passed as parameters,
277 * but are returned in the corresponding fields of the state struct.
279 * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
280 * of get_buffer to be used. (On machines with wider words, an even larger
281 * buffer could be used.) However, on some machines 32-bit shifts are
282 * quite slow and take time proportional to the number of places shifted.
283 * (This is true with most PC compilers, for instance.) In this case it may
284 * be a win to set MIN_GET_BITS to the minimum value of 15. This reduces the
285 * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
289 #define MIN_GET_BITS 15 /* minimum allowable value */
291 #define MIN_GET_BITS (BIT_BUF_SIZE-7)
296 jpeg_fill_bit_buffer (bitread_working_state * state,
297 register bit_buf_type get_buffer, register int bits_left,
299 /* Load up the bit buffer to a depth of at least nbits */
301 /* Copy heavily used state fields into locals (hopefully registers) */
302 register const JOCTET * next_input_byte = state->next_input_byte;
303 register size_t bytes_in_buffer = state->bytes_in_buffer;
304 j_decompress_ptr cinfo = state->cinfo;
306 /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
307 /* (It is assumed that no request will be for more than that many bits.) */
308 /* We fail to do so only if we hit a marker or are forced to suspend. */
310 if (cinfo->unread_marker == 0) { /* cannot advance past a marker */
311 while (bits_left < MIN_GET_BITS) {
314 /* Attempt to read a byte */
315 if (bytes_in_buffer == 0) {
316 if (! (*cinfo->src->fill_input_buffer) (cinfo))
318 next_input_byte = cinfo->src->next_input_byte;
319 bytes_in_buffer = cinfo->src->bytes_in_buffer;
322 c = GETJOCTET(*next_input_byte++);
324 /* If it's 0xFF, check and discard stuffed zero byte */
326 /* Loop here to discard any padding FF's on terminating marker,
327 * so that we can save a valid unread_marker value. NOTE: we will
328 * accept multiple FF's followed by a 0 as meaning a single FF data
329 * byte. This data pattern is not valid according to the standard.
332 if (bytes_in_buffer == 0) {
333 if (! (*cinfo->src->fill_input_buffer) (cinfo))
335 next_input_byte = cinfo->src->next_input_byte;
336 bytes_in_buffer = cinfo->src->bytes_in_buffer;
339 c = GETJOCTET(*next_input_byte++);
343 /* Found FF/00, which represents an FF data byte */
346 /* Oops, it's actually a marker indicating end of compressed data.
347 * Save the marker code for later use.
348 * Fine point: it might appear that we should save the marker into
349 * bitread working state, not straight into permanent state. But
350 * once we have hit a marker, we cannot need to suspend within the
351 * current MCU, because we will read no more bytes from the data
352 * source. So it is OK to update permanent state right away.
354 cinfo->unread_marker = c;
355 /* See if we need to insert some fake zero bits. */
360 /* OK, load c into get_buffer */
361 get_buffer = (get_buffer << 8) | c;
366 /* We get here if we've read the marker that terminates the compressed
367 * data segment. There should be enough bits in the buffer register
368 * to satisfy the request; if so, no problem.
370 if (nbits > bits_left) {
371 /* Uh-oh. Report corrupted data to user and stuff zeroes into
372 * the data stream, so that we can produce some kind of image.
373 * We use a nonvolatile flag to ensure that only one warning message
374 * appears per data segment.
376 if (! cinfo->entropy->insufficient_data) {
377 WARNMS(cinfo, JWRN_HIT_MARKER);
378 cinfo->entropy->insufficient_data = TRUE;
380 /* Fill the buffer with zero bits */
381 get_buffer <<= MIN_GET_BITS - bits_left;
382 bits_left = MIN_GET_BITS;
386 /* Unload the local registers */
387 state->next_input_byte = next_input_byte;
388 state->bytes_in_buffer = bytes_in_buffer;
389 state->get_buffer = get_buffer;
390 state->bits_left = bits_left;
396 /* Macro version of the above, which performs much better but does not
397 handle markers. We have to hand off any blocks with markers to the
402 register int c0, c1; \
403 c0 = GETJOCTET(*buffer++); \
404 c1 = GETJOCTET(*buffer); \
405 /* Pre-execute most common case */ \
406 get_buffer = (get_buffer << 8) | c0; \
409 /* Pre-execute case of FF/00, which represents an FF data byte */ \
412 /* Oops, it's actually a marker indicating end of compressed data. */ \
413 cinfo->unread_marker = c1; \
414 /* Back out pre-execution and fill the buffer with zero bits */ \
416 get_buffer &= ~0xFF; \
421 #if __WORDSIZE == 64 || defined(_WIN64)
423 /* Pre-fetch 48 bytes, because the holding register is 64-bit */
424 #define FILL_BIT_BUFFER_FAST \
425 if (bits_left < 16) { \
426 GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE GET_BYTE \
431 /* Pre-fetch 16 bytes, because the holding register is 32-bit */
432 #define FILL_BIT_BUFFER_FAST \
433 if (bits_left < 16) { \
441 * Out-of-line code for Huffman code decoding.
442 * See jdhuff.h for info about usage.
446 jpeg_huff_decode (bitread_working_state * state,
447 register bit_buf_type get_buffer, register int bits_left,
448 d_derived_tbl * htbl, int min_bits)
450 register int l = min_bits;
453 /* HUFF_DECODE has determined that the code is at least min_bits */
454 /* bits long, so fetch that many bits in one swoop. */
456 CHECK_BIT_BUFFER(*state, l, return -1);
459 /* Collect the rest of the Huffman code one bit at a time. */
460 /* This is per Figure F.16 in the JPEG spec. */
462 while (code > htbl->maxcode[l]) {
464 CHECK_BIT_BUFFER(*state, 1, return -1);
469 /* Unload the local registers */
470 state->get_buffer = get_buffer;
471 state->bits_left = bits_left;
473 /* With garbage input we may reach the sentinel value l = 17. */
476 WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
477 return 0; /* fake a zero as the safest result */
480 return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
485 * Figure F.12: extend sign bit.
486 * On some machines, a shift and add will be faster than a table lookup.
492 #define HUFF_EXTEND(x,s) ((x) + ((((x) - (1<<((s)-1))) >> 31) & (((-1)<<(s)) + 1)))
496 #define HUFF_EXTEND(x,s) ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
498 static const int extend_test[16] = /* entry n is 2**(n-1) */
499 { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
500 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
502 static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
503 { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
504 ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
505 ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
506 ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
508 #endif /* AVOID_TABLES */
512 * Check for a restart marker & resynchronize decoder.
513 * Returns FALSE if must suspend.
517 process_restart (j_decompress_ptr cinfo)
519 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
522 /* Throw away any unused bits remaining in bit buffer; */
523 /* include any full bytes in next_marker's count of discarded bytes */
524 cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
525 entropy->bitstate.bits_left = 0;
527 /* Advance past the RSTn marker */
528 if (! (*cinfo->marker->read_restart_marker) (cinfo))
531 /* Re-initialize DC predictions to 0 */
532 for (ci = 0; ci < cinfo->comps_in_scan; ci++)
533 entropy->saved.last_dc_val[ci] = 0;
535 /* Reset restart counter */
536 entropy->restarts_to_go = cinfo->restart_interval;
538 /* Reset out-of-data flag, unless read_restart_marker left us smack up
539 * against a marker. In that case we will end up treating the next data
540 * segment as empty, and we can avoid producing bogus output pixels by
541 * leaving the flag set.
543 if (cinfo->unread_marker == 0)
544 entropy->pub.insufficient_data = FALSE;
551 decode_mcu_slow (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
553 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
557 /* Outer loop handles each block in the MCU */
559 /* Load up working state */
560 BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
561 ASSIGN_STATE(state, entropy->saved);
563 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
564 JBLOCKROW block = MCU_data[blkn];
565 d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
566 d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
567 register int s, k, r;
569 /* Decode a single block's worth of coefficients */
571 /* Section F.2.2.1: decode the DC coefficient difference */
572 HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
574 CHECK_BIT_BUFFER(br_state, s, return FALSE);
576 s = HUFF_EXTEND(r, s);
579 if (entropy->dc_needed[blkn]) {
580 /* Convert DC difference to actual value, update last_dc_val */
581 int ci = cinfo->MCU_membership[blkn];
582 s += state.last_dc_val[ci];
583 state.last_dc_val[ci] = s;
584 /* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
585 (*block)[0] = (JCOEF) s;
588 if (entropy->ac_needed[blkn]) {
590 /* Section F.2.2.2: decode the AC coefficients */
591 /* Since zeroes are skipped, output area must be cleared beforehand */
592 for (k = 1; k < DCTSIZE2; k++) {
593 HUFF_DECODE(s, br_state, actbl, return FALSE, label2);
600 CHECK_BIT_BUFFER(br_state, s, return FALSE);
602 s = HUFF_EXTEND(r, s);
603 /* Output coefficient in natural (dezigzagged) order.
604 * Note: the extra entries in jpeg_natural_order[] will save us
605 * if k >= DCTSIZE2, which could happen if the data is corrupted.
607 (*block)[jpeg_natural_order[k]] = (JCOEF) s;
617 /* Section F.2.2.2: decode the AC coefficients */
618 /* In this path we just discard the values */
619 for (k = 1; k < DCTSIZE2; k++) {
620 HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
627 CHECK_BIT_BUFFER(br_state, s, return FALSE);
638 /* Completed MCU, so update state */
639 BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
640 ASSIGN_STATE(entropy->saved, state);
646 decode_mcu_fast (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
648 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
653 /* Outer loop handles each block in the MCU */
655 /* Load up working state */
656 BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
657 buffer = (JOCTET *) br_state.next_input_byte;
658 ASSIGN_STATE(state, entropy->saved);
660 for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
661 JBLOCKROW block = MCU_data[blkn];
662 d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
663 d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
664 register int s, k, r, l;
666 HUFF_DECODE_FAST(s, l, dctbl);
670 s = HUFF_EXTEND(r, s);
673 if (entropy->dc_needed[blkn]) {
674 int ci = cinfo->MCU_membership[blkn];
675 s += state.last_dc_val[ci];
676 state.last_dc_val[ci] = s;
677 (*block)[0] = (JCOEF) s;
680 if (entropy->ac_needed[blkn]) {
682 for (k = 1; k < DCTSIZE2; k++) {
683 HUFF_DECODE_FAST(s, l, actbl);
691 s = HUFF_EXTEND(r, s);
692 (*block)[jpeg_natural_order[k]] = (JCOEF) s;
701 for (k = 1; k < DCTSIZE2; k++) {
702 HUFF_DECODE_FAST(s, l, actbl);
718 if (cinfo->unread_marker != 0) {
719 cinfo->unread_marker = 0;
723 br_state.bytes_in_buffer -= (buffer - br_state.next_input_byte);
724 br_state.next_input_byte = buffer;
725 BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
726 ASSIGN_STATE(entropy->saved, state);
732 * Decode and return one MCU's worth of Huffman-compressed coefficients.
733 * The coefficients are reordered from zigzag order into natural array order,
734 * but are not dequantized.
736 * The i'th block of the MCU is stored into the block pointed to by
737 * MCU_data[i]. WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
738 * (Wholesale zeroing is usually a little faster than retail...)
740 * Returns FALSE if data source requested suspension. In that case no
741 * changes have been made to permanent state. (Exception: some output
742 * coefficients may already have been assigned. This is harmless for
743 * this module, since we'll just re-assign them on the next call.)
746 #define BUFSIZE (DCTSIZE2 * 2)
749 decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
751 huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
754 /* Process restart marker if needed; may have to suspend */
755 if (cinfo->restart_interval) {
756 if (entropy->restarts_to_go == 0)
757 if (! process_restart(cinfo))
762 if (cinfo->src->bytes_in_buffer < BUFSIZE * (size_t)cinfo->blocks_in_MCU
763 || cinfo->unread_marker != 0)
766 /* If we've run out of data, just leave the MCU set to zeroes.
767 * This way, we return uniform gray for the remainder of the segment.
769 if (! entropy->pub.insufficient_data) {
772 if (!decode_mcu_fast(cinfo, MCU_data)) goto use_slow;
776 if (!decode_mcu_slow(cinfo, MCU_data)) return FALSE;
781 /* Account for restart interval (no-op if not using restarts) */
782 entropy->restarts_to_go--;
789 * Module initialization routine for Huffman entropy decoding.
793 jinit_huff_decoder (j_decompress_ptr cinfo)
795 huff_entropy_ptr entropy;
798 entropy = (huff_entropy_ptr)
799 (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
800 SIZEOF(huff_entropy_decoder));
801 cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
802 entropy->pub.start_pass = start_pass_huff_decoder;
803 entropy->pub.decode_mcu = decode_mcu;
805 /* Mark tables unallocated */
806 for (i = 0; i < NUM_HUFF_TBLS; i++) {
807 entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
811 * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in-
812 * TIFF encapsulations produced by Microsoft's Wang Imaging
813 * for Windows application with the public-domain TIFF Library. Based upon an
814 * examination of selected output files, this program apparently divides a JPEG
815 * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG
816 * encoder's/decoder's DC coefficients for each image component are reset before
817 * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple
818 * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip"
819 * for alignment to the next input-Byte storage boundary. IJG JPEG Library
820 * decoder state is not normally exposed to client applications, so this sub-
821 * routine provides the TIFF Library with a "hook" to make these corrections.
822 * It should be called after "jpeg_start_decompress()" and before
823 * "jpeg_finish_decompress()", just before decoding each "strip" using
824 * "jpeg_read_raw_data()" or "jpeg_read_scanlines()".
826 * This kludge is not sanctioned or supported by the Independent JPEG Group, and
827 * future changes to the IJG JPEG Library might invalidate it. Do not send bug
828 * reports about this code to IJG developers. Instead, contact the author for
829 * advice: Scott B. Marovich <marovich@hpl.hp.com>, Hewlett-Packard Labs, 6/01.
832 jpeg_reset_huff_decode (register j_decompress_ptr cinfo,register float *refbw)
833 { register huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
836 /* Re-initialize DC predictions */
837 do entropy->saved.last_dc_val[ci] = -refbw[ci << 1];
838 while (++ci < cinfo->comps_in_scan);
839 /* Discard encoded input bits, up to the next Byte boundary */
840 entropy->bitstate.bits_left &= ~7;