header.c

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

//*********************************************
//File name:  header.c
//Author:     Anna
//Date:    
//*********************************************
#include <math.h>

#define VOL_CODE    0x120  
#define VOL_START_CODE	0x12  
#define VOP_START_CODE	0x1b6
#define VOP_CODE    0xB6  


#define BINARY_SHAPE_ONLY 2 
#define GRAY_SCALE		  3
#define P_VOP		1
#define I_VOP       0


extern int vop_flag1;
extern int vop_flag2;
extern int voflag;
extern int volflag;
extern int bef_vol_value;
extern int bef_vop_value;
extern int vop_notbeh_vol;


extern int ident;
extern int random_accessible_vol;
extern int type_indication;
extern int is_object_layer_identifier;
extern int visual_object_layer_verid;
extern int visual_object_layer_priority;
extern int aspect_ratio_info;
extern int vol_control_parameters;
extern int chroma_format;
extern int low_delay;
extern int vbv_parameters;
extern int first_half_bit_rate;
extern int latter_half_bit_rate;
extern int first_half_vbv_buffer_size;
extern int latter_half_vbv_buffer_size;
extern int first_half_vbv_occupancy;
extern int latter_half_vbv_occupancy;
extern int shape;
extern int time_increment_resolution;
extern int fixed_vop_rate;
extern int width;
extern int height;
extern int interlaced;
extern int obmc_disable;
extern int sprite_usage;
extern int not_8_bit;
extern int quant_precision;
extern int bits_per_pixel;
extern int quant_type;
extern int quarter_pixel;
extern int complexity_estimation_disable;
extern int error_res_disable;
extern int data_partitioning;
extern int error_res_disable; 
extern int intra_acdc_pred_disable;
extern int scalability;
extern int prediction_type;
extern int time_base;
extern int time_inc;
extern int vop_coded;
extern int rounding_type;
extern int intra_dc_vlc_thr;
extern int quantizer;
extern int fcode_for;
extern int shape_coding_type;
extern int fixed_vop_time_increment;



extern int bitcnt;


extern unsigned int showbits (int n);
extern void flushbits (int n);
extern unsigned int getbits (int n);
void __inline next_start_code();
extern void _Print(const char * format, ...);


int getvolhdr(int n)
{
  vop_flag2=0;
  
 if (getbits(28) != VOL_START_CODE)
		{
			exit(101);
		}
		
    ident = getbits(4); // vol_id
    random_accessible_vol = getbits(1);
    type_indication = getbits(8); 
    is_object_layer_identifier = getbits(1);
  
    if (is_object_layer_identifier) {
			visual_object_layer_verid = getbits(4);
			visual_object_layer_priority = getbits(3);
		} 
    else {
	   visual_object_layer_verid = 1;
	   visual_object_layer_priority = 1;
	  }
	 
	aspect_ratio_info = getbits(4);
	vol_control_parameters = getbits(1);
	if (vol_control_parameters) {
			chroma_format = getbits(2);
			low_delay = getbits(1);
			vbv_parameters = getbits(1);
		 if(vbv_parameters) {
			first_half_bit_rate = getbits(15);
			getbits(1); // marker
			latter_half_bit_rate = getbits(15);
			getbits(1); // marker
			first_half_vbv_buffer_size = getbits(15);
			getbits(1); // marker
			latter_half_vbv_buffer_size = getbits(3);
			first_half_vbv_occupancy = getbits(11);
			getbits(1); // marker
			latter_half_vbv_occupancy = getbits(15);
			getbits(1); // marker
			}			
	}
	shape = getbits(2);
	getbits(1); // marker 	
	time_increment_resolution = getbits(16);
	getbits(1); // marker
	fixed_vop_rate = getbits(1);
	
	if (fixed_vop_rate) {
			int bits = (int) ceil(log((double)time_increment_resolution)/log(2.0));
			if (bits < 1) 
				bits = 1;
			fixed_vop_time_increment = getbits(bits);
		}
	
	if (shape != BINARY_SHAPE_ONLY) 
	{
	   if(shape == 0)
	   {
		getbits(1); // marker
		width = getbits(13);
		getbits(1); // marker
		height = getbits(13);
		getbits(1); // marker
	   }
	  
	   interlaced = getbits(1);
	   obmc_disable = getbits(1);
	  
	   if (visual_object_layer_verid == 1) {
		  sprite_usage = getbits(1);
	   } 
	   else {
	       sprite_usage = getbits(2);
			} 
			
	   not_8_bit = getbits(1);
	   if (not_8_bit) 
	   {
		quant_precision = getbits(4);
		bits_per_pixel = getbits(4);
	   }
	   else
	   {
	    quant_precision = 5;
		bits_per_pixel = 8;
	   }
	   
	   if(shape == GRAY_SCALE) {
		  exit(102);
	   }
	   
	   quant_type = getbits(1); // quant type
	   
	   if (visual_object_layer_verid/*ident*/ != 1) {
		   quarter_pixel = getbits(1);
	    } else {
		   quarter_pixel = 0;
		}
		
		complexity_estimation_disable = getbits(1);
		error_res_disable = getbits(1);
		data_partitioning = getbits(1);
	    if (data_partitioning) {
			exit(102);
		}	
		else {
			error_res_disable = 1;
		} 
		
		intra_acdc_pred_disable = 0;
		scalability = getbits(1);
		
		if (scalability)	{
			exit(103);
		}

/*read the bits before next vop_start_code*/
       next_start_code(); 	
do 
{
     vop_flag1 = 0;
	 bef_vop_value = showbits(8);
	 if (bef_vop_value == 0x00)
	 {
          flushbits(8);  
		  bef_vop_value = showbits(8);

		  if (bef_vop_value == 0x00)
		  {
			 flushbits(8);
			 bef_vop_value = showbits(8);
			  
			  if (bef_vop_value == 0x01 || bef_vop_value == 0x00 )
			  {
				  while (bef_vop_value == 0x00)
				  {
					  flushbits (8);
					  bef_vop_value = showbits(8);
				  }

				  if (bef_vop_value == 0x01)
				  {
					  flushbits (8);
					  bef_vop_value = showbits (8);
				  }
				  if (bef_vop_value == 0xB6)
				  {
                    vop_flag1 = 1;
				  }
			  }
		  }
	 }
	 
	 if (vop_flag1 !=1)
	 {
       flushbits (8);
	 }
}
while (vop_flag1 != 1);		
		
} //if (shape != BINARY_SHAPE_ONLY)
  return 1;
}

/***/ 
int getvophdr(int n)
{
   if(	vop_notbeh_vol==1 )
   { 
	  if(getbits(32) != (int) VOP_START_CODE)
       {
		_Print("Vop start_code NOT found\n");
		return 0;
       }
   }
   else
   {	 

	  if(getbits(8) != (int) VOP_CODE)
      {
		_Print("Vop start_code NOT found\n");
		return 0;
      }
    }
  
    prediction_type = getbits(2);
    
    while (getbits(1) == 1) // temporal time base
    {
	 time_base++;
    }
    getbits(1);//marker bit
    {
     int bits = (int) ceil(log(time_increment_resolution)/log(2.0));
	 if (bits < 1) bits = 1;
		
	 time_inc = getbits(bits); // vop_time_increment (1-16 bits)
    }
    
    getbits(1); // marker bit
	vop_coded = getbits(1);
    if (vop_coded == 0) 
	{
	  next_start_code();
	  return 1;
	}
	
	if ((shape != BINARY_SHAPE_ONLY) &&
		(prediction_type == P_VOP)) 
	{
	  rounding_type = getbits(1);
	} else {
	  rounding_type = 0;
	} 
	
	if (!(complexity_estimation_disable)) {
		exit(108);
	}
	
	if (shape != BINARY_SHAPE_ONLY)  
    { 
		intra_dc_vlc_thr = getbits(3);
		if (interlaced) {
			exit(109);
		 }
    }
    
    if (shape != BINARY_SHAPE_ONLY) 
    { 
		quantizer = getbits(quant_precision); // vop quant

		if (prediction_type != I_VOP) 
		{
			fcode_for = getbits(3); 
		}
		
		if (! scalability) {
			if (shape && prediction_type!=I_VOP)
			  shape_coding_type = getbits(1); // vop shape coding type
				
		 }
	 } 
	 
	 return 1;
}//first





/***/
int readbefvol(int n)
{ 
if (vop_flag2 !=1)
{
do
{
  voflag = 0;
  volflag = 0;

  bef_vol_value = showbits(8);
	
	if (bef_vol_value == 0x00)
	{
		flushbits (8);
		bef_vol_value = showbits(8);
	
	    if (bef_vol_value == 0x00)
		{
		  flushbits (8);
		  bef_vol_value = showbits(8);
		
		  if (bef_vol_value == 0x01 || bef_vol_value == 0x00)
		  { 
			  while (bef_vol_value == 0x00)
			  {
				flushbits(8);
				bef_vol_value = showbits(8);

			  }
			  if (bef_vol_value == 0x01)
			  {
				  flushbits(8);
				  bef_vol_value = showbits(8);

			  }
				  
			if (bef_vol_value == 0x00)
			{
				flushbits (8);

				bef_vol_value = showbits(32);

				voflag = 1;
				//voflagnum++;
		
				if (bef_vol_value ==VOL_CODE)
				{
				 volflag = 1;
				 
				}
				
				
			}
		  }
		}
	}

if (voflag !=1)
{
    flushbits (8);
}
}
 while (volflag != 1);

} // if (vop_flag2 !=1)

return 1;
}

/***/
// Purpose: look nbit forward for an alignement
int __inline bytealigned(int nbit) 
{
	return (((bitcnt + nbit) % 8) == 0);
}

void __inline next_start_code()
{
  getbits(1);

  // bytealign
  while (! bytealigned(0)) {
		flushbits(1);
  }
 }
 
 int  nextbits_bytealigned(int nbit)
{
	int code;
	int skipcnt = 0;

	if (bytealigned(skipcnt))
	{
		// stuffing bits
		if (showbits(8) == 127) {
			skipcnt += 8;
		}
	}
	else
	{
		// bytealign
		while (! bytealigned(skipcnt)) {
			skipcnt += 1;
		}
	}

	code = showbits(nbit + skipcnt);
	return ((code << skipcnt) >> skipcnt);
}