neo/renderer/jpeg-6/jdphuff.c

   1 /*
   2  * jdphuff.c
   3  *
   4  * Copyright (C) 1995, Thomas G. Lane.
   5  * This file is part of the Independent JPEG Group's software.
   6  * For conditions of distribution and use, see the accompanying README file.
   7  *
   8  * This file contains Huffman entropy decoding routines for progressive JPEG.
   9  *
  10  * Much of the complexity here has to do with supporting input suspension.
  11  * If the data source module demands suspension, we want to be able to back
  12  * up to the start of the current MCU.  To do this, we copy state variables
  13  * into local working storage, and update them back to the permanent
  14  * storage only upon successful completion of an MCU.
  15  */
  16
  17 #define JPEG_INTERNALS
  18 #include "jinclude.h"
  19 #include "jpeglib.h"
  20 #include "jdhuff.h"             /* Declarations shared with jdhuff.c */
  21
  22
  23 #ifdef D_PROGRESSIVE_SUPPORTED
  24
  25 /*
  26  * Expanded entropy decoder object for progressive 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   unsigned int EOBRUN;                  /* remaining EOBs in EOBRUN */
  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).EOBRUN = (src).EOBRUN, \
  48          (dest).last_dc_val[0] = (src).last_dc_val[0], \
  49          (dest).last_dc_val[1] = (src).last_dc_val[1], \
  50          (dest).last_dc_val[2] = (src).last_dc_val[2], \
  51          (dest).last_dc_val[3] = (src).last_dc_val[3])
  52 #endif
  53 #endif
  54
  55
  56 typedef struct {
  57   struct jpeg_entropy_decoder pub; /* public fields */
  58
  59   /* These fields are loaded into local variables at start of each MCU.
  60    * In case of suspension, we exit WITHOUT updating them.
  61    */
  62   bitread_perm_state bitstate;  /* Bit buffer at start of MCU */
  63   savable_state saved;          /* Other state at start of MCU */
  64
  65   /* These fields are NOT loaded into local working state. */
  66   unsigned int restarts_to_go;  /* MCUs left in this restart interval */
  67
  68   /* Pointers to derived tables (these workspaces have image lifespan) */
  69   d_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
  70
  71   d_derived_tbl * ac_derived_tbl; /* active table during an AC scan */
  72 } phuff_entropy_decoder;
  73
  74 typedef phuff_entropy_decoder * phuff_entropy_ptr;
  75
  76 /* Forward declarations */
  77 METHODDEF boolean decode_mcu_DC_first JPP((j_decompress_ptr cinfo,
  78                                            JBLOCKROW *MCU_data));
  79 METHODDEF boolean decode_mcu_AC_first JPP((j_decompress_ptr cinfo,
  80                                            JBLOCKROW *MCU_data));
  81 METHODDEF boolean decode_mcu_DC_refine JPP((j_decompress_ptr cinfo,
  82                                             JBLOCKROW *MCU_data));
  83 METHODDEF boolean decode_mcu_AC_refine JPP((j_decompress_ptr cinfo,
  84                                             JBLOCKROW *MCU_data));
  85
  86
  87 /*
  88  * Initialize for a Huffman-compressed scan.
  89  */
  90
  91 METHODDEF void
  92 start_pass_phuff_decoder (j_decompress_ptr cinfo)
  93 {
  94   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
  95   boolean is_DC_band, bad;
  96   int ci, coefi, tbl;
  97   int *coef_bit_ptr;
  98   jpeg_component_info * compptr;
  99
 100   is_DC_band = (cinfo->Ss == 0);
 101
 102   /* Validate scan parameters */
 103   bad = FALSE;
 104   if (is_DC_band) {
 105     if (cinfo->Se != 0)
 106       bad = TRUE;
 107   } else {
 108     /* need not check Ss/Se < 0 since they came from unsigned bytes */
 109     if (cinfo->Ss > cinfo->Se || cinfo->Se >= DCTSIZE2)
 110       bad = TRUE;
 111     /* AC scans may have only one component */
 112     if (cinfo->comps_in_scan != 1)
 113       bad = TRUE;
 114   }
 115   if (cinfo->Ah != 0) {
 116     /* Successive approximation refinement scan: must have Al = Ah-1. */
 117     if (cinfo->Al != cinfo->Ah-1)
 118       bad = TRUE;
 119   }
 120   if (cinfo->Al > 13)           /* need not check for < 0 */
 121     bad = TRUE;
 122   if (bad)
 123     ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
 124              cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
 125   /* Update progression status, and verify that scan order is legal.
 126    * Note that inter-scan inconsistencies are treated as warnings
 127    * not fatal errors ... not clear if this is right way to behave.
 128    */
 129   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 130     int cindex = cinfo->cur_comp_info[ci]->component_index;
 131     coef_bit_ptr = & cinfo->coef_bits[cindex][0];
 132     if (!is_DC_band && coef_bit_ptr[0] < 0) /* AC without prior DC scan */
 133       WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, 0);
 134     for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
 135       int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
 136       if (cinfo->Ah != expected)
 137         WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
 138       coef_bit_ptr[coefi] = cinfo->Al;
 139     }
 140   }
 141
 142   /* Select MCU decoding routine */
 143   if (cinfo->Ah == 0) {
 144     if (is_DC_band)
 145       entropy->pub.decode_mcu = decode_mcu_DC_first;
 146     else
 147       entropy->pub.decode_mcu = decode_mcu_AC_first;
 148   } else {
 149     if (is_DC_band)
 150       entropy->pub.decode_mcu = decode_mcu_DC_refine;
 151     else
 152       entropy->pub.decode_mcu = decode_mcu_AC_refine;
 153   }
 154
 155   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
 156     compptr = cinfo->cur_comp_info[ci];
 157     /* Make sure requested tables are present, and compute derived tables.
 158      * We may build same derived table more than once, but it's not expensive.
 159      */
 160     if (is_DC_band) {
 161       if (cinfo->Ah == 0) {     /* DC refinement needs no table */
 162         tbl = compptr->dc_tbl_no;
 163         if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
 164             cinfo->dc_huff_tbl_ptrs[tbl] == NULL)
 165           ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
 166         jpeg_make_d_derived_tbl(cinfo, cinfo->dc_huff_tbl_ptrs[tbl],
 167                                 & entropy->derived_tbls[tbl]);
 168       }
 169     } else {
 170       tbl = compptr->ac_tbl_no;
 171       if (tbl < 0 || tbl >= NUM_HUFF_TBLS ||
 172           cinfo->ac_huff_tbl_ptrs[tbl] == NULL)
 173         ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tbl);
 174       jpeg_make_d_derived_tbl(cinfo, cinfo->ac_huff_tbl_ptrs[tbl],
 175                               & entropy->derived_tbls[tbl]);
 176       /* remember the single active table */
 177       entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
 178     }
 179     /* Initialize DC predictions to 0 */
 180     entropy->saved.last_dc_val[ci] = 0;
 181   }
 182
 183   /* Initialize bitread state variables */
 184   entropy->bitstate.bits_left = 0;
 185   entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
 186   entropy->bitstate.printed_eod = FALSE;
 187
 188   /* Initialize private state variables */
 189   entropy->saved.EOBRUN = 0;
 190
 191   /* Initialize restart counter */
 192   entropy->restarts_to_go = cinfo->restart_interval;
 193 }
 194
 195
 196 /*
 197  * Figure F.12: extend sign bit.
 198  * On some machines, a shift and add will be faster than a table lookup.
 199  */
 200
 201 #ifdef AVOID_TABLES
 202
 203 #define HUFF_EXTEND(x,s)  ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))
 204
 205 #else
 206
 207 #define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
 208
 209 static const int extend_test[16] =   /* entry n is 2**(n-1) */
 210   { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
 211     0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
 212
 213 static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
 214   { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
 215     ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
 216     ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
 217     ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
 218
 219 #endif /* AVOID_TABLES */
 220
 221
 222 /*
 223  * Check for a restart marker & resynchronize decoder.
 224  * Returns FALSE if must suspend.
 225  */
 226
 227 LOCAL boolean
 228 process_restart (j_decompress_ptr cinfo)
 229 {
 230   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
 231   int ci;
 232
 233   /* Throw away any unused bits remaining in bit buffer; */
 234   /* include any full bytes in next_marker's count of discarded bytes */
 235   cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;
 236   entropy->bitstate.bits_left = 0;
 237
 238   /* Advance past the RSTn marker */
 239   if (! (*cinfo->marker->read_restart_marker) (cinfo))
 240     return FALSE;
 241
 242   /* Re-initialize DC predictions to 0 */
 243   for (ci = 0; ci < cinfo->comps_in_scan; ci++)
 244     entropy->saved.last_dc_val[ci] = 0;
 245   /* Re-init EOB run count, too */
 246   entropy->saved.EOBRUN = 0;
 247
 248   /* Reset restart counter */
 249   entropy->restarts_to_go = cinfo->restart_interval;
 250
 251   /* Next segment can get another out-of-data warning */
 252   entropy->bitstate.printed_eod = FALSE;
 253
 254   return TRUE;
 255 }
 256
 257
 258 /*
 259  * Huffman MCU decoding.
 260  * Each of these routines decodes and returns one MCU's worth of
 261  * Huffman-compressed coefficients.
 262  * The coefficients are reordered from zigzag order into natural array order,
 263  * but are not dequantized.
 264  *
 265  * The i'th block of the MCU is stored into the block pointed to by
 266  * MCU_data[i].  WE ASSUME THIS AREA IS INITIALLY ZEROED BY THE CALLER.
 267  *
 268  * We return FALSE if data source requested suspension.  In that case no
 269  * changes have been made to permanent state.  (Exception: some output
 270  * coefficients may already have been assigned.  This is harmless for
 271  * spectral selection, since we'll just re-assign them on the next call.
 272  * Successive approximation AC refinement has to be more careful, however.)
 273  */
 274
 275 /*
 276  * MCU decoding for DC initial scan (either spectral selection,
 277  * or first pass of successive approximation).
 278  */
 279
 280 METHODDEF boolean
 281 decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 282 {
 283   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
 284   int Al = cinfo->Al;
 285   register int s, r;
 286   int blkn, ci;
 287   JBLOCKROW block;
 288   BITREAD_STATE_VARS;
 289   savable_state state;
 290   d_derived_tbl * tbl;
 291   jpeg_component_info * compptr;
 292
 293   /* Process restart marker if needed; may have to suspend */
 294   if (cinfo->restart_interval) {
 295     if (entropy->restarts_to_go == 0)
 296       if (! process_restart(cinfo))
 297         return FALSE;
 298   }
 299
 300   /* Load up working state */
 301   BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
 302   ASSIGN_STATE(state, entropy->saved);
 303
 304   /* Outer loop handles each block in the MCU */
 305
 306   for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
 307     block = MCU_data[blkn];
 308     ci = cinfo->MCU_membership[blkn];
 309     compptr = cinfo->cur_comp_info[ci];
 310     tbl = entropy->derived_tbls[compptr->dc_tbl_no];
 311
 312     /* Decode a single block's worth of coefficients */
 313
 314     /* Section F.2.2.1: decode the DC coefficient difference */
 315     HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
 316     if (s) {
 317       CHECK_BIT_BUFFER(br_state, s, return FALSE);
 318       r = GET_BITS(s);
 319       s = HUFF_EXTEND(r, s);
 320     }
 321
 322     /* Convert DC difference to actual value, update last_dc_val */
 323     s += state.last_dc_val[ci];
 324     state.last_dc_val[ci] = s;
 325     /* Scale and output the DC coefficient (assumes jpeg_natural_order[0]=0) */
 326     (*block)[0] = (JCOEF) (s << Al);
 327   }
 328
 329   /* Completed MCU, so update state */
 330   BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
 331   ASSIGN_STATE(entropy->saved, state);
 332
 333   /* Account for restart interval (no-op if not using restarts) */
 334   entropy->restarts_to_go--;
 335
 336   return TRUE;
 337 }
 338
 339
 340 /*
 341  * MCU decoding for AC initial scan (either spectral selection,
 342  * or first pass of successive approximation).
 343  */
 344
 345 METHODDEF boolean
 346 decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 347 {
 348   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
 349   int Se = cinfo->Se;
 350   int Al = cinfo->Al;
 351   register int s, k, r;
 352   unsigned int EOBRUN;
 353   JBLOCKROW block;
 354   BITREAD_STATE_VARS;
 355   d_derived_tbl * tbl;
 356
 357   /* Process restart marker if needed; may have to suspend */
 358   if (cinfo->restart_interval) {
 359     if (entropy->restarts_to_go == 0)
 360       if (! process_restart(cinfo))
 361         return FALSE;
 362   }
 363
 364   /* Load up working state.
 365    * We can avoid loading/saving bitread state if in an EOB run.
 366    */
 367   EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we care about */
 368
 369   /* There is always only one block per MCU */
 370
 371   if (EOBRUN > 0)               /* if it's a band of zeroes... */
 372     EOBRUN--;                   /* ...process it now (we do nothing) */
 373   else {
 374     BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
 375     block = MCU_data[0];
 376     tbl = entropy->ac_derived_tbl;
 377
 378     for (k = cinfo->Ss; k <= Se; k++) {
 379       HUFF_DECODE(s, br_state, tbl, return FALSE, label2);
 380       r = s >> 4;
 381       s &= 15;
 382       if (s) {
 383         k += r;
 384         CHECK_BIT_BUFFER(br_state, s, return FALSE);
 385         r = GET_BITS(s);
 386         s = HUFF_EXTEND(r, s);
 387         /* Scale and output coefficient in natural (dezigzagged) order */
 388         (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al);
 389       } else {
 390         if (r == 15) {          /* ZRL */
 391           k += 15;              /* skip 15 zeroes in band */
 392         } else {                /* EOBr, run length is 2^r + appended bits */
 393           EOBRUN = 1 << r;
 394           if (r) {              /* EOBr, r > 0 */
 395             CHECK_BIT_BUFFER(br_state, r, return FALSE);
 396             r = GET_BITS(r);
 397             EOBRUN += r;
 398           }
 399           EOBRUN--;             /* this band is processed at this moment */
 400           break;                /* force end-of-band */
 401         }
 402       }
 403     }
 404
 405     BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
 406   }
 407
 408   /* Completed MCU, so update state */
 409   entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we care about */
 410
 411   /* Account for restart interval (no-op if not using restarts) */
 412   entropy->restarts_to_go--;
 413
 414   return TRUE;
 415 }
 416
 417
 418 /*
 419  * MCU decoding for DC successive approximation refinement scan.
 420  * Note: we assume such scans can be multi-component, although the spec
 421  * is not very clear on the point.
 422  */
 423
 424 METHODDEF boolean
 425 decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 426 {
 427   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
 428   int p1 = 1 << cinfo->Al;      /* 1 in the bit position being coded */
 429   int blkn;
 430   JBLOCKROW block;
 431   BITREAD_STATE_VARS;
 432
 433   /* Process restart marker if needed; may have to suspend */
 434   if (cinfo->restart_interval) {
 435     if (entropy->restarts_to_go == 0)
 436       if (! process_restart(cinfo))
 437         return FALSE;
 438   }
 439
 440   /* Load up working state */
 441   BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
 442
 443   /* Outer loop handles each block in the MCU */
 444
 445   for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
 446     block = MCU_data[blkn];
 447
 448     /* Encoded data is simply the next bit of the two's-complement DC value */
 449     CHECK_BIT_BUFFER(br_state, 1, return FALSE);
 450     if (GET_BITS(1))
 451       (*block)[0] |= p1;
 452     /* Note: since we use |=, repeating the assignment later is safe */
 453   }
 454
 455   /* Completed MCU, so update state */
 456   BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
 457
 458   /* Account for restart interval (no-op if not using restarts) */
 459   entropy->restarts_to_go--;
 460
 461   return TRUE;
 462 }
 463
 464
 465 /*
 466  * MCU decoding for AC successive approximation refinement scan.
 467  */
 468
 469 METHODDEF boolean
 470 decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 471 {
 472   phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
 473   int Se = cinfo->Se;
 474   int p1 = 1 << cinfo->Al;      /* 1 in the bit position being coded */
 475   int m1 = (-1) << cinfo->Al;   /* -1 in the bit position being coded */
 476   register int s, k, r;
 477   unsigned int EOBRUN;
 478   JBLOCKROW block;
 479   JCOEFPTR thiscoef;
 480   BITREAD_STATE_VARS;
 481   d_derived_tbl * tbl;
 482   int num_newnz;
 483   int newnz_pos[DCTSIZE2];
 484
 485   /* Process restart marker if needed; may have to suspend */
 486   if (cinfo->restart_interval) {
 487     if (entropy->restarts_to_go == 0)
 488       if (! process_restart(cinfo))
 489         return FALSE;
 490   }
 491
 492   /* Load up working state */
 493   BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
 494   EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we care about */
 495
 496   /* There is always only one block per MCU */
 497   block = MCU_data[0];
 498   tbl = entropy->ac_derived_tbl;
 499
 500   /* If we are forced to suspend, we must undo the assignments to any newly
 501    * nonzero coefficients in the block, because otherwise we'd get confused
 502    * next time about which coefficients were already nonzero.
 503    * But we need not undo addition of bits to already-nonzero coefficients;
 504    * instead, we can test the current bit position to see if we already did it.
 505    */
 506   num_newnz = 0;
 507
 508   /* initialize coefficient loop counter to start of band */
 509   k = cinfo->Ss;
 510
 511   if (EOBRUN == 0) {
 512     for (; k <= Se; k++) {
 513       HUFF_DECODE(s, br_state, tbl, goto undoit, label3);
 514       r = s >> 4;
 515       s &= 15;
 516       if (s) {
 517         if (s != 1)             /* size of new coef should always be 1 */
 518           WARNMS(cinfo, JWRN_HUFF_BAD_CODE);
 519         CHECK_BIT_BUFFER(br_state, 1, goto undoit);
 520         if (GET_BITS(1))
 521           s = p1;               /* newly nonzero coef is positive */
 522         else
 523           s = m1;               /* newly nonzero coef is negative */
 524       } else {
 525         if (r != 15) {
 526           EOBRUN = 1 << r;      /* EOBr, run length is 2^r + appended bits */
 527           if (r) {
 528             CHECK_BIT_BUFFER(br_state, r, goto undoit);
 529             r = GET_BITS(r);
 530             EOBRUN += r;
 531           }
 532           break;                /* rest of block is handled by EOB logic */
 533         }
 534         /* note s = 0 for processing ZRL */
 535       }
 536       /* Advance over already-nonzero coefs and r still-zero coefs,
 537        * appending correction bits to the nonzeroes.  A correction bit is 1
 538        * if the absolute value of the coefficient must be increased.
 539        */
 540       do {
 541         thiscoef = *block + jpeg_natural_order[k];
 542         if (*thiscoef != 0) {
 543           CHECK_BIT_BUFFER(br_state, 1, goto undoit);
 544           if (GET_BITS(1)) {
 545             if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
 546               if (*thiscoef >= 0)
 547                 *thiscoef += p1;
 548               else
 549                 *thiscoef += m1;
 550             }
 551           }
 552         } else {
 553           if (--r < 0)
 554             break;              /* reached target zero coefficient */
 555         }
 556         k++;
 557       } while (k <= Se);
 558       if (s) {
 559         int pos = jpeg_natural_order[k];
 560         /* Output newly nonzero coefficient */
 561         (*block)[pos] = (JCOEF) s;
 562         /* Remember its position in case we have to suspend */
 563         newnz_pos[num_newnz++] = pos;
 564       }
 565     }
 566   }
 567
 568   if (EOBRUN > 0) {
 569     /* Scan any remaining coefficient positions after the end-of-band
 570      * (the last newly nonzero coefficient, if any).  Append a correction
 571      * bit to each already-nonzero coefficient.  A correction bit is 1
 572      * if the absolute value of the coefficient must be increased.
 573      */
 574     for (; k <= Se; k++) {
 575       thiscoef = *block + jpeg_natural_order[k];
 576       if (*thiscoef != 0) {
 577         CHECK_BIT_BUFFER(br_state, 1, goto undoit);
 578         if (GET_BITS(1)) {
 579           if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */
 580             if (*thiscoef >= 0)
 581               *thiscoef += p1;
 582             else
 583               *thiscoef += m1;
 584           }
 585         }
 586       }
 587     }
 588     /* Count one block completed in EOB run */
 589     EOBRUN--;
 590   }
 591
 592   /* Completed MCU, so update state */
 593   BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
 594   entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we care about */
 595
 596   /* Account for restart interval (no-op if not using restarts) */
 597   entropy->restarts_to_go--;
 598
 599   return TRUE;
 600
 601 undoit:
 602   /* Re-zero any output coefficients that we made newly nonzero */
 603   while (num_newnz > 0)
 604     (*block)[newnz_pos[--num_newnz]] = 0;
 605
 606   return FALSE;
 607 }
 608
 609
 610 /*
 611  * Module initialization routine for progressive Huffman entropy decoding.
 612  */
 613
 614 GLOBAL void
 615 jinit_phuff_decoder (j_decompress_ptr cinfo)
 616 {
 617   phuff_entropy_ptr entropy;
 618   int *coef_bit_ptr;
 619   int ci, i;
 620
 621   entropy = (phuff_entropy_ptr)
 622     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 623                                 SIZEOF(phuff_entropy_decoder));
 624   cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
 625   entropy->pub.start_pass = start_pass_phuff_decoder;
 626
 627   /* Mark derived tables unallocated */
 628   for (i = 0; i < NUM_HUFF_TBLS; i++) {
 629     entropy->derived_tbls[i] = NULL;
 630   }
 631
 632   /* Create progression status table */
 633   cinfo->coef_bits = (int (*)[DCTSIZE2])
 634     (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
 635                                 cinfo->num_components*DCTSIZE2*SIZEOF(int));
 636   coef_bit_ptr = & cinfo->coef_bits[0][0];
 637   for (ci = 0; ci < cinfo->num_components; ci++)
 638     for (i = 0; i < DCTSIZE2; i++)
 639       *coef_bit_ptr++ = -1;
 640 }
 641
 642 #endif /* D_PROGRESSIVE_SUPPORTED */