pred.c

文件内包含H.263视频编码算法和解码算法2个文件

#include "sim.h"
#include "global_e.h"
#include "TMConfig.h"

static int roundtab[] = {0,0,0,1,1,1,1,1,1,1,1,1,1,1,2,2};


MB_Structure *Predict_P(PictImage *curr_image, PictImage *prev_image,
        unsigned char *prev_ipol, int x, int y, 
        MotionVector *MV[6][MBR+1][MBC+2], int PB)
{
  int m,n;
  short int curr[16][16];
  short int pred[16][16];
  MotionVector *fr0,*fr1,*fr2,*fr3,*fr4;
  int sum, dx, dy;
  int xmb, ymb;

  MB_Structure *pred_error = (MB_Structure *)malloc(sizeof(MB_Structure));
    
  xmb = x/MB_SIZE+1;
  ymb = y/MB_SIZE+1;

  fr0 = MV[0][ymb][xmb];
  fr1 = MV[1][ymb][xmb];
  fr2 = MV[2][ymb][xmb];
  fr3 = MV[3][ymb][xmb];
  fr4 = MV[4][ymb][xmb];

  FindMB_MY(x, y, curr_image->lum, curr); 
  FindPred_MY(x, y, fr0, prev_ipol, &pred[0][0], 16, 0);

  /* Do the actual prediction */
  if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) 
  {
    for (n = 0; n < MB_SIZE; n++)
      for (m = 0; m < MB_SIZE; m++) 
        pred_error->lum[n][m] = curr[n][m] - pred[n][m];

    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 );

    DoPredChrom_P(x, y, dx, dy, curr_image, prev_image, pred_error);
  }

  else if (fr0->Mode == MODE_INTER4V) 
  {
    for (n = 0; n < MB_SIZE; n++)
      for (m = 0; m < MB_SIZE; m++) 
        pred_error->lum[n][m] = curr[n][m] - pred[n][m];

    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);

    DoPredChrom_P(x, y, dx, dy, curr_image, prev_image, pred_error);
  }

  else
    fprintf(stderr,"Illegal Mode in Predict_P (pred.c)\n");

  return pred_error;
}


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, ofx, ofy, pel, lx;
  int xint, yint;
  int xh, yh;

  lx = (mv_outside_frame ? pels/2 + (long_vectors?32:16) : pels/2);

  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    + (ofy   )*lx);
        pred_error->Cr[n][m] = (short int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);

        pel=*(prev->Cb+ofx    + (ofy   )*lx);
        pred_error->Cb[n][m] = (short int)(*(curr->Cb + x+m + (y+n)*cpels) - 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    + (ofy   )*lx)+
             *(prev->Cr+ofx    + (ofy+yh)*lx) + 1)>>1;

        pred_error->Cr[n][m] = (short int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);

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

        pred_error->Cb[n][m] = (short int)(*(curr->Cb + x+m + (y+n)*cpels) - 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    + (ofy   )*lx)+
             *(prev->Cr+ofx+xh + (ofy   )*lx) + 1)>>1;

        pred_error->Cr[n][m] = (short int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);

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

        pred_error->Cb[n][m] = (short int)(*(curr->Cb + x+m + (y+n)*cpels) - 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    + (ofy   )*lx)+
             *(prev->Cr+ofx+xh + (ofy   )*lx)+
             *(prev->Cr+ofx    + (ofy+yh)*lx)+
             *(prev->Cr+ofx+xh + (ofy+yh)*lx)+
             2)>>2;

        pred_error->Cr[n][m] = (short int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);

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

        pred_error->Cb[n][m] = (short int)(*(curr->Cb + x+m + (y+n)*cpels) - pel);     
      }
    }
  }

  return;
}


void FindPredOBMC(int x, int y, MotionVector *MV[6][MBR+1][MBC+2], 
          unsigned char *prev, int *pred, int comp, int PB)
{
  int m, n;
  int pc,pt,pb,pr,pl;
  int nxc,nxt,nxb,nxr,nxl;
  int nyc,nyt,nyb,nyr,nyl;
  int xit=0,xib=0,xir=0,xil=0;
  int yit=0,yib=0,yir=0,yil=0;
  int vect=0,vecb=0,vecr=0,vecl=0;
  int c8,t8,l8,r8;
  int ti8,li8,ri8;
  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 = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);

  c8  = (MV[0][ymb][xmb]->Mode == MODE_INTER4V ? 1 : 0);

  t8  = (MV[0][ymb-1][xmb]->Mode == MODE_INTER4V ? 1 : 0);
  ti8 = (MV[0][ymb-1][xmb]->Mode == MODE_INTRA ? 1 : 0);
  ti8 = (MV[0][ymb-1][xmb]->Mode == MODE_INTRA_Q ? 1 : ti8);

  l8  = (MV[0][ymb][xmb-1]->Mode == MODE_INTER4V ? 1 : 0);
  li8 = (MV[0][ymb][xmb-1]->Mode == MODE_INTRA ? 1 : 0);
  li8 = (MV[0][ymb][xmb-1]->Mode == MODE_INTRA_Q ? 1 : li8);
  
  r8  = (MV[0][ymb][xmb+1]->Mode == MODE_INTER4V ? 1 : 0);
  ri8 = (MV[0][ymb][xmb+1]->Mode == MODE_INTRA ? 1 : 0);
  ri8 = (MV[0][ymb][xmb+1]->Mode == MODE_INTRA_Q ? 1 : ri8);

  switch (comp+1) 
  {
  case 1:
    vect = (ti8 ? (c8 ? 1 : 0) : (t8 ? 3 : 0)); 
    yit  = (ti8 ? ymb : ymb - 1); 
    xit = xmb;

    vecb = (c8 ? 3 : 0) ; yib = ymb; xib = xmb;

    vecl = (li8 ? (c8 ? 1 : 0) : (l8 ? 2 : 0)); 
    yil = ymb; 
    xil = (li8 ? xmb : xmb-1);

    vecr = (c8 ? 2 : 0) ; yir = ymb; xir = xmb;

    /* edge handling */
    if (ymb == 1) {
      yit = ymb;
      vect = (c8 ? 1 : 0);
    }
    if (xmb == 1) {
      xil = xmb;
      vecl = (c8 ? 1 : 0);
    }
    break;
  
  case 2:
    vect = (ti8 ? (c8 ? 2 : 0) : (t8 ? 4 : 0)); 
    yit = (ti8 ? ymb : ymb-1); 
    xit = xmb;

    vecb = (c8 ? 4 : 0) ; yib = ymb; xib = xmb;
    vecl = (c8 ? 1 : 0) ; yil = ymb; xil = xmb;

    vecr = (ri8 ? (c8 ? 2 : 0) : (r8 ? 1 : 0)); 
    yir = ymb; 
    xir = (ri8 ? xmb : xmb+1);

    /* edge handling */
    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 = (li8 ? (c8 ? 3 : 0) : (l8 ? 4 : 0)); 
    yil = ymb;  
    xil = (li8 ? xmb : xmb-1);
    
    vecr = (c8 ? 4 : 0) ; yir = ymb  ; xir = xmb;

    /* edge handling */
    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 = (ri8 ? (c8 ? 4 : 0) : (r8 ? 3 : 0)); 
    yir = ymb; 
    xir = (ri8 ? xmb : xmb+1);

    /* edge handling */
    if (xmb == pels/16) 
	{
      xir = xmb;
      vecr = (c8 ? 4 : 0);
    }
    break;

  default:
    fprintf(stderr,"Illegal block number in FindPredOBMC (pred.c)\n");
    exit(-1);
    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;

  /* Fill pred. data */
  for (n = 0; n < 8; n++)
  {
    for (m = 0; m < 8; m++) 
	{
      /* Find interpolated pixel-value */
      pc = *(prev + nxc + 2*m + (nyc + 2*n)*lx*2) * Mc[n][m];
      pt = *(prev + nxt + 2*m + (nyt + 2*n)*lx*2) * Mt[n][m];
      pb = *(prev + nxb + 2*m + (nyb + 2*n)*lx*2) * Mb[n][m];
      pr = *(prev + nxr + 2*m + (nyr + 2*n)*lx*2) * Mr[n][m];
      pl = *(prev + nxl + 2*m + (nyl + 2*n)*lx*2) * Ml[n][m];

      /*$pc = *(prev + nxc + 2*m + (nyc + 2*n)*lx*2) * 8;
      pt = *(prev + nxt + 2*m + (nyt + 2*n)*lx*2) * 0;;
      pb = *(prev + nxb + 2*m + (nyb + 2*n)*lx*2) * 0;
      pr = *(prev + nxr + 2*m + (nyr + 2*n)*lx*2) * 0;
      pl = *(prev + nxl + 2*m + (nyl + 2*n)*lx*2) * 0;$*/

      *(pred + m + n*16) = (pc+pt+pb+pr+pl+4)>>3;
    }	
  }
  return;
}


MB_Structure *MB_Recon_P(PictImage *prev_image, unsigned char *prev_ipol,
         MB_Structure *diff, int x_curr, int y_curr, 
         MotionVector *MV[6][MBR+1][MBC+2], int PB)
{
  MB_Structure *recon_data = (MB_Structure *)malloc(sizeof(MB_Structure));
  MotionVector *fr0,*fr1,*fr2,*fr3,*fr4;
  int pred[16][16];
  int dx, dy, sum;
  int i,j;

  fr0 = MV[0][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];

  if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) 
  {
      /* Inter 16x16 */
      ReconLumBlock_P_MY(x_curr,y_curr,fr0,prev_ipol,&diff->lum[0][0],16,0);
	  
      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, diff);
  }

  memcpy(recon_data, diff, sizeof(MB_Structure));

  return recon_data;
}


void ReconChromBlock_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 = cpels;

  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    + (ofy   )*lx);
        data->Cr[n][m] += pel;

        pel=*(prev->Cb+ofx    + (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    + (ofy   )*lx)+
             *(prev->Cr+ofx    + (ofy+yh)*lx) + 1)>>1;

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

        pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
             *(prev->Cb+ofx    + (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    + (ofy   )*lx)+
             *(prev->Cr+ofx+xh + (ofy   )*lx) + 1)>>1;

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

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

        data->Cb[n][m] += pel;