recon.c

H.263的压缩算法

      dyb = MV[1][5][y][x];

      /* Y */
      recon_comp (src_b[0], bframe[0], lx, lx2, w, h, bx, by, dxb, dyb, 0);

      lx >>= 1;
      w >>= 1;
      bx >>= 1;
      lx2 >>= 1;
      h >>= 1;
      by >>= 1;
      /* chroma rounding */
      dxb = (dxb % 4 == 0 ? dxb >> 1 : (dxb >> 1) | 1);
      dyb = (dyb % 4 == 0 ? dyb >> 1 : (dyb >> 1) | 1);

      /* Chroma */
      recon_comp (src_b[1], bframe[1], lx, lx2, w, h, bx, by, dxb, dyb, 1);
      recon_comp (src_b[2], bframe[2], lx, lx2, w, h, bx, by, dxb, dyb, 2);

      break;

    case B_BIDIRECTIONAL_PREDICTION:

      w = 16;
      h = 16;

      dxf = MV[0][0][y][x];
      dyf = MV[1][0][y][x];
      dxb = MV[0][5][y][x];
      dyb = MV[1][5][y][x];

      /* Y */
      recon_comp (src_f[0], tmp_f[0], lx, lx2, w, h, bx, by, dxf, dyf, 0);
      recon_comp (src_b[0], tmp_b[0], lx, lx2, w, h, bx, by, dxb, dyb, 0);

      lx >>= 1;
      w >>= 1;
      lx2 >>= 1;
      h >>= 1;

      bx_chroma = bx >> 1;
      by_chroma = by >> 1;


      dxf = (dxf % 4 == 0 ? dxf >> 1 : (dxf >> 1) | 1);
      dyf = (dyf % 4 == 0 ? dyf >> 1 : (dyf >> 1) | 1);
      dxb = (dxb % 4 == 0 ? dxb >> 1 : (dxb >> 1) | 1);
      dyb = (dyb % 4 == 0 ? dyb >> 1 : (dyb >> 1) | 1);

      /* Chroma */
      recon_comp (src_f[1], tmp_f[1], lx, lx2, w, h, bx_chroma, by_chroma, dxf, dyf, 1);
      recon_comp (src_f[2], tmp_f[2], lx, lx2, w, h, bx_chroma, by_chroma, dxf, dyf, 2);
      recon_comp (src_b[1], tmp_b[1], lx, lx2, w, h, bx_chroma, by_chroma, dxb, dyb, 1);
      recon_comp (src_b[2], tmp_b[2], lx, lx2, w, h, bx_chroma, by_chroma, dxb, dyb, 2);

      /* Average forward and backward prediction. */
      recon_bidir_average (bx, by);

      break;

    default:

      fprintf (stderr, "Illegal scalable prediction type in reconstruct_true_B (recon.c)\n");
      exit (-1);
      break;

  }
}

/**********************************************************************
  *
 *	Name:        reconstruct_ei_ep
 *	Description: Reconstructs ei and ep MBs
 *
 *	Input:       position, mb prediction type
 *	Returns:     
 *	Side effects:
 *
 *	Date: 971102 Author: Michael Gallant --- [e-mail]
 *
 ***********************************************************************/
void reconstruct_ei_ep (int bx, int by, int ei_ep_prediction_type)
{
  int w, h, lx, lx2, dxf, dyf;
  int x, y, mode;
  int bx_chroma, by_chroma;
  unsigned char *src_fwd[3], *src_up[3], *tmp_fwd[3], *tmp_up[3];

  /* current_refererence frame should be upsampled already if spatial scalbility is in use */

  x = bx / 16 + 1;
  y = by / 16 + 1;
  lx = coded_picture_width;
  w = 16;
  h = 16;

  lx2 = coded_picture_width + 64;
  src_fwd[0] = enhance_edgeframe[enhancement_layer_num-2][0];
  src_fwd[1] = enhance_edgeframe[enhancement_layer_num-2][1];
  src_fwd[2] = enhance_edgeframe[enhancement_layer_num-2][2];
  src_up[0] = curr_reference_frame[0];
  src_up[1] = curr_reference_frame[1];
  src_up[2] = curr_reference_frame[2];

  tmp_fwd[0] = tmp_enhance_fwd[enhancement_layer_num-2][0];
  tmp_fwd[1] = tmp_enhance_fwd[enhancement_layer_num-2][1];
  tmp_fwd[2] = tmp_enhance_fwd[enhancement_layer_num-2][2];
  tmp_up[0] = tmp_enhance_up[enhancement_layer_num-2][0];
  tmp_up[1] = tmp_enhance_up[enhancement_layer_num-2][1];
  tmp_up[2] = tmp_enhance_up[enhancement_layer_num-2][2];

  mode = modemap[y][x];

  switch (ei_ep_prediction_type)
  {

    case EP_FORWARD_PREDICTION:

      w = 16;
      h = 16;
      dxf = MV[0][0][y][x];
      dyf = MV[1][0][y][x];

      /* Y */
      recon_comp (src_fwd[0], current_enhancement_frame[enhancement_layer_num-2][0], lx, lx2, w, h, bx, by, dxf, dyf, 0);

      lx >>= 1;
      w >>= 1;
      bx >>= 1;
      lx2 >>= 1;
      h >>= 1;
      by >>= 1;

      /* chroma rounding */
      dxf = (dxf % 4 == 0 ? dxf >> 1 : (dxf >> 1) | 1);
      dyf = (dyf % 4 == 0 ? dyf >> 1 : (dyf >> 1) | 1);

      /* Chroma */
      recon_comp (src_fwd[1], current_enhancement_frame[enhancement_layer_num-2][1], lx, lx2, w, h, bx, by, dxf, dyf, 1);
      recon_comp (src_fwd[2], current_enhancement_frame[enhancement_layer_num-2][2], lx, lx2, w, h, bx, by, dxf, dyf, 2);

      break;

    case EI_EP_UPWARD_PREDICTION:

      /* Inter 16x16 */
      w = 16;
      h = 16;

      /* Y */
      recon_comp (src_up[0], current_enhancement_frame[enhancement_layer_num-2][0], lx, lx, w, h, bx, by, 0, 0, 0);

      lx >>= 1;
      w >>= 1;
      bx >>= 1;
      lx2 >>= 1;
      h >>= 1;
      by >>= 1;

      /* Chroma */
      recon_comp (src_up[1], current_enhancement_frame[enhancement_layer_num-2][1], lx, lx, w, h, bx, by, 0, 0, 1);
      recon_comp (src_up[2], current_enhancement_frame[enhancement_layer_num-2][2], lx, lx, w, h, bx, by, 0, 0, 2);

      break;

    case EP_BIDIRECTIONAL_PREDICTION:

      w = 16;
      h = 16;

      dxf = MV[0][0][y][x];
      dyf = MV[1][0][y][x];

      /* Y */
      recon_comp (src_fwd[0], tmp_fwd[0], lx, lx2, w, h, bx, by, dxf, dyf, 0);
      recon_comp (src_up[0], tmp_up[0], lx, lx, w, h, bx, by, 0, 0, 0);

      lx >>= 1;
      w >>= 1;
      lx2 >>= 1;
      h >>= 1;

      bx_chroma = bx >> 1;
      by_chroma = by >> 1;


      dxf = (dxf % 4 == 0 ? dxf >> 1 : (dxf >> 1) | 1);
      dyf = (dyf % 4 == 0 ? dyf >> 1 : (dyf >> 1) | 1);

      /* Chroma */
      recon_comp (src_fwd[1], tmp_fwd[1], lx, lx2, w, h, bx_chroma, by_chroma, dxf, dyf, 1);
      recon_comp (src_fwd[2], tmp_fwd[2], lx, lx2, w, h, bx_chroma, by_chroma, dxf, dyf, 2);
      recon_comp (src_up[1], tmp_up[1], lx, lx, w, h, bx_chroma, by_chroma, 0, 0, 1);
      recon_comp (src_up[2], tmp_up[2], lx, lx, w, h, bx_chroma, by_chroma, 0, 0, 2);

      /* Average forward and backward prediction. */
      recon_bidir_average (bx, by);

      break;

    default:

      fprintf (stderr, "Illegal scalable prediction type in reconstruct_ei_ep (recon.c)\n");
      exit (-1);

      break;

  }
}

static void recon_comp (unsigned char *src, unsigned char *dst, 
                        int lx, int lx2, int w, int h, int x, 
                        int y, int dx, int dy, int chroma)
{
  int xint, xh, yint, yh;
  unsigned char *s, *d;
  int store_rtype;
  
  store_rtype = rtype;

  xint = dx >> 1;
  xh = dx & 1;
  yint = dy >> 1;
  yh = dy & 1;

  /* origins */
  s = src + lx2 * (y + yint) + x + xint;
  d = dst + lx * y + x;

  if (!xh && !yh)
    if (w != 8)
      rec (s, d, lx, lx2, h);
    else
      recc (s, d, lx, lx2, h);
  else if (!xh && yh)
    if (w != 8)
      recv (s, d, lx, lx2, h);
    else
      recvc (s, d, lx, lx2, h);
  else if (xh && !yh)
    if (w != 8)
      rech (s, d, lx, lx2, h);
    else
      rechc (s, d, lx, lx2, h);
  else
   /* if (xh && yh) */ if (w != 8)
    rec4 (s, d, lx, lx2, h);
  else
    rec4c (s, d, lx, lx2, h);

  rtype = store_rtype;
}

static void rec (unsigned char *s, unsigned char *d, 
                 int lx, int lx2, int h)
{
  int j;

  for (j = 0; j < h; j++)
  {
    d[0] = s[0];
    d[1] = s[1];
    d[2] = s[2];
    d[3] = s[3];
    d[4] = s[4];
    d[5] = s[5];
    d[6] = s[6];
    d[7] = s[7];
    d[8] = s[8];
    d[9] = s[9];
    d[10] = s[10];
    d[11] = s[11];
    d[12] = s[12];
    d[13] = s[13];
    d[14] = s[14];
    d[15] = s[15];
    s += lx2;
    d += lx;
  }
}

/**********************************************************************
 *
 *	Name:        recon_bidir_average
 *	Description: move average of bidir predicted blocks into current frame
 *
 *	Input:       absolute position of current MB
 *
 *	Returns:
 *	Side effects:
 *
 *	Date: 971102 Author: Michael Gallant --- [e-mail]
 *
 ***********************************************************************/
static void recon_bidir_average (int bx, int by)
{
  int i, iincr, cc, comp;
  unsigned char *avg, *forw, *backw;
  unsigned char *prev_frame[3], *next_frame[3], *curr[3];

  /* B picture */
  if (PCT_B == pict_type)
  {
    prev_frame[0] = tmp_f[0];
    prev_frame[1] = tmp_f[1];
    prev_frame[2] = tmp_f[2];
    next_frame[0] = tmp_b[0];
    next_frame[1] = tmp_b[1];
    next_frame[2] = tmp_b[2];
    curr[0] = current_frame[0];
    curr[1] = current_frame[1];
    curr[2] = current_frame[2];
  }
  /* EP picture */
  else
  {
    prev_frame[0] = tmp_enhance_fwd[enhancement_layer_num-2][0];
    prev_frame[1] = tmp_enhance_fwd[enhancement_layer_num-2][1];
    prev_frame[2] = tmp_enhance_fwd[enhancement_layer_num-2][2];
    next_frame[0] = tmp_enhance_up[enhancement_layer_num-2][0];
    next_frame[1] = tmp_enhance_up[enhancement_layer_num-2][1];
    next_frame[2] = tmp_enhance_up[enhancement_layer_num-2][2];
    curr[0] = current_enhancement_frame[enhancement_layer_num-2][0];
    curr[1] = current_enhancement_frame[enhancement_layer_num-2][1];
    curr[2] = current_enhancement_frame[enhancement_layer_num-2][2];
  }

  for (comp = 0; comp < 6; ++comp)
  {
    cc = (comp < 4) ? 0 : (comp & 1) + 1; /* color component index */

    /* luminance */
    if (cc == 0)
    {
      avg = curr[cc] + coded_picture_width * (by + ((comp & 2) << 2)) + bx + ((comp & 1) << 3);
      forw = prev_frame[cc] + coded_picture_width * (by + ((comp & 2) << 2)) + bx + ((comp & 1) << 3);
      backw = next_frame[cc] + coded_picture_width * (by + ((comp & 2) << 2)) + bx + ((comp & 1) << 3);
      iincr = coded_picture_width;
    }
    /* chrominance */
    else
    {
      /* scale coordinates */
      if (4 == comp)
      {
        bx >>= 1;
        by >>= 1;
      }
      avg = curr[cc] + chrom_width * by + bx;
      forw = prev_frame[cc] + chrom_width * by + bx;
      backw = next_frame[cc] + chrom_width * by + bx;
      iincr = chrom_width;
    }

    for (i = 0; i < 8; i++)
    {
      avg[0] = (forw[0] + backw[0]) / 2;
      avg[1] = (forw[1] + backw[1]) / 2;
      avg[2] = (forw[2] + backw[2]) / 2;
      avg[3] = (forw[3] + backw[3]) / 2;
      avg[4] = (forw[4] + backw[4]) / 2;
      avg[5] = (forw[5] + backw[5]) / 2;
      avg[6] = (forw[6] + backw[6]) / 2;
      avg[7] = (forw[7] + backw[7]) / 2;
      avg += iincr;
      forw += iincr;
      backw += iincr;
    }
  }
}


static void recc (unsigned char *s, unsigned char *d, 
                  int lx, int lx2, int h)
{
  int j;

  for (j = 0; j < h; j++)
  {
    d[0] = s[0];
    d[1] = s[1];
    d[2] = s[2];
    d[3] = s[3];
    d[4] = s[4];
    d[5] = s[5];
    d[6] = s[6];
    d[7] = s[7];
    s += lx2;
    d += lx;
  }
}

static void reco (unsigned char *s, int *d, int lx, int lx2, 
                  int addflag, int c, int xa, int xb, 
                  int ya, int yb)
{
  int i, j;
  int *om;

  om = &OM[c][ya][0];

  if (!addflag)
  {
    for (j = ya; j < yb; j++)
    {
      for (i = xa; i < xb; i++)
      {
        d[i] = s[i] * om[i];
      }
      s += lx2;
      d += lx;
      om += 8;
    }
  } else
  {
    for (j = ya; j < yb; j++)
    {
      for (i = xa; i < xb; i++)
      {
        d[i] += s[i] * om[i];
      }
      s += lx2;
      d += lx;
      om += 8;
    }
  }
}

static void rech (unsigned char *s, unsigned char *d, 
                  int lx, int lx2, int h)
{
  unsigned char *dp, *sp;
  int j;
  unsigned int s1, s2;

  sp = s;
  dp = d;
  for (j = 0; j < h; j++)
  {
    s1 = sp[0];
    dp[0] = (unsigned int) (s1 + (s2 = sp[1]) + 1 - rtype) >> 1;
    dp[1] = (unsigned int) (s2 + (s1 = sp[2]) + 1 - rtype) >> 1;
    dp[2] = (unsigned int) (s1 + (s2 = sp[3]) + 1 - rtype) >> 1;
    dp[3] = (unsigned int) (s2 + (s1 = sp[4]) + 1 - rtype) >> 1;
    dp[4] = (unsigned int) (s1 + (s2 = sp[5]) + 1 - rtype) >> 1;
    dp[5] = (unsigned int) (s2 + (s1 = sp[6]) + 1 - rtype) >> 1;
    dp[6] = (unsigned int) (s1 + (s2 = sp[7]) + 1 - rtype) >> 1;
    dp[7] = (unsigned int) (s2 + (s1 = sp[8]) + 1 - rtype) >> 1;
    dp[8] = (unsigned int) (s1 + (s2 = sp[9]) + 1 - rtype) >> 1;
    dp[9] = (unsigned int) (s2 + (s1 = sp[10]) + 1 - rtype) >> 1;
    dp[10] = (unsigned int) (s1 + (s2 = sp[11]) + 1 - rtype) >> 1;
    dp[11] = (unsigned int) (s2 + (s1 = sp[12]) + 1 - rtype) >> 1;
    dp[12] = (unsigned int) (s1 + (s2 = sp[13]) + 1 - rtype) >> 1;
    dp[13] = (unsigned int) (s2 + (s1 = sp[14]) + 1 - rtype) >> 1;
    dp[14] = (unsigned int) (s1 + (s2 = sp[15]) + 1 - rtype) >> 1;
    dp[15] = (unsigned int) (s2 + sp[16] + 1 - rtype) >> 1;
    sp += lx2;
    dp += lx;
  }
}

static void rechc (unsigned char *s, unsigned char *d, 
                   int lx, int lx2, int h)
{
  unsigned char *dp, *sp;
  int j;
  unsigned int s1, s2;

  sp = s;
  dp = d;
  for (j = 0; j < h; j++)
  {
    s1 = sp[0];
    dp[0] = (unsigned int) (s1 + (s2 = sp[1]) + 1 - rtype) >> 1;
    dp[1] = (unsigned int) (s2 + (s1 = sp[2]) + 1 - rtype) >> 1;
    dp[2] = (unsigned int) (s1 + (s2 = sp[3]) + 1 - rtype) >> 1;
    dp[3] = (unsigned int) (s2 + (s1 = sp[4]) + 1 - rtype) >> 1;
    dp[4] = (unsigned int) (s1 + (s2 = sp[5]) + 1 - rtype) >> 1;
    dp[5] = (unsigned int) (s2 + (s1 = sp[6]) + 1 - rtype) >> 1;
    dp[6] = (unsigned int) (s1 + (s2 = sp[7]) + 1 - rtype) >> 1;
    dp[7] = (unsigned int) (s2 + sp[8] + 1 - rtype) >> 1;
    sp += lx2;
    dp += lx;
  }
}