I have removed all the cinfo referances and it is almost usable see Test_Huffman_Decoder()

It still is not tested Gives currently

WARNING JWRN_HUFF_BAD_CODE: No error
WARNING JWRN_HUFF_BAD_CODE: No error
while decoding encoded data.

Could still be a bug in the encoder

1 files changed, 217 insertions, 388 deletions

diff --git a/src/d_huffman.c b/src/d_huffman.c
index fb9c9d3..f9edca6 100644
--- a/src/d_huffman.c
+++ b/src/d_huffman.c
@@ -10,6 +10,7 @@
 #include "d_huffman.h"
 #include <string.h>
 
+
 #define MEMZERO(target,size)	memset((void *)(target), 0, (size_t)(size))
 #define MEMCOPY(dest,src,size)	memcpy((void *)(dest), (const void *)(src), (size_t)(size))
 
@@ -33,55 +34,15 @@
  */
 
 typedef struct {
-  int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
+  int last_dc_val[1]; /* last DC coef for each component we have only one */
 } savable_state;
 
-/* This macro is to work around compilers with missing or broken
- * structure assignment.  You'll need to fix this code if you have
- * such a compiler and you change MAX_COMPS_IN_SCAN.
- */
-
-#ifndef NO_STRUCT_ASSIGN
-#define ASSIGN_STATE(dest,src)  ((dest) = (src))
-#else
-#if MAX_COMPS_IN_SCAN == 4
-#define ASSIGN_STATE(dest,src)  \
-	((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 */
-
-  /* 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 */
 
-  /* These fields are NOT loaded into local working state. */
-  unsigned int restarts_to_go;	/* MCUs left in this restart interval */
-
-  /* Pointers to derived tables (these workspaces have image lifespan) */
-  d_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
-  d_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
-
-  /* Precalculated info set up by start_pass for use in decode_mcu: */
-
-  /* Pointers to derived tables to be used for each block within an MCU */
-  d_derived_tbl * dc_cur_tbls[D_MAX_BLOCKS_IN_MCU];
-  d_derived_tbl * ac_cur_tbls[D_MAX_BLOCKS_IN_MCU];
-  /* Whether we care about the DC and AC coefficient values for each block */
-  boolean dc_needed[D_MAX_BLOCKS_IN_MCU];
-  boolean ac_needed[D_MAX_BLOCKS_IN_MCU];
-} huff_entropy_decoder;
-
-typedef huff_entropy_decoder * huff_entropy_ptr;
+JHUFF_TBL  dc_Huffman_Table[2];
+JHUFF_TBL  ac_Huffman_Table[2];
 
+d_derived_tbl  dc_derived_table;
+d_derived_tbl  ac_derived_table;
 
 /*
  * Initialize for a Huffman-compressed scan.
@@ -99,16 +60,7 @@ start_pass_huff_decoder (j_decompress_ptr cinfo)
    // Check that the scan parameters Ss, Se, Ah/Al are OK for sequential JPEG.
    // This ought to be an error condition, but we make it a warning because
    // there are some baseline files out there with all zeroes in these bytes.
-   
-  if (cinfo->Ss != 0 || cinfo->Se != DCTSIZE2-1 ||
-      cinfo->Ah != 0 || cinfo->Al != 0)
-    WARNMS(cinfo, JWRN_NOT_SEQUENTIAL);
-
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
-    compptr = cinfo->cur_comp_info[ci];
-    dctbl = compptr->dc_tbl_no;
-    actbl = compptr->ac_tbl_no;
-    
+
     // Compute derived values for Huffman tables 
     // We may do this more than once for a table, but it's not expensive 
     jpeg_make_d_derived_tbl(cinfo, TRUE, dctbl,
@@ -117,32 +69,13 @@ start_pass_huff_decoder (j_decompress_ptr cinfo)
 			    & entropy->ac_derived_tbls[actbl]);
     // Initialize DC predictions to 0 
     entropy->saved.last_dc_val[ci] = 0;
-  }
 
-  // Precalculate decoding info for each block in an MCU of this scan 
-  for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-    ci = cinfo->MCU_membership[blkn];
-    compptr = cinfo->cur_comp_info[ci];
-    // Precalculate which table to use for each block 
-    entropy->dc_cur_tbls[blkn] = entropy->dc_derived_tbls[compptr->dc_tbl_no];
-    entropy->ac_cur_tbls[blkn] = entropy->ac_derived_tbls[compptr->ac_tbl_no];
-    // Decide whether we really care about the coefficient values 
-    if (compptr->component_needed) {
-      entropy->dc_needed[blkn] = TRUE;
-      // we don't need the ACs if producing a 1/8th-size image 
-      entropy->ac_needed[blkn] = (compptr->DCT_scaled_size > 1);
-    } else {
-      entropy->dc_needed[blkn] = entropy->ac_needed[blkn] = FALSE;
-    }
-  }
 
   // Initialize bitread state variables 
   entropy->bitstate.bits_left = 0;
   entropy->bitstate.get_buffer = 0; // unnecessary, but keeps Purify quiet 
   entropy->pub.insufficient_data = FALSE;
 
-  // Initialize restart counter 
-  entropy->restarts_to_go = cinfo->restart_interval;
 }
 */
 
@@ -154,10 +87,9 @@ start_pass_huff_decoder (j_decompress_ptr cinfo)
  */
 
 GLOBAL(void)
-jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
-			 d_derived_tbl ** pdtbl)
+jpeg_make_d_derived_tbl (JHUFF_TBL *htbl, boolean isDC,
+			 d_derived_tbl * pdtbl)
 {
-  JHUFF_TBL *htbl;
   d_derived_tbl *dtbl;
   int p, i, l, si, numsymbols;
   int lookbits, ctr;
@@ -169,22 +101,11 @@ jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
    * paralleling the order of the symbols themselves in htbl->huffval[].
    */
 
-  /* Find the input Huffman table */
-  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
-    perror("JERR_NO_HUFF_TABLE");
-  htbl =
-    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
   if (htbl == NULL)
     perror("JERR_NO_HUFF_TABLE");
 
-  /* Allocate a workspace if we haven't already done so. */
-  if (*pdtbl == NULL)
-    *pdtbl = (d_derived_tbl *)
-      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-				  SIZEOF(d_derived_tbl));
-  dtbl = *pdtbl;
-  dtbl->pub = htbl;		/* fill in back link */
-  
+  dtbl = pdtbl;
+  dtbl->pub = htbl;		/* fill in back link */ 
   /* Figure C.1: make table of Huffman code length for each symbol */
 
   p = 0;
@@ -296,104 +217,94 @@ jpeg_make_d_derived_tbl (j_decompress_ptr cinfo, boolean isDC, int tblno,
 #endif
 
 
-GLOBAL(boolean)
+	GLOBAL(boolean)
 jpeg_fill_bit_buffer (bitread_working_state * state,
-		      register bit_buf_type get_buffer, register int bits_left,
-		      int nbits)
+		register bit_buf_type get_buffer, register int bits_left,
+		int nbits)
 /* Load up the bit buffer to a depth of at least nbits */
 {
-  /* Copy heavily used state fields into locals (hopefully registers) */
-  register const JOCTET * next_input_byte = state->next_input_byte;
-  register size_t bytes_in_buffer = state->bytes_in_buffer;
-  j_decompress_ptr cinfo = state->cinfo;
-
-  /* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
-  /* (It is assumed that no request will be for more than that many bits.) */
-  /* We fail to do so only if we hit a marker or are forced to suspend. */
-
-  if (cinfo->unread_marker == 0) {	/* cannot advance past a marker */
-    while (bits_left < MIN_GET_BITS) {
-      register int c;
-
-      /* Attempt to read a byte */
-      if (bytes_in_buffer == 0) {
-	if (! (*cinfo->src->fill_input_buffer) (cinfo))
-	  return FALSE;
-	next_input_byte = cinfo->src->next_input_byte;
-	bytes_in_buffer = cinfo->src->bytes_in_buffer;
-      }
-      bytes_in_buffer--;
-      c = GETJOCTET(*next_input_byte++);
-
-      /* If it's 0xFF, check and discard stuffed zero byte */
-      if (c == 0xFF) {
-	/* Loop here to discard any padding FF's on terminating marker,
-	 * so that we can save a valid unread_marker value.  NOTE: we will
-	 * accept multiple FF's followed by a 0 as meaning a single FF data
-	 * byte.  This data pattern is not valid according to the standard.
-	 */
-	do {
-	  if (bytes_in_buffer == 0) {
-	    if (! (*cinfo->src->fill_input_buffer) (cinfo))
-	      return FALSE;
-	    next_input_byte = cinfo->src->next_input_byte;
-	    bytes_in_buffer = cinfo->src->bytes_in_buffer;
-	  }
-	  bytes_in_buffer--;
-	  c = GETJOCTET(*next_input_byte++);
-	} while (c == 0xFF);
-
-	if (c == 0) {
-	  /* Found FF/00, which represents an FF data byte */
-	  c = 0xFF;
+	/* Copy heavily used state fields into locals (hopefully registers) */
+	register const JOCTET * next_input_byte = state->next_input_byte;
+	register size_t bytes_in_buffer = state->bytes_in_buffer;
+
+	/* Attempt to load at least MIN_GET_BITS bits into get_buffer. */
+	/* (It is assumed that no request will be for more than that many bits.) */
+	/* We fail to do so only if we hit a marker or are forced to suspend. */
+
+	if(1){	/* cannot advance past a marker */
+		while (bits_left < MIN_GET_BITS) {
+			register int c;
+
+			/* Attempt to read a byte */
+			if (bytes_in_buffer == 0) {	
+				return FALSE;
+			}
+			bytes_in_buffer--;
+			c = GETJOCTET(*next_input_byte++);
+			printf("#%x",c);
+			/* If it's 0xFF, check and discard stuffed zero byte */
+			if (c == 0xFF) {
+				/* Loop here to discard any padding FF's on terminating marker,
+				 * so that we can save a valid unread_marker value.  NOTE: we will
+				 * accept multiple FF's followed by a 0 as meaning a single FF data
+				 * byte.  This data pattern is not valid according to the standard.
+				 */
+				do {
+					if (bytes_in_buffer == 0) {
+						return FALSE;
+					}
+					bytes_in_buffer--;
+					c = GETJOCTET(*next_input_byte++);
+				} while (c == 0xFF);
+
+				if (c == 0) {
+					/* Found FF/00, which represents an FF data byte */
+					c = 0xFF;
+				} else {
+					/* Oops, it's actually a marker indicating end of compressed data.
+					 * Save the marker code for later use.
+					 * Fine point: it might appear that we should save the marker into
+					 * bitread working state, not straight into permanent state.  But
+					 * once we have hit a marker, we cannot need to suspend within the
+					 * current MCU, because we will read no more bytes from the data
+					 * source.  So it is OK to update permanent state right away.
+					 */
+					/* See if we need to insert some fake zero bits. */
+					goto no_more_bytes;
+				}
+			}
+
+			/* OK, load c into get_buffer */
+			get_buffer = (get_buffer << 8) | c;
+			bits_left += 8;
+		} /* end while */
 	} else {
-	  /* Oops, it's actually a marker indicating end of compressed data.
-	   * Save the marker code for later use.
-	   * Fine point: it might appear that we should save the marker into
-	   * bitread working state, not straight into permanent state.  But
-	   * once we have hit a marker, we cannot need to suspend within the
-	   * current MCU, because we will read no more bytes from the data
-	   * source.  So it is OK to update permanent state right away.
-	   */
-	  cinfo->unread_marker = c;
-	  /* See if we need to insert some fake zero bits. */
-	  goto no_more_bytes;
+no_more_bytes:
+		/* We get here if we've read the marker that terminates the compressed
+		 * data segment.  There should be enough bits in the buffer register
+		 * to satisfy the request; if so, no problem.
+		 */
+		if (nbits > bits_left) {
+			/* Uh-oh.  Report corrupted data to user and stuff zeroes into
+			 * the data stream, so that we can produce some kind of image.
+			 * We use a nonvolatile flag to ensure that only one warning message
+			 * appears per data segment.
+			 */
+			perror("WARNING JWRN_HIT_MARKER");
+		}
+		/* Fill the buffer with zero bits */
+		get_buffer <<= MIN_GET_BITS - bits_left;
+		bits_left = MIN_GET_BITS;
 	}
-      }
 
-      /* OK, load c into get_buffer */
-      get_buffer = (get_buffer << 8) | c;
-      bits_left += 8;
-    } /* end while */
-  } else {
-  no_more_bytes:
-    /* We get here if we've read the marker that terminates the compressed
-     * data segment.  There should be enough bits in the buffer register
-     * to satisfy the request; if so, no problem.
-     */
-    if (nbits > bits_left) {
-      /* Uh-oh.  Report corrupted data to user and stuff zeroes into
-       * the data stream, so that we can produce some kind of image.
-       * We use a nonvolatile flag to ensure that only one warning message
-       * appears per data segment.
-       */
-      if (! cinfo->entropy->insufficient_data) {
-	perror("WARNING JWRN_HIT_MARKER");
-	cinfo->entropy->insufficient_data = TRUE;
-      }
-      /* Fill the buffer with zero bits */
-      get_buffer <<= MIN_GET_BITS - bits_left;
-      bits_left = MIN_GET_BITS;
-    }
-  }
 
-  /* Unload the local registers */
-  state->next_input_byte = next_input_byte;
-  state->bytes_in_buffer = bytes_in_buffer;
-  state->get_buffer = get_buffer;
-  state->bits_left = bits_left;
+/* Unload the local registers */
+state->next_input_byte = next_input_byte;
+state->bytes_in_buffer = bytes_in_buffer;
+state->get_buffer = get_buffer;
+state->bits_left = bits_left;
 
-  return TRUE;
+return TRUE;
 }
 
 
@@ -402,42 +313,42 @@ jpeg_fill_bit_buffer (bitread_working_state * state,
  * See jdhuff.h for info about usage.
  */
 
-GLOBAL(int)
+	GLOBAL(int)
 jpeg_huff_decode (bitread_working_state * state,
-		  register bit_buf_type get_buffer, register int bits_left,
-		  d_derived_tbl * htbl, int min_bits)
+		register bit_buf_type get_buffer, register int bits_left,
+		d_derived_tbl * htbl, int min_bits)
 {
-  register int l = min_bits;
-  register INT32 code;
+	register int l = min_bits;
+	register INT32 code;
 
-  /* HUFF_DECODE has determined that the code is at least min_bits */
-  /* bits long, so fetch that many bits in one swoop. */
+	/* HUFF_DECODE has determined that the code is at least min_bits */
+	/* bits long, so fetch that many bits in one swoop. */
 
-  CHECK_BIT_BUFFER(*state, l, return -1);
-  code = GET_BITS(l);
+	CHECK_BIT_BUFFER(*state, l, return -1);
+	code = GET_BITS(l);
 
-  /* Collect the rest of the Huffman code one bit at a time. */
-  /* This is per Figure F.16 in the JPEG spec. */
+	/* Collect the rest of the Huffman code one bit at a time. */
+	/* This is per Figure F.16 in the JPEG spec. */
 
-  while (code > htbl->maxcode[l]) {
-    code <<= 1;
-    CHECK_BIT_BUFFER(*state, 1, return -1);
-    code |= GET_BITS(1);
-    l++;
-  }
+	while (code > htbl->maxcode[l]) {
+		code <<= 1;
+		CHECK_BIT_BUFFER(*state, 1, return -1);
+		code |= GET_BITS(1);
+		l++;
+	}
 
-  /* Unload the local registers */
-  state->get_buffer = get_buffer;
-  state->bits_left = bits_left;
+	/* Unload the local registers */
+	state->get_buffer = get_buffer;
+	state->bits_left = bits_left;
 
-  /* With garbage input we may reach the sentinel value l = 17. */
+	/* With garbage input we may reach the sentinel value l = 17. */
 
-  if (l > 16) {
-    perror("WARNING JWRN_HUFF_BAD_CODE");
-    return 0;			/* fake a zero as the safest result */
-  }
+	if (l > 16) {
+		perror("WARNING JWRN_HUFF_BAD_CODE");
+		return 0;			/* fake a zero as the safest result */
+	}
 
-  return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
+	return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
 }
 
 
@@ -454,65 +365,24 @@ jpeg_huff_decode (bitread_working_state * state,
 
 #define HUFF_EXTEND(x,s)  ((x) < extend_test[s] ? (x) + extend_offset[s] : (x))
 
-static const int extend_test[16] =   /* entry n is 2**(n-1) */
-  { 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
-    0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
+									   static const int extend_test[16] =   /* entry n is 2**(n-1) */
+{ 0, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
+	0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000 };
 
 static const int extend_offset[16] = /* entry n is (-1 << n) + 1 */
-  { 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
-    ((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
-    ((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
-    ((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
+{ 0, ((-1)<<1) + 1, ((-1)<<2) + 1, ((-1)<<3) + 1, ((-1)<<4) + 1,
+	((-1)<<5) + 1, ((-1)<<6) + 1, ((-1)<<7) + 1, ((-1)<<8) + 1,
+	((-1)<<9) + 1, ((-1)<<10) + 1, ((-1)<<11) + 1, ((-1)<<12) + 1,
+	((-1)<<13) + 1, ((-1)<<14) + 1, ((-1)<<15) + 1 };
 
 #endif /* AVOID_TABLES */
 
-
-/*
- * Check for a restart marker & resynchronize decoder.
- * Returns FALSE if must suspend.
- */
-
-LOCAL(boolean)
-process_restart (j_decompress_ptr cinfo)
-{
-  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
-  int ci;
-
-  /* Throw away any unused bits remaining in bit buffer; */
-  /* include any full bytes in next_marker's count of discarded bytes */
-  // cinfo->marker->discarded_bytes += entropy->bitstate.bits_left / 8;    TODO
-  // entropy->bitstate.bits_left = 0;
-
-  /* Advance past the RSTn marker */
-  //if (! (*cinfo->marker->read_restart_marker) (cinfo))  TODO:
-  //  return FALSE;
-
-  /* Re-initialize DC predictions to 0 */
-  for (ci = 0; ci < cinfo->comps_in_scan; ci++)
-    entropy->saved.last_dc_val[ci] = 0;
-
-  /* Reset restart counter */
-  entropy->restarts_to_go = cinfo->restart_interval;
-
-  /* Reset out-of-data flag, unless read_restart_marker left us smack up
-   * against a marker.  In that case we will end up treating the next data
-   * segment as empty, and we can avoid producing bogus output pixels by
-   * leaving the flag set.
-   */
-  // if (cinfo->unread_marker == 0)   TODO:
-  //  entropy->pub.insufficient_data = FALSE;
-
-  return TRUE;
-}
-
-
 /*
  * Decode and return one MCU's worth of Huffman-compressed coefficients.
  * The coefficients are reordered from zigzag order into natural array order,
  * but are not dequantized.
  *
- * The i'th block of the MCU is stored into the block pointed to by
- * MCU_data[i].  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
+ *  WE ASSUME THIS AREA HAS BEEN ZEROED BY THE CALLER.
  * (Wholesale zeroing is usually a little faster than retail...)
  *
  * Returns FALSE if data source requested suspension.  In that case no
@@ -521,148 +391,107 @@ process_restart (j_decompress_ptr cinfo)
  * this module, since we'll just re-assign them on the next call.)
  */
 
-METHODDEF(boolean)
-decode_mcu (j_decompress_ptr cinfo, JBLOCKROW *MCU_data)
-{
-  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
-  int blkn;
-  BITREAD_STATE_VARS;
-  savable_state state;
-
-  /* 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 */
-    BITREAD_LOAD_STATE(cinfo,entropy->bitstate);
-    ASSIGN_STATE(state, entropy->saved);
-
-    /* Outer loop handles each block in the MCU */
-
-    for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
-      JBLOCKROW block = MCU_data[blkn];
-      d_derived_tbl * dctbl = entropy->dc_cur_tbls[blkn];
-      d_derived_tbl * actbl = entropy->ac_cur_tbls[blkn];
-      register int s, k, r;
-
-      /* Decode a single block's worth of coefficients */
-
-      /* Section F.2.2.1: decode the DC coefficient difference */
-      HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
-      if (s) {
-	CHECK_BIT_BUFFER(br_state, s, return FALSE);
-	r = GET_BITS(s);
-	s = HUFF_EXTEND(r, s);
-      }
-
-      if (entropy->dc_needed[blkn]) {
-	/* Convert DC difference to actual value, update last_dc_val */
-	int ci = cinfo->MCU_membership[blkn];
-	s += state.last_dc_val[ci];
-	state.last_dc_val[ci] = s;
-	/* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
-	(*block)[0] = (JCOEF) s;
-      }
-
-      if (entropy->ac_needed[blkn]) {
-
-	/* Section F.2.2.2: decode the AC coefficients */
-	/* Since zeroes are skipped, output area must be cleared beforehand */
-	for (k = 1; k < DCTSIZE2; k++) {
-	  HUFF_DECODE(s, br_state, actbl, 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);
-	    /* Output coefficient in natural (dezigzagged) order.
-	     * Note: the extra entries in jpeg_natural_order[] will save us
-	     * if k >= DCTSIZE2, which could happen if the data is corrupted.
-	     */
-	    (*block)[jpeg_natural_order[k]] = (JCOEF) s;
-	  } else {
-	    if (r != 15)
-	      break;
-	    k += 15;
-	  }
-	}
-
-      } else {
-
-	/* Section F.2.2.2: decode the AC coefficients */
-	/* In this path we just discard the values */
-	for (k = 1; k < DCTSIZE2; k++) {
-	  HUFF_DECODE(s, br_state, actbl, return FALSE, label3);
-      
-	  r = s >> 4;
-	  s &= 15;
-      
-	  if (s) {
-	    k += r;
-	    CHECK_BIT_BUFFER(br_state, s, return FALSE);
-	    DROP_BITS(s);
-	  } else {
-	    if (r != 15)
-	      break;
-	    k += 15;
-	  }
+bitread_working_state 	gs_bitReadWorkingState;
+bitread_perm_state	gs_PermState;
+savable_state		gs_SavableState;
+
+	METHODDEF(boolean)
+decode_mcu ( JCOEFPTR block, d_derived_tbl * dctbl,d_derived_tbl * actbl )
+{ 
+	register bit_buf_type get_buffer;  
+	register int bits_left;  
+	bitread_working_state br_state;
+	savable_state state;
+
+	/* Load up working state */
+	// BITREAD_LOAD_STATEM(cinfo,entropy->bitstate); 
+	br_state.next_input_byte 	= gs_bitReadWorkingState.next_input_byte; 
+	br_state.bytes_in_buffer 	= gs_bitReadWorkingState.bytes_in_buffer; 
+	get_buffer 			= gs_PermState.get_buffer; 
+	bits_left 			= gs_PermState.bits_left;
+
+	// ASSIGN_STATE(state, entropy->saved);	
+	state.last_dc_val[0] = gs_SavableState.last_dc_val[0];
+
+	/* Outer loop handles each block in the MCU */
+	{
+		register int s, k, r;
+		/* Decode a single block's worth of coefficients */
+		/* Section F.2.2.1: decode the DC coefficient difference */
+		HUFF_DECODE(s, br_state, dctbl, return FALSE, label1);
+		if (s) {
+			CHECK_BIT_BUFFER(br_state, s, return FALSE);
+			r = GET_BITS(s);
+			s = HUFF_EXTEND(r, s);
+		}
+
+		s += state.last_dc_val[0];
+		state.last_dc_val[0] = s;
+		/* Output the DC coefficient (assumes jpeg_natural_order[0] = 0) */
+		(block)[0] = (JCOEF) s;
+		{
+			/* Section F.2.2.2: decode the AC coefficients */
+			/* Since zeroes are skipped, output area must be cleared beforehand */
+			for (k = 1; k < DCTSIZE2; k++) {
+				HUFF_DECODE(s, br_state, actbl, 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);
+					/* Output coefficient in natural (dezigzagged) order.
+					 * Note: the extra entries in jpeg_natural_order[] will save us
+					 * if k >= DCTSIZE2, which could happen if the data is corrupted.
+					 */
+					(block)[jpeg_natural_order[k]] = (JCOEF) s;
+				} else {
+					if (r != 15)
+						break;
+					k += 15;
+				}
+			}
+		}
 	}
+	/* Completed MCU, so update state */
+	//BITREAD_SAVE_STATEM(cinfo,entropy->bitstate);
+	gs_bitReadWorkingState.next_input_byte = br_state.next_input_byte; 
+	gs_bitReadWorkingState.bytes_in_buffer = br_state.bytes_in_buffer; 
+	gs_PermState.get_buffer 		= get_buffer; 
+	gs_PermState.bits_left 			= bits_left;
 
-      }
-    }
+	//ASSIGN_STATE(entropy->saved, state);
+	gs_SavableState.last_dc_val[0] =	state.last_dc_val[0];
 
-    /* Completed MCU, so update state */
-    BITREAD_SAVE_STATE(cinfo,entropy->bitstate);
-    ASSIGN_STATE(entropy->saved, state);
-  }
+	return TRUE;
+}
+extern unsigned char outputBufferHuffman[];
 
-  /* Account for restart interval (no-op if not using restarts) */
-  entropy->restarts_to_go--;
+void Start_Huffman_decode(void)
+{
+	// Compute derived values for Huffman tables 
+	// We may do this more than once for a table, but it's not expensive 
+	jpeg_make_d_derived_tbl(dc_Huffman_Table, TRUE,		&dc_derived_table);
+	jpeg_make_d_derived_tbl(ac_Huffman_Table, FALSE,	&ac_derived_table);
+	// Initialize DC predictions to 0 
 
-  return TRUE;
-}
 
+	gs_bitReadWorkingState.next_input_byte = outputBufferHuffman; 
+	gs_bitReadWorkingState.bytes_in_buffer = 500; 
+	gs_PermState.get_buffer 		= 0; 
+	gs_PermState.bits_left 			=0;
 
-/*
- * Module initialization routine for Huffman entropy decoding.
- */
-/*
-GLOBAL(void)
-jinit_huff_decoder (j_decompress_ptr cinfo)
-{
-  //huff_entropy_ptr entropy;
-  //int i;
-
- // entropy = (huff_entropy_ptr)
- //   (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-//				SIZEOF(huff_entropy_decoder));
-//  cinfo->entropy = (struct jpeg_entropy_decoder *) entropy;
- // entropy->pub.start_pass = start_pass_huff_decoder;
-//  entropy->pub.decode_mcu = decode_mcu;
-
-  // Mark tables unallocated 
-//  for (i = 0; i < NUM_HUFF_TBLS; i++) {
-//    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
-//  }
+	//ASSIGN_STATE(entropy->saved, state);
+	gs_SavableState.last_dc_val[0] =	0;
 }
 
-*/
-
-JBLOCKROW data[64];
-void Test_Huffman_Decode(void)
+void Test_Huffman_Decoder(short * data)
 {
-decode_mcu( NULL, data);
+	Start_Huffman_decode();
+	decode_mcu( data, &dc_derived_table,&ac_derived_table);
 }
 
+