pred.c

h.263+ vc++商业源代码

#include"sim.h"
static int roundtab[] = {0,0,0,1,1,1,1,1,1,1,1,1,1,1,2,2};

/**********************************************************************
 *
 *	Name:		DoPredChrom_P
 *	Description:	Does the chrominance prediction for P-frames
 *	
 *	Input:		motionvectors for each field,
 *			current position in image,
 *			pointers to current and previos image,
 *			pointer to pred_error array,
 *			(int) field: 1 if field coding
 *			
 *	Side effects:	fills chrom-array in pred_error structure
 *
 *
 ***********************************************************************/

void DoPredChrom_P(int x_curr, int y_curr, int dx, int dy,
		   PictImage *curr, PictImage *prev, 
		   MB_Structure *pred_error)
{
  int m,n;

  int x, y, cr_pel, cb_pel, lx;
  int xint, yint;
  int xh, yh;
  long curr_start, prev_start;
  lx = pels/2 + 32;

  x = x_curr>>1;
  y = y_curr>>1;

  xint = dx>>1;
  xh = dx & 1;
  yint = dy>>1;
  yh = dy & 1;
  curr_start = (long)y*cpels + x;
  prev_start = (long)(y + yint)*lx + x + xint;
  for (n = 0; n < 8; n++) {
	for (m = 0; m < 8; m++) {
	if (!xh && !yh){
		cb_pel = *(prev->Cb + prev_start+m);
		cr_pel = *(prev->Cr + prev_start+m);
	}
	else if (!xh && yh) {
		cb_pel=(*(prev->Cb + prev_start + m)+
	    *(prev->Cb + lx + prev_start + m) + 1)>>1;
		cr_pel=(*(prev->Cr+prev_start + m)+
	    *(prev->Cr + lx + prev_start + m) + 1)>>1;
	}
	else if (xh && !yh){
		cb_pel=(*(prev->Cb + prev_start + m)+
	    *(prev->Cb + 1 +  prev_start + m) + 1)>>1;
		cr_pel=(*(prev->Cr + prev_start + m)+
	    *(prev->Cr + 1 +  prev_start + m) + 1)>>1;
	}
	else{
		cb_pel=(*(prev->Cb + prev_start + m)+
	    *(prev->Cb + 1 + prev_start + m )+
	    *(prev->Cb + lx + prev_start + m)+
	    *(prev->Cb + 1 + lx + prev_start + m)+
	    2)>>2;
		cr_pel=(*(prev->Cr + prev_start + m)+
	    *(prev->Cr + 1 + prev_start + m )+
	    *(prev->Cr + lx + prev_start + m)+
	    *(prev->Cr + 1 + lx + prev_start + m)+
	    2)>>2;
	}
	pred_error->Cr[n][m] = (int)(*(curr->Cr + m + curr_start) - cr_pel);
	pred_error->Cb[n][m] = (int)(*(curr->Cb + m + curr_start) - cb_pel);
    }
	curr_start += cpels;
	prev_start += lx;
  }
  return;
}

/**********************************************************************
 *
 *	Name:		FindHalfPelMB
 *	Description:Find the optimal half pel prediction for macro block
 *	
 *	Input:		position, vector, array with current data
 *			    pointer to previous interpolated luminance,
 *
 *	Returns:
 *
 ***********************************************************************/

static POINT search[9] = {{0,0},{-1,-1},{0,-1},{1,-1},{-1,0},{1,0},{-1,1},{0,1},{1,1}};
/*1 2 3
  4 0 5
  6 7 8 
*/

void FindHalfPel(MotionVector *fr, unsigned char *prev, unsigned char *curr, int bs, int comp)
{
  int i,n;
  int new_x, new_y;
  int min_pos = 0;
  int AE, AE_min = INT_MAX;
  unsigned char *ii, *kk, *aa, *pp;

  new_x = ((comp&1)<<3);
  new_y = ((comp&2)<<2);
  pp = prev + (new_x<<1) + (new_y<<1)*36;
  aa = curr + new_x + new_y*MB_SIZE;

  for (i = 0; i < 9; i++) 
  {
	AE = 0;
	ii = pp + search[i].x + search[i].y*36;
	kk = aa;
    for (n = 0; n < bs; n++) 
	{
		AE += (abs(*ii     - *kk     ) +abs(*(ii+2 ) - *(kk+1))
			  +abs(*(ii+4 ) - *(kk+2)) +abs(*(ii+6 ) - *(kk+3))
			  +abs(*(ii+8 ) - *(kk+4)) +abs(*(ii+10) - *(kk+5))
	 	      +abs(*(ii+12) - *(kk+6)) +abs(*(ii+14) - *(kk+7)));
		if(bs == 16)
		{
			
		    AE += abs(*(ii+16) - *(kk+8)) +abs(*(ii+18) - *(kk+9))
				 +abs(*(ii+20)- *(kk+10)) +abs(*(ii+22) - *(kk+11))
				 +abs(*(ii+24)- *(kk+12)) +abs(*(ii+26) - *(kk+13))
				 +abs(*(ii+28)- *(kk+14)) +abs(*(ii+30) - *(kk+15));
		}
		if(AE > AE_min)
		{
			AE = INT_MAX;
			break;
		}
		ii += 72;
		kk += 16;
	}
    if (AE < AE_min) {
      AE_min = AE;
      min_pos = i;
    }
  }

  /* Store optimal values */
  fr->min_error = AE_min;
  fr->x_half = search[min_pos].x;
  fr->y_half = search[min_pos].y;
	
  return;
}

/**********************************************************************
 *
 *	Name:		FindPred
 *	Description:	Find the prediction block
 *	
 *	Input:		position, vector, array for prediction
 *			pointer to previous interpolated luminance,
 *
 *	Side effects:	fills array with prediction
 *
 ***********************************************************************/


void FindPred(int x, int y, MotionVector *fr, unsigned char _huge *prev, 
	      int *pred, int bs, int comp)
{
  int m, n;
  int new_x, new_y;
  int lx;

  lx = pels + 64;

  new_x = x + fr->x;
  new_y = y + fr->y;

  new_x += ((comp&1)<<3);
  new_y += ((comp&2)<<2);


  /* Fill pred. data */
  for (n = 0; n < bs; n++) {
    for (m = 0; m < bs; m++) {
      /* Find interpolated pixel-value */
      *(pred + m + n*16) = *(prev + (new_x + m)*2L + fr->x_half +
			     (long)((new_y + n)*2 + fr->y_half)*lx*2);
    }	
  }
  return;
}

/**********************************************************************
 *
 *	Name:		FindPredOBMC
 *	Description:	Find the OBMC prediction block
 *	
 *	Input:		position, vector, array for prediction
 *			pointer to previous interpolated luminance,
 *
 *	Returns:
 *	Side effects:	fills array with prediction
 *
 ***********************************************************************/

void FindPredOBMC(unsigned char _huge *image_edge,int x, int y, MotionVector *MV[6][MBR+1][MBC+2], 
		          int *pred, int comp)
{
  int m, n;
  int summary ;
  int extrax , extray  ;
  int currx , curry ;
  int nxc,nxt,nxb,nxr,nxl;
  int nyc,nyt,nyb,nyr,nyl;
  int xit,xib,xir,xil;
  int yit,yib,yir,yil;
  int vect,vecb,vecr,vecl;
  int c8,t8,l8,r8;
  int xmb, ymb, lx;
  MotionVector *fc,*ft,*fb,*fr,*fl;

  int Mc[8][8] = {
    {4,5,5,5,5,5,5,4},
    {5,5,5,5,5,5,5,5},
    {5,5,6,6,6,6,5,5},
    {5,5,6,6,6,6,5,5},
    {5,5,6,6,6,6,5,5},
    {5,5,6,6,6,6,5,5},
    {5,5,5,5,5,5,5,5},
    {4,5,5,5,5,5,5,4},
  };
  int Mt[8][8] = {
    {2,2,2,2,2,2,2,2},
    {1,1,2,2,2,2,1,1},
    {1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
  };
  int Mb[8][8] = {
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0},
    {1,1,1,1,1,1,1,1},
    {1,1,1,1,1,1,1,1},
    {1,1,2,2,2,2,1,1},
    {2,2,2,2,2,2,2,2},
  };
  int Mr[8][8] = {
    {0,0,0,0,1,1,1,2},
    {0,0,0,0,1,1,2,2},
    {0,0,0,0,1,1,2,2},
    {0,0,0,0,1,1,2,2},
    {0,0,0,0,1,1,2,2},
    {0,0,0,0,1,1,2,2},
    {0,0,0,0,1,1,2,2},
    {0,0,0,0,1,1,1,2},
  };
  int Ml[8][8] = {
    {2,1,1,1,0,0,0,0},
    {2,2,1,1,0,0,0,0},
    {2,2,1,1,0,0,0,0},
    {2,2,1,1,0,0,0,0},
    {2,2,1,1,0,0,0,0},
    {2,2,1,1,0,0,0,0},
    {2,2,1,1,0,0,0,0},
    {2,1,1,1,0,0,0,0},
  };

  xmb = x/MB_SIZE+1;
  ymb = y/MB_SIZE+1;

  lx = pels + 64;

  c8 = (MV[0][ymb][xmb]->Mode == MODE_INTER4V ? 1 : 0);
  t8 = (MV[0][ymb-1][xmb]->Mode == MODE_INTER4V ? 1 : 0);
  l8 = (MV[0][ymb][xmb-1]->Mode == MODE_INTER4V ? 1 : 0);
  r8 = (MV[0][ymb][xmb+1]->Mode == MODE_INTER4V ? 1 : 0);
  if( comp < 0 ) comp = 0 ;
  if( comp > 3 ) comp = 3 ;
  switch (comp+1) {
  case 1:
    vect = (t8 ? 3 : 0) ; yit = ymb-1 ; xit = xmb;
    vecb = (c8 ? 3 : 0) ; yib = ymb   ; xib = xmb;
    vecl = (l8 ? 2 : 0) ; yil = ymb   ; xil = xmb-1;
    vecr = (c8 ? 2 : 0) ; yir = ymb   ; xir = xmb;
    if (ymb == 1) {
      yit = ymb;
      vect = (c8 ? 1 : 0);
    }
    if (xmb == 1) {
      xil = xmb;
      vecl = (c8 ? 1 : 0);
    }
    break;
  case 2:
    vect = (t8 ? 4 : 0) ; yit = ymb-1 ; xit = xmb;
    vecb = (c8 ? 4 : 0) ; yib = ymb   ; xib = xmb;
    vecl = (c8 ? 1 : 0) ; yil = ymb   ; xil = xmb;
    vecr = (r8 ? 1 : 0) ; yir = ymb   ; xir = xmb+1;
    if (ymb == 1) {
      yit = ymb;
      vect = (c8 ? 2 : 0);
    }
    if (xmb == pels/16) {
      xir = xmb;
      vecr = (c8 ? 2 : 0);
    }
    break;
  case 3:
    vect = (c8 ? 1 : 0) ; yit = ymb  ; xit = xmb;
    vecb = (c8 ? 3 : 0) ; yib = ymb  ; xib = xmb;
    vecl = (l8 ? 4 : 0) ; yil = ymb  ; xil = xmb-1;
    vecr = (c8 ? 4 : 0) ; yir = ymb  ; xir = xmb;
    if (xmb == 1) {
      xil = xmb;
      vecl = (c8 ? 3 : 0);
    }
    break;
  case 4:
    vect = (c8 ? 2 : 0) ; yit = ymb  ; xit = xmb;
    vecb = (c8 ? 4 : 0) ; yib = ymb  ; xib = xmb;
    vecl = (c8 ? 3 : 0) ; yil = ymb  ; xil = xmb;
    vecr = (r8 ? 3 : 0) ; yir = ymb  ; xir = xmb+1;
    if (xmb == pels/16) {
      xir = xmb;
      vecr = (c8 ? 4 : 0);
    }
    break;
  default:
    break;
  }

  fc = MV[c8 ? comp + 1: 0][ymb][xmb];

  ft = MV[vect][yit][xit];
  fb = MV[vecb][yib][xib];
  fr = MV[vecr][yir][xir];
  fl = MV[vecl][yil][xil];

  nxc = 2*x + ((comp&1)<<4); nyc = 2*y + ((comp&2)<<3);
  nxt = nxb = nxr = nxl = nxc;
  nyt = nyb = nyr = nyl = nyc;

  nxc += 2*fc->x + fc->x_half; nyc += 2*fc->y + fc->y_half;
  nxt += 2*ft->x + ft->x_half; nyt += 2*ft->y + ft->y_half;
  nxb += 2*fb->x + fb->x_half; nyb += 2*fb->y + fb->y_half;
  nxr += 2*fr->x + fr->x_half; nyr += 2*fr->y + fr->y_half;
  nxl += 2*fl->x + fl->x_half; nyl += 2*fl->y + fl->y_half;

  
  extray = 64 ;
  extrax = 64 ;
  for (n = 0; n < 8; n++) {
    for (m = 0; m < 8; m++) {
	  summary = 4 ;
      /* Find interpolated pixel-value */
	  	 
	  currx = nxc + extrax ;
	  curry = nyc + extray ;
	  summary += InterpolatePel(image_edge,currx,curry) * Mc[n][m];
	  
	  if( n < 4 )
	  {
		currx = nxt + extrax;