[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 1608, Thu Mar 31 22:14:20 2005 UTC revision 1668, Sun Dec 18 06:52:12 2005 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_pvop.c,v 1.17 2005-03-31 22:14:20 Isibaar Exp $   * $Id: estimation_pvop.c,v 1.18 2005-12-18 06:52:12 syskin Exp $
25   *   *
26   ****************************************************************************/   ****************************************************************************/
27    
# Line 705  Line 705 
705          } else Data->iMinSAD[1] = 4096*256;          } else Data->iMinSAD[1] = 4096*256;
706  }  }
707    
708    static int
709    InitialSkipDecisionP(int sad00,
710                                             const MBParam * pParam,
711                                             const FRAMEINFO * current,
712                                             MACROBLOCK * pMB,
713                                             const MACROBLOCK * prevMB,
714                                             int x, int y,
715                                             const SearchData * Data,
716                                             const IMAGE * const pGMC,
717                                             const IMAGE * const pCurrent,
718                                             const IMAGE * const pRef,
719                                             const uint32_t MotionFlags)
720    {
721            const unsigned int iEdgedWidth = pParam->edged_width;
722    
723            int skip_thresh = INITIAL_SKIP_THRESH * \
724                    (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);
725            int stat_thresh = 0;
726    
727            /* initial skip decision */
728            if (current->coding_type != S_VOP)      { /* no fast SKIP for S(GMC)-VOPs */
729                    if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh)
730                            if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant)) {
731                                    ZeroMacroblockP(pMB, sad00);
732                                    pMB->mode = MODE_NOT_CODED;
733                                    return 1;
734                            }
735            }
736    
737            if(MotionFlags & XVID_ME_DETECT_STATIC_MOTION) {
738                    VECTOR *cmpMV;
739                    VECTOR staticMV = { 0, 0 };
740                    const MACROBLOCK * pMBs = current->mbs;
741    
742                    if (current->coding_type == S_VOP)
743                            cmpMV = &pMB->amv;
744                    else
745                            cmpMV = &staticMV;
746    
747                    if(x > 0 && y > 0 && x < pParam->mb_width) {
748                            if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], *cmpMV) &&
749                               MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&
750                               MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&
751                               MVequal(prevMB->mvs[0], *cmpMV)) {
752                                    stat_thresh = MAX((&pMBs[(x-1) + y * pParam->mb_width])->sad16,
753                                                              MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
754                                                              MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,
755                                                              prevMB->sad16)));
756                            } else {
757                                    stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16,
758                                                              MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
759                                                              MIN((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,
760                                                              prevMB->sad16)));
761                            }
762                    }
763            }
764    
765             /* favorize (0,0) or global vector for cartoons */
766            if (current->vop_flags & XVID_VOP_CARTOON) {
767                    if (current->coding_type == S_VOP) {
768                            int32_t iSAD = sad16(pCurrent->y + (x + y * iEdgedWidth) * 16,
769                            pGMC->y + 16*y*iEdgedWidth + 16*x, iEdgedWidth, 65536);
770    
771                            if (Data->chroma) {
772                                    iSAD += sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, pGMC->u + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2);
773                                    iSAD += sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, pGMC->v + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2);
774                            }
775    
776                            if (iSAD <= stat_thresh) {              /* mode decision GMC */
777                                    pMB->mode = MODE_INTER;
778                                    pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = iSAD;
779                                    pMB->mcsel = 1;
780                                    if (Data->qpel) {
781                                            pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv;
782                                            pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2;
783                                            pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2;
784                                    } else
785                                            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
786    
787                                    return 1;
788                            }
789                    }
790                    else if (sad00 < stat_thresh) {
791                            VECTOR predMV;
792                            if (Data->qpel)
793                                    predMV = get_qpmv2(current->mbs, pParam->mb_width, 0, x, y, 0);
794                            else
795                                    predMV = get_pmv2(current->mbs, pParam->mb_width, 0, x, y, 0);
796    
797                            ZeroMacroblockP(pMB, sad00);
798                            pMB->cbp = 0x3f;
799                            pMB->pmvs[0].x = - predMV.x;
800                            pMB->pmvs[0].y = - predMV.y;
801                            return 1;
802                    }
803            }
804    
805            return 0;
806    }
807    
808  static __inline uint32_t  static __inline uint32_t
809  MakeGoodMotionFlags(const uint32_t MotionFlags, const uint32_t VopFlags, const uint32_t VolFlags)  MakeGoodMotionFlags(const uint32_t MotionFlags, const uint32_t VopFlags, const uint32_t VolFlags)
810  {  {
# Line 784  Line 884 
884          }          }
885  }  }
886    
887  bool  void
888  MotionEstimation(MBParam * const pParam,  MotionEstimation(MBParam * const pParam,
889                                   FRAMEINFO * const current,                                   FRAMEINFO * const current,
890                                   FRAMEINFO * const reference,                                   FRAMEINFO * const reference,
# Line 806  Line 906 
906          int MVmax = 0, mvSum = 0, mvCount = 0;          int MVmax = 0, mvSum = 0, mvCount = 0;
907    
908          uint32_t x, y;          uint32_t x, y;
909          int32_t sad00;          int sad00;
910          int skip_thresh = INITIAL_SKIP_THRESH * \          int skip_thresh = INITIAL_SKIP_THRESH * \
911                  (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);                  (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);
912            int block = 0;
913    
914          /* some pre-initialized thingies for SearchP */          /* some pre-initialized thingies for SearchP */
915          DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);
# Line 828  Line 929 
929    
930          for (y = 0; y < mb_height; y++) {          for (y = 0; y < mb_height; y++) {
931                  for (x = 0; x < mb_width; x++)  {                  for (x = 0; x < mb_width; x++)  {
932                          MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];                          MACROBLOCK *pMB = &pMBs[block];
933                          MACROBLOCK *prevMB = &reference->mbs[x + y * pParam->mb_width];                          MACROBLOCK *prevMB = &reference->mbs[block];
934                            int skip;
935                            block++;
936    
937                          pMB->sad16 =                          pMB->sad16 =
938                                  sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,                                  sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,
# Line 847  Line 950 
950                                  sad00 += Data.chromaSAD;                                  sad00 += Data.chromaSAD;
951                          }                          }
952    
953                          /* initial skip decision */                          skip = InitialSkipDecisionP(sad00, pParam, current, pMB, prevMB, x, y, &Data, pGMC,
954                          if (current->coding_type != S_VOP)      { /* no fast SKIP for S(GMC)-VOPs */                                                                                  pCurrent, pRef, MotionFlags);
955                                  if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh)                          if (skip) continue;
                                         if (Data.chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant)) {  
                                                 ZeroMacroblockP(pMB, sad00);  
                                                 pMB->mode = MODE_NOT_CODED;  
                                                 continue;  
                                         }  
                         }  
   
                         if(MotionFlags & XVID_ME_DETECT_STATIC_MOTION) {  
                                 VECTOR *cmpMV;  
                                 VECTOR staticMV = { 0, 0 };  
   
                                 if (current->coding_type == S_VOP)  
                                         cmpMV = &pMB->amv;  
                                 else  
                                         cmpMV = &staticMV;  
   
                                 if(x > 0 && y > 0 && x < pParam->mb_width) {  
                                         if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], *cmpMV) &&  
                                            MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&  
                                        MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], *cmpMV) &&  
                                        MVequal(prevMB->mvs[0], *cmpMV)) {  
                                                 stat_thresh = MAX((&pMBs[(x-1) + y * pParam->mb_width])->sad16,  
                                                                           MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16,  
                                                                           MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,  
                                                                           prevMB->sad16)));  
                                         } else {  
                                                 stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16,  
                                                                           MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16,  
                                                                           MIN((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,  
                                                                           prevMB->sad16)));  
                                         }  
                                 }  
                         }  
   
                          /* favorize (0,0) or global vector for cartoons */  
                         if (current->vop_flags & XVID_VOP_CARTOON) {  
                                 if (current->coding_type == S_VOP) {  
                                         int32_t iSAD = sad16(pCurrent->y + (x + y * iEdgedWidth) * 16,  
                                         pGMC->y + 16*y*iEdgedWidth + 16*x, iEdgedWidth, 65536);  
   
                                         if (Data.chroma) {  
                                                 iSAD += sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8, pGMC->u + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2);  
                                                 iSAD += sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8, pGMC->v + 8*y*(iEdgedWidth/2) + 8*x, iEdgedWidth/2);  
                                         }  
   
                                         if (iSAD <= stat_thresh) {              /* mode decision GMC */  
                                                 pMB->mode = MODE_INTER;  
                                                 pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = iSAD;  
                                                 pMB->mcsel = 1;  
                                                 if (Data.qpel) {  
                                                         pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv;  
                                                         pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2;  
                                                         pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2;  
                                                 } else  
                                                         pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;  
   
                                                 continue;  
                                         }  
                                 }  
                                 else if (sad00 < stat_thresh) {  
                                         VECTOR predMV;  
                                         if (current->vol_flags & XVID_VOL_QUARTERPEL)  
                                                 predMV = get_qpmv2(current->mbs, mb_width, 0, x, y, 0);  
                                         else  
                                                 predMV = get_pmv2(current->mbs, mb_width, 0, x, y, 0);  
   
                                         ZeroMacroblockP(pMB, sad00);  
                                         pMB->cbp = 0x3f;  
                                         pMB->pmvs[0].x = - predMV.x;  
                                         pMB->pmvs[0].y = - predMV.y;  
                                         continue;  
                                 }  
                         }  
956    
957                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,
958                                          y, MotionFlags, current->vop_flags,                                          y, MotionFlags, current->vop_flags,
# Line 950  Line 980 
980          current->fcode = getMinFcode(MVmax);          current->fcode = getMinFcode(MVmax);
981          current->sStat.iMvSum = mvSum;          current->sStat.iMvSum = mvSum;
982          current->sStat.iMvCount = mvCount;          current->sStat.iMvCount = mvCount;
   
         return 0;  
983  }  }
Legend:
Removed from v.1608  
changed lines
  Added in v.1668
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4