bitstream.cpp

一个优化的H.263解码器,性能达到商用级

// BitStream.cpp: implementation of the CBitStream class.
//
//////////////////////////////////////////////////////////////////////

#include "BitStream.h"
////////////////////
#include "tmndec.h"
#include "sactbls.h"
#include "indices.h"
#include "getvlc.h"
///////////////////


#if defined(WIN32)
#include <windows.h>

#endif

void AT_TRACE1(int level, char* fmtString, ...)
{
#ifdef WIN32
	char buf[512];
	va_list vl;

	if( 6 == level)
	{
		va_start(vl, fmtString);
		vsprintf(buf, fmtString, vl);
		va_end(vl);

		OutputDebugString("[ATVIDEO]:");
		OutputDebugString(buf);
	}
#endif
}
/*
EXTERN char version[]
#ifdef GLOBAL
= "H.263+"
#endif
;
*/
EXTERN int De_convmat[8][4]
#ifdef GLOBAL
=
{
  {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
  {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
  {104597, 132201, 25675, 53279}, /* unspecified */
  {104597, 132201, 25675, 53279}, /* reserved */
  {104448, 132798, 24759, 53109}, /* FCC */
  {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
  {104597, 132201, 25675, 53279}, /* SMPTE 170M */
  {117579, 136230, 16907, 35559}/* SMPTE 240M (1987) */
}
#endif
;
EXTERN int outtype;
/* zig-zag scan */
EXTERN  unsigned char De_zig_zag_scan[64]
#ifdef GLOBAL
=
{
  0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5,
  12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28,
  35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
  58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
}
#endif
;

EXTERN int De_lines[]
#ifdef GLOBAL
= {-1,128,176,352,704,1408,-1}
#endif
;

EXTERN int De_pels[7]
#ifdef GLOBAL
= {-1,96,144,288,576,1152,-1}
#endif
;

/* other scan orders needed in advanced intra coding mode */
EXTERN unsigned char De_alternate_horizontal_scan[64]
#ifdef GLOBAL
=
{
  0, 1, 2, 3, 8, 9, 16, 17, 10, 11, 4, 5, 6, 7, 15, 14,
  13, 12, 19, 18, 24, 25, 32, 33, 26, 27, 20, 21, 22, 23, 28, 29,
  30, 31, 34, 35, 40, 41, 48, 49, 42, 43, 36, 37, 38, 39, 44, 45,
  46, 47, 50, 51, 56, 57, 58, 59, 52, 53, 54, 55, 60, 61, 62, 63
}
#endif
;
EXTERN unsigned char De_alternate_vertical_scan[64]
#ifdef GLOBAL
=
{
  0, 8, 16, 24, 1, 9, 2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
  41, 33, 26, 18, 3, 11, 4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
  51, 59, 20, 28, 5, 13, 6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
  53, 61, 22, 30, 7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
}
#endif
;
EXTERN int De_bscan_tab[]

#ifdef GLOBAL
= {2, 4, 6, 8}
#endif
;
EXTERN int De_bquant_tab[]
#ifdef GLOBAL
= {5, 6, 7, 8}
#endif
;

EXTERN int De_OM[5][8][8]
#ifdef GLOBAL
= {
  {
    {4, 5, 5, 5, 5, 5, 5, 4},
    {5, 5, 5, 5, 5, 5, 5, 5},
    {5, 5, 6, 6, 6, 6, 5, 5},
    {5, 5, 6, 6, 6, 6, 5, 5},
    {5, 5, 6, 6, 6, 6, 5, 5},
    {5, 5, 6, 6, 6, 6, 5, 5},
    {5, 5, 5, 5, 5, 5, 5, 5},
    {4, 5, 5, 5, 5, 5, 5, 4},
  }, {
    {2, 2, 2, 2, 2, 2, 2, 2},
    {1, 1, 2, 2, 2, 2, 1, 1},
    {1, 1, 1, 1, 1, 1, 1, 1},
    {1, 1, 1, 1, 1, 1, 1, 1},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
  }, {
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {1, 1, 1, 1, 1, 1, 1, 1},
    {1, 1, 1, 1, 1, 1, 1, 1},
    {1, 1, 2, 2, 2, 2, 1, 1},
    {2, 2, 2, 2, 2, 2, 2, 2},
  }, {
    {0, 0, 0, 0, 1, 1, 1, 2},
    {0, 0, 0, 0, 1, 1, 2, 2},
    {0, 0, 0, 0, 1, 1, 2, 2},
    {0, 0, 0, 0, 1, 1, 2, 2},
    {0, 0, 0, 0, 1, 1, 2, 2},
    {0, 0, 0, 0, 1, 1, 2, 2},
    {0, 0, 0, 0, 1, 1, 2, 2},
    {0, 0, 0, 0, 1, 1, 1, 2},
  }, {
    {2, 1, 1, 1, 0, 0, 0, 0},
    {2, 2, 1, 1, 0, 0, 0, 0},
    {2, 2, 1, 1, 0, 0, 0, 0},
    {2, 2, 1, 1, 0, 0, 0, 0},
    {2, 2, 1, 1, 0, 0, 0, 0},
    {2, 2, 1, 1, 0, 0, 0, 0},
    {2, 2, 1, 1, 0, 0, 0, 0},
    {2, 1, 1, 1, 0, 0, 0, 0},
}}
#endif
;

EXTERN int De_roundtab[16]
#ifdef GLOBAL
= {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2}
#endif
;

EXTERN int De_MQ_chroma_QP_table[32]
#ifdef GLOBAL
 = {0, 1, 2, 3, 4, 5, 6, 6, 7, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 13, 13, 13, 
14, 14, 14, 14, 14, 15, 15, 15, 15, 15}
#endif
;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CBitStream::CBitStream()
{

////Initialize SAC part values start////////////// 
  low =0;
  high=0; 
  code_value =0;
  bit =0; 
  length=0; 
  sacindex =0; 
  cum =0; 
  zerorun =0;
////Initialize SAC part values end////////////// 
  m_ColorSpaceConvert = new CColorSpaceConvert();
  m_IDCTDecode        = new CIDCTDecode();
}

CBitStream::~CBitStream()
{
 if(m_ColorSpaceConvert !=NULL)
 {
	 delete m_ColorSpaceConvert;
	 m_ColorSpaceConvert = NULL;
 }
 if(m_IDCTDecode !=NULL)
 {
	 delete m_IDCTDecode;
	 m_IDCTDecode = NULL;
 }
}
void CBitStream::Setld(struct ld_struct* ldp)
{
	ld = ldp;
}
/* initialize buffer, call once before first getbits or showbits */

/////////////////////////////////////////////////////

void CBitStream::SetActualsize(long iActualsize)
{
   Actualsize = iActualsize;
}
//////////////function in getbits.c start//////////

#define BUFFER_LENGTH		2048

/* to mask the n least significant bits of an integer */
static unsigned int msk[33] =
{
	0x00000000, 0x00000001, 0x00000003, 0x00000007,
	0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
	0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
	0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,
	0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,
	0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,
	0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,
	0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,
	0xffffffff
};


/* initialize buffer, call once before first getbits or showbits */

void CBitStream::De_initbits ()
{
	ld->incnt = 0;
	ld->rdptr = ld->rdbfr + BUFFER_LENGTH;
	ld->bitcnt = 0;
}

void CBitStream::fillbfr ()
{
	int l;
	unsigned char *lptemp;
	ld->inbfr[0] = ld->inbfr[8];
	ld->inbfr[1] = ld->inbfr[9];
	ld->inbfr[2] = ld->inbfr[10];
	ld->inbfr[3] = ld->inbfr[11];

	if (ld->rdptr >= ld->rdbfr + BUFFER_LENGTH)
	{
		//l = read (ld->infile, ld->rdbfr, BUFFER_LENGTH);
		  /***************************************************/
		if(Actualsize>=BUFFER_LENGTH)
		{     
			lptemp=ld->input;
			memcpy(ld->rdbfr,lptemp,BUFFER_LENGTH);
			ld->input+=BUFFER_LENGTH;Actualsize-=BUFFER_LENGTH;
			l=BUFFER_LENGTH;
		}
		else
		{
			lptemp=ld->input;
			memcpy(ld->rdbfr,lptemp,Actualsize);
			ld->input+=Actualsize;
			l=Actualsize;
			Actualsize-=Actualsize;
		}
		/**********************************************************/
		ld->rdptr = ld->rdbfr;
		if (l < BUFFER_LENGTH)
		{
			if (l < 0)
			l = 0;

			while (l < BUFFER_LENGTH)          /* Add recognizable sequence end code */
			{
				ld->rdbfr[l++] = 0;
				ld->rdbfr[l++] = 0;
				ld->rdbfr[l++] = (1 << 7) | (SE_CODE << 2);
			}
		}
	}
	for (l = 0; l < 8; l++)
		ld->inbfr[l + 4] = ld->rdptr[l];

	ld->rdptr += 8;
	ld->incnt += 64;
}


/* return next n bits (right adjusted) without advancing */

unsigned int CBitStream::showbits (int n)
{
	unsigned char *v;
	unsigned int b;
	int c;

	if (ld->incnt < n)
		fillbfr ();

	v = ld->inbfr + ((96 - ld->incnt) >> 3);
	b = (v[0] << 24) | (v[1] << 16) | (v[2] << 8) | v[3];
	c = ((ld->incnt - 1) & 7) + 25;
	return (b >> (c - n)) & msk[n];
}


/* return next bit (could be made faster than getbits(1)) */

unsigned int CBitStream:: getbits1 ()
{
	return getbits (1);
}


/* advance by n bits */

void CBitStream::flushbits (int n)
{
	ld->bitcnt += n;
	ld->incnt -= n;
	if (ld->incnt < 0)
		fillbfr ();
}


/* return next n bits (right adjusted) */
/*
unsigned int getbits (int n)
{
	unsigned int l;

	l = showbits (n);
	flushbits (n);

	return l;
}
*/
unsigned int CBitStream::getbits (int n)
{
	unsigned char *v;
	unsigned int b;
	int c;

	if (ld->incnt < n)
		fillbfr ();

	v = ld->inbfr + ((96 - ld->incnt) >> 3);
	b = (v[0] << 24) | (v[1] << 16) | (v[2] << 8) | v[3];
	c = ((ld->incnt - 1) & 7) + 25;

	ld->bitcnt += n;
	ld->incnt -= n;

	return (b >> (c - n)) & msk[n];
}

//////////////function in getbits.c end ///////////

//////////////functions in getblk.cpp start ///////
void CBitStream::getblock (int comp, int mode, int INTRA_AC_DC, int Mode)
{
	int val, i, j, sign, val2;
	unsigned int code;
//	De_VLCtabI *tab;
	De_VLCtab *tab;
	short *bp;
	int run, last, level, QP;
	short *qval;

	/* store_code used in alternative inter VLC mode */
	int use_intra = 0;
	De_CodeCoeff store_code[64];
	int coeff_ind;

	bp = ld->block[comp];

	/* decode AC coefficients (or all coefficients in advanced intra coding
	* mode) */

	if (alternative_inter_VLC_mode && !(Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
	{
		coeff_ind = 0;
		use_intra = 0;
		for (i = (mode == 0);; i++)
		{
			code = showbits (12);
			store_code[coeff_ind].code = code;
			if (code >= 512)
				tab = &De_DCT3Dtab0[(code >> 5) - 16];
			else if (code >= 128)
				tab = &De_DCT3Dtab1[(code >> 2) - 32];
			else if (code >= 8)
				tab = &De_DCT3Dtab2[(code >> 0) - 8];
			else
			{
				fault = 1;
				return;
			}

			run = (tab->val >> 4) & 255;
			last = (tab->val >> 12) & 1;
			flushbits (tab->len);
			if (tab->val == ESCAPE)
			{
				//last = getbits1 ();
				last = getbits (1);
				store_code[coeff_ind].last = last;

				i += run = getbits (6);
				store_code[coeff_ind].run = run;

				level = getbits (8);
				store_code[coeff_ind].level = level;


				if (level == 128 && modified_quantization_mode)
				{
					level = getbits (11);
					store_code[coeff_ind].extended_level = level;
				}
			} 
			else
			{
				store_code[coeff_ind].sign = getbits (1);
				i += run;
			}
			coeff_ind += 1;

			if (i >= 64)
				use_intra = 1;
			if (last)
				break;
		}
	}
	coeff_ind = 0;

	for (i = (mode == 0);; i++)
	{
		if ((alternative_inter_VLC_mode) && !(Mode == MODE_INTRA || Mode == MODE_INTRA_Q))
		{
			if (use_intra)
			{
				if ((store_code[coeff_ind].code) >= 512)
					tab = &INTRA_DCT3Dtab0[((store_code[coeff_ind].code) >> 5) - 16];
				else if ((store_code[coeff_ind].code) >= 128)
					tab = &INTRA_DCT3Dtab1[((store_code[coeff_ind].code) >> 2) - 32];
				else if ((store_code[coeff_ind].code) >= 8)
					tab = &INTRA_DCT3Dtab2[((store_code[coeff_ind].code) >> 0) - 8];
				else
				{
					fault = 1;
					return;
				}
				run = (tab->val >> 6) & 63;
				level = tab->val & 63;
				last = (tab->val >> 12) & 1;
			} 
			else
			{
				if (store_code[coeff_ind].code >= 512)
					tab = &De_DCT3Dtab0[(store_code[coeff_ind].code >> 5) - 16];
				else if (store_code[coeff_ind].code >= 128)
					tab = &De_DCT3Dtab1[(store_code[coeff_ind].code >> 2) - 32];
				else if (store_code[coeff_ind].code >= 8)
					tab = &De_DCT3Dtab2[(store_code[coeff_ind].code >> 0) - 8];
				else
				{
					fault = 1;
					return;
				}

				run = (tab->val >> 4) & 255;
				level = tab->val & 15;
				last = (tab->val >> 12) & 1;
			}

			if (tab->val == ESCAPE)
			{                         /* escape */
				last = store_code[coeff_ind].last;

				i += run = store_code[coeff_ind].run;
				level = store_code[coeff_ind].level;

				if ((sign = (level >= 128)))