macroblock.c

avs-s最新代码,包括编码器和解码器源码

		}
	}
	// !! end shenyanfei

	currMB->cbp     = 0 ;
	currMB->cbp_blk = 0 ;
	sum_cnt_nonz    = 0 ;

	for (block8x8=stage_block8x8_pos/*lgp*/; block8x8<4; block8x8++)
	{
		int bw_ref;

		SetModesAndRefframe (block8x8, &fw_mode, &bw_mode, &refframe, &bw_ref);

		skipped    = (fw_mode == 0 && bw_mode == 0 && (img->type!=B_IMG));
		sum_cnt_nonz += LumaResidualCoding8x8 (&(currMB->cbp), &(currMB->cbp_blk), block8x8,fw_mode, bw_mode, refframe, bw_ref);
	}

	if (sum_cnt_nonz <= 5)
	{
		currMB->cbp     &= 0xfffff0 ;
		currMB->cbp_blk &= 0xff0000 ;
		for (i=0; i < MB_BLOCK_SIZE; i++)
		{
			for (j=0; j < MB_BLOCK_SIZE; j++)
			{
				imgY[img->pix_y+j][img->pix_x+i]=img->mpr[i][j];
			}
		}
	}
}

/*
*************************************************************************
* Function: Predict one component of a chroma 4x4 block
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

void
OneComponentChromaPrediction4x4 (int*     mpred,      //  --> array to store prediction values
								 int      pix_c_x,    // <--  horizontal pixel coordinate of 4x4 block
								 int      pix_c_y,    // <--  vertical   pixel coordinate of 4x4 block
								 int***** mv,         // <--  motion vector array
								 int      ref,        // <--  reference frame parameter (0.../ -1: backward)
								 int      blocktype,  // <--  block type
								 int      uv,
								 int      directforword)         // <--  chroma component
{
	int     i, j, ii, jj, ii0, jj0, ii1, jj1, if0, if1, jf0, jf1;
	int     incr;
	int*    mvb;
	int     refframe  = (ref<0 ?      0 :    ref);
	pel_t** refimage;
	int     je        = pix_c_y + 4;
	int     ie        = pix_c_x + 4;
	int     f1        = 8 , f2=f1-1, f3=f1*f1, f4=f3>>1;
	int     s1        = 3;
	int     img_pic_c_x = img->pix_c_x;
	int     img_pic_c_y = img->pix_c_y;
	int     scale   = 1;
	int field_mode;
	int     fpred = ref < 0 ? 0: 1;

	//xyji 11.27
	if (!img->picture_structure) // field coding
	{
		if (img->type==B_IMG)
			refframe = ref<0 ? ref+2 : ref;
	}

	field_mode = (!img->picture_structure);


	incr = 1;
	if(img->type==B_IMG && !img->picture_structure)
		incr = 2;

	ref = (img->type==B_IMG) ? ref+incr : ref;

	refimage  = mcef [ref][uv];

#ifdef BACKGROUND
	if(img->typeb == BP_IMG)
		refimage  = background_frame[uv + 1];
#endif

	field_mode = (!img->picture_structure);


	for (j=pix_c_y; j<je; j++)
		for (i=pix_c_x; i<ie; i++)
		{
			mvb  = mv [(i-img_pic_c_x)>>2][(j-img_pic_c_y)>>2][refframe][blocktype];
			ii   = (i<<s1) + mvb[0];
			jj   = (j<<s1) + mvb[1];

			ii0  = max (0, min (img->width_cr -1, ii>>s1     ));
			jj0  = max (0, min (img->height_cr/scale-1, jj>>s1     ));    // For MB level field/frame -- scale chroma height by 2
			ii1  = max (0, min (img->width_cr -1, (ii+f2)>>s1));
			jj1  = max (0, min (img->height_cr/scale-1, (jj+f2)>>s1));

			if1  = (ii&f2);  if0 = f1-if1;
			jf1  = (jj&f2);  jf0 = f1-jf1;

			*mpred++ = (if0 * jf0 * refimage[jj0][ii0] +
				if1 * jf0 * refimage[jj0][ii1] +
				if0 * jf1 * refimage[jj1][ii0] +
				if1 * jf1 * refimage[jj1][ii1] + f4) / f3;
		}
}


/*
*************************************************************************
* Function:Predict one component of a chroma 4x4 block
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

void
OneComponentChromaPrediction4x4_dir (int*     mpred,      //  --> array to store prediction values
									 int      pix_c_x,    // <--  horizontal pixel coordinate of 4x4 block
									 int      pix_c_y,    // <--  vertical   pixel coordinate of 4x4 block
									 int***** mv,         // <--  motion vector array
									 int      ref,        // <--  reference frame parameter (0.../ -1: backward)
									 int      blocktype,  // <--  block type
									 int      uv,
									 int		refframe
									 )
{
	int     i, j, ii, jj, ii0, jj0, ii1, jj1, if0, if1, jf0, jf1;
	int     incr;
	int*    mvb;
	//int     refframe  = (ref<0 ?      0 :    ref);
	pel_t** refimage;
	int     je        = pix_c_y + 4;
	int     ie        = pix_c_x + 4;
	int     f1        = 8 , f2=f1-1, f3=f1*f1, f4=f3>>1;
	int     s1        = 3;
	int     img_pic_c_y = img->pix_c_y;
	int   scale   = 1;
	int field_mode;


	incr = 1;
	if(img->type==B_IMG && !img->picture_structure)
		incr = 2;

	ref = (img->type==B_IMG) ? ref+incr : ref;

	field_mode = (!img->picture_structure);
	refimage  = mcef [ref][uv];


	for (j=pix_c_y; j<je; j++)
		for (i=pix_c_x; i<ie; i++)
		{
			//xyji 11.27
			//sw 9.30
			mvb  = mv [(i-img->pix_c_x)>>2][(j-img_pic_c_y)>>2][refframe][blocktype];
			{	   
				int delta_P,TRp,DistanceIndexFw,DistanceIndexBw,delta_PB;		   
				delta_P = 2*(img->imgtr_next_P_frm - img->imgtr_last_P_frm);
				delta_P = (delta_P + 512)%512;  // Added by Xiaozhen ZHENG, 2007.05.05
				if(img->picture_structure)
					TRp = (refframe+1)*delta_P;  //the lates backward reference
				else
				{
					TRp = delta_P;//refframe == 0 ? delta_P-1 : delta_P+1;
				}

				delta_PB = 2*(picture_distance - img->imgtr_last_P_frm);     // Tsinghua 200701
				TRp  = (TRp + 512)%512;
				delta_PB = (delta_PB + 512)%512;  // Added by Xiaozhen ZHENG, 2007.05.05

				if(!img->picture_structure)
				{
					if(img->current_mb_nr_fld < img->total_number_mb) //top field
						DistanceIndexFw =  refframe == 0 ? delta_PB-1:delta_PB;
					else
						DistanceIndexFw =  refframe == 0 ? delta_PB:delta_PB+1;
				}	
				else
					DistanceIndexFw = delta_PB;  

				//DistanceIndexBw    = TRp - DistanceIndexFw;
				DistanceIndexBw    = (TRp - DistanceIndexFw+512)%512; // Added by Zhijie Yang, 20070419, Broadcom

				ii   = (i<<s1) - ((mvb[0]*DistanceIndexBw*(512/DistanceIndexFw)+256)>>9);
				jj   = (j<<s1) - ((mvb[1]*DistanceIndexBw*(512/DistanceIndexFw)+256)>>9);

#ifdef half_pixel_compensation
				if(!img->picture_structure)
				{
					int delt, delt2;
					MV_compensation_sym(&delt, &delt2, 1-refframe, refframe); 
					assert(delt2 == delt);

					// ii   = (i<<s1) - ((mvb[0]*DistanceIndexBw*(512/DistanceIndexFw)+256)>>9);
					jj   = (j<<s1) - (((mvb[1]+delt)*DistanceIndexBw*(512/DistanceIndexFw)+256)>>9) - delt2;
				}
#endif
			}

			ii0  = max (0, min (img->width_cr -1, ii>>s1     ));
			jj0  = max (0, min (img->height_cr/scale-1, jj>>s1     ));    // For MB level field/frame -- scale chroma height by 2
			ii1  = max (0, min (img->width_cr -1, (ii+f2)>>s1));
			jj1  = max (0, min (img->height_cr/scale-1, (jj+f2)>>s1));

			if1  = (ii&f2);  if0 = f1-if1;
			jf1  = (jj&f2);  jf0 = f1-jf1;

			*mpred++ = (if0 * jf0 * refimage[jj0][ii0] +
				if1 * jf0 * refimage[jj0][ii1] +
				if0 * jf1 * refimage[jj1][ii0] +
				if1 * jf1 * refimage[jj1][ii1] + f4) / f3;
		}
}

/*
*************************************************************************
* Function:Predict an intra chroma 4x4 block
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

void IntraChromaPrediction4x4 (int  uv,       // <-- colour component
							   int  block_x,  // <-- relative horizontal block coordinate of 4x4 block
							   int  block_y)  // <-- relative vertical   block coordinate of 4x4 block
{
	int mode = img->mb_data[img->current_mb_nr].c_ipred_mode;
	int i, j;
	//===== prediction =====
	for (j=block_y; j<block_y+4; j++)
		for (i=block_x; i<block_x+4; i++)
		{
			img->mpr[i][j] = img->mprr_c[uv][mode][i][j];
		}
}

/*
*************************************************************************
* Function:Predict one chroma 4x4 block
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

void
ChromaPrediction4x4 (int  uv,           // <-- colour component
					 int  block_x,      // <-- relative horizontal block coordinate of 4x4 block
					 int  block_y,      // <-- relative vertical   block coordinate of 4x4 block
					 int  fw_mode,      // <-- forward  prediction mode (1-7, 0=DIRECT if bw_mode=0)
					 int  bw_mode,      // <-- backward prediction mode (1-7, 0=DIRECT if fw_mode=0)
					 int  fw_ref_frame, // <-- reference frame for forward prediction (if (<0) -> intra prediction)
					 int  bw_ref_frame) // <-- reference frame for backward prediction 
{
	static int fw_pred[16];
	static int bw_pred[16];

	int  i, j;
	int  block_x4  = block_x+4;
	int  block_y4  = block_y+4;
	int  pic_pix_x = img->pix_c_x + block_x;
	int  pic_pix_y = img->pix_c_y + block_y;
	int* fpred     = fw_pred;
	int* bpred     = bw_pred;
	int  by = block_y >>2;
	int  bx = block_x >>2;

	int  direct    = (fw_mode == 0 && bw_mode == 0 && (img->type==B_IMG));

	int  skipped   = (fw_mode == 0 && bw_mode == 0 && (img->type!=B_IMG));
	int  *****fmv_array = (fw_mode && bw_mode)?img->all_omv:img->all_mv;    // For MB level frame/field coding

	int***** bmv_array = img->all_bmv;
	int fw_ref_idx, bw_ref_idx;
	int scale_frame;

	int directforward = (img->type==B_IMG && fw_mode==0);

	int fw_scale , fw_shift ;
	int bw_scale , bw_shift ;
	int bw_ref_num ;
	int fw_ref_num ;
	int  DistanceIndexRef = 0; //zj
	int  DistanceIndexCur = 0;
	int  DistanceIndexFw0 = 0;


	// zj
	direct_mode = direct;

	//===== INTRA PREDICTION =====
	if (fw_ref_frame < 0)
	{
		IntraChromaPrediction4x4 (uv, block_x, block_y);
		return;
	}

#ifndef COREFRAME
	if (direct)    
	{
		fw_ref_frame= 0;//max(refFrArr[ipdirect_y][ipdirect_x],0);
		bw_ref_frame= 0;//min(refFrArr[ipdirect_y][ipdirect_x],0);
		if(!img->picture_structure)
		{
			scale_frame = refFrArr[img->block8_y + by][img->block8_x+bx];
			bw_ref_frame = 0;//-1; xyji 11.25
			if (img->current_mb_nr_fld < img->total_number_mb)
			{
				fw_ref_frame =  scale_frame >= 1 ? 1 : 0;
				bw_ref_frame = scale_frame >= 0 ? 1 : 0;
			}
			else
			{
				fw_ref_frame = (scale_frame == 1 || scale_frame < 0)? 0 : 1; 
				bw_ref_frame = 0;
			}

			if(scale_frame < 0)
				bw_ref_frame = 1;
		}
	}
#else
	if (direct)    
	{
		fw_ref_frame= 0;//max(refFrArr[ipdirect_y][ipdirect_x],0);
		bw_ref_frame= 0;//min(refFrArr[ipdirect_y][ipdirect_x],0);
		if(!img->picture_structure)
		{
			scale_frame = refFrArr[img->block8_y + by][img->block8_x+bx];
			bw_ref_frame = 0;//-1; xyji 11.25
			//核心帧修改
			if(img->current_mb_nr_fld < img->total_number_mb) //top field
			{
				//DistanceIndexCur
				DistanceIndexCur = 2*picture_distance;
				//DistanceIndexRef
				if (scale_frame==0)
				{
					DistanceIndexRef = 2*img->imgtr_last_P_frm+1;
					//核心帧
					if(img->img_next_is_core_frame==1)
						DistanceIndexRef = 2*img->img_next_core_frame_ref_distance+1;
				}
				else if (scale_frame==1)
				{
					DistanceIndexRef = 2*img->imgtr_last_P_frm;
					//核心帧
					if(img->img_next_is_core_frame==1)
						DistanceIndexRef = 2*img->img_next_core_frame_ref_distance;
				}
				else if (scale_frame==2)
				{
					DistanceIndexRef = 2*img->imgtr_last_last_P_frm+1;
				}
				else if (scale_frame==3)
				{
					DistanceIndexRef = 2*img->imgtr_last_last_P_frm;
				}
				DistanceIndexFw0 = 2*img->imgtr_last_P_frm+1;

				//DistanceIndexFw
				if (DistanceIndexRef == DistanceIndexFw0)
				{
					fw_ref_frame = 0;//fw reference        
				}
				else
				{
					fw_ref_frame = 1;
				}
				//DistanceIndexBw
				bw_ref_frame = 1;//bw reference

			}
			else
			{
				//DistanceIndexCur
				DistanceIndexCur = 2*picture_distance+1;
				//DistanceIndexRef
				if (scale_frame==0)
				{
					DistanceIndexRef = 2*img->imgtr_next_P_frm;
				}
				else if (scale_frame==1)
				{
					DistanceIndexRef = 2*img->imgtr_last_P_frm+1;
					//核心帧
					if(img->img_next_is_core_frame==1)
						DistanceIndexRef = 2*img->img_next_core_frame_ref_distance+1;
				}
				else if (scale_frame==2)
				{
					DistanceIndexRef = 2*img->imgtr_last_P_frm;
					//核心帧
					if(img->img_next_is_core_frame==1)
						DistanceIndexRef = 2*img->img_next_core_frame_ref_distance;
				}
				else if (scale_frame==3)
				{
					DistanceIndexRef = 2*img->imgtr_last_last_P_frm+1;