#include <stdlib.h>
#include <stdio.h>

#include "config.h"
#include "morecfg.h"

#include "jpeglib.h"
#include "jpegint.h"

#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))


/*
 * In ANSI C, and indeed any rational implementation, size_t is also the
 * type returned by sizeof().  However, it seems there are some irrational
 * implementations out there, in which sizeof() returns an int even though
 * size_t is defined as long or unsigned long.  To ensure consistent results
 * we always use this SIZEOF() macro in place of using sizeof() directly.
 */

#define SIZEOF(object)	((size_t) sizeof(object))


/*
 * Expanded entropy decoder object for 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 {
  int last_dc_val[1]; /* last DC coef for each component we have only one */
} savable_state;


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.
 */

/*

METHODDEF(void)
start_pass_huff_decoder (j_decompress_ptr cinfo)
{
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int ci, blkn, dctbl, actbl;
  jpeg_component_info * compptr;

   // 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.

    // 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,
			    & entropy->dc_derived_tbls[dctbl]);
    jpeg_make_d_derived_tbl(cinfo, FALSE, actbl,
			    & entropy->ac_derived_tbls[actbl]);
    // Initialize DC predictions to 0 
    entropy->saved.last_dc_val[ci] = 0;


  // Initialize bitread state variables 
  entropy->bitstate.bits_left = 0;
  entropy->bitstate.get_buffer = 0; // unnecessary, but keeps Purify quiet 
  entropy->pub.insufficient_data = FALSE;

}
*/

/*
 * Compute the derived values for a Huffman table.
 * This routine also performs some validation checks on the table.
 *
 * Note this is also used by jdphuff.c.
 */

GLOBAL(void)
jpeg_make_d_derived_tbl (JHUFF_TBL *htbl, boolean isDC,
			 d_derived_tbl * pdtbl)
{
  d_derived_tbl *dtbl;
  int p, i, l, si, numsymbols;
  int lookbits, ctr;
  char huffsize[257];
  unsigned int huffcode[257];
  unsigned int code;

  /* Note that huffsize[] and huffcode[] are filled in code-length order,
   * paralleling the order of the symbols themselves in htbl->huffval[].
   */

  if (htbl == NULL)
    perror("JERR_NO_HUFF_TABLE");

  dtbl = pdtbl;
  dtbl->pub = htbl;		/* fill in back link */ 
  /* Figure C.1: make table of Huffman code length for each symbol */

  p = 0;
  for (l = 1; l <= 16; l++) {
    i = (int) htbl->bits[l];
    if (i < 0 || p + i > 256)	/* protect against table overrun */
      perror("JERR_BAD_HUFF_TABLE");
    while (i--)
      huffsize[p++] = (char) l;
  }
  huffsize[p] = 0;
  numsymbols = p;
  
  /* Figure C.2: generate the codes themselves */
  /* We also validate that the counts represent a legal Huffman code tree. */
  
  code = 0;
  si = huffsize[0];
  p = 0;
  while (huffsize[p]) {
    while (((int) huffsize[p]) == si) {
      huffcode[p++] = code;
      code++;
    }
    /* code is now 1 more than the last code used for codelength si; but
     * it must still fit in si bits, since no code is allowed to be all ones.
     */
    if (((INT32) code) >= (((INT32) 1) << si))
      perror("JERR_BAD_HUFF_TABLE");
    code <<= 1;
    si++;
  }

  /* Figure F.15: generate decoding tables for bit-sequential decoding */

  p = 0;
  for (l = 1; l <= 16; l++) {
    if (htbl->bits[l]) {
      /* valoffset[l] = huffval[] index of 1st symbol of code length l,
       * minus the minimum code of length l
       */
      dtbl->valoffset[l] = (INT32) p - (INT32) huffcode[p];
      p += htbl->bits[l];
      dtbl->maxcode[l] = huffcode[p-1]; /* maximum code of length l */
    } else {
      dtbl->maxcode[l] = -1;	/* -1 if no codes of this length */
    }
  }
  dtbl->maxcode[17] = 0xFFFFFL; /* ensures jpeg_huff_decode terminates */

  /* Compute lookahead tables to speed up decoding.
   * First we set all the table entries to 0, indicating "too long";
   * then we iterate through the Huffman codes that are short enough and
   * fill in all the entries that correspond to bit sequences starting
   * with that code.
   */

  MEMZERO(dtbl->look_nbits, SIZEOF(dtbl->look_nbits));

  p = 0;
  for (l = 1; l <= HUFF_LOOKAHEAD; l++) {
    for (i = 1; i <= (int) htbl->bits[l]; i++, p++) {
      /* l = current code's length, p = its index in huffcode[] & huffval[]. */
      /* Generate left-justified code followed by all possible bit sequences */
      lookbits = huffcode[p] << (HUFF_LOOKAHEAD-l);
      for (ctr = 1 << (HUFF_LOOKAHEAD-l); ctr > 0; ctr--) {
	dtbl->look_nbits[lookbits] = l;
	dtbl->look_sym[lookbits] = htbl->huffval[p];
	lookbits++;
      }
    }
  }

  /* Validate symbols as being reasonable.
   * For AC tables, we make no check, but accept all byte values 0..255.
   * For DC tables, we require the symbols to be in range 0..15.
   * (Tighter bounds could be applied depending on the data depth and mode,
   * but this is sufficient to ensure safe decoding.)
   */
  if (isDC) {
    for (i = 0; i < numsymbols; i++) {
      int sym = htbl->huffval[i];
      if (sym < 0 || sym > 15)
	perror("JERR_BAD_HUFF_TABLE");
    }
  }
}


/*
 * Out-of-line code for bit fetching (shared with jdphuff.c).
 * See jdhuff.h for info about usage.
 * Note: current values of get_buffer and bits_left are passed as parameters,
 * but are returned in the corresponding fields of the state struct.
 *
 * On most machines MIN_GET_BITS should be 25 to allow the full 32-bit width
 * of get_buffer to be used.  (On machines with wider words, an even larger
 * buffer could be used.)  However, on some machines 32-bit shifts are
 * quite slow and take time proportional to the number of places shifted.
 * (This is true with most PC compilers, for instance.)  In this case it may
 * be a win to set MIN_GET_BITS to the minimum value of 15.  This reduces the
 * average shift distance at the cost of more calls to jpeg_fill_bit_buffer.
 */

#ifdef SLOW_SHIFT_32
#define MIN_GET_BITS  15	/* minimum allowable value */
#else
#define MIN_GET_BITS  (BIT_BUF_SIZE-7)
#endif


	GLOBAL(boolean)
jpeg_fill_bit_buffer (bitread_working_state * state,
		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;

	/* 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 {
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;
	}


/* 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;
}


/*
 * Out-of-line code for Huffman code decoding.
 * See jdhuff.h for info about usage.
 */

	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 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. */

	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. */

	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;

	/* 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 */
	}

	return htbl->pub->huffval[ (int) (code + htbl->valoffset[l]) ];
}


/*
 * Figure F.12: extend sign bit.
 * On some machines, a shift and add will be faster than a table lookup.
 */

#ifdef AVOID_TABLES

#define HUFF_EXTEND(x,s)  ((x) < (1<<((s)-1)) ? (x) + (((-1)<<(s)) + 1) : (x))

#else

#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_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 };

#endif /* AVOID_TABLES */

/*
 * 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.
 *
 *  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
 * changes have been made to permanent state.  (Exception: some output
 * coefficients may already have been assigned.  This is harmless for
 * this module, since we'll just re-assign them on the next call.)
 */

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];

	return TRUE;
}
extern unsigned char outputBufferHuffman[];

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 


	gs_bitReadWorkingState.next_input_byte = outputBufferHuffman; 
	gs_bitReadWorkingState.bytes_in_buffer = 500; 
	gs_PermState.get_buffer 		= 0; 
	gs_PermState.bits_left 			=0;

	//ASSIGN_STATE(entropy->saved, state);
	gs_SavableState.last_dc_val[0] =	0;
}

void Test_Huffman_Decoder(short * data)
{
	Start_Huffman_decode();
	decode_mcu( data, &dc_derived_table,&ac_derived_table);
}