ASSIGN_STATE(entropy->saved, state);  /* Account for restart interval (no-op if not using restarts) */  entropy->restarts_to_go--;  return TRUE;}/* * MCU decoding for AC initial scan (either spectral selection, * or first pass of successive approximation). */METHODDEF(boolean)decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data){     phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;  int Se = cinfo->Se;  int Al = cinfo->Al;  register int s, k, r;  unsigned int EOBRUN;  JBLOCKROW block;  BITREAD_STATE_VARS;  d_derived_tbl * tbl;  /* Process restart marker if needed; may have to suspend */  if (cinfo->restart_interval) {    if (entropy->restarts_to_go == 0)      if (! process_restart(cinfo))	return FALSE;  }  /* Load up working state.   * We can avoid loading/saving bitread state if in an EOB run.   */  EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we care about */  /* There is always only one block per MCU */  if (EOBRUN > 0)		/* if it's a band of zeroes... */    EOBRUN--;			/* ...process it now (we do nothing) */  else {    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);    block = MCU_data[0];    tbl = entropy->ac_derived_tbl;    for (k = cinfo->Ss; k <= Se; k++) {      HUFF_DECODE(s, br_state, tbl, return FALSE, label2);      r = s >> 4;      s &= 15;      if (s) {        k += r;        CHECK_BIT_BUFFER(br_state, s, return FALSE);        r = GET_BITS(s);        s = HUFF_EXTEND(r, s);	/* Scale and output coefficient in natural (dezigzagged) order */        (*block)[jpeg_natural_order[k]] = (JCOEF) (s << Al);      } else {        if (r == 15) {		/* ZRL */          k += 15;		/* skip 15 zeroes in band */        } else {		/* EOBr, run length is 2^r + appended bits */          EOBRUN = 1 << r;          if (r) {		/* EOBr, r > 0 */	    CHECK_BIT_BUFFER(br_state, r, return FALSE);            r = GET_BITS(r);            EOBRUN += r;          }	  EOBRUN--;		/* this band is processed at this moment */	  break;		/* force end-of-band */	}      }    }    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);  }  /* Completed MCU, so update state */  entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we care about */  /* Account for restart interval (no-op if not using restarts) */  entropy->restarts_to_go--;  return TRUE;}/* * MCU decoding for DC successive approximation refinement scan. * Note: we assume such scans can be multi-component, although the spec * is not very clear on the point. */METHODDEF(boolean)decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data){     phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;  int p1 = 1 << cinfo->Al;	/* 1 in the bit position being coded */  int blkn;  JBLOCKROW block;  BITREAD_STATE_VARS;  /* Process restart marker if needed; may have to suspend */  if (cinfo->restart_interval) {    if (entropy->restarts_to_go == 0)      if (! process_restart(cinfo))	return FALSE;  }  /* Load up working state */  BITREAD_LOAD_STATE(cinfo,entropy->bitstate);  /* Outer loop handles each block in the MCU */  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {    block = MCU_data[blkn];    /* Encoded data is simply the next bit of the two's-complement DC value */    CHECK_BIT_BUFFER(br_state, 1, return FALSE);    if (GET_BITS(1))      (*block)[0] |= p1;    /* Note: since we use |=, repeating the assignment later is safe */  }  /* Completed MCU, so update state */  BITREAD_SAVE_STATE(cinfo,entropy->bitstate);  /* Account for restart interval (no-op if not using restarts) */  entropy->restarts_to_go--;  return TRUE;}/* * MCU decoding for AC successive approximation refinement scan. */METHODDEF(boolean)decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data){     phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;  int Se = cinfo->Se;  int p1 = 1 << cinfo->Al;	/* 1 in the bit position being coded */  int m1 = (-1) << cinfo->Al;	/* -1 in the bit position being coded */  register int s, k, r;  unsigned int EOBRUN;  JBLOCKROW block;  JCOEFPTR thiscoef;  BITREAD_STATE_VARS;  d_derived_tbl * tbl;  int num_newnz;  int newnz_pos[DCTSIZE2];  /* Process restart marker if needed; may have to suspend */  if (cinfo->restart_interval) {    if (entropy->restarts_to_go == 0)      if (! process_restart(cinfo))	return FALSE;  }  /* Load up working state */  BITREAD_LOAD_STATE(cinfo,entropy->bitstate);  EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we care about */  /* There is always only one block per MCU */  block = MCU_data[0];  tbl = entropy->ac_derived_tbl;  /* If we are forced to suspend, we must undo the assignments to any newly   * nonzero coefficients in the block, because otherwise we'd get confused   * next time about which coefficients were already nonzero.   * But we need not undo addition of bits to already-nonzero coefficients;   * instead, we can test the current bit position to see if we already did it.   */  num_newnz = 0;  /* initialize coefficient loop counter to start of band */  k = cinfo->Ss;  if (EOBRUN == 0) {    for (; k <= Se; k++) {      HUFF_DECODE(s, br_state, tbl, goto undoit, label3);      r = s >> 4;      s &= 15;      if (s) {	if (s != 1)		/* size of new coef should always be 1 */	  WARNMS(cinfo, JWRN_HUFF_BAD_CODE);        CHECK_BIT_BUFFER(br_state, 1, goto undoit);        if (GET_BITS(1))	  s = p1;		/* newly nonzero coef is positive */	else	  s = m1;		/* newly nonzero coef is negative */      } else {	if (r != 15) {	  EOBRUN = 1 << r;	/* EOBr, run length is 2^r + appended bits */	  if (r) {	    CHECK_BIT_BUFFER(br_state, r, goto undoit);	    r = GET_BITS(r);	    EOBRUN += r;	  }	  break;		/* rest of block is handled by EOB logic */	}	/* note s = 0 for processing ZRL */      }      /* Advance over already-nonzero coefs and r still-zero coefs,       * appending correction bits to the nonzeroes.  A correction bit is 1       * if the absolute value of the coefficient must be increased.       */      do {	thiscoef = *block + jpeg_natural_order[k];	if (*thiscoef != 0) {	  CHECK_BIT_BUFFER(br_state, 1, goto undoit);	  if (GET_BITS(1)) {	    if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */	      if (*thiscoef >= 0)		*thiscoef += p1;	      else		*thiscoef += m1;	    }	  }	} else {	  if (--r < 0)	    break;		/* reached target zero coefficient */	}	k++;      } while (k <= Se);      if (s) {	int pos = jpeg_natural_order[k];	/* Output newly nonzero coefficient */	(*block)[pos] = (JCOEF) s;	/* Remember its position in case we have to suspend */	newnz_pos[num_newnz++] = pos;      }    }  }  if (EOBRUN > 0) {    /* Scan any remaining coefficient positions after the end-of-band     * (the last newly nonzero coefficient, if any).  Append a correction     * bit to each already-nonzero coefficient.  A correction bit is 1     * if the absolute value of the coefficient must be increased.     */    for (; k <= Se; k++) {      thiscoef = *block + jpeg_natural_order[k];      if (*thiscoef != 0) {	CHECK_BIT_BUFFER(br_state, 1, goto undoit);	if (GET_BITS(1)) {	  if ((*thiscoef & p1) == 0) { /* do nothing if already changed it */	    if (*thiscoef >= 0)	      *thiscoef += p1;	    else	      *thiscoef += m1;	  }	}      }    }    /* Count one block completed in EOB run */    EOBRUN--;  }  /* Completed MCU, so update state */  BITREAD_SAVE_STATE(cinfo,entropy->bitstate);  entropy->saved.EOBRUN = EOBRUN; /* only part of saved state we care about */  /* Account for restart interval (no-op if not using restarts) */  entropy->restarts_to_go--;  return TRUE;undoit:  /* Re-zero any output coefficients that we made newly nonzero */  while (num_newnz > 0)    (*block)[newnz_pos[--num_newnz]] = 0;  return FALSE;}/* * Module initialization routine for progressive Huffman entropy decoding. */GLOBAL(void)jinit_phuff_decoder (j_decompress_ptr cinfo){  phuff_entropy_ptr entropy;  int *coef_bit_ptr;  int ci, i;  entropy = (phuff_entropy_ptr)    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,				SIZEOF(phuff_entropy_decoder));  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;  entropy->pub.start_pass = start_pass_phuff_decoder;  /* Mark derived tables unallocated */  for (i = 0; i < NUM_HUFF_TBLS; i++) {    entropy->derived_tbls[i] = NULL;  }  /* Create progression status table */  cinfo->coef_bits = (int (*)[DCTSIZE2])    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,				cinfo->num_components*DCTSIZE2*SIZEOF(int));  coef_bit_ptr = & cinfo->coef_bits[0][0];  for (ci = 0; ci < cinfo->num_components; ci++)     for (i = 0; i < DCTSIZE2; i++)      *coef_bit_ptr++ = -1;}#endif /* D_PROGRESSIVE_SUPPORTED */