[svn] / trunk / xvidcore / src / motion / estimation_bvop.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/motion/estimation_bvop.c

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

revision 1485, Sat Jul 10 17:42:18 2004 UTC revision 1567, Wed Dec 8 12:43:48 2004 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: estimation_bvop.c,v 1.9 2004-07-10 17:42:18 edgomez Exp $   * $Id: estimation_bvop.c,v 1.18 2004-12-08 12:43:48 syskin Exp $
25   *   *
26   ****************************************************************************/   ****************************************************************************/
27    
# Line 137  Line 137 
137                  xcb = xb/2; ycb = yb/2;                  xcb = xb/2; ycb = yb/2;
138          }          }
139    
140          t = d_mv_bits(xf, yf, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0)          t = d_mv_bits(xf, yf, data->predMV, data->iFcode, data->qpel^data->qpel_precision)
141                   + d_mv_bits(xb, yb, data->bpredMV, data->iFcode, data->qpel^data->qpel_precision, 0);                   + d_mv_bits(xb, yb, data->bpredMV, data->iFcode, data->qpel^data->qpel_precision);
142    
143          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
144          sad += (data->lambda16 * t * sad)>>10;          sad += (data->lambda16 * t * sad)>>10;
# Line 207  Line 207 
207                  if (sad > *(data->iMinSAD)) return;                  if (sad > *(data->iMinSAD)) return;
208          }          }
209    
210          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0) * sad)>>10;
211    
212          if (data->chroma && sad < *data->iMinSAD)          if (data->chroma && sad < *data->iMinSAD)
213                  sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],                  sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
# Line 265  Line 265 
265    
266  done:  done:
267          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
268          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0) * sad)>>10;
269    
270          if (data->chroma && sad < *data->iMinSAD)          if (data->chroma && sad < *data->iMinSAD)
271                  sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],                  sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
# Line 291  Line 291 
291          if ( (x > data->max_dx) || ( x < data->min_dx)          if ( (x > data->max_dx) || ( x < data->min_dx)
292                  || (y > data->max_dy) || (y < data->min_dy) ) return;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
293    
         if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; /* non-zero even value */  
   
294          if (data->qpel_precision) { /* x and y are in 1/4 precision */          if (data->qpel_precision) { /* x and y are in 1/4 precision */
295                  Reference = xvid_me_interpolate16x16qpel(x, y, 0, data);                  Reference = xvid_me_interpolate16x16qpel(x, y, 0, data);
296                  current = data->currentQMV;                  current = data->currentQMV;
# Line 303  Line 301 
301                  xc = x; yc = y;                  xc = x; yc = y;
302          }          }
303          t = d_mv_bits(x, y, data->predMV, data->iFcode,          t = d_mv_bits(x, y, data->predMV, data->iFcode,
304                                          data->qpel^data->qpel_precision, data->rrv);                                          data->qpel^data->qpel_precision);
305    
306          sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);          sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);
307          sad += (data->lambda16 * t * sad)>>10;          sad += (data->lambda16 * t * sad)>>10;
# Line 375  Line 373 
373          Data_d->CurU = Data_f->CurU = Data_b->CurU = Data_i->CurU = Cur[1];          Data_d->CurU = Data_f->CurU = Data_b->CurU = Data_i->CurU = Cur[1];
374          Data_d->CurV = Data_f->CurV = Data_b->CurV = Data_i->CurV = Cur[2];          Data_d->CurV = Data_f->CurV = Data_b->CurV = Data_i->CurV = Cur[2];
375    
376          Data_d->lambda16 = lambda/4;          Data_d->lambda16 = Data_f->lambda16 = Data_b->lambda16 = Data_i->lambda16 = lambda;
         Data_f->lambda16 = Data_b->lambda16 = Data_i->lambda16 = lambda;  
377    
378          /* reset chroma-sad cache */          /* reset chroma-sad cache */
379          Data_d->b_chromaX = Data_d->b_chromaY = Data_d->chromaX = Data_d->chromaY = Data_d->chromaSAD = 256*4096;          Data_d->b_chromaX = Data_d->b_chromaY = Data_d->chromaX = Data_d->chromaY = Data_d->chromaSAD = 256*4096;
# Line 401  Line 398 
398                                                          const uint32_t mode_curr,                                                          const uint32_t mode_curr,
399                                                          const VECTOR hint)                                                          const VECTOR hint)
400  {  {
   
401          /* [0] is prediction */          /* [0] is prediction */
402          pmv[0].x = (pmv[0].x); pmv[0].y = (pmv[0].y);          /* [1] is zero */
403            pmv[1].x = pmv[1].y = 0;
         pmv[1].x = pmv[1].y = 0; /* [1] is zero */  
404    
405          pmv[2].x = hint.x; pmv[2].y = hint.y;          pmv[2].x = hint.x; pmv[2].y = hint.y;
406    
# Line 448  Line 443 
443          Data->predMV = *predMV;          Data->predMV = *predMV;
444    
445          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,
446                                  pParam->width, pParam->height, iFcode - Data->qpel, 1, 0);                                  pParam->width, pParam->height, iFcode - Data->qpel, 1);
447    
448          pmv[0] = Data->predMV;          pmv[0] = Data->predMV;
449          if (Data->qpel) {          if (Data->qpel) {
# Line 495  Line 490 
490                  if(MotionFlags & XVID_ME_FASTREFINE16) {                  if(MotionFlags & XVID_ME_FASTREFINE16) {
491                          /* fast */                          /* fast */
492                          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,
493                                                  pParam->width, pParam->height, Data->iFcode, 2, 0);                                                  pParam->width, pParam->height, Data->iFcode, 2);
494                          FullRefine_Fast(Data, CheckCandidate16no4v, 0);                          FullRefine_Fast(Data, CheckCandidate16no4v, 0);
495    
496                  } else {                  } else {
# Line 510  Line 505 
505                                          Data->currentQMV->y = 2*Data->currentMV->y;                                          Data->currentQMV->y = 2*Data->currentMV->y;
506                                  }                                  }
507                                  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,
508                                                          pParam->width, pParam->height, Data->iFcode, 2, 0);                                                          pParam->width, pParam->height, Data->iFcode, 2);
509                                  Data->qpel_precision = 1;                                  Data->qpel_precision = 1;
510                                  xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate16no4v, 0); /* qpel part */                                  xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate16no4v, 0); /* qpel part */
511                          }                          }
# Line 525  Line 520 
520  {  {
521          int k;          int k;
522    
         pMB->mode = MODE_DIRECT; /* just to initialize it */  
   
523          if (!Data->chroma) {          if (!Data->chroma) {
524                  int dx = 0, dy = 0, b_dx = 0, b_dy = 0;                  int dx = 0, dy = 0, b_dx = 0, b_dy = 0;
525                  int32_t sum;                  int32_t sum;
# Line 546  Line 539 
539                  b_dx = (b_dx >> 3) + roundtab_76[b_dx & 0xf];                  b_dx = (b_dx >> 3) + roundtab_76[b_dx & 0xf];
540    
541                  sum = sad8bi(Data->CurU,                  sum = sad8bi(Data->CurU,
542                                                  Data->RefP[4] + (dy/2) * stride + dx/2,                                                  Data->RefP[4] + (dy/2) * (int)stride + dx/2,
543                                                  Data->b_RefP[4] + (b_dy/2) * stride + b_dx/2,                                                  Data->b_RefP[4] + (b_dy/2) * (int)stride + b_dx/2,
544                                                  stride);                                                  stride);
545    
546                  if (sum >= MAX_CHROMA_SAD_FOR_SKIP * (int)Data->iQuant) return; /* no skip */                  if (sum >= MAX_CHROMA_SAD_FOR_SKIP * (int)Data->iQuant) return; /* no skip */
547    
548                  sum += sad8bi(Data->CurV,                  sum += sad8bi(Data->CurV,
549                                                  Data->RefP[5] + (dy/2) * stride + dx/2,                                                  Data->RefP[5] + (dy/2) * (int)stride + dx/2,
550                                                  Data->b_RefP[5] + (b_dy/2) * stride + b_dx/2,                                                  Data->b_RefP[5] + (b_dy/2) * (int)stride + b_dx/2,
551                                                  stride);                                                  stride);
552    
553                  if (sum >= MAX_CHROMA_SAD_FOR_SKIP * (int)Data->iQuant) return; /* no skip */                  if (sum >= MAX_CHROMA_SAD_FOR_SKIP * (int)Data->iQuant) return; /* no skip */
# Line 569  Line 562 
562          for (k = 0; k < 4; k++) {          for (k = 0; k < 4; k++) {
563                  pMB->qmvs[k] = pMB->mvs[k] = Data->directmvF[k];                  pMB->qmvs[k] = pMB->mvs[k] = Data->directmvF[k];
564                  pMB->b_qmvs[k] = pMB->b_mvs[k] =  Data->directmvB[k];                  pMB->b_qmvs[k] = pMB->b_mvs[k] =  Data->directmvB[k];
565                    if (Data->qpel) {
566                            pMB->mvs[k].x /= 2; pMB->mvs[k].y /= 2; /* it's a hint for future searches */
567                            pMB->b_mvs[k].x /= 2; pMB->b_mvs[k].y /= 2;
568                    }
569          }          }
570  }  }
571    
# Line 617  Line 614 
614    
615          CheckCandidateDirect(0, 0, Data, 255);  /* will also fill iMinSAD[1..4] with 8x8 SADs */          CheckCandidateDirect(0, 0, Data, 255);  /* will also fill iMinSAD[1..4] with 8x8 SADs */
616    
   
617          /* initial (fast) skip decision */          /* initial (fast) skip decision */
618          if (Data->iMinSAD[1] < (int)Data->iQuant * INITIAL_SKIP_THRESH          if (Data->iMinSAD[1] < (int)Data->iQuant * INITIAL_SKIP_THRESH
619                  && Data->iMinSAD[2] < (int)Data->iQuant * INITIAL_SKIP_THRESH                  && Data->iMinSAD[2] < (int)Data->iQuant * INITIAL_SKIP_THRESH
# Line 629  Line 625 
625                          return *Data->iMinSAD; /* skipped */                          return *Data->iMinSAD; /* skipped */
626          }          }
627    
628            if (Data->chroma && Data->chromaSAD >= MAX_CHROMA_SAD_FOR_SKIP * (int)Data->iQuant) /* chroma doesn't allow skip */
629                    skip_sad = 256*4096;
630            else
631          skip_sad = 4*MAX(MAX(Data->iMinSAD[1],Data->iMinSAD[2]), MAX(Data->iMinSAD[3],Data->iMinSAD[4]));          skip_sad = 4*MAX(MAX(Data->iMinSAD[1],Data->iMinSAD[2]), MAX(Data->iMinSAD[3],Data->iMinSAD[4]));
         if (Data->chroma) skip_sad += Data->chromaSAD;  
632    
633          Data->currentMV[1].x = Data->directmvF[0].x + Data->currentMV->x; /* hints for forward and backward searches */          Data->currentMV[1].x = Data->directmvF[0].x + Data->currentMV->x; /* hints for forward and backward searches */
634          Data->currentMV[1].y = Data->directmvF[0].y + Data->currentMV->y;          Data->currentMV[1].y = Data->directmvF[0].y + Data->currentMV->y;
# Line 643  Line 641 
641                          Data->directmvB[0].y                          Data->directmvB[0].y
642                          : Data->currentMV[1].y - Data->referencemv[0].y);                          : Data->currentMV[1].y - Data->referencemv[0].y);
643    
644            *best_sad = Data->iMinSAD[0];
645    
646          return skip_sad;          return skip_sad;
647  }  }
648    
# Line 711  Line 711 
711          Data->currentMV[0] = startF;          Data->currentMV[0] = startF;
712          Data->currentMV[1] = startB;          Data->currentMV[1] = startB;
713    
714          get_range(f_range, f_range+1, f_range+2, f_range+3, x, y, 4, pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, 0);          get_range(f_range, f_range+1, f_range+2, f_range+3, x, y, 4, pParam->width, pParam->height, Data->iFcode - Data->qpel, 1);
715          get_range(b_range, b_range+1, b_range+2, b_range+3, x, y, 4, pParam->width, pParam->height, Data->bFcode - Data->qpel, 1, 0);          get_range(b_range, b_range+1, b_range+2, b_range+3, x, y, 4, pParam->width, pParam->height, Data->bFcode - Data->qpel, 1);
716    
717          if (Data->currentMV[0].x > f_range[1]) Data->currentMV[0].x = f_range[1];          if (Data->currentMV[0].x > f_range[1]) Data->currentMV[0].x = f_range[1];
718          if (Data->currentMV[0].x < f_range[0]) Data->currentMV[0].x = f_range[0];          if (Data->currentMV[0].x < f_range[0]) Data->currentMV[0].x = f_range[0];
# Line 741  Line 741 
741          int i, j;          int i, j;
742          int b_range[4], f_range[4];          int b_range[4], f_range[4];
743    
744          get_range(f_range, f_range+1, f_range+2, f_range+3, x, y, 4, pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, 0);          get_range(f_range, f_range+1, f_range+2, f_range+3, x, y, 4, pParam->width, pParam->height, Data->iFcode - Data->qpel, 1);
745          get_range(b_range, b_range+1, b_range+2, b_range+3, x, y, 4, pParam->width, pParam->height, Data->bFcode - Data->qpel, 1, 0);          get_range(b_range, b_range+1, b_range+2, b_range+3, x, y, 4, pParam->width, pParam->height, Data->bFcode - Data->qpel, 1);
746    
747          /* diamond */          /* diamond */
748          do {          do {
# Line 772  Line 772 
772          if (Data->qpel) {          if (Data->qpel) {
773                  Data->qpel_precision = 1;                  Data->qpel_precision = 1;
774                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy,                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy,
775                          x, y, 4, pParam->width, pParam->height, Data->iFcode, 2, 0);                          x, y, 4, pParam->width, pParam->height, Data->iFcode, 2);
776    
777                  Data->currentQMV[0].x = 2 * Data->currentMV[0].x;                  Data->currentQMV[0].x = 2 * Data->currentMV[0].x;
778                  Data->currentQMV[0].y = 2 * Data->currentMV[0].y;                  Data->currentQMV[0].y = 2 * Data->currentMV[0].y;
# Line 783  Line 783 
783                          xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidateInt, 1);                          xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidateInt, 1);
784    
785                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy,                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy,
786                                  x, y, 4, pParam->width, pParam->height, Data->bFcode, 2, 0);                                  x, y, 4, pParam->width, pParam->height, Data->bFcode, 2);
787    
788                          xvid_me_SubpelRefine(Data->currentQMV[1], Data, CheckCandidateInt, 2);                          xvid_me_SubpelRefine(Data->currentQMV[1], Data, CheckCandidateInt, 2);
789                  }                  }
# Line 875  Line 875 
875                          *f_predMV = Data_f->currentMV[0];                          *f_predMV = Data_f->currentMV[0];
876                  }                  }
877                  pMB->mvs[0] = *Data_f->currentMV;                  pMB->mvs[0] = *Data_f->currentMV;
878                    pMB->b_mvs[0] = *Data_b->currentMV; /* hint for future searches */
879                  break;                  break;
880    
881          case MODE_BACKWARD:          case MODE_BACKWARD:
# Line 889  Line 890 
890                          *b_predMV = Data_b->currentMV[0];                          *b_predMV = Data_b->currentMV[0];
891                  }                  }
892                  pMB->b_mvs[0] = *Data_b->currentMV;                  pMB->b_mvs[0] = *Data_b->currentMV;
893                    pMB->mvs[0] = *Data_f->currentMV; /* hint for future searches */
894                  break;                  break;
895    
896    
# Line 916  Line 918 
918          }          }
919  }  }
920    
921    static __inline void
922    maxMotionBVOP(int * const MVmaxF, int * const MVmaxB, const MACROBLOCK * const pMB, const int qpel)
923    {
924            if (pMB->mode == MODE_FORWARD || pMB->mode == MODE_INTERPOLATE) {
925                    const VECTOR * const mv = qpel ? pMB->qmvs : pMB->mvs;
926                    int max = *MVmaxF;
927                    if (mv[0].x > max) max = mv[0].x;
928                    else if (-mv[0].x - 1 > max) max = -mv[0].x - 1;
929                    if (mv[0].y > max) max = mv[0].y;
930                    else if (-mv[0].y - 1 > max) max = -mv[0].y - 1;
931    
932                    *MVmaxF = max;
933            }
934    
935            if (pMB->mode == MODE_BACKWARD || pMB->mode == MODE_INTERPOLATE) {
936                    const VECTOR * const mv = qpel ? pMB->b_qmvs : pMB->b_mvs;
937                    int max = *MVmaxB;
938                    if (mv[0].x > max) max = mv[0].x;
939                    else if (-mv[0].x - 1 > max) max = -mv[0].x - 1;
940                    if (mv[0].y > max) max = mv[0].y;
941                    else if (-mv[0].y - 1 > max) max = -mv[0].y - 1;
942                    *MVmaxB = max;
943            }
944    }
945    
946    
947  void  void
948  MotionEstimationBVOP(MBParam * const pParam,  MotionEstimationBVOP(MBParam * const pParam,
949                                           FRAMEINFO * const frame,                                           FRAMEINFO * const frame,
# Line 935  Line 963 
963                                           const IMAGE * const b_refHV)                                           const IMAGE * const b_refHV)
964  {  {
965          uint32_t i, j;          uint32_t i, j;
966          int32_t best_sad, sad2;          int32_t best_sad = 256*4096;
967            int32_t sad2;
968          uint32_t skip_sad;          uint32_t skip_sad;
969    
970          const MACROBLOCK * const b_mbs = b_reference->mbs;          const MACROBLOCK * const b_mbs = b_reference->mbs;
971    
972          VECTOR f_predMV, b_predMV;          VECTOR f_predMV, b_predMV;
973    
974            int MVmaxF = 0, MVmaxB = 0;
975          const int32_t TRB = time_pp - time_bp;          const int32_t TRB = time_pp - time_bp;
976          const int32_t TRD = time_pp;          const int32_t TRD = time_pp;
977            DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);
978    
979          /* some pre-inintialized data for the rest of the search */          /* some pre-inintialized data for the rest of the search */
980          SearchData Data_d, Data_f, Data_b, Data_i;          SearchData Data_d, Data_f, Data_b, Data_i;
# Line 954  Line 985 
985          Data_d.rounding = 0;          Data_d.rounding = 0;
986          Data_d.chroma = frame->motion_flags & XVID_ME_CHROMA_BVOP;          Data_d.chroma = frame->motion_flags & XVID_ME_CHROMA_BVOP;
987          Data_d.iQuant = frame->quant;          Data_d.iQuant = frame->quant;
988            Data_d.dctSpace = dct_space;
989            Data_d.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT);
990            Data_d.mpeg_quant_matrices = pParam->mpeg_quant_matrices;
991    
992          Data_d.RefQ = f_refV->u; /* a good place, also used in MC (for similar purpose) */          Data_d.RefQ = f_refV->u; /* a good place, also used in MC (for similar purpose) */
993    
# Line 961  Line 995 
995          memcpy(&Data_b, &Data_d, sizeof(SearchData));          memcpy(&Data_b, &Data_d, sizeof(SearchData));
996          memcpy(&Data_i, &Data_d, sizeof(SearchData));          memcpy(&Data_i, &Data_d, sizeof(SearchData));
997    
998          Data_f.iFcode = Data_i.iFcode = frame->fcode;          Data_f.iFcode = Data_i.iFcode = frame->fcode = b_reference->fcode;
999          Data_b.iFcode = Data_i.bFcode = frame->bcode;          Data_b.iFcode = Data_i.bFcode = frame->bcode = b_reference->fcode;
   
1000    
1001          for (j = 0; j < pParam->mb_height; j++) {          for (j = 0; j < pParam->mb_height; j++) {
1002    
# Line 1006  Line 1039 
1039    
1040                          sad2 = best_sad;                          sad2 = best_sad;
1041    
1042                          if (Data_f.iMinSAD[0] < 2*sad2+1500)                          if (Data_f.iMinSAD[0] < 2*sad2+2000)
1043                                  SearchBF_final(i, j, frame->motion_flags, pParam, &best_sad, &Data_f);                                  SearchBF_final(i, j, frame->motion_flags, pParam, &best_sad, &Data_f);
1044    
1045                          if (Data_b.iMinSAD[0] < 2*sad2+1500)                          if (Data_b.iMinSAD[0] < 2*sad2+2000)
1046                                  SearchBF_final(i, j, frame->motion_flags, pParam, &best_sad, &Data_b);                                  SearchBF_final(i, j, frame->motion_flags, pParam, &best_sad, &Data_b);
1047    
1048                          SearchInterpolate_initial(i, j, frame->motion_flags, pParam, &f_predMV, &b_predMV, &best_sad,                          SearchInterpolate_initial(i, j, frame->motion_flags, pParam, &f_predMV, &b_predMV, &best_sad,
# Line 1020  Line 1053 
1053    
1054                                  SearchInterpolate_final(i, j, frame->motion_flags, pParam, &best_sad, &Data_i);                                  SearchInterpolate_final(i, j, frame->motion_flags, pParam, &best_sad, &Data_i);
1055    
1056                            if ((Data_d.iMinSAD[0] <= 2*best_sad) && (!frame->motion_flags&XVID_ME_SKIP_DELTASEARCH))
                         if ((Data_d.iMinSAD[0] <= best_sad) && (!(frame->motion_flags&XVID_ME_SKIP_DELTASEARCH)))  
1057                                  SearchDirect_final(frame->motion_flags, b_mb, &best_sad, &Data_d);                                  SearchDirect_final(frame->motion_flags, b_mb, &best_sad, &Data_d);
1058    
   
1059                          /* final skip decision */                          /* final skip decision */
1060                          if ( (skip_sad < Data_d.iQuant * MAX_SAD00_FOR_SKIP )                          if ( (skip_sad < 2 * Data_d.iQuant * MAX_SAD00_FOR_SKIP )
1061                                  && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) ) {                                  && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) ) {
1062    
1063                                    Data_d.chromaSAD = 0; /* green light for chroma check */
1064    
1065                                  SkipDecisionB(pMB, &Data_d);                                  SkipDecisionB(pMB, &Data_d);
1066    
1067                                  if (pMB->mode == MODE_DIRECT_NONE_MV) { /* skipped? */                                  if (pMB->mode == MODE_DIRECT_NONE_MV) { /* skipped? */
1068                                          pMB->sad16 = best_sad;                                          pMB->sad16 = skip_sad;
1069                                          continue;                                          continue;
1070                                  }                                  }
1071                          }                          }
1072    
1073                            if (frame->vop_flags & XVID_VOP_RD_BVOP)
1074                                    ModeDecision_BVOP_RD(&Data_d, &Data_b, &Data_f, &Data_i,
1075                                            pMB, b_mb, &f_predMV, &b_predMV, frame->motion_flags, pParam, i, j);
1076                            else
1077                          ModeDecision_BVOP_SAD(&Data_d, &Data_b, &Data_f, &Data_i, pMB, b_mb, &f_predMV, &b_predMV);                          ModeDecision_BVOP_SAD(&Data_d, &Data_b, &Data_f, &Data_i, pMB, b_mb, &f_predMV, &b_predMV);
1078    
1079                            maxMotionBVOP(&MVmaxF, &MVmaxB, pMB, Data_d.qpel);
1080    
1081                  }                  }
1082          }          }
1083    
1084            frame->fcode = getMinFcode(MVmaxF);
1085            frame->bcode = getMinFcode(MVmaxB);
1086  }  }
Legend:
Removed from v.1485  
changed lines
  Added in v.1567
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4