p_picture.c

H.263的压缩算法

}

/**********************************************************************
 *
 *	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
 *
 *	Date: 930211	Author: [e-mail]
 *
 ***********************************************************************/

void DoPredChrom_P (int x_curr, int y_curr, int dx, int dy,
                    PictImage * curr, PictImage * prev, MB_Structure * prediction,
                    MB_Structure * pred_error, int rtype)
{
  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);
        prediction->Cr[n][m] = pel;
        pred_error->Cr[n][m] = (int) (*(curr->Cr + x + m + (y + n) * cpels) - pel);

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

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

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

      }
    }
  }
  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:
 *
 *	Date: 930122	Author: [e-mail]
 *
 ***********************************************************************/

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, int RTYPE)
{
  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];
  /* change advanced to overlapping_MC since * 4 MV can be used without
   * OBMC in        * deblocking filter mode                  */
  if (overlapping_MC)
  {
    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, RTYPE);
    } else if (fr0->Mode == MODE_INTER4V || fr0->Mode == MODE_INTER4V_Q)
    {                           /* 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, RTYPE);
    }
  } 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, RTYPE);
    }
    if (fr0->Mode == MODE_INTER4V || fr0->Mode == MODE_INTER4V_Q)
    {
      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];
      FindPred (x_curr, y_curr, fr1, prev_ipol, &pred[0][0], 8, 0);
      FindPred (x_curr, y_curr, fr2, prev_ipol, &pred[0][8], 8, 1);
      FindPred (x_curr, y_curr, fr3, prev_ipol, &pred[8][0], 8, 2);
      FindPred (x_curr, y_curr, fr4, prev_ipol, &pred[8][8], 8, 3);
      for (j = 0; j < MB_SIZE; j++)
        for (i = 0; i < MB_SIZE; i++)
          diff->lum[j][i] += pred[j][i];

      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, RTYPE);
    }
  }

  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
 *
 *	Date: 950210	Author: [e-mail]
 *
 ***********************************************************************/

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
 *
 *	Date: 930203	Author: [e-mail]
 *
 ***********************************************************************/

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

{
  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 - rtype) >> 1;

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

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

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

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

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

      }
    }
  }
  r