mblock.c

代码实现了基于ARM7的MPEG-4视频解码器

//********************************************
//File name:  mblock.c
//Author;     Anna
//Date:
//********************************************
#include <assert.h> 

#define I_VOP 0
#define P_VOP 1

#define NOT_CODED -1
#define INTER			0
#define INTER_Q	  1
#define INTER4V		2
#define INTRA			3
#define INTRA_Q	 	4
#define STUFFING	7

#define DEC_MBC         45
#define DEC_MBR         36
#define abs(a)					((a)>0 ? (a) : -(a))

extern int prediction_type;
extern int not_coded;
extern int mcbpc;
extern int derived_mb_type;
extern int cbpc;
extern int ac_pred_flag;
extern int cbpy;
extern int cbp;
extern int mb_xpos;
extern int mb_ypos;
extern int mb_width;
extern int quantizer;
extern int fcode_for;
extern int dquant;

extern int find_pmv(int block_num, int type);
extern int blockIntra(int block_num, int coded);
extern int blockInter();
extern void addblockIntra (int comp, int bx, int by);
extern void addblockInter (int comp, int bx, int by);
extern void reconstruct (int bx, int by, int mode);

unsigned int showbits(int n);
void flushbits(int n);
unsigned int getbits(int n);
static int getMCBPC();
static int getCBPY();
static int setMV(int block_num);
static int getMVdata();

extern int  MCBPCtabIntra_val[32];
extern int  MCBPCtabIntra_len[32];
extern int  CBPYtab_val[48];
extern int CBPYtab_len[48];
extern int	quant_store[DEC_MBR+1][DEC_MBC+1]; // [Review]
extern int	modemap[DEC_MBR+1][DEC_MBC+2];
extern int	MV[2][6][DEC_MBR+1][DEC_MBC+2];


typedef struct {
	int val, len;
} tab_type;

extern tab_type MCBPCtabInter[256];
extern tab_type MVtab0[14];
extern tab_type MVtab1[96];
extern tab_type MVtab2[124];

extern int DQtab[4];

//extern int blockintra_num;
           

int macroblock()
{
   int j;
   int intraFlag,interFlag;
  
   if (prediction_type != I_VOP)
	  not_coded = getbits(1);
   
    // coded macroblock or I-VOP
    if (!not_coded || prediction_type == I_VOP) {
     
     mcbpc = getMCBPC(); // mcbpc 
     derived_mb_type = mcbpc & 7;
	 cbpc = (mcbpc >> 4) & 3;
	 
	 modemap[mb_ypos+1][mb_xpos+1] = 
			derived_mb_type; // [Review] used only in P-VOPs

     intraFlag = ((derived_mb_type == INTRA) || 
			(derived_mb_type == INTRA_Q)) ? 1 : 0;
	 interFlag = (! intraFlag);
	 
	 if (intraFlag)
			ac_pred_flag = getbits(1);
		if (derived_mb_type != STUFFING) {

			cbpy = getCBPY(); // cbpy
			cbp = (cbpy << 2) | cbpc;
		}
		else
			return 1;
			
	if (derived_mb_type == INTER_Q ||
			derived_mb_type == INTRA_Q) {

			dquant = getbits(2);
			quantizer += DQtab[dquant];
			if (quantizer > 31)
				quantizer = 31;
			else if (quantizer < 1)
				quantizer = 1;
		}
		if (derived_mb_type == INTER ||
			derived_mb_type == INTER_Q) {

			setMV(-1); // mv
		}
		else if (derived_mb_type == INTER4V) {

			for (j = 0; j < 4; j++) {

			  setMV(j); // mv             
			}
		}
		else { // intra
			if (prediction_type == P_VOP) {
				int i;
				for (i = 0; i < 4; i++) {
					MV[0][i][mb_ypos+1][mb_xpos+1] = 0;
					MV[1][i][mb_ypos+1][mb_xpos+1] = 0;
				}
			}
		}
		
		// motion compensation
		if (interFlag) 
		{
		   
			reconstruct(mb_xpos, mb_ypos, derived_mb_type);

			// texture decoding add
			for (j = 0; j < 6; j++) {
				int coded = cbp & (1 << (5 - j));

				if (coded) { 
					blockInter(j, (coded != 0));
					addblockInter(j, mb_xpos, mb_ypos);
				}
			}
		}
		else 
		{
			// texture decoding add
			
			for(j=0;j<6;j++)
		    {
				int coded = cbp & (1 << (5 - j));
				
                blockIntra(j, (coded != 0));
				addblockIntra(j, mb_xpos, mb_ypos);
				//blockintra_num = blockintra_num+1;
			}
		}	
			
    }// coded macroblock or I-VOP
    
   // not coded macroblock
	else {

		MV[0][0][mb_ypos+1][mb_xpos+1] = MV[0][1][mb_ypos+1][mb_xpos+1] =
		MV[0][2][mb_ypos+1][mb_xpos+1] = MV[0][3][mb_ypos+1][mb_xpos+1] = 0;
		MV[1][0][mb_ypos+1][mb_xpos+1] = MV[1][1][mb_ypos+1][mb_xpos+1] =
		MV[1][2][mb_ypos+1][mb_xpos+1] = MV[1][3][mb_ypos+1][mb_xpos+1] = 0;

		modemap[mb_ypos+1][mb_xpos+1] = NOT_CODED; // [Review] used only in P-VOPs

		reconstruct(mb_xpos, mb_ypos, derived_mb_type);
	} 
      
    quant_store[mb_ypos+1][mb_xpos+1] = quantizer;

	if (mb_xpos < (mb_width-1)) {
		mb_xpos++;
	}
	else {
		mb_ypos++;
		mb_xpos = 0;
	}

	return 1;
	
}//first end

/***/
static int getMCBPC()
{
	if (prediction_type == I_VOP)
	{
		int code = showbits(9);

		if (code == 1) {
			flushbits(9); // stuffing
			return 0;
		}
		else if (code < 8) {
			return -1;
		}

		code >>= 3;
		if (code >= 32) {
			flushbits(1);
			return 3;
		}
		
		flushbits(MCBPCtabIntra_len[code]);
		return MCBPCtabIntra_val[code];
	}
	else
	{
		int code = showbits(9);

		if (code == 1) {
			flushbits(9); // stuffing
			return 0;
		}
		else if (code == 0)	{
			return -1;
		}
		
		if (code >= 256)
		{
			flushbits(1);
			return 0;
		}
		
		flushbits(MCBPCtabInter[code].len);
		return MCBPCtabInter[code].val;
	}
}

/***/
static int getCBPY()
{
	int cbpy;
	int code = showbits(6);

	if (code < 2) {
		return -1;
	}
			  
	if (code >= 48) {
		flushbits(2);
		cbpy = 15;
	} else {
		flushbits(CBPYtab_len[code]);
		cbpy = CBPYtab_val[code];
	}

	if (!((derived_mb_type == 3) ||
		(derived_mb_type == 4)))
		  cbpy = 15 - cbpy;

  return cbpy;
}

/***/
static int setMV(int block_num)
{
	int hor_mv_data, ver_mv_data, hor_mv_res, ver_mv_res;
	int scale_fac = 1 << (fcode_for - 1);
	int high = (32 * scale_fac) - 1;
	int low = ((-32) * scale_fac);
	int range = (64 * scale_fac);

	int mvd_x, mvd_y, pmv_x, pmv_y, mv_x, mv_y;


/***

	[hor_mv_data]
	if ((vop_fcode_forward != 1) && (hor_mv_data != 0))
		[hor_mv_residual]

***/	

  hor_mv_data = getMVdata(); // mv data

	if ((scale_fac == 1) || (hor_mv_data == 0))
		mvd_x = hor_mv_data;
	else {
		hor_mv_res = getbits(fcode_for-1); // mv residual
		mvd_x = ((abs(hor_mv_data) - 1) * scale_fac) + hor_mv_res + 1;
		if (hor_mv_data < 0)
			mvd_x = - mvd_x;
	}

  ver_mv_data = getMVdata(); 

	if ((scale_fac == 1) || (ver_mv_data == 0))
		mvd_y = ver_mv_data;
	else {
		ver_mv_res = getbits(fcode_for-1);
		mvd_y = ((abs(ver_mv_data) - 1) * scale_fac) + ver_mv_res + 1;
		if (ver_mv_data < 0)
			mvd_y = - mvd_y;
	}

	if (block_num == -1) {
		pmv_x = find_pmv(0, 0);
		pmv_y = find_pmv(0, 1);
	}
	else {
		pmv_x = find_pmv(block_num, 0);
		pmv_y = find_pmv(block_num, 1);
	}

//	_Print("Hor MotV Pred: %d\n", pmv_x);
//	_Print("Ver MorV Pred: %d\n", pmv_y);

	mv_x = pmv_x + mvd_x;

	if (mv_x < low)
		mv_x += range;
	if (mv_x > high)
        mv_x -= range;

	mv_y = pmv_y + mvd_y;

	if (mv_y < low)
		mv_y += range;
	if (mv_y > high)
		mv_y -= range;

	// put [mv_x, mv_y] in MV struct
	if (block_num == -1) {
		int i;
		for (i = 0; i < 4; i++) {
			MV[0][i][mb_ypos+1][mb_xpos+1] = mv_x;
			MV[1][i][mb_ypos+1][mb_xpos+1] = mv_y;
		}
	}
	else {
		MV[0][block_num][mb_ypos+1][mb_xpos+1] = mv_x;
		MV[1][block_num][mb_ypos+1][mb_xpos+1] = mv_y;
	}

//  _Print("Hor MotV: %d\n", mv_x);
//	_Print("Ver MotV: %d\n", mv_y);

  return 1;
}

/***/

static int getMVdata()
{
	int code;

	if (getbits(1)) {
		return 0; // hor_mv_data == 0
  }
	
	code = showbits(12);

	if (code >= 512)
  {
		code = (code >> 8) - 2;
		flushbits(MVtab0[code].len);
		return MVtab0[code].val;
  }
	
	if (code >= 128)
  {
		code = (code >> 2) - 32;
		flushbits(MVtab1[code].len);
		return MVtab1[code].val;
  }

	code -= 4; 

	assert(code >= 0);

	flushbits(MVtab2[code].len);
	return MVtab2[code].val;
}

/***/