pred.c

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

		curry = nyt + extray;
		summary += InterpolatePel(image_edge,currx,curry) * Mt[n][m];
	  }
	  if( n >= 4 )
	  {
		currx = nxb + extrax;
		curry = nyb + extray;
		summary += InterpolatePel(image_edge,currx,curry) * Mb[n][m];
	  }
	  if( m >= 4 )
	  {
		currx = nxr + extrax;
		curry = nyr + extray;
		summary += InterpolatePel(image_edge,currx,curry) * Mr[n][m];
	  }
	  if( m < 4 )
	  {
		currx = nxl + extrax;
		curry = nyl + extray;
	    summary += InterpolatePel(image_edge,currx,curry) * Ml[n][m];
	  }
	  
      *(pred + m + n*16) = summary >>3;
	  extrax += 2 ;
    }
	extray += 2 ;
	extrax = 64 ;
  }
 return;
}
//==================================================================

/**********************************************************************
 *
 *	Name:		ReconMacroblock_P
 *	Description:	Reconstructs MB after quantization for P_images
 *	
 *	Input:		pointers to current and previous image,
 *			current slice and mb, and which mode
 *			of prediction has been used
 *	Returns:
 *	Side effects:
 *
 ***********************************************************************/
//This function only deal with one macro block 
void MB_Pred(unsigned char _huge *image_edge ,
			 PictImage *prev_image,MB_Structure *pred, int x_curr, 
			 int y_curr,MotionVector *MV[6][MBR+1][MBC+2])
{
  MotionVector *fr0,*fr1,*fr2,*fr3,*fr4;
  int dx, dy, sum;
  int i = MB_SIZE,j = MB_SIZE;
  int y = y_curr/MB_SIZE + 1, x = x_curr/MB_SIZE + 1;
  //unsigned char _huge *in;
  int *out;
  int currx ,curry ; 	
  int lx = (pels + 64)<<1;

  fr0 = MV[0][y][x];

  if (advanced) 
  {
	FindPredOBMC(image_edge,x_curr, y_curr, MV, &pred->lum[0][0], 0);
	FindPredOBMC(image_edge,x_curr, y_curr, MV, &pred->lum[0][8], 1);
	FindPredOBMC(image_edge,x_curr, y_curr, MV, &pred->lum[8][0], 2);
	FindPredOBMC(image_edge,x_curr, y_curr, MV, &pred->lum[8][8], 3);

    if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) {
      dx = 2*fr0->x + fr0->x_half;
      dy = 2*fr0->y + fr0->y_half;
      dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
      dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
      ReconChromBlock_P(x_curr, y_curr, dx, dy, prev_image, pred);
    }
	else if(fr0->Mode == MODE_INTER0)
      ReconChromBlock_P(x_curr, y_curr, 0, 0, prev_image, pred);
    else if (fr0->Mode == MODE_INTER4V) 
    { // Inter 8x8 
      fr1 = MV[1][y][x];
      fr2 = MV[2][y][x];
      fr3 = MV[3][y][x];
      fr4 = MV[4][y][x];

      sum = 2*fr1->x + fr1->x_half + 2*fr2->x + fr2->x_half +
	2*fr3->x + fr3->x_half + 2*fr4->x + fr4->x_half ; 
      dx = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);

      sum = 2*fr1->y + fr1->y_half + 2*fr2->y + fr2->y_half +
	2*fr3->y + fr3->y_half + 2*fr4->y + fr4->y_half;
      dy = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);

      ReconChromBlock_P(x_curr, y_curr, dx, dy, prev_image, pred);
    }
  }
  // here is the commom pred mode
  else 
  {
    if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q || fr0->Mode == MODE_INTER0) 
	{
      dx = 2*fr0->x + fr0->x_half;
      dy = 2*fr0->y + fr0->y_half;
	  out = pred->lum[0];
	  //MB_SIZE * MB_SIZE次
	  while (j--) {
		while (i--)
		{
			currx = (x_curr<<1) + dx + ((15-i)<<1) +4*B ;
			curry = (y_curr<<1) + dy + ((15-j)<<1) +4*B ;
			*out++ = InterpolatePel(image_edge,currx,curry);   
	  
		}
		i = MB_SIZE;
	  }

      dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
      dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
      ReconChromBlock_P(x_curr, y_curr, dx, dy, prev_image, pred);

    }
  }
}


//===============================================================
void ReconChromBlock_P(int x_curr, int y_curr, int dx, int dy,
		       PictImage *prev, MB_Structure *data)

{
 int m,n;
 int x = x_curr>>1, y = y_curr>>1,lx = pels/2 + 32;
 int xint = dx>>1, yint = dy>>1;
 int xh = dx & 1, yh = dy & 1;
 int *cr = data->Cr[0], *cb = data->Cb[0];
 unsigned char _huge *pr = prev->Cr + x + xint + (y + yint)*lx;
 unsigned char _huge *pb = prev->Cb + x + xint + (y + yint)*lx;;

 for (n = 0; n < 8; n++) 
 {
	 for (m = 0; m < 8; m++) 
	 {
	    if (!xh && !yh) 
		{
			*cr++ = *(pr + m);
			*cb++ = *(pb + m);
		}
	    else if (!xh && yh) 
		{
			*cr++ = ((*(pr + m) + *(pr + m + lx) + 1)>>1);
			*cb++ = ((*(pb + m) + *(pb + m + lx) + 1)>>1);
		}
		else if (xh && !yh) {
			*cr++ = ((*(pr + m) + *(pr + m + 1) + 1)>>1);
			*cb++ = ((*(pb + m) + *(pb + m + 1) + 1)>>1);;
      
		}
		else { /* xh && yh */
			*cr++ = ((*(pr + m) + *(pr + m + 1) + 
						  *(pr + m + lx) + *(pr + m + lx +1) + 2)>>2);
			*cb++ = ((*(pb + m) + *(pb + m + 1) + 
						  *(pb + m + lx) + *(pb + m + lx +1) + 2)>>2);;
		}
	 }
	 pr += lx;
	 pb += lx;
 }
		
  return;
}


/**********************************************************************
 *
 *	Name:		ReconLumBlock_P
 *	Description:	Reconstructs one block of luminance data
 *	
 *	Input:		position, vector-data, previous image, data-block
 *	Returns:
 *	Side effects:	reconstructs data-block
 *
 ***********************************************************************/

void ReconLumBlock_P(int x, int y, MotionVector *fr, 
		     unsigned char _huge *prev, int *data, int bs, int comp)
{
  int m, n;
  int x1, y1, lx;

  lx = pels + 64;

  x1 = 2*(x + fr->x) + fr->x_half;
  y1 = 2*(y + fr->y) + fr->y_half;
  
  x1 += ((comp&1)<<4);
  y1 += ((comp&2)<<3);

  for (n = 0; n < bs; n++) {
    for (m = 0; m < bs; m++) {
      *(data+m+n*16) += *(prev+x1+2*m + (long)(y1+2*n)*2L*lx);
    }
  }

  return;
}

/**********************************************************************
 *
 *	Name:		FindChromBlock_P
 *	Description:   	Finds chrominance of one block in P frame
 *	
 *	Input:	      	position, vector-data, previous image, data-block
 *
 ***********************************************************************/

void FindChromBlock_P(int x_curr, int y_curr, int dx, int dy,
		      PictImage *prev, MB_Structure *data)

{
  int m,n;

  int x, y, ofx, ofy, pel,lx;
  int xint, yint;
  int xh, yh;

  lx = pels/2 + 32;

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

  xint = dx>>1;
  xh = dx & 1;
  yint = dy>>1;
  yh = dy & 1;
    
  if (!xh && !yh) {
    for (n = 0; n < 8; n++) {
      for (m = 0; m < 8; m++) {

	ofx = x + xint + m;
	ofy = y + yint + n;
	pel=*(prev->Cr+ofx    + (long)(ofy   )*lx);
	data->Cr[n][m] = pel;

	pel=*(prev->Cb+ofx    + (long)(ofy   )*lx);
	data->Cb[n][m] = pel;
      }
    }
  }
  else if (!xh && yh) {
    for (n = 0; n < 8; n++) {
      for (m = 0; m < 8; m++) {

	ofx = x + xint + m;
	ofy = y + yint + n;
	pel=(*(prev->Cr+ofx    + (long)(ofy   )*lx)+
	     *(prev->Cr+ofx    + (long)(ofy+yh)*lx) + 1)>>1;

	data->Cr[n][m] = pel;

	pel=(*(prev->Cb+ofx    + (long)(ofy   )*lx)+
	     *(prev->Cb+ofx    + (long)(ofy+yh)*lx) + 1)>>1;

	data->Cb[n][m] = pel;
      
      }
    }
  }
  else if (xh && !yh) {
    for (n = 0; n < 8; n++) {
      for (m = 0; m < 8; m++) {

	ofx = x + xint + m;
	ofy = y + yint + n;
	pel=(*(prev->Cr+ofx    + (long)(ofy   )*lx)+
	     *(prev->Cr+ofx+xh + (long)(ofy   )*lx) + 1)>>1;

	data->Cr[n][m] = pel;

	pel=(*(prev->Cb+ofx    + (long)(ofy   )*lx)+
	     *(prev->Cb+ofx+xh + (long)(ofy   )*lx) + 1)>>1;

	data->Cb[n][m] = pel;
      
      }
    }
  }
  else { /* xh && yh */
    for (n = 0; n < 8; n++) {
      for (m = 0; m < 8; m++) {
	ofx = x + xint + m;
	ofy = y + yint + n;
	pel=(*(prev->Cr+ofx    + (long)(ofy   )*lx)+
	     *(prev->Cr+ofx+xh + (long)(ofy   )*lx)+
	     *(prev->Cr+ofx    + (long)(ofy+yh)*lx)+
	     *(prev->Cr+ofx+xh + (long)(ofy+yh)*lx)+
	     2)>>2;

	data->Cr[n][m] = pel;

	pel=(*(prev->Cb+ofx    + (long)(ofy   )*lx)+
	     *(prev->Cb+ofx+xh + (long)(ofy   )*lx)+
	     *(prev->Cb+ofx    + (long)(ofy+yh)*lx)+
	     *(prev->Cb+ofx+xh + (long)(ofy+yh)*lx)+
	     2)>>2;

	data->Cb[n][m] = pel;
      
      }
    }
  }
  return;
}



/**********************************************************************
 *
 *	Name:		ChooseMode
 *	Description:    chooses coding mode
 *	
 *	Input:	        pointer to original fram, min_error from 
 *                      integer pel search, DQUANT
 *	Returns:        1 for Inter, 0 for Intra
 *
 *
 ***********************************************************************/

int ChooseMode(unsigned char *curr, int min_SAD)
{
  int i,j;
  int MB_mean = 0, A = 0;
  int SIZE_MB = MB_SIZE*MB_SIZE;

  for (j = 0; j < SIZE_MB; j += MB_SIZE) 
    for (i = 0; i < MB_SIZE; i++) 
      MB_mean += *(curr + i + j);

  MB_mean /= SIZE_MB;
  for (j = 0; j < SIZE_MB; j += MB_SIZE)
    for (i = 0; i < MB_SIZE; i++)
      A += abs( *(curr + i + j) - MB_mean );

  if (A < (min_SAD - 500)) 
    return MODE_INTRA;
  else
    return MODE_INTER;
}

int ModifyMode(int Mode, int dquant)
{

  if (Mode == MODE_INTRA) {
    if(dquant!=0)
      return MODE_INTRA_Q;
    else
      return MODE_INTRA;
  }
  else if(Mode != MODE_INTER0){ 
    if(dquant!=0)
      return MODE_INTER_Q;
    else
      return Mode;
  }
  else
      return Mode;
}