pred.c

基于H.263的图像压缩编解码的C源码

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


/**********************************************************************
 *
 *      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:
 *
 ***********************************************************************/

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 (advanced) {
    if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) {
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][0], 0, PB);
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][8], 1, PB);
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][0], 2, PB);
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][8], 3, PB);
      for (j = 0; j < MB_SIZE; j++) 
        for (i = 0; i < MB_SIZE; i++) 
          diff->lum[j][i] += pred[j][i];

      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);
    }
    else if (fr0->Mode == MODE_INTER4V) { /* Inter 8x8 */
      
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][0], 0, PB);
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][8], 1, PB);
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][0], 2, PB);
      FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][8], 3, PB);
      for (j = 0; j < MB_SIZE; j++) 
        for (i = 0; i < MB_SIZE; i++) 
          diff->lum[j][i] += pred[j][i];

      fr1 = MV[1][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
      fr2 = MV[2][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
      fr3 = MV[3][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
      fr4 = MV[4][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];

      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, diff);
    }
  }
  else {
    if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) {
      /* Inter 16x16 */
      ReconLumBlock_P(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;
}

/**********************************************************************
 *
 *      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 *prev, int *data, int bs, int comp)
{
  int m, n;
  int x1, y1, lx;

  lx = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);

  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) += (int)(*(prev+x1+2*m + (y1+2*n)*2*lx));
    }
  }

  return;
}

/**********************************************************************
 *
 *      Name:           ReconChromBlock_P
 *      Description:    Reconstructs chrominance of one block in P frame
 *	
 *      Input:          position, vector-data, previous image, data-block
 *	Returns:        
 *	Side effects:	reconstructs data-block
 *
 ***********************************************************************/

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 = (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);
        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;
      
      }
    }
  }
  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;

        data->Cr[n][m] += 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;

        data->Cb[n][m] += pel;
      
      }
    }
  }
  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 = (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);
        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;
      
      }
    }
  }
  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;

        data->Cr[n][m] = 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;

        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 x_pos, int y_pos, int min_SAD)
{
  int i,j;
  int MB_mean = 0, A = 0;
  int y_off;

  for (j = 0; j < MB_SIZE; j++) {
    y_off = (y_pos + j) * pels;
    for (i = 0; i < MB_SIZE; i++) {
      MB_mean += *(curr + x_pos + i + y_off);
    }
  }
  MB_mean /= (MB_SIZE*MB_SIZE);
  for (j = 0; j < MB_SIZE; j++) {
    y_off = (y_pos + j) * pels;
    for (i = 0; i < MB_SIZE; i++) {
      A += abs( *(curr + x_pos + i + y_off) - 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(dquant!=0)
      return MODE_INTER_Q;
    else
      return Mode;
  }
}