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

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

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

revision 1687, Sat Feb 25 01:20:41 2006 UTC revision 1928, Tue Dec 28 19:19:57 2010 UTC
# Line 4  Line 4 
4   *  - Motion Estimation for P- and S- VOPs  -   *  - Motion Estimation for P- and S- VOPs  -
5   *   *
6   *  Copyright(C) 2002 Christoph Lampert <gruel@web.de>   *  Copyright(C) 2002 Christoph Lampert <gruel@web.de>
7   *               2002 Michael Militzer <michael@xvid.org>   *               2002-2010 Michael Militzer <michael@xvid.org>
8   *               2002-2003 Radoslaw Czyz <xvid@syskin.cjb.net>   *               2002-2003 Radoslaw Czyz <xvid@syskin.cjb.net>
9   *   *
10   *  This program is free software ; you can redistribute it and/or modify   *  This program is free software ; you can redistribute it and/or modify
# 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_pvop.c,v 1.20 2006-02-25 01:20:41 syskin Exp $   * $Id: estimation_pvop.c,v 1.25 2010-12-28 19:19:43 Isibaar Exp $
25   *   *
26   ****************************************************************************/   ****************************************************************************/
27    
# Line 296  Line 296 
296    
297          /* final skip decision, a.k.a. "the vector you found, really that good?" */          /* final skip decision, a.k.a. "the vector you found, really that good?" */
298          if (skip_possible && (skip_sad < (int)iQuant * MAX_SAD00_FOR_SKIP))          if (skip_possible && (skip_sad < (int)iQuant * MAX_SAD00_FOR_SKIP))
299                  if ( (100*skip_sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH)                  if ( (100*skip_sad)/(pMB->sad16+1) < FINAL_SKIP_THRESH)
300                          if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant)) {                          if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant)) {
301                                  mode = MODE_NOT_CODED;                                  mode = MODE_NOT_CODED;
302                                  sad = 0;                                  sad = 0;
# Line 407  Line 407 
407                  MACROBLOCK * const pMB,                  MACROBLOCK * const pMB,
408                  const MACROBLOCK * const pMBs,                  const MACROBLOCK * const pMBs,
409                  const int block,                  const int block,
410                  SearchData * const Data)                  SearchData * const Data,
411                    const int bound)
412  {  {
413          int i = 0;          int i = 0;
414          VECTOR vbest_q; int32_t sbest_q;          VECTOR vbest_q; int32_t sbest_q;
# Line 416  Line 417 
417          *Data->currentQMV = *(OldData->currentQMV + 1 + block);          *Data->currentQMV = *(OldData->currentQMV + 1 + block);
418    
419          if(Data->qpel) {          if(Data->qpel) {
420                  Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);                  Data->predMV = get_qpmv2(pMBs, pParam->mb_width, bound, x/2, y/2, block);
421                  if (block != 0) i = d_mv_bits(  Data->currentQMV->x, Data->currentQMV->y,                  if (block != 0) i = d_mv_bits(  Data->currentQMV->x, Data->currentQMV->y,
422                                                                                  Data->predMV, Data->iFcode, 0);                                                                                  Data->predMV, Data->iFcode, 0);
423          } else {          } else {
424                  Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);                  Data->predMV = get_pmv2(pMBs, pParam->mb_width, bound, x/2, y/2, block);
425                  if (block != 0) i = d_mv_bits(  Data->currentMV->x, Data->currentMV->y,                  if (block != 0) i = d_mv_bits(  Data->currentMV->x, Data->currentMV->y,
426                                                                                  Data->predMV, Data->iFcode, 0);                                                                                  Data->predMV, Data->iFcode, 0);
427          }          }
# Line 523  Line 524 
524                  const MBParam * const pParam,                  const MBParam * const pParam,
525                  const MACROBLOCK * const pMBs,                  const MACROBLOCK * const pMBs,
526                  const MACROBLOCK * const prevMBs,                  const MACROBLOCK * const prevMBs,
527                  MACROBLOCK * const pMB)                  MACROBLOCK * const pMB,
528                    const int bound)
529  {  {
530    
531          int i, threshA;          int i, threshA;
# Line 534  Line 536 
536          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,
537                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1);                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1);
538    
539          get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, pmv, Data->temp);          get_pmvdata2(pMBs, pParam->mb_width, bound, x, y, pmv, Data->temp);
540    
541          Data->chromaX = Data->chromaY = 0; /* chroma-sad cache */          Data->chromaX = Data->chromaY = 0; /* chroma-sad cache */
542          Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16;          Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16;
# Line 555  Line 557 
557    
558          memset(Data->currentMV, 0, 5*sizeof(VECTOR));          memset(Data->currentMV, 0, 5*sizeof(VECTOR));
559    
560          if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0);          if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, bound, x, y, 0);
561          else Data->predMV = pmv[0];          else Data->predMV = pmv[0];
562    
563          i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0);          i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0);
# Line 681  Line 683 
683                  SearchData Data8;                  SearchData Data8;
684                  memcpy(&Data8, Data, sizeof(SearchData)); /* quick copy of common data */                  memcpy(&Data8, Data, sizeof(SearchData)); /* quick copy of common data */
685    
686                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8);                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8, bound);
687                  Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8);                  Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8, bound);
688                  Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8);                  Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8, bound);
689                  Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);                  Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8, bound);
690    
691                  if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_RD))) {                  if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_RD))) {
692                          /* chroma is only used for comparison to INTER. if the comparison will be done in RD domain, it will not be used */                          /* chroma is only used for comparison to INTER. if the comparison will be done in RD domain, it will not be used */
# Line 718  Line 720 
720                                           const IMAGE * const pGMC,                                           const IMAGE * const pGMC,
721                                           const IMAGE * const pCurrent,                                           const IMAGE * const pCurrent,
722                                           const IMAGE * const pRef,                                           const IMAGE * const pRef,
723                                           const uint32_t MotionFlags)                                           const uint32_t MotionFlags,
724                                             const int bound)
725  {  {
726          const unsigned int iEdgedWidth = pParam->edged_width;          const unsigned int iEdgedWidth = pParam->edged_width;
727    
# Line 746  Line 749 
749                  else                  else
750                          cmpMV = &staticMV;                          cmpMV = &staticMV;
751    
752                  if(x > 0 && y > 0 && x < pParam->mb_width) {                  if(x > 0 && y > 0 && x < (int) pParam->mb_width) {
753                          if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], *cmpMV) &&                          if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], *cmpMV) &&
754                             MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&                             MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&
755                             MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&                             MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&
# Line 792  Line 795 
795                  else if (sad00 < stat_thresh) {                  else if (sad00 < stat_thresh) {
796                          VECTOR predMV;                          VECTOR predMV;
797                          if (Data->qpel)                          if (Data->qpel)
798                                  predMV = get_qpmv2(current->mbs, pParam->mb_width, 0, x, y, 0);                                  predMV = get_qpmv2(current->mbs, pParam->mb_width, bound, x, y, 0);
799                          else                          else
800                                  predMV = get_pmv2(current->mbs, pParam->mb_width, 0, x, y, 0);                                  predMV = get_pmv2(current->mbs, pParam->mb_width, bound, x, y, 0);
801    
802                          ZeroMacroblockP(pMB, sad00);                          ZeroMacroblockP(pMB, sad00);
803                          pMB->cbp = 0x3f;                          pMB->cbp = 0x3f;
# Line 894  Line 897 
897                                   const IMAGE * const pRefV,                                   const IMAGE * const pRefV,
898                                   const IMAGE * const pRefHV,                                   const IMAGE * const pRefHV,
899                                   const IMAGE * const pGMC,                                   const IMAGE * const pGMC,
900                                   const uint32_t iLimit)                                   const uint32_t iLimit,
901                                     const int num_slices)
902  {  {
903          MACROBLOCK *const pMBs = current->mbs;          MACROBLOCK *const pMBs = current->mbs;
904          const IMAGE *const pCurrent = &current->image;          const IMAGE *const pCurrent = &current->image;
# Line 904  Line 908 
908          const uint32_t mb_height = pParam->mb_height;          const uint32_t mb_height = pParam->mb_height;
909          const uint32_t iEdgedWidth = pParam->edged_width;          const uint32_t iEdgedWidth = pParam->edged_width;
910          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);
911          int stat_thresh = 0;          int bound = 0;
912          int MVmax = 0, mvSum = 0, mvCount = 0;          int MVmax = 0, mvSum = 0, mvCount = 0;
913    
914          uint32_t x, y;          uint32_t x, y;
915          int sad00;          int sad00;
         int skip_thresh = INITIAL_SKIP_THRESH * \  
                 (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);  
916          int block = 0;          int block = 0;
917    
918          /* some pre-initialized thingies for SearchP */          /* some pre-initialized thingies for SearchP */
# Line 930  Line 932 
932          if (sadInit) (*sadInit) ();          if (sadInit) (*sadInit) ();
933    
934          for (y = 0; y < mb_height; y++) {          for (y = 0; y < mb_height; y++) {
935    
936                    bound = mb_width * ((((y*num_slices) / mb_height) * mb_height + (num_slices-1)) / num_slices);
937    
938                  for (x = 0; x < mb_width; x++)  {                  for (x = 0; x < mb_width; x++)  {
939                          MACROBLOCK *pMB = &pMBs[block];                          MACROBLOCK *pMB = &pMBs[block];
940                          MACROBLOCK *prevMB = &reference->mbs[block];                          MACROBLOCK *prevMB = &reference->mbs[block];
# Line 953  Line 958 
958                          }                          }
959    
960                          skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC,                          skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC,
961                                                                                  pCurrent, pRef, MotionFlags);                                                                                  pCurrent, pRef, MotionFlags, bound);
962                          if (skip) continue;                          if (skip) continue;
963    
964                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,
965                                          y, MotionFlags, current->vop_flags,                                          y, MotionFlags, current->vop_flags,
966                                          &Data, pParam, pMBs, reference->mbs, pMB);                                          &Data, pParam, pMBs, reference->mbs, pMB, bound);
967    
968                          if (current->vop_flags & XVID_VOP_MODEDECISION_RD)                          if (current->vop_flags & XVID_VOP_MODEDECISION_RD)
969                                  xvid_me_ModeDecision_RD(&Data, pMB, pMBs, x, y, pParam,                                  xvid_me_ModeDecision_RD(&Data, pMB, pMBs, x, y, pParam,
970                                                                  MotionFlags, current->vop_flags, current->vol_flags,                                                                  MotionFlags, current->vop_flags, current->vol_flags,
971                                                                  pCurrent, pRef, pGMC, current->coding_type);                                                                  pCurrent, pRef, pGMC, current->coding_type, bound);
972    
973                          else if (current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD)                          else if (current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD)
974                                  xvid_me_ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam,                                  xvid_me_ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam,
975                                                                  MotionFlags, current->vop_flags, current->vol_flags,                                                                  MotionFlags, current->vop_flags, current->vol_flags,
976                                                                  pCurrent, pRef, pGMC, current->coding_type);                                                                  pCurrent, pRef, pGMC, current->coding_type, bound);
977                          else                          else
978                                  ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam,                                  ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam,
979                                                                  MotionFlags, current->vop_flags, current->vol_flags,                                                                  MotionFlags, current->vop_flags, current->vol_flags,
# Line 985  Line 990 
990  }  }
991    
992  void  void
993  MotionEstimateSMP(SMPmotionData * h)  MotionEstimateSMP(SMPData * h)
994  {  {
995          const MBParam * const pParam = h->pParam;          Encoder *pEnc = (Encoder *) h->pEnc;
996          const FRAMEINFO * const current = h->current;  
997          const FRAMEINFO * const reference = h->reference;          const MBParam * const pParam = &pEnc->mbParam;
998          const IMAGE * const pRefH = h->pRefH;          const FRAMEINFO * const current = pEnc->current;
999          const IMAGE * const pRefV = h->pRefV;          const FRAMEINFO * const reference = pEnc->reference;
1000          const IMAGE * const pRefHV = h->pRefHV;          const IMAGE * const pRefH = &pEnc->vInterH;
1001          const IMAGE * const pGMC = h->pGMC;          const IMAGE * const pRefV = &pEnc->vInterV;
1002            const IMAGE * const pRefHV = &pEnc->vInterHV;
1003            const IMAGE * const pGMC = &pEnc->vGMC;
1004          uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags,          uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags,
1005                                                                                                  current->vop_flags,                                                                                                  current->vop_flags,
1006                                                                                                  current->vol_flags);                                                                                                  current->vol_flags);
# Line 1002  Line 1009 
1009          const IMAGE *const pCurrent = &current->image;          const IMAGE *const pCurrent = &current->image;
1010          const IMAGE *const pRef = &reference->image;          const IMAGE *const pRef = &reference->image;
1011    
1012          const uint32_t mb_width = pParam->mb_width;          const int mb_width = pParam->mb_width;
1013          const uint32_t mb_height = pParam->mb_height;          const int mb_height = pParam->mb_height;
1014          const uint32_t iEdgedWidth = pParam->edged_width;          const uint32_t iEdgedWidth = pParam->edged_width;
1015          int stat_thresh = 0;          int bound = 0;
1016          int MVmax = 0, mvSum = 0, mvCount = 0;          int num_slices = pEnc->num_slices;
1017          int y_step = h->y_step;          int y_step = h->y_step;
1018            int y_row = h->y_row;
1019          int start_y = h->start_y;          int start_y = h->start_y;
1020            int stop_y = h->stop_y;
1021            int MVmax = 0, mvSum = 0, mvCount = 0;
1022    
1023          uint32_t x, y;          int x, y;
1024          int sad00;          int sad00;
1025          int skip_thresh = INITIAL_SKIP_THRESH * \          int block = (start_y+y_row)*mb_width;
                 (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);  
         int block = start_y*mb_width;  
1026          int * complete_count_self = h->complete_count_self;          int * complete_count_self = h->complete_count_self;
1027          const int * complete_count_above = h->complete_count_above;          const volatile int * complete_count_above = h->complete_count_above;
1028          int max_mbs;          int max_mbs;
1029          int current_mb = 0;          int current_mb = 0;
1030    
# Line 1039  Line 1047 
1047    
1048          max_mbs = 0;          max_mbs = 0;
1049    
1050          for (y = start_y; y < mb_height; y += y_step)   {          for (y = (start_y + y_row); y < stop_y; y += y_step)    {
1051                  if (y == 0) max_mbs = mb_width; /* we can process all blocks of the first row */                  bound = mb_width * ((((y*num_slices) / mb_height) * mb_height + (num_slices-1)) / num_slices);
1052    
1053                    if (y == start_y) max_mbs = mb_width; /* we can process all blocks of the first row */
1054    
1055                  for (x = 0; x < mb_width; x++)  {                  for (x = 0; x < mb_width; x++)  {
1056    
1057                          MACROBLOCK *pMB, *prevMB;                          MACROBLOCK *pMB, *prevMB;
1058                          int skip;                          int skip;
1059    
                         pMB = &pMBs[block];  
                         prevMB = &reference->mbs[block];  
   
                         pMB->sad16 =  
                                 sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,  
                                                         pRef->y + (x + y * iEdgedWidth) * 16,  
                                                         pParam->edged_width, pMB->sad8);  
   
                         sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3]));  
   
                         if (Data.chroma) {  
                                 Data.chromaSAD = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8,  
                                                                         pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2)  
                                                                 + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8,  
                                                                         pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2);  
                                 pMB->sad16 += Data.chromaSAD;  
                                 sad00 += Data.chromaSAD;  
                         }  
   
1060                          if (current_mb >= max_mbs) {                          if (current_mb >= max_mbs) {
1061                                  /* we ME-ed all macroblocks we safely could. grab next portion */                                  /* we ME-ed all macroblocks we safely could. grab next portion */
1062                                  int above_count = *complete_count_above; /* sync point */                                  int above_count = *complete_count_above; /* sync point */
1063                                  if (above_count == mb_width) {                                  if (above_count == mb_width) {
1064                                          /* full line above is ready */                                          /* full line above is ready */
1065                                          above_count = mb_width+1;                                          above_count = mb_width+1;
1066                                          if (y < mb_height-y_step) {                                          if (y < (stop_y-y_step)) {
1067                                                  /* this is not last line, grab a portion of MBs from the next line too */                                                  /* this is not last line, grab a portion of MBs from the next line too */
1068                                                  above_count += MAX(0, complete_count_above[1] - 1);                                                  above_count += MAX(0, complete_count_above[1] - 1);
1069                                          }                                          }
# Line 1088  Line 1079 
1079                                  }                                  }
1080                          }                          }
1081    
1082                          skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC,                          pMB = &pMBs[block];
1083                                                                                  pCurrent, pRef, MotionFlags);                          prevMB = &reference->mbs[block];
                         if (current_mb >= max_mbs) {  
                                 /* we ME-ed all macroblocks we safely could. grab next portion */  
                                 int above_count = *complete_count_above; /* sync point */  
                                 if (above_count == mb_width) {  
                                         /* full line above is ready */  
                                         above_count = mb_width+1;  
                                         if (y < mb_height-y_step) {  
                                                 /* this is not last line, grab a portion of MBs from the next line too */  
                                                 above_count += MAX(0, complete_count_above[1] - 1);  
                                         }  
                                 }  
1084    
1085                                  max_mbs = current_mb + above_count - x - 1;                          pMB->sad16 =
1086                                    sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,
1087                                                            pRef->y + (x + y * iEdgedWidth) * 16,
1088                                                            pParam->edged_width, pMB->sad8);
1089    
1090                                  if (current_mb >= max_mbs) {                          sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3]));
1091                                          /* current workload is zero */  
1092                                          x--;                          if (Data.chroma) {
1093                                          sched_yield();                                  Data.chromaSAD = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8,
1094                                          continue;                                                                          pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2)
1095                                  }                                                                  + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8,
1096                                                                            pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2);
1097                                    pMB->sad16 += Data.chromaSAD;
1098                                    sad00 += Data.chromaSAD;
1099                          }                          }
1100    
1101                            skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC,
1102                                                                                    pCurrent, pRef, MotionFlags, bound);
1103    
1104                          if (skip) {                          if (skip) {
1105                                  current_mb++;                                  current_mb++;
1106                                  block++;                                  block++;
# Line 1121  Line 1110 
1110    
1111                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,
1112                                          y, MotionFlags, current->vop_flags,                                          y, MotionFlags, current->vop_flags,
1113                                          &Data, pParam, pMBs, reference->mbs, pMB);                                          &Data, pParam, pMBs, reference->mbs, pMB, bound);
1114    
1115                          if (current->vop_flags & XVID_VOP_MODEDECISION_RD)                          if (current->vop_flags & XVID_VOP_MODEDECISION_RD)
1116                                  xvid_me_ModeDecision_RD(&Data, pMB, pMBs, x, y, pParam,                                  xvid_me_ModeDecision_RD(&Data, pMB, pMBs, x, y, pParam,
1117                                                                  MotionFlags, current->vop_flags, current->vol_flags,                                                                  MotionFlags, current->vop_flags, current->vol_flags,
1118                                                                  pCurrent, pRef, pGMC, current->coding_type);                                                                  pCurrent, pRef, pGMC, current->coding_type, bound);
1119    
1120                          else if (current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD)                          else if (current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD)
1121                                  xvid_me_ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam,                                  xvid_me_ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam,
1122                                                                  MotionFlags, current->vop_flags, current->vol_flags,                                                                  MotionFlags, current->vop_flags, current->vol_flags,
1123                                                                  pCurrent, pRef, pGMC, current->coding_type);                                                                  pCurrent, pRef, pGMC, current->coding_type, bound);
1124                          else                          else
1125                                  ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam,                                  ModeDecision_SAD(&Data, pMB, pMBs, x, y, pParam,
1126                                                                  MotionFlags, current->vop_flags, current->vol_flags,                                                                  MotionFlags, current->vop_flags, current->vol_flags,
# Line 1145  Line 1134 
1134                          motionStatsPVOP(&MVmax, &mvCount, &mvSum, pMB, Data.qpel);                          motionStatsPVOP(&MVmax, &mvCount, &mvSum, pMB, Data.qpel);
1135    
1136                  }                  }
1137    
1138                  block += (y_step-1)*pParam->mb_width;                  block += (y_step-1)*pParam->mb_width;
1139    
1140                  complete_count_self++;                  complete_count_self++;
1141                  complete_count_above++;                  complete_count_above++;
1142          }          }
Legend:
Removed from v.1687  
changed lines
  Added in v.1928
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4