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

Legend:
Removed from v.347  
changed lines
  Added in v.949

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