[cvs] / xvidcore / src / motion / estimation_pvop.c Repository:
ViewVC logotype

Diff of /xvidcore/src/motion/estimation_pvop.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.2.1, Wed Sep 10 22:18:59 2003 UTC revision 1.7, Thu May 27 14:25:49 2004 UTC
# Line 42  Line 42 
42    
43  static const int xvid_me_lambda_vec8[32] =  static const int xvid_me_lambda_vec8[32] =
44          {     0    ,(int)(1.00235 * NEIGH_TEND_8X8 + 0.5),          {     0    ,(int)(1.00235 * NEIGH_TEND_8X8 + 0.5),
45          (int)(1.15582 + NEIGH_TEND_8X8 + 0.5), (int)(1.31976*NEIGH_TEND_8X8 + 0.5),          (int)(1.15582*NEIGH_TEND_8X8 + 0.5), (int)(1.31976*NEIGH_TEND_8X8 + 0.5),
46          (int)(1.49591*NEIGH_TEND_8X8 + 0.5), (int)(1.68601*NEIGH_TEND_8X8 + 0.5),          (int)(1.49591*NEIGH_TEND_8X8 + 0.5), (int)(1.68601*NEIGH_TEND_8X8 + 0.5),
47          (int)(1.89187*NEIGH_TEND_8X8 + 0.5), (int)(2.11542*NEIGH_TEND_8X8 + 0.5),          (int)(1.89187*NEIGH_TEND_8X8 + 0.5), (int)(2.11542*NEIGH_TEND_8X8 + 0.5),
48          (int)(2.35878*NEIGH_TEND_8X8 + 0.5), (int)(2.62429*NEIGH_TEND_8X8 + 0.5),          (int)(2.35878*NEIGH_TEND_8X8 + 0.5), (int)(2.62429*NEIGH_TEND_8X8 + 0.5),
# Line 60  Line 60 
60  };  };
61    
62  static void  static void
63  CheckCandidate16(const int x, const int y, const SearchData * const data, const unsigned int Direction)  CheckCandidate16(const int x, const int y, SearchData * const data, const unsigned int Direction)
64  {  {
         int xc, yc;  
65          const uint8_t * Reference;          const uint8_t * Reference;
66            int32_t sad, xc, yc; uint32_t t;
67          VECTOR * current;          VECTOR * current;
         int32_t sad; uint32_t t;  
68    
69          if ( (x > data->max_dx) || (x < data->min_dx)          if ( (x > data->max_dx) || (x < data->min_dx)
70                  || (y > data->max_dy) || (y < data->min_dy) ) return;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
71    
72          if (!data->qpel_precision) {          if (data->qpel_precision) { /* x and y are in 1/4 precision */
73                    Reference = xvid_me_interpolate16x16qpel(x, y, 0, data);
74                    current = data->currentQMV;
75                    xc = x/2; yc = y/2;
76            } else {
77                  Reference = GetReference(x, y, data);                  Reference = GetReference(x, y, data);
78                  current = data->currentMV;                  current = data->currentMV;
79                  xc = x; yc = y;                  xc = x; yc = y;
         } else { /* x and y are in 1/4 precision */  
                 Reference = xvid_me_interpolate16x16qpel(x, y, 0, data);  
                 xc = x/2; yc = y/2; /* for chroma sad */  
                 current = data->currentQMV;  
80          }          }
81    
82          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);
# Line 86  Line 85 
85          sad += (data->lambda16 * t * sad)>>10;          sad += (data->lambda16 * t * sad)>>10;
86          data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;          data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
87    
88          if (data->chroma && sad < data->iMinSAD[0])          if (data->chroma) {
89                    if (sad >= data->iMinSAD[0]) goto no16;
90                  sad += xvid_me_ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],                  sad += xvid_me_ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
91                                                                  (yc >> 1) + roundtab_79[yc & 0x3], data);                                                                  (yc >> 1) + roundtab_79[yc & 0x3], data);
92            }
93    
94          if (sad < data->iMinSAD[0]) {          if (sad < data->iMinSAD[0]) {
95                  data->iMinSAD[0] = sad;                  data->iMinSAD[0] = sad;
96                  current[0].x = x; current[0].y = y;                  current[0].x = x; current[0].y = y;
97                  *data->dir = Direction;                  data->dir = Direction;
         }  
   
         if (data->temp[0] < data->iMinSAD[1]) {  
                 data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; }  
         if (data->temp[1] < data->iMinSAD[2]) {  
                 data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }  
         if (data->temp[2] < data->iMinSAD[3]) {  
                 data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }  
         if (data->temp[3] < data->iMinSAD[4]) {  
                 data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }  
 }  
   
 static void  
 CheckCandidate16_subpel(const int x, const int y, const SearchData * const data, const unsigned int Direction)  
 {  
         int xc, yc;  
         const uint8_t *Reference;  
         VECTOR *current, *current2;  
         int32_t sad; uint32_t t;  
   
         if ( (x > data->max_dx) || (x < data->min_dx)  
                 || (y > data->max_dy) || (y < data->min_dy) ) return;  
   
         if (!data->qpel_precision) {  
                 Reference = GetReference(x, y, data);  
                 current = data->currentMV;  
                 current2 = data->currentMV2;  
                 xc = x; yc = y;  
         } else { /* x and y are in 1/4 precision */  
                 Reference = xvid_me_interpolate16x16qpel(x, y, 0, data);  
                 xc = x/2; yc = y/2; /* for chroma sad */  
                 current = data->currentQMV;  
                 current2 = data->currentQMV2;  
98          }          }
99    
100          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);  no16:
         t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);  
   
         sad += (data->lambda16 * t * sad)>>10;  
         data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;  
   
         if (data->chroma && sad < data->iMinSAD[0])  
                 sad += xvid_me_ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],  
                                                                 (yc >> 1) + roundtab_79[yc & 0x3], data);  
   
101          if (data->temp[0] < data->iMinSAD[1]) {          if (data->temp[0] < data->iMinSAD[1]) {
102                  data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; }                  data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; }
103          if (data->temp[1] < data->iMinSAD[2]) {          if (data->temp[1] < data->iMinSAD[2]) {
# Line 147  Line 106 
106                  data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }                  data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
107          if (data->temp[3] < data->iMinSAD[4]) {          if (data->temp[3] < data->iMinSAD[4]) {
108                  data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }                  data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
   
         if (sad < data->iMinSAD[0]) {  
                 *(data->iMinSAD2) = *(data->iMinSAD);  
                 current2->x = current->x; current2->y = current->y;  
   
                 data->iMinSAD[0] = sad;  
                 current[0].x = x; current[0].y = y;  
                 *data->dir = Direction;  
                 return;  
         }  
   
         if (sad < *(data->iMinSAD2)) {  
                 *(data->iMinSAD2) = sad;  
                 current2->x = x; current2->y = y;  
                 *data->dir = Direction;  
         }  
109  }  }
110    
111  static void  static void
112  CheckCandidate8(const int x, const int y, const SearchData * const data, const unsigned int Direction)  CheckCandidate8(const int x, const int y, SearchData * const data, const unsigned int Direction)
113  {  {
114          int32_t sad; uint32_t t;          int32_t sad; uint32_t t;
115          const uint8_t * Reference;          const uint8_t * Reference;
# Line 191  Line 134 
134          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
135                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
136                  current->x = x; current->y = y;                  current->x = x; current->y = y;
137                  *data->dir = Direction;                  data->dir = Direction;
138          }          }
139  }  }
140    
141  static void  static void
142  CheckCandidate32(const int x, const int y, const SearchData * const data, const unsigned int Direction)  CheckCandidate32(const int x, const int y, SearchData * const data, const unsigned int Direction)
143  {  {
144          uint32_t t;          uint32_t t;
145          const uint8_t * Reference;          const uint8_t * Reference;
# Line 217  Line 160 
160          if (sad < data->iMinSAD[0]) {          if (sad < data->iMinSAD[0]) {
161                  data->iMinSAD[0] = sad;                  data->iMinSAD[0] = sad;
162                  data->currentMV[0].x = x; data->currentMV[0].y = y;                  data->currentMV[0].x = x; data->currentMV[0].y = y;
163                  *data->dir = Direction;                  data->dir = Direction;
164          }          }
165    
166          if (data->temp[0] < data->iMinSAD[1]) {          if (data->temp[0] < data->iMinSAD[1]) {
# Line 230  Line 173 
173                  data->iMinSAD[4] = data->temp[3]; data->currentMV[4].x = x; data->currentMV[4].y = y; }                  data->iMinSAD[4] = data->temp[3]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
174  }  }
175    
 static void  
 SubpelRefine_Fast(SearchData * data, CheckFunc * CheckCandidate)  
 {  
 /* Do a half-pel or q-pel refinement */  
         VECTOR centerMV;  
         VECTOR second_best;  
         int best_sad = *data->iMinSAD;  
         int xo, yo, xo2, yo2;  
         int size = 2;  
         CheckFunc *backupFunc = CheckCandidate;  
   
         if(data->qpel_precision)  
                 size = 1;  
   
         centerMV = *data->currentMV;  
         *data->iMinSAD = 256 * 4096;  
   
         CHECK_CANDIDATE(centerMV.x, centerMV.y - size, 0);  
         CHECK_CANDIDATE(centerMV.x + size, centerMV.y - size, 0);  
         CHECK_CANDIDATE(centerMV.x + size, centerMV.y, 0);  
         CHECK_CANDIDATE(centerMV.x + size, centerMV.y + size, 0);  
   
         CHECK_CANDIDATE(centerMV.x, centerMV.y + size, 0);  
         CHECK_CANDIDATE(centerMV.x - size, centerMV.y + size, 0);  
         CHECK_CANDIDATE(centerMV.x - size, centerMV.y, 0);  
         CHECK_CANDIDATE(centerMV.x - size, centerMV.y - size, 0);  
   
         second_best = *data->currentMV;  
   
         if(data->qpel_precision) {  
                 second_best.x *= 2;     second_best.y *= 2;  
         }  
   
         data->currentMV[0] = centerMV;  
         *data->iMinSAD = best_sad;  
   
     centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;  
   
         xo = centerMV.x;  
         yo = centerMV.y;  
         xo2 = second_best.x;  
         yo2 = second_best.y;  
   
         CheckCandidate = CheckCandidate16_subpel;  
         *data->iMinSAD2 = 256 * 4096;  
   
         if (yo == yo2)  
         {  
                 CHECK_CANDIDATE((xo+xo2)>>1, yo, 0);  
                 CHECK_CANDIDATE(xo, yo-1, 0);  
                 CHECK_CANDIDATE(xo, yo+1, 0);  
   
                 if(best_sad <= *data->iMinSAD2)  
                         goto ende;  
   
                 if(data->currentQMV[0].x == data->currentQMV2[0].x) {  
                         CHECK_CANDIDATE((xo+xo2)>>1, yo-1, 0);  
                         CHECK_CANDIDATE((xo+xo2)>>1, yo+1, 0);  
                         goto ende;  
                 }  
                 else {  
                         CHECK_CANDIDATE((xo+xo2)>>1,  
                                 (data->currentQMV[0].x == xo) ? data->currentQMV[0].y : data->currentQMV2[0].y,  
                                 0);  
                         goto ende;  
                 }  
         }  
   
         if (xo == xo2)  
         {  
                 CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0);  
                 CHECK_CANDIDATE(xo-1, yo, 0);  
                 CHECK_CANDIDATE(xo+1, yo, 0);  
   
                 if(best_sad < *data->iMinSAD2)  
                         goto ende;  
   
                 if(data->currentQMV[0].y == data->currentQMV2[0].y) {  
                         CHECK_CANDIDATE(xo-1, (yo+yo2)>>1, 0);  
                         CHECK_CANDIDATE(xo+1, (yo+yo2)>>1, 0);  
                         goto ende;  
                 }  
                 else {  
                         CHECK_CANDIDATE((data->currentQMV[0].y == yo) ? data->currentQMV[0].x : data->currentQMV2[0].x, (yo+yo2)>>1, 0);  
                         goto ende;  
                 }  
         }  
   
         CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0);  
         CHECK_CANDIDATE((xo+xo2)>>1, yo, 0);  
   
         if(best_sad <= *data->iMinSAD2)  
                 goto ende;  
   
         CHECK_CANDIDATE((xo+xo2)>>1, (yo+yo2)>>1, 0);  
   
 ende:  
         CheckCandidate = backupFunc;  
 }  
   
176  int  int
177  xvid_me_SkipDecisionP(const IMAGE * current, const IMAGE * reference,  xvid_me_SkipDecisionP(const IMAGE * current, const IMAGE * reference,
178                                                          const int x, const int y,                                                          const int x, const int y,
# Line 369  Line 212 
212           *  [3]: topright neighbour's SAD           *  [3]: topright neighbour's SAD
213           */           */
214    
215  static __inline int  static __inline void
216  get_pmvdata2(const MACROBLOCK * const mbs,  get_pmvdata2(const MACROBLOCK * const mbs,
217                  const int mb_width,                  const int mb_width,
218                  const int bound,                  const int bound,
219                  const int x,                  const int x,
220                  const int y,                  const int y,
                 const int block,  
221                  VECTOR * const pmv,                  VECTOR * const pmv,
222                  int32_t * const psad)                  int32_t * const psad)
223  {  {
# Line 385  Line 227 
227          int lpos, tpos, rpos;          int lpos, tpos, rpos;
228          int num_cand = 0, last_cand = 1;          int num_cand = 0, last_cand = 1;
229    
         switch (block) {  
         case 0:  
230                  lx = x - 1;     ly = y;         lz = 1;                  lx = x - 1;     ly = y;         lz = 1;
231                  tx = x;         ty = y - 1;     tz = 2;                  tx = x;         ty = y - 1;     tz = 2;
232                  rx = x + 1;     ry = y - 1;     rz = 2;                  rx = x + 1;     ry = y - 1;     rz = 2;
                 break;  
         case 1:  
                 lx = x;         ly = y;         lz = 0;  
                 tx = x;         ty = y - 1;     tz = 3;  
                 rx = x + 1;     ry = y - 1;     rz = 2;  
                 break;  
         case 2:  
                 lx = x - 1;     ly = y;         lz = 3;  
                 tx = x;         ty = y;         tz = 0;  
                 rx = x;         ry = y;         rz = 1;  
                 break;  
         default:  
                 lx = x;         ly = y;         lz = 2;  
                 tx = x;         ty = y;         tz = 0;  
                 rx = x;         ry = y;         rz = 1;  
         }  
233    
234          lpos = lx + ly * mb_width;          lpos = lx + ly * mb_width;
235          rpos = rx + ry * mb_width;          rpos = rx + ry * mb_width;
# Line 442  Line 266 
266          }          }
267    
268          /* original pmvdata() compatibility hack */          /* original pmvdata() compatibility hack */
269          if (x == 0 && y == 0 && block == 0) {          if (x == 0 && y == 0) {
270                  pmv[0] = pmv[1] = pmv[2] = pmv[3] = zeroMV;                  pmv[0] = pmv[1] = pmv[2] = pmv[3] = zeroMV;
271                  psad[0] = 0;                  psad[0] = 0;
272                  psad[1] = psad[2] = psad[3] = MV_MAX_ERROR;                  psad[1] = psad[2] = psad[3] = MV_MAX_ERROR;
273                  return 0;                  return;
274          }          }
275    
276          /* if only one valid candidate preictor, the invalid candiates are set to the canidate */          /* if only one valid candidate preictor, the invalid candiates are set to the canidate */
277          if (num_cand == 1) {          if (num_cand == 1) {
278                  pmv[0] = pmv[last_cand];                  pmv[0] = pmv[last_cand];
279                  psad[0] = psad[last_cand];                  psad[0] = psad[last_cand];
280  #if 0                  return;
                 return MVequal(pmv[0], zeroMV); /* no point calculating median mv and minimum sad */  
 #endif  
   
                 /* original pmvdata() compatibility hack */  
                 return y==0 && block <= 1 ? 0 : MVequal(pmv[0], zeroMV);  
281          }          }
282    
283          if ((MVequal(pmv[1], pmv[2])) && (MVequal(pmv[1], pmv[3]))) {          if ((MVequal(pmv[1], pmv[2])) && (MVequal(pmv[1], pmv[3]))) {
284                  pmv[0] = pmv[1];                  pmv[0] = pmv[1];
285                  psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]);                  psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]);
286                  return 1;                  return;
287          }          }
288    
289          /* set median, minimum */          /* set median, minimum */
# Line 478  Line 297 
297    
298          psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]);          psad[0] = MIN(MIN(psad[1], psad[2]), psad[3]);
299    
         return 0;  
300  }  }
301    
302    
# Line 494  Line 312 
312                                  const IMAGE * const pCurrent,                                  const IMAGE * const pCurrent,
313                                  const IMAGE * const pRef,                                  const IMAGE * const pRef,
314                                  const IMAGE * const vGMC,                                  const IMAGE * const vGMC,
315                                  const int coding_type)                                  const int coding_type,
316                                    const int skip_sad)
317  {  {
318          int mode = MODE_INTER;          int mode = MODE_INTER;
319          int mcsel = 0;          int mcsel = 0;
# Line 520  Line 339 
339          }          }
340    
341          /* final skip decision, a.k.a. "the vector you found, really that good?" */          /* final skip decision, a.k.a. "the vector you found, really that good?" */
342          if (skip_possible && (pMB->sad16 < (int)iQuant * MAX_SAD00_FOR_SKIP))          if (skip_possible && (skip_sad < (int)iQuant * MAX_SAD00_FOR_SKIP))
343                  if ( (100*sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH)                  if ( (100*skip_sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH)
344                          if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {                          if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {
345                                  mode = MODE_NOT_CODED;                                  mode = MODE_NOT_CODED;
346                                  sad = 0;                                  sad = 0;
# Line 547  Line 366 
366    
367          /* intra decision */          /* intra decision */
368    
369          if (iQuant > 8) InterBias += 100 * (iQuant - 8); /* to make high quants work */          if (iQuant > 10) InterBias += 60 * (iQuant - 10); /* to make high quants work */
370          if (y != 0)          if (y != 0)
371                  if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;                  if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;
372          if (x != 0)          if (x != 0)
# Line 590  Line 409 
409                          pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;                          pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;
410                  }                  }
411    
412          } else if (mode == MODE_INTER ) { // but mcsel == 1          } else if (mode == MODE_INTER ) { /* but mcsel == 1 */
413    
414                  pMB->mcsel = 1;                  pMB->mcsel = 1;
415                  if (Data->qpel) {                  if (Data->qpel) {
# Line 649  Line 468 
468  }  }
469    
470  static void  static void
471  Search8(const SearchData * const OldData,  Search8(SearchData * const OldData,
472                  const int x, const int y,                  const int x, const int y,
473                  const uint32_t MotionFlags,                  const uint32_t MotionFlags,
474                  const MBParam * const pParam,                  const MBParam * const pParam,
# Line 659  Line 478 
478                  SearchData * const Data)                  SearchData * const Data)
479  {  {
480          int i = 0;          int i = 0;
481            VECTOR vbest_q; int32_t sbest_q;
482          CheckFunc * CheckCandidate;          CheckFunc * CheckCandidate;
483          Data->iMinSAD = OldData->iMinSAD + 1 + block;          *Data->iMinSAD = *(OldData->iMinSAD + 1 + block);
484          Data->currentMV = OldData->currentMV + 1 + block;          *Data->currentMV = *(OldData->currentMV + 1 + block);
485          Data->currentQMV = OldData->currentQMV + 1 + block;          *Data->currentQMV = *(OldData->currentQMV + 1 + block);
486    
487          if(Data->qpel) {          if(Data->qpel) {
488                  Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);                  Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
# Line 678  Line 498 
498    
499          if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) {          if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) {
500    
501                    vbest_q = Data->currentQMV[0];
502                    sbest_q = Data->iMinSAD[0];
503    
504                  if (Data->rrv) i = 16; else i = 8;                  if (Data->rrv) i = 16; else i = 8;
505    
506                  Data->RefP[0] = OldData->RefP[0] + i * ((block&1) + Data->iEdgedWidth*(block>>1));                  Data->RefP[0] = OldData->RefP[0] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
# Line 695  Line 518 
518                  else CheckCandidate = CheckCandidate16no4v;                  else CheckCandidate = CheckCandidate16no4v;
519    
520                  if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_RD))) {                  if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_RD))) {
                         int32_t temp_sad = *(Data->iMinSAD); /* store current MinSAD */  
521    
522                          MainSearchFunc *MainSearchPtr;                          MainSearchFunc *MainSearchPtr;
523                          if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = xvid_me_SquareSearch;                          if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = xvid_me_SquareSearch;
# Line 703  Line 525 
525                                          else MainSearchPtr = xvid_me_DiamondSearch;                                          else MainSearchPtr = xvid_me_DiamondSearch;
526    
527                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate);                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate);
528                    }
529    
530                          if(*(Data->iMinSAD) < temp_sad) {                  if(!Data->qpel) {
531                                          Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */                          /* halfpel mode */
532                            if (MotionFlags & XVID_ME_HALFPELREFINE8)
533                                    xvid_me_SubpelRefine(Data, CheckCandidate, 0); /* perform halfpel refine of current best vector */
534                    } else {
535                            /* qpel mode */
536                            Data->currentQMV->x = 2*Data->currentMV->x;
537                                          Data->currentQMV->y = 2 * Data->currentMV->y;                                          Data->currentQMV->y = 2 * Data->currentMV->y;
                         }  
                 }  
538    
539                            if(MotionFlags & XVID_ME_FASTREFINE8) {
540                                    /* fast */
541                                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3,
542                                            pParam->width, pParam->height, Data->iFcode, 2, 0);
543                                    FullRefine_Fast(Data, CheckCandidate8, 0);
544                            } else if(MotionFlags & XVID_ME_QUARTERPELREFINE8) {
545                                    /* full */
546                  if (MotionFlags & XVID_ME_HALFPELREFINE8) {                  if (MotionFlags & XVID_ME_HALFPELREFINE8) {
547                          int32_t temp_sad = *(Data->iMinSAD); /* store current MinSAD */                                          xvid_me_SubpelRefine(Data, CheckCandidate8, 0); /* hpel part */
548                                            Data->currentQMV->x = 2*Data->currentMV->x;
                         xvid_me_SubpelRefine(Data, CheckCandidate); /* perform halfpel refine of current best vector */  
   
                         if(*(Data->iMinSAD) < temp_sad) { /* we have found a better match */  
                                 Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */  
549                                  Data->currentQMV->y = 2 * Data->currentMV->y;                                  Data->currentQMV->y = 2 * Data->currentMV->y;
550                          }                          }
                 }  
551    
                 if (Data->qpel && MotionFlags & XVID_ME_QUARTERPELREFINE8) {  
                                 Data->qpel_precision = 1;  
552                                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3,                                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3,
553                                          pParam->width, pParam->height, Data->iFcode, 2, 0);                                          pParam->width, pParam->height, Data->iFcode, 2, 0);
554                                  xvid_me_SubpelRefine(Data, CheckCandidate);                                  Data->qpel_precision = 1;
555    
556                                    xvid_me_SubpelRefine(Data, CheckCandidate8, 0); /* qpel part */
557                  }                  }
558          }          }
559    
560                    if (sbest_q <= Data->iMinSAD[0]) /* we have not found a better match */
561                            Data->currentQMV[0] = vbest_q;
562    
563            }
564    
565          if (Data->rrv) {          if (Data->rrv) {
566                          Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);                          Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);
567                          Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);                          Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);
568          }          } else if(Data->qpel) {
   
         if(Data->qpel) {  
569                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x;                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x;
570                  pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y;                  pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y;
571                  pMB->qmvs[block] = *Data->currentQMV;                  pMB->qmvs[block] = *Data->currentQMV;
# Line 743  Line 574 
574                  pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;                  pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;
575          }          }
576    
577            *(OldData->iMinSAD + 1 + block) = *Data->iMinSAD;
578            *(OldData->currentMV + 1 + block) = *Data->currentMV;
579            *(OldData->currentQMV + 1 + block) = *Data->currentQMV;
580    
581          pMB->mvs[block] = *Data->currentMV;          pMB->mvs[block] = *Data->currentMV;
582          pMB->sad8[block] = 4 * *Data->iMinSAD;          pMB->sad8[block] = 4 * *Data->iMinSAD;
583  }  }
# Line 774  Line 609 
609          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
610                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
611    
612          get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp);          get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, pmv, Data->temp);
613    
614          Data->temp[5] = Data->temp[6] = 0; /* chroma-sad cache */          Data->chromaX = Data->chromaY = 0; /* chroma-sad cache */
615          i = Data->rrv ? 2 : 1;          i = Data->rrv ? 2 : 1;
616          Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;          Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;
617          Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;          Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
# Line 792  Line 627 
627          Data->lambda16 = xvid_me_lambda_vec16[pMB->quant];          Data->lambda16 = xvid_me_lambda_vec16[pMB->quant];
628          Data->lambda8 = xvid_me_lambda_vec8[pMB->quant];          Data->lambda8 = xvid_me_lambda_vec8[pMB->quant];
629          Data->qpel_precision = 0;          Data->qpel_precision = 0;
630          *Data->dir = 0;          Data->dir = 0;
631    
632          memset(Data->currentMV, 0, 5*sizeof(VECTOR));          memset(Data->currentMV, 0, 5*sizeof(VECTOR));
633    
# Line 836  Line 671 
671          else {          else {
672    
673                  MainSearchFunc * MainSearchPtr;                  MainSearchFunc * MainSearchPtr;
674                  int mask = make_mask(pmv, i, *Data->dir); // all vectors pmv[0..i-1] have been checked                  int mask = make_mask(pmv, i, Data->dir); /* all vectors pmv[0..i-1] have been checked */
675    
676                  if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = xvid_me_SquareSearch;                  if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = xvid_me_SquareSearch;
677                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = xvid_me_AdvDiamondSearch;                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = xvid_me_AdvDiamondSearch;
# Line 851  Line 686 
686                  if (MotionFlags & XVID_ME_EXTSEARCH16) {                  if (MotionFlags & XVID_ME_EXTSEARCH16) {
687                          int32_t bSAD;                          int32_t bSAD;
688                          VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0];                          VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0];
689                          if (Data->rrv) {                          if (Data->qpel) {
690                                    startMV.x /= 2;
691                                    startMV.y /= 2;
692                            } else if (Data->rrv) {
693                                  startMV.x = RRV_MV_SCALEUP(startMV.x);                                  startMV.x = RRV_MV_SCALEUP(startMV.x);
694                                  startMV.y = RRV_MV_SCALEUP(startMV.y);                                  startMV.y = RRV_MV_SCALEUP(startMV.y);
695                          }                          }
# Line 859  Line 697 
697                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
698    
699                                  CheckCandidate(startMV.x, startMV.y, Data, 255);                                  CheckCandidate(startMV.x, startMV.y, Data, 255);
700                                  MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate);                                  xvid_me_DiamondSearch(startMV.x, startMV.y, Data, 255, CheckCandidate);
701                                  if (bSAD < Data->iMinSAD[0]) {                                  if (bSAD < Data->iMinSAD[0]) {
702                                          Data->currentMV[0] = backupMV;                                          Data->currentMV[0] = backupMV;
703                                          Data->iMinSAD[0] = bSAD; }                                          Data->iMinSAD[0] = bSAD; }
# Line 871  Line 709 
709                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
710    
711                                  CheckCandidate(startMV.x, startMV.y, Data, 255);                                  CheckCandidate(startMV.x, startMV.y, Data, 255);
712                                  MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate);                                  xvid_me_DiamondSearch(startMV.x, startMV.y, Data, 255, CheckCandidate);
713                                  if (bSAD < Data->iMinSAD[0]) {                                  if (bSAD < Data->iMinSAD[0]) {
714                                          Data->currentMV[0] = backupMV;                                          Data->currentMV[0] = backupMV;
715                                          Data->iMinSAD[0] = bSAD;                                          Data->iMinSAD[0] = bSAD;
# Line 880  Line 718 
718                  }                  }
719          }          }
720    
721    
722            if(!Data->qpel) {
723                    /* halfpel mode */
724          if (MotionFlags & XVID_ME_HALFPELREFINE16)          if (MotionFlags & XVID_ME_HALFPELREFINE16)
725                          xvid_me_SubpelRefine(Data, CheckCandidate);                                  xvid_me_SubpelRefine(Data, CheckCandidate, 0);
726            } else {
727                    /* qpel mode */
728    
729          for(i = 0; i < 5; i++) {          for(i = 0; i < 5; i++) {
730                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* initialize qpel vectors */                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* initialize qpel vectors */
731                  Data->currentQMV[i].y = 2 * Data->currentMV[i].y;                  Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
732          }          }
733                    if(MotionFlags & XVID_ME_FASTREFINE16 && MotionFlags & XVID_ME_QUARTERPELREFINE16) {
734          if (Data->qpel) {                          /* fast */
735                            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
736                                                    pParam->width, pParam->height, Data->iFcode, 2, 0);
737                            FullRefine_Fast(Data, CheckCandidate, 0);
738                    } else {
739                            if(MotionFlags & (XVID_ME_QUARTERPELREFINE16 | XVID_ME_QUARTERPELREFINE16_RD)) {
740                                    /* full */
741                                    if (MotionFlags & XVID_ME_HALFPELREFINE16) {
742                                            xvid_me_SubpelRefine(Data, CheckCandidate, 0); /* hpel part */
743                                            for(i = 0; i < 5; i++) {
744                                                    Data->currentQMV[i].x = 2 * Data->currentMV[i].x;
745                                                    Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
746                                            }
747                                    }
748                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
749                                  pParam->width, pParam->height, Data->iFcode, 2, 0);                                  pParam->width, pParam->height, Data->iFcode, 2, 0);
750                  Data->qpel_precision = 1;                  Data->qpel_precision = 1;
751                  if (MotionFlags & XVID_ME_QUARTERPELREFINE16) {                                  if(MotionFlags & XVID_ME_QUARTERPELREFINE16)
752                          if(MotionFlags & XVID_ME_FASTREFINE16)                                          xvid_me_SubpelRefine(Data, CheckCandidate, 0); /* qpel part */
753                                  SubpelRefine_Fast(Data, CheckCandidate);                          }
                         else  
                                 xvid_me_SubpelRefine(Data, CheckCandidate);  
754                  }                  }
755          }          }
756    
757          if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30)          if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30* ((MotionFlags & XVID_ME_FASTREFINE16) ? 8 : 1))
758                  inter4v = 0;                  inter4v = 0;
759    
760          if (inter4v) {          if (inter4v) {
# Line 913  Line 767 
767                  Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);                  Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);
768    
769                  if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_RD))) {                  if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_RD))) {
770                          /* chroma is only used for comparsion to INTER. if the comparsion will be done in BITS domain, it will not be used */                          /* chroma is only used for comparison to INTER. if the comparison will be done in RD domain, it will not be used */
771                          int sumx = 0, sumy = 0;                          int sumx = 0, sumy = 0;
772    
773                          if (Data->qpel)                          if (Data->qpel)
# Line 958  Line 812 
812          if (Flags & XVID_ME_QUARTERPELREFINE8_RD)          if (Flags & XVID_ME_QUARTERPELREFINE8_RD)
813                  Flags &= ~XVID_ME_QUARTERPELREFINE8;                  Flags &= ~XVID_ME_QUARTERPELREFINE8;
814    
815            if (Flags & XVID_ME_QUARTERPELREFINE16_RD)
816                    Flags &= ~XVID_ME_QUARTERPELREFINE16;
817    
818          if (!(VolFlags & XVID_VOL_QUARTERPEL))          if (!(VolFlags & XVID_VOL_QUARTERPEL))
819                  Flags &= ~(XVID_ME_QUARTERPELREFINE16+XVID_ME_QUARTERPELREFINE8+XVID_ME_QUARTERPELREFINE16_RD+XVID_ME_QUARTERPELREFINE8_RD);                  Flags &= ~(XVID_ME_QUARTERPELREFINE16+XVID_ME_QUARTERPELREFINE8+XVID_ME_QUARTERPELREFINE16_RD+XVID_ME_QUARTERPELREFINE8_RD);
820    
# Line 967  Line 824 
824          if ((VopFlags & XVID_VOP_GREYSCALE) || (VopFlags & XVID_VOP_REDUCED))          if ((VopFlags & XVID_VOP_GREYSCALE) || (VopFlags & XVID_VOP_REDUCED))
825                  Flags &= ~(XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP);                  Flags &= ~(XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP);
826    
827            if (Flags & XVID_ME_FASTREFINE8)
828                    Flags &= ~XVID_ME_HALFPELREFINE8_RD;
829    
830            if (Flags & XVID_ME_FASTREFINE16)
831                    Flags &= ~XVID_ME_HALFPELREFINE16_RD;
832    
833          return Flags;          return Flags;
834  }  }
835    
# Line 998  Line 861 
861                  (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);                  (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);
862    
863          /* some pre-initialized thingies for SearchP */          /* some pre-initialized thingies for SearchP */
         int32_t temp[8]; uint32_t dir;  
         VECTOR currentMV[5];  
         VECTOR currentQMV[5];  
         VECTOR currentMV2[5];  
         VECTOR currentQMV2[5];  
         int32_t iMinSAD[5];  
         int32_t iMinSAD2[5];  
864          DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);
865          SearchData Data;          SearchData Data;
866          memset(&Data, 0, sizeof(SearchData));          memset(&Data, 0, sizeof(SearchData));
867          Data.iEdgedWidth = iEdgedWidth;          Data.iEdgedWidth = iEdgedWidth;
         Data.currentMV = currentMV;  
         Data.currentQMV = currentQMV;  
         Data.currentMV2 = currentMV2;  
         Data.currentQMV2 = currentQMV2;  
         Data.iMinSAD = iMinSAD;  
         Data.iMinSAD2 = iMinSAD2;  
         Data.temp = temp;  
         Data.dir = &dir;  
868          Data.iFcode = current->fcode;          Data.iFcode = current->fcode;
869          Data.rounding = pParam->m_rounding_type;          Data.rounding = pParam->m_rounding_type;
870          Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0);          Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0);
# Line 1024  Line 872 
872          Data.rrv = (current->vop_flags & XVID_VOP_REDUCED) ? 1:0;          Data.rrv = (current->vop_flags & XVID_VOP_REDUCED) ? 1:0;
873          Data.dctSpace = dct_space;          Data.dctSpace = dct_space;
874          Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT);          Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT);
875            Data.mpeg_quant_matrices = pParam->mpeg_quant_matrices;
876    
877          if ((current->vop_flags & XVID_VOP_REDUCED)) {          if ((current->vop_flags & XVID_VOP_REDUCED)) {
878                  mb_width = (pParam->width + 31) / 32;                  mb_width = (pParam->width + 31) / 32;
# Line 1049  Line 898 
898                                                          pRef->y + (x + y * iEdgedWidth) * 32,                                                          pRef->y + (x + y * iEdgedWidth) * 32,
899                                                          pParam->edged_width, pMB->sad8 );                                                          pParam->edged_width, pMB->sad8 );
900    
901                            sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3]));
902    
903                          if (Data.chroma) {                          if (Data.chroma) {
904                                  Data.temp[7] = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8,                                  Data.chromaSAD = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8,
905                                                                          pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2)                                                                          pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2)
906                                                                  + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8,                                                                  + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8,
907                                                                          pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2);                                                                          pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2);
908                                  pMB->sad16 += Data.temp[7];                                  pMB->sad16 += Data.chromaSAD;
909                                    sad00 += Data.chromaSAD;
910                          }                          }
911    
                         sad00 = pMB->sad16;  
   
912                          /* initial skip decision */                          /* initial skip decision */
913                          /* no early skip for GMC (global vector = skip vector is unknown!)  */                          /* no early skip for GMC (global vector = skip vector is unknown!)  */
914                          if (current->coding_type != S_VOP)      { /* no fast SKIP for S(GMC)-VOPs */                          if (current->coding_type != S_VOP)      { /* no fast SKIP for S(GMC)-VOPs */
# Line 1080  Line 930 
930                                                                            MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16,                                                                            MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
931                                                                            MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,                                                                            MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,
932                                                                            prevMB->sad16)));                                                                            prevMB->sad16)));
                                         }  
933                                  } else {                                  } else {
934                                          stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16,                                          stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16,
935                                                                            MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16,                                                                            MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
# Line 1088  Line 937 
937                                                                            prevMB->sad16)));                                                                            prevMB->sad16)));
938                                  }                                  }
939                          }                          }
940                            }
941    
942                           /* favorize (0,0) vector for cartoons */                           /* favorize (0,0) vector for cartoons */
943                          if ((current->vop_flags & XVID_VOP_CARTOON) &&                          if ((current->vop_flags & XVID_VOP_CARTOON) &&
# Line 1112  Line 962 
962                          else                          else
963                                  ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam,                                  ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam,
964                                                                  MotionFlags, current->vop_flags, current->vol_flags,                                                                  MotionFlags, current->vop_flags, current->vol_flags,
965                                                                  pCurrent, pRef, pGMC, current->coding_type);                                                                  pCurrent, pRef, pGMC, current->coding_type, sad00);
966    
967    
968                          if (pMB->mode == MODE_INTRA)                          if (pMB->mode == MODE_INTRA)
Legend:
Removed from v.1.1.2.1  
changed lines
  Added in v.1.7
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4