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

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

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

trunk/xvidcore/src/motion/motion_est.c revision 346, Sun Jul 28 02:55:41 2002 UTC branches/dev-api-4/xvidcore/src/motion/motion_est.c revision 974, Sat Apr 5 16:47:44 2003 UTC
# Line 28  Line 28 
28   *   *
29   *************************************************************************/   *************************************************************************/
30    
 /**************************************************************************  
  *  
  *  Modifications:  
  *  
  *      01.05.2002      updated MotionEstimationBVOP  
  *      25.04.2002 partial prevMB conversion  
  *  22.04.2002 remove some compile warning by chenm001 <chenm001@163.com>  
  *  14.04.2002 added MotionEstimationBVOP()  
  *  02.04.2002 add EPZS(^2) as ME algorithm, use PMV_USESQUARES to choose between  
  *             EPZS and EPZS^2  
  *  08.02.2002 split up PMVfast into three routines: PMVFast, PMVFast_MainLoop  
  *             PMVFast_Refine to support multiple searches with different start points  
  *  07.01.2002 uv-block-based interpolation  
  *  06.01.2002 INTER/INTRA-decision is now done before any SEARCH8 (speedup)  
  *             changed INTER_BIAS to 150 (as suggested by suxen_drol)  
  *             removed halfpel refinement step in PMVfastSearch8 + quality=5  
  *             added new quality mode = 6 which performs halfpel refinement  
  *             filesize difference between quality 5 and 6 is smaller than 1%  
  *             (Isibaar)  
  *  31.12.2001 PMVfastSearch16 and PMVfastSearch8 (gruel)  
  *  30.12.2001 get_range/MotionSearchX simplified; blue/green bug fix  
  *  22.12.2001 commented best_point==99 check  
  *  19.12.2001 modified get_range (purple bug fix)  
  *  15.12.2001 moved pmv displacement from mbprediction  
  *  02.12.2001 motion estimation/compensation split (Isibaar)  
  *  16.11.2001 rewrote/tweaked search algorithms; pross@cs.rmit.edu.au  
  *  10.11.2001 support for sad16/sad8 functions  
  *  28.08.2001 reactivated MODE_INTER4V for EXT_MODE  
  *  24.08.2001 removed MODE_INTER4V_Q, disabled MODE_INTER4V for EXT_MODE  
  *  22.08.2001 added MODE_INTER4V_Q  
  *  20.08.2001 added pragma to get rid of internal compiler error with VC6  
  *             idea by Cyril. Thanks.  
  *  
  *  Michael Militzer <isibaar@videocoding.de>  
  *  
  **************************************************************************/  
   
31  #include <assert.h>  #include <assert.h>
32  #include <stdio.h>  #include <stdio.h>
33  #include <stdlib.h>  #include <stdlib.h>
34    #include <string.h>     // memcpy
35    #include <math.h>       // lrint
36    
37  #include "../encoder.h"  #include "../encoder.h"
38  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
39  #include "../prediction/mbprediction.h"  #include "../prediction/mbprediction.h"
40  #include "../global.h"  #include "../global.h"
41  #include "../utils/timer.h"  #include "../utils/timer.h"
42    #include "../image/interpolate8x8.h"
43    #include "motion_est.h"
44  #include "motion.h"  #include "motion.h"
45  #include "sad.h"  #include "sad.h"
46    #include "../utils/emms.h"
47    #include "../dct/fdct.h"
48    
49    /*****************************************************************************
50     * Modified rounding tables -- declared in motion.h
51  static int32_t lambda_vec16[32] =       /* rounded values for lambda param for weight of motion bits as in modified H.26L */   * Original tables see ISO spec tables 7-6 -> 7-9
52  { 0, (int) (1.00235 + 0.5), (int) (1.15582 + 0.5), (int) (1.31976 + 0.5),   ****************************************************************************/
53                  (int) (1.49591 + 0.5), (int) (1.68601 + 0.5),  
54          (int) (1.89187 + 0.5), (int) (2.11542 + 0.5), (int) (2.35878 + 0.5),  const uint32_t roundtab[16] =
55                  (int) (2.62429 + 0.5), (int) (2.91455 + 0.5),  {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
56          (int) (3.23253 + 0.5), (int) (3.58158 + 0.5), (int) (3.96555 + 0.5),  
57                  (int) (4.38887 + 0.5), (int) (4.85673 + 0.5),  /* K = 4 */
58          (int) (5.37519 + 0.5), (int) (5.95144 + 0.5), (int) (6.59408 + 0.5),  const uint32_t roundtab_76[16] =
59                  (int) (7.31349 + 0.5), (int) (8.12242 + 0.5),  { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1 };
60          (int) (9.03669 + 0.5), (int) (10.0763 + 0.5), (int) (11.2669 + 0.5),  
61                  (int) (12.6426 + 0.5), (int) (14.2493 + 0.5),  /* K = 2 */
62          (int) (16.1512 + 0.5), (int) (18.442 + 0.5), (int) (21.2656 + 0.5),  const uint32_t roundtab_78[8] =
63                  (int) (24.8580 + 0.5), (int) (29.6436 + 0.5),  { 0, 0, 1, 1, 0, 0, 0, 1  };
64          (int) (36.4949 + 0.5)  
65  };  /* K = 1 */
66    const uint32_t roundtab_79[4] =
67  static int32_t *lambda_vec8 = lambda_vec16;     /* same table for INTER and INTER4V for now */  { 0, 1, 0, 0 };
68    
69    #define INITIAL_SKIP_THRESH     (10)
70    #define FINAL_SKIP_THRESH       (50)
71  // mv.length table  #define MAX_SAD00_FOR_SKIP      (20)
72  static const uint32_t mvtab[33] = {  #define MAX_CHROMA_SAD_FOR_SKIP (22)
73          1, 2, 3, 4, 6, 7, 7, 7,  
74          9, 9, 9, 10, 10, 10, 10, 10,  #define CHECK_CANDIDATE(X,Y,D) { \
75          10, 10, 10, 10, 10, 10, 10, 10,  CheckCandidate((X),(Y), (D), &iDirection, data ); }
76          10, 11, 11, 11, 11, 11, 11, 12, 12  
77  };  /*****************************************************************************
78     * Code
79     ****************************************************************************/
80    
81  static __inline uint32_t  static __inline uint32_t
82  mv_bits(int32_t component,  d_mv_bits(int x, int y, const VECTOR pred, const uint32_t iFcode, const int qpel, const int rrv)
                 const uint32_t iFcode)  
83  {  {
84          if (component == 0)          int bits;
85                  return 1;          const int q = (1 << (iFcode - 1)) - 1;
   
         if (component < 0)  
                 component = -component;  
   
         if (iFcode == 1) {  
                 if (component > 32)  
                         component = 32;  
86    
87                  return mvtab[component] + 1;          x <<= qpel;
88          }          y <<= qpel;
89            if (rrv) { x = RRV_MV_SCALEDOWN(x); y = RRV_MV_SCALEDOWN(y); }
90          component += (1 << (iFcode - 1)) - 1;  
91          component >>= (iFcode - 1);          x -= pred.x;
92            bits = (x != 0 ? iFcode:0);
93          if (component > 32)          x = abs(x);
94                  component = 32;          x += q;
95            x >>= (iFcode - 1);
96          return mvtab[component] + 1 + iFcode - 1;          bits += mvtab[x];
97  }  
98            y -= pred.y;
99            bits += (y != 0 ? iFcode:0);
100  static __inline uint32_t          y = abs(y);
101  calc_delta_16(const int32_t dx,          y += q;
102                            const int32_t dy,          y >>= (iFcode - 1);
103                            const uint32_t iFcode,          bits += mvtab[y];
104                            const uint32_t iQuant)  
105  {          return bits;
106          return NEIGH_TEND_16X16 * lambda_vec16[iQuant] * (mv_bits(dx, iFcode) +  }
107                                                                                                            mv_bits(dy, iFcode));  
108  }  static int32_t ChromaSAD2(int fx, int fy, int bx, int by, const SearchData * const data)
109    {
110  static __inline uint32_t          int sad;
111  calc_delta_8(const int32_t dx,          const uint32_t stride = data->iEdgedWidth/2;
112                           const int32_t dy,          uint8_t * f_refu = data->RefQ,
113                           const uint32_t iFcode,                  * f_refv = data->RefQ + 8,
114                           const uint32_t iQuant)                  * b_refu = data->RefQ + 16,
115  {                  * b_refv = data->RefQ + 24;
116          return NEIGH_TEND_8X8 * lambda_vec8[iQuant] * (mv_bits(dx, iFcode) +  
117                                                                                                     mv_bits(dy, iFcode));          switch (((fx & 1) << 1) | (fy & 1))     {
118  }                  case 0:
119                            fx = fx / 2; fy = fy / 2;
120  bool                          f_refu = (uint8_t*)data->RefCU + fy * stride + fx, stride;
121  MotionEstimation(MBParam * const pParam,                          f_refv = (uint8_t*)data->RefCV + fy * stride + fx, stride;
122                                   FRAMEINFO * const current,                          break;
                                  FRAMEINFO * const reference,  
                                  const IMAGE * const pRefH,  
                                  const IMAGE * const pRefV,  
                                  const IMAGE * const pRefHV,  
                                  const uint32_t iLimit)  
 {  
         const uint32_t iWcount = pParam->mb_width;  
         const uint32_t iHcount = pParam->mb_height;  
         MACROBLOCK *const pMBs = current->mbs;  
         MACROBLOCK *const prevMBs = reference->mbs;  
         const IMAGE *const pCurrent = &current->image;  
         const IMAGE *const pRef = &reference->image;  
   
         static const VECTOR zeroMV = { 0, 0 };  
         VECTOR predMV;  
   
         int32_t x, y;  
         int32_t iIntra = 0;  
         VECTOR pmv;  
   
         if (sadInit)  
                 (*sadInit) ();  
   
         for (y = 0; y < iHcount; y++)   {  
                 for (x = 0; x < iWcount; x ++)  {  
   
                         MACROBLOCK *const pMB = &pMBs[x + y * iWcount];  
   
                         predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);  
   
                         pMB->sad16 =  
                                 SEARCH16(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent,  
                                                  x, y, predMV.x, predMV.y, predMV.x, predMV.y,  
                                                  current->motion_flags, current->quant,  
                                                  current->fcode, pParam, pMBs, prevMBs, &pMB->mv16,  
                                                  &pMB->pmvs[0]);  
   
                         if (0 < (pMB->sad16 - MV16_INTER_BIAS)) {  
                                 int32_t deviation;  
   
                                 deviation =  
                                         dev16(pCurrent->y + x * 16 + y * 16 * pParam->edged_width,  
                                                   pParam->edged_width);  
   
                                 if (deviation < (pMB->sad16 - MV16_INTER_BIAS)) {  
                                         pMB->mode = MODE_INTRA;  
                                         pMB->mv16 = pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] =  
                                                 pMB->mvs[3] = zeroMV;  
                                         pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] =  
                                                 pMB->sad8[3] = 0;  
   
                                         iIntra++;  
                                         if (iIntra >= iLimit)  
                                                 return 1;  
   
                                         continue;  
                                 }  
                         }  
   
                         pmv = pMB->pmvs[0];  
                         if (current->global_flags & XVID_INTER4V)  
                                 if ((!(current->global_flags & XVID_LUMIMASKING) ||  
                                          pMB->dquant == NO_CHANGE)) {  
                                         int32_t sad8 = IMV16X16 * current->quant;  
   
                                         if (sad8 < pMB->sad16) {  
                                                 sad8 += pMB->sad8[0] =  
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x, 2 * y,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[0],  
                                                                         &pMB->pmvs[0]);  
                                         }  
                                         if (sad8 < pMB->sad16) {  
   
                                                 predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 1);  
                                                 sad8 += pMB->sad8[1] =  
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x + 1, 2 * y,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[1],  
                                                                         &pMB->pmvs[1]);  
                                         }  
                                         if (sad8 < pMB->sad16) {  
                                                 predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 2);  
                                                 sad8 += pMB->sad8[2] =  
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x, 2 * y + 1,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[2],  
                                                                         &pMB->pmvs[2]);  
                                         }  
                                         if (sad8 < pMB->sad16) {  
                                                 predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 3);  
                                                 sad8 += pMB->sad8[3] =  
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x + 1, 2 * y + 1,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs,  
                                                                         &pMB->mvs[3],  
                                                                         &pMB->pmvs[3]);  
                                         }  
   
                                         /* decide: MODE_INTER or MODE_INTER4V  
                                            mpeg4:   if (sad8 < pMB->sad16 - nb/2+1) use_inter4v  
                                          */  
   
                                         if (sad8 < pMB->sad16) {  
                                                 pMB->mode = MODE_INTER4V;  
                                                 pMB->sad8[0] *= 4;  
                                                 pMB->sad8[1] *= 4;  
                                                 pMB->sad8[2] *= 4;  
                                                 pMB->sad8[3] *= 4;  
                                                 continue;  
                                         }  
   
                                 }  
   
                         pMB->mode = MODE_INTER;  
                         pMB->pmvs[0] = pmv;     /* pMB->pmvs[1] = pMB->pmvs[2] = pMB->pmvs[3]  are not needed for INTER */  
                         pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mv16;  
                         pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] =  
                                 pMB->sad16;  
                         }  
                         }  
   
         return 0;  
 }  
   
   
 #define CHECK_MV16_ZERO {\  
   if ( (0 <= max_dx) && (0 >= min_dx) \  
     && (0 <= max_dy) && (0 >= min_dy) ) \  
   { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0, 0 , iEdgedWidth), iEdgedWidth, MV_MAX_ERROR); \  
     iSAD += calc_delta_16(-center_x, -center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=0; currMV->y=0; }  }     \  
 }  
   
 #define NOCHECK_MV16_CANDIDATE(X,Y) { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } \  
 }  
   
 #define CHECK_MV16_CANDIDATE(X,Y) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV16_CANDIDATE_DIR(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \  
 }  
   
 #define CHECK_MV16_CANDIDATE_FOUND(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \  
 }  
   
   
 #define CHECK_MV8_ZERO {\  
   iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, 0, 0 , iEdgedWidth), iEdgedWidth); \  
   iSAD += calc_delta_8(-center_x, -center_y, (uint8_t)iFcode, iQuant);\  
   if (iSAD < iMinSAD) \  
   { iMinSAD=iSAD; currMV->x=0; currMV->y=0; } \  
 }  
   
 #define NOCHECK_MV8_CANDIDATE(X,Y) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } \  
 }  
   
 #define CHECK_MV8_CANDIDATE(X,Y) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV8_CANDIDATE_DIR(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \  
 }  
   
 #define CHECK_MV8_CANDIDATE_FOUND(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \  
 }  
   
 /* too slow and not fully functional at the moment */  
 /*  
 int32_t ZeroSearch16(  
                                         const uint8_t * const pRef,  
                                         const uint8_t * const pRefH,  
                                         const uint8_t * const pRefV,  
                                         const uint8_t * const pRefHV,  
                                         const IMAGE * const pCur,  
                                         const int x, const int y,  
                                         const uint32_t MotionFlags,  
                                         const uint32_t iQuant,  
                                         const uint32_t iFcode,  
                                         MBParam * const pParam,  
                                         const MACROBLOCK * const pMBs,  
                                         const MACROBLOCK * const prevMBs,  
                                         VECTOR * const currMV,  
                                         VECTOR * const currPMV)  
 {  
         const int32_t iEdgedWidth = pParam->edged_width;  
         const uint8_t * cur = pCur->y + x*16 + y*16*iEdgedWidth;  
         int32_t iSAD;  
         VECTOR pred;  
   
   
         pred = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);  
   
         iSAD = sad16( cur,  
                 get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0,0, iEdgedWidth),  
                 iEdgedWidth, MV_MAX_ERROR);  
         if (iSAD <= iQuant * 96)  
                 iSAD -= MV16_00_BIAS;  
   
         currMV->x = 0;  
         currMV->y = 0;  
         currPMV->x = -pred.x;  
         currPMV->y = -pred.y;  
   
         return iSAD;  
   
 }  
 */  
   
 int32_t  
 Diamond16_MainSearch(const uint8_t * const pRef,  
                                          const uint8_t * const pRefH,  
                                          const uint8_t * const pRefV,  
                                          const uint8_t * const pRefHV,  
                                          const uint8_t * const cur,  
                                          const int x,  
                                          const int y,  
                                    const int start_x,  
                                    const int start_y,  
                                    int iMinSAD,  
                                    VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                          const int32_t min_dx,  
                                          const int32_t max_dx,  
                                          const int32_t min_dy,  
                                          const int32_t max_dy,  
                                          const int32_t iEdgedWidth,  
                                          const int32_t iDiamondSize,  
                                          const int32_t iFcode,  
                                          const int32_t iQuant,  
                                          int iFound)  
 {  
 /* Do a diamond search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iDirectionBackup;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */  
   
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
   
         if (iDirection) {  
                 while (!iFound) {  
                         iFound = 1;  
                         backupMV = *currMV;  
                         iDirectionBackup = iDirection;  
   
                         if (iDirectionBackup != 2)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                    backupMV.y, 1);  
                         if (iDirectionBackup != 1)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                    backupMV.y, 2);  
                         if (iDirectionBackup != 4)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x,  
                                                                                    backupMV.y - iDiamondSize, 3);  
                         if (iDirectionBackup != 3)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x,  
                                                                                    backupMV.y + iDiamondSize, 4);  
                 }  
         } else {  
                 currMV->x = start_x;  
                 currMV->y = start_y;  
         }  
         return iMinSAD;  
 }  
   
 int32_t  
 Square16_MainSearch(const uint8_t * const pRef,  
                                         const uint8_t * const pRefH,  
                                         const uint8_t * const pRefV,  
                                         const uint8_t * const pRefHV,  
                                         const uint8_t * const cur,  
                                         const int x,  
                                         const int y,  
                                    const int start_x,  
                                    const int start_y,  
                                    int iMinSAD,  
                                    VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                         const int32_t min_dx,  
                                         const int32_t max_dx,  
                                         const int32_t min_dy,  
                                         const int32_t max_dy,  
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
                                         const int32_t iFcode,  
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a square search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full square pattern, and new parts for all following diamonds */  
   
 /*   new direction are extra, so 1-4 is normal diamond  
       537  
       1*2  
       648  
 */  
   
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
   
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                          backupMV.y - iDiamondSize, 5);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                          backupMV.y + iDiamondSize, 6);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                          backupMV.y - iDiamondSize, 7);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                          backupMV.y + iDiamondSize, 8);  
   
   
         if (iDirection) {  
                 while (!iFound) {  
                         iFound = 1;  
                         backupMV = *currMV;  
   
                         switch (iDirection) {  
123                          case 1:                          case 1:
124                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          fx = fx / 2; fy = (fy - 1) / 2;
125                                                                                     backupMV.y, 1);                          interpolate8x8_halfpel_v(f_refu, data->RefCU + fy * stride + fx, stride, data->rounding);
126                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          interpolate8x8_halfpel_v(f_refv, data->RefCV + fy * stride + fx, stride, data->rounding);
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
127                                  break;                                  break;
128                          case 2:                          case 2:
129                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                          fx = (fx - 1) / 2; fy = fy / 2;
130                                                                                   2);                          interpolate8x8_halfpel_h(f_refu, data->RefCU + fy * stride + fx, stride, data->rounding);
131                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          interpolate8x8_halfpel_h(f_refv, data->RefCV + fy * stride + fx, stride, data->rounding);
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
132                                  break;                                  break;
133                    default:
134                          case 3:                          fx = (fx - 1) / 2; fy = (fy - 1) / 2;
135                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,                          interpolate8x8_halfpel_hv(f_refu, data->RefCU + fy * stride + fx, stride, data->rounding);
136                                                                                   4);                          interpolate8x8_halfpel_hv(f_refv, data->RefCV + fy * stride + fx, stride, data->rounding);
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
137                                  break;                                  break;
138            }
139    
140                          case 4:          switch (((bx & 1) << 1) | (by & 1))     {
141                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,                  case 0:
142                                                                                   3);                          bx = bx / 2; by = by / 2;
143                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          b_refu = (uint8_t*)data->b_RefCU + by * stride + bx, stride;
144                                                                                   backupMV.y - iDiamondSize, 5);                          b_refv = (uint8_t*)data->b_RefCV + by * stride + bx, stride;
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 break;  
   
                         case 5:  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,  
                                                                                  1);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 break;  
   
                         case 6:  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
   
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
   
145                                  break;                                  break;
146                    case 1:
147                          case 7:                          bx = bx / 2; by = (by - 1) / 2;
148                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          interpolate8x8_halfpel_v(b_refu, data->b_RefCU + by * stride + bx, stride, data->rounding);
149                                                                                     backupMV.y, 1);                          interpolate8x8_halfpel_v(b_refv, data->b_RefCV + by * stride + bx, stride, data->rounding);
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
150                                  break;                                  break;
151                    case 2:
152                          case 8:                          bx = (bx - 1) / 2; by = by / 2;
153                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                          interpolate8x8_halfpel_h(b_refu, data->b_RefCU + by * stride + bx, stride, data->rounding);
154                                                                                   2);                          interpolate8x8_halfpel_h(b_refv, data->b_RefCV + by * stride + bx, stride, data->rounding);
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
155                                  break;                                  break;
156                          default:                          default:
157                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,                          bx = (bx - 1) / 2; by = (by - 1) / 2;
158                                                                                   1);                          interpolate8x8_halfpel_hv(b_refu, data->b_RefCU + by * stride + bx, stride, data->rounding);
159                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                          interpolate8x8_halfpel_hv(b_refv, data->b_RefCV + by * stride + bx, stride, data->rounding);
                                                                                  2);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
   
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
160                                  break;                                  break;
161                          }                          }
                 }  
         } else {  
                 currMV->x = start_x;  
                 currMV->y = start_y;  
         }  
         return iMinSAD;  
 }  
162    
163            sad = sad8bi(data->CurU, b_refu, f_refu, stride);
164            sad += sad8bi(data->CurV, b_refv, f_refv, stride);
165    
166  int32_t          return sad;
 Full16_MainSearch(const uint8_t * const pRef,  
                                   const uint8_t * const pRefH,  
                                   const uint8_t * const pRefV,  
                                   const uint8_t * const pRefHV,  
                                   const uint8_t * const cur,  
                                   const int x,  
                                   const int y,  
                                    const int start_x,  
                                    const int start_y,  
                                    int iMinSAD,  
                                    VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                   const int32_t min_dx,  
                                   const int32_t max_dx,  
                                   const int32_t min_dy,  
                                   const int32_t max_dy,  
                                   const int32_t iEdgedWidth,  
                                   const int32_t iDiamondSize,  
                                   const int32_t iFcode,  
                                   const int32_t iQuant,  
                                   int iFound)  
 {  
         int32_t iSAD;  
         int32_t dx, dy;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
         for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)  
                 for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)  
                         NOCHECK_MV16_CANDIDATE(dx, dy);  
   
         return iMinSAD;  
167  }  }
168    
 int32_t  
 AdvDiamond16_MainSearch(const uint8_t * const pRef,  
                                                 const uint8_t * const pRefH,  
                                                 const uint8_t * const pRefV,  
                                                 const uint8_t * const pRefHV,  
                                                 const uint8_t * const cur,  
                                                 const int x,  
                                                 const int y,  
                                            int start_x,  
                                            int start_y,  
                                            int iMinSAD,  
                                            VECTOR * const currMV,  
                                            const int center_x,  
                                            const int center_y,  
                                                 const int32_t min_dx,  
                                                 const int32_t max_dx,  
                                                 const int32_t min_dy,  
                                                 const int32_t max_dy,  
                                                 const int32_t iEdgedWidth,  
                                                 const int32_t iDiamondSize,  
                                                 const int32_t iFcode,  
                                                 const int32_t iQuant,  
                                                 int iDirection)  
 {  
   
         int32_t iSAD;  
169    
170  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */  static int32_t
171    ChromaSAD(int dx, int dy, const SearchData * const data)
         if (iDirection) {  
                 CHECK_MV16_CANDIDATE(start_x - iDiamondSize, start_y);  
                 CHECK_MV16_CANDIDATE(start_x + iDiamondSize, start_y);  
                 CHECK_MV16_CANDIDATE(start_x, start_y - iDiamondSize);  
                 CHECK_MV16_CANDIDATE(start_x, start_y + iDiamondSize);  
         } else {  
                 int bDirection = 1 + 2 + 4 + 8;  
   
                 do {  
                         iDirection = 0;  
                         if (bDirection & 1)     //we only want to check left if we came from the right (our last motion was to the left, up-left or down-left)  
                                 CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);  
   
                         if (bDirection & 2)  
                                 CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);  
   
                         if (bDirection & 4)  
                                 CHECK_MV16_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);  
   
                         if (bDirection & 8)  
                                 CHECK_MV16_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);  
   
                         /* now we're doing diagonal checks near our candidate */  
   
                         if (iDirection)         //checking if anything found  
172                          {                          {
173                                  bDirection = iDirection;          int sad;
174                                  iDirection = 0;          const uint32_t stride = data->iEdgedWidth/2;
                                 start_x = currMV->x;  
                                 start_y = currMV->y;  
                                 if (bDirection & 3)     //our candidate is left or right  
                                 {  
                                         CHECK_MV16_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);  
                                 } else                  // what remains here is up or down  
                                 {  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);  
                                 }  
175    
176                                  if (iDirection) {          if (dx == data->temp[5] && dy == data->temp[6]) return data->temp[7]; //it has been checked recently
177                                          bDirection += iDirection;          data->temp[5] = dx; data->temp[6] = dy; // backup
                                         start_x = currMV->x;  
                                         start_y = currMV->y;  
                                 }  
                         } else                          //about to quit, eh? not so fast....  
                         {  
                                 switch (bDirection) {  
                                 case 2:  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 1:  
178    
179                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,          switch (((dx & 1) << 1) | (dy & 1))     {
180                                                                                           start_y - iDiamondSize, 1 + 4);                  case 0:
181                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                          dx = dx / 2; dy = dy / 2;
182                                                                                           start_y + iDiamondSize, 1 + 8);                          sad = sad8(data->CurU, data->RefCU + dy * stride + dx, stride);
183                                          break;                          sad += sad8(data->CurV, data->RefCV + dy * stride + dx, stride);
                                 case 2 + 4:  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 4:  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y - iDiamondSize, 1 + 4);  
184                                          break;                                          break;
185                                  case 8:                  case 1:
186                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                          dx = dx / 2; dy = (dy - 1) / 2;
187                                                                                           start_y + iDiamondSize, 2 + 8);                          sad = sad8bi(data->CurU, data->RefCU + dy * stride + dx, data->RefCU + (dy+1) * stride + dx, stride);
188                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                          sad += sad8bi(data->CurV, data->RefCV + dy * stride + dx, data->RefCV + (dy+1) * stride + dx, stride);
                                                                                          start_y + iDiamondSize, 1 + 8);  
                                         break;  
                                 case 1 + 4:  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y - iDiamondSize, 2 + 4);  
                                         break;  
                                 case 2 + 8:  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
189                                          break;                                          break;
190                                  case 1 + 8:                  case 2:
191                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                          dx = (dx - 1) / 2; dy = dy / 2;
192                                                                                           start_y - iDiamondSize, 2 + 4);                          sad = sad8bi(data->CurU, data->RefCU + dy * stride + dx, data->RefCU + dy * stride + dx+1, stride);
193                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                          sad += sad8bi(data->CurV, data->RefCV + dy * stride + dx, data->RefCV + dy * stride + dx+1, stride);
                                                                                          start_y + iDiamondSize, 2 + 8);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y + iDiamondSize, 1 + 8);  
194                                          break;                                          break;
195                                  default:                //1+2+4+8 == we didn't find anything at all                  default:
196                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                          dx = (dx - 1) / 2; dy = (dy - 1) / 2;
197                                                                                           start_y - iDiamondSize, 1 + 4);                          interpolate8x8_halfpel_hv(data->RefQ, data->RefCU + dy * stride + dx, stride, data->rounding);
198                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                          sad = sad8(data->CurU, data->RefQ, stride);
199                                                                                           start_y + iDiamondSize, 1 + 8);  
200                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                          interpolate8x8_halfpel_hv(data->RefQ, data->RefCV + dy * stride + dx, stride, data->rounding);
201                                                                                           start_y - iDiamondSize, 2 + 4);                          sad += sad8(data->CurV, data->RefQ, stride);
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
202                                          break;                                          break;
203                                  }                                  }
204                                  if (!iDirection)          data->temp[7] = sad; //backup, part 2
205                                          break;          //ok, the end. really          return sad;
                                 else {  
                                         bDirection = iDirection;  
                                         start_x = currMV->x;  
                                         start_y = currMV->y;  
                                 }  
206                          }                          }
                 }  
                 while (1);                              //forever  
         }  
         return iMinSAD;  
 }  
   
 #define CHECK_MV16_F_INTERPOL(X,Y) { \  
   if ( ((X) <= f_max_dx) && ((X) >= f_min_dx) \  
     && ((Y) <= f_max_dy) && ((Y) >= f_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, b_currMV->x, b_currMV->y, iEdgedWidth),   \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16((X) - f_center_x, (Y) - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16(b_currMV->x - b_center_x, b_currMV->y - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; f_currMV->x=(X); f_currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV16_F_INTERPOL_FOUND(X,Y) { \  
   if ( ((X) <= f_max_dx) && ((X) >= f_min_dx) \  
     && ((Y) <= f_max_dy) && ((Y) >= f_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, b_currMV->x, b_currMV->y, iEdgedWidth),   \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16((X) - f_center_x, (Y) - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16(b_currMV->x - b_center_x, b_currMV->y - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; f_currMV->x=(X); f_currMV->y=(Y); iFound=0;} } \  
 }  
   
 #define CHECK_MV16_B_INTERPOL(X,Y) { \  
   if ( ((X) <= b_max_dx) && ((X) >= b_min_dx) \  
     && ((Y) <= b_max_dy) && ((Y) >= b_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, f_currMV->x, f_currMV->y, iEdgedWidth),   \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16(f_currMV->x - f_center_x, f_currMV->y - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16((X) - b_center_x, (Y) - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; b_currMV->x=(X); b_currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV16_B_INTERPOL_FOUND(X,Y) { \  
   if ( ((X) <= b_max_dx) && ((X) >= b_min_dx) \  
     && ((Y) <= b_max_dy) && ((Y) >= b_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, f_currMV->x, f_currMV->y, iEdgedWidth),   \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16(f_currMV->x - f_center_x, f_currMV->y - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16((X) - b_center_x, (Y) - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; b_currMV->x=(X); b_currMV->y=(Y); iFound=0;} } \  
 }  
   
 int32_t  
 Diamond16_InterpolMainSearch(  
                                         const uint8_t * const f_pRef,  
                                          const uint8_t * const f_pRefH,  
                                          const uint8_t * const f_pRefV,  
                                          const uint8_t * const f_pRefHV,  
   
                                          const uint8_t * const cur,  
   
                                         const uint8_t * const b_pRef,  
                                          const uint8_t * const b_pRefH,  
                                          const uint8_t * const b_pRefV,  
                                          const uint8_t * const b_pRefHV,  
   
                                          const int x,  
                                          const int y,  
   
                                    const int f_start_x,  
                                    const int f_start_y,  
                                    const int b_start_x,  
                                    const int b_start_y,  
   
                                    int iMinSAD,  
                                    VECTOR * const f_currMV,  
                                    VECTOR * const b_currMV,  
   
                                    const int f_center_x,  
                                    const int f_center_y,  
                                    const int b_center_x,  
                                    const int b_center_y,  
   
                                     const int32_t f_min_dx,  
                                         const int32_t f_max_dx,  
                                         const int32_t f_min_dy,  
                                         const int32_t f_max_dy,  
   
                                     const int32_t b_min_dx,  
                                         const int32_t b_max_dx,  
                                         const int32_t b_min_dy,  
                                         const int32_t b_max_dy,  
   
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
   
                                         const int32_t f_iFcode,  
                                         const int32_t b_iFcode,  
   
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a diamond search around given starting point, return SAD of best */  
   
         int32_t iSAD;  
   
         VECTOR f_backupMV;  
         VECTOR b_backupMV;  
   
         f_currMV->x = f_start_x;  
         f_currMV->y = f_start_y;  
         b_currMV->x = b_start_x;  
         b_currMV->y = b_start_y;  
   
         do  
         {  
                 iFound = 1;  
   
                 f_backupMV = *f_currMV;  
   
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x - iDiamondSize, f_backupMV.y);  
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x + iDiamondSize, f_backupMV.y);  
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x, f_backupMV.y - iDiamondSize);  
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x, f_backupMV.y + iDiamondSize);  
   
                 b_backupMV = *b_currMV;  
   
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x - iDiamondSize, b_backupMV.y);  
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x + iDiamondSize, b_backupMV.y);  
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x, b_backupMV.y - iDiamondSize);  
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x, b_backupMV.y + iDiamondSize);  
   
         } while (!iFound);  
   
         return iMinSAD;  
 }  
   
 /* Sorry, these MACROS really got too large... I'll turn them into function soon! */  
   
 #define CHECK_MV16_DIRECT_FOUND(X,Y) \  
         if ( (X)>=(-32) && (X)<=(31) && ((Y)>=-32) && ((Y)<=31) ) \  
         { int k;\  
         VECTOR mvs,b_mvs;       \  
         iSAD = 0;\  
         for (k = 0; k < 4; k++) {       \  
                                         mvs.x = (int32_t) ((TRB * directmv[k].x) / TRD + (X));          \  
                     b_mvs.x = (int32_t) (((X) == 0)                                                     \  
                                                                                 ? ((TRB - TRD) * directmv[k].x) / TRD   \  
                                             : mvs.x - directmv[k].x);                           \  
                                                                                                                                                                 \  
                     mvs.y = (int32_t) ((TRB * directmv[k].y) / TRD + (Y));              \  
                         b_mvs.y = (int32_t) (((Y) == 0)                                                         \  
                                                                                 ? ((TRB - TRD) * directmv[k].y) / TRD   \  
                                             : mvs.y - directmv[k].y);                           \  
                                                                                                                                                                 \  
   if ( (mvs.x <= max_dx) && (mvs.x >= min_dx) \  
     && (mvs.y <= max_dy) && (mvs.y >= min_dy)  \  
         && (b_mvs.x <= max_dx) && (b_mvs.x >= min_dx)  \  
     && (b_mvs.y <= max_dy) && (b_mvs.y >= min_dy) ) { \  
             iSAD += sad8bi( cur + 8*(k&1) + 8*(k>>1)*iEdgedWidth,                                                                                                       \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, 2*x+(k&1), 2*y+(k>>1), 8, \  
                                         mvs.x, mvs.y, iEdgedWidth),                                                             \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, 2*x+(k&1), 2*y+(k>>1), 8, \  
                                         b_mvs.x, b_mvs.y, iEdgedWidth),                                                         \  
                         iEdgedWidth); \  
                 }       \  
         else    \  
                 iSAD = 65535;   \  
         } \  
         iSAD += calc_delta_16((X),(Y), 1, iQuant);\  
         if (iSAD < iMinSAD) \  
             {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iFound=0; } \  
 }  
   
   
   
 int32_t  
 Diamond16_DirectMainSearch(  
                                         const uint8_t * const f_pRef,  
                                         const uint8_t * const f_pRefH,  
                                         const uint8_t * const f_pRefV,  
                                         const uint8_t * const f_pRefHV,  
   
                                         const uint8_t * const cur,  
   
                                         const uint8_t * const b_pRef,  
                                         const uint8_t * const b_pRefH,  
                                         const uint8_t * const b_pRefV,  
                                         const uint8_t * const b_pRefHV,  
   
                                         const int x,  
                                         const int y,  
   
                                         const int TRB,  
                                         const int TRD,  
   
                                     const int start_x,  
                                     const int start_y,  
   
                                     int iMinSAD,  
                                     VECTOR * const currMV,  
                                         const VECTOR * const directmv,  
207    
208                                      const int32_t min_dx,  static __inline const uint8_t *
209                                          const int32_t max_dx,  GetReferenceB(const int x, const int y, const uint32_t dir, const SearchData * const data)
                                         const int32_t min_dy,  
                                         const int32_t max_dy,  
   
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
   
                                         const int32_t iQuant,  
                                         int iFound)  
210  {  {
211  /* Do a diamond search around given starting point, return SAD of best */  //      dir : 0 = forward, 1 = backward
212            switch ( (dir << 2) | ((x&1)<<1) | (y&1) ) {
213          int32_t iSAD;                  case 0 : return data->Ref + x/2 + (y/2)*(data->iEdgedWidth);
214                    case 1 : return data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
215          VECTOR backupMV;                  case 2 : return data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);
216                    case 3 : return data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
217          currMV->x = start_x;                  case 4 : return data->bRef + x/2 + (y/2)*(data->iEdgedWidth);
218          currMV->y = start_y;                  case 5 : return data->bRefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
219                    case 6 : return data->bRefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);
220  /* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */                  default : return data->bRefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
221            }
222    }
223    
224          do  // this is a simpler copy of GetReferenceB, but as it's __inline anyway, we can keep the two separate
225    static __inline const uint8_t *
226    GetReference(const int x, const int y, const SearchData * const data)
227          {          {
228                  iFound = 1;          switch ( ((x&1)<<1) | (y&1) ) {
229                    case 0 : return data->Ref + x/2 + (y/2)*(data->iEdgedWidth);
230                  backupMV = *currMV;                  case 3 : return data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
231                    case 1 : return data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
232                  CHECK_MV16_DIRECT_FOUND(backupMV.x - iDiamondSize, backupMV.y);                  default : return data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);      //case 2
233                  CHECK_MV16_DIRECT_FOUND(backupMV.x + iDiamondSize, backupMV.y);          }
                 CHECK_MV16_DIRECT_FOUND(backupMV.x, backupMV.y - iDiamondSize);  
                 CHECK_MV16_DIRECT_FOUND(backupMV.x, backupMV.y + iDiamondSize);  
   
         } while (!iFound);  
   
         return iMinSAD;  
234  }  }
235    
236    static uint8_t *
237  int32_t  Interpolate8x8qpel(const int x, const int y, const uint32_t block, const uint32_t dir, const SearchData * const data)
 AdvDiamond8_MainSearch(const uint8_t * const pRef,  
                                            const uint8_t * const pRefH,  
                                            const uint8_t * const pRefV,  
                                            const uint8_t * const pRefHV,  
                                            const uint8_t * const cur,  
                                            const int x,  
                                            const int y,  
                                            int start_x,  
                                            int start_y,  
                                            int iMinSAD,  
                                            VECTOR * const currMV,  
                                            const int center_x,  
                                            const int center_y,  
                                            const int32_t min_dx,  
                                            const int32_t max_dx,  
                                            const int32_t min_dy,  
                                            const int32_t max_dy,  
                                            const int32_t iEdgedWidth,  
                                            const int32_t iDiamondSize,  
                                            const int32_t iFcode,  
                                            const int32_t iQuant,  
                                            int iDirection)  
238  {  {
239    // create or find a qpel-precision reference picture; return pointer to it
240            uint8_t * Reference = data->RefQ + 16*dir;
241            const uint32_t iEdgedWidth = data->iEdgedWidth;
242            const uint32_t rounding = data->rounding;
243            const int halfpel_x = x/2;
244            const int halfpel_y = y/2;
245            const uint8_t *ref1, *ref2, *ref3, *ref4;
246    
247          int32_t iSAD;          ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
248            ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
249  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */          switch( ((x&1)<<1) + (y&1) ) {
250            case 3: // x and y in qpel resolution - the "corners" (top left/right and
251          if (iDirection) {                          // bottom left/right) during qpel refinement
252                  CHECK_MV8_CANDIDATE(start_x - iDiamondSize, start_y);                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
253                  CHECK_MV8_CANDIDATE(start_x + iDiamondSize, start_y);                  ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
254                  CHECK_MV8_CANDIDATE(start_x, start_y - iDiamondSize);                  ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
255                  CHECK_MV8_CANDIDATE(start_x, start_y + iDiamondSize);                  ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
256          } else {                  ref3 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
257                  int bDirection = 1 + 2 + 4 + 8;                  ref4 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
258                    interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
259                  do {                  break;
                         iDirection = 0;  
                         if (bDirection & 1)     //we only want to check left if we came from the right (our last motion was to the left, up-left or down-left)  
                                 CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);  
   
                         if (bDirection & 2)  
                                 CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);  
260    
261                          if (bDirection & 4)          case 1: // x halfpel, y qpel - top or bottom during qpel refinement
262                                  CHECK_MV8_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
263                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
264                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
265                    break;
266    
267                          if (bDirection & 8)          case 2: // x qpel, y halfpel - left or right during qpel refinement
268                                  CHECK_MV8_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);                  ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
269                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
270                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
271                    break;
272    
273                          /* now we're doing diagonal checks near our candidate */          default: // pure halfpel position
274                    return (uint8_t *) ref1;
275    
                         if (iDirection)         //checking if anything found  
                         {  
                                 bDirection = iDirection;  
                                 iDirection = 0;  
                                 start_x = currMV->x;  
                                 start_y = currMV->y;  
                                 if (bDirection & 3)     //our candidate is left or right  
                                 {  
                                         CHECK_MV8_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);  
                                 } else                  // what remains here is up or down  
                                 {  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);  
276                                  }                                  }
277            return Reference;
                                 if (iDirection) {  
                                         bDirection += iDirection;  
                                         start_x = currMV->x;  
                                         start_y = currMV->y;  
278                                  }                                  }
279                          } else                          //about to quit, eh? not so fast....  
280    static uint8_t *
281    Interpolate16x16qpel(const int x, const int y, const uint32_t dir, const SearchData * const data)
282                          {                          {
283                                  switch (bDirection) {  // create or find a qpel-precision reference picture; return pointer to it
284                                  case 2:          uint8_t * Reference = data->RefQ + 16*dir;
285                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,          const uint32_t iEdgedWidth = data->iEdgedWidth;
286                                                                                          start_y - iDiamondSize, 2 + 4);          const uint32_t rounding = data->rounding;
287                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,          const int halfpel_x = x/2;
288                                                                                          start_y + iDiamondSize, 2 + 8);          const int halfpel_y = y/2;
289                                          break;          const uint8_t *ref1, *ref2, *ref3, *ref4;
290                                  case 1:  
291                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,          ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
292                                                                                          start_y - iDiamondSize, 1 + 4);          switch( ((x&1)<<1) + (y&1) ) {
293                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,          case 3: // x and y in qpel resolution - the "corners" (top left/right and
294                                                                                          start_y + iDiamondSize, 1 + 8);                           // bottom left/right) during qpel refinement
295                                          break;                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
296                                  case 2 + 4:                  ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
297                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,                  ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
298                                                                                          start_y - iDiamondSize, 1 + 4);                  interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
299                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,                  interpolate8x8_avg4(Reference+8, ref1+8, ref2+8, ref3+8, ref4+8, iEdgedWidth, rounding);
300                                                                                          start_y - iDiamondSize, 2 + 4);                  interpolate8x8_avg4(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, ref3+8*iEdgedWidth, ref4+8*iEdgedWidth, iEdgedWidth, rounding);
301                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,                  interpolate8x8_avg4(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, ref3+8*iEdgedWidth+8, ref4+8*iEdgedWidth+8, iEdgedWidth, rounding);
                                                                                         start_y + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 4:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         break;  
                                 case 8:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         break;  
                                 case 1 + 4:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y - iDiamondSize, 2 + 4);  
                                         break;  
                                 case 2 + 8:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
302                                          break;                                          break;
303                                  case 1 + 8:  
304                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,          case 1: // x halfpel, y qpel - top or bottom during qpel refinement
305                                                                                          start_y - iDiamondSize, 2 + 4);                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
306                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,                  interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
307                                                                                          start_y + iDiamondSize, 2 + 8);                  interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
308                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,                  interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
309                                                                                          start_y + iDiamondSize, 1 + 8);                  interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
310                                          break;                                          break;
311                                  default:                //1+2+4+8 == we didn't find anything at all  
312                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,          case 2: // x qpel, y halfpel - left or right during qpel refinement
313                                                                                          start_y - iDiamondSize, 1 + 4);                  ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
314                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,                  interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
315                                                                                          start_y + iDiamondSize, 1 + 8);                  interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
316                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,                  interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
317                                                                                          start_y - iDiamondSize, 2 + 4);                  interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
318                                          break;                                          break;
319    
320            default: // pure halfpel position
321                    return (uint8_t *) ref1;
322                                  }                                  }
323                                  if (!(iDirection))          return Reference;
                                         break;          //ok, the end. really  
                                 else {  
                                         bDirection = iDirection;  
                                         start_x = currMV->x;  
                                         start_y = currMV->y;  
                                 }  
                         }  
                 }  
                 while (1);                              //forever  
         }  
         return iMinSAD;  
324  }  }
325    
326    /* CHECK_CANDIATE FUNCTIONS START */
327    
328  int32_t  static void
329  Full8_MainSearch(const uint8_t * const pRef,  CheckCandidate16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
330                                   const uint8_t * const pRefH,  {
331                                   const uint8_t * const pRefV,          int xc, yc;
332                                   const uint8_t * const pRefHV,          const uint8_t * Reference;
333                                   const uint8_t * const cur,          VECTOR * current;
334                                   const int x,          int32_t sad; uint32_t t;
                                  const int y,  
                            const int start_x,  
                            const int start_y,  
                            int iMinSAD,  
                            VECTOR * const currMV,  
                            const int center_x,  
                            const int center_y,  
                                  const int32_t min_dx,  
                                  const int32_t max_dx,  
                                  const int32_t min_dy,  
                                  const int32_t max_dy,  
                                  const int32_t iEdgedWidth,  
                                  const int32_t iDiamondSize,  
                                  const int32_t iFcode,  
                                  const int32_t iQuant,  
                                  int iFound)  
 {  
         int32_t iSAD;  
         int32_t dx, dy;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
         for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)  
                 for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)  
                         NOCHECK_MV8_CANDIDATE(dx, dy);  
335    
336          return iMinSAD;          if ( (x > data->max_dx) || (x < data->min_dx)
337  }                  || (y > data->max_dy) || (y < data->min_dy) ) return;
338    
339  Halfpel8_RefineFuncPtr Halfpel8_Refine;          if (!data->qpel_precision) {
340                    Reference = GetReference(x, y, data);
341                    current = data->currentMV;
342                    xc = x; yc = y;
343            } else { // x and y are in 1/4 precision
344                    Reference = Interpolate16x16qpel(x, y, 0, data);
345                    xc = x/2; yc = y/2; //for chroma sad
346                    current = data->currentQMV;
347            }
348    
349  int32_t          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
350  Halfpel16_Refine(const uint8_t * const pRef,          t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
                                  const uint8_t * const pRefH,  
                                  const uint8_t * const pRefV,  
                                  const uint8_t * const pRefHV,  
                                  const uint8_t * const cur,  
                                  const int x,  
                                  const int y,  
                                  VECTOR * const currMV,  
                                  int32_t iMinSAD,  
                            const int center_x,  
                            const int center_y,  
                                  const int32_t min_dx,  
                                  const int32_t max_dx,  
                                  const int32_t min_dy,  
                                  const int32_t max_dy,  
                                  const int32_t iFcode,  
                                  const int32_t iQuant,  
                                  const int32_t iEdgedWidth)  
 {  
 /* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */  
351    
352          int32_t iSAD;          sad += (data->lambda16 * t * sad)>>10;
353          VECTOR backupMV = *currMV;          data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
354    
355          CHECK_MV16_CANDIDATE(backupMV.x - 1, backupMV.y - 1);          if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
356          CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y - 1);                                                                             (yc >> 1) + roundtab_79[yc & 0x3], data);
         CHECK_MV16_CANDIDATE(backupMV.x + 1, backupMV.y - 1);  
         CHECK_MV16_CANDIDATE(backupMV.x - 1, backupMV.y);  
         CHECK_MV16_CANDIDATE(backupMV.x + 1, backupMV.y);  
         CHECK_MV16_CANDIDATE(backupMV.x - 1, backupMV.y + 1);  
         CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y + 1);  
         CHECK_MV16_CANDIDATE(backupMV.x + 1, backupMV.y + 1);  
357    
358          return iMinSAD;          if (sad < data->iMinSAD[0]) {
359                    data->iMinSAD[0] = sad;
360                    current[0].x = x; current[0].y = y;
361                    *dir = Direction;
362  }  }
363    
364  #define PMV_HALFPEL16 (PMV_HALFPELDIAMOND16|PMV_HALFPELREFINE16)          if (data->temp[1] < data->iMinSAD[1]) {
365                    data->iMinSAD[1] = data->temp[1]; current[1].x = x; current[1].y = y; }
366            if (data->temp[2] < data->iMinSAD[2]) {
367                    data->iMinSAD[2] = data->temp[2]; current[2].x = x; current[2].y = y; }
368            if (data->temp[3] < data->iMinSAD[3]) {
369                    data->iMinSAD[3] = data->temp[3]; current[3].x = x; current[3].y = y; }
370            if (data->temp[4] < data->iMinSAD[4]) {
371                    data->iMinSAD[4] = data->temp[4]; current[4].x = x; current[4].y = y; }
372    
373    }
374  int32_t  
375  PMVfastSearch16(const uint8_t * const pRef,  static void
376                                  const uint8_t * const pRefH,  CheckCandidate8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
                                 const uint8_t * const pRefV,  
                                 const uint8_t * const pRefHV,  
                                 const IMAGE * const pCur,  
                                 const int x,  
                                 const int y,  
                                 const int start_x,      /* start is searched first, so it should contain the most */  
                                 const int start_y,  /* likely motion vector for this block */  
                                 const int center_x,     /* center is from where length of MVs is measured */  
                                 const int center_y,  
                                 const uint32_t MotionFlags,  
                                 const uint32_t iQuant,  
                                 const uint32_t iFcode,  
                                 const MBParam * const pParam,  
                                 const MACROBLOCK * const pMBs,  
                                 const MACROBLOCK * const prevMBs,  
                                 VECTOR * const currMV,  
                                 VECTOR * const currPMV)  
377  {  {
378          const uint32_t iWcount = pParam->mb_width;          int32_t sad; uint32_t t;
379          const int32_t iWidth = pParam->width;          const uint8_t * Reference;
380          const int32_t iHeight = pParam->height;          VECTOR * current;
381          const int32_t iEdgedWidth = pParam->edged_width;  
382            if ( (x > data->max_dx) || (x < data->min_dx)
383                    || (y > data->max_dy) || (y < data->min_dy) ) return;
384    
385          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;          if (!data->qpel_precision) {
386                    Reference = GetReference(x, y, data);
387                    current = data->currentMV;
388            } else { // x and y are in 1/4 precision
389                    Reference = Interpolate8x8qpel(x, y, 0, 0, data);
390                    current = data->currentQMV;
391            }
392    
393          int32_t iDiamondSize;          sad = sad8(data->Cur, Reference, data->iEdgedWidth);
394            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
395    
396          int32_t min_dx;          sad += (data->lambda8 * t * (sad+NEIGH_8X8_BIAS))>>10;
         int32_t max_dx;  
         int32_t min_dy;  
         int32_t max_dy;  
397    
398          int32_t iFound;          if (sad < *(data->iMinSAD)) {
399                    *(data->iMinSAD) = sad;
400                    current->x = x; current->y = y;
401                    *dir = Direction;
402            }
403    }
404    
         VECTOR newMV;  
         VECTOR backupMV;                        /* just for PMVFAST */  
405    
406          VECTOR pmv[4];  static void
407          int32_t psad[4];  CheckCandidate32(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
408    {
409            uint32_t t;
410            const uint8_t * Reference;
411    
412          MainSearch16FuncPtr MainSearchPtr;          if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || //non-zero even value
413                    (x > data->max_dx) || (x < data->min_dx)
414                    || (y > data->max_dy) || (y < data->min_dy) ) return;
415    
416          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;          Reference = GetReference(x, y, data);
417            t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);
418    
419          int32_t threshA, threshB;          data->temp[0] = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
         int32_t bPredEq;  
         int32_t iMinSAD, iSAD;  
420    
421  /* Get maximum range */          data->temp[0] += (data->lambda16 * t * data->temp[0]) >> 10;
422          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,          data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
                           iFcode);  
423    
424  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */          if (data->temp[0] < data->iMinSAD[0]) {
425                    data->iMinSAD[0] = data->temp[0];
426                    data->currentMV[0].x = x; data->currentMV[0].y = y;
427                    *dir = Direction; }
428    
429          if (!(MotionFlags & PMV_HALFPEL16)) {          if (data->temp[1] < data->iMinSAD[1]) {
430                  min_dx = EVEN(min_dx);                  data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
431                  max_dx = EVEN(max_dx);          if (data->temp[2] < data->iMinSAD[2]) {
432                  min_dy = EVEN(min_dy);                  data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
433                  max_dy = EVEN(max_dy);          if (data->temp[3] < data->iMinSAD[3]) {
434                    data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
435            if (data->temp[4] < data->iMinSAD[4]) {
436                    data->iMinSAD[4] = data->temp[4]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
437          }          }
438    
439          /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */  static void
440          //bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);  CheckCandidate16no4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
441          bPredEq = get_pmvdata2(pMBs, iWcount, 0, x, y, 0, pmv, psad);  {
442            int32_t sad, xc, yc;
443            const uint8_t * Reference;
444            uint32_t t;
445            VECTOR * current;
446    
447          if ((x == 0) && (y == 0)) {          if ( (x > data->max_dx) || ( x < data->min_dx)
448                  threshA = 512;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
449                  threshB = 1024;  
450            if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; //non-zero even value
451    
452            if (data->qpel_precision) { // x and y are in 1/4 precision
453                    Reference = Interpolate16x16qpel(x, y, 0, data);
454                    current = data->currentQMV;
455                    xc = x/2; yc = y/2;
456          } else {          } else {
457                  threshA = psad[0];                  Reference = GetReference(x, y, data);
458                  threshB = threshA + 256;                  current = data->currentMV;
459                  if (threshA < 512)                  xc = x; yc = y;
                         threshA = 512;  
                 if (threshA > 1024)  
                         threshA = 1024;  
                 if (threshB > 1792)  
                         threshB = 1792;  
460          }          }
461            t = d_mv_bits(x, y, data->predMV, data->iFcode,
462                                            data->qpel^data->qpel_precision, data->rrv);
463    
464          iFound = 0;          sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);
465            sad += (data->lambda16 * t * sad)>>10;
 /* Step 4: Calculate SAD around the Median prediction.  
    MinSAD=SAD  
    If Motion Vector equal to Previous frame motion vector  
    and MinSAD<PrevFrmSAD goto Step 10.  
    If SAD<=256 goto Step 10.  
 */  
   
         currMV->x = start_x;  
         currMV->y = start_y;  
466    
467          if (!(MotionFlags & PMV_HALFPEL16)) {   /* This should NOT be necessary! */          if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
468                  currMV->x = EVEN(currMV->x);                                                                                  (yc >> 1) + roundtab_79[yc & 0x3], data);
                 currMV->y = EVEN(currMV->y);  
         }  
469    
470          if (currMV->x > max_dx) {          if (sad < *(data->iMinSAD)) {
471                  currMV->x = max_dx;                  *(data->iMinSAD) = sad;
472          }                  current->x = x; current->y = y;
473          if (currMV->x < min_dx) {                  *dir = Direction;
                 currMV->x = min_dx;  
         }  
         if (currMV->y > max_dy) {  
                 currMV->y = max_dy;  
474          }          }
         if (currMV->y < min_dy) {  
                 currMV->y = min_dy;  
475          }          }
476    
477          iMinSAD =  static void
478                  sad16(cur,  CheckCandidate32I(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,  
                                                  iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);  
         iMinSAD +=  
                 calc_delta_16(currMV->x - center_x, currMV->y - center_y,  
                                           (uint8_t) iFcode, iQuant);  
   
         if ((iMinSAD < 256) ||  
                 ((MVequal(*currMV, prevMB->mvs[0])) &&  
                  ((int32_t) iMinSAD < prevMB->sad16))) {  
                 if (iMinSAD < 2 * iQuant)       // high chances for SKIP-mode  
479                  {                  {
480                          if (!MVzero(*currMV)) {  // maximum speed - for P/B/I decision
481                                  iMinSAD += MV16_00_BIAS;          int32_t sad;
                                 CHECK_MV16_ZERO;        // (0,0) saves space for letterboxed pictures  
                                 iMinSAD -= MV16_00_BIAS;  
                         }  
                 }  
482    
483                  if (MotionFlags & PMV_QUICKSTOP16)          if ( (x > data->max_dx) || (x < data->min_dx)
484                          goto PMVfast16_Terminate_without_Refine;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast16_Terminate_with_Refine;  
         }  
485    
486            sad = sad32v_c(data->Cur, data->Ref + x/2 + (y/2)*(data->iEdgedWidth),
487                                                            data->iEdgedWidth, data->temp+1);
488    
489  /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion          if (sad < *(data->iMinSAD)) {
490     vector of the median.                  *(data->iMinSAD) = sad;
491     If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2                  data->currentMV[0].x = x; data->currentMV[0].y = y;
492  */                  *dir = Direction;
493            }
494            if (data->temp[1] < data->iMinSAD[1]) {
495                    data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
496            if (data->temp[2] < data->iMinSAD[2]) {
497                    data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
498            if (data->temp[3] < data->iMinSAD[3]) {
499                    data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
500            if (data->temp[4] < data->iMinSAD[4]) {
501                    data->iMinSAD[4] = data->temp[4]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
502    
503          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[0])))  }
                 iFound = 2;  
504    
505  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.  static void
506     Otherwise select large Diamond Search.  CheckCandidateInt(const int xf, const int yf, const int Direction, int * const dir, const SearchData * const data)
507  */  {
508            int32_t sad, xb, yb, xcf, ycf, xcb, ycb;
509            uint32_t t;
510            const uint8_t *ReferenceF, *ReferenceB;
511            VECTOR *current;
512    
513          if ((!MVzero(pmv[0])) || (threshB < 1536) || (bPredEq))          if ((xf > data->max_dx) || (xf < data->min_dx) ||
514                  iDiamondSize = 1;               // halfpel!                  (yf > data->max_dy) || (yf < data->min_dy))
515          else                  return;
                 iDiamondSize = 2;               // halfpel!  
516    
517          if (!(MotionFlags & PMV_HALFPELDIAMOND16))          if (!data->qpel_precision) {
518                  iDiamondSize *= 2;                  ReferenceF = GetReference(xf, yf, data);
519                    xb = data->currentMV[1].x; yb = data->currentMV[1].y;
520                    ReferenceB = GetReferenceB(xb, yb, 1, data);
521                    current = data->currentMV;
522                    xcf = xf; ycf = yf;
523                    xcb = xb; ycb = yb;
524            } else {
525                    ReferenceF = Interpolate16x16qpel(xf, yf, 0, data);
526                    xb = data->currentQMV[1].x; yb = data->currentQMV[1].y;
527                    current = data->currentQMV;
528                    ReferenceB = Interpolate16x16qpel(xb, yb, 1, data);
529                    xcf = xf/2; ycf = yf/2;
530                    xcb = xb/2; ycb = yb/2;
531            }
532    
533  /*          t = d_mv_bits(xf, yf, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0)
534     Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.                   + d_mv_bits(xb, yb, data->bpredMV, data->iFcode, data->qpel^data->qpel_precision, 0);
    Also calculate (0,0) but do not subtract offset.  
    Let MinSAD be the smallest SAD up to this point.  
    If MV is (0,0) subtract offset.  
 */  
535    
536  // (0,0) is always possible          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
537            sad += (data->lambda16 * t * sad)>>10;
538    
539          if (!MVzero(pmv[0]))          if (data->chroma) sad += ChromaSAD2((xcf >> 1) + roundtab_79[xcf & 0x3],
540                  CHECK_MV16_ZERO;                                                                                  (ycf >> 1) + roundtab_79[ycf & 0x3],
541                                                                                    (xcb >> 1) + roundtab_79[xcb & 0x3],
542                                                                                    (ycb >> 1) + roundtab_79[ycb & 0x3], data);
543    
544  // previous frame MV is always possible          if (sad < *(data->iMinSAD)) {
545                    *(data->iMinSAD) = sad;
546                    current->x = xf; current->y = yf;
547                    *dir = Direction;
548            }
549    }
550    
551          if (!MVzero(prevMB->mvs[0]))  static void
552                  if (!MVequal(prevMB->mvs[0], pmv[0]))  CheckCandidateDirect(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
553                          CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);  {
554            int32_t sad = 0, xcf = 0, ycf = 0, xcb = 0, ycb = 0;
555            uint32_t k;
556            const uint8_t *ReferenceF;
557            const uint8_t *ReferenceB;
558            VECTOR mvs, b_mvs;
559    
560  // left neighbour, if allowed          if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return;
561    
562          if (!MVzero(pmv[1]))          for (k = 0; k < 4; k++) {
563                  if (!MVequal(pmv[1], prevMB->mvs[0]))                  mvs.x = data->directmvF[k].x + x;
564                          if (!MVequal(pmv[1], pmv[0])) {                  b_mvs.x = ((x == 0) ?
565                                  if (!(MotionFlags & PMV_HALFPEL16)) {                          data->directmvB[k].x
566                                          pmv[1].x = EVEN(pmv[1].x);                          : mvs.x - data->referencemv[k].x);
567                                          pmv[1].y = EVEN(pmv[1].y);  
568                    mvs.y = data->directmvF[k].y + y;
569                    b_mvs.y = ((y == 0) ?
570                            data->directmvB[k].y
571                            : mvs.y - data->referencemv[k].y);
572    
573                    if ((mvs.x > data->max_dx)   || (mvs.x < data->min_dx)   ||
574                            (mvs.y > data->max_dy)   || (mvs.y < data->min_dy)   ||
575                            (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx) ||
576                            (b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) )
577                            return;
578    
579                    if (data->qpel) {
580                            xcf += mvs.x/2; ycf += mvs.y/2;
581                            xcb += b_mvs.x/2; ycb += b_mvs.y/2;
582                    } else {
583                            xcf += mvs.x; ycf += mvs.y;
584                            xcb += b_mvs.x; ycb += b_mvs.y;
585                            mvs.x *= 2; mvs.y *= 2; //we move to qpel precision anyway
586                            b_mvs.x *= 2; b_mvs.y *= 2;
587                                  }                                  }
588    
589                                  CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);                  ReferenceF = Interpolate8x8qpel(mvs.x, mvs.y, k, 0, data);
590                          }                  ReferenceB = Interpolate8x8qpel(b_mvs.x, b_mvs.y, k, 1, data);
 // top neighbour, if allowed  
         if (!MVzero(pmv[2]))  
                 if (!MVequal(pmv[2], prevMB->mvs[0]))  
                         if (!MVequal(pmv[2], pmv[0]))  
                                 if (!MVequal(pmv[2], pmv[1])) {  
                                         if (!(MotionFlags & PMV_HALFPEL16)) {  
                                                 pmv[2].x = EVEN(pmv[2].x);  
                                                 pmv[2].y = EVEN(pmv[2].y);  
                                         }  
                                         CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
591    
592  // top right neighbour, if allowed                  sad += sad8bi(data->Cur + 8*(k&1) + 8*(k>>1)*(data->iEdgedWidth),
593                                          if (!MVzero(pmv[3]))                                                  ReferenceF, ReferenceB, data->iEdgedWidth);
594                                                  if (!MVequal(pmv[3], prevMB->mvs[0]))                  if (sad > *(data->iMinSAD)) return;
                                                         if (!MVequal(pmv[3], pmv[0]))  
                                                                 if (!MVequal(pmv[3], pmv[1]))  
                                                                         if (!MVequal(pmv[3], pmv[2])) {  
                                                                                 if (!(MotionFlags & PMV_HALFPEL16)) {  
                                                                                         pmv[3].x = EVEN(pmv[3].x);  
                                                                                         pmv[3].y = EVEN(pmv[3].y);  
595                                                                                  }                                                                                  }
596                                                                                  CHECK_MV16_CANDIDATE(pmv[3].x,  
597                                                                                                                           pmv[3].y);          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
598    
599            if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
600                                                                                    (ycf >> 3) + roundtab_76[ycf & 0xf],
601                                                                                    (xcb >> 3) + roundtab_76[xcb & 0xf],
602                                                                                    (ycb >> 3) + roundtab_76[ycb & 0xf], data);
603    
604            if (sad < *(data->iMinSAD)) {
605                    *(data->iMinSAD) = sad;
606                    data->currentMV->x = x; data->currentMV->y = y;
607                    *dir = Direction;
608                                                                          }                                                                          }
609                                  }                                  }
610    
611          if ((MVzero(*currMV)) &&  static void
612                  (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )  CheckCandidateDirectno4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
613                  iMinSAD -= MV16_00_BIAS;  {
614            int32_t sad, xcf, ycf, xcb, ycb;
615            const uint8_t *ReferenceF;
616            const uint8_t *ReferenceB;
617            VECTOR mvs, b_mvs;
618    
619            if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return;
620    
621  /* Step 6: If MinSAD <= thresa goto Step 10.          mvs.x = data->directmvF[0].x + x;
622     If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.          b_mvs.x = ((x == 0) ?
623  */                  data->directmvB[0].x
624                    : mvs.x - data->referencemv[0].x);
625    
626          if ((iMinSAD <= threshA) ||          mvs.y = data->directmvF[0].y + y;
627                  (MVequal(*currMV, prevMB->mvs[0]) &&          b_mvs.y = ((y == 0) ?
628                   ((int32_t) iMinSAD < prevMB->sad16))) {                  data->directmvB[0].y
629                  if (MotionFlags & PMV_QUICKSTOP16)                  : mvs.y - data->referencemv[0].y);
                         goto PMVfast16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast16_Terminate_with_Refine;  
         }  
630    
631            if ( (mvs.x > data->max_dx) || (mvs.x < data->min_dx)
632                    || (mvs.y > data->max_dy) || (mvs.y < data->min_dy)
633                    || (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx)
634                    || (b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) ) return;
635    
636  /************ (Diamond Search)  **************/          if (data->qpel) {
637  /*                  xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2);
638     Step 7: Perform Diamond search, with either the small or large diamond.                  xcb = 4*(b_mvs.x/2); ycb = 4*(b_mvs.y/2);
639     If Found=2 only examine one Diamond pattern, and afterwards goto step 10                  ReferenceF = Interpolate16x16qpel(mvs.x, mvs.y, 0, data);
640     Step 8: If small diamond, iterate small diamond search pattern until motion vector lies in the center of the diamond.                  ReferenceB = Interpolate16x16qpel(b_mvs.x, b_mvs.y, 1, data);
641     If center then goto step 10.          } else {
642     Step 9: If large diamond, iterate large diamond search pattern until motion vector lies in the center.                  xcf = 4*mvs.x; ycf = 4*mvs.y;
643     Refine by using small diamond and goto step 10.                  xcb = 4*b_mvs.x; ycb = 4*b_mvs.y;
644  */                  ReferenceF = GetReference(mvs.x, mvs.y, data);
645                    ReferenceB = GetReferenceB(b_mvs.x, b_mvs.y, 1, data);
646            }
647    
648          if (MotionFlags & PMV_USESQUARES16)          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
649                  MainSearchPtr = Square16_MainSearch;          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
         else if (MotionFlags & PMV_ADVANCEDDIAMOND16)  
                 MainSearchPtr = AdvDiamond16_MainSearch;  
         else  
                 MainSearchPtr = Diamond16_MainSearch;  
650    
651          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */          if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
652                                                                                    (ycf >> 3) + roundtab_76[ycf & 0xf],
653                                                                                    (xcb >> 3) + roundtab_76[xcb & 0xf],
654                                                                                    (ycb >> 3) + roundtab_76[ycb & 0xf], data);
655    
656            if (sad < *(data->iMinSAD)) {
657                    *(data->iMinSAD) = sad;
658                    data->currentMV->x = x; data->currentMV->y = y;
659                    *dir = Direction;
660            }
661    }
662    
 /* default: use best prediction as starting point for one call of PMVfast_MainSearch */  
         iSAD =  
                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  
                                                   currMV->x, currMV->y, iMinSAD, &newMV, center_x, center_y,  
                                                   min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, iFound);  
663    
664          if (iSAD < iMinSAD) {  static void
665                  *currMV = newMV;  CheckCandidateBits16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
666                  iMinSAD = iSAD;  {
         }  
667    
668          if (MotionFlags & PMV_EXTSEARCH16) {          int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;
669  /* extended: search (up to) two more times: orignal prediction and (0,0) */          int32_t bits = 0, sum;
670            VECTOR * current;
671            const uint8_t * ptr;
672            int i, cbp = 0, t, xc, yc;
673    
674                  if (!(MVequal(pmv[0], backupMV))) {          if ( (x > data->max_dx) || (x < data->min_dx)
675                          iSAD =                  || (y > data->max_dy) || (y < data->min_dy) ) return;
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  
                                                                   center_x, center_y, iMinSAD, &newMV, center_x, center_y,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
676    
677                          if (iSAD < iMinSAD) {          if (!data->qpel_precision) {
678                                  *currMV = newMV;                  ptr = GetReference(x, y, data);
679                                  iMinSAD = iSAD;                  current = data->currentMV;
680                    xc = x; yc = y;
681            } else { // x and y are in 1/4 precision
682                    ptr = Interpolate16x16qpel(x, y, 0, data);
683                    current = data->currentQMV;
684                    xc = x/2; yc = y/2;
685                          }                          }
686    
687            for(i = 0; i < 4; i++) {
688                    int s = 8*((i&1) + (i>>1)*data->iEdgedWidth);
689                    transfer_8to16subro(in, data->Cur + s, ptr + s, data->iEdgedWidth);
690                    fdct(in);
691                    if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
692                    else sum = quant4_inter(coeff, in, data->lambda16);
693                    if (sum > 0) {
694                            cbp |= 1 << (5 - i);
695                            bits += data->temp[i] = CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
696                    } else data->temp[i] = 0;
697                  }                  }
698    
699                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {          bits += t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
700                          iSAD =  
701                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,          if (bits < data->iMinSAD[0]) { // there is still a chance, adding chroma
702                                                                    iMinSAD, &newMV, center_x, center_y,                  xc = (xc >> 1) + roundtab_79[xc & 0x3];
703                                                                    min_dx, max_dx, min_dy, max_dy,                  yc = (yc >> 1) + roundtab_79[yc & 0x3];
                                                                   iEdgedWidth, iDiamondSize, iFcode,  
                                                                   iQuant, iFound);  
704    
705                          if (iSAD < iMinSAD) {                  //chroma U
706                                  *currMV = newMV;                  ptr = interpolate8x8_switch2(data->RefQ + 64, data->RefCU, 0, 0, xc, yc,  data->iEdgedWidth/2, data->rounding);
707                                  iMinSAD = iSAD;                  transfer_8to16subro(in, ptr, data->CurU, data->iEdgedWidth/2);
708                    fdct(in);
709                    if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
710                    else sum = quant4_inter(coeff, in, data->lambda16);
711                    if (sum > 0) {
712                            cbp |= 1 << (5 - 4);
713                            bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
714                    }
715    
716                    if (bits < data->iMinSAD[0]) {
717                            //chroma V
718                            ptr = interpolate8x8_switch2(data->RefQ + 64, data->RefCV, 0, 0, xc, yc,  data->iEdgedWidth/2, data->rounding);
719                            transfer_8to16subro(in, ptr, data->CurV, data->iEdgedWidth/2);
720                            fdct(in);
721                            if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
722                            else sum = quant4_inter(coeff, in, data->lambda16);
723                            if (sum > 0) {
724                                    cbp |= 1 << (5 - 5);
725                                    bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
726                          }                          }
727                  }                  }
728          }          }
729    
730  /*          bits += xvid_cbpy_tab[15-(cbp>>2)].len;
731     Step 10:  The motion vector is chosen according to the block corresponding to MinSAD.          bits += mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len;
 */  
   
   PMVfast16_Terminate_with_Refine:  
         if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step  
                 iMinSAD =  
                         Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                          iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,  
                                                          iFcode, iQuant, iEdgedWidth);  
732    
733    PMVfast16_Terminate_without_Refine:          if (bits < data->iMinSAD[0]) {
734          currPMV->x = currMV->x - center_x;                  data->iMinSAD[0] = bits;
735          currPMV->y = currMV->y - center_y;                  current[0].x = x; current[0].y = y;
736          return iMinSAD;                  *dir = Direction;
737  }  }
738    
739            if (data->temp[0] + t < data->iMinSAD[1]) {
740                    data->iMinSAD[1] = data->temp[0] + t; current[1].x = x; current[1].y = y; }
741            if (data->temp[1] < data->iMinSAD[2]) {
742                    data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }
743            if (data->temp[2] < data->iMinSAD[3]) {
744                    data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
745            if (data->temp[3] < data->iMinSAD[4]) {
746                    data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
747    
748    }
749    static void
750    CheckCandidateBits8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
751    {
752    
753            int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;
754            int32_t sum, bits;
755            VECTOR * current;
756            const uint8_t * ptr;
757            int cbp;
758    
759            if ( (x > data->max_dx) || (x < data->min_dx)
760                    || (y > data->max_dy) || (y < data->min_dy) ) return;
761    
762            if (!data->qpel_precision) {
763                    ptr = GetReference(x, y, data);
764                    current = data->currentMV;
765            } else { // x and y are in 1/4 precision
766                    ptr = Interpolate8x8qpel(x, y, 0, 0, data);
767                    current = data->currentQMV;
768            }
769    
770  int32_t          transfer_8to16subro(in, data->Cur, ptr, data->iEdgedWidth);
771  Diamond8_MainSearch(const uint8_t * const pRef,          fdct(in);
772                                          const uint8_t * const pRefH,          if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
773                                          const uint8_t * const pRefV,          else sum = quant4_inter(coeff, in, data->lambda16);
774                                          const uint8_t * const pRefHV,          if (sum > 0) {
775                                          const uint8_t * const cur,                  bits = CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
776                                          const int x,                  cbp = 1;
777                                          const int y,          } else cbp = bits = 0;
                                         int32_t start_x,  
                                         int32_t start_y,  
                                         int32_t iMinSAD,  
                                         VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                         const int32_t min_dx,  
                                         const int32_t max_dx,  
                                         const int32_t min_dy,  
                                         const int32_t max_dy,  
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
                                         const int32_t iFcode,  
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a diamond search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iDirectionBackup;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */  
   
         CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
778    
779          if (iDirection) {          bits += sum = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
780                  while (!iFound) {  
781                          iFound = 1;          if (bits < data->iMinSAD[0]) {
782                          backupMV = *currMV;     // since iDirection!=0, this is well defined!                  data->temp[0] = cbp;
783                          iDirectionBackup = iDirection;                  data->iMinSAD[0] = bits;
784                    current[0].x = x; current[0].y = y;
785                          if (iDirectionBackup != 2)                  *dir = Direction;
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                   backupMV.y, 1);  
                         if (iDirectionBackup != 1)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                   backupMV.y, 2);  
                         if (iDirectionBackup != 4)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x,  
                                                                                   backupMV.y - iDiamondSize, 3);  
                         if (iDirectionBackup != 3)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x,  
                                                                                   backupMV.y + iDiamondSize, 4);  
                 }  
         } else {  
                 currMV->x = start_x;  
                 currMV->y = start_y;  
786          }          }
         return iMinSAD;  
787  }  }
788    
789    /* CHECK_CANDIATE FUNCTIONS END */
790    
791    /* MAINSEARCH FUNCTIONS START */
792    
793    static void
794    AdvDiamondSearch(int x, int y, const SearchData * const data, int bDirection)
795    {
796    
797  int32_t  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
 Square8_MainSearch(const uint8_t * const pRef,  
                                         const uint8_t * const pRefH,  
                                         const uint8_t * const pRefV,  
                                         const uint8_t * const pRefHV,  
                                         const uint8_t * const cur,  
                                         const int x,  
                                         const int y,  
                                         int32_t start_x,  
                                         int32_t start_y,  
                                         int32_t iMinSAD,  
                                         VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                         const int32_t min_dx,  
                                         const int32_t max_dx,  
                                         const int32_t min_dy,  
                                         const int32_t max_dy,  
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
                                         const int32_t iFcode,  
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a square search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full square pattern, and new parts for all following diamonds */  
   
 /*   new direction are extra, so 1-4 is normal diamond  
       537  
       1*2  
       648  
 */  
798    
799          CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);          int iDirection;
         CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
   
         CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                          backupMV.y - iDiamondSize, 5);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                          backupMV.y + iDiamondSize, 6);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                          backupMV.y - iDiamondSize, 7);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                          backupMV.y + iDiamondSize, 8);  
800    
801            for(;;) { //forever
802                    iDirection = 0;
803                    if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
804                    if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);
805                    if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);
806                    if (bDirection & 8) CHECK_CANDIDATE(x, y + iDiamondSize, 8);
807    
808          if (iDirection) {                  /* now we're doing diagonal checks near our candidate */
                 while (!iFound) {  
                         iFound = 1;  
                         backupMV = *currMV;  
809    
810                          switch (iDirection) {                  if (iDirection) {               //if anything found
811                          case 1:                          bDirection = iDirection;
812                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          iDirection = 0;
813                                                                                     backupMV.y, 1);                          x = data->currentMV->x; y = data->currentMV->y;
814                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          if (bDirection & 3) {   //our candidate is left or right
815                                                                                   backupMV.y - iDiamondSize, 5);                                  CHECK_CANDIDATE(x, y + iDiamondSize, 8);
816                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                                  CHECK_CANDIDATE(x, y - iDiamondSize, 4);
817                                                                                   backupMV.y - iDiamondSize, 7);                          } else {                        // what remains here is up or down
818                                  break;                                  CHECK_CANDIDATE(x + iDiamondSize, y, 2);
819                                    CHECK_CANDIDATE(x - iDiamondSize, y, 1);
820                            }
821    
822                            if (iDirection) {
823                                    bDirection += iDirection;
824                                    x = data->currentMV->x; y = data->currentMV->y;
825                            }
826                    } else {                                //about to quit, eh? not so fast....
827                            switch (bDirection) {
828                          case 2:                          case 2:
829                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
830                                                                                   2);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
831                                  break;                                  break;
832                            case 1:
833                          case 3:                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
834                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
                                                                                  4);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
835                                  break;                                  break;
836                            case 2 + 4:
837                          case 4:                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
838                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
839                                                                                   3);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 break;  
   
                         case 5:  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,  
                                                                                  1);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 break;  
   
                         case 6:  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
   
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
   
840                                  break;                                  break;
841                            case 4:
842                          case 7:                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
843                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
                                                                                    backupMV.y, 1);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
844                                  break;                                  break;
   
845                          case 8:                          case 8:
846                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
847                                                                                   2);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
848                                  break;                                  break;
849                          default:                          case 1 + 4:
850                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
851                                                                                   1);                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
852                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
853                                                                                   2);                                  break;
854                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,                          case 2 + 8:
855                                                                                   3);                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
856                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
857                                                                                   4);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
858                                    break;
859                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                          case 1 + 8:
860                                                                                   backupMV.y - iDiamondSize, 5);                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
861                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
862                                                                                   backupMV.y + iDiamondSize, 6);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
863                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                                  break;
864                                                                                   backupMV.y - iDiamondSize, 7);                          default:                //1+2+4+8 == we didn't find anything at all
865                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
866                                                                                   backupMV.y + iDiamondSize, 8);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
867                                    CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
868                                    CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
869                                  break;                                  break;
870                          }                          }
871                            if (!iDirection) break;         //ok, the end. really
872                            bDirection = iDirection;
873                            x = data->currentMV->x; y = data->currentMV->y;
874                  }                  }
         } else {  
                 currMV->x = start_x;  
                 currMV->y = start_y;  
875          }          }
         return iMinSAD;  
876  }  }
877    
878    static void
879    SquareSearch(int x, int y, const SearchData * const data, int bDirection)
880    {
881            int iDirection;
882    
883            do {
884                    iDirection = 0;
885                    if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1+16+64);
886                    if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2+32+128);
887                    if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4+16+32);
888                    if (bDirection & 8) CHECK_CANDIDATE(x, y + iDiamondSize, 8+64+128);
889                    if (bDirection & 16) CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1+4+16+32+64);
890                    if (bDirection & 32) CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2+4+16+32+128);
891                    if (bDirection & 64) CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1+8+16+64+128);
892                    if (bDirection & 128) CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2+8+32+64+128);
893    
894                    bDirection = iDirection;
895                    x = data->currentMV->x; y = data->currentMV->y;
896  int32_t          } while (iDirection);
 Halfpel8_Refine_c(const uint8_t * const pRef,  
                                 const uint8_t * const pRefH,  
                                 const uint8_t * const pRefV,  
                                 const uint8_t * const pRefHV,  
                                 const uint8_t * const cur,  
                                 const int x,  
                                 const int y,  
                                 VECTOR * const currMV,  
                                 int32_t iMinSAD,  
                            const int center_x,  
                            const int center_y,  
                                 const int32_t min_dx,  
                                 const int32_t max_dx,  
                                 const int32_t min_dy,  
                                 const int32_t max_dy,  
                                 const int32_t iFcode,  
                                 const int32_t iQuant,  
                                 const int32_t iEdgedWidth)  
 {  
 /* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */  
   
         int32_t iSAD;  
         VECTOR backupMV = *currMV;  
   
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y);  
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y + 1);  
         CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y + 1);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y + 1);  
   
         return iMinSAD;  
897  }  }
898    
899    static void
900  #define PMV_HALFPEL8 (PMV_HALFPELDIAMOND8|PMV_HALFPELREFINE8)  DiamondSearch(int x, int y, const SearchData * const data, int bDirection)
   
 int32_t  
 PMVfastSearch8(const uint8_t * const pRef,  
                            const uint8_t * const pRefH,  
                            const uint8_t * const pRefV,  
                            const uint8_t * const pRefHV,  
                            const IMAGE * const pCur,  
                            const int x,  
                            const int y,  
                            const int start_x,  
                            const int start_y,  
                                 const int center_x,  
                                 const int center_y,  
                            const uint32_t MotionFlags,  
                            const uint32_t iQuant,  
                            const uint32_t iFcode,  
                            const MBParam * const pParam,  
                            const MACROBLOCK * const pMBs,  
                            const MACROBLOCK * const prevMBs,  
                            VECTOR * const currMV,  
                            VECTOR * const currPMV)  
901  {  {
         const uint32_t iWcount = pParam->mb_width;  
         const int32_t iWidth = pParam->width;  
         const int32_t iHeight = pParam->height;  
         const int32_t iEdgedWidth = pParam->edged_width;  
902    
903          const uint8_t *cur = pCur->y + x * 8 + y * 8 * iEdgedWidth;  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
904    
905            int iDirection;
906    
907          int32_t iDiamondSize;          do {
908                    iDirection = 0;
909                    if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
910                    if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);
911                    if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);
912                    if (bDirection & 8) CHECK_CANDIDATE(x, y + iDiamondSize, 8);
913    
914          int32_t min_dx;                  /* now we're doing diagonal checks near our candidate */
         int32_t max_dx;  
         int32_t min_dy;  
         int32_t max_dy;  
915    
916          VECTOR pmv[4];                  if (iDirection) {               //checking if anything found
917          int32_t psad[4];                          bDirection = iDirection;
918          VECTOR newMV;                          iDirection = 0;
919          VECTOR backupMV;                          x = data->currentMV->x; y = data->currentMV->y;
920          VECTOR startMV;                          if (bDirection & 3) {   //our candidate is left or right
921                                    CHECK_CANDIDATE(x, y + iDiamondSize, 8);
922                                    CHECK_CANDIDATE(x, y - iDiamondSize, 4);
923                            } else {                        // what remains here is up or down
924                                    CHECK_CANDIDATE(x + iDiamondSize, y, 2);
925                                    CHECK_CANDIDATE(x - iDiamondSize, y, 1);
926                            }
927                            bDirection += iDirection;
928                            x = data->currentMV->x; y = data->currentMV->y;
929                    }
930            }
931            while (iDirection);
932    }
933    
934  //  const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;  /* MAINSEARCH FUNCTIONS END */
         const MACROBLOCK *const prevMB = prevMBs + (x >> 1) + (y >> 1) * iWcount;  
935    
936           int32_t threshA, threshB;  static void
937          int32_t iFound, bPredEq;  SubpelRefine(const SearchData * const data)
938          int32_t iMinSAD, iSAD;  {
939    /* Do a half-pel or q-pel refinement */
940            const VECTOR centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;
941            int iDirection; //only needed because macro expects it
942    
943          int32_t iSubBlock = (y & 1) + (y & 1) + (x & 1);          CHECK_CANDIDATE(centerMV.x, centerMV.y - 1, 0);
944            CHECK_CANDIDATE(centerMV.x + 1, centerMV.y - 1, 0);
945            CHECK_CANDIDATE(centerMV.x + 1, centerMV.y, 0);
946            CHECK_CANDIDATE(centerMV.x + 1, centerMV.y + 1, 0);
947            CHECK_CANDIDATE(centerMV.x, centerMV.y + 1, 0);
948            CHECK_CANDIDATE(centerMV.x - 1, centerMV.y + 1, 0);
949            CHECK_CANDIDATE(centerMV.x - 1, centerMV.y, 0);
950            CHECK_CANDIDATE(centerMV.x - 1, centerMV.y - 1, 0);
951    }
952    
953          MainSearch8FuncPtr MainSearchPtr;  static __inline int
954    SkipDecisionP(const IMAGE * current, const IMAGE * reference,
955                                                            const int x, const int y,
956                                                            const uint32_t stride, const uint32_t iQuant, int rrv)
957    
958          /* Init variables */  {
959          startMV.x = start_x;          int offset = (x + y*stride)*8;
960          startMV.y = start_y;          if(!rrv) {
961                    uint32_t sadC = sad8(current->u + offset,
962                                                    reference->u + offset, stride);
963                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
964                    sadC += sad8(current->v + offset,
965                                                    reference->v + offset, stride);
966                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
967                    return 1;
968    
969          /* Get maximum range */          } else {
970          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,                  uint32_t sadC = sad16(current->u + 2*offset,
971                            iFcode);                                                  reference->u + 2*offset, stride, 256*4096);
972                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
973                    sadC += sad16(current->v + 2*offset,
974                                                    reference->v + 2*offset, stride, 256*4096);
975                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
976                    return 1;
977            }
978    }
979    
980          if (!(MotionFlags & PMV_HALFPELDIAMOND8)) {  static __inline void
981                  min_dx = EVEN(min_dx);  SkipMacroblockP(MACROBLOCK *pMB, const int32_t sad)
982                  max_dx = EVEN(max_dx);  {
983                  min_dy = EVEN(min_dy);          pMB->mode = MODE_NOT_CODED;
984                  max_dy = EVEN(max_dy);          pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = zeroMV;
985            pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = zeroMV;
986            pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
987          }          }
988    
989          /* because we might use IF (dx>max_dx) THEN dx=max_dx; */  bool
990          //bPredEq = get_pmvdata(pMBs, (x >> 1), (y >> 1), iWcount, iSubBlock, pmv, psad);  MotionEstimation(MBParam * const pParam,
991          bPredEq = get_pmvdata2(pMBs, iWcount, 0, (x >> 1), (y >> 1), iSubBlock, pmv, psad);                                   FRAMEINFO * const current,
992                                     FRAMEINFO * const reference,
993                                     const IMAGE * const pRefH,
994                                     const IMAGE * const pRefV,
995                                     const IMAGE * const pRefHV,
996                                     const uint32_t iLimit)
997    {
998            MACROBLOCK *const pMBs = current->mbs;
999            const IMAGE *const pCurrent = &current->image;
1000            const IMAGE *const pRef = &reference->image;
1001    
1002            uint32_t mb_width = pParam->mb_width;
1003            uint32_t mb_height = pParam->mb_height;
1004            const uint32_t iEdgedWidth = pParam->edged_width;
1005            const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags);
1006    
1007            uint32_t x, y;
1008            uint32_t iIntra = 0;
1009            int32_t quant = current->quant, sad00;
1010            int skip_thresh = \
1011                    INITIAL_SKIP_THRESH * \
1012                    (current->vop_flags & XVID_VOP_REDUCED ? 4:1) * \
1013                    (current->vop_flags & XVID_VOP_MODEDECISION_BITS ? 2:1);
1014    
1015            // some pre-initialized thingies for SearchP
1016            int32_t temp[8];
1017            VECTOR currentMV[5];
1018            VECTOR currentQMV[5];
1019            int32_t iMinSAD[5];
1020            DECLARE_ALIGNED_MATRIX(dct_space, 2, 64, int16_t, CACHE_LINE);
1021            SearchData Data;
1022            memset(&Data, 0, sizeof(SearchData));
1023            Data.iEdgedWidth = iEdgedWidth;
1024            Data.currentMV = currentMV;
1025            Data.currentQMV = currentQMV;
1026            Data.iMinSAD = iMinSAD;
1027            Data.temp = temp;
1028            Data.iFcode = current->fcode;
1029            Data.rounding = pParam->m_rounding_type;
1030            Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0);
1031            Data.chroma = MotionFlags & XVID_ME_CHROMA16;
1032            Data.rrv = (current->vop_flags & XVID_VOP_REDUCED ? 1:0);
1033            Data.dctSpace = dct_space;
1034    
1035            if ((current->vop_flags & XVID_VOP_REDUCED)) {
1036                    mb_width = (pParam->width + 31) / 32;
1037                    mb_height = (pParam->height + 31) / 32;
1038                    Data.qpel = 0;
1039            }
1040    
1041            Data.RefQ = pRefV->u; // a good place, also used in MC (for similar purpose)
1042            if (sadInit) (*sadInit) ();
1043    
1044            for (y = 0; y < mb_height; y++) {
1045                    for (x = 0; x < mb_width; x++)  {
1046                            MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];
1047    
1048                            if (!Data.rrv) pMB->sad16 =
1049                                    sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,
1050                                                            pRef->y + (x + y * iEdgedWidth) * 16,
1051                                                            pParam->edged_width, pMB->sad8 );
1052    
1053                            else pMB->sad16 =
1054                                    sad32v_c(pCurrent->y + (x + y * iEdgedWidth) * 32,
1055                                                            pRef->y + (x + y * iEdgedWidth) * 32,
1056                                                            pParam->edged_width, pMB->sad8 );
1057    
1058                            if (Data.chroma) {
1059                                    Data.temp[7] = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8,
1060                                                                            pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2)
1061                                                                    + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8,
1062                                                                            pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2);
1063                                    pMB->sad16 += Data.temp[7];
1064                            }
1065    
1066                            sad00 = pMB->sad16;
1067    
1068                            if (pMB->dquant != 0) {
1069                                    quant += DQtab[pMB->dquant];
1070                                    if (quant > 31) quant = 31;
1071                                    else if (quant < 1) quant = 1;
1072                            }
1073    
1074                            pMB->quant = current->quant;
1075    
1076    //initial skip decision
1077    /* no early skip for GMC (global vector = skip vector is unknown!)  */
1078                            if (!(current->vol_flags & XVID_VOL_GMC))       { /* no fast SKIP for S(GMC)-VOPs */
1079                                    if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh)
1080                                            if (Data.chroma || SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv)) {
1081                                                    SkipMacroblockP(pMB, sad00);
1082                                                    continue;
1083                                            }
1084                            }
1085    
1086          if ((x == 0) && (y == 0)) {                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,
1087                  threshA = 512 / 4;                                                  y, MotionFlags, current->vol_flags, pMB->quant,
1088                  threshB = 1024 / 4;                                                  &Data, pParam, pMBs, reference->mbs,
1089                                                    current->vop_flags & XVID_VOP_INTER4V, pMB);
1090    
1091          } else {  /* final skip decision, a.k.a. "the vector you found, really that good?" */
1092                  threshA = psad[0] / 4;  /* good estimate? */                          if (!(current->vol_flags & XVID_VOL_GMC || current->vop_flags & XVID_VOP_MODEDECISION_BITS)) {
1093                  threshB = threshA + 256 / 4;                                  if ( pMB->dquant == 0 && sad00 < pMB->quant * MAX_SAD00_FOR_SKIP) {
1094                  if (threshA < 512 / 4)                                          if ( (100*pMB->sad16)/(sad00+1) > FINAL_SKIP_THRESH * (Data.rrv ? 4:1) )
1095                          threshA = 512 / 4;                                                  if (Data.chroma || SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv))
1096                  if (threshA > 1024 / 4)                                                          SkipMacroblockP(pMB, sad00);
1097                          threshA = 1024 / 4;                                  }
1098                  if (threshB > 1792 / 4)                          }
1099                          threshB = 1792 / 4;                          if (pMB->mode == MODE_INTRA)
1100          }                                  if (++iIntra > iLimit) return 1;
1101                    }
1102          iFound = 0;          }
   
 /* Step 4: Calculate SAD around the Median prediction.  
    MinSAD=SAD  
    If Motion Vector equal to Previous frame motion vector  
    and MinSAD<PrevFrmSAD goto Step 10.  
    If SAD<=256 goto Step 10.  
 */  
1103    
1104            if (current->vol_flags & XVID_VOL_GMC ) /* GMC only for S(GMC)-VOPs */
1105                    current->warp = GlobalMotionEst( pMBs, pParam, current, reference, pRefH, pRefV, pRefHV);
1106    
1107  // Prepare for main loop          return 0;
1108    }
1109    
   if (MotionFlags & PMV_USESQUARES8)  
       MainSearchPtr = Square8_MainSearch;  
   else  
1110    
1111          if (MotionFlags & PMV_ADVANCEDDIAMOND8)  static __inline int
1112                  MainSearchPtr = AdvDiamond8_MainSearch;  make_mask(const VECTOR * const pmv, const int i)
1113          else  {
1114                  MainSearchPtr = Diamond8_MainSearch;          int mask = 255, j;
1115            for (j = 0; j < i; j++) {
1116                    if (MVequal(pmv[i], pmv[j])) return 0; // same vector has been checked already
1117                    if (pmv[i].x == pmv[j].x) {
1118                            if (pmv[i].y == pmv[j].y + iDiamondSize) mask &= ~4;
1119                            else if (pmv[i].y == pmv[j].y - iDiamondSize) mask &= ~8;
1120                    } else
1121                            if (pmv[i].y == pmv[j].y) {
1122                                    if (pmv[i].x == pmv[j].x + iDiamondSize) mask &= ~1;
1123                                    else if (pmv[i].x == pmv[j].x - iDiamondSize) mask &= ~2;
1124                            }
1125            }
1126            return mask;
1127    }
1128    
1129    static __inline void
1130    PreparePredictionsP(VECTOR * const pmv, int x, int y, int iWcount,
1131                            int iHcount, const MACROBLOCK * const prevMB, int rrv)
1132    {
1133    
1134          *currMV = startMV;  //this function depends on get_pmvdata which means that it sucks. It should get the predictions by itself
1135            if (rrv) { iWcount /= 2; iHcount /= 2; }
1136    
1137          iMinSAD =          if ( (y != 0) && (x < (iWcount-1)) ) {          // [5] top-right neighbour
1138                  sad8(cur,                  pmv[5].x = EVEN(pmv[3].x);
1139                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,                  pmv[5].y = EVEN(pmv[3].y);
1140                                                  iEdgedWidth), iEdgedWidth);          } else pmv[5].x = pmv[5].y = 0;
         iMinSAD +=  
                 calc_delta_8(currMV->x - center_x, currMV->y - center_y,  
                                          (uint8_t) iFcode, iQuant);  
   
         if ((iMinSAD < 256 / 4) || ((MVequal(*currMV, prevMB->mvs[iSubBlock]))  
                                                                 && ((int32_t) iMinSAD <  
                                                                         prevMB->sad8[iSubBlock]))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast8_Terminate_with_Refine;  
         }  
   
 /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion  
    vector of the median.  
    If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2  
 */  
1141    
1142          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[iSubBlock])))          if (x != 0) { pmv[3].x = EVEN(pmv[1].x); pmv[3].y = EVEN(pmv[1].y); }// pmv[3] is left neighbour
1143                  iFound = 2;          else pmv[3].x = pmv[3].y = 0;
1144    
1145  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.          if (y != 0) { pmv[4].x = EVEN(pmv[2].x); pmv[4].y = EVEN(pmv[2].y); }// [4] top neighbour
1146     Otherwise select large Diamond Search.          else pmv[4].x = pmv[4].y = 0;
 */  
1147    
1148          if ((!MVzero(pmv[0])) || (threshB < 1536 / 4) || (bPredEq))          // [1] median prediction
1149                  iDiamondSize = 1;               // 1 halfpel!          pmv[1].x = EVEN(pmv[0].x); pmv[1].y = EVEN(pmv[0].y);
         else  
                 iDiamondSize = 2;               // 2 halfpel = 1 full pixel!  
1150    
1151          if (!(MotionFlags & PMV_HALFPELDIAMOND8))          pmv[0].x = pmv[0].y = 0; // [0] is zero; not used in the loop (checked before) but needed here for make_mask
                 iDiamondSize *= 2;  
1152    
1153            pmv[2].x = EVEN(prevMB->mvs[0].x); // [2] is last frame
1154            pmv[2].y = EVEN(prevMB->mvs[0].y);
1155    
1156  /*          if ((x < iWcount-1) && (y < iHcount-1)) {
1157     Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.                  pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); //[6] right-down neighbour in last frame
1158     Also calculate (0,0) but do not subtract offset.                  pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y);
1159     Let MinSAD be the smallest SAD up to this point.          } else pmv[6].x = pmv[6].y = 0;
    If MV is (0,0) subtract offset.  
 */  
1160    
1161  // the median prediction might be even better than mv16          if (rrv) {
1162                    int i;
1163                    for (i = 0; i < 7; i++) {
1164                            pmv[i].x = RRV_MV_SCALEUP(pmv[i].x);
1165                            pmv[i].y = RRV_MV_SCALEUP(pmv[i].y);
1166                    }
1167            }
1168    }
1169    
1170          if (!MVequal(pmv[0], startMV))  static int
1171                  CHECK_MV8_CANDIDATE(center_x, center_y);  ModeDecision(const uint32_t iQuant, SearchData * const Data,
1172                    int inter4v,
1173                    MACROBLOCK * const pMB,
1174                    const MACROBLOCK * const pMBs,
1175                    const int x, const int y,
1176                    const MBParam * const pParam,
1177                    const uint32_t MotionFlags,
1178                    const uint32_t VopFlags)
1179    {
1180    
1181  // (0,0) if needed          int mode = MODE_INTER;
         if (!MVzero(pmv[0]))  
                 if (!MVzero(startMV))  
                         CHECK_MV8_ZERO;  
   
 // previous frame MV if needed  
         if (!MVzero(prevMB->mvs[iSubBlock]))  
                 if (!MVequal(prevMB->mvs[iSubBlock], startMV))  
                         if (!MVequal(prevMB->mvs[iSubBlock], pmv[0]))  
                                 CHECK_MV8_CANDIDATE(prevMB->mvs[iSubBlock].x,  
                                                                         prevMB->mvs[iSubBlock].y);  
   
         if ((iMinSAD <= threshA) ||  
                 (MVequal(*currMV, prevMB->mvs[iSubBlock]) &&  
                  ((int32_t) iMinSAD < prevMB->sad8[iSubBlock]))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast8_Terminate_with_Refine;  
         }  
   
 // left neighbour, if allowed and needed  
         if (!MVzero(pmv[1]))  
                 if (!MVequal(pmv[1], startMV))  
                         if (!MVequal(pmv[1], prevMB->mvs[iSubBlock]))  
                                 if (!MVequal(pmv[1], pmv[0])) {  
                                         if (!(MotionFlags & PMV_HALFPEL8)) {  
                                                 pmv[1].x = EVEN(pmv[1].x);  
                                                 pmv[1].y = EVEN(pmv[1].y);  
                                         }  
                                         CHECK_MV8_CANDIDATE(pmv[1].x, pmv[1].y);  
                                 }  
 // top neighbour, if allowed and needed  
         if (!MVzero(pmv[2]))  
                 if (!MVequal(pmv[2], startMV))  
                         if (!MVequal(pmv[2], prevMB->mvs[iSubBlock]))  
                                 if (!MVequal(pmv[2], pmv[0]))  
                                         if (!MVequal(pmv[2], pmv[1])) {  
                                                 if (!(MotionFlags & PMV_HALFPEL8)) {  
                                                         pmv[2].x = EVEN(pmv[2].x);  
                                                         pmv[2].y = EVEN(pmv[2].y);  
                                                 }  
                                                 CHECK_MV8_CANDIDATE(pmv[2].x, pmv[2].y);  
   
 // top right neighbour, if allowed and needed  
                                                 if (!MVzero(pmv[3]))  
                                                         if (!MVequal(pmv[3], startMV))  
                                                                 if (!MVequal(pmv[3], prevMB->mvs[iSubBlock]))  
                                                                         if (!MVequal(pmv[3], pmv[0]))  
                                                                                 if (!MVequal(pmv[3], pmv[1]))  
                                                                                         if (!MVequal(pmv[3], pmv[2])) {  
                                                                                                 if (!  
                                                                                                         (MotionFlags &  
                                                                                                          PMV_HALFPEL8)) {  
                                                                                                         pmv[3].x = EVEN(pmv[3].x);  
                                                                                                         pmv[3].y = EVEN(pmv[3].y);  
                                                                                                 }  
                                                                                                 CHECK_MV8_CANDIDATE(pmv[3].x,  
                                                                                                                                         pmv[3].y);  
                                                                                         }  
                                         }  
   
         if ((MVzero(*currMV)) &&  
                 (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )  
                 iMinSAD -= MV8_00_BIAS;  
1182    
1183            if (!(VopFlags & XVID_VOP_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision
1184                    int sad;
1185                    int InterBias = MV16_INTER_BIAS;
1186                    if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +
1187                            Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) {
1188                            mode = MODE_INTER;
1189                            sad = Data->iMinSAD[0];
1190                    } else {
1191                            mode = MODE_INTER4V;
1192                            sad = Data->iMinSAD[1] + Data->iMinSAD[2] +
1193                                                    Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant;
1194                            Data->iMinSAD[0] = sad;
1195                    }
1196    
1197  /* Step 6: If MinSAD <= thresa goto Step 10.                  /* intra decision */
    If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.  
 */  
1198    
1199          if ((iMinSAD <= threshA) ||                  if (iQuant > 8) InterBias += 100 * (iQuant - 8); // to make high quants work
1200                  (MVequal(*currMV, prevMB->mvs[iSubBlock]) &&                  if (y != 0)
1201                   ((int32_t) iMinSAD < prevMB->sad8[iSubBlock]))) {                          if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;
1202                  if (MotionFlags & PMV_QUICKSTOP16)                  if (x != 0)
1203                          goto PMVfast8_Terminate_without_Refine;                          if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80;
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast8_Terminate_with_Refine;  
         }  
   
 /************ (Diamond Search)  **************/  
 /*  
    Step 7: Perform Diamond search, with either the small or large diamond.  
    If Found=2 only examine one Diamond pattern, and afterwards goto step 10  
    Step 8: If small diamond, iterate small diamond search pattern until motion vector lies in the center of the diamond.  
    If center then goto step 10.  
    Step 9: If large diamond, iterate large diamond search pattern until motion vector lies in the center.  
    Refine by using small diamond and goto step 10.  
 */  
1204    
1205          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                  if (Data->chroma) InterBias += 50; // to compensate bigger SAD
1206                    if (Data->rrv) InterBias *= 4;
1207    
1208  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */                  if (InterBias < pMB->sad16) {
1209          iSAD =                          int32_t deviation;
1210                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,                          if (!Data->rrv) deviation = dev16(Data->Cur, Data->iEdgedWidth);
1211                                                    currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,                          else deviation = dev16(Data->Cur, Data->iEdgedWidth) +
1212                                                    min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,                                  dev16(Data->Cur+8, Data->iEdgedWidth) +
1213                                                    iQuant, iFound);                                  dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) +
1214                                    dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth);
1215    
1216          if (iSAD < iMinSAD) {                          if (deviation < (sad - InterBias)) return MODE_INTRA;
                 *currMV = newMV;  
                 iMinSAD = iSAD;  
1217          }          }
1218                    return mode;
1219    
1220          if (MotionFlags & PMV_EXTSEARCH8) {          } else {
 /* extended: search (up to) two more times: orignal prediction and (0,0) */  
1221    
1222                  if (!(MVequal(pmv[0], backupMV))) {                  int bits, intra, i;
1223                          iSAD =                  VECTOR backup[5], *v;
1224                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,                  Data->lambda16 = iQuant;
1225                                                                    pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,          Data->lambda8 = (pParam->vol_flags & XVID_VOL_MPEGQUANT)?1:0;
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
1226    
1227                          if (iSAD < iMinSAD) {                  v = Data->qpel ? Data->currentQMV : Data->currentMV;
1228                                  *currMV = newMV;                  for (i = 0; i < 5; i++) {
1229                                  iMinSAD = iSAD;                          Data->iMinSAD[i] = 256*4096;
1230                          }                          backup[i] = v[i];
1231                  }                  }
1232    
1233                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                  bits = CountMBBitsInter(Data, pMBs, x, y, pParam, MotionFlags);
1234                          iSAD =                  if (bits == 0) return MODE_INTER; // quick stop
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                                   iQuant, iFound);  
1235    
1236                          if (iSAD < iMinSAD) {                  if (inter4v) {
1237                                  *currMV = newMV;                          int bits_inter4v = CountMBBitsInter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1238                                  iMinSAD = iSAD;                          if (bits_inter4v < bits) { Data->iMinSAD[0] = bits = bits_inter4v; mode = MODE_INTER4V; }
1239                          }                          }
                 }  
         }  
   
 /* Step 10: The motion vector is chosen according to the block corresponding to MinSAD.  
    By performing an optional local half-pixel search, we can refine this result even further.  
 */  
1240    
   PMVfast8_Terminate_with_Refine:  
         if (MotionFlags & PMV_HALFPELREFINE8)   // perform final half-pel step  
                 iMinSAD =  
                         Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                         iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,  
                                                         iFcode, iQuant, iEdgedWidth);  
1241    
1242                    intra = CountMBBitsIntra(Data);
1243    
1244    PMVfast8_Terminate_without_Refine:                  if (intra < bits) { *Data->iMinSAD = bits = intra; return MODE_INTRA; }
         currPMV->x = currMV->x - center_x;  
         currPMV->y = currMV->y - center_y;  
1245    
1246          return iMinSAD;                  return mode;
1247            }
1248  }  }
1249    
1250  int32_t  static void
1251  EPZSSearch16(const uint8_t * const pRef,  SearchP(const IMAGE * const pRef,
1252                           const uint8_t * const pRefH,                           const uint8_t * const pRefH,
1253                           const uint8_t * const pRefV,                           const uint8_t * const pRefV,
1254                           const uint8_t * const pRefHV,                           const uint8_t * const pRefHV,
1255                           const IMAGE * const pCur,                           const IMAGE * const pCur,
1256                           const int x,                           const int x,
1257                           const int y,                           const int y,
                         const int start_x,  
                         const int start_y,  
                         const int center_x,  
                         const int center_y,  
1258                           const uint32_t MotionFlags,                           const uint32_t MotionFlags,
1259                    const uint32_t VopFlags,
1260                           const uint32_t iQuant,                           const uint32_t iQuant,
1261                           const uint32_t iFcode,                  SearchData * const Data,
1262                           const MBParam * const pParam,                           const MBParam * const pParam,
1263                           const MACROBLOCK * const pMBs,                           const MACROBLOCK * const pMBs,
1264                           const MACROBLOCK * const prevMBs,                           const MACROBLOCK * const prevMBs,
1265                           VECTOR * const currMV,                  int inter4v,
1266                           VECTOR * const currPMV)                  MACROBLOCK * const pMB)
1267  {  {
         const uint32_t iWcount = pParam->mb_width;  
         const uint32_t iHcount = pParam->mb_height;  
1268    
1269          const int32_t iWidth = pParam->width;          int i, iDirection = 255, mask, threshA;
1270          const int32_t iHeight = pParam->height;          VECTOR pmv[7];
         const int32_t iEdgedWidth = pParam->edged_width;  
1271    
1272          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1273                                                    pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
1274          int32_t min_dx;  
1275          int32_t max_dx;          get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp);
1276          int32_t min_dy;  
1277          int32_t max_dy;          Data->temp[5] = Data->temp[6] = 0; // chroma-sad cache
1278            i = Data->rrv ? 2 : 1;
1279            Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;
1280            Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1281            Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1282    
1283            Data->Ref = pRef->y + (x + Data->iEdgedWidth*y) * 16*i;
1284            Data->RefH = pRefH + (x + Data->iEdgedWidth*y) * 16*i;
1285            Data->RefV = pRefV + (x + Data->iEdgedWidth*y) * 16*i;
1286            Data->RefHV = pRefHV + (x + Data->iEdgedWidth*y) * 16*i;
1287            Data->RefCV = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1288            Data->RefCU = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1289    
1290            Data->lambda16 = lambda_vec16[iQuant];
1291            Data->lambda8 = lambda_vec8[iQuant];
1292            Data->qpel_precision = 0;
1293    
1294            if (pMB->dquant != 0) inter4v = 0;
1295    
1296            memset(Data->currentMV, 0, 5*sizeof(VECTOR));
1297    
1298            if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0);
1299            else Data->predMV = pmv[0];
1300    
1301            i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0, 0);
1302            Data->iMinSAD[0] = pMB->sad16 + ((Data->lambda16 * i * pMB->sad16)>>10);
1303            Data->iMinSAD[1] = pMB->sad8[0] + ((Data->lambda8 * i * (pMB->sad8[0]+NEIGH_8X8_BIAS)) >> 10);
1304            Data->iMinSAD[2] = pMB->sad8[1];
1305            Data->iMinSAD[3] = pMB->sad8[2];
1306            Data->iMinSAD[4] = pMB->sad8[3];
1307    
1308            if ((!(VopFlags & XVID_VOP_MODEDECISION_BITS)) || (x | y)) {
1309                    threshA = Data->temp[0]; // that's where we keep this SAD atm
1310                    if (threshA < 512) threshA = 512;
1311                    else if (threshA > 1024) threshA = 1024;
1312            } else
1313                    threshA = 512;
1314    
1315          VECTOR newMV;          PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height,
1316          VECTOR backupMV;                                          prevMBs + x + y * pParam->mb_width, Data->rrv);
1317    
1318          VECTOR pmv[4];          if (!Data->rrv) {
1319          int32_t psad[8];                  if (inter4v | Data->chroma) CheckCandidate = CheckCandidate16;
1320                            else CheckCandidate = CheckCandidate16no4v; //for extra speed
1321            } else CheckCandidate = CheckCandidate32;
1322    
1323    /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/
1324    
1325            for (i = 1; i < 7; i++) {
1326                    if (!(mask = make_mask(pmv, i)) ) continue;
1327                    CheckCandidate(pmv[i].x, pmv[i].y, mask, &iDirection, Data);
1328                    if (Data->iMinSAD[0] <= threshA) break;
1329            }
1330    
1331            if ((Data->iMinSAD[0] <= threshA) ||
1332                            (MVequal(Data->currentMV[0], (prevMBs+x+y*pParam->mb_width)->mvs[0]) &&
1333                            (Data->iMinSAD[0] < (prevMBs+x+y*pParam->mb_width)->sad16))) {
1334                    if (!(VopFlags & XVID_VOP_MODEDECISION_BITS)) inter4v = 0;      }
1335            else {
1336    
1337          static MACROBLOCK *oldMBs = NULL;                  MainSearchFunc * MainSearchPtr;
1338                    if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1339                    else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1340                            else MainSearchPtr = DiamondSearch;
1341    
1342  //  const MACROBLOCK * const pMB = pMBs + x + y * iWcount;                  MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
         const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;  
         MACROBLOCK *oldMB = NULL;  
1343    
1344           int32_t thresh2;  /* extended search, diamond starting in 0,0 and in prediction.
1345          int32_t bPredEq;          note that this search is/might be done in halfpel positions,
1346          int32_t iMinSAD, iSAD = 9999;          which makes it more different than the diamond above */
1347    
1348          MainSearch16FuncPtr MainSearchPtr;                  if (MotionFlags & XVID_ME_EXTSEARCH16) {
1349                            int32_t bSAD;
1350                            VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0];
1351                            if (Data->rrv) {
1352                                    startMV.x = RRV_MV_SCALEUP(startMV.x);
1353                                    startMV.y = RRV_MV_SCALEUP(startMV.y);
1354                            }
1355                            if (!(MVequal(startMV, backupMV))) {
1356                                    bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1357    
1358          if (oldMBs == NULL) {                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1359                  oldMBs = (MACROBLOCK *) calloc(iWcount * iHcount, sizeof(MACROBLOCK));                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);
1360  //      fprintf(stderr,"allocated %d bytes for oldMBs\n",iWcount*iHcount*sizeof(MACROBLOCK));                                  if (bSAD < Data->iMinSAD[0]) {
1361                                            Data->currentMV[0] = backupMV;
1362                                            Data->iMinSAD[0] = bSAD; }
1363          }          }
         oldMB = oldMBs + x + y * iWcount;  
1364    
1365  /* Get maximum range */                          backupMV = Data->currentMV[0];
1366          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,                          startMV.x = startMV.y = 1;
1367                            iFcode);                          if (!(MVequal(startMV, backupMV))) {
1368                                    bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1369    
1370          if (!(MotionFlags & PMV_HALFPEL16)) {                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1371                  min_dx = EVEN(min_dx);                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);
1372                  max_dx = EVEN(max_dx);                                  if (bSAD < Data->iMinSAD[0]) {
1373                  min_dy = EVEN(min_dy);                                          Data->currentMV[0] = backupMV;
1374                  max_dy = EVEN(max_dy);                                          Data->iMinSAD[0] = bSAD; }
1375                            }
1376                    }
1377          }          }
         /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */  
         //bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);  
         bPredEq = get_pmvdata2(pMBs, iWcount, 0, x, y, 0, pmv, psad);  
   
 /* Step 4: Calculate SAD around the Median prediction.  
         MinSAD=SAD  
         If Motion Vector equal to Previous frame motion vector  
                 and MinSAD<PrevFrmSAD goto Step 10.  
         If SAD<=256 goto Step 10.  
 */  
1378    
1379  // Prepare for main loop          if (MotionFlags & XVID_ME_HALFPELREFINE16)
1380                    if ((!(MotionFlags & XVID_ME_HALFPELREFINE16_BITS)) || Data->iMinSAD[0] < 200*(int)iQuant)
1381                            SubpelRefine(Data);
1382    
1383          currMV->x = start_x;          for(i = 0; i < 5; i++) {
1384          currMV->y = start_y;                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // initialize qpel vectors
1385                    Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
1386            }
1387    
1388          if (!(MotionFlags & PMV_HALFPEL16)) {          if (MotionFlags & XVID_ME_QUARTERPELREFINE16) {
                 currMV->x = EVEN(currMV->x);  
                 currMV->y = EVEN(currMV->y);  
         }  
   
         if (currMV->x > max_dx)  
                 currMV->x = max_dx;  
         if (currMV->x < min_dx)  
                 currMV->x = min_dx;  
         if (currMV->y > max_dy)  
                 currMV->y = max_dy;  
         if (currMV->y < min_dy)  
                 currMV->y = min_dy;  
   
 /***************** This is predictor SET A: only median prediction ******************/  
   
         iMinSAD =  
                 sad16(cur,  
                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,  
                                                  iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);  
         iMinSAD +=  
                 calc_delta_16(currMV->x - center_x, currMV->y - center_y,  
                                           (uint8_t) iFcode, iQuant);  
   
 // thresh1 is fixed to 256  
         if ((iMinSAD < 256) ||  
                 ((MVequal(*currMV, prevMB->mvs[0])) &&  
                  ((int32_t) iMinSAD < prevMB->sad16))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto EPZS16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto EPZS16_Terminate_with_Refine;  
         }  
   
 /************** This is predictor SET B: (0,0), prev.frame MV, neighbours **************/  
1389    
1390  // previous frame MV                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1391          CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);                                  pParam->width, pParam->height, Data->iFcode, 1, 0);
1392    
1393  // set threshhold based on Min of Prediction and SAD of collocated block                  if ((!(MotionFlags & XVID_ME_QUARTERPELREFINE16_BITS)) || (Data->iMinSAD[0] < 200*(int)iQuant)) {
1394  // CHECK_MV16 always uses iSAD for the SAD of last vector to check, so now iSAD is what we want                          Data->qpel_precision = 1;
1395                            SubpelRefine(Data);
1396                    }
1397            }
1398    
1399          if ((x == 0) && (y == 0)) {          if ((!(VopFlags & XVID_VOP_MODEDECISION_BITS)) && (Data->iMinSAD[0] < (int32_t)iQuant * 30)) inter4v = 0;
                 thresh2 = 512;  
         } else {  
 /* T_k = 1.2 * MIN(SAD_top,SAD_left,SAD_topleft,SAD_coll) +128;   [Tourapis, 2002] */  
1400    
1401                  thresh2 = MIN(psad[0], iSAD) * 6 / 5 + 128;          if (inter4v && (!(VopFlags & XVID_VOP_MODEDECISION_BITS) ||
1402          }                          (!(MotionFlags & XVID_ME_QUARTERPELREFINE8_BITS)) || (!(MotionFlags & XVID_ME_HALFPELREFINE8_BITS)) ||
1403                            ((!(MotionFlags & XVID_ME_EXTSEARCH_BITS)) && (!(MotionFlags&XVID_ME_EXTSEARCH8)) ))) {
1404                    // if decision is BITS-based and all refinement steps will be done in BITS domain, there is no reason to call this loop
1405    
1406  // MV=(0,0) is often a good choice                  SearchData Data8;
1407                    memcpy(&Data8, Data, sizeof(SearchData)); //quick copy of common data
1408    
1409          CHECK_MV16_ZERO;                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8);
1410                    Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8);
1411                    Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8);
1412                    Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);
1413    
1414                    if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_BITS))) {
1415                            // chroma is only used for comparsion to INTER. if the comparsion will be done in BITS domain, there is no reason to compute it
1416                            int sumx = 0, sumy = 0;
1417                            const int div = 1 + Data->qpel;
1418                            const VECTOR * const mv = Data->qpel ? pMB->qmvs : pMB->mvs;
1419    
1420  // left neighbour, if allowed                          for (i = 0; i < 4; i++) {
1421          if (x != 0) {                                  sumx += mv[i].x / div;
1422                  if (!(MotionFlags & PMV_HALFPEL16)) {                                  sumy += mv[i].y / div;
                         pmv[1].x = EVEN(pmv[1].x);  
                         pmv[1].y = EVEN(pmv[1].y);  
1423                  }                  }
1424                  CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);  
1425                            Data->iMinSAD[1] += ChromaSAD(  (sumx >> 3) + roundtab_76[sumx & 0xf],
1426                                                                                            (sumy >> 3) + roundtab_76[sumy & 0xf], Data);
1427          }          }
 // top neighbour, if allowed  
         if (y != 0) {  
                 if (!(MotionFlags & PMV_HALFPEL16)) {  
                         pmv[2].x = EVEN(pmv[2].x);  
                         pmv[2].y = EVEN(pmv[2].y);  
1428                  }                  }
                 CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
1429    
1430  // top right neighbour, if allowed          inter4v = ModeDecision(iQuant, Data, inter4v, pMB, pMBs, x, y, pParam, MotionFlags, VopFlags);
1431                  if ((uint32_t) x != (iWcount - 1)) {  
1432                          if (!(MotionFlags & PMV_HALFPEL16)) {          if (Data->rrv) {
1433                                  pmv[3].x = EVEN(pmv[3].x);                          Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
1434                                  pmv[3].y = EVEN(pmv[3].y);                          Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
1435                          }                          }
1436                          CHECK_MV16_CANDIDATE(pmv[3].x, pmv[3].y);  
1437            if (inter4v == MODE_INTER) {
1438                    pMB->mode = MODE_INTER;
1439                    pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
1440                    pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = Data->iMinSAD[0];
1441    
1442                    if(Data->qpel) {
1443                            pMB->qmvs[0] = pMB->qmvs[1]
1444                                    = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0];
1445                            pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x;
1446                            pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y;
1447                    } else {
1448                            pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x;
1449                            pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;
1450                  }                  }
1451    
1452            } else if (inter4v == MODE_INTER4V) {
1453                    pMB->mode = MODE_INTER4V;
1454                    pMB->sad16 = Data->iMinSAD[0];
1455            } else { // INTRA mode
1456                    SkipMacroblockP(pMB, 0); // not skip, but similar enough
1457                    pMB->mode = MODE_INTRA;
1458          }          }
1459    
1460  /* Terminate if MinSAD <= T_2  }
    Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]  
 */  
1461    
1462          if ((iMinSAD <= thresh2)  static void
1463                  || (MVequal(*currMV, prevMB->mvs[0]) &&  Search8(const SearchData * const OldData,
1464                          ((int32_t) iMinSAD <= prevMB->sad16))) {                  const int x, const int y,
1465                  if (MotionFlags & PMV_QUICKSTOP16)                  const uint32_t MotionFlags,
1466                          goto EPZS16_Terminate_without_Refine;                  const MBParam * const pParam,
1467                  if (MotionFlags & PMV_EARLYSTOP16)                  MACROBLOCK * const pMB,
1468                          goto EPZS16_Terminate_with_Refine;                  const MACROBLOCK * const pMBs,
1469                    const int block,
1470                    SearchData * const Data)
1471    {
1472            int i = 0;
1473            Data->iMinSAD = OldData->iMinSAD + 1 + block;
1474            Data->currentMV = OldData->currentMV + 1 + block;
1475            Data->currentQMV = OldData->currentQMV + 1 + block;
1476    
1477            if(Data->qpel) {
1478                    Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1479                    if (block != 0) i = d_mv_bits(  Data->currentQMV->x, Data->currentQMV->y,
1480                                                                                    Data->predMV, Data->iFcode, 0, 0);
1481            } else {
1482                    Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1483                    if (block != 0) i = d_mv_bits(  Data->currentMV->x, Data->currentMV->y,
1484                                                                                    Data->predMV, Data->iFcode, 0, Data->rrv);
1485          }          }
1486    
1487  /***** predictor SET C: acceleration MV (new!), neighbours in prev. frame(new!) ****/          *(Data->iMinSAD) += (Data->lambda8 * i * (*Data->iMinSAD + NEIGH_8X8_BIAS))>>10;
1488    
1489          backupMV = prevMB->mvs[0];      // collocated MV          if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) {
1490          backupMV.x += (prevMB->mvs[0].x - oldMB->mvs[0].x);     // acceleration X                  if (Data->rrv) i = 2; else i = 1;
         backupMV.y += (prevMB->mvs[0].y - oldMB->mvs[0].y);     // acceleration Y  
1491    
1492          CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y);                  Data->Ref = OldData->Ref + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1493                    Data->RefH = OldData->RefH + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1494                    Data->RefV = OldData->RefV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1495                    Data->RefHV = OldData->RefHV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1496    
1497  // left neighbour                  Data->Cur = OldData->Cur + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1498          if (x != 0)                  Data->qpel_precision = 0;
                 CHECK_MV16_CANDIDATE((prevMB - 1)->mvs[0].x, (prevMB - 1)->mvs[0].y);  
1499    
1500  // top neighbour                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1501          if (y != 0)                                          pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
                 CHECK_MV16_CANDIDATE((prevMB - iWcount)->mvs[0].x,  
                                                          (prevMB - iWcount)->mvs[0].y);  
1502    
1503  // right neighbour, if allowed (this value is not written yet, so take it from   pMB->mvs                  if (!Data->rrv) CheckCandidate = CheckCandidate8;
1504                    else CheckCandidate = CheckCandidate16no4v;
1505    
1506          if ((uint32_t) x != iWcount - 1)                  if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_BITS))) {
1507                  CHECK_MV16_CANDIDATE((prevMB + 1)->mvs[0].x, (prevMB + 1)->mvs[0].y);                          int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
1508    
1509  // bottom neighbour, dito                          MainSearchFunc *MainSearchPtr;
1510          if ((uint32_t) y != iHcount - 1)                          if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = SquareSearch;
1511                  CHECK_MV16_CANDIDATE((prevMB + iWcount)->mvs[0].x,                                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;
1512                                                           (prevMB + iWcount)->mvs[0].y);                                          else MainSearchPtr = DiamondSearch;
1513    
1514  /* Terminate if MinSAD <= T_3 (here T_3 = T_2)  */                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255);
1515          if (iMinSAD <= thresh2) {  
1516                  if (MotionFlags & PMV_QUICKSTOP16)                          if(*(Data->iMinSAD) < temp_sad) {
1517                          goto EPZS16_Terminate_without_Refine;                                          Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1518                  if (MotionFlags & PMV_EARLYSTOP16)                                          Data->currentQMV->y = 2 * Data->currentMV->y;
1519                          goto EPZS16_Terminate_with_Refine;                          }
1520          }          }
1521    
1522  /************ (if Diamond Search)  **************/                  if (MotionFlags & XVID_ME_HALFPELREFINE8) {
1523                            int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
1524    
1525          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                          SubpelRefine(Data); // perform halfpel refine of current best vector
1526    
1527          if (MotionFlags & PMV_USESQUARES16)                          if(*(Data->iMinSAD) < temp_sad) { // we have found a better match
1528                  MainSearchPtr = Square16_MainSearch;                                  Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1529          else                                  Data->currentQMV->y = 2 * Data->currentMV->y;
1530           if (MotionFlags & PMV_ADVANCEDDIAMOND16)                          }
1531                  MainSearchPtr = AdvDiamond16_MainSearch;                  }
         else  
                 MainSearchPtr = Diamond16_MainSearch;  
1532    
1533  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */                  if (Data->qpel && MotionFlags & XVID_ME_QUARTERPELREFINE8) {
1534                                    Data->qpel_precision = 1;
1535                                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1536                                            pParam->width, pParam->height, Data->iFcode, 1, 0);
1537                                    SubpelRefine(Data);
1538                    }
1539            }
1540    
1541          iSAD =          if (Data->rrv) {
1542                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,                          Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);
1543                                                    currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,                          Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);
1544                                                    min_dy, max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);          }
1545    
1546          if (iSAD < iMinSAD) {          if(Data->qpel) {
1547                  *currMV = newMV;                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x;
1548                  iMinSAD = iSAD;                  pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y;
1549                    pMB->qmvs[block] = *Data->currentQMV;
1550            } else {
1551                    pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x;
1552                    pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;
1553          }          }
1554    
1555            pMB->mvs[block] = *Data->currentMV;
1556            pMB->sad8[block] = 4 * *Data->iMinSAD;
1557    }
1558    
1559          if (MotionFlags & PMV_EXTSEARCH16) {  /* motion estimation for B-frames */
 /* extended mode: search (up to) two more times: orignal prediction and (0,0) */  
1560    
1561                  if (!(MVequal(pmv[0], backupMV))) {  static __inline VECTOR
1562                          iSAD =  ChoosePred(const MACROBLOCK * const pMB, const uint32_t mode)
1563                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  {
1564                                                                    pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,  /* the stupidiest function ever */
1565                                                                    min_dx, max_dx, min_dy, max_dy, iEdgedWidth,          return (mode == MODE_FORWARD ? pMB->mvs[0] : pMB->b_mvs[0]);
                                                                   2, iFcode, iQuant, 0);  
1566                  }                  }
1567    
1568                  if (iSAD < iMinSAD) {  static void __inline
1569                          *currMV = newMV;  PreparePredictionsBF(VECTOR * const pmv, const int x, const int y,
1570                          iMinSAD = iSAD;                                                          const uint32_t iWcount,
1571                  }                                                          const MACROBLOCK * const pMB,
1572                                                            const uint32_t mode_curr)
1573    {
1574    
1575                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {          // [0] is prediction
1576                          iSAD =          pmv[0].x = EVEN(pmv[0].x); pmv[0].y = EVEN(pmv[0].y);
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);  
1577    
1578                          if (iSAD < iMinSAD) {          pmv[1].x = pmv[1].y = 0; // [1] is zero
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
                         }  
                 }  
         }  
1579    
1580  /***************        Choose best MV found     **************/          pmv[2] = ChoosePred(pMB, mode_curr);
1581            pmv[2].x = EVEN(pmv[2].x); pmv[2].y = EVEN(pmv[2].y);
1582    
1583    EPZS16_Terminate_with_Refine:          if ((y != 0)&&(x != (int)(iWcount+1))) {                        // [3] top-right neighbour
1584          if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step                  pmv[3] = ChoosePred(pMB+1-iWcount, mode_curr);
1585                  iMinSAD =                  pmv[3].x = EVEN(pmv[3].x); pmv[3].y = EVEN(pmv[3].y);
1586                          Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,          } else pmv[3].x = pmv[3].y = 0;
                                                          iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,  
                                                          iFcode, iQuant, iEdgedWidth);  
1587    
1588    EPZS16_Terminate_without_Refine:          if (y != 0) {
1589                    pmv[4] = ChoosePred(pMB-iWcount, mode_curr);
1590                    pmv[4].x = EVEN(pmv[4].x); pmv[4].y = EVEN(pmv[4].y);
1591            } else pmv[4].x = pmv[4].y = 0;
1592    
1593          *oldMB = *prevMB;          if (x != 0) {
1594                    pmv[5] = ChoosePred(pMB-1, mode_curr);
1595                    pmv[5].x = EVEN(pmv[5].x); pmv[5].y = EVEN(pmv[5].y);
1596            } else pmv[5].x = pmv[5].y = 0;
1597    
1598          currPMV->x = currMV->x - center_x;          if (x != 0 && y != 0) {
1599          currPMV->y = currMV->y - center_y;                  pmv[6] = ChoosePred(pMB-1-iWcount, mode_curr);
1600          return iMinSAD;                  pmv[6].x = EVEN(pmv[6].x); pmv[6].y = EVEN(pmv[6].y);
1601            } else pmv[6].x = pmv[6].y = 0;
1602  }  }
1603    
1604    
1605  int32_t  /* search backward or forward */
1606  EPZSSearch8(const uint8_t * const pRef,  static void
1607    SearchBF(       const IMAGE * const pRef,
1608                          const uint8_t * const pRefH,                          const uint8_t * const pRefH,
1609                          const uint8_t * const pRefV,                          const uint8_t * const pRefV,
1610                          const uint8_t * const pRefHV,                          const uint8_t * const pRefHV,
1611                          const IMAGE * const pCur,                          const IMAGE * const pCur,
1612                          const int x,                          const int x, const int y,
                         const int y,  
                         const int start_x,  
                         const int start_y,  
                         const int center_x,  
                         const int center_y,  
1613                          const uint32_t MotionFlags,                          const uint32_t MotionFlags,
                         const uint32_t iQuant,  
1614                          const uint32_t iFcode,                          const uint32_t iFcode,
1615                          const MBParam * const pParam,                          const MBParam * const pParam,
1616                          const MACROBLOCK * const pMBs,                          MACROBLOCK * const pMB,
1617                          const MACROBLOCK * const prevMBs,                          const VECTOR * const predMV,
1618                          VECTOR * const currMV,                          int32_t * const best_sad,
1619                          VECTOR * const currPMV)                          const int32_t mode_current,
1620                            SearchData * const Data)
1621  {  {
 /* Please not that EPZS might not be a good choice for 8x8-block motion search ! */  
   
         const uint32_t iWcount = pParam->mb_width;  
         const int32_t iWidth = pParam->width;  
         const int32_t iHeight = pParam->height;  
         const int32_t iEdgedWidth = pParam->edged_width;  
   
         const uint8_t *cur = pCur->y + x * 8 + y * 8 * iEdgedWidth;  
   
         int32_t iDiamondSize = 1;  
1622    
1623          int32_t min_dx;          int i, iDirection = 255, mask;
1624          int32_t max_dx;          VECTOR pmv[7];
1625          int32_t min_dy;          MainSearchFunc *MainSearchPtr;
1626          int32_t max_dy;          *Data->iMinSAD = MV_MAX_ERROR;
1627            Data->iFcode = iFcode;
1628            Data->qpel_precision = 0;
1629            Data->temp[5] = Data->temp[6] = Data->temp[7] = 256*4096; // reset chroma-sad cache
1630    
1631          VECTOR newMV;          Data->Ref = pRef->y + (x + y * Data->iEdgedWidth) * 16;
1632          VECTOR backupMV;          Data->RefH = pRefH + (x + y * Data->iEdgedWidth) * 16;
1633            Data->RefV = pRefV + (x + y * Data->iEdgedWidth) * 16;
1634            Data->RefHV = pRefHV + (x + y * Data->iEdgedWidth) * 16;
1635            Data->RefCU = pRef->u + (x + y * Data->iEdgedWidth/2) * 8;
1636            Data->RefCV = pRef->v + (x + y * Data->iEdgedWidth/2) * 8;
1637    
1638          VECTOR pmv[4];          Data->predMV = *predMV;
         int32_t psad[8];  
1639    
1640          const int32_t iSubBlock = ((y & 1) << 1) + (x & 1);          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1641                                    pParam->width, pParam->height, iFcode - Data->qpel, 0, 0);
1642    
1643  //  const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;          pmv[0] = Data->predMV;
1644          const MACROBLOCK *const prevMB = prevMBs + (x >> 1) + (y >> 1) * iWcount;          if (Data->qpel) { pmv[0].x /= 2; pmv[0].y /= 2; }
1645    
1646          int32_t bPredEq;          PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current);
         int32_t iMinSAD, iSAD = 9999;  
1647    
1648          MainSearch8FuncPtr MainSearchPtr;          Data->currentMV->x = Data->currentMV->y = 0;
1649            CheckCandidate = CheckCandidate16no4v;
1650    
1651  /* Get maximum range */  // main loop. checking all predictions
1652          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,          for (i = 0; i < 7; i++) {
1653                            iFcode);                  if (!(mask = make_mask(pmv, i)) ) continue;
1654                    CheckCandidate16no4v(pmv[i].x, pmv[i].y, mask, &iDirection, Data);
 /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */  
   
         if (!(MotionFlags & PMV_HALFPEL8)) {  
                 min_dx = EVEN(min_dx);  
                 max_dx = EVEN(max_dx);  
                 min_dy = EVEN(min_dy);  
                 max_dy = EVEN(max_dy);  
1655          }          }
         /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */  
         //bPredEq = get_pmvdata(pMBs, x >> 1, y >> 1, iWcount, iSubBlock, pmv[0].x, pmv[0].y, psad);  
         bPredEq = get_pmvdata2(pMBs, iWcount, 0, x >> 1, y >> 1, iSubBlock, pmv, psad);  
1656    
1657            if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1658            else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1659                    else MainSearchPtr = DiamondSearch;
1660    
1661  /* Step 4: Calculate SAD around the Median prediction.          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
         MinSAD=SAD  
         If Motion Vector equal to Previous frame motion vector  
                 and MinSAD<PrevFrmSAD goto Step 10.  
         If SAD<=256 goto Step 10.  
 */  
   
 // Prepare for main loop  
1662    
1663            SubpelRefine(Data);
1664    
1665          if (!(MotionFlags & PMV_HALFPEL8)) {          if (Data->qpel && *Data->iMinSAD < *best_sad + 300) {
1666                  currMV->x = EVEN(currMV->x);                  Data->currentQMV->x = 2*Data->currentMV->x;
1667                  currMV->y = EVEN(currMV->y);                  Data->currentQMV->y = 2*Data->currentMV->y;
1668                    Data->qpel_precision = 1;
1669                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1670                                            pParam->width, pParam->height, iFcode, 1, 0);
1671                    SubpelRefine(Data);
1672          }          }
1673    
1674          if (currMV->x > max_dx)  // three bits are needed to code backward mode. four for forward
                 currMV->x = max_dx;  
         if (currMV->x < min_dx)  
                 currMV->x = min_dx;  
         if (currMV->y > max_dy)  
                 currMV->y = max_dy;  
         if (currMV->y < min_dy)  
                 currMV->y = min_dy;  
1675    
1676  /***************** This is predictor SET A: only median prediction ******************/          if (mode_current == MODE_FORWARD) *Data->iMinSAD += 4 * Data->lambda16;
1677            else *Data->iMinSAD += 3 * Data->lambda16;
1678    
1679            if (*Data->iMinSAD < *best_sad) {
1680                    *best_sad = *Data->iMinSAD;
1681                    pMB->mode = mode_current;
1682                    if (Data->qpel) {
1683                            pMB->pmvs[0].x = Data->currentQMV->x - predMV->x;
1684                            pMB->pmvs[0].y = Data->currentQMV->y - predMV->y;
1685                            if (mode_current == MODE_FORWARD)
1686                                    pMB->qmvs[0] = *Data->currentQMV;
1687                            else
1688                                    pMB->b_qmvs[0] = *Data->currentQMV;
1689                    } else {
1690                            pMB->pmvs[0].x = Data->currentMV->x - predMV->x;
1691                            pMB->pmvs[0].y = Data->currentMV->y - predMV->y;
1692                    }
1693                    if (mode_current == MODE_FORWARD) pMB->mvs[0] = *Data->currentMV;
1694                    else pMB->b_mvs[0] = *Data->currentMV;
1695            }
1696    
1697          iMinSAD =          if (mode_current == MODE_FORWARD) *(Data->currentMV+2) = *Data->currentMV;
1698                  sad8(cur,          else *(Data->currentMV+1) = *Data->currentMV; //we store currmv for interpolate search
1699                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,  }
1700                                                  iEdgedWidth), iEdgedWidth);  
1701          iMinSAD +=  static void
1702                  calc_delta_8(currMV->x - center_x, currMV->y - center_y,  SkipDecisionB(const IMAGE * const pCur,
1703                                           (uint8_t) iFcode, iQuant);                                  const IMAGE * const f_Ref,
1704                                    const IMAGE * const b_Ref,
1705                                    MACROBLOCK * const pMB,
1706                                    const uint32_t x, const uint32_t y,
1707                                    const SearchData * const Data)
1708    {
1709            int dx = 0, dy = 0, b_dx = 0, b_dy = 0;
1710            int32_t sum;
1711            const int div = 1 + Data->qpel;
1712            int k;
1713            const uint32_t stride = Data->iEdgedWidth/2;
1714    //this is not full chroma compensation, only it's fullpel approximation. should work though
1715    
1716            for (k = 0; k < 4; k++) {
1717                    dy += Data->directmvF[k].y / div;
1718                    dx += Data->directmvF[k].x / div;
1719                    b_dy += Data->directmvB[k].y / div;
1720                    b_dx += Data->directmvB[k].x / div;
1721            }
1722    
1723            dy = (dy >> 3) + roundtab_76[dy & 0xf];
1724            dx = (dx >> 3) + roundtab_76[dx & 0xf];
1725            b_dy = (b_dy >> 3) + roundtab_76[b_dy & 0xf];
1726            b_dx = (b_dx >> 3) + roundtab_76[b_dx & 0xf];
1727    
1728            sum = sad8bi(pCur->u + 8 * x + 8 * y * stride,
1729                                            f_Ref->u + (y*8 + dy/2) * stride + x*8 + dx/2,
1730                                            b_Ref->u + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
1731                                            stride);
1732    
1733            if (sum >= 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) return; //no skip
1734    
1735            sum += sad8bi(pCur->v + 8*x + 8 * y * stride,
1736                                            f_Ref->v + (y*8 + dy/2) * stride + x*8 + dx/2,
1737                                            b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
1738                                            stride);
1739    
1740  // thresh1 is fixed to 256          if (sum < 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) {
1741          if (iMinSAD < 256 / 4) {                  pMB->mode = MODE_DIRECT_NONE_MV; //skipped
1742                  if (MotionFlags & PMV_QUICKSTOP8)                  for (k = 0; k < 4; k++) {
1743                          goto EPZS8_Terminate_without_Refine;                          pMB->qmvs[k] = pMB->mvs[k];
1744                  if (MotionFlags & PMV_EARLYSTOP8)                          pMB->b_qmvs[k] = pMB->b_mvs[k];
1745                          goto EPZS8_Terminate_with_Refine;                  }
1746            }
1747          }          }
1748    
1749  /************** This is predictor SET B: (0,0), prev.frame MV, neighbours **************/  static __inline uint32_t
1750    SearchDirect(const IMAGE * const f_Ref,
1751                                    const uint8_t * const f_RefH,
1752                                    const uint8_t * const f_RefV,
1753                                    const uint8_t * const f_RefHV,
1754                                    const IMAGE * const b_Ref,
1755                                    const uint8_t * const b_RefH,
1756                                    const uint8_t * const b_RefV,
1757                                    const uint8_t * const b_RefHV,
1758                                    const IMAGE * const pCur,
1759                                    const int x, const int y,
1760                                    const uint32_t MotionFlags,
1761                                    const int32_t TRB, const int32_t TRD,
1762                                    const MBParam * const pParam,
1763                                    MACROBLOCK * const pMB,
1764                                    const MACROBLOCK * const b_mb,
1765                                    int32_t * const best_sad,
1766                                    SearchData * const Data)
1767    
1768    {
1769            int32_t skip_sad;
1770            int k = (x + Data->iEdgedWidth*y) * 16;
1771            MainSearchFunc *MainSearchPtr;
1772    
1773            *Data->iMinSAD = 256*4096;
1774            Data->Ref = f_Ref->y + k;
1775            Data->RefH = f_RefH + k;
1776            Data->RefV = f_RefV + k;
1777            Data->RefHV = f_RefHV + k;
1778            Data->bRef = b_Ref->y + k;
1779            Data->bRefH = b_RefH + k;
1780            Data->bRefV = b_RefV + k;
1781            Data->bRefHV = b_RefHV + k;
1782            Data->RefCU = f_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
1783            Data->RefCV = f_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
1784            Data->b_RefCU = b_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
1785            Data->b_RefCV = b_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
1786    
1787            k = Data->qpel ? 4 : 2;
1788            Data->max_dx = k * (pParam->width - x * 16);
1789            Data->max_dy = k * (pParam->height - y * 16);
1790            Data->min_dx = -k * (16 + x * 16);
1791            Data->min_dy = -k * (16 + y * 16);
1792    
1793            Data->referencemv = Data->qpel ? b_mb->qmvs : b_mb->mvs;
1794            Data->qpel_precision = 0;
1795    
1796  // MV=(0,0) is often a good choice          for (k = 0; k < 4; k++) {
1797          CHECK_MV8_ZERO;                  pMB->mvs[k].x = Data->directmvF[k].x = ((TRB * Data->referencemv[k].x) / TRD);
1798                    pMB->b_mvs[k].x = Data->directmvB[k].x = ((TRB - TRD) * Data->referencemv[k].x) / TRD;
1799                    pMB->mvs[k].y = Data->directmvF[k].y = ((TRB * Data->referencemv[k].y) / TRD);
1800                    pMB->b_mvs[k].y = Data->directmvB[k].y = ((TRB - TRD) * Data->referencemv[k].y) / TRD;
1801    
1802  // previous frame MV                  if ( (pMB->b_mvs[k].x > Data->max_dx) | (pMB->b_mvs[k].x < Data->min_dx)
1803          CHECK_MV8_CANDIDATE(prevMB->mvs[iSubBlock].x, prevMB->mvs[iSubBlock].y);                          | (pMB->b_mvs[k].y > Data->max_dy) | (pMB->b_mvs[k].y < Data->min_dy) ) {
1804    
1805  // left neighbour, if allowed                          *best_sad = 256*4096; // in that case, we won't use direct mode
1806          if (psad[1] != MV_MAX_ERROR) {                          pMB->mode = MODE_DIRECT; // just to make sure it doesn't say "MODE_DIRECT_NONE_MV"
1807                  if (!(MotionFlags & PMV_HALFPEL8)) {                          pMB->b_mvs[0].x = pMB->b_mvs[0].y = 0;
1808                          pmv[1].x = EVEN(pmv[1].x);                          return 256*4096;
                         pmv[1].y = EVEN(pmv[1].y);  
1809                  }                  }
1810                  CHECK_MV8_CANDIDATE(pmv[1].x, pmv[1].y);                  if (b_mb->mode != MODE_INTER4V) {
1811                            pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mvs[0];
1812                            pMB->b_mvs[1] = pMB->b_mvs[2] = pMB->b_mvs[3] = pMB->b_mvs[0];
1813                            Data->directmvF[1] = Data->directmvF[2] = Data->directmvF[3] = Data->directmvF[0];
1814                            Data->directmvB[1] = Data->directmvB[2] = Data->directmvB[3] = Data->directmvB[0];
1815                            break;
1816          }          }
 // top neighbour, if allowed  
         if (psad[2] != MV_MAX_ERROR) {  
                 if (!(MotionFlags & PMV_HALFPEL8)) {  
                         pmv[2].x = EVEN(pmv[2].x);  
                         pmv[2].y = EVEN(pmv[2].y);  
1817                  }                  }
                 CHECK_MV8_CANDIDATE(pmv[2].x, pmv[2].y);  
1818    
1819  // top right neighbour, if allowed          CheckCandidate = b_mb->mode == MODE_INTER4V ? CheckCandidateDirect : CheckCandidateDirectno4v;
1820                  if (psad[3] != MV_MAX_ERROR) {  
1821                          if (!(MotionFlags & PMV_HALFPEL8)) {          CheckCandidate(0, 0, 255, &k, Data);
1822                                  pmv[3].x = EVEN(pmv[3].x);  
1823                                  pmv[3].y = EVEN(pmv[3].y);  // initial (fast) skip decision
1824                          }          if (*Data->iMinSAD < pMB->quant * INITIAL_SKIP_THRESH * (2 + Data->chroma?1:0)) {
1825                          CHECK_MV8_CANDIDATE(pmv[3].x, pmv[3].y);                  //possible skip
1826                    if (Data->chroma) {
1827                            pMB->mode = MODE_DIRECT_NONE_MV;
1828                            return *Data->iMinSAD; // skip.
1829                    } else {
1830                            SkipDecisionB(pCur, f_Ref, b_Ref, pMB, x, y, Data);
1831                            if (pMB->mode == MODE_DIRECT_NONE_MV) return *Data->iMinSAD; // skip.
1832                  }                  }
1833          }          }
1834    
1835  /*  // this bias is zero anyway, at the moment!          *Data->iMinSAD += Data->lambda16;
1836            skip_sad = *Data->iMinSAD;
1837    
1838          if ( (MVzero(*currMV)) && (!MVzero(pmv[0])) ) // && (iMinSAD <= iQuant * 96)  //      DIRECT MODE DELTA VECTOR SEARCH.
1839                  iMinSAD -= MV8_00_BIAS;  //      This has to be made more effective, but at the moment I'm happy it's running at all
1840    
1841  */          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1842                    else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1843                            else MainSearchPtr = DiamondSearch;
1844    
1845  /* Terminate if MinSAD <= T_2          MainSearchPtr(0, 0, Data, 255);
    Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]  
 */  
1846    
1847          if (iMinSAD < 512 / 4) {        /* T_2 == 512/4 hardcoded */          SubpelRefine(Data);
                 if (MotionFlags & PMV_QUICKSTOP8)  
                         goto EPZS8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP8)  
                         goto EPZS8_Terminate_with_Refine;  
         }  
1848    
1849  /************ (Diamond Search)  **************/          *best_sad = *Data->iMinSAD;
1850    
1851          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */          if (Data->qpel || b_mb->mode == MODE_INTER4V) pMB->mode = MODE_DIRECT;
1852            else pMB->mode = MODE_DIRECT_NO4V; //for faster compensation
1853    
1854          if (!(MotionFlags & PMV_HALFPELDIAMOND8))          pMB->pmvs[3] = *Data->currentMV;
1855                  iDiamondSize *= 2;  
1856            for (k = 0; k < 4; k++) {
1857                    pMB->mvs[k].x = Data->directmvF[k].x + Data->currentMV->x;
1858                    pMB->b_mvs[k].x = (     (Data->currentMV->x == 0)
1859                                                            ? Data->directmvB[k].x
1860                                                            :pMB->mvs[k].x - Data->referencemv[k].x);
1861                    pMB->mvs[k].y = (Data->directmvF[k].y + Data->currentMV->y);
1862                    pMB->b_mvs[k].y = ((Data->currentMV->y == 0)
1863                                                            ? Data->directmvB[k].y
1864                                                            : pMB->mvs[k].y - Data->referencemv[k].y);
1865                    if (Data->qpel) {
1866                            pMB->qmvs[k].x = pMB->mvs[k].x; pMB->mvs[k].x /= 2;
1867                            pMB->b_qmvs[k].x = pMB->b_mvs[k].x; pMB->b_mvs[k].x /= 2;
1868                            pMB->qmvs[k].y = pMB->mvs[k].y; pMB->mvs[k].y /= 2;
1869                            pMB->b_qmvs[k].y = pMB->b_mvs[k].y; pMB->b_mvs[k].y /= 2;
1870                    }
1871    
1872                    if (b_mb->mode != MODE_INTER4V) {
1873                            pMB->mvs[3] = pMB->mvs[2] = pMB->mvs[1] = pMB->mvs[0];
1874                            pMB->b_mvs[3] = pMB->b_mvs[2] = pMB->b_mvs[1] = pMB->b_mvs[0];
1875                            pMB->qmvs[3] = pMB->qmvs[2] = pMB->qmvs[1] = pMB->qmvs[0];
1876                            pMB->b_qmvs[3] = pMB->b_qmvs[2] = pMB->b_qmvs[1] = pMB->b_qmvs[0];
1877                            break;
1878                    }
1879            }
1880            return skip_sad;
1881    }
1882    
1883    static void
1884    SearchInterpolate(const IMAGE * const f_Ref,
1885                                    const uint8_t * const f_RefH,
1886                                    const uint8_t * const f_RefV,
1887                                    const uint8_t * const f_RefHV,
1888                                    const IMAGE * const b_Ref,
1889                                    const uint8_t * const b_RefH,
1890                                    const uint8_t * const b_RefV,
1891                                    const uint8_t * const b_RefHV,
1892                                    const IMAGE * const pCur,
1893                                    const int x, const int y,
1894                                    const uint32_t fcode,
1895                                    const uint32_t bcode,
1896                                    const uint32_t MotionFlags,
1897                                    const MBParam * const pParam,
1898                                    const VECTOR * const f_predMV,
1899                                    const VECTOR * const b_predMV,
1900                                    MACROBLOCK * const pMB,
1901                                    int32_t * const best_sad,
1902                                    SearchData * const fData)
1903    
1904  /* default: use best prediction as starting point for one call of EPZS_MainSearch */  {
1905    
1906  // there is no EPZS^2 for inter4v at the moment          int iDirection, i, j;
1907            SearchData bData;
1908    
1909            fData->qpel_precision = 0;
1910            memcpy(&bData, fData, sizeof(SearchData)); //quick copy of common data
1911            *fData->iMinSAD = 4096*256;
1912            bData.currentMV++; bData.currentQMV++;
1913            fData->iFcode = bData.bFcode = fcode; fData->bFcode = bData.iFcode = bcode;
1914    
1915            i = (x + y * fData->iEdgedWidth) * 16;
1916            bData.bRef = fData->Ref = f_Ref->y + i;
1917            bData.bRefH = fData->RefH = f_RefH + i;
1918            bData.bRefV = fData->RefV = f_RefV + i;
1919            bData.bRefHV = fData->RefHV = f_RefHV + i;
1920            bData.Ref = fData->bRef = b_Ref->y + i;
1921            bData.RefH = fData->bRefH = b_RefH + i;
1922            bData.RefV = fData->bRefV = b_RefV + i;
1923            bData.RefHV = fData->bRefHV = b_RefHV + i;
1924            bData.b_RefCU = fData->RefCU = f_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
1925            bData.b_RefCV = fData->RefCV = f_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
1926            bData.RefCU = fData->b_RefCU = b_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
1927            bData.RefCV = fData->b_RefCV = b_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
1928    
1929    
1930            bData.bpredMV = fData->predMV = *f_predMV;
1931            fData->bpredMV = bData.predMV = *b_predMV;
1932            fData->currentMV[0] = fData->currentMV[2];
1933    
1934            get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 16, pParam->width, pParam->height, fcode - fData->qpel, 0, 0);
1935            get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode - fData->qpel, 0, 0);
1936    
1937            if (fData->currentMV[0].x > fData->max_dx) fData->currentMV[0].x = fData->max_dx;
1938            if (fData->currentMV[0].x < fData->min_dx) fData->currentMV[0].x = fData->min_dx;
1939            if (fData->currentMV[0].y > fData->max_dy) fData->currentMV[0].y = fData->max_dy;
1940            if (fData->currentMV[0].y < fData->min_dy) fData->currentMV[0].y = fData->min_dy;
1941    
1942            if (fData->currentMV[1].x > bData.max_dx) fData->currentMV[1].x = bData.max_dx;
1943            if (fData->currentMV[1].x < bData.min_dx) fData->currentMV[1].x = bData.min_dx;
1944            if (fData->currentMV[1].y > bData.max_dy) fData->currentMV[1].y = bData.max_dy;
1945            if (fData->currentMV[1].y < bData.min_dy) fData->currentMV[1].y = bData.min_dy;
1946    
1947    if (MotionFlags & PMV_USESQUARES8)          CheckCandidateInt(fData->currentMV[0].x, fData->currentMV[0].y, 255, &iDirection, fData);
       MainSearchPtr = Square8_MainSearch;  
   else  
1948    
1949          if (MotionFlags & PMV_ADVANCEDDIAMOND8)  //diamond
1950                  MainSearchPtr = AdvDiamond8_MainSearch;          do {
1951          else                  iDirection = 255;
1952                  MainSearchPtr = Diamond8_MainSearch;                  // forward MV moves
1953                    i = fData->currentMV[0].x; j = fData->currentMV[0].y;
1954    
1955                    CheckCandidateInt(i + 1, j, 0, &iDirection, fData);
1956                    CheckCandidateInt(i, j + 1, 0, &iDirection, fData);
1957                    CheckCandidateInt(i - 1, j, 0, &iDirection, fData);
1958                    CheckCandidateInt(i, j - 1, 0, &iDirection, fData);
1959    
1960                    // backward MV moves
1961                    i = fData->currentMV[1].x; j = fData->currentMV[1].y;
1962                    fData->currentMV[2] = fData->currentMV[0];
1963                    CheckCandidateInt(i + 1, j, 0, &iDirection, &bData);
1964                    CheckCandidateInt(i, j + 1, 0, &iDirection, &bData);
1965                    CheckCandidateInt(i - 1, j, 0, &iDirection, &bData);
1966                    CheckCandidateInt(i, j - 1, 0, &iDirection, &bData);
1967    
1968            } while (!(iDirection));
1969    
1970    //qpel refinement
1971            if (fData->qpel) {
1972                    if (*fData->iMinSAD > *best_sad + 500) return;
1973                    CheckCandidate = CheckCandidateInt;
1974                    fData->qpel_precision = bData.qpel_precision = 1;
1975                    get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 16, pParam->width, pParam->height, fcode, 1, 0);
1976                    get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode, 1, 0);
1977                    fData->currentQMV[2].x = fData->currentQMV[0].x = 2 * fData->currentMV[0].x;
1978                    fData->currentQMV[2].y = fData->currentQMV[0].y = 2 * fData->currentMV[0].y;
1979                    fData->currentQMV[1].x = 2 * fData->currentMV[1].x;
1980                    fData->currentQMV[1].y = 2 * fData->currentMV[1].y;
1981                    SubpelRefine(fData);
1982                    if (*fData->iMinSAD > *best_sad + 300) return;
1983                    fData->currentQMV[2] = fData->currentQMV[0];
1984                    SubpelRefine(&bData);
1985            }
1986    
1987            *fData->iMinSAD += (2+3) * fData->lambda16; // two bits are needed to code interpolate mode.
1988    
1989            if (*fData->iMinSAD < *best_sad) {
1990                    *best_sad = *fData->iMinSAD;
1991                    pMB->mvs[0] = fData->currentMV[0];
1992                    pMB->b_mvs[0] = fData->currentMV[1];
1993                    pMB->mode = MODE_INTERPOLATE;
1994                    if (fData->qpel) {
1995                            pMB->qmvs[0] = fData->currentQMV[0];
1996                            pMB->b_qmvs[0] = fData->currentQMV[1];
1997                            pMB->pmvs[1].x = pMB->qmvs[0].x - f_predMV->x;
1998                            pMB->pmvs[1].y = pMB->qmvs[0].y - f_predMV->y;
1999                            pMB->pmvs[0].x = pMB->b_qmvs[0].x - b_predMV->x;
2000                            pMB->pmvs[0].y = pMB->b_qmvs[0].y - b_predMV->y;
2001                    } else {
2002                            pMB->pmvs[1].x = pMB->mvs[0].x - f_predMV->x;
2003                            pMB->pmvs[1].y = pMB->mvs[0].y - f_predMV->y;
2004                            pMB->pmvs[0].x = pMB->b_mvs[0].x - b_predMV->x;
2005                            pMB->pmvs[0].y = pMB->b_mvs[0].y - b_predMV->y;
2006                    }
2007            }
2008    }
2009    
2010          iSAD =  void
2011                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,  MotionEstimationBVOP(MBParam * const pParam,
2012                                                    currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,                                           FRAMEINFO * const frame,
2013                                                    min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,                                           const int32_t time_bp,
2014                                                    iQuant, 0);                                           const int32_t time_pp,
2015                                             // forward (past) reference
2016                                             const MACROBLOCK * const f_mbs,
2017                                             const IMAGE * const f_ref,
2018                                             const IMAGE * const f_refH,
2019                                             const IMAGE * const f_refV,
2020                                             const IMAGE * const f_refHV,
2021                                             // backward (future) reference
2022                                             const FRAMEINFO * const b_reference,
2023                                             const IMAGE * const b_ref,
2024                                             const IMAGE * const b_refH,
2025                                             const IMAGE * const b_refV,
2026                                             const IMAGE * const b_refHV)
2027    {
2028            uint32_t i, j;
2029            int32_t best_sad;
2030            uint32_t skip_sad;
2031            int f_count = 0, b_count = 0, i_count = 0, d_count = 0, n_count = 0;
2032            const MACROBLOCK * const b_mbs = b_reference->mbs;
2033    
2034            VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/
2035    
2036          if (iSAD < iMinSAD) {          const int32_t TRB = time_pp - time_bp;
2037                  *currMV = newMV;          const int32_t TRD = time_pp;
                 iMinSAD = iSAD;  
         }  
2038    
2039          if (MotionFlags & PMV_EXTSEARCH8) {  // some pre-inintialized data for the rest of the search
 /* extended mode: search (up to) two more times: orignal prediction and (0,0) */  
2040    
2041                  if (!(MVequal(pmv[0], backupMV))) {          SearchData Data;
2042                          iSAD =          int32_t iMinSAD;
2043                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,          VECTOR currentMV[3];
2044                                                                    pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,          VECTOR currentQMV[3];
2045                                                                    min_dx, max_dx, min_dy, max_dy, iEdgedWidth,          int32_t temp[8];
2046                                                                    iDiamondSize, iFcode, iQuant, 0);          memset(&Data, 0, sizeof(SearchData));
2047            Data.iEdgedWidth = pParam->edged_width;
2048            Data.currentMV = currentMV; Data.currentQMV = currentQMV;
2049            Data.iMinSAD = &iMinSAD;
2050            Data.lambda16 = lambda_vec16[frame->quant];
2051            Data.qpel = pParam->vol_flags & XVID_VOL_QUARTERPEL;
2052            Data.rounding = 0;
2053            Data.chroma = frame->motion_flags & XVID_ME_CHROMA8;
2054            Data.temp = temp;
2055    
2056                          if (iSAD < iMinSAD) {          Data.RefQ = f_refV->u; // a good place, also used in MC (for similar purpose)
2057                                  *currMV = newMV;          // note: i==horizontal, j==vertical
2058                                  iMinSAD = iSAD;          for (j = 0; j < pParam->mb_height; j++) {
                         }  
                 }  
2059    
2060                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                  f_predMV = b_predMV = zeroMV;   /* prediction is reset at left boundary */
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                                   iQuant, 0);  
2061    
2062                          if (iSAD < iMinSAD) {                  for (i = 0; i < pParam->mb_width; i++) {
2063                                  *currMV = newMV;                          MACROBLOCK * const pMB = frame->mbs + i + j * pParam->mb_width;
2064                                  iMinSAD = iSAD;                          const MACROBLOCK * const b_mb = b_mbs + i + j * pParam->mb_width;
2065                          }  
2066                  }  /* special case, if collocated block is SKIPed in P-VOP: encoding is forward (0,0), cpb=0 without further ado */
2067                            if (b_reference->coding_type != S_VOP)
2068                                    if (b_mb->mode == MODE_NOT_CODED) {
2069                                            pMB->mode = MODE_NOT_CODED;
2070                                            continue;
2071          }          }
2072    
2073  /***************        Choose best MV found     **************/                          Data.Cur = frame->image.y + (j * Data.iEdgedWidth + i) * 16;
2074                            Data.CurU = frame->image.u + (j * Data.iEdgedWidth/2 + i) * 8;
2075    EPZS8_Terminate_with_Refine:                          Data.CurV = frame->image.v + (j * Data.iEdgedWidth/2 + i) * 8;
2076          if (MotionFlags & PMV_HALFPELREFINE8)   // perform final half-pel step                          pMB->quant = frame->quant;
2077                  iMinSAD =  
2078                          Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  /* direct search comes first, because it (1) checks for SKIP-mode
2079                                                          iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,          and (2) sets very good predictions for forward and backward search */
2080                                                          iFcode, iQuant, iEdgedWidth);                          skip_sad = SearchDirect(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2081                                                                            b_ref, b_refH->y, b_refV->y, b_refHV->y,
2082                                                                            &frame->image,
2083                                                                            i, j,
2084                                                                            frame->motion_flags,
2085                                                                            TRB, TRD,
2086                                                                            pParam,
2087                                                                            pMB, b_mb,
2088                                                                            &best_sad,
2089                                                                            &Data);
2090    
2091    EPZS8_Terminate_without_Refine:                          if (pMB->mode == MODE_DIRECT_NONE_MV) { n_count++; continue; }
2092    
2093          currPMV->x = currMV->x - center_x;                          // forward search
2094          currPMV->y = currMV->y - center_y;                          SearchBF(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2095          return iMinSAD;                                                  &frame->image, i, j,
2096  }                                                  frame->motion_flags,
2097                                                    frame->fcode, pParam,
2098                                                    pMB, &f_predMV, &best_sad,
2099                                                    MODE_FORWARD, &Data);
2100    
2101                            // backward search
2102                            SearchBF(b_ref, b_refH->y, b_refV->y, b_refHV->y,
2103                                                    &frame->image, i, j,
2104                                                    frame->motion_flags,
2105                                                    frame->bcode, pParam,
2106                                                    pMB, &b_predMV, &best_sad,
2107                                                    MODE_BACKWARD, &Data);
2108    
2109                            // interpolate search comes last, because it uses data from forward and backward as prediction
2110                            SearchInterpolate(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2111                                                    b_ref, b_refH->y, b_refV->y, b_refHV->y,
2112                                                    &frame->image,
2113                                                    i, j,
2114                                                    frame->fcode, frame->bcode,
2115                                                    frame->motion_flags,
2116                                                    pParam,
2117                                                    &f_predMV, &b_predMV,
2118                                                    pMB, &best_sad,
2119                                                    &Data);
2120    
2121    // final skip decision
2122                            if ( (skip_sad < frame->quant * MAX_SAD00_FOR_SKIP * 2)
2123                                            && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) )
2124                                    SkipDecisionB(&frame->image, f_ref, b_ref, pMB, i, j, &Data);
2125    
2126                            switch (pMB->mode) {
2127                                    case MODE_FORWARD:
2128                                            f_count++;
2129                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2130                                            break;
2131                                    case MODE_BACKWARD:
2132                                            b_count++;
2133                                            b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2134                                            break;
2135                                    case MODE_INTERPOLATE:
2136                                            i_count++;
2137                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2138                                            b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2139                                            break;
2140                                    case MODE_DIRECT:
2141                                    case MODE_DIRECT_NO4V:
2142                                            d_count++;
2143                                    default:
2144                                            break;
2145                            }
2146                    }
2147            }
2148    }
2149    
2150  int32_t  static __inline void
2151  PMVfastIntSearch16(const uint8_t * const pRef,  MEanalyzeMB (   const uint8_t * const pRef,
2152                                  const uint8_t * const pRefH,                                  const uint8_t * const pCur,
                                 const uint8_t * const pRefV,  
                                 const uint8_t * const pRefHV,  
                                 const IMAGE * const pCur,  
2153                                  const int x,                                  const int x,
2154                                  const int y,                                  const int y,
                                 const int start_x,              /* start should be most likely vector */  
                                 const int start_y,  
                                 const int center_x,             /* center is from where length of MVs is measured */  
                                 const int center_y,  
                                 const uint32_t MotionFlags,  
                                 const uint32_t iQuant,  
                                 const uint32_t iFcode,  
2155                                  const MBParam * const pParam,                                  const MBParam * const pParam,
2156                                  const MACROBLOCK * const pMBs,                                  MACROBLOCK * const pMBs,
2157                                  const MACROBLOCK * const prevMBs,                                  SearchData * const Data)
                                 VECTOR * const currMV,  
                                 VECTOR * const currPMV)  
2158  {  {
         const uint32_t iWcount = pParam->mb_width;  
         const int32_t iWidth = pParam->width;  
         const int32_t iHeight = pParam->height;  
         const int32_t iEdgedWidth = pParam->edged_width;  
2159    
2160          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;          int i, mask;
2161          const VECTOR zeroMV = { 0, 0 };          int quarterpel = (pParam->vol_flags & XVID_VOL_QUARTERPEL)? 1: 0;
2162            VECTOR pmv[3];
2163            MACROBLOCK * const pMB = &pMBs[x + y * pParam->mb_width];
2164    
2165            for (i = 0; i < 5; i++) Data->iMinSAD[i] = MV_MAX_ERROR;
2166    
2167          int32_t iDiamondSize;          //median is only used as prediction. it doesn't have to be real
2168            if (x == 1 && y == 1) Data->predMV.x = Data->predMV.y = 0;
2169            else
2170                    if (x == 1) //left macroblock does not have any vector now
2171                            Data->predMV = (pMB - pParam->mb_width)->mvs[0]; // top instead of median
2172                    else if (y == 1) // top macroblock doesn't have it's vector
2173                            Data->predMV = (pMB - 1)->mvs[0]; // left instead of median
2174                            else Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); //else median
2175    
2176          int32_t min_dx;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2177          int32_t max_dx;          pParam->width, pParam->height, Data->iFcode - quarterpel, 0, 0);
         int32_t min_dy;  
         int32_t max_dy;  
2178    
2179          int32_t iFound;          Data->Cur = pCur + (x + y * pParam->edged_width) * 16;
2180            Data->Ref = pRef + (x + y * pParam->edged_width) * 16;
2181    
2182          VECTOR newMV;          pmv[1].x = EVEN(pMB->mvs[0].x);
2183          VECTOR backupMV;          pmv[1].y = EVEN(pMB->mvs[0].y);
2184            pmv[2].x = EVEN(Data->predMV.x);
2185            pmv[2].y = EVEN(Data->predMV.y);
2186            pmv[0].x = pmv[0].y = 0;
2187    
2188          VECTOR pmv[4];          CheckCandidate32I(0, 0, 255, &i, Data);
2189          int32_t psad[4];          Data->iMinSAD[1] -= 50;
2190            Data->iMinSAD[2] -= 50;
2191            Data->iMinSAD[3] -= 50;
2192            Data->iMinSAD[4] -= 50;
2193    
2194          MainSearch16FuncPtr MainSearchPtr;          if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP) {
2195    
2196          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;                  if (!(mask = make_mask(pmv, 1)))
2197          MACROBLOCK *const pMB = pMBs + x + y * iWcount;                          CheckCandidate32I(pmv[1].x, pmv[1].y, mask, &i, Data);
2198                    if (!(mask = make_mask(pmv, 2)))
2199                            CheckCandidate32I(pmv[2].x, pmv[2].y, mask, &i, Data);
2200    
2201          int32_t threshA, threshB;                  if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP) // diamond only if needed
2202          int32_t bPredEq;                          DiamondSearch(Data->currentMV->x, Data->currentMV->y, Data, i);
2203          int32_t iMinSAD, iSAD;          }
2204    
2205            for (i = 0; i < 4; i++) {
2206                    MACROBLOCK * MB = &pMBs[x + (i&1) + (y+(i>>1)) * pParam->mb_width];
2207                    MB->mvs[0] = MB->mvs[1] = MB->mvs[2] = MB->mvs[3] = Data->currentMV[i];
2208                    MB->mode = MODE_INTER;
2209                    MB->sad16 = Data->iMinSAD[i+1];
2210            }
2211    }
2212    
2213  /* Get maximum range */  #define INTRA_THRESH    2400
2214          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,  #define INTER_THRESH    1100
                           iFcode);  
2215    
2216  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */  int
2217    MEanalysis(     const IMAGE * const pRef,
2218                            const FRAMEINFO * const Current,
2219                            const MBParam * const pParam,
2220                            const int maxIntra, //maximum number if non-I frames
2221                            const int intraCount, //number of non-I frames after last I frame; 0 if we force P/B frame
2222                            const int bCount,  // number of B frames in a row
2223                            const int b_thresh)
2224    {
2225            uint32_t x, y, intra = 0;
2226            int sSAD = 0;
2227            MACROBLOCK * const pMBs = Current->mbs;
2228            const IMAGE * const pCurrent = &Current->image;
2229            int IntraThresh = INTRA_THRESH, InterThresh = INTER_THRESH + 10*b_thresh;
2230            int s = 0, blocks = 0;
2231    
2232            int32_t iMinSAD[5], temp[5];
2233            VECTOR currentMV[5];
2234            SearchData Data;
2235            Data.iEdgedWidth = pParam->edged_width;
2236            Data.currentMV = currentMV;
2237            Data.iMinSAD = iMinSAD;
2238            Data.iFcode = Current->fcode;
2239            Data.temp = temp;
2240            CheckCandidate = CheckCandidate32I;
2241    
2242          if ((x == 0) && (y == 0)) {          if (intraCount != 0 && intraCount < 10) // we're right after an I frame
2243                  threshA = 512;                  IntraThresh += 8 * (intraCount - 10) * (intraCount - 10);
2244                  threshB = 1024;          else
2245                    if ( 5*(maxIntra - intraCount) < maxIntra) // we're close to maximum. 2 sec when max is 10 sec
2246                            IntraThresh -= (IntraThresh * (maxIntra - 5*(maxIntra - intraCount)))/maxIntra;
2247    
2248                  bPredEq = 0;          InterThresh -= (350 - 8*b_thresh) * bCount;
2249                  psad[0] = psad[1] = psad[2] = psad[3] = 0;          if (InterThresh < 300 + 5*b_thresh) InterThresh = 300 + 5*b_thresh;
                 *currMV = pmv[0] = pmv[1] = pmv[2] = pmv[3] = zeroMV;  
2250    
2251          } else {          if (sadInit) (*sadInit) ();
                 threshA = psad[0];  
                 threshB = threshA + 256;  
                 if (threshA < 512)  
                         threshA = 512;  
                 if (threshA > 1024)  
                         threshA = 1024;  
                 if (threshB > 1792)  
                         threshB = 1792;  
   
                 bPredEq = get_ipmvdata(pMBs, iWcount, 0, x, y, 0, pmv, psad);  
                 *currMV = pmv[0];                       /* current best := prediction */  
         }  
   
         iFound = 0;  
   
 /* Step 4: Calculate SAD around the Median prediction.  
    MinSAD=SAD  
    If Motion Vector equal to Previous frame motion vector  
    and MinSAD<PrevFrmSAD goto Step 10.  
    If SAD<=256 goto Step 10.  
 */  
2252    
2253          if (currMV->x > max_dx) {          for (y = 1; y < pParam->mb_height-1; y += 2) {
2254                  currMV->x = EVEN(max_dx);                  for (x = 1; x < pParam->mb_width-1; x += 2) {
2255                            int i;
2256                            blocks += 4;
2257    
2258                            if (bCount == 0) pMBs[x + y * pParam->mb_width].mvs[0] = zeroMV;
2259                            else { //extrapolation of the vector found for last frame
2260                                    pMBs[x + y * pParam->mb_width].mvs[0].x =
2261                                            (pMBs[x + y * pParam->mb_width].mvs[0].x * (bCount+1) ) / bCount;
2262                                    pMBs[x + y * pParam->mb_width].mvs[0].y =
2263                                            (pMBs[x + y * pParam->mb_width].mvs[0].y * (bCount+1) ) / bCount;
2264                            }
2265    
2266                            MEanalyzeMB(pRef->y, pCurrent->y, x, y, pParam, pMBs, &Data);
2267    
2268                            for (i = 0; i < 4; i++) {
2269                                    int dev;
2270                                    MACROBLOCK *pMB = &pMBs[x+(i&1) + (y+(i>>1)) * pParam->mb_width];
2271                                    if (pMB->sad16 > IntraThresh) {
2272                                            dev = dev16(pCurrent->y + (x + (i&1) + (y + (i>>1)) * pParam->edged_width) * 16,
2273                                                                            pParam->edged_width);
2274                                            if (dev + IntraThresh < pMB->sad16) {
2275                                                    pMB->mode = MODE_INTRA;
2276                                                    if (++intra > ((pParam->mb_height-2)*(pParam->mb_width-2))/2) return I_VOP;
2277          }          }
         if (currMV->x < min_dx) {  
                 currMV->x = EVEN(min_dx);  
2278          }          }
2279          if (currMV->y > max_dy) {                                  if (pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0) s++;
2280                  currMV->y = EVEN(max_dy);  
2281                                    sSAD += pMB->sad16;
2282                            }
2283          }          }
         if (currMV->y < min_dy) {  
                 currMV->y = EVEN(min_dy);  
2284          }          }
2285    
2286          iMinSAD =          sSAD /= blocks;
2287                  sad16(cur,          s = (10*s) / blocks;
                           get_iref_mv(pRef, x, y, 16, currMV,  
                                                  iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);  
         iMinSAD +=  
                 calc_delta_16(currMV->x - center_x, currMV->y - center_y,  
                                           (uint8_t) iFcode, iQuant);  
2288    
2289          if ((iMinSAD < 256) ||          if (s > 5) sSAD += (s - 4) * (180 - 2*b_thresh); //static block - looks bad when in bframe...
                 ((MVequal(*currMV, prevMB->i_mvs[0])) &&  
                  ((int32_t) iMinSAD < prevMB->i_sad16))) {  
                 if (iMinSAD < 2 * iQuant)       // high chances for SKIP-mode  
                 {  
                         if (!MVzero(*currMV)) {  
                                 iMinSAD += MV16_00_BIAS;  
                                 CHECK_MV16_ZERO;        // (0,0) saves space for letterboxed pictures  
                                 iMinSAD -= MV16_00_BIAS;  
                         }  
                 }  
2290    
2291                  if (MotionFlags & PMV_EARLYSTOP16)          if (sSAD > InterThresh ) return P_VOP;
2292                          goto PMVfastInt16_Terminate_with_Refine;          emms();
2293            return B_VOP;
2294          }          }
2295    
2296    
2297  /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion  static WARPPOINTS
2298     vector of the median.  GlobalMotionEst(const MACROBLOCK * const pMBs,
2299     If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2                                  const MBParam * const pParam,
2300  */                                  const FRAMEINFO * const current,
2301                                    const FRAMEINFO * const reference,
2302          if ((bPredEq) && (MVequal(pmv[0], prevMB->i_mvs[0])))                                  const IMAGE * const pRefH,
2303                  iFound = 2;                                  const IMAGE * const pRefV,
2304                                    const IMAGE * const pRefHV      )
2305    {
2306    
2307  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.          const int deltax=8;             // upper bound for difference between a MV and it's neighbour MVs
2308     Otherwise select large Diamond Search.          const int deltay=8;
2309  */          const int grad=512;             // lower bound for deviation in MB
2310    
2311          if ((!MVzero(pmv[0])) || (threshB < 1536) || (bPredEq))          WARPPOINTS gmc;
                 iDiamondSize = 2;               // halfpel units!  
         else  
                 iDiamondSize = 4;               // halfpel units!  
2312    
2313  /*          uint32_t mx, my;
    Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.  
    Also calculate (0,0) but do not subtract offset.  
    Let MinSAD be the smallest SAD up to this point.  
    If MV is (0,0) subtract offset.  
 */  
2314    
2315  // (0,0) is often a good choice          int MBh = pParam->mb_height;
2316            int MBw = pParam->mb_width;
2317    
2318          if (!MVzero(pmv[0]))          int *MBmask= calloc(MBh*MBw,sizeof(int));
2319                  CHECK_MV16_ZERO;          double DtimesF[4] = { 0.,0., 0., 0. };
2320            double sol[4] = { 0., 0., 0., 0. };
2321            double a,b,c,n,denom;
2322            double meanx,meany;
2323            int num,oldnum;
2324    
2325  // previous frame MV is always possible          if (!MBmask) { fprintf(stderr,"Mem error\n");
2326                                   gmc.duv[0].x= gmc.duv[0].y =
2327                                                    gmc.duv[1].x= gmc.duv[1].y =
2328                                                    gmc.duv[2].x= gmc.duv[2].y = 0;
2329                                            return gmc; }
2330    
2331          if (!MVzero(prevMB->i_mvs[0]))  // filter mask of all blocks
                 if (!MVequal(prevMB->i_mvs[0], pmv[0]))  
                         CHECK_MV16_CANDIDATE(prevMB->i_mvs[0].x, prevMB->i_mvs[0].y);  
   
 // left neighbour, if allowed  
   
         if (!MVzero(pmv[1]))  
                 if (!MVequal(pmv[1], prevMB->i_mvs[0]))  
                         if (!MVequal(pmv[1], pmv[0]))  
                                 CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);  
   
 // top neighbour, if allowed  
         if (!MVzero(pmv[2]))  
                 if (!MVequal(pmv[2], prevMB->i_mvs[0]))  
                         if (!MVequal(pmv[2], pmv[0]))  
                                 if (!MVequal(pmv[2], pmv[1]))  
                                         CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
   
 // top right neighbour, if allowed  
                                         if (!MVzero(pmv[3]))  
                                                 if (!MVequal(pmv[3], prevMB->i_mvs[0]))  
                                                         if (!MVequal(pmv[3], pmv[0]))  
                                                                 if (!MVequal(pmv[3], pmv[1]))  
                                                                         if (!MVequal(pmv[3], pmv[2]))  
                                                                                 CHECK_MV16_CANDIDATE(pmv[3].x,  
                                                                                                                          pmv[3].y);  
   
         if ((MVzero(*currMV)) &&  
                 (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )  
                 iMinSAD -= MV16_00_BIAS;  
2332    
2333            for (my = 1; my < (uint32_t)MBh-1; my++)
2334            for (mx = 1; mx < (uint32_t)MBw-1; mx++)
2335            {
2336                    const int mbnum = mx + my * MBw;
2337                    const MACROBLOCK *pMB = &pMBs[mbnum];
2338                    const VECTOR mv = pMB->mvs[0];
2339    
2340  /* Step 6: If MinSAD <= thresa goto Step 10.                  if (pMB->mode == MODE_INTRA || pMB->mode == MODE_NOT_CODED)
2341     If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.                          continue;
 */  
2342    
2343          if ((iMinSAD <= threshA) ||                  if ( ( (ABS(mv.x -   (pMB-1)->mvs[0].x) < deltax) && (ABS(mv.y -   (pMB-1)->mvs[0].y) < deltay) )
2344                  (MVequal(*currMV, prevMB->i_mvs[0]) &&                  &&   ( (ABS(mv.x -   (pMB+1)->mvs[0].x) < deltax) && (ABS(mv.y -   (pMB+1)->mvs[0].y) < deltay) )
2345                   ((int32_t) iMinSAD < prevMB->i_sad16))) {                  &&   ( (ABS(mv.x - (pMB-MBw)->mvs[0].x) < deltax) && (ABS(mv.y - (pMB-MBw)->mvs[0].y) < deltay) )
2346                    &&   ( (ABS(mv.x - (pMB+MBw)->mvs[0].x) < deltax) && (ABS(mv.y - (pMB+MBw)->mvs[0].y) < deltay) ) )
2347                  if (MotionFlags & PMV_EARLYSTOP16)                          MBmask[mbnum]=1;
                         goto PMVfastInt16_Terminate_with_Refine;  
2348          }          }
2349    
2350            for (my = 1; my < (uint32_t)MBh-1; my++)
2351            for (mx = 1; mx < (uint32_t)MBw-1; mx++)
2352            {
2353                    const uint8_t *const pCur = current->image.y + 16*my*pParam->edged_width + 16*mx;
2354    
2355  /************ (Diamond Search)  **************/                  const int mbnum = mx + my * MBw;
2356  /*                  if (!MBmask[mbnum])
2357     Step 7: Perform Diamond search, with either the small or large diamond.                          continue;
    If Found=2 only examine one Diamond pattern, and afterwards goto step 10  
    Step 8: If small diamond, iterate small diamond search pattern until motion vector lies in the center of the diamond.  
    If center then goto step 10.  
    Step 9: If large diamond, iterate large diamond search pattern until motion vector lies in the center.  
    Refine by using small diamond and goto step 10.  
 */  
   
         if (MotionFlags & PMV_USESQUARES16)  
                 MainSearchPtr = Square16_MainSearch;  
         else if (MotionFlags & PMV_ADVANCEDDIAMOND16)  
                 MainSearchPtr = AdvDiamond16_MainSearch;  
         else  
                 MainSearchPtr = Diamond16_MainSearch;  
2358    
2359          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                  if (sad16 ( pCur, pCur+1 , pParam->edged_width, 65536) <= (uint32_t)grad )
2360                            MBmask[mbnum] = 0;
2361                    if (sad16 ( pCur, pCur+pParam->edged_width, pParam->edged_width, 65536) <= (uint32_t)grad )
2362                            MBmask[mbnum] = 0;
2363    
2364            }
2365    
2366  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */          emms();
         iSAD =  
                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,  
                                                   currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, iFound);  
2367    
2368          if (iSAD < iMinSAD) {          do {            /* until convergence */
                 *currMV = newMV;  
                 iMinSAD = iSAD;  
         }  
2369    
2370          if (MotionFlags & PMV_EXTSEARCH16) {          a = b = c = n = 0;
2371  /* extended: search (up to) two more times: orignal prediction and (0,0) */          DtimesF[0] = DtimesF[1] = DtimesF[2] = DtimesF[3] = 0.;
2372            for (my = 0; my < (uint32_t)MBh; my++)
2373                    for (mx = 0; mx < (uint32_t)MBw; mx++)
2374                    {
2375                            const int mbnum = mx + my * MBw;
2376                            const MACROBLOCK *pMB = &pMBs[mbnum];
2377                            const VECTOR mv = pMB->mvs[0];
2378    
2379                  if (!(MVequal(pmv[0], backupMV))) {                          if (!MBmask[mbnum])
2380                          iSAD =                                  continue;
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  
                                                                   pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
2381    
2382                          if (iSAD < iMinSAD) {                          n++;
2383                                  *currMV = newMV;                          a += 16*mx+8;
2384                                  iMinSAD = iSAD;                          b += 16*my+8;
2385                          }                          c += (16*mx+8)*(16*mx+8)+(16*my+8)*(16*my+8);
2386                  }  
2387                            DtimesF[0] += (double)mv.x;
2388                            DtimesF[1] += (double)mv.x*(16*mx+8) + (double)mv.y*(16*my+8);
2389                            DtimesF[2] += (double)mv.x*(16*my+8) - (double)mv.y*(16*mx+8);
2390                            DtimesF[3] += (double)mv.y;
2391                    }
2392    
2393            denom = a*a+b*b-c*n;
2394    
2395    /* Solve the system:     sol = (D'*E*D)^{-1} D'*E*F   */
2396    /* D'*E*F has been calculated in the same loop as matrix */
2397    
2398            sol[0] = -c*DtimesF[0] + a*DtimesF[1] + b*DtimesF[2];
2399            sol[1] =  a*DtimesF[0] - n*DtimesF[1]                + b*DtimesF[3];
2400            sol[2] =  b*DtimesF[0]                - n*DtimesF[2] - a*DtimesF[3];
2401            sol[3] =                 b*DtimesF[1] - a*DtimesF[2] - c*DtimesF[3];
2402    
2403            sol[0] /= denom;
2404            sol[1] /= denom;
2405            sol[2] /= denom;
2406            sol[3] /= denom;
2407    
2408            meanx = meany = 0.;
2409            oldnum = 0;
2410            for (my = 0; my < (uint32_t)MBh; my++)
2411                    for (mx = 0; mx < (uint32_t)MBw; mx++)
2412                    {
2413                            const int mbnum = mx + my * MBw;
2414                            const MACROBLOCK *pMB = &pMBs[mbnum];
2415                            const VECTOR mv = pMB->mvs[0];
2416    
2417                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                          if (!MBmask[mbnum])
2418                          iSAD =                                  continue;
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                                   iQuant, iFound);  
2419    
2420                          if (iSAD < iMinSAD) {                          oldnum++;
2421                                  *currMV = newMV;                          meanx += ABS(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - mv.x );
2422                                  iMinSAD = iSAD;                          meany += ABS(( sol[3] - (16*mx+8)*sol[2] + (16*my+8)*sol[1] ) - mv.y );
                         }  
2423                  }                  }
         }  
   
 /*  
    Step 10:  The motion vector is chosen according to the block corresponding to MinSAD.  
 */  
2424    
2425  PMVfastInt16_Terminate_with_Refine:          if (4*meanx > oldnum)   /* better fit than 0.25 is useless */
2426                    meanx /= oldnum;
2427            else
2428                    meanx = 0.25;
2429    
2430          pMB->i_mvs[0] = pMB->i_mvs[1] = pMB->i_mvs[2] = pMB->i_mvs[3] = pMB->i_mv16 = *currMV;          if (4*meany > oldnum)
2431          pMB->i_sad8[0] = pMB->i_sad8[1] = pMB->i_sad8[2] = pMB->i_sad8[3] = pMB->i_sad16 = iMinSAD;                  meany /= oldnum;
2432            else
2433                    meany = 0.25;
2434    
2435          if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step  /*      fprintf(stderr,"sol = (%8.5f, %8.5f, %8.5f, %8.5f)\n",sol[0],sol[1],sol[2],sol[3]);
2436                  iMinSAD =          fprintf(stderr,"meanx = %8.5f  meany = %8.5f   %d\n",meanx,meany, oldnum);
2437                          Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  */
2438                                                           iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,          num = 0;
2439                                                           iFcode, iQuant, iEdgedWidth);          for (my = 0; my < (uint32_t)MBh; my++)
2440                    for (mx = 0; mx < (uint32_t)MBw; mx++)
2441                    {
2442                            const int mbnum = mx + my * MBw;
2443                            const MACROBLOCK *pMB = &pMBs[mbnum];
2444                            const VECTOR mv = pMB->mvs[0];
2445    
2446          pmv[0] = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);          // get _REAL_ prediction (halfpel possible)                          if (!MBmask[mbnum])
2447                                    continue;
2448    
2449  PMVfastInt16_Terminate_without_Refine:                          if  ( ( ABS(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - mv.x ) > meanx )
2450          currPMV->x = currMV->x - center_x;                             || ( ABS(( sol[3] - (16*mx+8)*sol[2] + (16*my+8)*sol[1] ) - mv.y ) > meany ) )
2451          currPMV->y = currMV->y - center_y;                                  MBmask[mbnum]=0;
2452          return iMinSAD;                          else
2453                                    num++;
2454  }  }
2455    
2456            } while ( (oldnum != num) && (num>=4) );
2457    
2458            if (num < 4)
2459            {
2460                    gmc.duv[0].x= gmc.duv[0].y= gmc.duv[1].x= gmc.duv[1].y= gmc.duv[2].x= gmc.duv[2].y=0;
2461            } else {
2462    
2463  /* ***********************************************************                  gmc.duv[0].x=(int)(sol[0]+0.5);
2464          bvop motion estimation                  gmc.duv[0].y=(int)(sol[3]+0.5);
 ***************************************************************/  
2465    
2466  void                  gmc.duv[1].x=(int)(sol[1]*pParam->width+0.5);
2467  MotionEstimationBVOP(MBParam * const pParam,                  gmc.duv[1].y=(int)(-sol[2]*pParam->width+0.5);
                                          FRAMEINFO * const frame,  
                                          const int32_t time_bp,  
                                          const int32_t time_pp,  
                                          // forward (past) reference  
                                          const MACROBLOCK * const f_mbs,  
                                          const IMAGE * const f_ref,  
                                          const IMAGE * const f_refH,  
                                          const IMAGE * const f_refV,  
                                          const IMAGE * const f_refHV,  
                                          // backward (future) reference  
                                          const MACROBLOCK * const b_mbs,  
                                          const IMAGE * const b_ref,  
                                          const IMAGE * const b_refH,  
                                          const IMAGE * const b_refV,  
                                          const IMAGE * const b_refHV)  
 {  
         const int mb_width = pParam->mb_width;  
         const int mb_height = pParam->mb_height;  
         const int edged_width = pParam->edged_width;  
2468    
2469          const int32_t iWidth = pParam->width;                  gmc.duv[2].x=0;
2470          const int32_t iHeight = pParam->height;                  gmc.duv[2].y=0;
2471            }
2472    //      fprintf(stderr,"wp1 = ( %4d, %4d)  wp2 = ( %4d, %4d) \n", gmc.duv[0].x, gmc.duv[0].y, gmc.duv[1].x, gmc.duv[1].y);
2473    
2474          int i, j, k;          free(MBmask);
2475    
2476          static const VECTOR zeroMV={0,0};          return gmc;
2477    }
2478    
2479          int f_sad16;    /* forward (as usual) search */  // functions which perform BITS-based search/bitcount
         int b_sad16;    /* backward (only in b-frames) search */  
         int i_sad16;    /* interpolated (both direction, b-frames only) */  
         int d_sad16;    /* direct mode (assume almost linear motion) */  
2480    
2481          int best_sad;  static int
2482    CountMBBitsInter(SearchData * const Data,
2483                                    const MACROBLOCK * const pMBs, const int x, const int y,
2484                                    const MBParam * const pParam,
2485                                    const uint32_t MotionFlags)
2486    {
2487            int i, iDirection;
2488            int32_t bsad[5];
2489    
2490          VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/          CheckCandidate = CheckCandidateBits16;
         VECTOR f_interpolMV, b_interpolMV;  
         VECTOR pmv_dontcare;  
2491    
2492          int min_dx, max_dx, min_dy, max_dy;          if (Data->qpel) {
2493          int f_min_dx, f_max_dx, f_min_dy, f_max_dy;                  for(i = 0; i < 5; i++) {
2494          int b_min_dx, b_max_dx, b_min_dy, b_max_dy;                          Data->currentMV[i].x = Data->currentQMV[i].x/2;
2495                            Data->currentMV[i].y = Data->currentQMV[i].y/2;
2496          int f_count=0;                  }
2497          int b_count=0;                  Data->qpel_precision = 1;
2498          int i_count=0;                  CheckCandidateBits16(Data->currentQMV[0].x, Data->currentQMV[0].y, 255, &iDirection, Data);
         int d_count=0;  
2499    
2500          const int64_t TRB = (int32_t)time_pp - (int32_t)time_bp;                  //checking if this vector is perfect. if it is, we stop.
2501      const int64_t TRD = (int32_t)time_pp;                  if (Data->temp[0] == 0 && Data->temp[1] == 0 && Data->temp[2] == 0 && Data->temp[3] == 0)
2502                            return 0; //quick stop
2503    
2504          // fprintf(stderr,"TRB = %lld  TRD = %lld  time_bp =%d time_pp =%d\n\n",TRB,TRD,time_bp,time_pp);                  if (MotionFlags & (XVID_ME_HALFPELREFINE16_BITS | XVID_ME_EXTSEARCH_BITS)) { //we have to prepare for halfpixel-precision search
2505          // note: i==horizontal, j==vertical                          for(i = 0; i < 5; i++) bsad[i] = Data->iMinSAD[i];
2506          for (j = 0; j < mb_height; j++) {                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2507                                                    pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
2508                            Data->qpel_precision = 0;
2509                            if (Data->currentQMV->x & 1 || Data->currentQMV->y & 1)
2510                                    CheckCandidateBits16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);
2511                    }
2512    
2513                  f_predMV = zeroMV;      /* prediction is reset at left boundary */          } else { // not qpel
                 b_predMV = zeroMV;  
2514    
2515                  for (i = 0; i < mb_width; i++) {                  CheckCandidateBits16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);
2516                          MACROBLOCK *mb = &frame->mbs[i + j * mb_width];                  //checking if this vector is perfect. if it is, we stop.
2517                          const MACROBLOCK *f_mb = &f_mbs[i + j * mb_width];                  if (Data->temp[0] == 0 && Data->temp[1] == 0 && Data->temp[2] == 0 && Data->temp[3] == 0) {
2518                          const MACROBLOCK *b_mb = &b_mbs[i + j * mb_width];                          return 0; //inter
2519                    }
                         mb->deltamv=zeroMV;  
   
 /* special case, if collocated block is SKIPed: encoding is forward (0,0), cpb=0 without further ado */  
   
 #ifndef _DISABLE_SKIP  
                         if (b_mb->mode == MODE_INTER && b_mb->cbp == 0 &&  
                                 b_mb->mvs[0].x == 0 && b_mb->mvs[0].y == 0) {  
                                 mb->mode = MODE_NOT_CODED;  
                                 mb->mvs[0].x = 0;  
                                 mb->mvs[0].y = 0;  
                                 mb->b_mvs[0].x = 0;  
                                 mb->b_mvs[0].y = 0;  
                                 continue;  
2520                          }                          }
 #endif  
2521    
2522                          if (b_mb->mode == MODE_INTER4V)          if (MotionFlags&XVID_ME_EXTSEARCH_BITS) SquareSearch(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
                         {  
                                 d_sad16 = 0;  
                         /* same method of scaling as in decoder.c, so we copy from there */  
                     for (k = 0; k < 4; k++) {  
2523    
2524                                          mb->directmv[k] = b_mb->mvs[k];          if (MotionFlags&XVID_ME_HALFPELREFINE16_BITS) SubpelRefine(Data);
2525    
2526                                          mb->mvs[k].x = (int32_t) ((TRB * mb->directmv[k].x) / TRD + mb->deltamv.x);          if (Data->qpel) {
2527                      mb->b_mvs[k].x = (int32_t) ((mb->deltamv.x == 0)                  if (MotionFlags&(XVID_ME_EXTSEARCH_BITS | XVID_ME_HALFPELREFINE16_BITS)) { // there was halfpel-precision search
2528                                                                                  ? ((TRB - TRD) * mb->directmv[k].x) / TRD                          for(i = 0; i < 5; i++) if (bsad[i] > Data->iMinSAD[i]) {
2529                                              : mb->mvs[k].x - mb->directmv[k].x);                                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // we have found a better match
2530                                    Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
                     mb->mvs[k].y = (int32_t) ((TRB * mb->directmv[k].y) / TRD + mb->deltamv.y);  
                         mb->b_mvs[k].y = (int32_t) ((mb->deltamv.y == 0)  
                                                                                 ? ((TRB - TRD) * mb->directmv[k].y) / TRD  
                                             : mb->mvs[k].y - mb->directmv[k].y);  
   
                                         d_sad16 +=  
                                                 sad8bi(frame->image.y + 2*(i+(k&1))*8 + 2*(j+(k>>1))*8*edged_width,  
                                                   get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                                 2*(i+(k&1)), 2*(j+(k>>1)), 8, &mb->mvs[k], edged_width),  
                                                   get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                                 2*(i+(k&1)), 2*(j+(k>>1)), 8, &mb->b_mvs[k], edged_width),  
                                                   edged_width);  
2531                                  }                                  }
                         }  
                         else  
                         {  
                                 mb->directmv[3] = mb->directmv[2] = mb->directmv[1] =  
                                         mb->directmv[0] = b_mb->mvs[0];  
2532    
2533                                  mb->mvs[0].x = (int32_t) ((TRB * mb->directmv[0].x) / TRD + mb->deltamv.x);                          // preparing for qpel-precision search
2534                      mb->b_mvs[0].x = (int32_t) ((mb->deltamv.x == 0)                          Data->qpel_precision = 1;
2535                                                                          ? ((TRB - TRD) * mb->directmv[0].x) / TRD                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2536                                      : mb->mvs[0].x - mb->directmv[0].x);                                          pParam->width, pParam->height, Data->iFcode, 1, 0);
2537                    }
2538                      mb->mvs[0].y = (int32_t) ((TRB * mb->directmv[0].y) / TRD + mb->deltamv.y);                  if (MotionFlags&XVID_ME_QUARTERPELREFINE16_BITS) SubpelRefine(Data);
2539                  mb->b_mvs[0].y = (int32_t) ((mb->directmv[0].y == 0)          }
                                                                         ? ((TRB - TRD) * mb->directmv[0].y) / TRD  
                                     : mb->mvs[0].y - mb->directmv[0].y);  
   
                                 d_sad16 = sad16bi(frame->image.y + i * 16 + j * 16 * edged_width,  
                                                   get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                                 i, j, 16, &mb->mvs[0], edged_width),  
                                                   get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                                 i, j, 16, &mb->b_mvs[0], edged_width),  
                                                   edged_width);  
2540    
2541            if (MotionFlags&XVID_ME_CHECKPREDICTION_BITS) { //let's check vector equal to prediction
2542                    VECTOR * v = Data->qpel ? Data->currentQMV : Data->currentMV;
2543                    if (!(Data->predMV.x == v->x && Data->predMV.y == v->y))
2544                            CheckCandidateBits16(Data->predMV.x, Data->predMV.y, 255, &iDirection, Data);
2545            }
2546            return Data->iMinSAD[0];
2547              }              }
                     d_sad16 += calc_delta_16(mb->deltamv.x, mb->deltamv.y, 1, frame->quant);  
2548    
                         // forward search  
                         f_sad16 = SEARCH16(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                 &frame->image, i, j,  
                                                 mb->mvs[0].x, mb->mvs[0].y,                     /* start point f_directMV */  
                                                 f_predMV.x, f_predMV.y,                         /* center is f-prediction */  
                                                 frame->motion_flags,  
                                                 frame->quant, frame->fcode, pParam,  
                                                 f_mbs, f_mbs,  
                                                 &mb->mvs[0], &pmv_dontcare);  
2549    
2550    static int
2551    CountMBBitsInter4v(const SearchData * const Data,
2552                                            MACROBLOCK * const pMB, const MACROBLOCK * const pMBs,
2553                                            const int x, const int y,
2554                                            const MBParam * const pParam, const uint32_t MotionFlags,
2555                                            const VECTOR * const backup)
2556    {
2557    
2558                          // backward search          int cbp = 0, bits = 0, t = 0, i, iDirection;
2559                          b_sad16 = SEARCH16(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,          SearchData Data2, *Data8 = &Data2;
2560                                                  &frame->image, i, j,          int sumx = 0, sumy = 0;
2561                                                  mb->b_mvs[0].x, mb->b_mvs[0].y,         /* start point b_directMV */          int16_t *in = Data->dctSpace, *coeff = Data->dctSpace + 64;
2562                                                  b_predMV.x, b_predMV.y,                         /* center is b-prediction */  
2563                                                  frame->motion_flags,          memcpy(Data8, Data, sizeof(SearchData));
2564                                                  frame->quant, frame->bcode, pParam,          CheckCandidate = CheckCandidateBits8;
2565                                                  b_mbs, b_mbs,  
2566                                                  &mb->b_mvs[0], &pmv_dontcare);          for (i = 0; i < 4; i++) {
2567                    Data8->iMinSAD = Data->iMinSAD + i + 1;
2568                          i_sad16 =                  Data8->currentMV = Data->currentMV + i + 1;
2569                                  sad16bi(frame->image.y + i * 16 + j * 16 * edged_width,                  Data8->currentQMV = Data->currentQMV + i + 1;
2570                                                    get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,                  Data8->Cur = Data->Cur + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2571                                                                  i, j, 16, &mb->mvs[0], edged_width),                  Data8->Ref = Data->Ref + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2572                                                    get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,                  Data8->RefH = Data->RefH + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2573                                                                  i, j, 16, &mb->b_mvs[0], edged_width),                  Data8->RefV = Data->RefV + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2574                                                    edged_width);                  Data8->RefHV = Data->RefHV + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2575                      i_sad16 += calc_delta_16(mb->mvs[0].x-f_predMV.x, mb->mvs[0].y-f_predMV.y,  
2576                                                                  frame->fcode, frame->quant);                  if(Data->qpel) {
2577                      i_sad16 += calc_delta_16(mb->b_mvs[0].x-b_predMV.x, mb->b_mvs[0].y-b_predMV.y,                          Data8->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, i);
2578                                                                  frame->bcode, frame->quant);                          if (i != 0)     t = d_mv_bits(  Data8->currentQMV->x, Data8->currentQMV->y,
2579                                                                                    Data8->predMV, Data8->iFcode, 0, 0);
                         get_range(&f_min_dx, &f_max_dx, &f_min_dy, &f_max_dy, i, j, 16, iWidth, iHeight,  
                           frame->fcode);  
                         get_range(&b_min_dx, &b_max_dx, &b_min_dy, &b_max_dy, i, j, 16, iWidth, iHeight,  
                           frame->bcode);  
   
 /* Interpolated MC motion vector search, this is tedious and more complicated because there are  
    two values for everything, always one for backward and one for forward ME. Still, we don't gain  
    much from this search, maybe it should simply be skipped and simply current i_sad16 value used  
    as "optimal". */  
   
                         i_sad16 = Diamond16_InterpolMainSearch(  
                                                 f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                 frame->image.y + i * 16 + j * 16 * edged_width,  
                                                 b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                 i, j,  
                                                 mb->mvs[0].x, mb->mvs[0].y,  
                                                 mb->b_mvs[0].x, mb->b_mvs[0].y,  
                                                 i_sad16,  
                                                 &f_interpolMV, &b_interpolMV,  
                                                 f_predMV.x, f_predMV.y, b_predMV.x, b_predMV.y,  
                                                 f_min_dx, f_max_dx, f_min_dy, f_max_dy,  
                                                 b_min_dx, b_max_dx, b_min_dy, b_max_dy,  
                                                 edged_width,  1,  
                                                 frame->fcode, frame->bcode,frame->quant,0);  
   
   
 /*  DIRECT MODE DELTA VECTOR SEARCH.  
     This has to be made more effective, but at the moment I'm happy it's running at all */  
   
 /* range is taken without fcode restriction, just a hack instead of writing down the dimensions, of course */  
   
                         get_range(&min_dx, &max_dx, &min_dy, &max_dy, i, j, 16, iWidth, iHeight, 19);  
   
                         d_sad16 = Diamond16_DirectMainSearch(  
                                                 f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                 frame->image.y + i*16 + j*16*edged_width,  
                                                 b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                 i, j,  
                                                 TRB,TRD,  
                                                 0,0,  
                                                 d_sad16,  
                                                 &mb->deltamv,  
                                                 mb->directmv, // this has to be pre-initialized with b_mb->mvs[}  
                                         min_dx, max_dx, min_dy, max_dy,  
                                                 edged_width, 1, frame->quant, 0);  
   
   
 //                      i_sad16 = 65535;                /* remove the comment to disable any of the MODEs */  
 //                      f_sad16 = 65535;  
 //                      b_sad16 = 65535;  
 //                      d_sad16 = 65535;  
   
                         if (f_sad16 < b_sad16) {  
                                 best_sad = f_sad16;  
                                 mb->mode = MODE_FORWARD;  
2580                          } else {                          } else {
2581                                  best_sad = b_sad16;                          Data8->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, i);
2582                                  mb->mode = MODE_BACKWARD;                          if (i != 0)     t = d_mv_bits(  Data8->currentMV->x, Data8->currentMV->y,
2583                                                                                    Data8->predMV, Data8->iFcode, 0, 0);
2584                          }                          }
2585    
2586                          if (i_sad16 < best_sad) {                  get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 8,
2587                                  best_sad = i_sad16;                                          pParam->width, pParam->height, Data8->iFcode, Data8->qpel, 0);
2588                                  mb->mode = MODE_INTERPOLATE;  
2589                    *Data8->iMinSAD += t;
2590    
2591                    Data8->qpel_precision = Data8->qpel;
2592                    // checking the vector which has been found by SAD-based 8x8 search (if it's different than the one found so far)
2593                    if (Data8->qpel) {
2594                            if (!(Data8->currentQMV->x == backup[i+1].x && Data8->currentQMV->y == backup[i+1].y))
2595                                    CheckCandidateBits8(backup[i+1].x, backup[i+1].y, 255, &iDirection, Data8);
2596                    } else {
2597                            if (!(Data8->currentMV->x == backup[i+1].x && Data8->currentMV->y == backup[i+1].y))
2598                                    CheckCandidateBits8(backup[i+1].x, backup[i+1].y, 255, &iDirection, Data8);
2599                          }                          }
2600    
2601                          if (d_sad16 < best_sad) {                  if (Data8->qpel) {
2602                            if (MotionFlags&XVID_ME_HALFPELREFINE8_BITS || (MotionFlags&XVID_ME_EXTSEARCH8 && MotionFlags&XVID_ME_EXTSEARCH_BITS)) { // halfpixel motion search follows
2603                                    int32_t s = *Data8->iMinSAD;
2604                                    Data8->currentMV->x = Data8->currentQMV->x/2;
2605                                    Data8->currentMV->y = Data8->currentQMV->y/2;
2606                                    Data8->qpel_precision = 0;
2607                                    get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 8,
2608                                                            pParam->width, pParam->height, Data8->iFcode - 1, 0, 0);
2609    
2610                                  if (b_mb->mode == MODE_INTER4V)                                  if (Data8->currentQMV->x & 1 || Data8->currentQMV->y & 1)
2611                                  {                                          CheckCandidateBits8(Data8->currentMV->x, Data8->currentMV->y, 255, &iDirection, Data8);
2612    
2613                                  /* how to calc vectors is defined in standard. mvs[] and b_mvs[] are only for motion compensation */                                  if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_BITS)
2614                                  /* for the bitstream, the value mb->deltamv is read directly */                                          SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255);
2615    
2616                              for (k = 0; k < 4; k++) {                                  if (MotionFlags & XVID_ME_HALFPELREFINE8_BITS) SubpelRefine(Data8);
2617    
2618                                                  mb->mvs[k].x = (int32_t) ((TRB * mb->directmv[k].x) / TRD + mb->deltamv.x);                                  if(s > *Data8->iMinSAD) { //we have found a better match
2619                              mb->b_mvs[k].x = (int32_t) ((mb->deltamv.x == 0)                                          Data8->currentQMV->x = 2*Data8->currentMV->x;
2620                                                                                          ? ((TRB - TRD) * mb->directmv[k].x) / TRD                                          Data8->currentQMV->y = 2*Data8->currentMV->y;
                                                     : mb->mvs[k].x - mb->directmv[k].x);  
   
                             mb->mvs[k].y = (int32_t) ((TRB * mb->directmv[k].y) / TRD + mb->deltamv.y);  
                         mb->b_mvs[k].y = (int32_t) ((mb->deltamv.y == 0)  
                                                                                         ? ((TRB - TRD) * mb->directmv[k].y) / TRD  
                                             : mb->mvs[k].y - mb->directmv[k].y);  
2621                                          }                                          }
                                 }  
                                 else  
                                 {  
                                         mb->mvs[0].x = (int32_t) ((TRB * mb->directmv[0].x) / TRD + mb->deltamv.x);  
2622    
2623                      mb->b_mvs[0].x = (int32_t) ((mb->deltamv.x == 0)                                  Data8->qpel_precision = 1;
2624                                                                                  ? ((TRB - TRD) * mb->directmv[0].x) / TRD                                  get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 8,
2625                                          : mb->mvs[0].x - mb->directmv[0].x);                                                          pParam->width, pParam->height, Data8->iFcode, 1, 0);
2626    
2627                              mb->mvs[0].y = (int32_t) ((TRB * mb->directmv[0].y) / TRD + mb->deltamv.y);                          }
2628                            if (MotionFlags & XVID_ME_QUARTERPELREFINE8_BITS) SubpelRefine(Data8);
2629    
2630                          mb->b_mvs[0].y = (int32_t) ((mb->deltamv.y == 0)                  } else // not qpel
2631                                                                                  ? ((TRB - TRD) * mb->directmv[0].y) / TRD                          if (MotionFlags & XVID_ME_HALFPELREFINE8_BITS) SubpelRefine(Data8); //halfpel mode, halfpel refinement
                                             : mb->mvs[0].y - mb->directmv[0].y);  
2632    
2633                                          mb->mvs[3] = mb->mvs[2] = mb->mvs[1] = mb->mvs[0];                  //checking vector equal to predicion
2634                                          mb->b_mvs[3] = mb->b_mvs[2] = mb->b_mvs[1] = mb->b_mvs[0];                  if (i != 0 && MotionFlags & XVID_ME_CHECKPREDICTION_BITS) {
2635                            const VECTOR * v = Data->qpel ? Data8->currentQMV : Data8->currentMV;
2636                            if (!(Data8->predMV.x == v->x && Data8->predMV.y == v->y))
2637                                    CheckCandidateBits8(Data8->predMV.x, Data8->predMV.y, 255, &iDirection, Data8);
2638                  }                  }
2639    
2640                                  best_sad = d_sad16;                  bits += *Data8->iMinSAD;
2641                                  mb->mode = MODE_DIRECT;                  if (bits >= Data->iMinSAD[0]) break; // no chances for INTER4V
                         }  
2642    
2643                          switch (mb->mode)                  // MB structures for INTER4V mode; we have to set them here, we don't have predictor anywhere else
2644                          {                  if(Data->qpel) {
2645                                  case MODE_FORWARD:                          pMB->pmvs[i].x = Data8->currentQMV->x - Data8->predMV.x;
2646                                          f_count++;                          pMB->pmvs[i].y = Data8->currentQMV->y - Data8->predMV.y;
2647                                          f_predMV = mb->mvs[0];                          pMB->qmvs[i] = *Data8->currentQMV;
2648                                          break;                          sumx += Data8->currentQMV->x/2;
2649                                  case MODE_BACKWARD:                          sumy += Data8->currentQMV->y/2;
2650                                          b_count++;                  } else {
2651                                          b_predMV = mb->b_mvs[0];                          pMB->pmvs[i].x = Data8->currentMV->x - Data8->predMV.x;
2652                            pMB->pmvs[i].y = Data8->currentMV->y - Data8->predMV.y;
2653                            sumx += Data8->currentMV->x;
2654                            sumy += Data8->currentMV->y;
2655                    }
2656                    pMB->mvs[i] = *Data8->currentMV;
2657                    pMB->sad8[i] = 4 * *Data8->iMinSAD;
2658                    if (Data8->temp[0]) cbp |= 1 << (5 - i);
2659            }
2660    
2661            if (bits < *Data->iMinSAD) { // there is still a chance for inter4v mode. let's check chroma
2662                    const uint8_t * ptr;
2663                    sumx = (sumx >> 3) + roundtab_76[sumx & 0xf];
2664                    sumy = (sumy >> 3) + roundtab_76[sumy & 0xf];
2665    
2666                    //chroma U
2667                    ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefCU, 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
2668                    transfer_8to16subro(in, Data->CurU, ptr, Data->iEdgedWidth/2);
2669                    fdct(in);
2670                    if (Data->lambda8 == 0) i = quant_inter(coeff, in, Data->lambda16);
2671                    else i = quant4_inter(coeff, in, Data->lambda16);
2672                    if (i > 0) {
2673                            bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
2674                            cbp |= 1 << (5 - 4);
2675                    }
2676    
2677                    if (bits < *Data->iMinSAD) { // still possible
2678                            //chroma V
2679                            ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefCV, 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
2680                            transfer_8to16subro(in, Data->CurV, ptr, Data->iEdgedWidth/2);
2681                            fdct(in);
2682                            if (Data->lambda8 == 0) i = quant_inter(coeff, in, Data->lambda16);
2683                            else i = quant4_inter(coeff, in, Data->lambda16);
2684                            if (i > 0) {
2685                                    bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
2686                                    cbp |= 1 << (5 - 5);
2687                            }
2688                            bits += xvid_cbpy_tab[15-(cbp>>2)].len;
2689                            bits += mcbpc_inter_tab[(MODE_INTER4V & 7) | ((cbp & 3) << 3)].len;
2690                    }
2691            }
2692    
2693            return bits;
2694    }
2695    
2696    
2697    static int
2698    CountMBBitsIntra(const SearchData * const Data)
2699    {
2700            int bits = 1; //this one is ac/dc prediction flag. always 1.
2701            int cbp = 0, i, t, dc = 0, b_dc = 1024;
2702            const uint32_t iQuant = Data->lambda16;
2703            int16_t *in = Data->dctSpace, * coeff = Data->dctSpace + 64;
2704    
2705            for(i = 0; i < 4; i++) {
2706                    uint32_t iDcScaler = get_dc_scaler(iQuant, 1);
2707    
2708                    int s = 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2709                    transfer_8to16copy(in, Data->Cur + s, Data->iEdgedWidth);
2710                    fdct(in);
2711                    b_dc = dc;
2712                    dc = in[0];
2713                    in[0] -= b_dc;
2714                    if (Data->lambda8 == 0) quant_intra_c(coeff, in, iQuant, iDcScaler);
2715                    else quant4_intra_c(coeff, in, iQuant, iDcScaler);
2716    
2717                    b_dc = dc;
2718                    dc = coeff[0];
2719                    if (i != 0) coeff[0] -= b_dc;
2720    
2721                    bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcy_tab[coeff[0] + 255].len;;
2722                    Data->temp[i] = t;
2723                    if (t != 0)  cbp |= 1 << (5 - i);
2724                    if (bits >= Data->iMinSAD[0]) break;
2725            }
2726    
2727            if (bits < Data->iMinSAD[0]) { // INTRA still looks good, let's add chroma
2728                    uint32_t iDcScaler = get_dc_scaler(iQuant, 0);
2729                    //chroma U
2730                    transfer_8to16copy(in, Data->CurU, Data->iEdgedWidth/2);
2731                    fdct(in);
2732                    in[0] -= 1024;
2733                    if (Data->lambda8 == 0) quant_intra(coeff, in, iQuant, iDcScaler);
2734                    else quant4_intra(coeff, in, iQuant, iDcScaler);
2735    
2736                    bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len;
2737                    if (t != 0) cbp |= 1 << (5 - 4);
2738    
2739                    if (bits < Data->iMinSAD[0]) {
2740                            iDcScaler = get_dc_scaler(iQuant, 1);
2741                            //chroma V
2742                            transfer_8to16copy(in, Data->CurV, Data->iEdgedWidth/2);
2743                            fdct(in);
2744                            in[0] -= 1024;
2745                            if (Data->lambda8 == 0) quant_intra(coeff, in, iQuant, iDcScaler);
2746                            else quant4_intra(coeff, in, iQuant, iDcScaler);
2747    
2748                                          break;                          bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len;
2749                                  case MODE_INTERPOLATE:                          if (t != 0) cbp |= 1 << (5 - 5);
                                         i_count++;  
                                         mb->mvs[0] = f_interpolMV;  
                                         mb->b_mvs[0] = b_interpolMV;  
                                         f_predMV = mb->mvs[0];  
                                         b_predMV = mb->b_mvs[0];  
                                         break;  
                                 case MODE_DIRECT:  
                                         d_count++;  
                                         break;  
                                 default:  
                                         break;  
                         }  
2750    
2751                            bits += xvid_cbpy_tab[cbp>>2].len;
2752                            bits += mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp & 3) << 3)].len;
2753                  }                  }
2754          }          }
2755            return bits;
 #ifdef _DEBUG_BFRAME_STAT  
         fprintf(stderr,"B-Stat: F: %04d   B: %04d   I: %04d  D: %04d\n",  
                                 f_count,b_count,i_count,d_count);  
 #endif  
   
2756  }  }

Legend:
Removed from v.346  
changed lines
  Added in v.974

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4