p_picture.c

tmn3.2编解码源程序 Linux C环境编写 文件齐全 压缩包完整 试用正常 欢迎试用

      /* round values according to TABLE 16/H.263 */
      dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
      dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);
      FindChromBlock_P (x, y, dx, dy, prev_image, pred, 0);

      /* chroma vectors are sum of B luma vectors divided and rounded */
      xvec = yvec = 0;
      for (k = 1; k <= 4; k++)
      {
        mvx = 2 * f[k]->x + f[k]->x_half;
        mvy = 2 * f[k]->y + f[k]->y_half;
        xvec += bdx == 0 ? (TRB - TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx;
        yvec += bdy == 0 ? (TRB - TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy;
      }

      /* round values according to TABLE 16/H.263 */
      dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
      dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);

      FindBiDirChrPredPB (recon_P, dx, dy, pred);
    } 
    else
    {
      xvec = 4 * (TRB * (2 * f[0]->x + f[0]->x_half) / TRD + bdx);
      yvec = 4 * (TRB * (2 * f[0]->y + f[0]->y_half) / TRD + bdy);
      /* round values according to TABLE 16/H.263 */
      dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
      dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);

      /* chroma vectors */
      FindChromBlock_P (x, y, dx, dy, prev_image, pred, 0);

      mvx = 2 * f[0]->x + f[0]->x_half;
      xvec = bdx == 0 ? (TRB - TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx;
      xvec *= 4;

      mvy = 2 * f[0]->y + f[0]->y_half;
      yvec = bdy == 0 ? (TRB - TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy;
      yvec *= 4;

      /* round values according to TABLE 16/H.263 */
      dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
      dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);

      FindBiDirChrPredPB (recon_P, dx, dy, pred);
    }

    /* Do the actual prediction */
    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) - pred->lum[j][i];
        pred_macroblock->lum[j][i] = 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) - pred->Cr[j][i];
        p_err->Cb[j][i] = *(curr_image->Cb + xx + i + (yy + j) * cpels) - pred->Cb[j][i];

        pred_macroblock->Cr[j][i] = pred->Cr[j][i];
        pred_macroblock->Cb[j][i] = pred->Cb[j][i];
      }
  }

  /* store PB-deltas */
  MV[6][y / MB_SIZE + 1][x / MB_SIZE + 1]->x = bdx; /* is in half pel format */
  MV[6][y / MB_SIZE + 1][x / MB_SIZE + 1]->y = bdy;
  MV[6][y / MB_SIZE + 1][x / MB_SIZE + 1]->x_half = 0;
  MV[6][y / MB_SIZE + 1][x / MB_SIZE + 1]->y_half = 0;

  free (pred);
  free (frw_pred);

  return p_err;
}

/***********************************************************************
 *
 *	Name:        MB_Recon_B
 *	Description:    Reconstructs the B macroblock in PB-frame
 *                      prediction
 *
 *	Input:	        pointers previous recon. frame, pred. diff.,
 *                      pos. in image, MV-data, reconstructed macroblock
 *                      from image ahead
 *	Returns:        pointer to reconstructed MB data
 *	Side effects:   allocates memory to MB_structure
 *
 *	Date: 950114        Author: [e-mail]
 *
 ***********************************************************************/

MB_Structure *MB_Recon_B (PictImage * prev_image, MB_Structure * diff,
                           unsigned char *prev_ipol, int x, int y,
                           MotionVector * MV[5][MBR + 1][MBC + 2],
                           MB_Structure * recon_P, int TRD, int TRB)
{
  int i, j, k;
  int dx, dy, bdx, bdy, mvx, mvy, xvec, yvec;
  MB_Structure *recon_B = (MB_Structure *) malloc (sizeof (MB_Structure));
  MB_Structure *pred = (MB_Structure *) malloc (sizeof (MB_Structure));
  MotionVector *f[5];

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

  bdx = MV[6][y / MB_SIZE + 1][x / MB_SIZE + 1]->x;
  bdy = MV[6][y / MB_SIZE + 1][x / MB_SIZE + 1]->y;

  if (f[0]->Mode == MODE_INTER4V || f[0]->Mode == MODE_INTER4V_Q)
  {                             /* Mode INTER4V */
    /* Find forward prediction */

    /* Luma */
    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);

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

    /* round values according to TABLE 16/H.263 */
    dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
    dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);

    FindChromBlock_P (x, y, dx, dy, prev_image, pred, 0);

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

    /* chroma vectors are sum of B luma vectors divided and rounded */
    xvec = yvec = 0;
    for (k = 1; k <= 4; k++)
    {
      mvx = 2 * f[k]->x + f[k]->x_half;
      mvy = 2 * f[k]->y + f[k]->y_half;
      xvec += bdx == 0 ? (TRB - TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx;
      yvec += bdy == 0 ? (TRB - TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy;
    }

    /* round values according to TABLE 16/H.263 */
    dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
    dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);

    FindBiDirChrPredPB (recon_P, dx, dy, pred);

  } else
  {                             /* Mode INTER or INTER_Q */
    /* Find forward prediction */

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

    xvec = 4 * (TRB * (2 * f[0]->x + f[0]->x_half) / TRD + bdx);
    yvec = 4 * (TRB * (2 * f[0]->y + f[0]->y_half) / TRD + bdy);
    /* round values according to TABLE 16/H.263 */
    dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
    dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);

    FindChromBlock_P (x, y, dx, dy, prev_image, pred, 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);

    /* chroma vectors */
    mvx = 2 * f[0]->x + f[0]->x_half;
    xvec = bdx == 0 ? (TRB - TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx;
    xvec *= 4;

    mvy = 2 * f[0]->y + f[0]->y_half;
    yvec = bdy == 0 ? (TRB - TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy;
    yvec *= 4;

    /* round values according to TABLE 16/H.263 */
    dx = sign (xvec) * (roundtab[abs (xvec) % 16] + (abs (xvec) / 16) * 2);
    dy = sign (yvec) * (roundtab[abs (yvec) % 16] + (abs (yvec) / 16) * 2);

    FindBiDirChrPredPB (recon_P, dx, dy, pred);

  }

  /* Reconstruction */
  for (j = 0; j < MB_SIZE; j++)
    for (i = 0; i < MB_SIZE; i++)
      recon_B->lum[j][i] = pred->lum[j][i] + diff->lum[j][i];

  for (j = 0; j < MB_SIZE >> 1; j++)
    for (i = 0; i < MB_SIZE >> 1; i++)
    {
      recon_B->Cr[j][i] = pred->Cr[j][i] + diff->Cr[j][i];
      recon_B->Cb[j][i] = pred->Cb[j][i] + diff->Cb[j][i];
    }

  free (pred);
  return recon_B;
}

/**********************************************************************
 *
 *	Name:	       FindForwLumPredPB
 *	Description:   Finds the forward luma  prediction in PB-frame
 *                     pred.
 *
 *	Input:	       pointer to prev. recon. frame, current positon,
 *                     MV structure and pred. structure to fill
 *
 *	Date: 950114        Author: [e-mail]
 *
 ***********************************************************************/

void FindForwLumPredPB (unsigned char *prev_ipol, int x_curr, int y_curr,
                         MotionVector * fr, int *pred, int TRD, int TRB,
                         int bdx, int bdy, int bs, int comp)
{
  int i, j;
  int xvec, yvec, lx;

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

  /* Luma */
  xvec = (TRB) * (2 * fr->x + fr->x_half) / TRD + bdx;
  yvec = (TRB) * (2 * fr->y + fr->y_half) / TRD + bdy;

  x_curr += ((comp & 1) << 3);
  y_curr += ((comp & 2) << 2);

  for (j = 0; j < bs; j++)
  {
    for (i = 0; i < bs; i++)
    {
      *(pred + i + j * 16) = *(prev_ipol + (i + x_curr) * 2 + xvec +
                               ((j + y_curr) * 2 + yvec) * lx * 2);
    }
  }

  return;
}

/**********************************************************************
 *
 *	Name:	       FindBiDirLumPredPB
 *	Description:   Finds the bi-dir. luma prediction in PB-frame
 *                     prediction
 *
 *	Input:	       pointer to future recon. data, current positon,
 *                     MV structure and pred. structure to fill
 *
 *	Date: 950115        Author: [e-mail]
 *
 ***********************************************************************/

void FindBiDirLumPredPB (int *recon_P, MotionVector * fr, int *pred, int TRD,
                          int TRB, int bdx, int bdy, int nh, int nv)
{
  int xstart, xstop, ystart, ystop;
  int xvec, yvec, mvx, mvy;

  mvx = 2 * fr->x + fr->x_half;
  mvy = 2 * fr->y + fr->y_half;

  xvec = (bdx == 0 ? (TRB - TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx);
  yvec = (bdy == 0 ? (TRB - TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy);

  /* Luma */

  FindBiDirLimits (xvec, &xstart, &xstop, nh);
  FindBiDirLimits (yvec, &ystart, &ystop, nv);

  BiDirPredBlock (xstart, xstop, ystart, ystop, xvec, yvec, recon_P, pred, 16);

  return;
}

/**********************************************************************
 *
 *	Name:	       FindBiDirChrPredPB
 *	Description:   Finds the bi-dir. chroma prediction in PB-frame
 *                     prediction
 *
 *	Input:	       pointer to future recon. data, current positon,
 *                     MV structure and pred. structure to fill
 *
 *	Date: 950115        Author: [e-mail]
 *
 ***********************************************************************/

void FindBiDirChrPredPB (MB_Structure * recon_P, int dx, int dy,
                          MB_Structure * pred)
{
  int xstart, xstop, ystart, ystop;

  FindBiDirChromaLimits (dx, &xstart, &xstop);
  FindBiDirChromaLimits (dy, &ystart, &ystop);

  BiDirPredBlock (xstart, xstop, ystart, ystop, dx, dy,
                  &recon_P->Cb[0][0], &pred->Cb[0][0], 8);
  BiDirPredBlock (xstart, xstop, ystart, ystop, dx, dy,
                  &recon_P->Cr[0][0], &pred->Cr[0][0], 8);

  return;
}

void FindBiDirLimits (int vec, int *start, int *stop, int nhv)
{

  /* limits taken from C loop in section G5 in H.263 */
  *start = mmax (0, (-vec + 1) / 2 - nhv * 8);
  *stop = mmin (7, 15 - (vec + 1) / 2 - nhv * 8);

  return;

}

void FindBiDirChromaLimits (int vec, int *start, int *stop)
{

  /* limits taken from C loop in section G5 in H.263 */
  *start = mmax (0, (-vec + 1) / 2);
  *stop = mmin (7, 7 - (vec + 1) / 2);

  return;
}


void BiDirPredBlock (int xstart, int xstop, int ystart, int ystop,
                      int xvec, int yvec, int *recon, int *pred, int bl)
{
  int i, j, pel;
  int xint, yint;
  int xh, yh;

  xint = xvec >> 1;
  xh = xvec - 2 * xint;
  yint = yvec >> 1;
  yh = yvec - 2 * yint;

  if (!xh && !yh)
  {
    for (j = ystart; j <= ystop; j++)
    {
      for (i = xstart; i <= xstop; i++)
      {
        pel = *(recon + (j + yint) * bl + i + xint);
        *(pred + j * bl + i) = (mmin (255, mmax (0, pel)) + *(pred + j * bl + i)) >> 1;
      }
    }
  } else if (!xh && yh)
  {
    for (j = ystart; j <= ystop; j++)
    {
      for (i = xstart; i <= xstop; i++)
      {
        pel = (*(recon + (j + yint) * bl + i + xint) +
               *(recon + (j + yint + yh) * bl + i + xint) + 1) >> 1;
        *(pred + j * bl + i) = (pel + *(pred + j * bl + i)) >> 1;
      }
    }
  } else if (xh && !yh)
  {
    for (j = ystart; j <= ystop; j++)
    {
      for (i = xstart; i <= xstop; i++)
      {
        pel = (*(recon + (j + yint) * bl + i + xint) +
               *(recon + (j + yint) * bl + i + xint + xh) + 1) >> 1;
        *(pred + j * bl + i) = (pel + *(pred + j * bl + i)) >> 1;
      }
    }
  } else
  {                             /* xh && yh */
    for (j = ystart; j <= ystop; j++)
    {
      for (i = xstart; i <= xstop; i++)
      {
        pel = (*(recon + (j + yint) * bl + i + xint) +
               *(recon + (j + yint + yh) * bl + i + xint) +
               *(recon + (j + yint) * bl + i + xint + xh) +
               *(recon + (j + yint + yh) * bl + i + xint + xh) + 2) >> 2;
        *(pred + j * bl + i) = (pel + *(pred + j * bl + i)) >> 1;
      }
    }
  }
  return;