p_picture.c

H.263的压缩算法

    store_pb = pic->PB;
    pic->PB = 0;
    EdgeFilter(recon, pic);
    pic->PB = store_pb;
    if (pic->PB)
      EdgeFilter(B_recon,pic);
  }

  pic->QP_mean = QP_cumulative/(float)abs_mb_num;

  /* Free memory */
  free (pred_P);
  free (pred_B);

  if (mv_outside_frame)
  {
    free(prev_recon);
    FreeImage(pr_edge);
  }

  if (PCT_IPB == pic->picture_coding_type || PCT_PB == pic->picture_coding_type)
    free(pi_woRTYPE);

  free(pi);
 
  for (j = 0; j < (lines>>4)+1; j++)
    for (i = 0; i < (pels>>4)+2; i++) 
      for (k = 0; k < 7; k++)
      {
        free(MV[k][j][i]);
        free(B_f_MV[k][j][i]);
      }

  if (advanced_intra_coding)
  {
    free(store_coeff);
    free(store_rcoeff);
  }

  if (advanced_temporarily_off)
  {
    overlapping_MC = ON;
    adv_pred = ON;
    use_4mv = ON;
    advanced_temporarily_off = NO;
  }
  return;
}


/**********************************************************************
 *
 *	Name:        Predict_P
 *	Description:    Predicts P macroblock in advanced or normal
 *                      mode
 *
 *	Input:        pointers to current and previous frames
 *        and previous interpolated image,
 *                      position and motion vector array
 *	Returns:	pointer to MB_Structure of data to be coded
 *	Side effects:	allocates memory to MB_Structure
 *
 *	Date: 9501        Author: <[e-mail]>
 *
 ***********************************************************************/

MB_Structure *Predict_P (PictImage * curr_image, PictImage * prev_image,
                         unsigned char *prev_ipol, MB_Structure * pred_macroblock,
                         int x, int y,
                         MotionVector * MV[7][MBR + 1][MBC + 2], int PB, int RTYPE)
{
  int m, n;
  int curr[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];

  /* Find MB in current image */
  FindMB (x, y, curr_image->lum, curr);

  /* Find prediction based on half pel MV    */

  if (overlapping_MC)
  {
    FindPredOBMC (x, y, MV, prev_ipol, &pred_macroblock->lum[0][0], 0, PB);
    FindPredOBMC (x, y, MV, prev_ipol, &pred_macroblock->lum[0][8], 1, PB);
    FindPredOBMC (x, y, MV, prev_ipol, &pred_macroblock->lum[8][0], 2, PB);
    FindPredOBMC (x, y, MV, prev_ipol, &pred_macroblock->lum[8][8], 3, PB);
  } else if (fr0->Mode == MODE_INTER4V || fr0->Mode == MODE_INTER4V_Q)
  {
    /* Luma */
    FindPred (x, y, fr1, prev_ipol, &pred_macroblock->lum[0][0], 8, 0);
    FindPred (x, y, fr2, prev_ipol, &pred_macroblock->lum[0][8], 8, 1);
    FindPred (x, y, fr3, prev_ipol, &pred_macroblock->lum[8][0], 8, 2);
    FindPred (x, y, fr4, prev_ipol, &pred_macroblock->lum[8][8], 8, 3);
  } else
  {
    FindPred (x, y, fr0, prev_ipol, &pred_macroblock->lum[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] = (int) (curr[n][m] - pred_macroblock->lum[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_macroblock, pred_error, RTYPE);

  } else if (fr0->Mode == MODE_INTER4V || fr0->Mode == MODE_INTER4V_Q)
  {
    for (n = 0; n < MB_SIZE; n++)
      for (m = 0; m < MB_SIZE; m++)
        pred_error->lum[n][m] = (int) (curr[n][m] - pred_macroblock->lum[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_macroblock, pred_error, RTYPE);
  } else
    fprintf (stderr, "Illegal Mode in Predict_P (pred.c)\n");

  return pred_error;
}


/***********************************************************************
 *
 *	Name:        Predict_B
 *	Description:    Predicts the B macroblock in PB-frame prediction
 *
 *	Input:	        pointers to current frame, previous recon. frame,
 *                      pos. in image, MV-data, reconstructed macroblock
 *                      from image ahead
 *	Returns:        pointer to differential MB data after prediction
 *	Side effects:   allocates memory to MB_structure
 *
 *	Date: 950113        Author: [e-mail]
 *
 ***********************************************************************/

MB_Structure *Predict_B (PictImage * curr_image, PictImage * prev_image,
  unsigned char *prev_ipol, MB_Structure * pred_macroblock, int x, int y,
                          MotionVector * MV[7][MBR + 1][MBC + 2], MotionVector * B_f_MV[7][MBR + 1][MBC + 2],
  MB_Structure * recon_P, int TRD, int TRB, int PB, int *im_PB_pred_type)
{
  int i, j, k, xx, yy;
  int dx, dy, sad, sad_min = INT_MAX, curr[16][16], bdx = 0, bdy = 0;
  MB_Structure *p_err = (MB_Structure *) malloc (sizeof (MB_Structure));
  MB_Structure *pred = (MB_Structure *) malloc (sizeof (MB_Structure));
  MB_Structure *frw_pred = (MB_Structure *) malloc (sizeof (MB_Structure));
  MotionVector *f[7];
  MotionVector *frw[7];
  int xvec, yvec, mvx, mvy;
  int SADbidir, SADforw,SADbackw,min_SAD;
  int forward_pred = 0;
  int bidir_pred = 0;
  int backward_pred = 0;

  for (k = 0; k <= 4; k++)
    f[k] = MV[k][y / MB_SIZE + 1][x / MB_SIZE + 1];

  for (k = 0; k <= 4; k++)
    frw[k] = B_f_MV[k][y / MB_SIZE + 1][x / MB_SIZE + 1];

  /* Find MB in current image */
  FindMB (x, y, curr_image->lum, curr);

  if (f[0]->Mode == MODE_INTER4V || f[0]->Mode == MODE_INTER4V_Q)
  {
    /* Mode INTER4V */
    if (PB == IM_PB_FRAMES)
    {
      bdx = 0;
      bdy = 0;
    } else
    {
      /* Find forward prediction. Luma */
      for (j = -DEF_PBDELTA_WIN; j <= DEF_PBDELTA_WIN; j++)
      {
        for (i = -DEF_PBDELTA_WIN; i <= DEF_PBDELTA_WIN; i++)
        {

          FindForwLumPredPB (prev_ipol, x, y, f[1], &pred->lum[0][0], TRD, TRB, i, j, 8, 0);
          FindForwLumPredPB (prev_ipol, x, y, f[2], &pred->lum[0][8], TRD, TRB, i, j, 8, 1);
          FindForwLumPredPB (prev_ipol, x, y, f[3], &pred->lum[8][0], TRD, TRB, i, j, 8, 2);
          FindForwLumPredPB (prev_ipol, x, y, f[4], &pred->lum[8][8], TRD, TRB, i, j, 8, 3);

          sad = SAD_MB_integer (&curr[0][0], &pred->lum[0][0], 16, INT_MAX);
          if (i == 0 && j == 0)
            sad -= PREF_PBDELTA_NULL_VEC;
          if (sad < sad_min)
          {
            sad_min = sad;
            bdx = i;
            bdy = j;
          }
        }
      }
    }

    FindForwLumPredPB (prev_ipol, x, y, f[1], &pred->lum[0][0], TRD, TRB, bdx, bdy, 8, 0);
    FindForwLumPredPB (prev_ipol, x, y, f[2], &pred->lum[0][8], TRD, TRB, bdx, bdy, 8, 1);
    FindForwLumPredPB (prev_ipol, x, y, f[3], &pred->lum[8][0], TRD, TRB, bdx, bdy, 8, 2);
    FindForwLumPredPB (prev_ipol, x, y, f[4], &pred->lum[8][8], TRD, TRB, bdx, bdy, 8, 3);

    /* Find bidirectional prediction */
    FindBiDirLumPredPB (&recon_P->lum[0][0], f[1], &pred->lum[0][0],
                        TRD, TRB, bdx, bdy, 0, 0);
    FindBiDirLumPredPB (&recon_P->lum[0][8], f[2], &pred->lum[0][8],
                        TRD, TRB, bdx, bdy, 1, 0);
    FindBiDirLumPredPB (&recon_P->lum[8][0], f[3], &pred->lum[8][0],
                        TRD, TRB, bdx, bdy, 0, 1);
    FindBiDirLumPredPB (&recon_P->lum[8][8], f[4], &pred->lum[8][8],
                        TRD, TRB, bdx, bdy, 1, 1);

  } else
  {
    /* Mode INTER or INTER_Q */
    if (PB == IM_PB_FRAMES)
    {
      bdx = 0;
      bdy = 0;
    } else
    {
      /* Find forward prediction */
      for (j = -DEF_PBDELTA_WIN; j <= DEF_PBDELTA_WIN; j++)
      {
        for (i = -DEF_PBDELTA_WIN; i <= DEF_PBDELTA_WIN; i++)
        {

          dx = i;
          dy = j;

          /* To keep things simple I turn off PB delta vectors at the
           * edges */
          if (!mv_outside_frame)
          {
            if (x == 0)
              dx = 0;
            if (x == pels - MB_SIZE)
              dx = 0;
            if (y == 0)
              dy = 0;
            if (y == lines - MB_SIZE)
              dy = 0;
          }
          if (f[0]->Mode == MODE_INTRA || f[0]->Mode == MODE_INTRA_Q)
          {
            dx = dy = 0;
          }
          if ((f[0]->x == 0 && f[0]->y == 0) &&
              (f[0]->x_half == 0 && f[0]->y_half == 0))
          {
            dx = dy = 0;
          }
          FindForwLumPredPB (prev_ipol, x, y, f[0], &pred->lum[0][0],
                             TRD, TRB, dx, dy, 16, 0);

          sad = SAD_MB_integer (&curr[0][0], &pred->lum[0][0], 16, INT_MAX);
          if (i == 0 && j == 0)
          {
            sad -= PREF_PBDELTA_NULL_VEC;
          }
          if (sad < sad_min)
          {
            sad_min = sad;
            bdx = dx;
            bdy = dy;
          }
        }
      }
    }

    FindForwLumPredPB (prev_ipol, x, y, f[0], &pred->lum[0][0], TRD, TRB,
                       bdx, bdy, 16, 0);

    /* Find bidirectional prediction */
    FindBiDirLumPredPB (&recon_P->lum[0][0], f[0], &pred->lum[0][0],
                        TRD, TRB, bdx, bdy, 0, 0);
    FindBiDirLumPredPB (&recon_P->lum[0][8], f[0], &pred->lum[0][8],
                        TRD, TRB, bdx, bdy, 1, 0);
    FindBiDirLumPredPB (&recon_P->lum[8][0], f[0], &pred->lum[8][0],
                        TRD, TRB, bdx, bdy, 0, 1);
    FindBiDirLumPredPB (&recon_P->lum[8][8], f[0], &pred->lum[8][8],
                        TRD, TRB, bdx, bdy, 1, 1);
  }

  if (PB == IM_PB_FRAMES)
  {
    SADbidir = SAD_MB_integer (&curr[0][0], &pred->lum[0][0], 16, INT_MAX);

    FindPred (x, y, frw[0], prev_ipol, &frw_pred->lum[0][0], 16, 0);
    SADforw = SAD_MB_integer (&curr[0][0], &frw_pred->lum[0][0], 16, INT_MAX);
    SADbackw = SAD_MB_integer (&curr[0][0], &recon_P->lum[0][0], 16, INT_MAX);

    /* make decision about using forward prediction, backward prediction or bidir pre
diction */
    min_SAD=mmin(mmin(SADforw,SADbackw),(SADbidir-100));

    if (min_SAD == (SADbidir - 100))
    {
      /* bidirectional prediction is chosen */
      bidir_pred = 1;
      (*im_PB_pred_type) = BIDIRECTIONAL_PREDICTION;
    } 
    else if (min_SAD==SADbackw)
    {
      /* backward prediction is chosen */
      backward_pred = 1;
      (*im_PB_pred_type) = BACKWARD_PREDICTION;
    }
    else 
    {
      /* forward prediction is chosen */
      forward_pred = 1;
      (*im_PB_pred_type) = FORWARD_PREDICTION;
    }
  }
  if (PB == IM_PB_FRAMES && forward_pred)
  {
    dx = 2 * frw[0]->x + frw[0]->x_half;
    dy = 2 * frw[0]->y + frw[0]->y_half;
    dx = (dx % 4 == 0 ? dx >> 1 : (dx >> 1) | 1);
    dy = (dy % 4 == 0 ? dy >> 1 : (dy >> 1) | 1);

    /* predict B as if it is P */
    DoPredChrom_P (x, y, dx, dy, curr_image, prev_image, frw_pred, p_err, 0);

    for (j = 0; j < MB_SIZE; j++)
      for (i = 0; i < MB_SIZE; i++)
      {
        p_err->lum[j][i] = *(curr_image->lum + x + i + (y + j) * pels) - frw_pred->lum[j][i];
        pred_macroblock->lum[j][i] = frw_pred->lum[j][i];
      }
    xx = x >> 1;
    yy = y >> 1;
    for (j = 0; j < MB_SIZE >> 1; j++)
      for (i = 0; i < MB_SIZE >> 1; i++)
      {
        p_err->Cr[j][i] = *(curr_image->Cr + xx + i + (yy + j) * cpels) - frw_pred->Cr[j][i];
        p_err->Cb[j][i] = *(curr_image->Cb + xx + i + (yy + j) * cpels) - frw_pred->Cb[j][i];
        pred_macroblock->Cr[j][i] = frw_pred->Cr[j][i];
        pred_macroblock->Cb[j][i] = frw_pred->Cb[j][i];
      }
  } 
  else if (PB == IM_PB_FRAMES && backward_pred)
  {
    dx = 0;
    dy = 0;
    
    for (j = 0; j < MB_SIZE; j++)
      for (i = 0; i < MB_SIZE; i++)
      {
        p_err->lum[j][i] = *(curr_image->lum + x + i + (y + j) * pels) - recon_P->lum
[j][i];
        pred_macroblock->lum[j][i] = recon_P->lum[j][i];
      }

    xx = x >> 1;
    yy = y >> 1;

    for (j = 0; j < MB_SIZE >> 1; j++)
      for (i = 0; i < MB_SIZE >> 1; i++)
      {
        p_err->Cr[j][i] = *(curr_image->Cr + xx + i + (yy + j) * cpels) - recon_P->Cr[j][i];
        p_err->Cb[j][i] = *(curr_image->Cb + xx + i + (yy + j) * cpels) - recon_P->Cb[j][i];

        pred_macroblock->Cr[j][i] = recon_P->Cr[j][i];
        pred_macroblock->Cb[j][i] = recon_P->Cb[j][i];
      }
  }
  else
  {
    /* bidir prediction */
    if (f[0]->Mode == MODE_INTER4V || f[0]->Mode == MODE_INTER4V_Q)
    {
      /* Mode INTER4V chroma vectors are sum of B luma vectors divided and
       * rounded */
      xvec = yvec = 0;
      for (k = 1; k <= 4; k++)
      {
        xvec += TRB * (2 * f[k]->x + f[k]->x_half) / TRD + bdx;
        yvec += TRB * (2 * f[k]->y + f[k]->y_half) / TRD + bdy;
      }