开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
Pred.cpp
资源名称：263.rar　[点击查看]
上传用户：szklck
上传日期：2007-01-22
资源大小：925k
文件大小：43k
源码类别：

图形图像处理

开发平台：

Visual C++

Pred.cpp：源码内容
  1. #include"stdafx.h"
  2. #include"Global.h"
  4. /**********************************************************************
  5.  *
  6.  * Name:        Predict_P
  7.  * Description:    Predicts P macroblock in advanced or normal
  8.  *                      mode
  9.  *
  10.  * Input:        pointers to current and previous frames
  11.  *        and previous interpolated image,
  12.  *                      position and motion vector array
  13.  * Returns: pointer to MB_Structure of data to be coded
  14.  * Side effects: allocates memory to MB_Structure
  15.  *
  16.  *
  17.  ***********************************************************************/
  19. MB_Structure *Predict_P(PictImage *curr_image, PictImage *prev_image,
  20.         unsigned char *prev_ipol, int x, int y, 
  21.         MotionVector *MV[6][MBR+1][MBC+2], int PB)
  22. {
  23.   int m,n;
  24.   int curr[16][16];
  25.   int pred[16][16];
  26.   MotionVector *fr0,*fr1,*fr2,*fr3,*fr4;
  27.   int sum, dx, dy;
  28.   int xmb, ymb;
  30.   MB_Structure *pred_error = (MB_Structure *)malloc(sizeof(MB_Structure));
  31.     
  32.   xmb = x/MB_SIZE+1;
  33.   ymb = y/MB_SIZE+1;
  35.   fr0 = MV[0][ymb][xmb];
  36.   fr1 = MV[1][ymb][xmb];
  37.   fr2 = MV[2][ymb][xmb];
  38.   fr3 = MV[3][ymb][xmb];
  39.   fr4 = MV[4][ymb][xmb];
  41.   /* 装入当前宏块到curr */
  42.   FindMB(x, y, curr_image->lum, curr);
  44.   /* 基于半象素MV预测当前块 */
  45.   if (advanced) {
  46.     FindPredOBMC(x, y, MV, prev_ipol, &pred[0][0], 0, PB);
  47.     FindPredOBMC(x, y, MV, prev_ipol, &pred[0][8], 1, PB);
  48.     FindPredOBMC(x, y, MV, prev_ipol, &pred[8][0], 2, PB);
  49.     FindPredOBMC(x, y, MV, prev_ipol, &pred[8][8], 3, PB);
  50.   }
  51.   else 
  52.     FindPred(x, y, fr0, prev_ipol, &pred[0][0], 16, 0);
  54.   /* 进行预测 */
  55.   if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) {
  56.     for (n = 0; n < MB_SIZE; n++)
  57.       for (m = 0; m < MB_SIZE; m++) 
  58.         pred_error->lum[n][m] = (int)(curr[n][m] - pred[n][m]);
  60.     dx = 2*fr0->x + fr0->x_half;
  61.     dy = 2*fr0->y + fr0->y_half;
  62.     dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
  63.     dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
  65.     DoPredChrom_P(x, y, dx, dy, curr_image, prev_image, pred_error);
  66.   }
  68.   else if (fr0->Mode == MODE_INTER4V) {
  69.     for (n = 0; n < MB_SIZE; n++)
  70.       for (m = 0; m < MB_SIZE; m++) 
  71.         pred_error->lum[n][m] = (int)(curr[n][m] - pred[n][m]);
  73.     sum = 2*fr1->x + fr1->x_half + 2*fr2->x + fr2->x_half +
  74.       2*fr3->x + fr3->x_half + 2*fr4->x + fr4->x_half ; 
  75.     dx = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);
  77.     sum = 2*fr1->y + fr1->y_half + 2*fr2->y + fr2->y_half +
  78.       2*fr3->y + fr3->y_half + 2*fr4->y + fr4->y_half;
  79.     dy = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);
  81.     DoPredChrom_P(x, y, dx, dy, curr_image, prev_image, pred_error);
  82.   }
  84.   else
  85.     fprintf(stderr,"Illegal Mode in Predict_P (pred.c)n");
  87.   return pred_error;
  88. }
  91. /***********************************************************************
  92.  *
  93.  * Name:        Predict_B
  94.  * Description:    Predicts the B macroblock in PB-frame prediction
  95.  *
  96.  * Input:         pointers to current frame, previous recon. frame,
  97.  *                      pos. in image, MV-data, reconstructed macroblock
  98.  *                      from image ahead
  99.  * Returns:        pointer to differential MB data after prediction
  100.  * Side effects:   allocates memory to MB_structure
  101.  *
  102.  *
  103.  ***********************************************************************/
  105. MB_Structure *Predict_B(PictImage *curr_image, PictImage *prev_image,
  106.         unsigned char *prev_ipol,int x, int y,
  107.         MotionVector *MV[5][MBR+1][MBC+2],
  108.         MB_Structure *recon_P, int TRD,int TRB)
  109. {
  110.   int i,j,k;
  111.   int dx, dy, sad, sad_min=INT_MAX, curr[16][16], bdx=0, bdy=0;
  112.   MB_Structure *p_err = (MB_Structure *)malloc(sizeof(MB_Structure));
  113.   MB_Structure *pred = (MB_Structure *)malloc(sizeof(MB_Structure));
  114.   MotionVector *f[5];
  115.   int xvec, yvec, mvx, mvy;
  117.   for (k = 0; k <= 4; k++)
  118.     f[k] = MV[k][y/MB_SIZE+1][x/MB_SIZE+1];
  120.   /* Find MB in current image */
  121.   FindMB(x, y, curr_image->lum, curr);
  123.   if (f[0]->Mode == MODE_INTER4V) {  /* Mode INTER4V */
  124.     /* Find forward prediction */
  126.     /* Luma */
  127.     for (j = -DEF_PBDELTA_WIN; j <= DEF_PBDELTA_WIN; j++) {
  128.       for (i = -DEF_PBDELTA_WIN; i <= DEF_PBDELTA_WIN; i++) {
  130.         FindForwLumPredPB(prev_ipol, x, y, f[1], &pred->lum[0][0], 
  131.           TRD, TRB, i, j, 8, 0);
  132.         FindForwLumPredPB(prev_ipol, x, y, f[2], &pred->lum[0][8], 
  133.           TRD, TRB, i, j, 8, 1);
  134.         FindForwLumPredPB(prev_ipol, x, y, f[3], &pred->lum[8][0], 
  135.           TRD, TRB, i, j, 8, 2);
  136.         FindForwLumPredPB(prev_ipol, x, y, f[4], &pred->lum[8][8], 
  137.           TRD, TRB, i, j, 8, 3);
  139.         sad = SAD_MB_integer(&curr[0][0],&pred->lum[0][0], 16,INT_MAX);
  140.         if (i == 0 && j == 0)
  141.           sad -= PREF_PBDELTA_NULL_VEC;
  142.         if (sad < sad_min) {
  143.           sad_min = sad;
  144.           bdx = i;
  145.           bdy = j;
  146.         }
  147.       }
  148.     }
  150.     FindForwLumPredPB(prev_ipol,x,y,f[1],&pred->lum[0][0],TRD,TRB,bdx,bdy,8,0);
  151.     FindForwLumPredPB(prev_ipol,x,y,f[2],&pred->lum[0][8],TRD,TRB,bdx,bdy,8,1);
  152.     FindForwLumPredPB(prev_ipol,x,y,f[3],&pred->lum[8][0],TRD,TRB,bdx,bdy,8,2);
  153.     FindForwLumPredPB(prev_ipol,x,y,f[4],&pred->lum[8][8],TRD,TRB,bdx,bdy,8,3);
  155.     /* chroma vectors are sum of B luma vectors divided and rounded */
  156.     xvec = yvec = 0;
  157.     for (k = 1; k <= 4; k++) {
  158.       xvec += TRB*(2*f[k]->x + f[k]->x_half)/TRD + bdx;
  159.       yvec += TRB*(2*f[k]->y + f[k]->y_half)/TRD + bdy;
  160.     }
  162.     /* round values according to TABLE 16/H.263 */
  163.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  164.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  166.     FindChromBlock_P(x, y, dx, dy, prev_image, pred);
  168.     /* Find bidirectional prediction */
  169.     FindBiDirLumPredPB(&recon_P->lum[0][0], f[1], &pred->lum[0][0], 
  170.                TRD, TRB, bdx, bdy, 0, 0);
  171.     FindBiDirLumPredPB(&recon_P->lum[0][8], f[2], &pred->lum[0][8], 
  172.                TRD, TRB, bdx, bdy, 1, 0);
  173.     FindBiDirLumPredPB(&recon_P->lum[8][0], f[3], &pred->lum[8][0], 
  174.                TRD, TRB, bdx, bdy, 0, 1);
  175.     FindBiDirLumPredPB(&recon_P->lum[8][8], f[4], &pred->lum[8][8], 
  176.                TRD, TRB, bdx, bdy, 1, 1);
  178.     /* chroma vectors are sum of B luma vectors divided and rounded */
  179.     xvec = yvec = 0;
  180.     for (k = 1; k <= 4; k++) {
  181.       mvx = 2*f[k]->x + f[k]->x_half;
  182.       mvy = 2*f[k]->y + f[k]->y_half;
  183.       xvec += bdx == 0 ? (TRB-TRD) *  mvx / TRD : TRB * mvx / TRD + bdx - mvx;
  184.       yvec += bdy == 0 ? (TRB-TRD) *  mvy / TRD : TRB * mvy / TRD + bdy - mvy;
  185.     }
  187.     /* round values according to TABLE 16/H.263 */
  188.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  189.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  191.     FindBiDirChrPredPB(recon_P, dx, dy, pred); 
  192.   }
  194.   else {  /* Mode INTER or INTER_Q */
  195.     /* Find forward prediction */
  197.     for (j = -DEF_PBDELTA_WIN; j <= DEF_PBDELTA_WIN; j++) {
  198.       for (i = -DEF_PBDELTA_WIN; i <= DEF_PBDELTA_WIN; i++) {
  200.         dx = i; dy = j;
  201.         /* To keep things simple I turn off PB delta vectors at the edges */
  202.         if (!mv_outside_frame) {
  203.           if (x == 0) dx = 0;
  204.           if (x == pels - MB_SIZE) dx = 0;
  205.           if (y == 0) dy = 0;
  206.           if (y == lines - MB_SIZE) dy = 0;
  207.         }
  209.         if (f[0]->Mode == MODE_INTRA || f[0]->Mode == MODE_INTRA_Q) {
  210.           dx = dy = 0;
  211.         }
  213.         if (f[0]->x == 0 && f[0]->y == 0 && 
  214.             f[0]->x_half == 0 && f[0]->y_half == 0) {
  215.           dx = dy = 0;
  216.         }
  218.         FindForwLumPredPB(prev_ipol, x, y, f[0], &pred->lum[0][0], 
  219.           TRD, TRB, dx, dy, 16, 0);
  221.         sad = SAD_MB_integer(&curr[0][0],&pred->lum[0][0], 16, INT_MAX);
  222.         if (i == 0 && j == 0)
  223.           sad -= PREF_PBDELTA_NULL_VEC;
  224.         if (sad < sad_min) {
  225.           sad_min = sad;
  226.           bdx = dx;
  227.           bdy = dy;
  228.         }
  229.       }
  230.     }
  231.     FindForwLumPredPB(prev_ipol,x,y,f[0],&pred->lum[0][0],TRD,TRB,
  232.               bdx,bdy,16,0);
  234.     xvec = 4 * (TRB*(2*f[0]->x + f[0]->x_half) / TRD + bdx);
  235.     yvec = 4 * (TRB*(2*f[0]->y + f[0]->y_half) / TRD + bdy);
  236.     /* round values according to TABLE 16/H.263 */
  237.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  238.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  240.     FindChromBlock_P(x, y, dx, dy, prev_image, pred);
  242.     /* Find bidirectional prediction */
  243.     FindBiDirLumPredPB(&recon_P->lum[0][0], f[0], &pred->lum[0][0], 
  244.                TRD, TRB, bdx, bdy, 0, 0);
  245.     FindBiDirLumPredPB(&recon_P->lum[0][8], f[0], &pred->lum[0][8], 
  246.                TRD, TRB, bdx, bdy, 1, 0);
  247.     FindBiDirLumPredPB(&recon_P->lum[8][0], f[0], &pred->lum[8][0], 
  248.                TRD, TRB, bdx, bdy, 0, 1);
  249.     FindBiDirLumPredPB(&recon_P->lum[8][8], f[0], &pred->lum[8][8], 
  250.                TRD, TRB, bdx, bdy, 1, 1);
  252.     /* chroma vectors */
  253.     mvx = 2*f[0]->x + f[0]->x_half;
  254.     xvec = bdx == 0 ? (TRB-TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx;
  255.     xvec *= 4;
  257.     mvy = 2*f[0]->y + f[0]->y_half;
  258.     yvec = bdy == 0 ? (TRB-TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy;
  259.     yvec *= 4;
  260.       
  261.     /* round values according to TABLE 16/H.263 */
  262.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  263.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  265.     FindBiDirChrPredPB(recon_P, dx, dy, pred); 
  266.   }
  268.   /* store PB-deltas */
  269.   MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->x = bdx; /* is in half pel format */
  270.   MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->y = bdy;
  271.   MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->x_half = 0;
  272.   MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->y_half = 0;
  275.   /* Do the actual prediction */
  276.   for (j = 0; j < MB_SIZE; j++) 
  277.     for (i = 0; i < MB_SIZE; i++) 
  278.       p_err->lum[j][i] = 
  279.         *(curr_image->lum+x+i + (y+j)*pels) - pred->lum[j][i];
  281.   y >>= 1;
  282.   x >>= 1;
  283.   for (j = 0; j < (MB_SIZE>>1); j++)
  284.     for (i = 0; i < (MB_SIZE>>1); i++) {
  285.       p_err->Cr[j][i] = *(curr_image->Cr+x+i + (y+j)*cpels) - pred->Cr[j][i];
  286.       p_err->Cb[j][i] = *(curr_image->Cb+x+i + (y+j)*cpels) - pred->Cb[j][i];
  287.     }
  289.   free(pred);
  290.   return p_err;
  291. }
  293. /***********************************************************************
  294.  *
  295.  * Name:        MB_Recon_B
  296.  * Description:    Reconstructs the B macroblock in PB-frame
  297.  *                      prediction
  298.  *
  299.  * Input:         pointers previous recon. frame, pred. diff.,
  300.  *                      pos. in image, MV-data, reconstructed macroblock
  301.  *                      from image ahead
  302.  * Returns:        pointer to reconstructed MB data 
  303.  * Side effects:   allocates memory to MB_structure
  304.  *
  305.  *
  306.  ***********************************************************************/
  308. MB_Structure* MB_Recon_B(PictImage* prev_image, 
  309. MB_Structure *diff, 
  310.           unsigned char *prev_ipol, 
  311.                int x, int y,    
  312.           MotionVector *MV[5][MBR+1][MBC+2], 
  313.           MB_Structure *recon_P, 
  314.                int TRD, int TRB)
  315. {
  316.   int i,j,k;
  317.   int dx, dy, bdx, bdy, mvx, mvy, xvec, yvec;
  318.   MB_Structure *recon_B = (MB_Structure *)malloc(sizeof(MB_Structure));
  319.   MB_Structure *pred = (MB_Structure *)malloc(sizeof(MB_Structure));
  320.   MotionVector *f[5];
  322.   for (k = 0; k <= 4; k++)
  323.     f[k] = MV[k][y/MB_SIZE+1][x/MB_SIZE+1];
  325.   bdx = MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->x;
  326.   bdy = MV[5][y/MB_SIZE+1][x/MB_SIZE+1]->y;
  328.   if (f[0]->Mode == MODE_INTER4V) {  /* Mode INTER4V */
  329.     /* Find forward prediction */
  331.     /* Luma */
  332.     FindForwLumPredPB(prev_ipol,x,y,f[1],&pred->lum[0][0],TRD,TRB,bdx,bdy,8,0);
  333.     FindForwLumPredPB(prev_ipol,x,y,f[2],&pred->lum[0][8],TRD,TRB,bdx,bdy,8,1);
  334.     FindForwLumPredPB(prev_ipol,x,y,f[3],&pred->lum[8][0],TRD,TRB,bdx,bdy,8,2);
  335.     FindForwLumPredPB(prev_ipol,x,y,f[4],&pred->lum[8][8],TRD,TRB,bdx,bdy,8,3);
  337.     /* chroma vectors are sum of B luma vectors divided and rounded */
  338.     xvec = yvec = 0;
  339.     for (k = 1; k <= 4; k++) {
  340.       xvec += TRB*(2*f[k]->x + f[k]->x_half)/TRD + bdx;
  341.       yvec += TRB*(2*f[k]->y + f[k]->y_half)/TRD + bdy;
  342.     }
  344.     /* round values according to TABLE 16/H.263 */
  345.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  346.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  348.     FindChromBlock_P(x, y, dx, dy, prev_image, pred);
  350.     /* Find bidirectional prediction */
  351.     FindBiDirLumPredPB(&recon_P->lum[0][0], f[1], &pred->lum[0][0], 
  352.                TRD, TRB, bdx, bdy, 0, 0);
  353.     FindBiDirLumPredPB(&recon_P->lum[0][8], f[2], &pred->lum[0][8], 
  354.                TRD, TRB, bdx, bdy, 1, 0);
  355.     FindBiDirLumPredPB(&recon_P->lum[8][0], f[3], &pred->lum[8][0], 
  356.                TRD, TRB, bdx, bdy, 0, 1);
  357.     FindBiDirLumPredPB(&recon_P->lum[8][8], f[4], &pred->lum[8][8], 
  358.                TRD, TRB, bdx, bdy, 1, 1);
  360.     /* chroma vectors are sum of B luma vectors divided and rounded */
  361.     xvec = yvec = 0;
  362.     for (k = 1; k <= 4; k++) {
  363.       mvx = 2*f[k]->x + f[k]->x_half;
  364.       mvy = 2*f[k]->y + f[k]->y_half;
  365.       xvec += bdx == 0 ? (TRB-TRD) *  mvx / TRD : TRB * mvx / TRD + bdx - mvx;
  366.       yvec += bdy == 0 ? (TRB-TRD) *  mvy / TRD : TRB * mvy / TRD + bdy - mvy;
  367.     }
  369.     /* round values according to TABLE 16/H.263 */
  370.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  371.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  373.     FindBiDirChrPredPB(recon_P, dx, dy, pred); 
  375.   }
  376.   else {  /* Mode INTER or INTER_Q */
  377.     /* Find forward prediction */
  378.     
  379.     FindForwLumPredPB(prev_ipol,x,y,f[0],&pred->lum[0][0],TRD,TRB,
  380.               bdx,bdy,16,0);
  382.     xvec = 4 * (TRB*(2*f[0]->x + f[0]->x_half) / TRD + bdx);
  383.     yvec = 4 * (TRB*(2*f[0]->y + f[0]->y_half) / TRD + bdy);
  384.     /* round values according to TABLE 16/H.263 */
  385.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  386.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  388.     FindChromBlock_P(x, y, dx, dy, prev_image, pred);
  390.     /* Find bidirectional prediction */
  391.     FindBiDirLumPredPB(&recon_P->lum[0][0], f[0], &pred->lum[0][0], 
  392.                TRD, TRB, bdx, bdy, 0, 0);
  393.     FindBiDirLumPredPB(&recon_P->lum[0][8], f[0], &pred->lum[0][8], 
  394.                TRD, TRB, bdx, bdy, 1, 0);
  395.     FindBiDirLumPredPB(&recon_P->lum[8][0], f[0], &pred->lum[8][0], 
  396.                TRD, TRB, bdx, bdy, 0, 1);
  397.     FindBiDirLumPredPB(&recon_P->lum[8][8], f[0], &pred->lum[8][8], 
  398.                TRD, TRB, bdx, bdy, 1, 1);
  400.     /* chroma vectors */
  401.     mvx = 2*f[0]->x + f[0]->x_half;
  402.     xvec = bdx == 0 ? (TRB-TRD) * mvx / TRD : TRB * mvx / TRD + bdx - mvx;
  403.     xvec *= 4;
  405.     mvy = 2*f[0]->y + f[0]->y_half;
  406.     yvec = bdy == 0 ? (TRB-TRD) * mvy / TRD : TRB * mvy / TRD + bdy - mvy;
  407.     yvec *= 4;
  408.       
  409.     /* round values according to TABLE 16/H.263 */
  410.     dx = sign(xvec)*(roundtab[abs(xvec)%16] + (abs(xvec)/16)*2);
  411.     dy = sign(yvec)*(roundtab[abs(yvec)%16] + (abs(yvec)/16)*2);
  413.     FindBiDirChrPredPB(recon_P, dx, dy, pred); 
  415.   }
  417.   /* Reconstruction */
  418.   for (j = 0; j < MB_SIZE; j++) 
  419.     for (i = 0; i < MB_SIZE; i++) 
  420.       recon_B->lum[j][i] = pred->lum[j][i] + diff->lum[j][i];
  421.         
  422.   for (j = 0; j < (MB_SIZE>>1); j++)
  423.     for (i = 0; i < (MB_SIZE>>1); i++) {
  424.       recon_B->Cr[j][i] = pred->Cr[j][i] + diff->Cr[j][i];
  425.       recon_B->Cb[j][i] = pred->Cb[j][i] + diff->Cb[j][i];
  426.     }
  427.   
  428.   free(pred);
  429.   return recon_B;
  430. }
  432. /**********************************************************************
  433.  *
  434.  * Name:        FindForwLumPredPB
  435.  * Description:   Finds the forward luma  prediction in PB-frame 
  436.  *                     pred.
  437.  *
  438.  * Input:        pointer to prev. recon. frame, current positon,
  439.  *                     MV structure and pred. structure to fill
  440.  *
  441.  *
  442.  ***********************************************************************/
  444. void FindForwLumPredPB(unsigned char *prev_ipol, int x_curr, int y_curr, 
  445.                MotionVector *fr, int *pred, int TRD, int TRB, 
  446.                int bdx, int bdy, int bs, int comp)
  447. {
  448.   int i,j;
  449.   int xvec,yvec,lx;
  451.   lx = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);
  453.   /* Luma */
  454.   xvec = (TRB)*(2*fr->x + fr->x_half)/TRD + bdx;
  455.   yvec = (TRB)*(2*fr->y + fr->y_half)/TRD + bdy;
  457.   x_curr += ((comp&1)<<3);
  458.   y_curr += ((comp&2)<<2);
  460.   for (j = 0; j < bs; j++) {
  461.     for (i = 0; i < bs; i++) {
  462.       *(pred+i+j*16) = *(prev_ipol + (i+x_curr)*2 + xvec +
  463.          ((j+y_curr)*2 + yvec)*lx*2);
  464.     }
  465.   }
  467.   return;
  468. }
  471. /**********************************************************************
  472.  *
  473.  * Name:        FindBiDirLumPredPB
  474.  * Description:   Finds the bi-dir. luma prediction in PB-frame 
  475.  *                     prediction
  476.  *
  477.  * Input:        pointer to future recon. data, current positon,
  478.  *                     MV structure and pred. structure to fill
  479.  *
  480.  *
  481.  ***********************************************************************/
  483. void FindBiDirLumPredPB(int *recon_P, MotionVector *fr, int *pred, int TRD, 
  484.         int TRB, int bdx, int bdy, int nh, int nv)
  485. {
  486.   int xstart,xstop,ystart,ystop;
  487.   int xvec,yvec, mvx, mvy;
  489.   mvx = 2*fr->x + fr->x_half;
  490.   mvy = 2*fr->y + fr->y_half;
  492.   xvec = (bdx == 0 ? (TRB-TRD) *  mvx / TRD : TRB * mvx / TRD + bdx - mvx);
  493.   yvec = (bdy == 0 ? (TRB-TRD) *  mvy / TRD : TRB * mvy / TRD + bdy - mvy);
  495.   /* Luma */
  497.   FindBiDirLimits(xvec,&xstart,&xstop,nh);
  498.   FindBiDirLimits(yvec,&ystart,&ystop,nv);
  500.   BiDirPredBlock(xstart,xstop,ystart,ystop,xvec,yvec, recon_P,pred,16);
  502.   return;
  503. }
  505. /**********************************************************************
  506.  *
  507.  * Name:        FindBiDirChrPredPB
  508.  * Description:   Finds the bi-dir. chroma prediction in PB-frame 
  509.  *                     prediction
  510.  *
  511.  * Input:        pointer to future recon. data, current positon,
  512.  *                     MV structure and pred. structure to fill
  513.  *
  514.  *
  515.  ***********************************************************************/
  517. void FindBiDirChrPredPB(MB_Structure *recon_P, int dx, int dy, 
  518.         MB_Structure *pred)
  519. {
  520.   int xstart,xstop,ystart,ystop;
  522.   FindBiDirChromaLimits(dx,&xstart,&xstop);
  523.   FindBiDirChromaLimits(dy,&ystart,&ystop);
  525.   BiDirPredBlock(xstart,xstop,ystart,ystop,dx,dy,
  526.          &recon_P->Cb[0][0], &pred->Cb[0][0],8);
  527.   BiDirPredBlock(xstart,xstop,ystart,ystop,dx,dy,
  528.          &recon_P->Cr[0][0], &pred->Cr[0][0],8);
  530.   return;
  531. }
  533. void FindBiDirLimits(int vec, int *start, int *stop, int nhv)
  534. {
  536.   /* limits taken from C loop in section G5 in H.263 */
  537.   *start = mmax(0,(-vec+1)/2 - nhv*8);
  538.   *stop = mmin(7,15-(vec+1)/2 - nhv*8);
  540.   return;
  542. }
  543.   
  544. void FindBiDirChromaLimits(int vec, int *start, int *stop)
  545. {
  547.   /* limits taken from C loop in section G5 in H.263 */
  548.   *start = mmax(0,(-vec+1)/2);
  549.   *stop = mmin(7,7-(vec+1)/2);
  551.   return;
  552. }
  555. void BiDirPredBlock(int xstart, int xstop, int ystart, int ystop,
  556.             int xvec, int yvec, int *recon, int *pred, int bl)
  557. {
  558.   int i,j,pel;
  559.   int xint, yint;
  560.   int xh, yh;
  562.   xint = xvec>>1;
  563.   xh = xvec - 2*xint;
  564.   yint = yvec>>1;
  565.   yh = yvec - 2*yint;
  567.   if (!xh && !yh) {
  568.     for (j = ystart; j <= ystop; j++) {
  569.       for (i = xstart; i <= xstop; i++) {
  570.         pel = *(recon +(j+yint)*bl + i+xint);
  571.         *(pred + j*bl + i) = (mmin(255,mmax(0,pel)) + *(pred + j*bl + i))>>1;
  572.       }
  573.     }
  574.   }
  575.   else if (!xh && yh) {
  576.     for (j = ystart; j <= ystop; j++) {
  577.       for (i = xstart; i <= xstop; i++) {
  578.         pel = (*(recon +(j+yint)*bl + i+xint)       + 
  579.                *(recon +(j+yint+yh)*bl + i+xint) + 1)>>1;
  580.         *(pred + j*bl + i) = (pel + *(pred + j*bl + i))>>1;
  581.       }
  582.     }
  583.   }
  584.   else if (xh && !yh) {
  585.     for (j = ystart; j <= ystop; j++) {
  586.       for (i = xstart; i <= xstop; i++) {
  587.         pel = (*(recon +(j+yint)*bl + i+xint)       + 
  588.                *(recon +(j+yint)*bl + i+xint+xh) + 1)>>1;
  589.         *(pred + j*bl + i) = (pel + *(pred + j*bl + i))>>1;
  590.       }
  591.     }
  592.   }
  593.   else { /* xh && yh */
  594.     for (j = ystart; j <= ystop; j++) {
  595.       for (i = xstart; i <= xstop; i++) {
  596.         pel = (*(recon +(j+yint)*bl + i+xint)       + 
  597.                *(recon +(j+yint+yh)*bl + i+xint) + 
  598.                *(recon +(j+yint)*bl + i+xint+xh) + 
  599.                *(recon +(j+yint+yh)*bl + i+xint+xh)+2)>>2;
  600.         *(pred + j*bl + i) = (pel + *(pred + j*bl + i))>>1;
  601.       }
  602.     }
  603.   }
  604.   return;
  605. }
  607. /**********************************************************************
  608.  *
  609.  * Name:        DoPredChrom_P
  610.  * Description: Does the chrominance prediction for P-frames
  611.  *
  612.  * Input:        motionvectors for each field,
  613.  *        current position in image,
  614.  *        pointers to current and previos image,
  615.  *        pointer to pred_error array,
  616.  *        (int) field: 1 if field coding
  617.  *        
  618.  * Side effects: fills chrom-array in pred_error structure
  619.  *
  620.  *
  621.  ***********************************************************************/
  623. void DoPredChrom_P(int x_curr, int y_curr, int dx, int dy,
  624.            PictImage *curr, PictImage *prev, 
  625.            MB_Structure *pred_error)
  626. {
  627.   int m,n;
  629.   int x, y, ofx, ofy, pel, lx;
  630.   int xint, yint;
  631.   int xh, yh;
  633.   lx = (mv_outside_frame ? pels/2 + (long_vectors?32:16) : pels/2);
  635.   x = x_curr>>1;
  636.   y = y_curr>>1;
  638.   xint = dx>>1;
  639.   xh = dx & 1;
  640.   yint = dy>>1;
  641.   yh = dy & 1;
  643.   if (!xh && !yh) {
  644.     for (n = 0; n < 8; n++) {
  645.       for (m = 0; m < 8; m++) {
  647.         ofx = x + xint + m;
  648.         ofy = y + yint + n;
  649.         pel=*(prev->Cr+ofx    + (ofy   )*lx);
  650.         pred_error->Cr[n][m] = (int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);
  652.         pel=*(prev->Cb+ofx    + (ofy   )*lx);
  653.         pred_error->Cb[n][m] = (int)(*(curr->Cb + x+m + (y+n)*cpels) - pel);
  654.       }
  655.     }
  656.   }
  657.   else if (!xh && yh) {
  658.     for (n = 0; n < 8; n++) {
  659.       for (m = 0; m < 8; m++) {
  661.         ofx = x + xint + m;
  662.         ofy = y + yint + n;
  663.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  664.              *(prev->Cr+ofx    + (ofy+yh)*lx) + 1)>>1;
  666.         pred_error->Cr[n][m] = 
  667.           (int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);
  669.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  670.              *(prev->Cb+ofx    + (ofy+yh)*lx) + 1)>>1;
  672.         pred_error->Cb[n][m] = 
  673.           (int)(*(curr->Cb + x+m + (y+n)*cpels) - pel);
  674.       
  675.       }
  676.     }
  677.   }
  678.   else if (xh && !yh) {
  679.     for (n = 0; n < 8; n++) {
  680.       for (m = 0; m < 8; m++) {
  682.         ofx = x + xint + m;
  683.         ofy = y + yint + n;
  684.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  685.              *(prev->Cr+ofx+xh + (ofy   )*lx) + 1)>>1;
  687.         pred_error->Cr[n][m] = 
  688.           (int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);
  690.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  691.              *(prev->Cb+ofx+xh + (ofy   )*lx) + 1)>>1;
  693.         pred_error->Cb[n][m] = 
  694.           (int)(*(curr->Cb + x+m + (y+n)*cpels) - pel);
  695.       
  696.       }
  697.     }
  698.   }
  699.   else { /* xh && yh */
  700.     for (n = 0; n < 8; n++) {
  701.       for (m = 0; m < 8; m++) {
  702.         ofx = x + xint + m;
  703.         ofy = y + yint + n;
  704.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  705.              *(prev->Cr+ofx+xh + (ofy   )*lx)+
  706.              *(prev->Cr+ofx    + (ofy+yh)*lx)+
  707.              *(prev->Cr+ofx+xh + (ofy+yh)*lx)+
  708.              2)>>2;
  710.         pred_error->Cr[n][m] = 
  711.           (int)(*(curr->Cr + x+m + (y+n)*cpels) - pel);
  713.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  714.              *(prev->Cb+ofx+xh + (ofy   )*lx)+
  715.              *(prev->Cb+ofx    + (ofy+yh)*lx)+
  716.              *(prev->Cb+ofx+xh + (ofy+yh)*lx)+
  717.              2)>>2;
  719.         pred_error->Cb[n][m] = 
  720.           (int)(*(curr->Cb + x+m + (y+n)*cpels) - pel);
  721.       
  722.       }
  723.     }
  724.   }
  725.   return;
  726. }
  728. /**********************************************************************
  729.  *
  730.  * Name:        FindHalfPel
  731.  * Description: Find the optimal half pel prediction
  732.  *
  733.  * Input:        position, vector, array with current data
  734.  *        pointer to previous interpolated luminance,
  735.  *
  736.  * Returns:
  737.  *
  738.  *            950208    Mod: Karl.Lillevold@nta.no
  739.  *
  740.  ***********************************************************************/
  743. void FindHalfPel(int x, int y, MotionVector *fr, unsigned char *prev, 
  744.          int *curr, int bs, int comp)
  745. {
  746.   int i, m, n;
  747.   int half_pel;
  748.   int start_x, start_y, stop_x, stop_y, new_x, new_y, lx;
  749.   int min_pos;
  750.   int AE, AE_min;
  751.   CPoint search[9];
  753.   start_x = -1;
  754.   stop_x = 1;
  755.   start_y = -1;
  756.   stop_y = 1;
  758.   new_x = x + fr->x;
  759.   new_y = y + fr->y;
  761.   new_x += ((comp&1)<<3);
  762.   new_y += ((comp&2)<<2);
  764.   lx = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);
  766.   if (!mv_outside_frame) {
  767.     if ((new_x) <= 0) 
  768.       start_x = 0;
  769.     if ((new_y) <= 0) 
  770.       start_y = 0;
  771.     if ((new_x) >= (pels-bs)) 
  772.       stop_x = 0;
  773.     if ((new_y) >= (lines-bs)) 
  774.       stop_y = 0;
  775.   }
  777.   search[0].x = 0;             search[0].y = 0;
  778.   search[1].x = start_x;       search[1].y = start_y; /*   1 2 3   */
  779.   search[2].x = 0;             search[2].y = start_y; /*   4 0 5   */
  780.   search[3].x = stop_x;        search[3].y = start_y; /*   6 7 8   */
  781.   search[4].x = start_x;       search[4].y = 0;
  782.   search[5].x = stop_x;        search[5].y = 0;
  783.   search[6].x = start_x;       search[6].y = stop_y;
  784.   search[7].x = 0;             search[7].y = stop_y;
  785.   search[8].x = stop_x;        search[8].y = stop_y;
  787.   AE_min = INT_MAX;
  788.   min_pos = 0;
  789.   for (i = 0; i < 9; i++) {
  790.     AE = 0;
  791.     for (n = 0; n < bs; n++) {
  792.       for (m = 0; m < bs; m++) {
  793.         /* 计算绝对误差 */
  794.         half_pel = *(prev + 2*new_x + 2*m + search[i].x +
  795.              (2*new_y + 2*n + search[i].y)*lx*2);
  796.         AE += abs(half_pel - *(curr + m + n*16));
  797.       }
  798.     }
  800.     if (AE < AE_min) {
  801.       AE_min = AE;
  802.       min_pos = i;
  803.     }
  804.   }
  806.   /* 存储最优值 */
  807.   fr->min_error = AE_min;
  808.   fr->x_half = search[min_pos].x;
  809.   fr->y_half = search[min_pos].y;
  810.         
  811.   return;
  812. }
  814. /**********************************************************************
  815.  *
  816.  * Name:        FindPred
  817.  * Description: Find the prediction block
  818.  *
  819.  * Input:        position, vector, array for prediction
  820.  *        pointer to previous interpolated luminance,
  821.  *
  822.  * Side effects: fills array with prediction
  823.  *
  824.  *            950208    Mod: Karl.Lillevold@nta.no
  825.  *
  826.  ***********************************************************************/
  829. void FindPred(int x, int y, MotionVector *fr, unsigned char *prev, 
  830.               int *pred, int bs, int comp)
  831. {
  832.   int m, n;
  833.   int new_x, new_y;
  834.   int lx;
  836.   lx = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);
  838.   new_x = x + fr->x;
  839.   new_y = y + fr->y;
  841.   new_x += ((comp&1)<<3);
  842.   new_y += ((comp&2)<<2);
  845.   /* 填充预测数据 */
  846.   for (n = 0; n < bs; n++) {
  847.     for (m = 0; m < bs; m++) {
  848.       *(pred + m + n*16) = *(prev + (new_x + m)*2 + fr->x_half +
  849.              ((new_y + n)*2 + fr->y_half)*lx*2);
  850.     }
  851.   }
  852.   return;
  853. }
  855. /**********************************************************************
  856.  *
  857.  * Name:        FindPredOBMC
  858.  * Description: Find the OBMC prediction block
  859.  *
  860.  * Input:        position, vector, array for prediction
  861.  *        pointer to previous interpolated luminance,
  862.  *
  863.  * Returns:
  864.  * Side effects: fills array with prediction
  865.  *
  866.  *
  867.  ***********************************************************************/
  870. void FindPredOBMC(int x, int y, MotionVector *MV[6][MBR+1][MBC+2], 
  871.           unsigned char *prev, int *pred, int comp, int PB)
  872. {
  873.   int m, n;
  874.   int pc,pt,pb,pr,pl;
  875.   int nxc,nxt,nxb,nxr,nxl;
  876.   int nyc,nyt,nyb,nyr,nyl;
  877.   int xit,xib,xir,xil;
  878.   int yit,yib,yir,yil;
  879.   int vect,vecb,vecr,vecl;
  880.   int c8,t8,l8,r8;
  881.   int ti8,li8,ri8;
  882.   int xmb, ymb, lx;
  883.   MotionVector *fc,*ft,*fb,*fr,*fl;
  885.   int Mc[8][8] = {
  886.     {4,5,5,5,5,5,5,4},
  887.     {5,5,5,5,5,5,5,5},
  888.     {5,5,6,6,6,6,5,5},
  889.     {5,5,6,6,6,6,5,5},
  890.     {5,5,6,6,6,6,5,5},
  891.     {5,5,6,6,6,6,5,5},
  892.     {5,5,5,5,5,5,5,5},
  893.     {4,5,5,5,5,5,5,4},
  894.   };
  895.   int Mt[8][8] = {
  896.     {2,2,2,2,2,2,2,2},
  897.     {1,1,2,2,2,2,1,1},
  898.     {1,1,1,1,1,1,1,1},
  899.     {1,1,1,1,1,1,1,1},
  900.     {0,0,0,0,0,0,0,0},
  901.     {0,0,0,0,0,0,0,0},
  902.     {0,0,0,0,0,0,0,0},
  903.     {0,0,0,0,0,0,0,0},
  904.   };
  905.   int Mb[8][8] = {
  906.     {0,0,0,0,0,0,0,0},
  907.     {0,0,0,0,0,0,0,0},
  908.     {0,0,0,0,0,0,0,0},
  909.     {0,0,0,0,0,0,0,0},
  910.     {1,1,1,1,1,1,1,1},
  911.     {1,1,1,1,1,1,1,1},
  912.     {1,1,2,2,2,2,1,1},
  913.     {2,2,2,2,2,2,2,2},
  914.   };
  915.   int Mr[8][8] = {
  916.     {0,0,0,0,1,1,1,2},
  917.     {0,0,0,0,1,1,2,2},
  918.     {0,0,0,0,1,1,2,2},
  919.     {0,0,0,0,1,1,2,2},
  920.     {0,0,0,0,1,1,2,2},
  921.     {0,0,0,0,1,1,2,2},
  922.     {0,0,0,0,1,1,2,2},
  923.     {0,0,0,0,1,1,1,2},
  924.   };
  925.   int Ml[8][8] = {
  926.     {2,1,1,1,0,0,0,0},
  927.     {2,2,1,1,0,0,0,0},
  928.     {2,2,1,1,0,0,0,0},
  929.     {2,2,1,1,0,0,0,0},
  930.     {2,2,1,1,0,0,0,0},
  931.     {2,2,1,1,0,0,0,0},
  932.     {2,2,1,1,0,0,0,0},
  933.     {2,1,1,1,0,0,0,0},
  934.   };
  936.   xmb = x/MB_SIZE+1;
  937.   ymb = y/MB_SIZE+1;
  939.   lx = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);
  941.   c8  = (MV[0][ymb][xmb]->Mode == MODE_INTER4V ? 1 : 0);
  943.   t8  = (MV[0][ymb-1][xmb]->Mode == MODE_INTER4V ? 1 : 0);
  944.   ti8 = (MV[0][ymb-1][xmb]->Mode == MODE_INTRA ? 1 : 0);
  945.   ti8 = (MV[0][ymb-1][xmb]->Mode == MODE_INTRA_Q ? 1 : ti8);
  947.   l8  = (MV[0][ymb][xmb-1]->Mode == MODE_INTER4V ? 1 : 0);
  948.   li8 = (MV[0][ymb][xmb-1]->Mode == MODE_INTRA ? 1 : 0);
  949.   li8 = (MV[0][ymb][xmb-1]->Mode == MODE_INTRA_Q ? 1 : li8);
  950.   
  951.   r8  = (MV[0][ymb][xmb+1]->Mode == MODE_INTER4V ? 1 : 0);
  952.   ri8 = (MV[0][ymb][xmb+1]->Mode == MODE_INTRA ? 1 : 0);
  953.   ri8 = (MV[0][ymb][xmb+1]->Mode == MODE_INTRA_Q ? 1 : ri8);
  955.   if (PB) {
  956.     ti8 = li8 = ri8 = 0;
  957.   }
  959.   switch (comp+1) {
  961.   case 1:
  962.     vect = (ti8 ? (c8 ? 1 : 0) : (t8 ? 3 : 0)); 
  963.     yit  = (ti8 ? ymb : ymb - 1); 
  964.     xit = xmb;
  966.     vecb = (c8 ? 3 : 0) ; yib = ymb; xib = xmb;
  968.     vecl = (li8 ? (c8 ? 1 : 0) : (l8 ? 2 : 0)); 
  969.     yil = ymb; 
  970.     xil = (li8 ? xmb : xmb-1);
  972.     vecr = (c8 ? 2 : 0) ; yir = ymb; xir = xmb;
  974.     /* edge handling */
  975.     if (ymb == 1) {
  976.       yit = ymb;
  977.       vect = (c8 ? 1 : 0);
  978.     }
  979.     if (xmb == 1) {
  980.       xil = xmb;
  981.       vecl = (c8 ? 1 : 0);
  982.     }
  983.     break;
  984.   
  985.   case 2:
  986.     vect = (ti8 ? (c8 ? 2 : 0) : (t8 ? 4 : 0)); 
  987.     yit = (ti8 ? ymb : ymb-1); 
  988.     xit = xmb;
  990.     vecb = (c8 ? 4 : 0) ; yib = ymb; xib = xmb;
  991.     vecl = (c8 ? 1 : 0) ; yil = ymb; xil = xmb;
  993.     vecr = (ri8 ? (c8 ? 2 : 0) : (r8 ? 1 : 0)); 
  994.     yir = ymb; 
  995.     xir = (ri8 ? xmb : xmb+1);
  997.     /* edge handling */
  998.     if (ymb == 1) {
  999.       yit = ymb;
  1000.       vect = (c8 ? 2 : 0);
  1001.     }
  1002.     if (xmb == pels/16) {
  1003.       xir = xmb;
  1004.       vecr = (c8 ? 2 : 0);
  1005.     }
  1006.     break;
  1008.   case 3:
  1009.     vect = (c8 ? 1 : 0) ; yit = ymb  ; xit = xmb;
  1010.     vecb = (c8 ? 3 : 0) ; yib = ymb  ; xib = xmb;
  1011.       
  1012.     vecl = (li8 ? (c8 ? 3 : 0) : (l8 ? 4 : 0)); 
  1013.     yil = ymb;  
  1014.     xil = (li8 ? xmb : xmb-1);
  1015.     
  1016.     vecr = (c8 ? 4 : 0) ; yir = ymb  ; xir = xmb;
  1018.     /* edge handling */
  1019.     if (xmb == 1) {
  1020.       xil = xmb;
  1021.       vecl = (c8 ? 3 : 0);
  1022.     }
  1023.     break;
  1025.   case 4:
  1026.     vect = (c8 ? 2 : 0) ; yit = ymb  ; xit = xmb;
  1027.     vecb = (c8 ? 4 : 0) ; yib = ymb  ; xib = xmb;
  1028.     vecl = (c8 ? 3 : 0) ; yil = ymb  ; xil = xmb;
  1030.     vecr = (ri8 ? (c8 ? 4 : 0) : (r8 ? 3 : 0)); 
  1031.     yir = ymb; 
  1032.     xir = (ri8 ? xmb : xmb+1);
  1034.     /* edge handling */
  1035.     if (xmb == pels/16) {
  1036.       xir = xmb;
  1037.       vecr = (c8 ? 4 : 0);
  1038.     }
  1039.     break;
  1041.   default:
  1042.     fprintf(stderr,"Illegal block number in FindPredOBMC (pred.c)n");
  1043.     exit(-1);
  1044.     break;
  1045.   }
  1047.   fc = MV[c8 ? comp + 1: 0][ymb][xmb];
  1049.   ft = MV[vect][yit][xit];
  1050.   fb = MV[vecb][yib][xib];
  1051.   fr = MV[vecr][yir][xir];
  1052.   fl = MV[vecl][yil][xil];
  1054.   nxc = 2*x + ((comp&1)<<4); nyc = 2*y + ((comp&2)<<3);
  1055.   nxt = nxb = nxr = nxl = nxc;
  1056.   nyt = nyb = nyr = nyl = nyc;
  1058.   nxc += 2*fc->x + fc->x_half; nyc += 2*fc->y + fc->y_half;
  1059.   nxt += 2*ft->x + ft->x_half; nyt += 2*ft->y + ft->y_half;
  1060.   nxb += 2*fb->x + fb->x_half; nyb += 2*fb->y + fb->y_half;
  1061.   nxr += 2*fr->x + fr->x_half; nyr += 2*fr->y + fr->y_half;
  1062.   nxl += 2*fl->x + fl->x_half; nyl += 2*fl->y + fl->y_half;
  1064.   /* Fill pred. data */
  1065.   for (n = 0; n < 8; n++) {
  1066.     for (m = 0; m < 8; m++) {
  1068.       /* Find interpolated pixel-value */
  1069.       pc = *(prev + nxc + 2*m + (nyc + 2*n)*lx*2) * Mc[n][m];
  1070.       pt = *(prev + nxt + 2*m + (nyt + 2*n)*lx*2) * Mt[n][m];
  1071.       pb = *(prev + nxb + 2*m + (nyb + 2*n)*lx*2) * Mb[n][m];
  1072.       pr = *(prev + nxr + 2*m + (nyr + 2*n)*lx*2) * Mr[n][m];
  1073.       pl = *(prev + nxl + 2*m + (nyl + 2*n)*lx*2) * Ml[n][m];
  1075.       /*$pc = *(prev + nxc + 2*m + (nyc + 2*n)*lx*2) * 8;
  1076.       pt = *(prev + nxt + 2*m + (nyt + 2*n)*lx*2) * 0;;
  1077.       pb = *(prev + nxb + 2*m + (nyb + 2*n)*lx*2) * 0;
  1078.       pr = *(prev + nxr + 2*m + (nyr + 2*n)*lx*2) * 0;
  1079.       pl = *(prev + nxl + 2*m + (nyl + 2*n)*lx*2) * 0;$*/
  1081.       *(pred + m + n*16) = (pc+pt+pb+pr+pl+4)>>3;
  1082.     }
  1083.   }
  1084.   return;
  1085. }
  1088. /**********************************************************************
  1089.  *
  1090.  * Name:        ReconMacroblock_P
  1091.  * Description: Reconstructs MB after quantization for P_images
  1092.  *
  1093.  * Input:        pointers to current and previous image,
  1094.  *        current slice and mb, and which mode
  1095.  *        of prediction has been used
  1096.  * Returns:
  1097.  * Side effects:
  1098.  *
  1099.  *
  1100.  ***********************************************************************/
  1102. MB_Structure *MB_Recon_P(PictImage *prev_image, unsigned char *prev_ipol,
  1103.          MB_Structure *diff, int x_curr, int y_curr, 
  1104.          MotionVector *MV[6][MBR+1][MBC+2], int PB)
  1105. {
  1106.   MB_Structure *recon_data = (MB_Structure *)malloc(sizeof(MB_Structure));
  1107.   MotionVector *fr0,*fr1,*fr2,*fr3,*fr4;
  1108.   int pred[16][16];
  1109.   int dx, dy, sum;
  1110.   int i,j;
  1112.   fr0 = MV[0][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
  1114.   if (advanced) {
  1115.     if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) {
  1116.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][0], 0, PB);
  1117.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][8], 1, PB);
  1118.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][0], 2, PB);
  1119.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][8], 3, PB);
  1120.       for (j = 0; j < MB_SIZE; j++) 
  1121.         for (i = 0; i < MB_SIZE; i++) 
  1122.           diff->lum[j][i] += pred[j][i];
  1124.       dx = 2*fr0->x + fr0->x_half;
  1125.       dy = 2*fr0->y + fr0->y_half;
  1126.       dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
  1127.       dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
  1128.       ReconChromBlock_P(x_curr, y_curr, dx, dy, prev_image, diff);
  1129.     }
  1130.     else if (fr0->Mode == MODE_INTER4V) { /* Inter 8x8 */
  1131.       
  1132.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][0], 0, PB);
  1133.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[0][8], 1, PB);
  1134.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][0], 2, PB);
  1135.       FindPredOBMC(x_curr, y_curr, MV, prev_ipol, &pred[8][8], 3, PB);
  1136.       for (j = 0; j < MB_SIZE; j++) 
  1137.         for (i = 0; i < MB_SIZE; i++) 
  1138.           diff->lum[j][i] += pred[j][i];
  1140.       fr1 = MV[1][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
  1141.       fr2 = MV[2][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
  1142.       fr3 = MV[3][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
  1143.       fr4 = MV[4][y_curr/MB_SIZE+1][x_curr/MB_SIZE+1];
  1145.       sum = 2*fr1->x + fr1->x_half + 2*fr2->x + fr2->x_half +
  1146.         2*fr3->x + fr3->x_half + 2*fr4->x + fr4->x_half ; 
  1147.       dx = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);
  1149.       sum = 2*fr1->y + fr1->y_half + 2*fr2->y + fr2->y_half +
  1150.         2*fr3->y + fr3->y_half + 2*fr4->y + fr4->y_half;
  1151.       dy = sign(sum)*(roundtab[abs(sum)%16] + (abs(sum)/16)*2);
  1153.       ReconChromBlock_P(x_curr, y_curr, dx, dy, prev_image, diff);
  1154.     }
  1155.   }
  1156.   else {
  1157.     if (fr0->Mode == MODE_INTER || fr0->Mode == MODE_INTER_Q) {
  1158.       /* Inter 16x16 */
  1159.       ReconLumBlock_P(x_curr,y_curr,fr0,prev_ipol,&diff->lum[0][0],16,0);
  1161.       dx = 2*fr0->x + fr0->x_half;
  1162.       dy = 2*fr0->y + fr0->y_half;
  1163.       dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
  1164.       dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
  1165.       ReconChromBlock_P(x_curr, y_curr, dx, dy, prev_image, diff);
  1166.     }
  1167.   }
  1169.   memcpy(recon_data, diff, sizeof(MB_Structure));
  1171.   return recon_data;
  1172. }
  1174. /**********************************************************************
  1175.  *
  1176.  * Name:        ReconLumBlock_P
  1177.  * Description: Reconstructs one block of luminance data
  1178.  *
  1179.  * Input:        position, vector-data, previous image, data-block
  1180.  * Returns:
  1181.  * Side effects: reconstructs data-block
  1182.  *
  1183.  *
  1184.  ***********************************************************************/
  1186. void ReconLumBlock_P(int x, int y, MotionVector *fr, 
  1187.              unsigned char *prev, int *data, int bs, int comp)
  1188. {
  1189.   int m, n;
  1190.   int x1, y1, lx;
  1192.   lx = (mv_outside_frame ? pels + (long_vectors?64:32) : pels);
  1194.   x1 = 2*(x + fr->x) + fr->x_half;
  1195.   y1 = 2*(y + fr->y) + fr->y_half;
  1196.   
  1197.   x1 += ((comp&1)<<4);
  1198.   y1 += ((comp&2)<<3);
  1200.   for (n = 0; n < bs; n++) {
  1201.     for (m = 0; m < bs; m++) {
  1202.       *(data+m+n*16) += (int)(*(prev+x1+2*m + (y1+2*n)*2*lx));
  1203.     }
  1204.   }
  1206.   return;
  1207. }
  1209. /**********************************************************************
  1210.  *
  1211.  * Name:        ReconChromBlock_P
  1212.  * Description:        Reconstructs chrominance of one block in P frame
  1213.  *
  1214.  * Input:        position, vector-data, previous image, data-block
  1215.  * Returns:        
  1216.  * Side effects: reconstructs data-block
  1217.  *
  1218.  *
  1219.  ***********************************************************************/
  1221. void ReconChromBlock_P(int x_curr, int y_curr, int dx, int dy,
  1222.                PictImage *prev, MB_Structure *data)
  1224. {
  1225.   int m,n;
  1227.   int x, y, ofx, ofy, pel,lx;
  1228.   int xint, yint;
  1229.   int xh, yh;
  1231.   lx = (mv_outside_frame ? pels/2 + (long_vectors?32:16) : pels/2);
  1233.   x = x_curr>>1;
  1234.   y = y_curr>>1;
  1236.   xint = dx>>1;
  1237.   xh = dx & 1;
  1238.   yint = dy>>1;
  1239.   yh = dy & 1;
  1240.     
  1241.   if (!xh && !yh) {
  1242.     for (n = 0; n < 8; n++) {
  1243.       for (m = 0; m < 8; m++) {
  1245.         ofx = x + xint + m;
  1246.         ofy = y + yint + n;
  1247.         pel=*(prev->Cr+ofx    + (ofy   )*lx);
  1248.         data->Cr[n][m] += pel;
  1250.         pel=*(prev->Cb+ofx    + (ofy   )*lx);
  1251.         data->Cb[n][m] += pel;
  1252.       }
  1253.     }
  1254.   }
  1255.   else if (!xh && yh) {
  1256.     for (n = 0; n < 8; n++) {
  1257.       for (m = 0; m < 8; m++) {
  1259.         ofx = x + xint + m;
  1260.         ofy = y + yint + n;
  1261.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  1262.              *(prev->Cr+ofx    + (ofy+yh)*lx) + 1)>>1;
  1264.         data->Cr[n][m] += pel;
  1266.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  1267.              *(prev->Cb+ofx    + (ofy+yh)*lx) + 1)>>1;
  1269.         data->Cb[n][m] += pel;
  1270.       
  1271.       }
  1272.     }
  1273.   }
  1274.   else if (xh && !yh) {
  1275.     for (n = 0; n < 8; n++) {
  1276.       for (m = 0; m < 8; m++) {
  1278.         ofx = x + xint + m;
  1279.         ofy = y + yint + n;
  1280.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  1281.              *(prev->Cr+ofx+xh + (ofy   )*lx) + 1)>>1;
  1283.         data->Cr[n][m] += pel;
  1285.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  1286.              *(prev->Cb+ofx+xh + (ofy   )*lx) + 1)>>1;
  1288.         data->Cb[n][m] += pel;
  1289.       
  1290.       }
  1291.     }
  1292.   }
  1293.   else { /* xh && yh */
  1294.     for (n = 0; n < 8; n++) {
  1295.       for (m = 0; m < 8; m++) {
  1296.         ofx = x + xint + m;
  1297.         ofy = y + yint + n;
  1298.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  1299.              *(prev->Cr+ofx+xh + (ofy   )*lx)+
  1300.              *(prev->Cr+ofx    + (ofy+yh)*lx)+
  1301.              *(prev->Cr+ofx+xh + (ofy+yh)*lx)+
  1302.              2)>>2;
  1304.         data->Cr[n][m] += pel;
  1306.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  1307.              *(prev->Cb+ofx+xh + (ofy   )*lx)+
  1308.              *(prev->Cb+ofx    + (ofy+yh)*lx)+
  1309.              *(prev->Cb+ofx+xh + (ofy+yh)*lx)+
  1310.              2)>>2;
  1312.         data->Cb[n][m] += pel;
  1313.       
  1314.       }
  1315.     }
  1316.   }
  1317.   return;
  1318. }
  1320. /**********************************************************************
  1321.  *
  1322.  * Name:        FindChromBlock_P
  1323.  * Description:        Finds chrominance of one block in P frame
  1324.  *
  1325.  * Input:        position, vector-data, previous image, data-block
  1326.  *
  1327.  *
  1328.  ***********************************************************************/
  1330. void FindChromBlock_P(int x_curr, int y_curr, int dx, int dy,
  1331.               PictImage *prev, MB_Structure *data)
  1333. {
  1334.   int m,n;
  1336.   int x, y, ofx, ofy, pel,lx;
  1337.   int xint, yint;
  1338.   int xh, yh;
  1340.   lx = (mv_outside_frame ? pels/2 + (long_vectors?32:16) : pels/2);
  1342.   x = x_curr>>1;
  1343.   y = y_curr>>1;
  1345.   xint = dx>>1;
  1346.   xh = dx & 1;
  1347.   yint = dy>>1;
  1348.   yh = dy & 1;
  1349.     
  1350.   if (!xh && !yh) {
  1351.     for (n = 0; n < 8; n++) {
  1352.       for (m = 0; m < 8; m++) {
  1354.         ofx = x + xint + m;
  1355.         ofy = y + yint + n;
  1356.         pel=*(prev->Cr+ofx    + (ofy   )*lx);
  1357.         data->Cr[n][m] = pel;
  1359.         pel=*(prev->Cb+ofx    + (ofy   )*lx);
  1360.         data->Cb[n][m] = pel;
  1361.       }
  1362.     }
  1363.   }
  1364.   else if (!xh && yh) {
  1365.     for (n = 0; n < 8; n++) {
  1366.       for (m = 0; m < 8; m++) {
  1368.         ofx = x + xint + m;
  1369.         ofy = y + yint + n;
  1370.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  1371.              *(prev->Cr+ofx    + (ofy+yh)*lx) + 1)>>1;
  1373.         data->Cr[n][m] = pel;
  1375.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  1376.              *(prev->Cb+ofx    + (ofy+yh)*lx) + 1)>>1;
  1378.         data->Cb[n][m] = pel;
  1379.       
  1380.       }
  1381.     }
  1382.   }
  1383.   else if (xh && !yh) {
  1384.     for (n = 0; n < 8; n++) {
  1385.       for (m = 0; m < 8; m++) {
  1387.         ofx = x + xint + m;
  1388.         ofy = y + yint + n;
  1389.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  1390.              *(prev->Cr+ofx+xh + (ofy   )*lx) + 1)>>1;
  1392.         data->Cr[n][m] = pel;
  1394.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  1395.              *(prev->Cb+ofx+xh + (ofy   )*lx) + 1)>>1;
  1397.         data->Cb[n][m] = pel;
  1398.       
  1399.       }
  1400.     }
  1401.   }
  1402.   else { /* xh && yh */
  1403.     for (n = 0; n < 8; n++) {
  1404.       for (m = 0; m < 8; m++) {
  1405.         ofx = x + xint + m;
  1406.         ofy = y + yint + n;
  1407.         pel=(*(prev->Cr+ofx    + (ofy   )*lx)+
  1408.              *(prev->Cr+ofx+xh + (ofy   )*lx)+
  1409.              *(prev->Cr+ofx    + (ofy+yh)*lx)+
  1410.              *(prev->Cr+ofx+xh + (ofy+yh)*lx)+
  1411.              2)>>2;
  1413.         data->Cr[n][m] = pel;
  1415.         pel=(*(prev->Cb+ofx    + (ofy   )*lx)+
  1416.              *(prev->Cb+ofx+xh + (ofy   )*lx)+
  1417.              *(prev->Cb+ofx    + (ofy+yh)*lx)+
  1418.              *(prev->Cb+ofx+xh + (ofy+yh)*lx)+
  1419.              2)>>2;
  1421.         data->Cb[n][m] = pel;
  1422.       
  1423.       }
  1424.     }
  1425.   }
  1426.   return;
  1427. }
  1431. /**********************************************************************
  1432.  *
  1433.  * Name:        ChooseMode
  1434.  * Description:    chooses coding mode
  1435.  *
  1436.  * Input:         pointer to original fram, min_error from 
  1437.  *                      integer pel search, DQUANT
  1438.  * Returns:        1 for Inter, 0 for Intra
  1439.  *
  1440.  *
  1441.  ***********************************************************************/
  1443. int ChooseMode(unsigned char *curr, int x_pos, int y_pos, int min_SAD)
  1444. {
  1445.   int i,j;
  1446.   int MB_mean = 0, A = 0;
  1447.   int y_off;
  1449.   for (j = 0; j < MB_SIZE; j++) {
  1450.     y_off = (y_pos + j) * pels;
  1451.     for (i = 0; i < MB_SIZE; i++) {
  1452.       MB_mean += *(curr + x_pos + i + y_off);
  1453.     }
  1454.   }
  1455.   MB_mean /= (MB_SIZE*MB_SIZE);
  1456.   for (j = 0; j < MB_SIZE; j++) {
  1457.     y_off = (y_pos + j) * pels;
  1458.     for (i = 0; i < MB_SIZE; i++) {
  1459.       A += abs( *(curr + x_pos + i + y_off) - MB_mean );
  1460.     }
  1461.   }
  1463.   if (A < (min_SAD - 500)) 
  1464.     return MODE_INTRA;
  1465.   else
  1466.     return MODE_INTER;
  1467. }
  1469. int ModifyMode(int Mode, int dquant)
  1470. {
  1472.   if (Mode == MODE_INTRA) {
  1473.     if(dquant!=0)
  1474.       return MODE_INTRA_Q;
  1475.     else
  1476.       return MODE_INTRA;
  1477.   }
  1478.   else{ 
  1479.     if(dquant!=0)
  1480.       return MODE_INTER_Q;
  1481.     else
  1482.       return Mode;
  1483.   }
  1484. }