}/********************************************************************** * *	Name:        DoPredChrom_P *	Description:	Does the chrominance prediction for P-frames * *	Input:        motionvectors for each field, *        current position in image, *        pointers to current and previos image, *        pointer to pred_error array, *        (int) field: 1 if field coding * *	Side effects:	fills chrom-array in pred_error structure * *	Date: 930211	Author: Karl.Lillevold@nta.no * ***********************************************************************/void DoPredChrom_P (int x_curr, int y_curr, int dx, int dy,                    PictImage * curr, PictImage * prev, MB_Structure * prediction,                    MB_Structure * pred_error, int rtype){  int m, n;  int x, y, ofx, ofy, pel, lx;  int xint, yint;  int xh, yh;  lx = (mv_outside_frame ? pels / 2 + (long_vectors ? 32 : 16) : pels / 2);  x = x_curr >> 1;  y = y_curr >> 1;  xint = dx >> 1;  xh = dx & 1;  yint = dy >> 1;  yh = dy & 1;  if (!xh && !yh)  {    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = *(prev->Cr + ofx + (ofy) * lx);        prediction->Cr[n][m] = pel;        pred_error->Cr[n][m] = (int) (*(curr->Cr + x + m + (y + n) * cpels) - pel);        pel = *(prev->Cb + ofx + (ofy) * lx);        prediction->Cb[n][m] = pel;        pred_error->Cb[n][m] = (int) (*(curr->Cb + x + m + (y + n) * cpels) - pel);      }    }  } else if (!xh && yh)  {    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = (*(prev->Cr + ofx + (ofy) * lx) +               *(prev->Cr + ofx + (ofy + yh) * lx) + 1 - rtype) >> 1;        prediction->Cr[n][m] = pel;        pred_error->Cr[n][m] =          (int) (*(curr->Cr + x + m + (y + n) * cpels) - pel);        pel = (*(prev->Cb + ofx + (ofy) * lx) +               *(prev->Cb + ofx + (ofy + yh) * lx) + 1 - rtype) >> 1;        prediction->Cb[n][m] = pel;        pred_error->Cb[n][m] =          (int) (*(curr->Cb + x + m + (y + n) * cpels) - pel);      }    }  } else if (xh && !yh)  {    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = (*(prev->Cr + ofx + (ofy) * lx) +               *(prev->Cr + ofx + xh + (ofy) * lx) + 1 - rtype) >> 1;        prediction->Cr[n][m] = pel;        pred_error->Cr[n][m] =          (int) (*(curr->Cr + x + m + (y + n) * cpels) - pel);        pel = (*(prev->Cb + ofx + (ofy) * lx) +               *(prev->Cb + ofx + xh + (ofy) * lx) + 1 - rtype) >> 1;        prediction->Cb[n][m] = pel;        pred_error->Cb[n][m] =          (int) (*(curr->Cb + x + m + (y + n) * cpels) - pel);      }    }  } else  {                             /* xh && yh */    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = (*(prev->Cr + ofx + (ofy) * lx) +               *(prev->Cr + ofx + xh + (ofy) * lx) +               *(prev->Cr + ofx + (ofy + yh) * lx) +               *(prev->Cr + ofx + xh + (ofy + yh) * lx) +               2 - rtype) >> 2;        prediction->Cr[n][m] = pel;        pred_error->Cr[n][m] =          (int) (*(curr->Cr + x + m + (y + n) * cpels) - pel);        pel = (*(prev->Cb + ofx + (ofy) * lx) +               *(prev->Cb + ofx + xh + (ofy) * lx) +               *(prev->Cb + ofx + (ofy + yh) * lx) +               *(prev->Cb + ofx + xh + (ofy + yh) * lx) +               2 - rtype) >> 2;        prediction->Cb[n][m] = pel;        pred_error->Cb[n][m] =          (int) (*(curr->Cb + x + m + (y + n) * cpels) - pel);      }    }  }  return;}/********************************************************************** * *	Name:        ReconMacroblock_P *	Description:	Reconstructs MB after quantization for P_images * *	Input:        pointers to current and previous image, *        current slice and mb, and which mode *        of prediction has been used *	Returns: *	Side effects: * *	Date: 930122	Author: Karl.Lillevold@nta.no * ***********************************************************************/MB_Structure *MB_Recon_P (PictImage * prev_image, unsigned char *prev_ipol,                          MB_Structure * diff, int x_curr, int y_curr,                          MotionVector * MV[6][MBR + 1][MBC + 2], int PB, int RTYPE){  MB_Structure *recon_data = (MB_Structure *) malloc (sizeof (MB_Structure));  MotionVector *fr0, *fr1, *fr2, *fr3, *fr4;  int pred[16][16];  int dx, dy, sum;  int i, j;  fr0 = MV[0][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];  /* change advanced to overlapping_MC since * 4 MV can be used without   * OBMC in        * deblocking filter mode                  */  if (overlapping_MC)  {    if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q)    {      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[0][0], 0, PB);      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[0][8], 1, PB);      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[8][0], 2, PB);      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[8][8], 3, PB);      for (j = 0; j < MB_SIZE; j++)        for (i = 0; i < MB_SIZE; i++)          diff->lum[j][i] += pred[j][i];      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);      ReconChromBlock_P (x_curr, y_curr, dx, dy, prev_image, diff, RTYPE);    } else if (fr0->Mode == MODE_INTER4V || fr0->Mode == MODE_INTER4V_Q)    {                           /* Inter 8x8 */      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[0][0], 0, PB);      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[0][8], 1, PB);      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[8][0], 2, PB);      FindPredOBMC (x_curr, y_curr, MV, prev_ipol, &pred[8][8], 3, PB);      for (j = 0; j < MB_SIZE; j++)        for (i = 0; i < MB_SIZE; i++)          diff->lum[j][i] += pred[j][i];      fr1 = MV[1][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      fr2 = MV[2][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      fr3 = MV[3][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      fr4 = MV[4][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      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);      ReconChromBlock_P (x_curr, y_curr, dx, dy, prev_image, diff, RTYPE);    }  } else  {    if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q)    {      /* Inter 16x16 */      ReconLumBlock_P (x_curr, y_curr, fr0, prev_ipol, &diff->lum[0][0], 16, 0);      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);      ReconChromBlock_P (x_curr, y_curr, dx, dy, prev_image, diff, RTYPE);    }    if (fr0->Mode == MODE_INTER4V || fr0->Mode == MODE_INTER4V_Q)    {      fr1 = MV[1][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      fr2 = MV[2][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      fr3 = MV[3][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      fr4 = MV[4][y_curr / MB_SIZE + 1][x_curr / MB_SIZE + 1];      FindPred (x_curr, y_curr, fr1, prev_ipol, &pred[0][0], 8, 0);      FindPred (x_curr, y_curr, fr2, prev_ipol, &pred[0][8], 8, 1);      FindPred (x_curr, y_curr, fr3, prev_ipol, &pred[8][0], 8, 2);      FindPred (x_curr, y_curr, fr4, prev_ipol, &pred[8][8], 8, 3);      for (j = 0; j < MB_SIZE; j++)        for (i = 0; i < MB_SIZE; i++)          diff->lum[j][i] += pred[j][i];      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);      ReconChromBlock_P (x_curr, y_curr, dx, dy, prev_image, diff, RTYPE);    }  }  memcpy (recon_data, diff, sizeof (MB_Structure));  return recon_data;}/********************************************************************** * *	Name:        ReconLumBlock_P *	Description:	Reconstructs one block of luminance data * *	Input:        position, vector-data, previous image, data-block *	Returns: *	Side effects:	reconstructs data-block * *	Date: 950210	Author: Karl.Lillevold@nta.no * ***********************************************************************/void ReconLumBlock_P (int x, int y, MotionVector * fr,                       unsigned char *prev, int *data, int bs, int comp){  int m, n;  int x1, y1, lx;  lx = (mv_outside_frame ? pels + (long_vectors ? 64 : 32) : pels);  x1 = 2 * (x + fr->x) + fr->x_half;  y1 = 2 * (y + fr->y) + fr->y_half;  x1 += ((comp & 1) << 4);  y1 += ((comp & 2) << 3);  for (n = 0; n < bs; n++)  {    for (m = 0; m < bs; m++)    {      *(data + m + n * 16) += (int) (*(prev + x1 + 2 * m + (y1 + 2 * n) * 2 * lx));    }  }  return;}/********************************************************************** * *	Name:        ReconChromBlock_P *	Description:        Reconstructs chrominance of one block in P frame * *	Input:        position, vector-data, previous image, data-block *	Returns: *	Side effects:	reconstructs data-block * *	Date: 930203	Author: Karl.Lillevold@nta.no * ***********************************************************************/void ReconChromBlock_P (int x_curr, int y_curr, int dx, int dy,                         PictImage * prev, MB_Structure * data, int rtype){  int m, n;  int x, y, ofx, ofy, pel, lx;  int xint, yint;  int xh, yh;  lx = (mv_outside_frame ? pels / 2 + (long_vectors ? 32 : 16) : pels / 2);  x = x_curr >> 1;  y = y_curr >> 1;  xint = dx >> 1;  xh = dx & 1;  yint = dy >> 1;  yh = dy & 1;  if (!xh && !yh)  {    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = *(prev->Cr + ofx + (ofy) * lx);        data->Cr[n][m] += pel;        pel = *(prev->Cb + ofx + (ofy) * lx);        data->Cb[n][m] += pel;      }    }  } else if (!xh && yh)  {    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = (*(prev->Cr + ofx + (ofy) * lx) +               *(prev->Cr + ofx + (ofy + yh) * lx) + 1 - rtype) >> 1;        data->Cr[n][m] += pel;        pel = (*(prev->Cb + ofx + (ofy) * lx) +               *(prev->Cb + ofx + (ofy + yh) * lx) + 1 - rtype) >> 1;        data->Cb[n][m] += pel;      }    }  } else if (xh && !yh)  {    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = (*(prev->Cr + ofx + (ofy) * lx) +               *(prev->Cr + ofx + xh + (ofy) * lx) + 1 - rtype) >> 1;        data->Cr[n][m] += pel;        pel = (*(prev->Cb + ofx + (ofy) * lx) +               *(prev->Cb + ofx + xh + (ofy) * lx) + 1 - rtype) >> 1;        data->Cb[n][m] += pel;      }    }  } else  {                             /* xh && yh */    for (n = 0; n < 8; n++)    {      for (m = 0; m < 8; m++)      {        ofx = x + xint + m;        ofy = y + yint + n;        pel = (*(prev->Cr + ofx + (ofy) * lx) +               *(prev->Cr + ofx + xh + (ofy) * lx) +               *(prev->Cr + ofx + (ofy + yh) * lx) +               *(prev->Cr + ofx + xh + (ofy + yh) * lx) +               2 - rtype) >> 2;        data->Cr[n][m] += pel;        pel = (*(prev->Cb + ofx + (ofy) * lx) +               *(prev->Cb + ofx + xh + (ofy) * lx) +               *(prev->Cb + ofx + (ofy + yh) * lx) +               *(prev->Cb + ofx + xh + (ofy + yh) * lx) +               2 - rtype) >> 2;        data->Cb[n][m] += pel;      }    }  }  r