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 --- mikeg@ee.ubc.ca * ***********************************************************************/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 --- mikeg@ee.ubc.ca * ***********************************************************************/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;  }}