media/libjpeg/jdhuff.c

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