X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2Fjpeg%2Flibijg%2Fjdphuff.c;h=7baaff921518a91ab846def6f1b3fdbbedc4f1d4;hb=933fb20f37f5f900c53c59b2a739e18303bd60d8;hp=22678099451a7f606c5cb2652940d569ba7885d5;hpb=a26e6f06a76ec85504cf65288e7c47f2cd728641;p=gdcm.git

diff --git a/src/jpeg/libijg/jdphuff.c b/src/jpeg/libijg/jdphuff.c
index 22678099..7baaff92 100644
--- a/src/jpeg/libijg/jdphuff.c
+++ b/src/jpeg/libijg/jdphuff.c
@@ -1,7 +1,7 @@
 /*
  * jdphuff.c
  *
- * Copyright (C) 1995-1997, Thomas G. Lane.
+ * Copyright (C) 1995-1998, Thomas G. Lane.
  * This file is part of the Independent JPEG Group's software.
  * For conditions of distribution and use, see the accompanying README file.
  *
@@ -17,21 +17,22 @@
 #define JPEG_INTERNALS
 #include "jinclude.h"
 #include "jpeglib.h"
-#include "jdhuff.h"		/* Declarations shared with jdhuff.c */
+#include "jlossy.h"    /* Private declarations for lossy subsystem */
+#include "jdhuff.h"    /* Declarations shared with jd*huff.c */
 
 
 #ifdef D_PROGRESSIVE_SUPPORTED
 
 /*
- * Expanded entropy decoder object for progressive Huffman decoding.
+ * Private entropy decoder object for progressive Huffman decoding.
  *
  * The savable_state subrecord contains fields that change within an MCU,
  * but must not be updated permanently until we complete the MCU.
  */
 
 typedef struct {
-  unsigned int EOBRUN;			/* remaining EOBs in EOBRUN */
-  int last_dc_val[MAX_COMPS_IN_SCAN];	/* last DC coef for each component */
+  unsigned int EOBRUN;      /* remaining EOBs in EOBRUN */
+  int last_dc_val[MAX_COMPS_IN_SCAN];  /* last DC coef for each component */
 } savable_state;
 
 /* This macro is to work around compilers with missing or broken
@@ -44,26 +45,25 @@ typedef struct {
 #else
 #if MAX_COMPS_IN_SCAN == 4
 #define ASSIGN_STATE(dest,src)  \
-	((dest).EOBRUN = (src).EOBRUN, \
-	 (dest).last_dc_val[0] = (src).last_dc_val[0], \
-	 (dest).last_dc_val[1] = (src).last_dc_val[1], \
-	 (dest).last_dc_val[2] = (src).last_dc_val[2], \
-	 (dest).last_dc_val[3] = (src).last_dc_val[3])
+  ((dest).EOBRUN = (src).EOBRUN, \
+   (dest).last_dc_val[0] = (src).last_dc_val[0], \
+   (dest).last_dc_val[1] = (src).last_dc_val[1], \
+   (dest).last_dc_val[2] = (src).last_dc_val[2], \
+   (dest).last_dc_val[3] = (src).last_dc_val[3])
 #endif
 #endif
 
 
 typedef struct {
-  struct jpeg_entropy_decoder pub; /* public fields */
+  huffd_common_fields;    /* Fields shared with other entropy decoders */
 
   /* These fields are loaded into local variables at start of each MCU.
    * In case of suspension, we exit WITHOUT updating them.
    */
-  bitread_perm_state bitstate;	/* Bit buffer at start of MCU */
-  savable_state saved;		/* Other state at start of MCU */
+  savable_state saved;    /* Other state at start of MCU */
 
   /* These fields are NOT loaded into local working state. */
-  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
+  unsigned int restarts_to_go;  /* MCUs left in this restart interval */
 
   /* Pointers to derived tables (these workspaces have image lifespan) */
   d_derived_tbl * derived_tbls[NUM_HUFF_TBLS];
@@ -75,13 +75,13 @@ typedef phuff_entropy_decoder * phuff_entropy_ptr;
 
 /* Forward declarations */
 METHODDEF(boolean) decode_mcu_DC_first JPP((j_decompress_ptr cinfo,
-					    JBLOCKROW *MCU_data));
+              JBLOCKROW *MCU_data));
 METHODDEF(boolean) decode_mcu_AC_first JPP((j_decompress_ptr cinfo,
-					    JBLOCKROW *MCU_data));
+              JBLOCKROW *MCU_data));
 METHODDEF(boolean) decode_mcu_DC_refine JPP((j_decompress_ptr cinfo,
-					     JBLOCKROW *MCU_data));
+               JBLOCKROW *MCU_data));
 METHODDEF(boolean) decode_mcu_AC_refine JPP((j_decompress_ptr cinfo,
-					     JBLOCKROW *MCU_data));
+               JBLOCKROW *MCU_data));
 
 
 /*
@@ -91,7 +91,8 @@ METHODDEF(boolean) decode_mcu_AC_refine JPP((j_decompress_ptr cinfo,
 METHODDEF(void)
 start_pass_phuff_decoder (j_decompress_ptr cinfo)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  j_lossy_d_ptr lossyd = (j_lossy_d_ptr) cinfo->codec;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) lossyd->entropy_private;
   boolean is_DC_band, bad;
   int ci, coefi, tbl;
   int *coef_bit_ptr;
@@ -117,7 +118,7 @@ start_pass_phuff_decoder (j_decompress_ptr cinfo)
     if (cinfo->Al != cinfo->Ah-1)
       bad = TRUE;
   }
-  if (cinfo->Al > 13)		/* need not check for < 0 */
+  if (cinfo->Al > 13)    /* need not check for < 0 */
     bad = TRUE;
   /* Arguably the maximum Al value should be less than 13 for 8-bit precision,
    * but the spec doesn't say so, and we try to be liberal about what we
@@ -127,7 +128,7 @@ start_pass_phuff_decoder (j_decompress_ptr cinfo)
    */
   if (bad)
     ERREXIT4(cinfo, JERR_BAD_PROGRESSION,
-	     cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
+       cinfo->Ss, cinfo->Se, cinfo->Ah, cinfo->Al);
   /* Update progression status, and verify that scan order is legal.
    * Note that inter-scan inconsistencies are treated as warnings
    * not fatal errors ... not clear if this is right way to behave.
@@ -140,7 +141,7 @@ start_pass_phuff_decoder (j_decompress_ptr cinfo)
     for (coefi = cinfo->Ss; coefi <= cinfo->Se; coefi++) {
       int expected = (coef_bit_ptr[coefi] < 0) ? 0 : coef_bit_ptr[coefi];
       if (cinfo->Ah != expected)
-	WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
+  WARNMS2(cinfo, JWRN_BOGUS_PROGRESSION, cindex, coefi);
       coef_bit_ptr[coefi] = cinfo->Al;
     }
   }
@@ -148,14 +149,14 @@ start_pass_phuff_decoder (j_decompress_ptr cinfo)
   /* Select MCU decoding routine */
   if (cinfo->Ah == 0) {
     if (is_DC_band)
-      entropy->pub.decode_mcu = decode_mcu_DC_first;
+      lossyd->entropy_decode_mcu = decode_mcu_DC_first;
     else
-      entropy->pub.decode_mcu = decode_mcu_AC_first;
+      lossyd->entropy_decode_mcu = decode_mcu_AC_first;
   } else {
     if (is_DC_band)
-      entropy->pub.decode_mcu = decode_mcu_DC_refine;
+      lossyd->entropy_decode_mcu = decode_mcu_DC_refine;
     else
-      entropy->pub.decode_mcu = decode_mcu_AC_refine;
+      lossyd->entropy_decode_mcu = decode_mcu_AC_refine;
   }
 
   for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
@@ -164,15 +165,15 @@ start_pass_phuff_decoder (j_decompress_ptr cinfo)
      * We may build same derived table more than once, but it's not expensive.
      */
     if (is_DC_band) {
-      if (cinfo->Ah == 0) {	/* DC refinement needs no table */
-	tbl = compptr->dc_tbl_no;
-	jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
-				& entropy->derived_tbls[tbl]);
+      if (cinfo->Ah == 0) {  /* DC refinement needs no table */
+  tbl = compptr->dc_tbl_no;
+  jpeg_make_d_derived_tbl(cinfo, TRUE, tbl,
+        & entropy->derived_tbls[tbl]);
       }
     } else {
       tbl = compptr->ac_tbl_no;
       jpeg_make_d_derived_tbl(cinfo, FALSE, tbl,
-			      & entropy->derived_tbls[tbl]);
+            & entropy->derived_tbls[tbl]);
       /* remember the single active table */
       entropy->ac_derived_tbl = entropy->derived_tbls[tbl];
     }
@@ -183,7 +184,7 @@ start_pass_phuff_decoder (j_decompress_ptr cinfo)
   /* Initialize bitread state variables */
   entropy->bitstate.bits_left = 0;
   entropy->bitstate.get_buffer = 0; /* unnecessary, but keeps Purify quiet */
-  entropy->pub.insufficient_data = FALSE;
+  entropy->insufficient_data = FALSE;
 
   /* Initialize private state variables */
   entropy->saved.EOBRUN = 0;
@@ -227,7 +228,8 @@ static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
 LOCAL(boolean)
 process_restart (j_decompress_ptr cinfo)
 {
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  j_lossy_d_ptr lossyd = (j_lossy_d_ptr) cinfo->codec;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) lossyd->entropy_private;
   int ci;
 
   /* Throw away any unused bits remaining in bit buffer; */
@@ -254,7 +256,7 @@ process_restart (j_decompress_ptr cinfo)
    * leaving the flag set.
    */
   if (cinfo->unread_marker == 0)
-    entropy->pub.insufficient_data = FALSE;
+    entropy->insufficient_data = FALSE;
 
   return TRUE;
 }
@@ -285,7 +287,8 @@ process_restart (j_decompress_ptr cinfo)
 METHODDEF(boolean)
 decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {   
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  j_lossy_d_ptr lossyd = (j_lossy_d_ptr) cinfo->codec;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) lossyd->entropy_private;
   int Al = cinfo->Al;
   register int s, r;
   int blkn, ci;
@@ -299,13 +302,13 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
   if (cinfo->restart_interval) {
     if (entropy->restarts_to_go == 0)
       if (! process_restart(cinfo))
-	return FALSE;
+  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) {
+  if (! entropy->insufficient_data) {
 
     /* Load up working state */
     BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
@@ -313,7 +316,7 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
     /* Outer loop handles each block in the MCU */
 
-    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+    for (blkn = 0; blkn < cinfo->data_units_in_MCU; blkn++) {
       block = MCU_data[blkn];
       ci = cinfo->MCU_membership[blkn];
       compptr = cinfo->cur_comp_info[ci];
@@ -324,9 +327,9 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
       /* Section F.2.2.1: decode the DC coefficient difference */
       HUFF_DECODE(s, br_state, tbl, return FALSE, label1);
       if (s) {
-	CHECK_BIT_BUFFER(br_state, s, return FALSE);
-	r = GET_BITS(s);
-	s = HUFF_EXTEND(r, s);
+  CHECK_BIT_BUFFER(br_state, s, return FALSE);
+  r = GET_BITS(s);
+  s = HUFF_EXTEND(r, s);
       }
 
       /* Convert DC difference to actual value, update last_dc_val */
@@ -356,7 +359,8 @@ decode_mcu_DC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 METHODDEF(boolean)
 decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {   
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  j_lossy_d_ptr lossyd = (j_lossy_d_ptr) cinfo->codec;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) lossyd->entropy_private;
   int Se = cinfo->Se;
   int Al = cinfo->Al;
   register int s, k, r;
@@ -369,60 +373,60 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
   if (cinfo->restart_interval) {
     if (entropy->restarts_to_go == 0)
       if (! process_restart(cinfo))
-	return FALSE;
+  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) {
+  if (! entropy->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 */
+    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) */
+    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 */
-	  }
-	}
+  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 */
+    entropy->saved.EOBRUN = EOBRUN;  /* only part of saved state we need */
   }
 
   /* Account for restart interval (no-op if not using restarts) */
@@ -441,8 +445,9 @@ decode_mcu_AC_first (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 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 */
+  j_lossy_d_ptr lossyd = (j_lossy_d_ptr) cinfo->codec;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) lossyd->entropy_private;
+  int p1 = 1 << cinfo->Al;  /* 1 in the bit position being coded */
   int blkn;
   JBLOCKROW block;
   BITREAD_STATE_VARS;
@@ -451,7 +456,7 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
   if (cinfo->restart_interval) {
     if (entropy->restarts_to_go == 0)
       if (! process_restart(cinfo))
-	return FALSE;
+  return FALSE;
   }
 
   /* Not worth the cycles to check insufficient_data here,
@@ -463,7 +468,7 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
   /* Outer loop handles each block in the MCU */
 
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
+  for (blkn = 0; blkn < cinfo->data_units_in_MCU; blkn++) {
     block = MCU_data[blkn];
 
     /* Encoded data is simply the next bit of the two's-complement DC value */
@@ -490,10 +495,11 @@ decode_mcu_DC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 METHODDEF(boolean)
 decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 {   
-  phuff_entropy_ptr entropy = (phuff_entropy_ptr) cinfo->entropy;
+  j_lossy_d_ptr lossyd = (j_lossy_d_ptr) cinfo->codec;
+  phuff_entropy_ptr entropy = (phuff_entropy_ptr) lossyd->entropy_private;
   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 */
+  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;
@@ -507,12 +513,12 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
   if (cinfo->restart_interval) {
     if (entropy->restarts_to_go == 0)
       if (! process_restart(cinfo))
-	return FALSE;
+  return FALSE;
   }
 
   /* If we've run out of data, don't modify the MCU.
    */
-  if (! entropy->pub.insufficient_data) {
+  if (! entropy->insufficient_data) {
 
     /* Load up working state */
     BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
@@ -535,58 +541,58 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
 
     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;
-	}
+  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;
+  }
       }
     }
 
@@ -597,18 +603,18 @@ decode_mcu_AC_refine (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
        * 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;
-	    }
-	  }
-	}
+  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--;
@@ -640,15 +646,16 @@ undoit:
 GLOBAL(void)
 jinit_phuff_decoder (j_decompress_ptr cinfo)
 {
+  j_lossy_d_ptr lossyd = (j_lossy_d_ptr) cinfo->codec;
   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;
+        SIZEOF(phuff_entropy_decoder));
+  lossyd->entropy_private = (void *) entropy;
+  lossyd->entropy_start_pass = start_pass_phuff_decoder;
 
   /* Mark derived tables unallocated */
   for (i = 0; i < NUM_HUFF_TBLS; i++) {
@@ -658,7 +665,7 @@ jinit_phuff_decoder (j_decompress_ptr cinfo)
   /* 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));
+        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++)