fast_me.c

AVS视频编解码器 能实现视频图像的高效率压缩 能在ＶＣ上高速运行

	
	if(blocktype>6)
		goto sec_step;
	else
		goto first_step;
	
first_step: //Unsymmetrical-cross search 
	iXMinNow = best_x;
	iYMinNow = best_y;
	
	for(i=1;i<=search_range/2;i++)
	{
		search_step = 2*i - 1;
		cand_x = iXMinNow + search_step;
		cand_y = iYMinNow ;
		SEARCH_ONE_PIXEL		
		cand_x = iXMinNow - search_step;
		cand_y = iYMinNow ;
		SEARCH_ONE_PIXEL
	}
	
	for(i=1;i<=search_range/4;i++)
	{
		search_step = 2*i - 1;
		cand_x = iXMinNow ;
		cand_y = iYMinNow + search_step;
		SEARCH_ONE_PIXEL
		cand_x = iXMinNow ;
		cand_y = iYMinNow - search_step;
		SEARCH_ONE_PIXEL
	}
	//early termination algrithm, refer to JVT-D016
    EARLY_TERMINATION
	
	iXMinNow = best_x;
	iYMinNow = best_y;
// Uneven Multi-Hexagon-grid Search	
	for(pos=1;pos<25;pos++)
	{
		cand_x = iXMinNow + spiral_search_x[pos];
		cand_y = iYMinNow + spiral_search_y[pos];
		SEARCH_ONE_PIXEL
	}
	//early termination algrithm, refer to JVT-D016
    EARLY_TERMINATION
	
	for(i=1;i<=search_range/4; i++)
	{
		iAbort = 0;   
		for (m = 0; m < 16; m++)
		{
			cand_x = iXMinNow + Big_Hexagon_x[m]*i;
			cand_y = iYMinNow + Big_Hexagon_y[m]*i; 
			SEARCH_ONE_PIXEL1(1)
		}
		if (iAbort)
		{	
			//early termination algrithm, refer to JVT-D016
			EARLY_TERMINATION
		}
	}
sec_step:  //Extended Hexagon-based Search
		  iXMinNow = best_x;
		  iYMinNow = best_y;
		  for(i=0;i<search_range;i++) 
		  {
			  iAbort = 1;   
			  for (m = 0; m < 6; m++)
			  {		
				  cand_x = iXMinNow + Hexagon_x[m];
				  cand_y = iYMinNow + Hexagon_y[m];   
				  SEARCH_ONE_PIXEL1(0)
			  } 
			  if(iAbort)
				  break;
			  iXMinNow = best_x;
			  iYMinNow = best_y;
		  }
third_step: // the third step with a small search pattern
		  iXMinNow = best_x;
		  iYMinNow = best_y;
		  for(i=0;i<search_range;i++) 
		  {
			  iSADLayer = 65536;
			  iAbort = 1;   
			  for (m = 0; m < 4; m++)
			  {		
				  cand_x = iXMinNow + Diamond_x[m];
				  cand_y = iYMinNow + Diamond_y[m];   
				  SEARCH_ONE_PIXEL1(0)
			  } 
			  if(iAbort)
				  break;
			  iXMinNow = best_x;
			  iYMinNow = best_y;
		  }

		  *mv_x = best_x - pic_pix_x;
		  *mv_y = best_y - pic_pix_y;	
		  return min_mcost;
  }


/*
*************************************************************************
* Function: Functions for fast fractional pel motion estimation.
  1. int AddUpSADQuarter() returns SADT of a fractiona pel MV
  2. int FastSubPelBlockMotionSearch () proceed the fast fractional pel ME
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/

int AddUpSADQuarter(int pic_pix_x,int pic_pix_y,int blocksize_x,int blocksize_y,
    int cand_mv_x,int cand_mv_y, pel_t **ref_pic, pel_t**   orig_pic, int Mvmcost, int min_mcost,int useABT)
  {
    int abort_search, y0, x0, rx0, ry0, ry; 
    pel_t *orig_line;
    int   diff[16], *d; 
    int  mcost = Mvmcost;
    int yy,kk,xx;
    int   curr_diff[MB_BLOCK_SIZE][MB_BLOCK_SIZE]; // for ABT SATD calculation
    
    for (y0=0, abort_search=0; y0<blocksize_y && !abort_search; y0+=4)
    {
      ry0 = ((pic_pix_y+y0)<<2) + cand_mv_y;
      
      for (x0=0; x0<blocksize_x; x0+=4)
      {
        rx0 = ((pic_pix_x+x0)<<2) + cand_mv_x;
        d   = diff;
        
        orig_line = orig_pic [y0  ];    ry=ry0;
        *d++      = orig_line[x0  ]  -  PelY_14 (ref_pic, ry, rx0   );
        *d++      = orig_line[x0+1]  -  PelY_14 (ref_pic, ry, rx0+ 4);
        *d++      = orig_line[x0+2]  -  PelY_14 (ref_pic, ry, rx0+ 8);
        *d++      = orig_line[x0+3]  -  PelY_14 (ref_pic, ry, rx0+ 12);
        
        orig_line = orig_pic [y0+1];    ry=ry0+4;
        *d++      = orig_line[x0  ]  -  PelY_14 (ref_pic, ry, rx0   );
        *d++      = orig_line[x0+1]  -  PelY_14 (ref_pic, ry, rx0+ 4);
        *d++      = orig_line[x0+2]  -  PelY_14 (ref_pic, ry, rx0+ 8);
        *d++      = orig_line[x0+3]  -  PelY_14 (ref_pic, ry, rx0+ 12);
        
        orig_line = orig_pic [y0+2];    ry=ry0+8;
        *d++      = orig_line[x0  ]  -  PelY_14 (ref_pic, ry, rx0   );
        *d++      = orig_line[x0+1]  -  PelY_14 (ref_pic, ry, rx0+ 4);
        *d++      = orig_line[x0+2]  -  PelY_14 (ref_pic, ry, rx0+ 8);
        *d++      = orig_line[x0+3]  -  PelY_14 (ref_pic, ry, rx0+ 12);
        
        orig_line = orig_pic [y0+3];    ry=ry0+12;
        *d++      = orig_line[x0  ]  -  PelY_14 (ref_pic, ry, rx0   );
        *d++      = orig_line[x0+1]  -  PelY_14 (ref_pic, ry, rx0+ 4);
        *d++      = orig_line[x0+2]  -  PelY_14 (ref_pic, ry, rx0+ 8);
        *d        = orig_line[x0+3]  -  PelY_14 (ref_pic, ry, rx0+ 12);
        
        if (!useABT)
        {
          if ((mcost += SATD (diff, input->hadamard)) > min_mcost)
          {
            abort_search = 1;
            break;
          }
        }
        else  // copy diff to curr_diff for ABT SATD calculation
        {
          for (yy=y0,kk=0; yy<y0+4; yy++)
            for (xx=x0; xx<x0+4; xx++, kk++)
              curr_diff[yy][xx] = diff[kk];
        }
      }
    }
    
    return mcost;
  }
  
  int                                                   //  ==> minimum motion cost after search
    FastSubPelBlockMotionSearch (pel_t**   orig_pic,      // <--  original pixel values for the AxB block
    int       ref,           // <--  reference frame (0... or -1 (backward))
    int       pic_pix_x,     // <--  absolute x-coordinate of regarded AxB block
    int       pic_pix_y,     // <--  absolute y-coordinate of regarded AxB block
    int       blocktype,     // <--  block type (1-16x16 ... 7-4x4)
    int       pred_mv_x,     // <--  motion vector predictor (x) in sub-pel units
    int       pred_mv_y,     // <--  motion vector predictor (y) in sub-pel units
    int*      mv_x,          // <--> in: search center (x) / out: motion vector (x) - in pel units
    int*      mv_y,          // <--> in: search center (y) / out: motion vector (y) - in pel units
    int       search_pos2,   // <--  search positions for    half-pel search  (default: 9)
    int       search_pos4,   // <--  search positions for quarter-pel search  (default: 9)
    int       min_mcost,     // <--  minimum motion cost (cost for center or huge value)
    double    lambda,
    int	useABT)        // <--  lagrangian parameter for determining motion cost
  {
    static int Diamond_x[4] = {-1, 0, 1, 0};
    static int Diamond_y[4] = {0, 1, 0, -1};
    int   mcost;
    int   cand_mv_x, cand_mv_y;
    
    int   incr            = ref==-1 ? ((!img->fld_type)&&(mref==mref_fld)&&(img->type==B_IMG)) : (mref==mref_fld)&&(img->type==B_IMG) ;
    pel_t **ref_pic       = img->type==B_IMG? mref [ref+1+incr] : mref [ref];
    
    int   lambda_factor   = LAMBDA_FACTOR (lambda);
    int   mv_shift        = 0;
    int   check_position0 = (blocktype==1 && *mv_x==0 && *mv_y==0 && input->hadamard && !input->rdopt && img->type!=B_IMG && ref==0);
    int   blocksize_x     = input->blc_size[blocktype][0];
    int   blocksize_y     = input->blc_size[blocktype][1];
    int   pic4_pix_x      = (pic_pix_x << 2);
    int   pic4_pix_y      = (pic_pix_y << 2);
    int   max_pos_x4      = ((img->width -blocksize_x+1)<<2);
    int   max_pos_y4      = ((img->height-blocksize_y+1)<<2);
    
    int   min_pos2        = (input->hadamard ? 0 : 1);
    int   max_pos2        = (input->hadamard ? max(1,search_pos2) : search_pos2);
    int   search_range_dynamic,iXMinNow,iYMinNow,i;
    int   iSADLayer,m,currmv_x,currmv_y,iCurrSearchRange;
    int   search_range = input->search_range;
    int   pred_frac_mv_x,pred_frac_mv_y,abort_search;
    int   mv_cost; 
    
    int   pred_frac_up_mv_x, pred_frac_up_mv_y;

	if (!img->picture_structure) //field coding
	{
		if (img->type==B_IMG)
		{
			incr = 2;
		}
	}else
	{
		if(img->type==B_IMG)
			incr = 1;
	}
    ref_pic       = img->type==B_IMG? mref [ref+incr] : mref [ref];
    
    *mv_x <<= 2;
    *mv_y <<= 2;
    if ((pic4_pix_x + *mv_x > 1) && (pic4_pix_x + *mv_x < max_pos_x4 - 2) &&
      (pic4_pix_y + *mv_y > 1) && (pic4_pix_y + *mv_y < max_pos_y4 - 2)   )
    {
      PelY_14 = FastPelY_14;
    }
    else
    {
      PelY_14 = UMVPelY_14;
    }
    
    search_range_dynamic = 3;
    pred_frac_mv_x = (pred_mv_x - *mv_x)%4;
    pred_frac_mv_y = (pred_mv_y - *mv_y)%4; 
    
    pred_frac_up_mv_x = (pred_MV_uplayer[0] - *mv_x)%4;
    pred_frac_up_mv_y = (pred_MV_uplayer[1] - *mv_y)%4;
    
    
    memset(SearchState[0],0,(2*search_range_dynamic+1)*(2*search_range_dynamic+1));
    
    if(input->hadamard)
    {
      cand_mv_x = *mv_x;    
      cand_mv_y = *mv_y;    
      mv_cost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);		
      mcost = AddUpSADQuarter(pic_pix_x,pic_pix_y,blocksize_x,blocksize_y,cand_mv_x,cand_mv_y,ref_pic,orig_pic,mv_cost,min_mcost,useABT);
      SearchState[search_range_dynamic][search_range_dynamic] = 1;
      if (mcost < min_mcost)
      {
        min_mcost = mcost;
        currmv_x = cand_mv_x;
        currmv_y = cand_mv_y;	
      }
    }
    else
    {
      SearchState[search_range_dynamic][search_range_dynamic] = 1;
      currmv_x = *mv_x;
      currmv_y = *mv_y;	
    }
    
    if(pred_frac_mv_x!=0 || pred_frac_mv_y!=0)
    {
      cand_mv_x = *mv_x + pred_frac_mv_x;    
      cand_mv_y = *mv_y + pred_frac_mv_y;    
      mv_cost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);		
      mcost = AddUpSADQuarter(pic_pix_x,pic_pix_y,blocksize_x,blocksize_y,cand_mv_x,cand_mv_y,ref_pic,orig_pic,mv_cost,min_mcost,useABT);
      SearchState[cand_mv_y -*mv_y + search_range_dynamic][cand_mv_x - *mv_x + search_range_dynamic] = 1;
      if (mcost < min_mcost)
      {
        min_mcost = mcost;
        currmv_x = cand_mv_x;
        currmv_y = cand_mv_y;	
      }
    }
    
     
    iXMinNow = currmv_x;
    iYMinNow = currmv_y;
    iCurrSearchRange = 2*search_range_dynamic+1; 
    for(i=0;i<iCurrSearchRange;i++) 
    {
      abort_search=1;
      iSADLayer = 65536;
      for (m = 0; m < 4; m++)
      {
        cand_mv_x = iXMinNow + Diamond_x[m];    
        cand_mv_y = iYMinNow + Diamond_y[m]; 
        
        if(abs(cand_mv_x - *mv_x) <=search_range_dynamic && abs(cand_mv_y - *mv_y)<= search_range_dynamic)
        {
          if(!SearchState[cand_mv_y -*mv_y+ search_range_dynamic][cand_mv_x -*mv_x+ search_range_dynamic])
          {
            mv_cost = MV_COST (lambda_factor, mv_shift, cand_mv_x, cand_mv_y, pred_mv_x, pred_mv_y);		
            mcost = AddUpSADQuarter(pic_pix_x,pic_pix_y,blocksize_x,blocksize_y,cand_mv_x,cand_mv_y,ref_pic,orig_pic,mv_cost,min_mcost,useABT);
            SearchState[cand_mv_y - *mv_y + search_range_dynamic][cand_mv_x - *mv_x + search_range_dynamic] = 1;
            if (mcost < min_mcost)
            {
              min_mcost = mcost;
              currmv_x = cand_mv_x;
              currmv_y = cand_mv_y;	
              abort_search = 0;	
                         
            }
          }
        }
      }
      iXMinNow = currmv_x;
      iYMinNow = currmv_y;
      if(abort_search)
        break;
    }
   
    *mv_x = currmv_x;
    *mv_y = currmv_y;
    
    //===== return minimum motion cost =====
    return min_mcost;
}

/*
*************************************************************************
* Function:Functions for SAD prediction of intra block cases.
   1. void   decide_intrabk_SAD() judges the block coding type(intra/inter) 
     of neibouring blocks
   2. void skip_intrabk_SAD() set the SAD to zero if neigouring block coding 
     type is intra
* Input:
* Output:
* Return: 
* Attention:
*************************************************************************
*/
 
void   decide_intrabk_SAD()
{
  if (img->type != 0)
  {
	  if (img->pix_x == 0 && img->pix_y == 0)
	  {
		  flag_intra_SAD = 0;
	  }
	  else if (img->pix_x == 0)
	  {
		  flag_intra_SAD = flag_intra[(img->pix_x)>>4];