block_functions.c

H.263的压缩算法

                   int width, int min_sofar)
{
  int i, sad = 0;
  unsigned char *ll, *kk;
  kk = aa;
  ll = bb;
  i = 16;
  while (i--)
  {
    sad += (abs (*ii - ((*kk + *ll) >> 1)) +
            abs (*(ii + 1) - ((*(kk + 1) + *(ll + 1)) >> 1)) +
            abs (*(ii + 2) - ((*(kk + 2) + *(ll + 2)) >> 1)) +
            abs (*(ii + 3) - ((*(kk + 3) + *(ll + 3)) >> 1)) +
            abs (*(ii + 4) - ((*(kk + 4) + *(ll + 4)) >> 1)) +
            abs (*(ii + 5) - ((*(kk + 5) + *(ll + 5)) >> 1)) +
            abs (*(ii + 6) - ((*(kk + 6) + *(ll + 6)) >> 1)) +
            abs (*(ii + 7) - ((*(kk + 7) + *(ll + 7)) >> 1)) +
            abs (*(ii + 8) - ((*(kk + 8) + *(ll + 8)) >> 1)) +
            abs (*(ii + 9) - ((*(kk + 9) + *(ll + 9)) >> 1)) +
            abs (*(ii + 10) - ((*(kk + 10) + *(ll + 10)) >> 1)) +
            abs (*(ii + 11) - ((*(kk + 11) + *(ll + 11)) >> 1)) +
            abs (*(ii + 12) - ((*(kk + 12) + *(ll + 12)) >> 1)) +
            abs (*(ii + 13) - ((*(kk + 13) + *(ll + 13)) >> 1)) +
            abs (*(ii + 14) - ((*(kk + 14) + *(ll + 14)) >> 1)) +
            abs (*(ii + 15) - ((*(kk + 15) + *(ll + 15)) >> 1)));

    ii += width;
    kk += width;
    ll += width;
    if (sad > min_sofar)
      return INT_MAX;
  }
  return sad;
}

int SAD_MB_integer (int *ii, int *act_block, int h_length, int min_sofar)
{
  int i, sad = 0, *kk;

  kk = act_block;
  i = 16;
  while (i--)
  {
    sad += (abs (*ii - *kk) + abs (*(ii + 1) - *(kk + 1))
            + abs (*(ii + 2) - *(kk + 2)) + abs (*(ii + 3) - *(kk + 3))
            + abs (*(ii + 4) - *(kk + 4)) + abs (*(ii + 5) - *(kk + 5))
            + abs (*(ii + 6) - *(kk + 6)) + abs (*(ii + 7) - *(kk + 7))
            + abs (*(ii + 8) - *(kk + 8)) + abs (*(ii + 9) - *(kk + 9))
          + abs (*(ii + 10) - *(kk + 10)) + abs (*(ii + 11) - *(kk + 11))
          + abs (*(ii + 12) - *(kk + 12)) + abs (*(ii + 13) - *(kk + 13))
        + abs (*(ii + 14) - *(kk + 14)) + abs (*(ii + 15) - *(kk + 15)));

    ii += h_length;
    kk += 16;
    if (sad > min_sofar)
      return INT_MAX;
  }
  return sad;
}

/**********************************************************************
 *
 *	Name:        FindMB
 *	Description:	Picks out one MB from picture
 *
 *	Input:        position of MB to pick out,
 *        pointer to frame data, empty 16x16 array
 *	Returns:
 *	Side effects:	fills array with MB data
 *
 *	Date: 930119	Author: Karl Olav Lillevold
 *
 ***********************************************************************/

void FindMB (int x, int y, unsigned char *image, int MB[16][16])

{
  int n;
  register int m;

  for (n = 0; n < MB_SIZE; n++)
    for (m = 0; m < MB_SIZE; m++)
      MB[n][m] = *(image + x + m + (y + n) * pels);
}

/**********************************************************************
 *
 *	Name:        FindPred
 *	Description:	Find the prediction block
 *
 *	Input:        position, vector, array for prediction
 *        pointer to previous interpolated luminance,
 *
 *	Side effects:	fills array with prediction
 *
 *	Date: 930126        Author: [e-mail]
 *            950208    Mod: [e-mail]
 *
 ***********************************************************************/


void FindPred (int x, int y, MotionVector * fr, unsigned char *prev,
               int *pred, int bs, int comp)
{
  int m, n;
  int new_x, new_y;
  int lx;

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

  new_x = x + fr->x;
  new_y = y + fr->y;

  new_x += ((comp & 1) << 3);
  new_y += ((comp & 2) << 2);


  /* Fill pred. data */
  for (n = 0; n < bs; n++)
  {
    for (m = 0; m < bs; m++)
    {
      /* Find interpolated pixel-value */
      *(pred + m + n * 16) = *(prev + (new_x + m) * 2 + fr->x_half +
                               ((new_y + n) * 2 + fr->y_half) * lx * 2);
    }
  }
  return;
}

/**********************************************************************
 *
 *	Name:        FindPredOBMC
 *	Description:	Find the OBMC prediction block
 *
 *	Input:        position, vector, array for prediction
 *        pointer to previous interpolated luminance,
 *
 *	Returns:
 *	Side effects:	fills array with prediction
 *
 *	Date: 950209        Author: [e-mail]
 *
 ***********************************************************************/


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, xib, xir, xil;
  int yit, yib, yir, yil;
  int vect, vecb, vecr, vecl;
  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);
  c8 = (MV[0][ymb][xmb]->Mode == MODE_INTER4V_Q ? 1 : c8);

  t8 = (MV[0][ymb - 1][xmb]->Mode == MODE_INTER4V ? 1 : 0);
  t8 = (MV[0][ymb - 1][xmb]->Mode == MODE_INTER4V_Q ? 1 : t8);
  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);
  l8 = (MV[0][ymb][xmb - 1]->Mode == MODE_INTER4V_Q ? 1 : l8);
  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);
  r8 = (MV[0][ymb][xmb + 1]->Mode == MODE_INTER4V_Q ? 1 : r8);
  ri8 = (MV[0][ymb][xmb + 1]->Mode == MODE_INTRA ? 1 : 0);
  ri8 = (MV[0][ymb][xmb + 1]->Mode == MODE_INTRA_Q ? 1 : ri8);

  if (PB)
  {
    ti8 = li8 = ri8 = 0;
  }
  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;
}
                       
/***********************************************************************
 *
 *	Name:        MB_Reconstruct
 *	Description:    Reconstructs the macroblock by using
 *                  previously calculated prediction array
 *
 *	Input:	        pointers prediction diff and prediction arrays
 *	Returns:        pointer to reconstructed MB data
 *	Side effects:   allocates memory to MB_structure
 *
 *	Date: 97/06/23        Author: Berna Erol <[e-mail]>
 *
 ***********************************************************************/

MB_Structure *MB_Reconstruct (MB_Structure * diff, MB_Structure * pred)
{
  int i, j;
  MB_Structure *recon = (MB_Structure *) malloc (sizeof (MB_Structure));

  /* Reconstruction */
  for (j = 0; j < MB_SIZE; j++)
    for (i = 0; i < MB_SIZE; i++)
      recon->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->Cr[j][i] = pred->Cr[j][i] + diff->Cr[j][i];
      recon->Cb[j][i] = pred->Cb[j][i] + diff->Cb[j][i];
    }

  return recon;
}