• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * jdhuff.c
3  *
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.
9  *
10  * This file contains Huffman entropy decoding routines.
11  *
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.
17  */
18 
19 #define JPEG_INTERNALS
20 #include "jinclude.h"
21 #include "jpeglib.h"
22 #include "jdhuff.h"		/* Declarations shared with jdphuff.c */
23 #include "jpegcomp.h"
24 
25 
26 /*
27  * Expanded entropy decoder object for Huffman decoding.
28  *
29  * The savable_state subrecord contains fields that change within an MCU,
30  * but must not be updated permanently until we complete the MCU.
31  */
32 
33 typedef struct {
34   int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
35 } savable_state;
36 
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.
40  */
41 
42 #ifndef NO_STRUCT_ASSIGN
43 #define ASSIGN_STATE(dest,src)  ((dest) = (src))
44 #else
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])
51 #endif
52 #endif
53 
54 
55 typedef struct {
56   struct jpeg_entropy_decoder pub; /* public fields */
57 
58   /* These fields are loaded into local variables at start of each MCU.
59    * In case of suspension, we exit WITHOUT updating them.
60    */
61   bitread_perm_state bitstate;	/* Bit buffer at start of MCU */
62   savable_state saved;		/* Other state at start of MCU */
63 
64   /* These fields are NOT loaded into local working state. */
65   unsigned int restarts_to_go;	/* MCUs left in this restart interval */
66 
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];
70 
71   /* Precalculated info set up by start_pass for use in decode_mcu: */
72 
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;
80 
81 typedef huff_entropy_decoder * huff_entropy_ptr;
82 
83 
84 /*
85  * Initialize for a Huffman-compressed scan.
86  */
87 
88 METHODDEF(void)
start_pass_huff_decoder(j_decompress_ptr cinfo)89 start_pass_huff_decoder (j_decompress_ptr cinfo)
90 {
91   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
92   int ci, blkn, dctbl, actbl;
93   jpeg_component_info * compptr;
94 
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.
98    */
99   if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
100       cinfo->Ah != 0 || cinfo->Al != 0)
101     WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
102 
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;
115   }
116 
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);
129     } else {
130       entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
131     }
132   }
133 
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;
138 
139   /* Initialize restart counter */
140   entropy->restarts_to_go = cinfo->restart_interval;
141 }
142 
143 
144 /*
145  * Compute the derived values for a Huffman table.
146  * This routine also performs some validation checks on the table.
147  *
148  * Note this is also used by jdphuff.c.
149  */
150 
151 GLOBAL(void)
jpeg_make_d_derived_tbl(j_decompress_ptr cinfo,boolean isDC,int tblno,d_derived_tbl ** pdtbl)152 jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
153 			 d_derived_tbl ** pdtbl)
154 {
155   JHUFF_TBL *htbl;
156   d_derived_tbl *dtbl;
157   int p, i, l, si, numsymbols;
158   int lookbits, ctr;
159   char huffsize[257];
160   unsigned int huffcode[257];
161   unsigned int code;
162 
163   /* Note that huffsize[] and huffcode[] are filled in code-length order,
164    * paralleling the order of the symbols themselves in htbl->huffval[].
165    */
166 
167   /* Find the input Huffman table */
168   if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
169     ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
170   htbl =
171     isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
172   if (htbl == NULL)
173     ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
174 
175   /* Allocate a workspace if we haven't already done so. */
176   if (*pdtbl == NULL)
177     *pdtbl = (d_derived_tbl *)
178       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
179 				  SIZEOF(d_derived_tbl));
180   dtbl = *pdtbl;
181   dtbl->pub = htbl;		/* fill in back link */
182 
183   /* Figure C.1: make table of Huffman code length for each symbol */
184 
185   p = 0;
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);
190     while (i--)
191       huffsize[p++] = (char) l;
192   }
193   huffsize[p] = 0;
194   numsymbols = p;
195 
196   /* Figure C.2: generate the codes themselves */
197   /* We also validate that the counts represent a legal Huffman code tree. */
198 
199   code = 0;
200   si = huffsize[0];
201   p = 0;
202   while (huffsize[p]) {
203     while (((int) huffsize[p]) == si) {
204       huffcode[p++] = code;
205       code++;
206     }
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.
209      */
210     if (((INT32) code) >= (((INT32) 1) << si))
211       ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
212     code <<= 1;
213     si++;
214   }
215 
216   /* Figure F.15: generate decoding tables for bit-sequential decoding */
217 
218   p = 0;
219   for (l = 1; l <= 16; l++) {
220     if (htbl->bits[l]) {
221       /* valoffset[l] = huffval[] index of 1st symbol of code length l,
222        * minus the minimum code of length l
223        */
224       dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
225       p += htbl->bits[l];
226       dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
227     } else {
228       dtbl->maxcode[l] = -1;	/* -1 if no codes of this length */
229     }
230   }
231   dtbl->valoffset[17] = 0;
232   dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */
233 
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
238    * with that code.
239    */
240 
241    for (i = 0; i < (1 << HUFF_LOOKAHEAD); i++)
242      dtbl->lookup[i] = (HUFF_LOOKAHEAD + 1) << HUFF_LOOKAHEAD;
243 
244   p = 0;
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];
252 	lookbits++;
253       }
254     }
255   }
256 
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.)
262    */
263   if (isDC) {
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);
268     }
269   }
270 }
271 
272 
273 /*
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.
278  *
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.
286  */
287 
288 #ifdef SLOW_SHIFT_32
289 #define MIN_GET_BITS  15	/* minimum allowable value */
290 #else
291 #define MIN_GET_BITS  (BIT_BUF_SIZE-7)
292 #endif
293 
294 
295 GLOBAL(boolean)
jpeg_fill_bit_buffer(bitread_working_state * state,register bit_buf_type get_buffer,register int bits_left,int nbits)296 jpeg_fill_bit_buffer (bitread_working_state * state,
297 		      register bit_buf_type get_buffer, register int bits_left,
298 		      int nbits)
299 /* Load up the bit buffer to a depth of at least nbits */
300 {
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;
305 
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. */
309 
310   if (cinfo->unread_marker == 0) {	/* cannot advance past a marker */
311     while (bits_left < MIN_GET_BITS) {
312       register int c;
313 
314       /* Attempt to read a byte */
315       if (bytes_in_buffer == 0) {
316 	if (! (*cinfo->src->fill_input_buffer) (cinfo))
317 	  return FALSE;
318 	next_input_byte = cinfo->src->next_input_byte;
319 	bytes_in_buffer = cinfo->src->bytes_in_buffer;
320       }
321       bytes_in_buffer--;
322       c = GETJOCTET(*next_input_byte++);
323 
324       /* If it's 0xFF, check and discard stuffed zero byte */
325       if (c == 0xFF) {
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.
330 	 */
331 	do {
332 	  if (bytes_in_buffer == 0) {
333 	    if (! (*cinfo->src->fill_input_buffer) (cinfo))
334 	      return FALSE;
335 	    next_input_byte = cinfo->src->next_input_byte;
336 	    bytes_in_buffer = cinfo->src->bytes_in_buffer;
337 	  }
338 	  bytes_in_buffer--;
339 	  c = GETJOCTET(*next_input_byte++);
340 	} while (c == 0xFF);
341 
342 	if (c == 0) {
343 	  /* Found FF/00, which represents an FF data byte */
344 	  c = 0xFF;
345 	} else {
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.
353 	   */
354 	  cinfo->unread_marker = c;
355 	  /* See if we need to insert some fake zero bits. */
356 	  goto no_more_bytes;
357 	}
358       }
359 
360       /* OK, load c into get_buffer */
361       get_buffer = (get_buffer << 8) | c;
362       bits_left += 8;
363     } /* end while */
364   } else {
365   no_more_bytes:
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.
369      */
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.
375        */
376       if (! cinfo->entropy->insufficient_data) {
377 	WARNMS(cinfo, JWRN_HIT_MARKER);
378 	cinfo->entropy->insufficient_data = TRUE;
379       }
380       /* Fill the buffer with zero bits */
381       get_buffer <<= MIN_GET_BITS - bits_left;
382       bits_left = MIN_GET_BITS;
383     }
384   }
385 
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;
391 
392   return TRUE;
393 }
394 
395 
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
398    slower routines. */
399 
400 #define GET_BYTE \
401 { \
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; \
407   bits_left += 8; \
408   if (c0 == 0xFF) { \
409     /* Pre-execute case of FF/00, which represents an FF data byte */ \
410     buffer++; \
411     if (c1 != 0) { \
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 */ \
415       buffer -= 2; \
416       get_buffer &= ~0xFF; \
417     } \
418   } \
419 }
420 
421 #if __WORDSIZE == 64 || defined(_WIN64)
422 
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 \
427   }
428 
429 #else
430 
431 /* Pre-fetch 16 bytes, because the holding register is 32-bit */
432 #define FILL_BIT_BUFFER_FAST \
433   if (bits_left < 16) { \
434     GET_BYTE GET_BYTE \
435   }
436 
437 #endif
438 
439 
440 /*
441  * Out-of-line code for Huffman code decoding.
442  * See jdhuff.h for info about usage.
443  */
444 
445 GLOBAL(int)
jpeg_huff_decode(bitread_working_state * state,register bit_buf_type get_buffer,register int bits_left,d_derived_tbl * htbl,int min_bits)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)
449 {
450   register int l = min_bits;
451   register INT32 code;
452 
453   /* HUFF_DECODE has determined that the code is at least min_bits */
454   /* bits long, so fetch that many bits in one swoop. */
455 
456   CHECK_BIT_BUFFER(*state, l, return -1);
457   code = GET_BITS(l);
458 
459   /* Collect the rest of the Huffman code one bit at a time. */
460   /* This is per Figure F.16 in the JPEG spec. */
461 
462   while (code > htbl->maxcode[l]) {
463     code <<= 1;
464     CHECK_BIT_BUFFER(*state, 1, return -1);
465     code |= GET_BITS(1);
466     l++;
467   }
468 
469   /* Unload the local registers */
470   state->get_buffer = get_buffer;
471   state->bits_left = bits_left;
472 
473   /* With garbage input we may reach the sentinel value l = 17. */
474 
475   if (l > 16) {
476     WARNMS(state->cinfo, JWRN_HUFF_BAD_CODE);
477     return 0;			/* fake a zero as the safest result */
478   }
479 
480   return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
481 }
482 
483 
484 /*
485  * Figure F.12: extend sign bit.
486  * On some machines, a shift and add will be faster than a table lookup.
487  */
488 
489 #define AVOID_TABLES
490 #ifdef AVOID_TABLES
491 
492 #define HUFF_EXTEND(x,s)  ((x) + ((((x) - (1<<((s)-1))) >> 31) & (((-1)<<(s)) + 1)))
493 
494 #else
495 
496 #define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
497 
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 };
501 
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 };
507 
508 #endif /* AVOID_TABLES */
509 
510 
511 /*
512  * Check for a restart marker & resynchronize decoder.
513  * Returns FALSE if must suspend.
514  */
515 
516 LOCAL(boolean)
process_restart(j_decompress_ptr cinfo)517 process_restart (j_decompress_ptr cinfo)
518 {
519   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
520   int ci;
521 
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;
526 
527   /* Advance past the RSTn marker */
528   if (! (*cinfo->marker->read_restart_marker) (cinfo))
529     return FALSE;
530 
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;
534 
535   /* Reset restart counter */
536   entropy->restarts_to_go = cinfo->restart_interval;
537 
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.
542    */
543   if (cinfo->unread_marker == 0)
544     entropy->pub.insufficient_data = FALSE;
545 
546   return TRUE;
547 }
548 
549 
550 LOCAL(boolean)
decode_mcu_slow(j_decompress_ptr cinfo,JBLOCKROW * MCU_data)551 decode_mcu_slow (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
552 {
553   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
554   BITREAD_STATE_VARS;
555   int blkn;
556   savable_state state;
557   /* Outer loop handles each block in the MCU */
558 
559   /* Load up working state */
560   BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
561   ASSIGN_STATE(state, entropy->saved);
562 
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;
568 
569     /* Decode a single block's worth of coefficients */
570 
571     /* Section F.2.2.1: decode the DC coefficient difference */
572     HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
573     if (s) {
574       CHECK_BIT_BUFFER(br_state, s, return FALSE);
575       r = GET_BITS(s);
576       s = HUFF_EXTEND(r, s);
577     }
578 
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;
586     }
587 
588     if (entropy->ac_needed[blkn]) {
589 
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);
594 
595         r = s >> 4;
596         s &= 15;
597 
598         if (s) {
599           k += r;
600           CHECK_BIT_BUFFER(br_state, s, return FALSE);
601           r = GET_BITS(s);
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.
606            */
607           (*block)[jpeg_natural_order[k]] = (JCOEF) s;
608         } else {
609           if (r != 15)
610             break;
611           k += 15;
612         }
613       }
614 
615     } else {
616 
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);
621 
622         r = s >> 4;
623         s &= 15;
624 
625         if (s) {
626           k += r;
627           CHECK_BIT_BUFFER(br_state, s, return FALSE);
628           DROP_BITS(s);
629         } else {
630           if (r != 15)
631             break;
632           k += 15;
633         }
634       }
635     }
636   }
637 
638   /* Completed MCU, so update state */
639   BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
640   ASSIGN_STATE(entropy->saved, state);
641   return TRUE;
642 }
643 
644 
645 LOCAL(boolean)
decode_mcu_fast(j_decompress_ptr cinfo,JBLOCKROW * MCU_data)646 decode_mcu_fast (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
647 {
648   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
649   BITREAD_STATE_VARS;
650   JOCTET *buffer;
651   int blkn;
652   savable_state state;
653   /* Outer loop handles each block in the MCU */
654 
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);
659 
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;
665 
666     HUFF_DECODE_FAST(s, l, dctbl);
667     if (s) {
668       FILL_BIT_BUFFER_FAST
669       r = GET_BITS(s);
670       s = HUFF_EXTEND(r, s);
671     }
672 
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;
678     }
679 
680     if (entropy->ac_needed[blkn]) {
681 
682       for (k = 1; k < DCTSIZE2; k++) {
683         HUFF_DECODE_FAST(s, l, actbl);
684         r = s >> 4;
685         s &= 15;
686 
687         if (s) {
688           k += r;
689           FILL_BIT_BUFFER_FAST
690           r = GET_BITS(s);
691           s = HUFF_EXTEND(r, s);
692           (*block)[jpeg_natural_order[k]] = (JCOEF) s;
693         } else {
694           if (r != 15) break;
695           k += 15;
696         }
697       }
698 
699     } else {
700 
701       for (k = 1; k < DCTSIZE2; k++) {
702         HUFF_DECODE_FAST(s, l, actbl);
703         r = s >> 4;
704         s &= 15;
705 
706         if (s) {
707           k += r;
708           FILL_BIT_BUFFER_FAST
709           DROP_BITS(s);
710         } else {
711           if (r != 15) break;
712           k += 15;
713         }
714       }
715     }
716   }
717 
718   if (cinfo->unread_marker != 0) {
719     cinfo->unread_marker = 0;
720     return FALSE;
721   }
722 
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);
727   return TRUE;
728 }
729 
730 
731 /*
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.
735  *
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...)
739  *
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.)
744  */
745 
746 #define BUFSIZE (DCTSIZE2 * 2u)
747 
748 METHODDEF(boolean)
decode_mcu(j_decompress_ptr cinfo,JBLOCKROW * MCU_data)749 decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
750 {
751   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
752   int usefast = 1;
753 
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))
758 	return FALSE;
759     usefast = 0;
760   }
761 
762   if (cinfo->src->bytes_in_buffer < BUFSIZE * (size_t)cinfo->blocks_in_MCU
763     || cinfo->unread_marker != 0)
764     usefast = 0;
765 
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.
768    */
769   if (! entropy->pub.insufficient_data) {
770 
771     if (usefast) {
772       if (!decode_mcu_fast(cinfo, MCU_data)) goto use_slow;
773     }
774     else {
775       use_slow:
776       if (!decode_mcu_slow(cinfo, MCU_data)) return FALSE;
777     }
778 
779   }
780 
781   /* Account for restart interval (no-op if not using restarts) */
782   entropy->restarts_to_go--;
783 
784   return TRUE;
785 }
786 
787 
788 /*
789  * Module initialization routine for Huffman entropy decoding.
790  */
791 
792 GLOBAL(void)
jinit_huff_decoder(j_decompress_ptr cinfo)793 jinit_huff_decoder (j_decompress_ptr cinfo)
794 {
795   huff_entropy_ptr entropy;
796   int i;
797 
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;
804 
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;
808   }
809 }
810