[svn] / branches / dev-api-4 / xvidcore / src / motion / motion_est.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/src/motion/motion_est.c

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

revision 1129, Mon Aug 25 15:10:30 2003 UTC revision 1137, Fri Sep 5 10:01:50 2003 UTC
# Line 21  Line 21 
21   *  along with this program ; if not, write to the Free Software   *  along with this program ; if not, write to the Free Software
22   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
23   *   *
24   * $Id: motion_est.c,v 1.58.2.28 2003-08-25 15:10:13 syskin Exp $   * $Id: motion_est.c,v 1.58.2.34 2003-09-05 10:01:50 Isibaar Exp $
25   *   *
26   ****************************************************************************/   ****************************************************************************/
27    
# Line 70  Line 70 
70  #define MAX_CHROMA_SAD_FOR_SKIP (22)  #define MAX_CHROMA_SAD_FOR_SKIP (22)
71    
72  #define CHECK_CANDIDATE(X,Y,D) { \  #define CHECK_CANDIDATE(X,Y,D) { \
73  CheckCandidate((X),(Y), (D), &iDirection, data ); }  CheckCandidate((X),(Y), data, (D) ); }
74    
75    
76  /*****************************************************************************  /*****************************************************************************
# Line 156  Line 156 
156          int sad;          int sad;
157          const uint32_t stride = data->iEdgedWidth/2;          const uint32_t stride = data->iEdgedWidth/2;
158          int offset = (dx>>1) + (dy>>1)*stride;          int offset = (dx>>1) + (dy>>1)*stride;
159            int next = 1;
160    
161          if (dx == data->temp[5] && dy == data->temp[6]) return data->temp[7]; /* it has been checked recently */          if (dx == data->temp[5] && dy == data->temp[6]) return data->temp[7]; /* it has been checked recently */
162          data->temp[5] = dx; data->temp[6] = dy; /* backup */          data->temp[5] = dx; data->temp[6] = dy; /* backup */
# Line 166  Line 167 
167                          sad += sad8(data->CurV, data->RefP[5] + offset, stride);                          sad += sad8(data->CurV, data->RefP[5] + offset, stride);
168                          break;                          break;
169                  case 1:                  case 1:
170                          sad = sad8bi(data->CurU, data->RefP[4] + offset, data->RefP[4] + offset + stride, stride);                          next = stride;
                         sad += sad8bi(data->CurV, data->RefP[5] + offset, data->RefP[5] + offset + stride, stride);  
                         break;  
171                  case 2:                  case 2:
172                          sad = sad8bi(data->CurU, data->RefP[4] + offset, data->RefP[4] + offset + 1, stride);                          sad = sad8bi(data->CurU, data->RefP[4] + offset, data->RefP[4] + offset + next, stride);
173                          sad += sad8bi(data->CurV, data->RefP[5] + offset, data->RefP[5] + offset + 1, stride);                          sad += sad8bi(data->CurV, data->RefP[5] + offset, data->RefP[5] + offset + next, stride);
174                          break;                          break;
175                  default:                  default:
176                          interpolate8x8_halfpel_hv(data->RefQ, data->RefP[4] + offset, stride, data->rounding);                          interpolate8x8_halfpel_hv(data->RefQ, data->RefP[4] + offset, stride, data->rounding);
# Line 301  Line 300 
300  /* CHECK_CANDIATE FUNCTIONS START */  /* CHECK_CANDIATE FUNCTIONS START */
301    
302  static void  static void
303  CheckCandidate16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate16(const int x, const int y, const SearchData * const data, const int Direction)
304  {  {
305          int xc, yc;          int xc, yc;
306          const uint8_t * Reference;          const uint8_t * Reference;
# Line 321  Line 320 
320                  current = data->currentQMV;                  current = data->currentQMV;
321          }          }
322    
323          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);
324            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
325    
326            sad += (data->lambda16 * t * sad)>>10;
327            data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
328    
329            if (data->chroma && sad < data->iMinSAD[0])
330                    sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
331                                                            (yc >> 1) + roundtab_79[yc & 0x3], data);
332    
333            if (sad < data->iMinSAD[0]) {
334                    data->iMinSAD[0] = sad;
335                    current[0].x = x; current[0].y = y;
336                    *data->dir = Direction;
337            }
338    
339            if (data->temp[0] < data->iMinSAD[1]) {
340                    data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; }
341            if (data->temp[1] < data->iMinSAD[2]) {
342                    data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }
343            if (data->temp[2] < data->iMinSAD[3]) {
344                    data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
345            if (data->temp[3] < data->iMinSAD[4]) {
346                    data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
347    }
348    
349    static void
350    CheckCandidate16_subpel(const int x, const int y, const SearchData * const data, const int Direction)
351    {
352            int xc, yc;
353            const uint8_t *Reference;
354            VECTOR *current, *current2;
355            int32_t sad; uint32_t t;
356    
357            if ( (x > data->max_dx) || (x < data->min_dx)
358                    || (y > data->max_dy) || (y < data->min_dy) ) return;
359    
360            if (!data->qpel_precision) {
361                    Reference = GetReference(x, y, data);
362                    current = data->currentMV;
363                    current2 = data->currentMV2;
364                    xc = x; yc = y;
365            } else { /* x and y are in 1/4 precision */
366                    Reference = Interpolate16x16qpel(x, y, 0, data);
367                    xc = x/2; yc = y/2; /* for chroma sad */
368                    current = data->currentQMV;
369                    current2 = data->currentQMV2;
370            }
371    
372            sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);
373          t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);          t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
374    
375          sad += (data->lambda16 * t * sad)>>10;          sad += (data->lambda16 * t * sad)>>10;
376          data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;          data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
377    
378          if (data->chroma && sad < data->iMinSAD[0])          if (data->chroma && sad < data->iMinSAD[0])
379                  sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],                  sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
380                                                          (yc >> 1) + roundtab_79[yc & 0x3], data);                                                          (yc >> 1) + roundtab_79[yc & 0x3], data);
381    
382            if (data->temp[0] < data->iMinSAD[1]) {
383                    data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; }
384            if (data->temp[1] < data->iMinSAD[2]) {
385                    data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }
386            if (data->temp[2] < data->iMinSAD[3]) {
387                    data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
388            if (data->temp[3] < data->iMinSAD[4]) {
389                    data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
390    
391          if (sad < data->iMinSAD[0]) {          if (sad < data->iMinSAD[0]) {
392                    *(data->iMinSAD2) = *(data->iMinSAD);
393                    current2->x = current->x; current2->y = current->y;
394    
395                  data->iMinSAD[0] = sad;                  data->iMinSAD[0] = sad;
396                  current[0].x = x; current[0].y = y;                  current[0].x = x; current[0].y = y;
397                  *dir = Direction;                  *data->dir = Direction;
398                    return;
399          }          }
400    
401          if (data->temp[1] < data->iMinSAD[1]) {          if (sad < *(data->iMinSAD2)) {
402                  data->iMinSAD[1] = data->temp[1]; current[1].x = x; current[1].y = y; }                  *(data->iMinSAD2) = sad;
403          if (data->temp[2] < data->iMinSAD[2]) {                  current2->x = x; current2->y = y;
404                  data->iMinSAD[2] = data->temp[2]; current[2].x = x; current[2].y = y; }                  *data->dir = Direction;
405          if (data->temp[3] < data->iMinSAD[3]) {          }
                 data->iMinSAD[3] = data->temp[3]; current[3].x = x; current[3].y = y; }  
         if (data->temp[4] < data->iMinSAD[4]) {  
                 data->iMinSAD[4] = data->temp[4]; current[4].x = x; current[4].y = y; }  
406  }  }
407    
408  static void  static void
409  CheckCandidate8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate8(const int x, const int y, const SearchData * const data, const int Direction)
410  {  {
411          int32_t sad; uint32_t t;          int32_t sad; uint32_t t;
412          const uint8_t * Reference;          const uint8_t * Reference;
# Line 373  Line 431 
431          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
432                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
433                  current->x = x; current->y = y;                  current->x = x; current->y = y;
434                  *dir = Direction;                  *data->dir = Direction;
435          }          }
436  }  }
437    
438  static void  static void
439  CheckCandidate32(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate32(const int x, const int y, const SearchData * const data, const int Direction)
440  {  {
441          uint32_t t;          uint32_t t;
442          const uint8_t * Reference;          const uint8_t * Reference;
443            int sad;
444    
445          if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || /* non-zero even value */          if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || /* non-zero even value */
446                  (x > data->max_dx) || (x < data->min_dx)                  (x > data->max_dx) || (x < data->min_dx)
# Line 390  Line 449 
449          Reference = GetReference(x, y, data);          Reference = GetReference(x, y, data);
450          t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);          t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);
451    
452          data->temp[0] = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);          sad = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp);
453    
454          data->temp[0] += (data->lambda16 * t * data->temp[0]) >> 10;          sad += (data->lambda16 * t * sad) >> 10;
455          data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;          data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
456    
457          if (data->temp[0] < data->iMinSAD[0]) {          if (sad < data->iMinSAD[0]) {
458                  data->iMinSAD[0] = data->temp[0];                  data->iMinSAD[0] = sad;
459                  data->currentMV[0].x = x; data->currentMV[0].y = y;                  data->currentMV[0].x = x; data->currentMV[0].y = y;
460                  *dir = Direction; }                  *data->dir = Direction;
461            }
462    
463          if (data->temp[1] < data->iMinSAD[1]) {          if (data->temp[0] < data->iMinSAD[1]) {
464                  data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }                  data->iMinSAD[1] = data->temp[0]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
465          if (data->temp[2] < data->iMinSAD[2]) {          if (data->temp[1] < data->iMinSAD[2]) {
466                  data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }                  data->iMinSAD[2] = data->temp[1]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
467          if (data->temp[3] < data->iMinSAD[3]) {          if (data->temp[2] < data->iMinSAD[3]) {
468                  data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }                  data->iMinSAD[3] = data->temp[2]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
469          if (data->temp[4] < data->iMinSAD[4]) {          if (data->temp[3] < data->iMinSAD[4]) {
470                  data->iMinSAD[4] = data->temp[4]; 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; }
471  }  }
472    
473  static void  static void
474  CheckCandidate16no4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate16no4v(const int x, const int y, const SearchData * const data, const int Direction)
475  {  {
476          int32_t sad, xc, yc;          int32_t sad, xc, yc;
477          const uint8_t * Reference;          const uint8_t * Reference;
# Line 445  Line 505 
505          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
506                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
507                  current->x = x; current->y = y;                  current->x = x; current->y = y;
508                  *dir = Direction;                  *data->dir = Direction;
509          }          }
510  }  }
511    
512  static void  static void
513  CheckCandidate16I(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate16I(const int x, const int y, const SearchData * const data, const int Direction)
514  {  {
515          int sad;          int sad;
516  //      int xc, yc;  //      int xc, yc;
# Line 473  Line 533 
533          if (sad < data->iMinSAD[0]) {          if (sad < data->iMinSAD[0]) {
534                  data->iMinSAD[0] = sad;                  data->iMinSAD[0] = sad;
535                  data->currentMV[0].x = x; data->currentMV[0].y = y;                  data->currentMV[0].x = x; data->currentMV[0].y = y;
536                  *dir = Direction;                  *data->dir = Direction;
537          }          }
538  }  }
539    
540  static void  static void
541  CheckCandidate32I(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate32I(const int x, const int y, const SearchData * const data, const int Direction)
542  {  {
543          /* maximum speed - for P/B/I decision */          /* maximum speed - for P/B/I decision */
544          int32_t sad;          int32_t sad;
# Line 486  Line 546 
546          if ( (x > data->max_dx) || (x < data->min_dx)          if ( (x > data->max_dx) || (x < data->min_dx)
547                  || (y > data->max_dy) || (y < data->min_dy) ) return;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
548    
549          sad = sad32v_c(data->Cur, data->RefP[0] + (x>>1) + (y>>1)*((int)data->iEdgedWidth),          sad = sad32v_c(data->Cur, data->RefP[0] + x + y*((int)data->iEdgedWidth),
550                                          data->iEdgedWidth, data->temp+1);                                          data->iEdgedWidth, data->temp);
551    
552          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
553                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
554                  data->currentMV[0].x = x; data->currentMV[0].y = y;                  data->currentMV[0].x = x; data->currentMV[0].y = y;
555                  *dir = Direction;                  *data->dir = Direction;
556          }          }
557          if (data->temp[1] < data->iMinSAD[1]) {          if (data->temp[0] < data->iMinSAD[1]) {
558                  data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }                  data->iMinSAD[1] = data->temp[0]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
559          if (data->temp[2] < data->iMinSAD[2]) {          if (data->temp[1] < data->iMinSAD[2]) {
560                  data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }                  data->iMinSAD[2] = data->temp[1]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
561          if (data->temp[3] < data->iMinSAD[3]) {          if (data->temp[2] < data->iMinSAD[3]) {
562                  data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }                  data->iMinSAD[3] = data->temp[2]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
563          if (data->temp[4] < data->iMinSAD[4]) {          if (data->temp[3] < data->iMinSAD[4]) {
564                  data->iMinSAD[4] = data->temp[4]; 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; }
565    
566  }  }
567    
568  static void  static void
569  CheckCandidateInt(const int xf, const int yf, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateInt(const int xf, const int yf, const SearchData * const data, const int Direction)
570  {  {
571          int32_t sad, xb, yb, xcf, ycf, xcb, ycb;          int32_t sad, xb, yb, xcf, ycf, xcb, ycb;
572          uint32_t t;          uint32_t t;
# Line 548  Line 608 
608          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
609                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
610                  current->x = xf; current->y = yf;                  current->x = xf; current->y = yf;
611                  *dir = Direction;                  *data->dir = Direction;
612          }          }
613  }  }
614    
615  static void  static void
616  CheckCandidateDirect(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateDirect(const int x, const int y, const SearchData * const data, const int Direction)
617  {  {
618          int32_t sad = 0, xcf = 0, ycf = 0, xcb = 0, ycb = 0;          int32_t sad = 0, xcf = 0, ycf = 0, xcb = 0, ycb = 0;
619          uint32_t k;          uint32_t k;
# Line 609  Line 669 
669          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
670                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
671                  data->currentMV->x = x; data->currentMV->y = y;                  data->currentMV->x = x; data->currentMV->y = y;
672                  *dir = Direction;                  *data->dir = Direction;
673          }          }
674  }  }
675    
676  static void  static void
677  CheckCandidateDirectno4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateDirectno4v(const int x, const int y, const SearchData * const data, const int Direction)
678  {  {
679          int32_t sad, xcf, ycf, xcb, ycb;          int32_t sad, xcf, ycf, xcb, ycb;
680          const uint8_t *ReferenceF;          const uint8_t *ReferenceF;
# Line 662  Line 722 
722          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
723                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
724                  data->currentMV->x = x; data->currentMV->y = y;                  data->currentMV->x = x; data->currentMV->y = y;
725                  *dir = Direction;                  *data->dir = Direction;
726          }          }
727  }  }
728    
729    
730  static void  static void
731  CheckCandidateRD16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateRD16(const int x, const int y, const SearchData * const data, const int Direction)
732  {  {
733    
734          int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;          int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;
# Line 731  Line 791 
791          if (rd < data->iMinSAD[0]) {          if (rd < data->iMinSAD[0]) {
792                  data->iMinSAD[0] = rd;                  data->iMinSAD[0] = rd;
793                  current[0].x = x; current[0].y = y;                  current[0].x = x; current[0].y = y;
794                  *dir = Direction;                  *data->dir = Direction;
795                  *data->cbp = cbp;                  *data->cbp = cbp;
796          }          }
797  }  }
798    
799  static void  static void
800  CheckCandidateRD8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateRD8(const int x, const int y, const SearchData * const data, const int Direction)
801  {  {
802    
803          int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;          int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;
# Line 765  Line 825 
825                  *data->cbp = cbp;                  *data->cbp = cbp;
826                  data->iMinSAD[0] = rd;                  data->iMinSAD[0] = rd;
827                  current[0].x = x; current[0].y = y;                  current[0].x = x; current[0].y = y;
828                  *dir = Direction;                  *data->dir = Direction;
829          }          }
830  }  }
831    
# Line 774  Line 834 
834  /* MAINSEARCH FUNCTIONS START */  /* MAINSEARCH FUNCTIONS START */
835    
836  static void  static void
837  AdvDiamondSearch(int x, int y, const SearchData * const data, int bDirection)  AdvDiamondSearch(int x, int y, const SearchData * const data, int bDirection, CheckFunc * const CheckCandidate)
838  {  {
839    
840  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
841    
842          int iDirection;          unsigned int * const iDirection = data->dir;
843    
844          for(;;) { /* forever */          for(;;) { /* forever */
845                  iDirection = 0;                  *iDirection = 0;
846                  if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);                  if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
847                  if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);                  if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);
848                  if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);                  if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);
# Line 790  Line 850 
850    
851                  /* now we're doing diagonal checks near our candidate */                  /* now we're doing diagonal checks near our candidate */
852    
853                  if (iDirection) {               /* if anything found */                  if (*iDirection) {              /* if anything found */
854                          bDirection = iDirection;                          bDirection = *iDirection;
855                          iDirection = 0;                          *iDirection = 0;
856                          x = data->currentMV->x; y = data->currentMV->y;                          x = data->currentMV->x; y = data->currentMV->y;
857                          if (bDirection & 3) {   /* our candidate is left or right */                          if (bDirection & 3) {   /* our candidate is left or right */
858                                  CHECK_CANDIDATE(x, y + iDiamondSize, 8);                                  CHECK_CANDIDATE(x, y + iDiamondSize, 8);
# Line 802  Line 862 
862                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);
863                          }                          }
864    
865                          if (iDirection) {                          if (*iDirection) {
866                                  bDirection += iDirection;                                  bDirection += *iDirection;
867                                  x = data->currentMV->x; y = data->currentMV->y;                                  x = data->currentMV->x; y = data->currentMV->y;
868                          }                          }
869                  } else {                                /* about to quit, eh? not so fast.... */                  } else {                                /* about to quit, eh? not so fast.... */
# Line 851  Line 911 
911                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
912                                  break;                                  break;
913                          }                          }
914                          if (!iDirection) break;         /* ok, the end. really */                          if (!*iDirection) break;                /* ok, the end. really */
915                          bDirection = iDirection;                          bDirection = *iDirection;
916                          x = data->currentMV->x; y = data->currentMV->y;                          x = data->currentMV->x; y = data->currentMV->y;
917                  }                  }
918          }          }
919  }  }
920    
921  static void  static void
922  SquareSearch(int x, int y, const SearchData * const data, int bDirection)  SquareSearch(int x, int y, const SearchData * const data, int bDirection, CheckFunc * const CheckCandidate)
923  {  {
924          int iDirection;          unsigned int * const iDirection = data->dir;
925    
926          do {          do {
927                  iDirection = 0;                  *iDirection = 0;
928                  if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1+16+64);                  if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1+16+64);
929                  if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2+32+128);                  if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2+32+128);
930                  if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4+16+32);                  if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4+16+32);
# Line 874  Line 934 
934                  if (bDirection & 64) CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1+8+16+64+128);                  if (bDirection & 64) CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1+8+16+64+128);
935                  if (bDirection & 128) CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2+8+32+64+128);                  if (bDirection & 128) CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2+8+32+64+128);
936    
937                  bDirection = iDirection;                  bDirection = *iDirection;
938                  x = data->currentMV->x; y = data->currentMV->y;                  x = data->currentMV->x; y = data->currentMV->y;
939          } while (iDirection);          } while (*iDirection);
940  }  }
941    
942  static void  static void
943  DiamondSearch(int x, int y, const SearchData * const data, int bDirection)  DiamondSearch(int x, int y, const SearchData * const data, int bDirection, CheckFunc * const CheckCandidate)
944  {  {
945    
946  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
947    
948          int iDirection;          unsigned int * const iDirection = data->dir;
949    
950          do {          do {
951                  iDirection = 0;                  *iDirection = 0;
952                  if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);                  if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
953                  if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);                  if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);
954                  if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);                  if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);
# Line 896  Line 956 
956    
957                  /* now we're doing diagonal checks near our candidate */                  /* now we're doing diagonal checks near our candidate */
958    
959                  if (iDirection) {               /* checking if anything found */                  if (*iDirection) {              /* checking if anything found */
960                          bDirection = iDirection;                          bDirection = *iDirection;
961                          iDirection = 0;                          *iDirection = 0;
962                          x = data->currentMV->x; y = data->currentMV->y;                          x = data->currentMV->x; y = data->currentMV->y;
963                          if (bDirection & 3) {   /* our candidate is left or right */                          if (bDirection & 3) {   /* our candidate is left or right */
964                                  CHECK_CANDIDATE(x, y + iDiamondSize, 8);                                  CHECK_CANDIDATE(x, y + iDiamondSize, 8);
# Line 907  Line 967 
967                                  CHECK_CANDIDATE(x + iDiamondSize, y, 2);                                  CHECK_CANDIDATE(x + iDiamondSize, y, 2);
968                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);
969                          }                          }
970                          bDirection += iDirection;                          bDirection += *iDirection;
971                          x = data->currentMV->x; y = data->currentMV->y;                          x = data->currentMV->x; y = data->currentMV->y;
972                  }                  }
973          }          }
974          while (iDirection);          while (*iDirection);
975  }  }
976    
977  /* MAINSEARCH FUNCTIONS END */  /* MAINSEARCH FUNCTIONS END */
978    
979  static void  static void
980  SubpelRefine(const SearchData * const data)  SubpelRefine_Fast(SearchData * data, CheckFunc * CheckCandidate)
981    {
982    /* Do a half-pel or q-pel refinement */
983            VECTOR centerMV;
984            VECTOR second_best;
985            int best_sad = *data->iMinSAD;
986            int xo, yo, xo2, yo2;
987            int size = 2;
988            CheckFunc *backupFunc = CheckCandidate;
989    
990            if(data->qpel_precision)
991                    size = 1;
992    
993            centerMV = *data->currentMV;
994            *data->iMinSAD = 256 * 4096;
995    
996            CHECK_CANDIDATE(centerMV.x, centerMV.y - size, 0);
997            CHECK_CANDIDATE(centerMV.x + size, centerMV.y - size, 0);
998            CHECK_CANDIDATE(centerMV.x + size, centerMV.y, 0);
999            CHECK_CANDIDATE(centerMV.x + size, centerMV.y + size, 0);
1000    
1001            CHECK_CANDIDATE(centerMV.x, centerMV.y + size, 0);
1002            CHECK_CANDIDATE(centerMV.x - size, centerMV.y + size, 0);
1003            CHECK_CANDIDATE(centerMV.x - size, centerMV.y, 0);
1004            CHECK_CANDIDATE(centerMV.x - size, centerMV.y - size, 0);
1005    
1006            second_best = *data->currentMV;
1007    
1008            if(data->qpel_precision) {
1009                    second_best.x *= 2;     second_best.y *= 2;
1010            }
1011    
1012            data->currentMV[0] = centerMV;
1013            *data->iMinSAD = best_sad;
1014    
1015        centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;
1016    
1017            xo = centerMV.x;
1018            yo = centerMV.y;
1019            xo2 = second_best.x;
1020            yo2 = second_best.y;
1021    
1022            CheckCandidate = CheckCandidate16_subpel;
1023            *data->iMinSAD2 = 256 * 4096;
1024    
1025            if (yo == yo2)
1026            {
1027                    CHECK_CANDIDATE((xo+xo2)>>1, yo, 0);
1028                    CHECK_CANDIDATE(xo, yo-1, 0);
1029                    CHECK_CANDIDATE(xo, yo+1, 0);
1030    
1031                    if(best_sad <= *data->iMinSAD2)
1032                            goto ende;
1033    
1034                    if(data->currentQMV[0].x == data->currentQMV2[0].x) {
1035                            CHECK_CANDIDATE((xo+xo2)>>1, yo-1, 0);
1036                            CHECK_CANDIDATE((xo+xo2)>>1, yo+1, 0);
1037                            goto ende;
1038                    }
1039                    else {
1040                            CHECK_CANDIDATE((xo+xo2)>>1,
1041                                    (data->currentQMV[0].x == xo) ? data->currentQMV[0].y : data->currentQMV2[0].y,
1042                                    0);
1043                            goto ende;
1044                    }
1045            }
1046    
1047            if (xo == xo2)
1048            {
1049                    CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0);
1050                    CHECK_CANDIDATE(xo-1, yo, 0);
1051                    CHECK_CANDIDATE(xo+1, yo, 0);
1052    
1053                    if(best_sad < *data->iMinSAD2)
1054                            goto ende;
1055    
1056                    if(data->currentQMV[0].y == data->currentQMV2[0].y) {
1057                            CHECK_CANDIDATE(xo-1, (yo+yo2)>>1, 0);
1058                            CHECK_CANDIDATE(xo+1, (yo+yo2)>>1, 0);
1059                            goto ende;
1060                    }
1061                    else {
1062                            CHECK_CANDIDATE((data->currentQMV[0].y == yo) ? data->currentQMV[0].x : data->currentQMV2[0].x, (yo+yo2)>>1, 0);
1063                            goto ende;
1064                    }
1065            }
1066    
1067            CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0);
1068            CHECK_CANDIDATE((xo+xo2)>>1, yo, 0);
1069    
1070            if(best_sad <= *data->iMinSAD2)
1071                    goto ende;
1072    
1073            CHECK_CANDIDATE((xo+xo2)>>1, (yo+yo2)>>1, 0);
1074    
1075    ende:
1076            CheckCandidate = backupFunc;
1077    }
1078    
1079    static void
1080    SubpelRefine(const SearchData * const data, CheckFunc * const CheckCandidate)
1081  {  {
1082  /* Do a half-pel or q-pel refinement */  /* Do a half-pel or q-pel refinement */
1083          const VECTOR centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;          const VECTOR centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;
         int iDirection; /* only needed because macro expects it */  
1084    
1085          CHECK_CANDIDATE(centerMV.x, centerMV.y - 1, 0);          CHECK_CANDIDATE(centerMV.x, centerMV.y - 1, 0);
1086          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y - 1, 0);          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y - 1, 0);
# Line 970  Line 1129 
1129  }  }
1130    
1131  static __inline void  static __inline void
1132    ModeDecision_Fast(SearchData * const Data,
1133                            MACROBLOCK * const pMB,
1134                            const MACROBLOCK * const pMBs,
1135                            const int x, const int y,
1136                            const MBParam * const pParam,
1137                            const uint32_t MotionFlags,
1138                            const uint32_t VopFlags,
1139                            const uint32_t VolFlags,
1140                            const IMAGE * const pCurrent,
1141                            const IMAGE * const pRef,
1142                            const IMAGE * const vGMC,
1143                            const int coding_type)
1144    {
1145            int mode = MODE_INTER;
1146            int mcsel = 0;
1147            int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0);
1148            const uint32_t iQuant = pMB->quant;
1149            const int skip_possible = (coding_type == P_VOP) && (pMB->dquant == 0);
1150        int sad;
1151            int min_rd = -1, intra_rd, i, cbp, c[2] = {0, 0};
1152            VECTOR backup[5], *v;
1153            int sad_backup[5];
1154            int InterBias = MV16_INTER_BIAS;
1155            int thresh = 0;
1156            int count = 0;
1157            int top = 0, top_right = 0, left = 0;
1158    
1159            pMB->mcsel = 0;
1160    
1161            /* INTER <-> INTER4V decision */
1162            if ((Data->iMinSAD[0] + 50 < Data->iMinSAD[1] +
1163                    Data->iMinSAD[2] + Data->iMinSAD[3] + Data->iMinSAD[4])) { /* normal, fast, SAD-based mode decision */
1164                    if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +
1165                            Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) {
1166                            mode = MODE_INTER;
1167                            sad = Data->iMinSAD[0];
1168                    } else {
1169                            mode = MODE_INTER4V;
1170                            sad = Data->iMinSAD[1] + Data->iMinSAD[2] +
1171                                                    Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant;
1172                            Data->iMinSAD[0] = sad;
1173                    }
1174    
1175                    /* final skip decision, a.k.a. "the vector you found, really that good?" */
1176                    if (skip_possible && (pMB->sad16 < (int)iQuant * MAX_SAD00_FOR_SKIP))
1177                            if ( (100*sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH)
1178                                    if (Data->chroma || SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {
1179                                            mode = MODE_NOT_CODED;
1180                                            goto early_out;
1181                                    }
1182    
1183                    /* mcsel */
1184                    if (coding_type == S_VOP) {
1185    
1186                            int32_t iSAD = sad16(Data->Cur,
1187                                    vGMC->y + 16*y*Data->iEdgedWidth + 16*x, Data->iEdgedWidth, 65536);
1188    
1189                            if (Data->chroma) {
1190                                    iSAD += sad8(Data->CurU, vGMC->u + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1191                                    iSAD += sad8(Data->CurV, vGMC->v + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1192                            }
1193    
1194                            if (iSAD <= sad) {              /* mode decision GMC */
1195                                    mode = MODE_INTER;
1196                                    mcsel = 1;
1197                                    sad = iSAD;
1198                            }
1199    
1200                    }
1201            } else { /* Rate-Distortion INTER<->INTER4V */
1202                    Data->iQuant = iQuant;
1203                    Data->cbp = c;
1204                    v = Data->qpel ? Data->currentQMV : Data->currentMV;
1205    
1206                    /* final skip decision, a.k.a. "the vector you found, really that good?" */
1207                    if (skip_possible && (pMB->sad16 < (int)iQuant * MAX_SAD00_FOR_SKIP))
1208                            if ( (100*Data->iMinSAD[0])/(pMB->sad16+1) > FINAL_SKIP_THRESH)
1209                                    if (Data->chroma || SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {
1210                                            mode = MODE_NOT_CODED;
1211                                            goto early_out;
1212                                    }
1213    
1214                    for (i = 0; i < 5; i++) {
1215                            sad_backup[i] = Data->iMinSAD[i];
1216                            Data->iMinSAD[i] = 256*4096;
1217                            backup[i] = v[i];
1218                    }
1219    
1220                    min_rd = findRDinter(Data, pMBs, x, y, pParam, MotionFlags);
1221                    cbp = *Data->cbp;
1222                    sad = sad_backup[0];
1223    
1224                    if (coding_type == S_VOP) {
1225                            int gmc_rd;
1226                            int32_t iSAD = sad16(Data->Cur,
1227                                    vGMC->y + 16*y*Data->iEdgedWidth + 16*x, Data->iEdgedWidth, 65536);
1228    
1229                            if (Data->chroma) {
1230                                    iSAD += sad8(Data->CurU, vGMC->u + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1231                                    iSAD += sad8(Data->CurV, vGMC->v + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1232                            }
1233    
1234                            *Data->iMinSAD = min_rd += BITS_MULT*1; /* mcsel */
1235                            gmc_rd = findRDgmc(Data, vGMC, x, y);
1236                            if (gmc_rd < min_rd) {
1237                                    mcsel = 1;
1238                                    *Data->iMinSAD = min_rd = gmc_rd;
1239                                    mode = MODE_INTER;
1240                                    cbp = *Data->cbp;
1241                                    sad = iSAD;
1242                            }
1243                    }
1244    
1245                    if (inter4v) {
1246                            int v4_rd;
1247                            v4_rd = findRDinter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1248                            if (v4_rd < min_rd) {
1249                                    Data->iMinSAD[0] = min_rd = v4_rd;
1250                                    mode = MODE_INTER4V;
1251                                    cbp = *Data->cbp;
1252                                    sad = sad_backup[1] + sad_backup[2] +
1253                                              sad_backup[3] + sad_backup[4] + IMV16X16 * (int32_t)iQuant;
1254                            }
1255                    }
1256            }
1257    
1258            left = top = top_right = -1;
1259            thresh = 0;
1260    
1261            if(x > 0 && y > 0 && x < pParam->mb_width) {
1262                    left = (&pMBs[(x-1) + y * pParam->mb_width])->sad16; // left
1263                    top = (&pMBs[x + (y-1) * pParam->mb_width])->sad16; // top
1264                    top_right = (&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16; // top right
1265    
1266                    if(((&pMBs[(x-1) + y * pParam->mb_width])->mode != MODE_INTRA) &&
1267                       ((&pMBs[x + (y-1) * pParam->mb_width])->mode != MODE_INTRA) &&
1268                       ((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mode != MODE_INTRA))
1269                            thresh = MAX(MAX(top, left), top_right);
1270                    else
1271                            thresh = MIN(MIN(top, left), top_right);
1272            }
1273    
1274            /* INTRA <-> INTER decision */
1275            if (sad < thresh) { /* normal, fast, SAD-based mode decision */
1276                    /* intra decision */
1277    
1278                    if (iQuant > 8) InterBias += 100 * (iQuant - 8); /* to make high quants work */
1279                    if (y != 0)
1280                            if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;
1281                    if (x != 0)
1282                            if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80;
1283    
1284                    if (Data->chroma) InterBias += 50; /* dev8(chroma) ??? <-- yes, we need dev8 (no big difference though) */
1285                    if (Data->rrv) InterBias *= 4;
1286    
1287                    if (InterBias < sad) {
1288                            int32_t deviation;
1289                            if (!Data->rrv)
1290                                    deviation = dev16(Data->Cur, Data->iEdgedWidth);
1291                            else
1292                                    deviation = dev16(Data->Cur, Data->iEdgedWidth) + /* dev32() */
1293                                                            dev16(Data->Cur+16, Data->iEdgedWidth) +
1294                                                            dev16(Data->Cur + 16*Data->iEdgedWidth, Data->iEdgedWidth) +
1295                                                            dev16(Data->Cur+16+16*Data->iEdgedWidth, Data->iEdgedWidth);
1296    
1297                            if (deviation < (sad - InterBias)) mode = MODE_INTRA;
1298                    }
1299    
1300                    pMB->cbp = 63;
1301            } else { /* Rate-Distortion INTRA<->INTER */
1302                    if(min_rd < 0) {
1303                            Data->iQuant = iQuant;
1304                            Data->cbp = c;
1305                            v = Data->qpel ? Data->currentQMV : Data->currentMV;
1306    
1307                            for (i = 0; i < 5; i++) {
1308                                    Data->iMinSAD[i] = 256*4096;
1309                                    backup[i] = v[i];
1310                            }
1311    
1312                            if(mode == MODE_INTER) {
1313                                    min_rd = findRDinter(Data, pMBs, x, y, pParam, MotionFlags);
1314                                    cbp = *Data->cbp;
1315    
1316                                    if (coding_type == S_VOP) {
1317                                            int gmc_rd;
1318    
1319                                            *Data->iMinSAD = min_rd += BITS_MULT*1; /* mcsel */
1320                                            gmc_rd = findRDgmc(Data, vGMC, x, y);
1321                                            if (gmc_rd < min_rd) {
1322                                                    mcsel = 1;
1323                                                    *Data->iMinSAD = min_rd = gmc_rd;
1324                                                    mode = MODE_INTER;
1325                                                    cbp = *Data->cbp;
1326                                            }
1327                                    }
1328                            }
1329    
1330                            if(mode == MODE_INTER4V) {
1331                                    int v4_rd;
1332                                    v4_rd = findRDinter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1333                                    if (v4_rd < min_rd) {
1334                                            Data->iMinSAD[0] = min_rd = v4_rd;
1335                                            mode = MODE_INTER4V;
1336                                            cbp = *Data->cbp;
1337                                    }
1338                            }
1339                    }
1340    
1341                    intra_rd = findRDintra(Data);
1342                    if (intra_rd < min_rd) {
1343                            *Data->iMinSAD = min_rd = intra_rd;
1344                            mode = MODE_INTRA;
1345                    }
1346    
1347                    pMB->cbp = cbp;
1348            }
1349    
1350    early_out:
1351            pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
1352    
1353            if (Data->rrv) {
1354                            Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
1355                            Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
1356            }
1357    
1358            if (mode == MODE_INTER && mcsel == 0) {
1359                    pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
1360    
1361                    if(Data->qpel) {
1362                            pMB->qmvs[0] = pMB->qmvs[1]
1363                                    = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0];
1364                            pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x;
1365                            pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y;
1366                    } else {
1367                            pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x;
1368                            pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;
1369                    }
1370    
1371            } else if (mode == MODE_INTER ) { // but mcsel == 1
1372    
1373                    pMB->mcsel = 1;
1374                    if (Data->qpel) {
1375                            pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv;
1376                            pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2;
1377                            pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2;
1378                    } else
1379                            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
1380    
1381            } else
1382                    if (mode == MODE_INTER4V) ; /* anything here? */
1383            else    /* INTRA, NOT_CODED */
1384                    ZeroMacroblockP(pMB, 0);
1385    
1386            pMB->mode = mode;
1387    }
1388    
1389    static __inline void
1390  ModeDecision(SearchData * const Data,  ModeDecision(SearchData * const Data,
1391                          MACROBLOCK * const pMB,                          MACROBLOCK * const pMB,
1392                          const MACROBLOCK * const pMBs,                          const MACROBLOCK * const pMBs,
# Line 1162  Line 1579 
1579          uint32_t mb_height = pParam->mb_height;          uint32_t mb_height = pParam->mb_height;
1580          const uint32_t iEdgedWidth = pParam->edged_width;          const uint32_t iEdgedWidth = pParam->edged_width;
1581          const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags);          const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags);
1582            int stat_thresh = 0;
1583    
1584          uint32_t x, y;          uint32_t x, y;
1585          uint32_t iIntra = 0;          uint32_t iIntra = 0;
# Line 1171  Line 1589 
1589                  (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);                  (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);
1590    
1591          /* some pre-initialized thingies for SearchP */          /* some pre-initialized thingies for SearchP */
1592          int32_t temp[8];          int32_t temp[8]; uint32_t dir;
1593          VECTOR currentMV[5];          VECTOR currentMV[5];
1594          VECTOR currentQMV[5];          VECTOR currentQMV[5];
1595            VECTOR currentMV2[5];
1596            VECTOR currentQMV2[5];
1597          int32_t iMinSAD[5];          int32_t iMinSAD[5];
1598            int32_t iMinSAD2[5];
1599          DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);
1600          SearchData Data;          SearchData Data;
1601          memset(&Data, 0, sizeof(SearchData));          memset(&Data, 0, sizeof(SearchData));
1602          Data.iEdgedWidth = iEdgedWidth;          Data.iEdgedWidth = iEdgedWidth;
1603          Data.currentMV = currentMV;          Data.currentMV = currentMV;
1604          Data.currentQMV = currentQMV;          Data.currentQMV = currentQMV;
1605            Data.currentMV2 = currentMV2;
1606            Data.currentQMV2 = currentQMV2;
1607          Data.iMinSAD = iMinSAD;          Data.iMinSAD = iMinSAD;
1608            Data.iMinSAD2 = iMinSAD2;
1609          Data.temp = temp;          Data.temp = temp;
1610            Data.dir = &dir;
1611          Data.iFcode = current->fcode;          Data.iFcode = current->fcode;
1612          Data.rounding = pParam->m_rounding_type;          Data.rounding = pParam->m_rounding_type;
1613          Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0);          Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0);
# Line 1203  Line 1628 
1628          for (y = 0; y < mb_height; y++) {          for (y = 0; y < mb_height; y++) {
1629                  for (x = 0; x < mb_width; x++)  {                  for (x = 0; x < mb_width; x++)  {
1630                          MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];                          MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];
1631                            MACROBLOCK *prevMB = &reference->mbs[x + y * pParam->mb_width];
1632    
1633                          if (!Data.rrv) pMB->sad16 =                          if (!Data.rrv) pMB->sad16 =
1634                                  sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,                                  sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,
# Line 1235  Line 1661 
1661                                          }                                          }
1662                          }                          }
1663    
1664                            if(MotionFlags & XVID_ME_DETECT_STATIC_MOTION) {
1665                                    if(x > 0 && y > 0 && x < pParam->mb_width)
1666                                            if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], zeroMV) &&
1667                                               MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], zeroMV) &&
1668                                           MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], zeroMV) &&
1669                                           MVequal(prevMB->mvs[0], zeroMV)) {
1670                                                    stat_thresh = MAX((&pMBs[(x-1) + y * pParam->mb_width])->sad16,
1671                                                                              MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
1672                                                                              MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,
1673                                                                              prevMB->sad16)));
1674                                            }
1675                                    else
1676                                            stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16,
1677                                                                              MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
1678                                                                              MIN((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,
1679                                                                              prevMB->sad16)));
1680                            }
1681    
1682                          if ((current->vop_flags & XVID_VOP_CARTOON) &&                          if ((current->vop_flags & XVID_VOP_CARTOON) &&
1683                                  (sad00 < pMB->quant * 4 * skip_thresh)) { /* favorize (0,0) vector for cartoons */                                  (sad00 < pMB->quant * 4 * skip_thresh) || (sad00 < stat_thresh)) { /* favorize (0,0) vector for cartoons */
1684                                  ZeroMacroblockP(pMB, sad00);                                  ZeroMacroblockP(pMB, sad00);
1685                                  continue;                                  continue;
1686                          }                          }
# Line 1245  Line 1689 
1689                                          y, MotionFlags, current->vop_flags, current->vol_flags,                                          y, MotionFlags, current->vop_flags, current->vol_flags,
1690                                          &Data, pParam, pMBs, reference->mbs, pMB);                                          &Data, pParam, pMBs, reference->mbs, pMB);
1691    
1692                            if(current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD) {
1693                                    ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam,
1694                                                             MotionFlags, current->vop_flags, current->vol_flags,
1695                                                             pCurrent, pRef, pGMC, current->coding_type);
1696                            }
1697                            else {
1698                          ModeDecision(&Data, pMB, pMBs, x, y, pParam,                          ModeDecision(&Data, pMB, pMBs, x, y, pParam,
1699                                                   MotionFlags, current->vop_flags, current->vol_flags,                                                   MotionFlags, current->vop_flags, current->vol_flags,
1700                                                   pCurrent, pRef, pGMC, current->coding_type);                                                   pCurrent, pRef, pGMC, current->coding_type);
1701                            }
1702    
1703                          if (pMB->mode == MODE_INTRA)                          if (pMB->mode == MODE_INTRA)
1704                                  if (++iIntra > iLimit) return 1;                                  if (++iIntra > iLimit) return 1;
# Line 1257  Line 1708 
1708          return 0;          return 0;
1709  }  }
1710    
1711    /* check if given vector is equal to any vector checked before */
1712    static __inline int
1713    vector_repeats(const VECTOR * const pmv, const int i)
1714    {
1715            unsigned int j;
1716            for (j = 0; j < i; j++)
1717                    if (MVequal(pmv[i], pmv[j])) return 1; /* same vector has been checked already */
1718            return 0;
1719    }
1720    
1721    /*      make a binary mask that prevents diamonds/squares
1722            from checking a vector which has been checked as a prediction */
1723  static __inline int  static __inline int
1724  make_mask(const VECTOR * const pmv, const int i)  make_mask(const VECTOR * const pmv, const int i, const int current)
1725  {  {
1726          int mask = 255, j;          unsigned int mask = 255, j;
1727          for (j = 0; j < i; j++) {          for (j = 0; j < i; j++) {
1728                  if (MVequal(pmv[i], pmv[j])) return 0; /* same vector has been checked already */                  if (pmv[current].x == pmv[j].x) {
1729                  if (pmv[i].x == pmv[j].x) {                          if (pmv[current].y == pmv[j].y + iDiamondSize) mask &= ~4;
1730                          if (pmv[i].y == pmv[j].y + iDiamondSize) mask &= ~4;                          else if (pmv[current].y == pmv[j].y - iDiamondSize) mask &= ~8;
                         else if (pmv[i].y == pmv[j].y - iDiamondSize) mask &= ~8;  
1731                  } else                  } else
1732                          if (pmv[i].y == pmv[j].y) {                          if (pmv[current].y == pmv[j].y) {
1733                                  if (pmv[i].x == pmv[j].x + iDiamondSize) mask &= ~1;                                  if (pmv[current].x == pmv[j].x + iDiamondSize) mask &= ~1;
1734                                  else if (pmv[i].x == pmv[j].x - iDiamondSize) mask &= ~2;                                  else if (pmv[current].x == pmv[j].x - iDiamondSize) mask &= ~2;
1735                          }                          }
1736          }          }
1737          return mask;          return mask;
# Line 1334  Line 1795 
1795                  MACROBLOCK * const pMB)                  MACROBLOCK * const pMB)
1796  {  {
1797    
1798          int i, iDirection = 255, mask, threshA;          int i, threshA;
1799          VECTOR pmv[7];          VECTOR pmv[7];
1800          int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0);          int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0);
1801            CheckFunc * CheckCandidate;
1802    
1803          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,
1804                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
# Line 1359  Line 1821 
1821          Data->lambda16 = lambda_vec16[pMB->quant];          Data->lambda16 = lambda_vec16[pMB->quant];
1822          Data->lambda8 = lambda_vec8[pMB->quant];          Data->lambda8 = lambda_vec8[pMB->quant];
1823          Data->qpel_precision = 0;          Data->qpel_precision = 0;
1824            *Data->dir = 0;
1825    
1826          memset(Data->currentMV, 0, 5*sizeof(VECTOR));          memset(Data->currentMV, 0, 5*sizeof(VECTOR));
1827    
# Line 1383  Line 1846 
1846                                          prevMBs + x + y * pParam->mb_width, Data->rrv);                                          prevMBs + x + y * pParam->mb_width, Data->rrv);
1847    
1848          if (!Data->rrv) {          if (!Data->rrv) {
1849                  if (inter4v | Data->chroma) CheckCandidate = CheckCandidate16;                  if (inter4v) CheckCandidate = CheckCandidate16;
1850                          else CheckCandidate = CheckCandidate16no4v; /* for extra speed */                          else CheckCandidate = CheckCandidate16no4v; /* for extra speed */
1851          } else CheckCandidate = CheckCandidate32;          } else CheckCandidate = CheckCandidate32;
1852    
1853  /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/  /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/
1854    
1855          for (i = 1; i < 7; i++) {          for (i = 1; i < 7; i++)
1856                  if (!(mask = make_mask(pmv, i)) ) continue;                  if (!vector_repeats(pmv, i)) {
1857                  CheckCandidate(pmv[i].x, pmv[i].y, mask, &iDirection, Data);                          CheckCandidate(pmv[i].x, pmv[i].y, Data, i);
1858                  if (Data->iMinSAD[0] <= threshA) break;                          if (Data->iMinSAD[0] <= threshA) { i++; break; }
1859          }          }
1860    
1861          if ((Data->iMinSAD[0] <= threshA) ||          if ((Data->iMinSAD[0] <= threshA) ||
# Line 1402  Line 1865 
1865          else {          else {
1866    
1867                  MainSearchFunc * MainSearchPtr;                  MainSearchFunc * MainSearchPtr;
1868                    int mask = make_mask(pmv, i, *Data->dir); // all vectors pmv[0..i-1] have been checked
1869    
1870                  if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;                  if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1871                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1872                          else MainSearchPtr = DiamondSearch;                          else MainSearchPtr = DiamondSearch;
1873    
1874                  MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);                  MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate);
1875    
1876  /* extended search, diamond starting in 0,0 and in prediction.  /* extended search, diamond starting in 0,0 and in prediction.
1877          note that this search is/might be done in halfpel positions,          note that this search is/might be done in halfpel positions,
# Line 1422  Line 1887 
1887                          if (!(MVequal(startMV, backupMV))) {                          if (!(MVequal(startMV, backupMV))) {
1888                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1889    
1890                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);                                  CheckCandidate(startMV.x, startMV.y, Data, 255);
1891                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);                                  MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate);
1892                                  if (bSAD < Data->iMinSAD[0]) {                                  if (bSAD < Data->iMinSAD[0]) {
1893                                          Data->currentMV[0] = backupMV;                                          Data->currentMV[0] = backupMV;
1894                                          Data->iMinSAD[0] = bSAD; }                                          Data->iMinSAD[0] = bSAD; }
# Line 1434  Line 1899 
1899                          if (!(MVequal(startMV, backupMV))) {                          if (!(MVequal(startMV, backupMV))) {
1900                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1901    
1902                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);                                  CheckCandidate(startMV.x, startMV.y, Data, 255);
1903                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);                                  MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate);
1904                                  if (bSAD < Data->iMinSAD[0]) {                                  if (bSAD < Data->iMinSAD[0]) {
1905                                          Data->currentMV[0] = backupMV;                                          Data->currentMV[0] = backupMV;
1906                                          Data->iMinSAD[0] = bSAD; }                                          Data->iMinSAD[0] = bSAD;
1907                                    }
1908                          }                          }
1909                  }                  }
1910          }          }
1911    
1912          if (MotionFlags & XVID_ME_HALFPELREFINE16)          if (MotionFlags & XVID_ME_HALFPELREFINE16)
1913                          SubpelRefine(Data);                          SubpelRefine(Data, CheckCandidate);
1914    
1915          for(i = 0; i < 5; i++) {          for(i = 0; i < 5; i++) {
1916                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* initialize qpel vectors */                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* initialize qpel vectors */
# Line 1456  Line 1922 
1922                                  pParam->width, pParam->height, Data->iFcode, 2, 0);                                  pParam->width, pParam->height, Data->iFcode, 2, 0);
1923                  Data->qpel_precision = 1;                  Data->qpel_precision = 1;
1924                  if (MotionFlags & XVID_ME_QUARTERPELREFINE16)                  if (MotionFlags & XVID_ME_QUARTERPELREFINE16)
1925                          SubpelRefine(Data);                          if(MotionFlags & XVID_ME_FASTREFINE16)
1926                                    SubpelRefine_Fast(Data, CheckCandidate);
1927                            else
1928                                    SubpelRefine(Data, CheckCandidate);
1929          }          }
1930    
1931          if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30)          if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30)
# Line 1503  Line 1972 
1972                  SearchData * const Data)                  SearchData * const Data)
1973  {  {
1974          int i = 0;          int i = 0;
1975            CheckFunc * CheckCandidate;
1976          Data->iMinSAD = OldData->iMinSAD + 1 + block;          Data->iMinSAD = OldData->iMinSAD + 1 + block;
1977          Data->currentMV = OldData->currentMV + 1 + block;          Data->currentMV = OldData->currentMV + 1 + block;
1978          Data->currentQMV = OldData->currentQMV + 1 + block;          Data->currentQMV = OldData->currentQMV + 1 + block;
# Line 1545  Line 2015 
2015                                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;                                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;
2016                                          else MainSearchPtr = DiamondSearch;                                          else MainSearchPtr = DiamondSearch;
2017    
2018                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255);                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate);
2019    
2020                          if(*(Data->iMinSAD) < temp_sad) {                          if(*(Data->iMinSAD) < temp_sad) {
2021                                          Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */                                          Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */
# Line 1556  Line 2026 
2026                  if (MotionFlags & XVID_ME_HALFPELREFINE8) {                  if (MotionFlags & XVID_ME_HALFPELREFINE8) {
2027                          int32_t temp_sad = *(Data->iMinSAD); /* store current MinSAD */                          int32_t temp_sad = *(Data->iMinSAD); /* store current MinSAD */
2028    
2029                          SubpelRefine(Data); /* perform halfpel refine of current best vector */                          SubpelRefine(Data, CheckCandidate); /* perform halfpel refine of current best vector */
2030    
2031                          if(*(Data->iMinSAD) < temp_sad) { /* we have found a better match */                          if(*(Data->iMinSAD) < temp_sad) { /* we have found a better match */
2032                                  Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */                                  Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */
# Line 1568  Line 2038 
2038                                  Data->qpel_precision = 1;                                  Data->qpel_precision = 1;
2039                                  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,
2040                                          pParam->width, pParam->height, Data->iFcode, 2, 0);                                          pParam->width, pParam->height, Data->iFcode, 2, 0);
2041                                  SubpelRefine(Data);                                  SubpelRefine(Data, CheckCandidate);
2042                  }                  }
2043          }          }
2044    
# Line 1654  Line 2124 
2124                          SearchData * const Data)                          SearchData * const Data)
2125  {  {
2126    
2127          int i, iDirection = 255, mask;          int i;
2128          VECTOR pmv[7];          VECTOR pmv[7];
2129          MainSearchFunc *MainSearchPtr;          MainSearchFunc *MainSearchPtr;
2130          *Data->iMinSAD = MV_MAX_ERROR;          *Data->iMinSAD = MV_MAX_ERROR;
# Line 1680  Line 2150 
2150          PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current);          PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current);
2151    
2152          Data->currentMV->x = Data->currentMV->y = 0;          Data->currentMV->x = Data->currentMV->y = 0;
         CheckCandidate = CheckCandidate16no4v;  
2153    
2154          /* main loop. checking all predictions */          /* main loop. checking all predictions */
2155          for (i = 0; i < 7; i++) {          for (i = 0; i < 7; i++)
2156                  if (!(mask = make_mask(pmv, i)) ) continue;                  if (!vector_repeats(pmv, i) )
2157                  CheckCandidate16no4v(pmv[i].x, pmv[i].y, mask, &iDirection, Data);                          CheckCandidate16no4v(pmv[i].x, pmv[i].y, Data, i);
         }  
2158    
2159          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
2160          else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;          else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
2161                  else MainSearchPtr = DiamondSearch;                  else MainSearchPtr = DiamondSearch;
2162    
2163          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);          if (*Data->iMinSAD > 512) {
2164                    unsigned int mask = make_mask(pmv, 7, *Data->dir);
2165                    MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate16no4v);
2166            }
2167    
2168          SubpelRefine(Data);          SubpelRefine(Data, CheckCandidate16no4v);
2169    
2170          if (Data->qpel && *Data->iMinSAD < *best_sad + 300) {          if (Data->qpel && *Data->iMinSAD < *best_sad + 300) {
2171                  Data->currentQMV->x = 2*Data->currentMV->x;                  Data->currentQMV->x = 2*Data->currentMV->x;
# Line 1702  Line 2173 
2173                  Data->qpel_precision = 1;                  Data->qpel_precision = 1;
2174                  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,
2175                                          pParam->width, pParam->height, iFcode, 2, 0);                                          pParam->width, pParam->height, iFcode, 2, 0);
2176                  SubpelRefine(Data);                  SubpelRefine(Data, CheckCandidate16no4v);
2177          }          }
2178    
2179          /* three bits are needed to code backward mode. four for forward */          /* three bits are needed to code backward mode. four for forward */
# Line 1742  Line 2213 
2213  {  {
2214          int dx = 0, dy = 0, b_dx = 0, b_dy = 0;          int dx = 0, dy = 0, b_dx = 0, b_dy = 0;
2215          int32_t sum;          int32_t sum;
         const int div = 1 + Data->qpel;  
2216          int k;          int k;
2217          const uint32_t stride = Data->iEdgedWidth/2;          const uint32_t stride = Data->iEdgedWidth/2;
2218          /* this is not full chroma compensation, only it's fullpel approximation. should work though */          /* this is not full chroma compensation, only it's fullpel approximation. should work though */
2219    
2220          for (k = 0; k < 4; k++) {          for (k = 0; k < 4; k++) {
2221                  dy += Data->directmvF[k].y / div;                  dy += Data->directmvF[k].y >> Data->qpel;
2222                  dx += Data->directmvF[k].x / div;                  dx += Data->directmvF[k].x >> Data->qpel;
2223                  b_dy += Data->directmvB[k].y / div;                  b_dy += Data->directmvB[k].y >> Data->qpel;
2224                  b_dx += Data->directmvB[k].x / div;                  b_dx += Data->directmvB[k].x >> Data->qpel;
2225          }          }
2226    
2227          dy = (dy >> 3) + roundtab_76[dy & 0xf];          dy = (dy >> 3) + roundtab_76[dy & 0xf];
# Line 1764  Line 2234 
2234                                          b_Ref->u + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,                                          b_Ref->u + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
2235                                          stride);                                          stride);
2236    
2237          if (sum >= MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) return; /* no skip */          if (sum >= MAX_CHROMA_SAD_FOR_SKIP * Data->iQuant) return; /* no skip */
2238    
2239          sum += sad8bi(pCur->v + 8*x + 8 * y * stride,          sum += sad8bi(pCur->v + 8*x + 8 * y * stride,
2240                                          f_Ref->v + (y*8 + dy/2) * stride + x*8 + dx/2,                                          f_Ref->v + (y*8 + dy/2) * stride + x*8 + dx/2,
2241                                          b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,                                          b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
2242                                          stride);                                          stride);
2243    
2244          if (sum < MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) {          if (sum < MAX_CHROMA_SAD_FOR_SKIP * Data->iQuant) {
2245                  pMB->mode = MODE_DIRECT_NONE_MV; /* skipped */                  pMB->mode = MODE_DIRECT_NONE_MV; /* skipped */
2246                  for (k = 0; k < 4; k++) {                  for (k = 0; k < 4; k++) {
2247                          pMB->qmvs[k] = pMB->mvs[k];                          pMB->qmvs[k] = pMB->mvs[k];
# Line 1803  Line 2273 
2273          int32_t skip_sad;          int32_t skip_sad;
2274          int k = (x + Data->iEdgedWidth*y) * 16;          int k = (x + Data->iEdgedWidth*y) * 16;
2275          MainSearchFunc *MainSearchPtr;          MainSearchFunc *MainSearchPtr;
2276            CheckFunc * CheckCandidate;
2277    
2278          *Data->iMinSAD = 256*4096;          *Data->iMinSAD = 256*4096;
2279          Data->RefP[0] = f_Ref->y + k;          Data->RefP[0] = f_Ref->y + k;
# Line 1852  Line 2323 
2323    
2324          CheckCandidate = b_mb->mode == MODE_INTER4V ? CheckCandidateDirect : CheckCandidateDirectno4v;          CheckCandidate = b_mb->mode == MODE_INTER4V ? CheckCandidateDirect : CheckCandidateDirectno4v;
2325    
2326          CheckCandidate(0, 0, 255, &k, Data);          CheckCandidate(0, 0, Data, 255);
2327    
2328          /* initial (fast) skip decision */          /* initial (fast) skip decision */
2329          if (*Data->iMinSAD < pMB->quant * INITIAL_SKIP_THRESH * (Data->chroma?3:2)) {          if (*Data->iMinSAD < Data->iQuant * INITIAL_SKIP_THRESH * (Data->chroma?3:2)) {
2330                  /* possible skip */                  /* possible skip */
2331                  if (Data->chroma) {                  if (Data->chroma) {
2332                          pMB->mode = MODE_DIRECT_NONE_MV;                          pMB->mode = MODE_DIRECT_NONE_MV;
# Line 1878  Line 2349 
2349                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
2350                          else MainSearchPtr = DiamondSearch;                          else MainSearchPtr = DiamondSearch;
2351    
2352          MainSearchPtr(0, 0, Data, 255);          MainSearchPtr(0, 0, Data, 255, CheckCandidate);
2353    
2354          SubpelRefine(Data);          SubpelRefine(Data, CheckCandidate);
2355    
2356          *best_sad = *Data->iMinSAD;          *best_sad = *Data->iMinSAD;
2357    
# Line 1939  Line 2410 
2410    
2411  {  {
2412    
2413          int iDirection, i, j;          int i, j;
2414          SearchData bData;          SearchData bData;
2415    
2416          fData->qpel_precision = 0;          fData->qpel_precision = 0;
# Line 1962  Line 2433 
2433          bData.b_RefP[5] = fData->RefP[5] = f_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;          bData.b_RefP[5] = fData->RefP[5] = f_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
2434          bData.RefP[4] = fData->b_RefP[4] = b_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;          bData.RefP[4] = fData->b_RefP[4] = b_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
2435          bData.RefP[5] = fData->b_RefP[5] = b_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;          bData.RefP[5] = fData->b_RefP[5] = b_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
2436            bData.dir = fData->dir;
2437    
2438          bData.bpredMV = fData->predMV = *f_predMV;          bData.bpredMV = fData->predMV = *f_predMV;
2439          fData->bpredMV = bData.predMV = *b_predMV;          fData->bpredMV = bData.predMV = *b_predMV;
# Line 1980  Line 2452 
2452          if (fData->currentMV[1].y > bData.max_dy) fData->currentMV[1].y = bData.max_dy;          if (fData->currentMV[1].y > bData.max_dy) fData->currentMV[1].y = bData.max_dy;
2453          if (fData->currentMV[1].y < bData.min_dy) fData->currentMV[1].y = bData.min_dy;          if (fData->currentMV[1].y < bData.min_dy) fData->currentMV[1].y = bData.min_dy;
2454    
2455          CheckCandidateInt(fData->currentMV[0].x, fData->currentMV[0].y, 255, &iDirection, fData);          CheckCandidateInt(fData->currentMV[0].x, fData->currentMV[0].y, fData, 255);
2456    
2457          /* diamond */          /* diamond */
2458          do {          do {
2459                  iDirection = 255;                  *fData->dir = 255;
2460                  /* forward MV moves */                  /* forward MV moves */
2461                  i = fData->currentMV[0].x; j = fData->currentMV[0].y;                  i = fData->currentMV[0].x; j = fData->currentMV[0].y;
2462    
2463                  CheckCandidateInt(i + 1, j, 0, &iDirection, fData);                  CheckCandidateInt(i + 1, j, fData, 0);
2464                  CheckCandidateInt(i, j + 1, 0, &iDirection, fData);                  CheckCandidateInt(i, j + 1, fData, 0);
2465                  CheckCandidateInt(i - 1, j, 0, &iDirection, fData);                  CheckCandidateInt(i - 1, j, fData, 0);
2466                  CheckCandidateInt(i, j - 1, 0, &iDirection, fData);                  CheckCandidateInt(i, j - 1, fData, 0);
2467    
2468                  /* backward MV moves */                  /* backward MV moves */
2469                  i = fData->currentMV[1].x; j = fData->currentMV[1].y;                  i = fData->currentMV[1].x; j = fData->currentMV[1].y;
2470                  fData->currentMV[2] = fData->currentMV[0];                  fData->currentMV[2] = fData->currentMV[0];
2471                  CheckCandidateInt(i + 1, j, 0, &iDirection, &bData);                  CheckCandidateInt(i + 1, j, &bData, 0);
2472                  CheckCandidateInt(i, j + 1, 0, &iDirection, &bData);                  CheckCandidateInt(i, j + 1, &bData, 0);
2473                  CheckCandidateInt(i - 1, j, 0, &iDirection, &bData);                  CheckCandidateInt(i - 1, j, &bData, 0);
2474                  CheckCandidateInt(i, j - 1, 0, &iDirection, &bData);                  CheckCandidateInt(i, j - 1, &bData, 0);
2475    
2476          } while (!(iDirection));          } while (!(*fData->dir));
2477    
2478          /* qpel refinement */          /* qpel refinement */
2479          if (fData->qpel) {          if (fData->qpel) {
2480                  if (*fData->iMinSAD > *best_sad + 500) return;                  if (*fData->iMinSAD > *best_sad + 500) return;
                 CheckCandidate = CheckCandidateInt;  
2481                  fData->qpel_precision = bData.qpel_precision = 1;                  fData->qpel_precision = bData.qpel_precision = 1;
2482                  get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 4, pParam->width, pParam->height, fcode, 2, 0);                  get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 4, pParam->width, pParam->height, fcode, 2, 0);
2483                  get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 4, pParam->width, pParam->height, bcode, 2, 0);                  get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 4, pParam->width, pParam->height, bcode, 2, 0);
# Line 2014  Line 2485 
2485                  fData->currentQMV[2].y = fData->currentQMV[0].y = 2 * fData->currentMV[0].y;                  fData->currentQMV[2].y = fData->currentQMV[0].y = 2 * fData->currentMV[0].y;
2486                  fData->currentQMV[1].x = 2 * fData->currentMV[1].x;                  fData->currentQMV[1].x = 2 * fData->currentMV[1].x;
2487                  fData->currentQMV[1].y = 2 * fData->currentMV[1].y;                  fData->currentQMV[1].y = 2 * fData->currentMV[1].y;
2488                  SubpelRefine(fData);                  SubpelRefine(fData, CheckCandidateInt);
2489                  if (*fData->iMinSAD > *best_sad + 300) return;                  if (*fData->iMinSAD > *best_sad + 300) return;
2490                  fData->currentQMV[2] = fData->currentQMV[0];                  fData->currentQMV[2] = fData->currentQMV[0];
2491                  SubpelRefine(&bData);                  SubpelRefine(&bData, CheckCandidateInt);
2492          }          }
2493    
2494          *fData->iMinSAD += (2+3) * fData->lambda16; /* two bits are needed to code interpolate mode. */          *fData->iMinSAD += (2+3) * fData->lambda16; /* two bits are needed to code interpolate mode. */
# Line 2076  Line 2547 
2547    
2548          SearchData Data;          SearchData Data;
2549          int32_t iMinSAD;          int32_t iMinSAD;
2550            uint32_t dir;
2551          VECTOR currentMV[3];          VECTOR currentMV[3];
2552          VECTOR currentQMV[3];          VECTOR currentQMV[3];
2553          int32_t temp[8];          int32_t temp[8];
# Line 2083  Line 2555 
2555          Data.iEdgedWidth = pParam->edged_width;          Data.iEdgedWidth = pParam->edged_width;
2556          Data.currentMV = currentMV; Data.currentQMV = currentQMV;          Data.currentMV = currentMV; Data.currentQMV = currentQMV;
2557          Data.iMinSAD = &iMinSAD;          Data.iMinSAD = &iMinSAD;
2558          Data.lambda16 = lambda_vec16[frame->quant];          Data.lambda16 = lambda_vec16[MAX(frame->quant-2, 2)];
2559          Data.qpel = pParam->vol_flags & XVID_VOL_QUARTERPEL ? 1 : 0;          Data.qpel = pParam->vol_flags & XVID_VOL_QUARTERPEL ? 1 : 0;
2560          Data.rounding = 0;          Data.rounding = 0;
2561          Data.chroma = frame->motion_flags & XVID_ME_CHROMA_BVOP;          Data.chroma = frame->motion_flags & XVID_ME_CHROMA_BVOP;
2562          Data.temp = temp;          Data.temp = temp;
2563            Data.dir = &dir;
2564            Data.iQuant = frame->quant;
2565    
2566          Data.RefQ = f_refV->u; /* a good place, also used in MC (for similar purpose) */          Data.RefQ = f_refV->u; /* a good place, also used in MC (for similar purpose) */
2567    
# Line 2110  Line 2584 
2584                          Data.Cur = frame->image.y + (j * Data.iEdgedWidth + i) * 16;                          Data.Cur = frame->image.y + (j * Data.iEdgedWidth + i) * 16;
2585                          Data.CurU = frame->image.u + (j * Data.iEdgedWidth/2 + i) * 8;                          Data.CurU = frame->image.u + (j * Data.iEdgedWidth/2 + i) * 8;
2586                          Data.CurV = frame->image.v + (j * Data.iEdgedWidth/2 + i) * 8;                          Data.CurV = frame->image.v + (j * Data.iEdgedWidth/2 + i) * 8;
                         pMB->quant = frame->quant;  
2587    
2588  /* direct search comes first, because it (1) checks for SKIP-mode  /* direct search comes first, because it (1) checks for SKIP-mode
2589          and (2) sets very good predictions for forward and backward search */          and (2) sets very good predictions for forward and backward search */
# Line 2156  Line 2629 
2629                                                  &Data);                                                  &Data);
2630    
2631                          /* final skip decision */                          /* final skip decision */
2632                          if ( (skip_sad < frame->quant * MAX_SAD00_FOR_SKIP * 2)                          if ( (skip_sad < Data.iQuant * MAX_SAD00_FOR_SKIP * 2)
2633                                          && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) )                                          && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) )
2634                                  SkipDecisionB(&frame->image, f_ref, b_ref, pMB, i, j, &Data);                                  SkipDecisionB(&frame->image, f_ref, b_ref, pMB, i, j, &Data);
2635    
# Line 2194  Line 2667 
2667                                  SearchData * const Data)                                  SearchData * const Data)
2668  {  {
2669    
2670          int i, mask;          int i;
         int quarterpel = (pParam->vol_flags & XVID_VOL_QUARTERPEL)? 1: 0;  
2671          VECTOR pmv[3];          VECTOR pmv[3];
2672          MACROBLOCK * const pMB = &pMBs[x + y * pParam->mb_width];          MACROBLOCK * const pMB = &pMBs[x + y * pParam->mb_width];
2673    
2674            unsigned int simplicity = 0;
2675    
2676          for (i = 0; i < 5; i++) Data->iMinSAD[i] = MV_MAX_ERROR;          for (i = 0; i < 5; i++) Data->iMinSAD[i] = MV_MAX_ERROR;
2677    
2678            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
2679                            pParam->width, pParam->height, Data->iFcode - Data->qpel - 1, 0, 0);
2680    
2681            Data->Cur = pCur + (x + y * pParam->edged_width) * 16;
2682            Data->RefP[0] = pRef + (x + y * pParam->edged_width) * 16;
2683    
2684            pmv[0].x = pMB->mvs[0].x;
2685            pmv[0].y = pMB->mvs[0].y;
2686    
2687            CheckCandidate32I(pmv[0].x, pmv[0].y, Data, 0);
2688    
2689            if (*Data->iMinSAD > 200) {
2690    
2691                    pmv[1].x = pmv[1].y = 0;
2692    
2693          /* median is only used as prediction. it doesn't have to be real */          /* median is only used as prediction. it doesn't have to be real */
2694          if (x == 1 && y == 1) Data->predMV.x = Data->predMV.y = 0;          if (x == 1 && y == 1) Data->predMV.x = Data->predMV.y = 0;
2695          else          else
# Line 2210  Line 2699 
2699                          Data->predMV = (pMB - 1)->mvs[0]; /* left instead of median */                          Data->predMV = (pMB - 1)->mvs[0]; /* left instead of median */
2700                          else Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); /* else median */                          else Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); /* else median */
2701    
2702          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,                  pmv[2].x = Data->predMV.x;
2703                          pParam->width, pParam->height, Data->iFcode - quarterpel, 1, 0);                  pmv[2].y = Data->predMV.y;
   
         Data->Cur = pCur + (x + y * pParam->edged_width) * 16;  
         Data->RefP[0] = pRef + (x + y * pParam->edged_width) * 16;  
   
         pmv[1].x = EVEN(pMB->mvs[0].x);  
         pmv[1].y = EVEN(pMB->mvs[0].y);  
         pmv[2].x = EVEN(Data->predMV.x);  
         pmv[2].y = EVEN(Data->predMV.y);  
         pmv[0].x = pmv[0].y = 0;  
   
         CheckCandidate32I(0, 0, 255, &i, Data);  
   
         if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP) {  
   
                 if (!(mask = make_mask(pmv, 1)))  
                         CheckCandidate32I(pmv[1].x, pmv[1].y, mask, &i, Data);  
                 if (!(mask = make_mask(pmv, 2)))  
                         CheckCandidate32I(pmv[2].x, pmv[2].y, mask, &i, Data);  
2704    
2705                  if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP) /* diamond only if needed */                  if (!vector_repeats(pmv, 1))
2706                          DiamondSearch(Data->currentMV->x, Data->currentMV->y, Data, i);                          CheckCandidate32I(pmv[1].x, pmv[1].y, Data, 1);
2707          }                  if (!vector_repeats(pmv, 2))
2708                            CheckCandidate32I(pmv[2].x, pmv[2].y, Data, 2);
2709    
2710                    if (*Data->iMinSAD > 500) { /* diamond only if needed */
2711                            unsigned int mask = make_mask(pmv, 3, *Data->dir);
2712                            DiamondSearch(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate32I);
2713                    } else simplicity++;
2714    
2715                    if (*Data->iMinSAD > 500) /* refinement from 2-pixel to 1-pixel */
2716                            SubpelRefine(Data, CheckCandidate32I);
2717                    else simplicity++;
2718            } else simplicity++;
2719    
2720          for (i = 0; i < 4; i++) {          for (i = 0; i < 4; i++) {
2721                  MACROBLOCK * MB = &pMBs[x + (i&1) + (y+(i>>1)) * pParam->mb_width];                  MACROBLOCK * MB = &pMBs[x + (i&1) + (y+(i>>1)) * pParam->mb_width];
2722                  MB->mvs[0] = MB->mvs[1] = MB->mvs[2] = MB->mvs[3] = Data->currentMV[i];                  MB->mvs[0] = MB->mvs[1] = MB->mvs[2] = MB->mvs[3] = Data->currentMV[i];
2723                  MB->mode = MODE_INTER;                  MB->mode = MODE_INTER;
2724                  MB->sad16 = Data->iMinSAD[i+1];                  /* if we skipped some search steps, we have to assume that SAD would be lower with them */
2725                    MB->sad16 = Data->iMinSAD[i+1] - (simplicity<<7);
2726          }          }
2727  }  }
2728    
2729  #define INTRA_THRESH    2200  #define INTRA_THRESH    2200
2730  #define INTER_THRESH    50  #define INTER_THRESH    40
2731  #define INTRA_THRESH2   95  #define INTRA_THRESH2   95
2732    
2733  int  int
# Line 2265  Line 2748 
2748          int complexity = 0;          int complexity = 0;
2749    
2750          int32_t iMinSAD[5], temp[5];          int32_t iMinSAD[5], temp[5];
2751            uint32_t dir;
2752          VECTOR currentMV[5];          VECTOR currentMV[5];
2753          SearchData Data;          SearchData Data;
2754          Data.iEdgedWidth = pParam->edged_width;          Data.iEdgedWidth = pParam->edged_width;
# Line 2272  Line 2756 
2756          Data.iMinSAD = iMinSAD;          Data.iMinSAD = iMinSAD;
2757          Data.iFcode = Current->fcode;          Data.iFcode = Current->fcode;
2758          Data.temp = temp;          Data.temp = temp;
2759          CheckCandidate = CheckCandidate32I;          Data.dir = &dir;
2760            Data.qpel = (pParam->vol_flags & XVID_VOL_QUARTERPEL)? 1: 0;
2761            Data.qpel_precision = 0;
2762    
2763          if (intraCount != 0) {          if (intraCount != 0) {
2764                  if (intraCount < 10) // we're right after an I frame                  if (intraCount < 10) // we're right after an I frame
# Line 2282  Line 2768 
2768                                  IntraThresh -= (IntraThresh * (maxIntra - 8*(maxIntra - intraCount)))/maxIntra;                                  IntraThresh -= (IntraThresh * (maxIntra - 8*(maxIntra - intraCount)))/maxIntra;
2769          }          }
2770    
2771          InterThresh -= 12 * bCount;          InterThresh -= 20 * bCount;
2772          if (InterThresh < 15 + b_thresh) InterThresh = 15 + b_thresh;          if (InterThresh < 10 + b_thresh) InterThresh = 10 + b_thresh;
2773    
2774          if (sadInit) (*sadInit) ();          if (sadInit) (*sadInit) ();
2775    
# Line 2315  Line 2801 
2801                                  }                                  }
2802    
2803                                  if (pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0)                                  if (pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0)
2804                                          if (dev > 500 && pMB->sad16 < 1000)                                          if (dev > 1000 && pMB->sad16 < 1000)
2805                                                  sSAD += 1000;                                                  sSAD += 1000;
2806    
2807                                  sSAD += (dev < 3000) ? pMB->sad16 : pMB->sad16/2; /* blocks with big contrast differences usually have large SAD - while they look very good in b-frames */                                  sSAD += (dev < 4000) ? pMB->sad16 : pMB->sad16/2; /* blocks with big contrast differences usually have large SAD - while they look very good in b-frames */
2808                          }                          }
2809                  }                  }
2810          }          }
# Line 2341  Line 2827 
2827                          const MBParam * const pParam,                          const MBParam * const pParam,
2828                          const uint32_t MotionFlags)                          const uint32_t MotionFlags)
2829  {  {
2830          int i, iDirection;          int i;
2831          int32_t bsad[5];          int32_t bsad[5];
2832    
         CheckCandidate = CheckCandidateRD16;  
   
2833          if (Data->qpel) {          if (Data->qpel) {
2834                  for(i = 0; i < 5; i++) {                  for(i = 0; i < 5; i++) {
2835                          Data->currentMV[i].x = Data->currentQMV[i].x/2;                          Data->currentMV[i].x = Data->currentQMV[i].x/2;
2836                          Data->currentMV[i].y = Data->currentQMV[i].y/2;                          Data->currentMV[i].y = Data->currentQMV[i].y/2;
2837                  }                  }
2838                  Data->qpel_precision = 1;                  Data->qpel_precision = 1;
2839                  CheckCandidateRD16(Data->currentQMV[0].x, Data->currentQMV[0].y, 255, &iDirection, Data);                  CheckCandidateRD16(Data->currentQMV[0].x, Data->currentQMV[0].y, Data, 255);
2840    
2841                  if (MotionFlags & (XVID_ME_HALFPELREFINE16_RD | XVID_ME_EXTSEARCH_RD)) { /* we have to prepare for halfpixel-precision search */                  if (MotionFlags & (XVID_ME_HALFPELREFINE16_RD | XVID_ME_EXTSEARCH_RD)) { /* we have to prepare for halfpixel-precision search */
2842                          for(i = 0; i < 5; i++) bsad[i] = Data->iMinSAD[i];                          for(i = 0; i < 5; i++) bsad[i] = Data->iMinSAD[i];
# Line 2360  Line 2844 
2844                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
2845                          Data->qpel_precision = 0;                          Data->qpel_precision = 0;
2846                          if (Data->currentQMV->x & 1 || Data->currentQMV->y & 1)                          if (Data->currentQMV->x & 1 || Data->currentQMV->y & 1)
2847                                  CheckCandidateRD16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);                                  CheckCandidateRD16(Data->currentMV[0].x, Data->currentMV[0].y, Data, 255);
2848                  }                  }
2849    
2850          } else { /* not qpel */          } else { /* not qpel */
2851    
2852                  CheckCandidateRD16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);                  CheckCandidateRD16(Data->currentMV[0].x, Data->currentMV[0].y, Data, 255);
2853          }          }
2854    
2855          if (MotionFlags&XVID_ME_EXTSEARCH_RD) SquareSearch(Data->currentMV->x, Data->currentMV->y, Data, iDirection);          if (MotionFlags&XVID_ME_EXTSEARCH_RD)
2856                    SquareSearch(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidateRD16);
2857    
2858          if (MotionFlags&XVID_ME_HALFPELREFINE16_RD) SubpelRefine(Data);          if (MotionFlags&XVID_ME_HALFPELREFINE16_RD)
2859                    SubpelRefine(Data, CheckCandidateRD16);
2860    
2861          if (Data->qpel) {          if (Data->qpel) {
2862                  if (MotionFlags&(XVID_ME_EXTSEARCH_RD | XVID_ME_HALFPELREFINE16_RD)) { /* there was halfpel-precision search */                  if (MotionFlags&(XVID_ME_EXTSEARCH_RD | XVID_ME_HALFPELREFINE16_RD)) { /* there was halfpel-precision search */
# Line 2384  Line 2870 
2870                          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,
2871                                          pParam->width, pParam->height, Data->iFcode, 2, 0);                                          pParam->width, pParam->height, Data->iFcode, 2, 0);
2872                  }                  }
2873                  if (MotionFlags&XVID_ME_QUARTERPELREFINE16_RD) SubpelRefine(Data);                  if (MotionFlags&XVID_ME_QUARTERPELREFINE16_RD)
2874                            SubpelRefine(Data, CheckCandidateRD16);
2875          }          }
2876    
2877          if (MotionFlags&XVID_ME_CHECKPREDICTION_RD) { /* let's check vector equal to prediction */          if (MotionFlags&XVID_ME_CHECKPREDICTION_RD) { /* let's check vector equal to prediction */
2878                  VECTOR * v = Data->qpel ? Data->currentQMV : Data->currentMV;                  VECTOR * v = Data->qpel ? Data->currentQMV : Data->currentMV;
2879                  if (!(Data->predMV.x == v->x && Data->predMV.y == v->y))                  if (!(Data->predMV.x == v->x && Data->predMV.y == v->y))
2880                          CheckCandidateRD16(Data->predMV.x, Data->predMV.y, 255, &iDirection, Data);                          CheckCandidateRD16(Data->predMV.x, Data->predMV.y, Data, 255);
2881          }          }
2882          return Data->iMinSAD[0];          return Data->iMinSAD[0];
2883  }  }
# Line 2403  Line 2890 
2890                                  const VECTOR * const backup)                                  const VECTOR * const backup)
2891  {  {
2892    
2893          int cbp = 0, bits = 0, t = 0, i, iDirection;          int cbp = 0, bits = 0, t = 0, i;
2894          SearchData Data2, *Data8 = &Data2;          SearchData Data2, *Data8 = &Data2;
2895          int sumx = 0, sumy = 0;          int sumx = 0, sumy = 0;
2896          int16_t *in = Data->dctSpace, *coeff = Data->dctSpace + 64;          int16_t *in = Data->dctSpace, *coeff = Data->dctSpace + 64;
2897          uint8_t * ptr;          uint8_t * ptr;
2898    
2899          memcpy(Data8, Data, sizeof(SearchData));          memcpy(Data8, Data, sizeof(SearchData));
         CheckCandidate = CheckCandidateRD8;  
2900    
2901          for (i = 0; i < 4; i++) { /* for all luma blocks */          for (i = 0; i < 4; i++) { /* for all luma blocks */
2902    
# Line 2444  Line 2930 
2930                  {                  {
2931                          VECTOR *v = Data8->qpel ? Data8->currentQMV : Data8->currentMV;                          VECTOR *v = Data8->qpel ? Data8->currentQMV : Data8->currentMV;
2932                          if (!MVequal (*v, backup[i+1]) )                          if (!MVequal (*v, backup[i+1]) )
2933                                  CheckCandidateRD8(backup[i+1].x, backup[i+1].y, 255, &iDirection, Data8);                                  CheckCandidateRD8(backup[i+1].x, backup[i+1].y, Data8, 255);
2934                  }                  }
2935    
2936                  if (Data8->qpel) {                  if (Data8->qpel) {
# Line 2457  Line 2943 
2943                                                          pParam->width, pParam->height, Data8->iFcode - 1, 1, 0);                                                          pParam->width, pParam->height, Data8->iFcode - 1, 1, 0);
2944    
2945                                  if (Data8->currentQMV->x & 1 || Data8->currentQMV->y & 1)                                  if (Data8->currentQMV->x & 1 || Data8->currentQMV->y & 1)
2946                                          CheckCandidateRD8(Data8->currentMV->x, Data8->currentMV->y, 255, &iDirection, Data8);                                          CheckCandidateRD8(Data8->currentMV->x, Data8->currentMV->y, Data8, 255);
2947    
2948                                  if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD)                                  if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD)
2949                                          SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255);                                          SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255, CheckCandidateRD8);
2950    
2951                                  if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)                                  if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)
2952                                          SubpelRefine(Data8);                                          SubpelRefine(Data8, CheckCandidateRD8);
2953    
2954                                  if(s > *Data8->iMinSAD) { /* we have found a better match */                                  if(s > *Data8->iMinSAD) { /* we have found a better match */
2955                                          Data8->currentQMV->x = 2*Data8->currentMV->x;                                          Data8->currentQMV->x = 2*Data8->currentMV->x;
# Line 2475  Line 2961 
2961                                                          pParam->width, pParam->height, Data8->iFcode, 2, 0);                                                          pParam->width, pParam->height, Data8->iFcode, 2, 0);
2962    
2963                          }                          }
2964                          if (MotionFlags & XVID_ME_QUARTERPELREFINE8_RD) SubpelRefine(Data8);                          if (MotionFlags & XVID_ME_QUARTERPELREFINE8_RD)
2965                                    SubpelRefine(Data8, CheckCandidateRD8);
2966    
2967                  } else { /* not qpel */                  } else { /* not qpel */
2968    
2969                          if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD) /* extsearch */                          if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD) /* extsearch */
2970                                  SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255);                                  SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255, CheckCandidateRD8);
2971    
2972                          if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)                          if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)
2973                                  SubpelRefine(Data8); /* halfpel refinement */                                  SubpelRefine(Data8, CheckCandidateRD8); /* halfpel refinement */
2974                  }                  }
2975    
2976                  /* checking vector equal to predicion */                  /* checking vector equal to predicion */
2977                  if (i != 0 && MotionFlags & XVID_ME_CHECKPREDICTION_RD) {                  if (i != 0 && MotionFlags & XVID_ME_CHECKPREDICTION_RD) {
2978                          const VECTOR * v = Data->qpel ? Data8->currentQMV : Data8->currentMV;                          const VECTOR * v = Data->qpel ? Data8->currentQMV : Data8->currentMV;
2979                          if (!MVequal(*v, Data8->predMV))                          if (!MVequal(*v, Data8->predMV))
2980                                  CheckCandidateRD8(Data8->predMV.x, Data8->predMV.y, 255, &iDirection, Data8);                                  CheckCandidateRD8(Data8->predMV.x, Data8->predMV.y, Data8, 255);
2981                  }                  }
2982    
2983                  bits += *Data8->iMinSAD;                  bits += *Data8->iMinSAD;
# Line 2637  Line 3124 
3124          Data->RefP[3] = pRefHV + 16*(x + y * pParam->edged_width);          Data->RefP[3] = pRefHV + 16*(x + y * pParam->edged_width);
3125    
3126          Data->currentMV[0].x = Data->currentMV[0].y = 0;          Data->currentMV[0].x = Data->currentMV[0].y = 0;
3127          CheckCandidate16I(0, 0, 255, &i, Data);          CheckCandidate16I(0, 0, Data, 255);
3128    
3129          if ( (Data->predMV.x !=0) || (Data->predMV.y != 0) )          if ( (Data->predMV.x !=0) || (Data->predMV.y != 0) )
3130                  CheckCandidate16I(Data->predMV.x, Data->predMV.y, 255, &i, Data);                  CheckCandidate16I(Data->predMV.x, Data->predMV.y, Data, 255);
3131    
3132          AdvDiamondSearch(Data->currentMV[0].x, Data->currentMV[0].y, Data, 255);          DiamondSearch(Data->currentMV[0].x, Data->currentMV[0].y, Data, 255, CheckCandidate16I);
3133    
3134          SubpelRefine(Data);          SubpelRefine(Data, CheckCandidate16I);
3135    
3136    
3137          /* for QPel halfpel positions are worse than in halfpel mode :( */          /* for QPel halfpel positions are worse than in halfpel mode :( */
# Line 2680  Line 3167 
3167    
3168          int32_t iMinSAD[5], temp[5];          int32_t iMinSAD[5], temp[5];
3169          VECTOR currentMV[5];          VECTOR currentMV[5];
3170            uint32_t dir;
3171          SearchData Data;          SearchData Data;
3172          memset(&Data, 0, sizeof(SearchData));          memset(&Data, 0, sizeof(SearchData));
3173    
# Line 2690  Line 3178 
3178          Data.iMinSAD = &iMinSAD[0];          Data.iMinSAD = &iMinSAD[0];
3179          Data.iFcode = current->fcode;          Data.iFcode = current->fcode;
3180          Data.temp = temp;          Data.temp = temp;
3181            Data.dir = &dir;
         CheckCandidate = CheckCandidate16I;  
3182    
3183          if (sadInit) (*sadInit) ();          if (sadInit) (*sadInit) ();
3184    
3185          for (y = 0; y < pParam->mb_height; y ++) {          for (y = 0; y < pParam->mb_height; y ++) {
3186                  for (x = 0; x < pParam->mb_width; x ++) {                  for (x = 0; x < pParam->mb_width; x ++) {
   
3187                          GMEanalyzeMB(pCurrent->y, pReference->y, pRefH->y, pRefV->y, pRefHV->y, x, y, pParam, pMBs, &Data);                          GMEanalyzeMB(pCurrent->y, pReference->y, pRefH->y, pRefV->y, pRefHV->y, x, y, pParam, pMBs, &Data);
3188                  }                  }
3189          }          }
Legend:
Removed from v.1129  
changed lines
  Added in v.1137
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4