path: root/src/c_huffman.c

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

#include "morecfg.h"
#include "jpeglib.h"

#include "c_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))

void ERRORREPORT(void)
{
	printf("Error");
}

/* Expanded entropy encoder object for Huffman encoding.
 *
 * The savable_state subrecord contains fields that change within an MCU,
 * but must not be updated permanently until we complete the MCU.
 */
typedef struct {
	INT32 put_buffer;		/* current bit-accumulation buffer */
	int put_bits;			/* # of bits now in it */
	int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
} savable_state;

#define ASSIGN_STATE(dest,src)  ((dest) = (src))


/* Working state while writing an MCU.
 * This struct contains all the fields that are needed by subroutines.
 */

typedef struct {
	JOCTET * next_output_byte;	/* => next byte to write in buffer */
	size_t free_in_buffer;	/* # of byte spaces remaining in buffer */
	savable_state cur;		/* Current bit buffer & DC state */
	//	j_compress_ptr cinfo;		/* dump_buffer needs access to this */
} working_state;


// ///////////////////////////////////////////
//     Huffman Tables allocated here
//
// //////////////////////////////////////////

JHUFF_TBL  dc_Huffman_Table[2];
JHUFF_TBL  ac_Huffman_Table[2];

c_derived_tbl	dc_derived_table;
c_derived_tbl	ac_derived_table;

/*
 * Huffman table setup routines
 */

	LOCAL(void)
add_huff_table (JHUFF_TBL *htblptr, const UINT8 *bits, const UINT8 *val)
	/* Define a Huffman table */
{
	int nsymbols, len;

	/* Copy the number-of-symbols-of-each-code-length counts */
	MEMCOPY((htblptr)->bits, bits, SIZEOF((htblptr)->bits));

	/* Validate the counts.  We do this here mainly so we can copy the right
	 * number of symbols from the val[] array, without risking marching off
	 * the end of memory.  jchuff.c will do a more thorough test later.
	 */
	nsymbols = 0;
	for (len = 1; len <= 16; len++)
		nsymbols += bits[len];
	if (nsymbols < 1 || nsymbols > 256)
	{
		perror("Bad Huffman code table entry");
		exit(0);
	}


	MEMCOPY((htblptr)->huffval, val, nsymbols * SIZEOF(UINT8));

	/* Initialize sent_table FALSE so table will be written to JPEG file. */
	(htblptr)->sent_table = FALSE;
}


	LOCAL(void)
std_huff_tables ()
	/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
	/* IMPORTANT: these are only valid for 8-bit data precision! */
{
	static const UINT8 bits_dc_luminance[17] =
	{ /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
	static const UINT8 val_dc_luminance[] =
	{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

	static const UINT8 bits_dc_chrominance[17] =
	{ /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
	static const UINT8 val_dc_chrominance[] =
	{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

	static const UINT8 bits_ac_luminance[17] =
	{ /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
	static const UINT8 val_ac_luminance[] =
	{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
		0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
		0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
		0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
		0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
		0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
		0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
		0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
		0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
		0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
		0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
		0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
		0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
		0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
		0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
		0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
		0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
		0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
		0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
		0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
		0xf9, 0xfa };

	static const UINT8 bits_ac_chrominance[17] =
	{ /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
	static const UINT8 val_ac_chrominance[] =
	{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
		0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
		0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
		0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
		0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
		0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
		0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
		0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
		0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
		0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
		0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
		0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
		0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
		0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
		0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
		0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
		0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
		0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
		0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
		0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
		0xf9, 0xfa };

	add_huff_table(&dc_Huffman_Table[0], bits_dc_luminance, val_dc_luminance);
	add_huff_table(&ac_Huffman_Table[0], bits_ac_luminance, val_ac_luminance);
	add_huff_table(&dc_Huffman_Table[1], bits_dc_chrominance, val_dc_chrominance);
	add_huff_table(&dc_Huffman_Table[1], bits_ac_chrominance, val_ac_chrominance);
}


	GLOBAL(void)
jpeg_make_c_derived_tbl (JHUFF_TBL *htbl, boolean isDC, 
		c_derived_tbl * pdtbl)
{ 
	c_derived_tbl *dtbl;
	int p, i, l, lastp, si, maxsymbol;
	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)
		ERRORREPORT();


	dtbl = pdtbl;

	// 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 */
			ERRORREPORT();
		while (i--)
			huffsize[p++] = (char) l;
	}
	huffsize[p] = 0;
	lastp = 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))
			ERRORREPORT();
		code <<= 1;
		si++;
	}

	/* Figure C.3: generate encoding tables */
	/* These are code and size indexed by symbol value */

	/* Set all codeless symbols to have code length 0;
	 * this lets us detect duplicate VAL entries here, and later
	 * allows emit_bits to detect any attempt to emit such symbols.
	 */
	MEMZERO(dtbl->ehufsi, SIZEOF(dtbl->ehufsi));

	/* This is also a convenient place to check for out-of-range
	 * and duplicated VAL entries.  We allow 0..255 for AC symbols
	 * but only 0..15 for DC.  (We could constrain them further
	 * based on data depth and mode, but this seems enough.)
	 */
	maxsymbol = isDC ? 15 : 255;

	for (p = 0; p < lastp; p++) {
		i = htbl->huffval[p];
		if (i < 0 || i > maxsymbol || dtbl->ehufsi[i])
			ERRORREPORT();
		dtbl->ehufco[i] = huffcode[p];
		dtbl->ehufsi[i] = huffsize[p];
	}
}




/* Outputting bytes to the file */

/* Emit a byte, taking 'action' if must suspend. */
#define emit_byte(state,val,action)  \
{ *(state)->next_output_byte++ = (JOCTET) (val);  \
	if (--(state)->free_in_buffer == 0)  \
	if (! dump_buffer(state))  \
	{ action; } }


/* Empty the output buffer; return TRUE if successful, FALSE if must suspend */
static boolean dump_buffer(working_state * state) {
	// TODO
	// 
	/*
	   struct jpeg_destination_mgr * dest = state->cinfo->dest;

	   if (! (*dest->empty_output_buffer) (state->cinfo)) {
	   return FALSE;
	   }
	// After a successful buffer dump, must reset buffer pointers 
	state->next_output_byte = dest->next_output_byte;
	state->free_in_buffer = dest->free_in_buffer;
	return TRUE;

*/
	return TRUE;
}


/* Outputting bits to the file */

/* Only the right 24 bits of put_buffer are used; the valid bits are
 * left-justified in this part.  At most 16 bits can be passed to emit_bits
 * in one call, and we never retain more than 7 bits in put_buffer
 * between calls, so 24 bits are sufficient.
 */

/* Emit some bits; return TRUE if successful, FALSE if must suspend */
inline static boolean emit_bits(working_state * state, unsigned int code, int size) {
	/* This routine is heavily used, so it's worth coding tightly. */
	register INT32 put_buffer = (INT32) code;
	register int put_bits = state->cur.put_bits;

	/* if size is 0, caller used an invalid Huffman table entry */
	if (size == 0) {
		perror("Missing Huffman code table entry");
		exit(0);
		/* ERREXIT(state->cinfo, JERR_HUFF_MISSING_CODE); */
	}

	put_buffer &= (((INT32) 1)<<size) - 1; /* mask off any extra bits in code */

	put_bits += size;		/* new number of bits in buffer */

	put_buffer <<= 24 - put_bits; /* align incoming bits */

	put_buffer |= state->cur.put_buffer; /* and merge with old buffer contents */

	while (put_bits >= 8) {
		int c = (int) ((put_buffer >> 16) & 0xFF);
		emit_byte(state, c, return FALSE);
		if (c == 0xFF) {		/* need to stuff a zero byte? */
			emit_byte(state, 0, return FALSE);
		}
		put_buffer <<= 8;
		put_bits -= 8;
	}

	state->cur.put_buffer = put_buffer; /* update state variables */
	state->cur.put_bits = put_bits;

	return TRUE;
}


	static boolean flush_bits (working_state * state) {
		if (! emit_bits(state, 0x7F, 7)) // fill any partial byte with ones 
			return FALSE;
		state->cur.put_buffer = 0;	// and reset bit-buffer to empty 
		state->cur.put_bits = 0;
		return TRUE;
	}


extern const int jpeg_natural_order[]; /* zigzag coef order to natural order */

int  bitCounter;


int encode_one_block(working_state *state, JCOEFPTR block, int last_dc_val, c_derived_tbl *dctbl, c_derived_tbl *actbl) {
	register int temp, temp2;
	register int nbits;
	register int k, r, i;

	bitCounter = 0; // TODEBUG
	/* Encode the DC coefficient difference per section F.1.2.1 */

	temp = temp2 = block[0] - last_dc_val;

	if (temp < 0) {
		temp = -temp;		/* temp is abs value of input */
		/* For a negative input, want temp2 = bitwise complement of abs(input) */
		/* This code assumes we are on a two's complement machine */
		temp2--;
	}

	/* Find the number of bits needed for the magnitude of the coefficient */
	nbits = 0;
	while (temp) {
		nbits++;
		temp >>= 1;
	}
	/* Check for out-of-range coefficient values.
	 * Since we're encoding a difference, the range limit is twice as much.
	 */
	if (nbits > MAX_COEF_BITS+1) {
		perror("DCT coefficient out of range");
		exit(0);
		/* ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); */
	}

	/* Emit the Huffman-coded symbol for the number of bits */
	if (! emit_bits(state, dctbl->ehufco[nbits], dctbl->ehufsi[nbits])) {
		return FALSE;
	}
	bitCounter += dctbl->ehufsi[nbits]; // TODEBUG

	/* Emit that number of bits of the value, if positive, */
	/* or the complement of its magnitude, if negative. */
	if (nbits) {			/* emit_bits rejects calls with size 0 */
		if (! emit_bits(state, (unsigned int) temp2, nbits)) {
			return FALSE;
		}
		bitCounter +=  nbits; // TODEBUG
	}

	/* Encode the AC coefficients per section F.1.2.2 */

	r = 0;			/* r = run length of zeros */

	for (k = 1; k < DCTSIZE2; k++) {
		if ((temp = block[jpeg_natural_order[k]]) == 0) {
			r++;
		} else {
			/* if run length > 15, must emit special run-length-16 codes (0xF0) */
			while (r > 15) {
				if (! emit_bits(state, actbl->ehufco[0xF0], actbl->ehufsi[0xF0])) {
					return FALSE;
				}
				r -= 16;
				bitCounter +=  actbl->ehufsi[0xF0]; // TODEBUG
			}

			temp2 = temp;
			if (temp < 0) {
				temp = -temp;		/* temp is abs value of input */
				/* This code assumes we are on a two's complement machine */
				temp2--;
			}

			/* Find the number of bits needed for the magnitude of the coefficient */
			nbits = 1;		/* there must be at least one 1 bit */
			while ((temp >>= 1)) {
				nbits++;
			}
			/* Check for out-of-range coefficient values */
			if (nbits > MAX_COEF_BITS) {
				perror("DCT coefficient out of range");
				exit(0);
				/* ERREXIT(state->cinfo, JERR_BAD_DCT_COEF); */
			}

			/* Emit Huffman symbol for run length / number of bits */
			i = (r << 4) + nbits;
			if (! emit_bits(state, actbl->ehufco[i], actbl->ehufsi[i])) {
				return FALSE;
			}

			bitCounter += actbl->ehufsi[i]; // TODEBUG
			/* Emit that number of bits of the value, if positive, */
			/* or the complement of its magnitude, if negative. */
			if (! emit_bits(state, (unsigned int) temp2, nbits)) {
				return FALSE;
			}
			bitCounter += nbits; // TODEBUG
			r = 0;
		}
	}

	/* If the last coef(s) were zero, emit an end-of-block code */
	if (r > 0) {
		if (! emit_bits(state, actbl->ehufco[0], actbl->ehufsi[0])) {
			return FALSE;
		}
		printf("END");
	}
	printf("\n Bitcounter = %d (%d)",bitCounter,bitCounter/8);
	return TRUE;
}

/*
 * Emit a restart marker & resynchronize predictions.
 */

static boolean emit_restart (working_state * state, int restart_num) {
	int ci;

	if (! flush_bits(state))
		return FALSE;

	emit_byte(state, 0xFF, return FALSE);
	emit_byte(state, JPEG_RST0 + restart_num, return FALSE);

	// Re-initialize DC predictions to 0 
	for (ci = 0; ci < MAX_COMPS_IN_SCAN; ci++)
		state->cur.last_dc_val[ci] = 0;

	// The restart counter is not updated until we successfully write the MCU. 
	return TRUE;
}


/*
 * Encode and output one MCU's worth of Huffman-compressed coefficients.
 */
/*
   static boolean encode_mcu_huff ( j_compress_ptr cinfo ,  JBLOCKROW *MCU_data) {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   working_state state;
   int blkn, ci;
   jpeg_component_info * compptr;

// Load up working state 
state.next_output_byte = cinfo->dest->next_output_byte;
state.free_in_buffer = cinfo->dest->free_in_buffer;
ASSIGN_STATE(state.cur, entropy->saved);
state.cinfo = cinfo;

// Emit restart marker if needed 
if (cinfo->restart_interval) {
if (entropy->restarts_to_go == 0)
if (! emit_restart(&state, entropy->next_restart_num))
return FALSE;
}

// Encode the MCU data blocks 
for (blkn = 0; blkn < cinfo->blocks_in_MCU; blkn++) {
ci = cinfo->MCU_membership[blkn];
compptr = cinfo->cur_comp_info[ci];
if (! encode_one_block(&state,
MCU_data[blkn][0], state.cur.last_dc_val[ci],
entropy->dc_derived_tbls[compptr->dc_tbl_no],
entropy->ac_derived_tbls[compptr->ac_tbl_no]))
return FALSE;
// Update last_dc_val 
state.cur.last_dc_val[ci] = MCU_data[blkn][0][0];
}

// Completed MCU, so update state 
cinfo->dest->next_output_byte = state.next_output_byte;
cinfo->dest->free_in_buffer = state.free_in_buffer;
ASSIGN_STATE(entropy->saved, state.cur);

// Update restart-interval state too 
if (cinfo->restart_interval) {
if (entropy->restarts_to_go == 0) {
entropy->restarts_to_go = cinfo->restart_interval;
entropy->next_restart_num++;
entropy->next_restart_num &= 7;
}
entropy->restarts_to_go--;
}

return TRUE;
}
*/

/*
 * Finish up at the end of a Huffman-compressed scan.
 */
/*
   static void finish_pass_huff (j_compress_ptr cinfo) {
   huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
   working_state state;

// Load up working state ... flush_bits needs it 
state.next_output_byte = cinfo->dest->next_output_byte;
state.free_in_buffer = cinfo->dest->free_in_buffer;
ASSIGN_STATE(state.cur, entropy->saved);
state.cinfo = cinfo;

// Flush out the last data 
if (! flush_bits(&state))
perror("Suspension not allowed here");
exit(0);
// ERREXIT(cinfo, JERR_CANT_SUSPEND); 

// Update state 
cinfo->dest->next_output_byte = state.next_output_byte;
cinfo->dest->free_in_buffer = state.free_in_buffer;
ASSIGN_STATE(entropy->saved, state.cur);
}
*/




static int  lastDCValue;
static  working_state savedHuffstate;

unsigned char outputBufferHuffman[500];

void encode_huffBlock64_init(void)
{
	std_huff_tables();
	/* Compute derived values for Huffman tables */
	/* We may do this more than once for a table, but it's not expensive */
	jpeg_make_c_derived_tbl(dc_Huffman_Table, TRUE, 
			&dc_derived_table);
	jpeg_make_c_derived_tbl(ac_Huffman_Table, FALSE,
			&ac_derived_table);	
}


void encode_huffBlock64_start(void)
{
	lastDCValue = 0;
	// Initialise buffer 
	savedHuffstate.next_output_byte 	= outputBufferHuffman;
	savedHuffstate.free_in_buffer 		= 500;  // TODO:
	savedHuffstate.cur.put_buffer 		= 0;
	savedHuffstate.cur.put_bits 		= 0;

	//	savedHuffstate.cinfo 		= NULL;
}

void encode_huffBlock64(short * data)
{
	working_state state;

	// Load up working state ... flush_bits needs it 
	state.next_output_byte 	= savedHuffstate.next_output_byte;
	state.free_in_buffer 	= savedHuffstate.free_in_buffer;
	ASSIGN_STATE(state.cur, savedHuffstate.cur);

	encode_one_block(&state, data, savedHuffstate.cur.last_dc_val[0], &dc_derived_table, &ac_derived_table);

	// Update last_dc_val 
	savedHuffstate.cur.last_dc_val[0] = data[0];  // Different for YUV TODO if all colours used

	// Completed MCU, so update state 
	savedHuffstate.next_output_byte = state.next_output_byte;
	savedHuffstate.free_in_buffer = state.free_in_buffer;
	ASSIGN_STATE(savedHuffstate.cur, state.cur);



}
void encode_huffBlock64_end(void )
{
	working_state state;

	// Load up working state ... flush_bits needs it 
	savedHuffstate.next_output_byte = state.next_output_byte;
	savedHuffstate.free_in_buffer = state.free_in_buffer ;
	ASSIGN_STATE(savedHuffstate.cur, state.cur);

	if (! flush_bits(&state))
	{
		perror("Suspension not allowed here");
		exit(0);
	}
}

/*
   typedef struct {
   unsigned int ehufco[256];	// code for each symbol 
   char ehufsi[256];		// length of code for each symbol 
// If no code has been allocated for a symbol S, ehufsi[S] contains 0 
} c_derived_tbl;
*/
void dump_Table(void)
{
	int i,j;
	printf("\n DC Derived Table Code\n\n ");
	for (i=0; i < 32; i++)
	{
		for(j=0;j < 8; j++)
		{
			printf("%4x\t",dc_derived_table.ehufco[ ((i * 8) + j)]);
		}
		printf("\n");
	}
	printf("\n DC Derived Table Symbol\n\n ");
	for (i=0; i < 32; i++)
	{
		for(j=0;j < 8; j++)
		{
			printf("%d\t",dc_derived_table.ehufsi[ ((i * 8) + j)]);
		}
		printf("\n");
	}	
	printf("\n AC Derived Table Code\n\n");
	for (i=0; i < 32; i++)
	{
		for(j=0;j < 8; j++)
		{
			printf("%4x\t",ac_derived_table.ehufco[ ((i * 8) + j)]);
		}
		printf("\n");
	}
	printf("\n AC Derived Table Symbol\n\n ");
	for (i=0; i < 32; i++)
	{
		for(j=0;j < 8; j++)
		{
			printf("%d\t",ac_derived_table.ehufsi[ ((i * 8) + j)]);
		}
		printf("\n");
	}	

}

void dump_Encoded(void)
{
	int i,j;
	printf("\n Huffman coded\n\n ");
	for (i=0; i < 50; i++)
	{
		for(j=0;j < 10; j++)
		{
			printf("%4x\t",outputBufferHuffman[ ((i * 10) + j)]);
		}
		printf("\n");
	}
}

void Test_dhuffman(short * data)
{

	//	dump_Encoded();

	encode_huffBlock64_init();

	dump_Table();
	encode_huffBlock64_start();
	encode_huffBlock64(data);
	encode_huffBlock64_end();
	dump_Encoded();

}