(*block)[0] = (JCOEF) (s << Al);    }    /* Completed MCU, so update state */    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);    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;  }  /* If we've run out of data, just leave the MCU set to zeroes.   * This way, we return uniform gray for the remainder of the segment.   */  if (! entropy->pub.insufficient_data) {    /* 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 need */    /* 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 need */  }  /* 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;  }  /* Not worth the cycles to check insufficient_data here,   * since we will not change the data anyway if we read zeroes.   */  /* 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;  }  /* If we've run out of data, don't modify the MCU.   */  if (! entropy->pub.insufficient_data) {    /* Load up working state */    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);    EOBRUN = entropy->saved.EOBRUN; /* only part of saved state we need */    /* 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 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 set 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 need */  }  /* 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 */