mot_est_mb.c

VC++视频开发实例集锦(包括“远程视频监控”"语音识别系统"等13个经典例子)

#include "mot_util.h"
#define ABSDOUBLE(x)   (((x) > 0.0001) ? (x) : (((x) < -0.0001) ? -(x): 0.0 ))
#define ARE_EQUAL(x,y) ( (ABSDOUBLE((Float)(x)-(y))>0.1)?(0):(1) )
#define INDEX_BIG(x,y) ((x)+(y)*(vop_width))
#define INDEX_NOR(x,y) ((x)+(y)*(MB_SIZE))
static Void
RangeInSearchArea(
Int     i,										  
Int     j,										  
Int     block,									  
Int     prev_x,									  
Int     prev_y,									  
Int     vop_width,								  
Int     vop_height,								  
Int     br_x,									  
Int     br_y,									  
Int     edge,									  
Int     f_code,									  
Float   *mv_x_min,								  
Float   *mv_x_max,								  
Float   *mv_y_min,								  
Float   *mv_y_max,								  
Int     *out									  												  
)
{
	Int   dim_curr_x_max,
		dim_curr_y_max,
		dim_curr_x_min,
		dim_curr_y_min;
	Int   dim_prev_x_max,
		dim_prev_y_max,
		dim_prev_x_min,
		dim_prev_y_min;
	Int   mb_b_size,
		block_x,
		block_y;
	*out=0;
	switch (block)
	{
		case 0:									  
			block_x=0;							  
			block_y=0;							  
			mb_b_size=MB_SIZE;					  
			break;								  
		case 1:
			block_x=0;
			block_y=0;
			mb_b_size=B_SIZE;
			break;
		case 2:
			block_x=B_SIZE;
			block_y=0;
			mb_b_size=B_SIZE;
			break;
		case 3:
			block_x=0;
			block_y=B_SIZE;
			mb_b_size=B_SIZE;
			break;
		case 4:
			block_x=B_SIZE;
			block_y=B_SIZE;
			mb_b_size=B_SIZE;
			break;
		default:
			return;
	}
	
	dim_curr_x_min=(Int)(br_x+i*MB_SIZE+*mv_x_min+block_x);
	dim_curr_y_min=(Int)(br_y+j*MB_SIZE+*mv_y_min+block_y);
	dim_prev_x_min=prev_x;
	dim_prev_y_min=prev_y;
	
	
	dim_curr_x_max=(Int)(br_x+i*MB_SIZE+*mv_x_max+mb_b_size+block_x);
	
	dim_curr_y_max=(Int)(br_y+j*MB_SIZE+*mv_y_max+mb_b_size+block_y);
	dim_prev_x_max=prev_x+vop_width ;
	dim_prev_y_max=prev_y+vop_height;
	
	if (dim_curr_x_min > dim_prev_x_max)
	{
		*out=1;
	}
	else if(dim_curr_x_min < dim_prev_x_min)
	{
		*mv_x_min = *mv_x_min + ( dim_prev_x_min - dim_curr_x_min ) ;
	}
	if(!(*out))
	{
		if (dim_curr_y_min > dim_prev_y_max)
		{
			*out=1;
		}
		else if(dim_curr_y_min < dim_prev_y_min)
		{
			*mv_y_min = *mv_y_min + ( dim_prev_y_min - dim_curr_y_min ) ;
		}
	}
	
	if(!(*out))
	{
		if(dim_curr_x_max < dim_prev_x_min)
		{
			*out=1;
		}
		if ((!(*out))&&(dim_curr_x_max > dim_prev_x_max))
		{
			*mv_x_max = *mv_x_max - ( dim_curr_x_max - dim_prev_x_max) ;
		}
	}
	if(!(*out))
	{
		if(dim_curr_y_max < dim_prev_y_min)
		{
			*out=1;								  
		}
		if ((!(*out))&&(dim_curr_y_max > dim_prev_y_max))
		{
			*mv_y_max = *mv_y_max - ( dim_curr_y_max - dim_prev_y_max) ;
		}
	}
	if(*mv_x_min>*mv_x_max)
	{
		*out=1;
	}
	if ( (!(*out)) && (*mv_y_min>*mv_y_max))
	{
		*out=1;
	}
	return;
}
static Int
Obtain_Range(
Int     f_code,									  
Int     sr,										  
Int     type,									  
Float   pmv_x,									  
Float   pmv_y,									  
Float   *mv_x_min,								  
Float   *mv_x_max,								  
Float   *mv_y_min,								  
Float   *mv_y_max,								  
Int     quarter_pel								  
)
{
	Int    error;
	Float  aux_x_min, aux_y_min,
		aux_x_max, aux_y_max;
	Float  range;
	error=0;
	if ((f_code==0) && (!quarter_pel))		  
	{
		*mv_x_min=0;
		*mv_x_max=0;
		*mv_y_min=0;
		*mv_y_max=0;
	}
	else
	{
		range = sr;
		*mv_x_min=-range; *mv_x_max= range - 0.5f;
		*mv_y_min=-range; *mv_y_max= range - 0.5f;
	}
	if (type==MBM_INTER8)
	{
		aux_x_min=pmv_x - DEFAULT_8_WIN;
		aux_y_min=pmv_y - DEFAULT_8_WIN;
		aux_x_max=pmv_x + DEFAULT_8_WIN;
		aux_y_max=pmv_y + DEFAULT_8_WIN;
		if(*mv_x_min < aux_x_min)
			*mv_x_min = aux_x_min;
		if(*mv_y_min < aux_y_min)
			*mv_y_min = aux_y_min;
		if(*mv_x_max > aux_x_max)
			*mv_x_max = aux_x_max;
		if(*mv_y_max > aux_y_max)
			*mv_y_max = aux_y_max;
	}
	if (error==1)
		return(0);
	else
		return(1);
}
Void
MBMotionEstimation(
SInt    *curr,								  
SInt    *prev,									  
Int     br_x,									  
Int     br_y,									  
Int     br_width,								  
Int     i,										  
Int     j,										  
Int     prev_x,									  
Int     prev_y,									  
Int     vop_width,								  
Int     vop_height,								  
Int     enable_8x8_mv,							  
Int     edge,									  
Int     f_code,									  
Int     sr,										  
Float	hint_mv_w,                                
Float	hint_mv_h,                                
Float   *mv16_w,								  
Float   *mv16_h,								  
Float   *mv8_w,									  
Float   *mv8_h,									  
Int     *min_error,								  
SInt    *flags
)
{
	Int     x, y;
	Int     sad, sad_min=MV_MAX_ERROR;
	Int     mv_x, mv_y;
	Int     block;
	Float   pmv_x, pmv_y;
	SInt	act_block[MB_SIZE*MB_SIZE];
	Float   mv_x_min, mv_x_max,
		mv_y_min, mv_y_max;
	Int     int_mv_x_min=0, int_mv_x_max=0,
		int_mv_y_min=0, int_mv_y_max=0;
	Int     pos16, pos8;
	Int     mvm_width   = br_width/MB_SIZE;
	Int     x_curr      = i*MB_SIZE,
		y_curr      = j*MB_SIZE;
	Int     hb,vb;
	Int     out;
	Int     rel_ori_x;
	Int     rel_ori_y;
	Int     min_error16, min_error8 = 0;
	#ifndef _FULL_SEARCH_						  
	typedef struct
	{
		Int x;
		Int y;
		SInt start_nmbr;
	} DPoint;
	typedef struct
	{
		DPoint point[8];
	} Diamond;
	SInt d_type=1,stop_flag=0,pt_nmbr=0,check_pts,total_check_pts=8,mot_dirn=0;
	Int d_centre_x=0,d_centre_y=0,check_pt_x,check_pt_y;
	Diamond diamond[2]=
	{
		{
			{	{0,1,0},	{1,0,0},	{0,-1,0},	{-1,0,0}	}
		}
		,
		{
			{	{0,2,6},	{1,1,0},	{2,0,0},	{1,-1,2},
				{0,-2,2},	{-1,-1,4},	{-2,0,4},	{-1,1,6}	}
		}
	};
	#endif
	d_centre_x = (int)hint_mv_w;
	d_centre_y = (int)hint_mv_h;
	rel_ori_x=br_x-prev_x;
	rel_ori_y=br_y-prev_y;
	
	
	LoadArea(curr, x_curr,y_curr,MB_SIZE,MB_SIZE,br_width, act_block);
	
	
	Obtain_Range (f_code, sr, MBM_INTER16,		  
		0.0, 0.0, &mv_x_min, &mv_x_max,
												  
		&mv_y_min, &mv_y_max, 0);
	RangeInSearchArea (i,j,0, prev_x, prev_y, vop_width, vop_height,
		br_x, br_y, edge,f_code, &mv_x_min, &mv_x_max,
												  
		&mv_y_min, &mv_y_max,&out);
	
	if(!out)
	{
		int_mv_x_min=(int)ceil((double)mv_x_min);
		int_mv_y_min=(int)ceil((double)mv_y_min);
		int_mv_x_max=(int)floor((double)mv_x_max);
		int_mv_y_max=(int)floor((double)mv_y_max);
		flags[0]=ARE_EQUAL(int_mv_x_min,mv_x_min);
		flags[1]=ARE_EQUAL(int_mv_x_max,mv_x_max);
		flags[2]=ARE_EQUAL(int_mv_y_min,mv_y_min);
		flags[3]=ARE_EQUAL(int_mv_y_max,mv_y_max);
		sad_min=MV_MAX_ERROR;
		mv_x = mv_y = 2000;						  
		#ifdef _FULL_SEARCH_				  
		for (y=int_mv_y_min; y<=int_mv_y_max; y++)
			for (x=int_mv_x_min; x<=int_mv_x_max; x++)
		{
			if (x==0 && y==0)
					sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+rel_ori_x,
					y_curr+rel_ori_y), act_block, 
					(vop_width), MV_MAX_ERROR)
					- (128 + 1);
			else
				sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+x+rel_ori_x,
					y_curr+y+rel_ori_y), act_block, 
					(vop_width), sad_min);
			if (sad<sad_min)
			{
				sad_min=sad;
				mv_x=x;
				mv_y=y;
			}
			else if (sad==sad_min)
			if((ABS(x)+ABS(y)) < (ABS(mv_x)+ABS(mv_y)))
			{
				sad_min=sad;
				mv_x=x;
				mv_y=y;
			}
		}									  
		#else								  
		sad = SAD_Macroblock(prev+INDEX_BIG(x_curr+rel_ori_x,
			y_curr+rel_ori_y), act_block, (vop_width), MV_MAX_ERROR)
			- (128 + 1);
		if (sad<sad_min)
		{
			sad_min=sad;
			mv_x = mv_y = 0;
		}
		do