jchuff.c

基于Linux的ffmepg decoder

/*
 * jchuff.c
 *
 * Copyright (C) 1991-1997, 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.
 *
 * This file contains Huffman entropy encoding routines.
 *
 * Much of the complexity here has to do with supporting output suspension.
 * If the data destination module demands suspension, we want to be able to
 * back up to the start of the current MCU.  To do this, we copy state
 * variables into local working storage, and update them back to the
 * permanent JPEG objects only upon successful completion of an MCU.
 */

#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"
#include "jchuff.h"		/* Declarations shared with jcphuff.c */
#include "local_mem.h"
#include "portab.h"

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

/* 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.
 */
#if 0

#ifndef NO_STRUCT_ASSIGN
#define ASSIGN_STATE(dest,src)  ((dest) = (src))
#else
#if MAX_COMPS_IN_SCAN == 4
#define ASSIGN_STATE(dest,src)  \
	((dest).put_buffer = (src).put_buffer, \
	 (dest).put_bits = (src).put_bits, \
	 (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

#endif

typedef struct {
  struct jpeg_entropy_encoder pub; /* public fields */

  savable_state saved;		/* Bit buffer & DC 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 */
  int next_restart_num;		/* next restart number to write (0-7) */

  /* Pointers to derived tables (these workspaces have image lifespan) */
  c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
  c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];

#ifdef ENTROPY_OPT_SUPPORTED	/* Statistics tables for optimization */
  long * dc_count_ptrs[NUM_HUFF_TBLS];
  long * ac_count_ptrs[NUM_HUFF_TBLS];
#endif
} huff_entropy_encoder;

typedef huff_entropy_encoder * huff_entropy_ptr;

/* 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 */
  unsigned int * next_output_word;		//pwhsu++:20040113
  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;


/* Forward declarations */
//METHODDEF(boolean) encode_mcu_huff JPP((j_compress_ptr cinfo,
//					JBLOCKROW *MCU_data));
METHODDEF(void) finish_pass_huff JPP((j_compress_ptr cinfo));
//#ifdef ENTROPY_OPT_SUPPORTED
//METHODDEF(boolean) encode_mcu_gather JPP((j_compress_ptr cinfo,
//					  JBLOCKROW *MCU_data));
//METHODDEF(void) finish_pass_gather JPP((j_compress_ptr cinfo));


//METHODDEF(void) Encode_block JPP((working_state * state, int last_dc_val, 
//							 int dc_tbln, int ac_tbln, int vlcnum));
//#endif


/*
 * Initialize for a Huffman-compressed scan.
 * If gather_statistics is TRUE, we do not output anything during the scan,
 * just count the Huffman symbols used and generate Huffman code tables.
 */
#if 0
METHODDEF(void)
start_pass_huff (j_compress_ptr cinfo, boolean gather_statistics)
{
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int ci, dctbl, actbl;
  jpeg_component_info * compptr;

//  entropy->pub.encode_mcu = encode_mcu_huff;
  entropy->pub.finish_pass = finish_pass_huff;


  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_c_derived_tbl(cinfo, TRUE, dctbl,
			      & entropy->dc_derived_tbls[dctbl]);		//pwhsu:20031016 玻ネdc huffman table 
    jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
			      & entropy->ac_derived_tbls[actbl]);		//pwhsu:20031016 玻ネac huffman table
	
  }

  /* Initialize restart stuff */
  entropy->restarts_to_go = cinfo->restart_interval;
  entropy->next_restart_num = 0;
}
#endif



void start_pass_huff1 (j_compress_ptr cinfo)
{
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  int ci, dctbl, actbl;
  jpeg_component_info * compptr;

  entropy->pub.finish_pass = finish_pass_huff;

  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_c_derived_tbl(cinfo, TRUE, dctbl,
			      & entropy->dc_derived_tbls[dctbl]);		//pwhsu:20031016 玻ネdc huffman table 
    jpeg_make_c_derived_tbl(cinfo, FALSE, actbl,
			      & entropy->ac_derived_tbls[actbl]);		//pwhsu:20031016 玻ネac huffman table
	
  }

  /* Initialize restart stuff */
  entropy->restarts_to_go = cinfo->restart_interval;
  entropy->next_restart_num = 0;
}




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

GLOBAL(void)
jpeg_make_c_derived_tbl (j_compress_ptr cinfo, boolean isDC, int tblno,
			 c_derived_tbl ** pdtbl)
{
  JHUFF_TBL *htbl;
  c_derived_tbl *dtbl;
  int p, i, l, lastp, si, maxsymbol;
  char huffsize[257];
  unsigned int huffcode[257];
  unsigned int code;
  int k1; //pwhsu++:20031022
  unsigned int *curtbl;		//pwhsu++:20040107
  unsigned int codesize;	//pwhsu++:20040107

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

  /* Find the input Huffman table */
  if (tblno < 0 || tblno >= NUM_HUFF_TBLS)
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);
  htbl =
    isDC ? cinfo->dc_huff_tbl_ptrs[tblno] : cinfo->ac_huff_tbl_ptrs[tblno];
  if (htbl == NULL)
    ERREXIT1(cinfo, JERR_NO_HUFF_TABLE, tblno);

  /* Allocate a workspace if we haven't already done so. */
  if (*pdtbl == NULL)
    *pdtbl = (c_derived_tbl *)
      (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
				  SIZEOF(c_derived_tbl));
  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 */
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
    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))
      ERREXIT(cinfo, JERR_BAD_HUFF_TABLE);
    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));		//pwhsu--:20040128 memzero
  //pwhsu++:20031022
  /*
  for ( k1=0; k1<256; k1++){
	  if (isDC){
		  rinfo.HuffsiDC[tblno][k1] = 0;
	  }
	  else{
		  rinfo.HuffsiAC[tblno][k1] = 0;
	  }
  }
  //pwhsu++:20031022
  */

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

  //pwhsu++:20040107
  if(isDC){
	  curtbl = tblno ? huftbl1_dc : huftbl0_dc;
  }else{
	  curtbl = tblno ? huftbl1_ac : huftbl0_ac;
  }


  for (p = 0; p < lastp; p++) {
    i = htbl->huffval[p];
	codesize = (huffcode[p]<< (5 + i%16) ) | (huffsize[p]+i%16);
	curtbl[i] = codesize;
  }
}



LOCAL(boolean)
flush_bits (void)
{
  unsigned char curbits;
  unsigned char curbits2;
  unsigned char	tmp;
  unsigned int buf1;
  unsigned char buf2;
  
	READ_VADR(curbits);
	READ_VLASTWORD(buf1);
  tmp = (((curbits-1) & 0xff) % 8);
  curbits2 = 7-tmp;
  
  /* fill any partial byte with ones */
  if (curbits2 != 0){			

	   BitstreamPutBits((0x7F)>>tmp, curbits2);
	   
	   buf2 = ( buf1 >> (  ( 32-((curbits)&0x1F))&0x18 ) ) & 0xFF;

	   switch(tmp){
	   case 0:
			buf2 = buf2 & 0x80 | 0x7f; 
			break;
	   case 1:
			buf2 = buf2 & 0xc0 | 0x3f; 
			break;
	   case 2:
			buf2 = buf2 & 0xe0 | 0x1f; 
			break;
       case 3:
			buf2 = buf2 & 0xf0 | 0x0f; 
			break;
	   case 4:
			buf2 = buf2 & 0xf8 | 0x07; 
			break;
	   case 5:
			buf2 = buf2 & 0xfc | 0x03; 
			break;
	   case 6:
			buf2 = buf2 & 0xfe | 0x01; 
			break;
	   default:
			buf2 = 0x0; 
			break;
	   }

	   if(buf2 == 0xff){
		mFa526DrainWrBuf ();
		BitstreamPutBits(0, 8);
	   }
	
  }

  return TRUE;
}


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

LOCAL(boolean)
emit_restart (int restart_num)
{

  if (! flush_bits())
    return FALSE;

  //BitstreamPutBits(0xFF,8);
  BitstreamPutBits( 0xFF00 | JPEG_RST0 + restart_num,16);

	SET_PYDCR(0);
	SET_PUVDCR(0);	

  return TRUE;
}




/*
 * Finish up at the end of a Huffman-compressed scan.
 */

METHODDEF(void)
finish_pass_huff (j_compress_ptr cinfo)
{

	flush_bits();

}


/*
 * Module initialization routine for Huffman entropy encoding.
 */

GLOBAL(void)
jinit_huff_encoder (j_compress_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_encoder));
  cinfo->entropy = (struct jpeg_entropy_encoder *) entropy;
//  entropy->pub.start_pass = start_pass_huff;

  /* Mark tables unallocated */
  for (i = 0; i < NUM_HUFF_TBLS; i++) {
    entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;

  }
}

//pwhsu++:20031030
//The modified function of Encode one MCU
boolean Encode_mcu (j_compress_ptr cinfo)
{
  huff_entropy_ptr entropy = (huff_entropy_ptr) cinfo->entropy;
  working_state state;

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

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


  return TRUE;
}
//pwhsu++:20031030