[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 1701, Wed Apr 19 15:42:19 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.22 2006-04-19 15:42:19 syskin Exp $   * $Id: estimation_pvop.c,v 1.25 2010-12-28 19:19:43 Isibaar Exp $
25   *   *
26   ****************************************************************************/   ****************************************************************************/
27    
# 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 volatile 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;
# 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    
# Line 1053  Line 1063 
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 1069  Line 1079 
1079                                  }                                  }
1080                          }                          }
1081    
   
1082                          pMB = &pMBs[block];                          pMB = &pMBs[block];
1083                          prevMB = &reference->mbs[block];                          prevMB = &reference->mbs[block];
1084    
# Line 1090  Line 1099 
1099                          }                          }
1100    
1101                          skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC,                          skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC,
1102                                                                                  pCurrent, pRef, MotionFlags);                                                                                  pCurrent, pRef, MotionFlags, bound);
1103    
1104                          if (skip) {                          if (skip) {
1105                                  current_mb++;                                  current_mb++;
# Line 1101  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 1125  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.1701  
changed lines
  Added in v.1928
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4