[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 285, Wed Jul 10 19:16:56 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     * Original tables see ISO spec tables 7-6 -> 7-9
52     ****************************************************************************/
53    
54    const uint32_t roundtab[16] =
55    {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
56    
57    /* K = 4 */
58    const uint32_t roundtab_76[16] =
59    { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1 };
60    
61    /* K = 2 */
62    const uint32_t roundtab_78[8] =
63    { 0, 0, 1, 1, 0, 0, 0, 1  };
64    
65    /* K = 1 */
66    const uint32_t roundtab_79[4] =
67    { 0, 1, 0, 0 };
68    
69    #define INITIAL_SKIP_THRESH     (10)
70    #define FINAL_SKIP_THRESH       (50)
71    #define MAX_SAD00_FOR_SKIP      (20)
72    #define MAX_CHROMA_SAD_FOR_SKIP (22)
73    
74    #define CHECK_CANDIDATE(X,Y,D) { \
75    CheckCandidate((X),(Y), (D), &iDirection, data ); }
76    
77    /*****************************************************************************
78     * Code
79     ****************************************************************************/
80    
81    static __inline uint32_t
82    d_mv_bits(int x, int y, const VECTOR pred, const uint32_t iFcode, const int qpel, const int rrv)
83    {
84            int xb, yb;
85            x = qpel ? x<<1 : x;
86            y = qpel ? y<<1 : y;
87            if (rrv) { x = RRV_MV_SCALEDOWN(x); y = RRV_MV_SCALEDOWN(y); }
88    
89            x -= pred.x;
90            y -= pred.y;
91    
92            if (x) {
93                    x = ABS(x);
94                    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            switch (((bx & 1) << 1) | (by & 1))     {
143                    case 0:
144                            bx = bx / 2; by = by / 2;
145                            b_refu = (uint8_t*)data->b_RefCU + by * stride + bx, stride;
146                            b_refv = (uint8_t*)data->b_RefCV + by * stride + bx, stride;
147                            break;
148                    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            return sad;
169    }
170    
171    
172  static int32_t lambda_vec16[32] =       /* rounded values for lambda param for weight of motion bits as in modified H.26L */  static int32_t
173  { 0, (int) (1.00235 + 0.5), (int) (1.15582 + 0.5), (int) (1.31976 + 0.5),  ChromaSAD(int dx, int dy, const SearchData * const data)
174                  (int) (1.49591 + 0.5), (int) (1.68601 + 0.5),  {
175          (int) (1.89187 + 0.5), (int) (2.11542 + 0.5), (int) (2.35878 + 0.5),          int sad;
176                  (int) (2.62429 + 0.5), (int) (2.91455 + 0.5),          const uint32_t stride = data->iEdgedWidth/2;
         (int) (3.23253 + 0.5), (int) (3.58158 + 0.5), (int) (3.96555 + 0.5),  
                 (int) (4.38887 + 0.5), (int) (4.85673 + 0.5),  
         (int) (5.37519 + 0.5), (int) (5.95144 + 0.5), (int) (6.59408 + 0.5),  
                 (int) (7.31349 + 0.5), (int) (8.12242 + 0.5),  
         (int) (9.03669 + 0.5), (int) (10.0763 + 0.5), (int) (11.2669 + 0.5),  
                 (int) (12.6426 + 0.5), (int) (14.2493 + 0.5),  
         (int) (16.1512 + 0.5), (int) (18.442 + 0.5), (int) (21.2656 + 0.5),  
                 (int) (24.8580 + 0.5), (int) (29.6436 + 0.5),  
         (int) (36.4949 + 0.5)  
 };  
   
 static int32_t *lambda_vec8 = lambda_vec16;     /* same table for INTER and INTER4V for now */  
177    
178            if (dx == data->temp[5] && dy == data->temp[6]) return data->temp[7]; //it has been checked recently
179            data->temp[5] = dx; data->temp[6] = dy; // backup
180    
181            switch (((dx & 1) << 1) | (dy & 1))     {
182                    case 0:
183                            dx = dx / 2; dy = dy / 2;
184                            sad = sad8(data->CurU, data->RefCU + dy * stride + dx, stride);
185                            sad += sad8(data->CurV, data->RefCV + dy * stride + dx, stride);
186                            break;
187                    case 1:
188                            dx = dx / 2; dy = (dy - 1) / 2;
189                            sad = sad8bi(data->CurU, data->RefCU + dy * stride + dx, data->RefCU + (dy+1) * stride + dx, stride);
190                            sad += sad8bi(data->CurV, data->RefCV + dy * stride + dx, data->RefCV + (dy+1) * stride + dx, stride);
191                            break;
192                    case 2:
193                            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                            sad += sad8bi(data->CurV, data->RefCV + dy * stride + dx, data->RefCV + dy * stride + dx+1, stride);
196                            break;
197                    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  // mv.length table                          interpolate8x8_halfpel_hv(data->RefQ, data->RefCV + dy * stride + dx, stride, data->rounding);
203  static const uint32_t mvtab[33] = {                          sad += sad8(data->CurV, data->RefQ, stride);
204          1, 2, 3, 4, 6, 7, 7, 7,                          break;
205          9, 9, 9, 10, 10, 10, 10, 10,          }
206          10, 10, 10, 10, 10, 10, 10, 10,          data->temp[7] = sad; //backup, part 2
207          10, 11, 11, 11, 11, 11, 11, 12, 12          return sad;
208  };  }
209    
210    static __inline const uint8_t *
211    GetReferenceB(const int x, const int y, const uint32_t dir, const SearchData * const data)
212    {
213    //      dir : 0 = forward, 1 = backward
214            switch ( (dir << 2) | ((x&1)<<1) | (y&1) ) {
215                    case 0 : return data->Ref + x/2 + (y/2)*(data->iEdgedWidth);
216                    case 1 : return data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
217                    case 2 : return data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);
218                    case 3 : return data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
219                    case 4 : return data->bRef + x/2 + (y/2)*(data->iEdgedWidth);
220                    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  static __inline uint32_t  // this is a simpler copy of GetReferenceB, but as it's __inline anyway, we can keep the two separate
227  mv_bits(int32_t component,  static __inline const uint8_t *
228                  const uint32_t iFcode)  GetReference(const int x, const int y, const SearchData * const data)
229  {  {
230          if (component == 0)          switch ( ((x&1)<<1) | (y&1) ) {
231                  return 1;                  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            }
236    }
237    
238          if (component < 0)  static uint8_t *
239                  component = -component;  Interpolate8x8qpel(const int x, const int y, const uint32_t block, const uint32_t dir, const SearchData * const data)
240    {
241    // create or find a qpel-precision reference picture; return pointer to it
242            uint8_t * Reference = data->RefQ + 16*dir;
243            const uint32_t iEdgedWidth = data->iEdgedWidth;
244            const uint32_t rounding = data->rounding;
245            const int halfpel_x = x/2;
246            const int halfpel_y = y/2;
247            const uint8_t *ref1, *ref2, *ref3, *ref4;
248    
249          if (iFcode == 1) {          ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
250                  if (component > 32)          ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
251                          component = 32;          switch( ((x&1)<<1) + (y&1) ) {
252            case 0: // pure halfpel position
253                    return (uint8_t *) ref1;
254                    break;
255    
256                  return mvtab[component] + 1;          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            case 2: // x qpel, y halfpel - left or right during qpel refinement
263                    ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
264                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
265                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
266                    break;
267    
268            default: // x and y in qpel resolution - the "corners" (top left/right and
269                             // bottom left/right) during qpel refinement
270                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
271                    ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
272                    ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
273                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
274                    ref3 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
275                    ref4 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
276                    interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
277                    break;
278            }
279            return Reference;
280          }          }
281    
282          component += (1 << (iFcode - 1)) - 1;  static uint8_t *
283          component >>= (iFcode - 1);  Interpolate16x16qpel(const int x, const int y, const uint32_t dir, const SearchData * const data)
284    {
285    // create or find a qpel-precision reference picture; return pointer to it
286            uint8_t * Reference = data->RefQ + 16*dir;
287            const uint32_t iEdgedWidth = data->iEdgedWidth;
288            const uint32_t rounding = data->rounding;
289            const int halfpel_x = x/2;
290            const int halfpel_y = y/2;
291            const uint8_t *ref1, *ref2, *ref3, *ref4;
292    
293            ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
294            switch( ((x&1)<<1) + (y&1) ) {
295            case 3: // x and y in qpel resolution - the "corners" (top left/right and
296                             // bottom left/right) during qpel refinement
297                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
298                    ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
299                    ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
300                    interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
301                    interpolate8x8_avg4(Reference+8, ref1+8, ref2+8, ref3+8, ref4+8, iEdgedWidth, rounding);
302                    interpolate8x8_avg4(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, ref3+8*iEdgedWidth, ref4+8*iEdgedWidth, iEdgedWidth, rounding);
303                    interpolate8x8_avg4(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, ref3+8*iEdgedWidth+8, ref4+8*iEdgedWidth+8, iEdgedWidth, rounding);
304                    break;
305    
306          if (component > 32)          case 1: // x halfpel, y qpel - top or bottom during qpel refinement
307                  component = 32;                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
308                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
309                    interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
310                    interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
311                    interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
312                    break;
313    
314            case 2: // x qpel, y halfpel - left or right during qpel refinement
315                    ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
316                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
317                    interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
318                    interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
319                    interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
320                    break;
321    
322          return mvtab[component] + 1 + iFcode - 1;          case 0: // pure halfpel position
323                    return (uint8_t *) ref1;
324            }
325            return Reference;
326  }  }
327    
328    /* CHECK_CANDIATE FUNCTIONS START */
329    
330  static __inline uint32_t  static void
331  calc_delta_16(const int32_t dx,  CheckCandidate16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
                           const int32_t dy,  
                           const uint32_t iFcode,  
                           const uint32_t iQuant)  
332  {  {
333          return NEIGH_TEND_16X16 * lambda_vec16[iQuant] * (mv_bits(dx, iFcode) +          int xc, yc;
334                                                                                                            mv_bits(dy, iFcode));          const uint8_t * Reference;
335            VECTOR * current;
336            int32_t sad; uint32_t t;
337    
338            if ( (x > data->max_dx) || (x < data->min_dx)
339                    || (y > data->max_dy) || (y < data->min_dy) ) return;
340    
341            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  static __inline uint32_t          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
352  calc_delta_8(const int32_t dx,          t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
353                           const int32_t dy,  
354                           const uint32_t iFcode,          sad += (data->lambda16 * t * sad)>>10;
355                           const uint32_t iQuant)          data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
356    
357            if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
358                                                                                                            (yc >> 1) + roundtab_79[yc & 0x3], data);
359    
360            if (sad < data->iMinSAD[0]) {
361                    data->iMinSAD[0] = sad;
362                    current[0].x = x; current[0].y = y;
363                    *dir = Direction;
364            }
365    
366            if (data->temp[1] < data->iMinSAD[1]) {
367                    data->iMinSAD[1] = data->temp[1]; current[1].x = x; current[1].y = y; }
368            if (data->temp[2] < data->iMinSAD[2]) {
369                    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    }
376    
377    static void
378    CheckCandidate8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
379  {  {
380          return NEIGH_TEND_8X8 * lambda_vec8[iQuant] * (mv_bits(dx, iFcode) +          int32_t sad; uint32_t t;
381                                                                                                     mv_bits(dy, iFcode));          const uint8_t * Reference;
382    
383            if ( (x > data->max_dx) || (x < data->min_dx)
384                    || (y > data->max_dy) || (y < data->min_dy) ) return;
385    
386            if (!data->qpel_precision) Reference = GetReference(x, y, data);
387            else Reference = Interpolate8x8qpel(x, y, 0, 0, data);
388    
389            sad = sad8(data->Cur, Reference, data->iEdgedWidth);
390            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
391    
392            sad += (data->lambda8 * t * (sad+NEIGH_8X8_BIAS))>>10;
393    
394            if (sad < *(data->iMinSAD)) {
395                    *(data->iMinSAD) = sad;
396                    data->currentMV->x = x; data->currentMV->y = y;
397                    *dir = Direction;
398            }
399  }  }
400    
401  bool  
402  MotionEstimation(MBParam * const pParam,  static void
403                                   FRAMEINFO * const current,  CheckCandidate32(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
                                  FRAMEINFO * const reference,  
                                  const IMAGE * const pRefH,  
                                  const IMAGE * const pRefV,  
                                  const IMAGE * const pRefHV,  
                                  const uint32_t iLimit)  
404  {  {
405          const uint32_t iWcount = pParam->mb_width;          uint32_t t;
406          const uint32_t iHcount = pParam->mb_height;          const uint8_t * Reference;
         MACROBLOCK *const pMBs = current->mbs;  
         MACROBLOCK *const prevMBs = reference->mbs;  
         const IMAGE *const pCurrent = &current->image;  
         const IMAGE *const pRef = &reference->image;  
407    
408          const VECTOR zeroMV = { 0, 0 };          if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || //non-zero integer value
409                    (x > data->max_dx) || (x < data->min_dx)
410                    || (y > data->max_dy) || (y < data->min_dy) ) return;
411    
412          int64_t time;          Reference = GetReference(x, y, data);
413          int32_t x, y;          t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);
         int32_t iIntra = 0;  
         VECTOR pmv;  
414    
415          if (sadInit)          data->temp[0] = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
                 (*sadInit) ();  
416    
417          for (y = 0; y < iHcount; y++)   {          data->temp[0] += (data->lambda16 * t * data->temp[0]) >> 10;
418                  for (x = 0; x < iWcount; x ++)  {          data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
419    
420                          MACROBLOCK *const pMB = &pMBs[x + y * iWcount];          if (data->temp[0] < data->iMinSAD[0]) {
421                    data->iMinSAD[0] = data->temp[0];
422                    data->currentMV[0].x = x; data->currentMV[0].y = y;
423                    *dir = Direction; }
424    
425                          pMB->sad16 =          if (data->temp[1] < data->iMinSAD[1]) {
426                                  SEARCH16(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,                  data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
427                                                   y, current->motion_flags, current->quant,          if (data->temp[2] < data->iMinSAD[2]) {
428                                                   current->fcode, pParam, pMBs, prevMBs, &pMB->mv16,                  data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
429                                                   &pMB->pmvs[0]);          if (data->temp[3] < data->iMinSAD[3]) {
430                    data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
431            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                          if (0 < (pMB->sad16 - MV16_INTER_BIAS)) {  static void
436                                  int32_t deviation;  CheckCandidate16no4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
437    {
438            int32_t sad, xc, yc;
439            const uint8_t * Reference;
440            uint32_t t;
441            VECTOR * current;
442    
443                                  deviation =          if ( (x > data->max_dx) | ( x < data->min_dx)
444                                          dev16(pCurrent->y + x * 16 + y * 16 * pParam->edged_width,                  | (y > data->max_dy) | (y < data->min_dy) ) return;
                                                   pParam->edged_width);  
445    
446                                  if (deviation < (pMB->sad16 - MV16_INTER_BIAS)) {          if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; //non-zero even value
                                         pMB->mode = MODE_INTRA;  
                                         pMB->mv16 = pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] =  
                                                 pMB->mvs[3] = zeroMV;  
                                         pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] =  
                                                 pMB->sad8[3] = 0;  
447    
448                                          iIntra++;          if (data->qpel_precision) { // x and y are in 1/4 precision
449                                          if (iIntra >= iLimit)                  Reference = Interpolate16x16qpel(x, y, 0, data);
450                                                  return 1;                  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                                          continue;          sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);
461            sad += (data->lambda16 * t * sad)>>10;
462    
463            if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
464                                                                                    (yc >> 1) + roundtab_79[yc & 0x3], data);
465    
466            if (sad < *(data->iMinSAD)) {
467                    *(data->iMinSAD) = sad;
468                    current->x = x; current->y = y;
469                    *dir = Direction;
470                                  }                                  }
471                          }                          }
472    
473                          pmv = pMB->pmvs[0];  static void
474                          if (current->global_flags & XVID_INTER4V)  CheckCandidate32I(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
475                                  if ((!(current->global_flags & XVID_LUMIMASKING) ||  {
476                                           pMB->dquant == NO_CHANGE)) {  // maximum speed - for P/B/I decision
477                                          int32_t sad8 = IMV16X16 * current->quant;          int32_t sad;
   
                                         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, current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[0],  
                                                                         &pMB->pmvs[0]);  
   
                                         if (sad8 < pMB->sad16)  
                                                 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, current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[1],  
                                                                         &pMB->pmvs[1]);  
   
                                         if (sad8 < pMB->sad16)  
                                                 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, current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[2],  
                                                                         &pMB->pmvs[2]);  
   
                                         if (sad8 < pMB->sad16)  
                                                 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,  
                                                                         current->motion_flags, current->quant,  
                                                                         current->fcode, pParam, pMBs, prevMBs,  
                                                                         &pMB->mvs[3], &pMB->pmvs[3]);  
478    
479                                          /* decide: MODE_INTER or MODE_INTER4V          if ( (x > data->max_dx) || (x < data->min_dx)
480                                             mpeg4:   if (sad8 < pMB->sad16 - nb/2+1) use_inter4v                  || (y > data->max_dy) || (y < data->min_dy) ) return;
                                          */  
481    
482                                          if (sad8 < pMB->sad16) {          sad = sad32v_c(data->Cur, data->Ref + x/2 + (y/2)*(data->iEdgedWidth),
483                                                  pMB->mode = MODE_INTER4V;                                                          data->iEdgedWidth, data->temp+1);
484                                                  pMB->sad8[0] *= 4;  
485                                                  pMB->sad8[1] *= 4;          if (sad < *(data->iMinSAD)) {
486                                                  pMB->sad8[2] *= 4;                  *(data->iMinSAD) = sad;
487                                                  pMB->sad8[3] *= 4;                  data->currentMV[0].x = x; data->currentMV[0].y = y;
488                                                  continue;                  *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                          pMB->mode = MODE_INTER;  static void
502                          pMB->pmvs[0] = pmv;     /* pMB->pmvs[1] = pMB->pmvs[2] = pMB->pmvs[3]  are not needed for INTER */  CheckCandidateInt(const int xf, const int yf, const int Direction, int * const dir, const SearchData * const data)
503                          pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mv16;  {
504                          pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] =          int32_t sad, xb, yb, xcf, ycf, xcb, ycb;
505                                  pMB->sad16;          uint32_t t;
506            const uint8_t *ReferenceF, *ReferenceB;
507            VECTOR *current;
508    
509            if ( (xf > data->max_dx) | (xf < data->min_dx)
510                    | (yf > data->max_dy) | (yf < data->min_dy) ) return;
511    
512            if (!data->qpel_precision) {
513                    ReferenceF = GetReference(xf, yf, data);
514                    xb = data->currentMV[1].x; yb = data->currentMV[1].y;
515                    ReferenceB = GetReferenceB(xb, yb, 1, data);
516                    current = data->currentMV;
517                    xcf = xf; ycf = yf;
518                    xcb = xb; ycb = yb;
519            } else {
520                    ReferenceF = Interpolate16x16qpel(xf, yf, 0, data);
521                    xb = data->currentQMV[1].x; yb = data->currentQMV[1].y;
522                    current = data->currentQMV;
523                    ReferenceB = Interpolate16x16qpel(xb, yb, 1, data);
524                    xcf = xf/2; ycf = yf/2;
525                    xcb = xb/2; ycb = yb/2;
526            }
527    
528            t = d_mv_bits(xf, yf, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0)
529                     + d_mv_bits(xb, yb, data->bpredMV, data->iFcode, data->qpel^data->qpel_precision, 0);
530    
531            sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
532            sad += (data->lambda16 * t * sad)>>10;
533    
534            if (data->chroma) sad += ChromaSAD2((xcf >> 1) + roundtab_79[xcf & 0x3],
535                                                                                    (ycf >> 1) + roundtab_79[ycf & 0x3],
536                                                                                    (xcb >> 1) + roundtab_79[xcb & 0x3],
537                                                                                    (ycb >> 1) + roundtab_79[ycb & 0x3], data);
538    
539            if (sad < *(data->iMinSAD)) {
540                    *(data->iMinSAD) = sad;
541                    current->x = xf; current->y = yf;
542                    *dir = Direction;
543                          }                          }
544                          }                          }
545    
546          return 0;  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            if (( x > 31) | ( x < -32) | ( y > 31) | (y < -32)) return;
556    
557            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  #define CHECK_MV16_ZERO {\                  ReferenceF = Interpolate8x8qpel(mvs.x, mvs.y, k, 0, data);
584    if ( (0 <= max_dx) && (0 >= min_dx) \                  ReferenceB = Interpolate8x8qpel(b_mvs.x, b_mvs.y, k, 1, data);
     && (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(-pmv[0].x, -pmv[0].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) - pmv[0].x, (Y) - pmv[0].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) - pmv[0].x, (Y) - pmv[0].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) - pmv[0].x, (Y) - pmv[0].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) - pmv[0].x, (Y) - pmv[0].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(-pmv[0].x, -pmv[0].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)-pmv[0].x, (Y)-pmv[0].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)-pmv[0].x, (Y)-pmv[0].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)-pmv[0].x, (Y)-pmv[0].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)-pmv[0].x, (Y)-pmv[0].y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \  
 }  
   
 /* too slow and not fully functional at the moment */  
 /*  
 int32_t ZeroSearch16(  
                                         const uint8_t * const pRef,  
                                         const uint8_t * const pRefH,  
                                         const uint8_t * const pRefV,  
                                         const uint8_t * const pRefHV,  
                                         const IMAGE * const pCur,  
                                         const int x, const int y,  
                                         const uint32_t MotionFlags,  
                                         const uint32_t iQuant,  
                                         const uint32_t iFcode,  
                                         MBParam * const pParam,  
                                         const MACROBLOCK * const pMBs,  
                                         const MACROBLOCK * const prevMBs,  
                                         VECTOR * const currMV,  
                                         VECTOR * const currPMV)  
 {  
         const int32_t iEdgedWidth = pParam->edged_width;  
         const uint8_t * cur = pCur->y + x*16 + y*16*iEdgedWidth;  
         int32_t iSAD;  
         VECTOR pred;  
585    
586                    sad += sad8bi(data->Cur + 8*(k&1) + 8*(k>>1)*(data->iEdgedWidth),
587                                                    ReferenceF, ReferenceB, data->iEdgedWidth);
588                    if (sad > *(data->iMinSAD)) return;
589            }
590    
591          pred = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
592    
593          iSAD = sad16( cur,          if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
594                  get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0,0, iEdgedWidth),                                                                                  (ycf >> 3) + roundtab_76[ycf & 0xf],
595                  iEdgedWidth, MV_MAX_ERROR);                                                                                  (xcb >> 3) + roundtab_76[xcb & 0xf],
596          if (iSAD <= iQuant * 96)                                                                                  (ycb >> 3) + roundtab_76[ycb & 0xf], data);
                 iSAD -= MV16_00_BIAS;  
597    
598          currMV->x = 0;          if (sad < *(data->iMinSAD)) {
599          currMV->y = 0;                  *(data->iMinSAD) = sad;
600          currPMV->x = -pred.x;                  data->currentMV->x = x; data->currentMV->y = y;
601          currPMV->y = -pred.y;                  *dir = Direction;
602            }
603    }
604    
605          return iSAD;  static void
606    CheckCandidateDirectno4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
607    {
608            int32_t sad, xcf, ycf, xcb, ycb;
609            const uint8_t *ReferenceF;
610            const uint8_t *ReferenceB;
611            VECTOR mvs, b_mvs;
612    
613  }          if (( x > 31) | ( x < -32) | ( y > 31) | (y < -32)) return;
 */  
614    
615  int32_t          mvs.x = data->directmvF[0].x + x;
616  Diamond16_MainSearch(const uint8_t * const pRef,          b_mvs.x = ((x == 0) ?
617                                           const uint8_t * const pRefH,                  data->directmvB[0].x
618                                           const uint8_t * const pRefV,                  : mvs.x - data->referencemv[0].x);
619                                           const uint8_t * const pRefHV,  
620                                           const uint8_t * const cur,          mvs.y = data->directmvF[0].y + y;
621                                           const int x,          b_mvs.y = ((y == 0) ?
622                                           const int y,                  data->directmvB[0].y
623                                           int32_t startx,                  : mvs.y - data->referencemv[0].y);
624                                           int32_t starty,  
625                                           int32_t iMinSAD,          if ( (mvs.x > data->max_dx) | (mvs.x < data->min_dx)
626                                           VECTOR * const currMV,                  | (mvs.y > data->max_dy) | (mvs.y < data->min_dy)
627                                           const VECTOR * const pmv,                  | (b_mvs.x > data->max_dx) | (b_mvs.x < data->min_dx)
628                                           const int32_t min_dx,                  | (b_mvs.y > data->max_dy) | (b_mvs.y < data->min_dy) ) return;
629                                           const int32_t max_dx,  
630                                           const int32_t min_dy,          if (data->qpel) {
631                                           const int32_t max_dy,                  xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2);
632                                           const int32_t iEdgedWidth,                  xcb = 4*(b_mvs.x/2); ycb = 4*(b_mvs.y/2);
633                                           const int32_t iDiamondSize,                  ReferenceF = Interpolate16x16qpel(mvs.x, mvs.y, 0, data);
634                                           const int32_t iFcode,                  ReferenceB = Interpolate16x16qpel(b_mvs.x, b_mvs.y, 1, data);
                                          const int32_t iQuant,  
                                          int iFound)  
 {  
 /* Do a diamond search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = startx;  
         backupMV.y = starty;  
   
 /* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */  
   
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
   
         if (iDirection)  
                 while (!iFound) {  
                         iFound = 1;  
                         backupMV = *currMV;  
   
                         if (iDirection != 2)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                    backupMV.y, 1);  
                         if (iDirection != 1)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                    backupMV.y, 2);  
                         if (iDirection != 4)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x,  
                                                                                    backupMV.y - iDiamondSize, 3);  
                         if (iDirection != 3)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x,  
                                                                                    backupMV.y + iDiamondSize, 4);  
635          } else {          } else {
636                  currMV->x = startx;                  xcf = 4*mvs.x; ycf = 4*mvs.y;
637                  currMV->y = starty;                  xcb = 4*b_mvs.x; ycb = 4*b_mvs.y;
638          }                  ReferenceF = GetReference(mvs.x, mvs.y, data);
639          return iMinSAD;                  ReferenceB = GetReferenceB(b_mvs.x, b_mvs.y, 1, data);
640  }  }
641    
642  int32_t          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
643  Square16_MainSearch(const uint8_t * const pRef,          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
                                         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 startx,  
                                         int32_t starty,  
                                         int32_t iMinSAD,  
                                         VECTOR * const currMV,  
                                         const VECTOR * const pmv,  
                                         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 = startx;  
         backupMV.y = starty;  
   
 /* 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  
 */  
644    
645          CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);          if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
646          CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);                                                                                  (ycf >> 3) + roundtab_76[ycf & 0xf],
647          CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);                                                                                  (xcb >> 3) + roundtab_76[xcb & 0xf],
648          CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);                                                                                  (ycb >> 3) + roundtab_76[ycb & 0xf], data);
   
         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;  
649    
650                          switch (iDirection) {          if (sad < *(data->iMinSAD)) {
651                          case 1:                  *(data->iMinSAD) = sad;
652                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                  data->currentMV->x = x; data->currentMV->y = y;
653                                                                                     backupMV.y, 1);                  *dir = Direction;
654                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,          }
655                                                                                   backupMV.y - iDiamondSize, 5);  }
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 break;  
                         case 2:  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
656    
                         case 3:  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
657    
658                          case 4:  static void
659                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,  CheckCandidateBits16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
660                                                                                   3);  {
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 break;  
   
                         case 5:  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y,  
                                                                                  1);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
                                 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);  
                                 break;  
   
                         case 6:  
                                 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 - 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, 8);  
661    
662                                  break;          static int16_t in[64], coeff[64];
663            int32_t bits = 0, sum;
664            VECTOR * current;
665            const uint8_t * ptr;
666            int i, cbp = 0, t, xc, yc;
667    
668                          case 7:          if ( (x > data->max_dx) || (x < data->min_dx)
669                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                  || (y > data->max_dy) || (y < data->min_dy) ) return;
                                                                                    backupMV.y, 1);  
                                 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, 7);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
670    
671                          case 8:          if (!data->qpel_precision) {
672                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,                  ptr = GetReference(x, y, data);
673                                                                                   2);                  current = data->currentMV;
674                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,                  xc = x; yc = y;
675                                                                                   4);          } else { // x and y are in 1/4 precision
676                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,                  ptr = Interpolate16x16qpel(x, y, 0, data);
677                                                                                   backupMV.y + iDiamondSize, 6);                  current = data->currentQMV;
678                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,                  xc = x/2; yc = y/2;
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
                         default:  
                                 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);  
                                 break;  
679                          }                          }
680          } else {  
681                  currMV->x = startx;          for(i = 0; i < 4; i++) {
682                  currMV->y = starty;                  int s = 8*((i&1) + (i>>1)*data->iEdgedWidth);
683                    transfer_8to16subro(in, data->Cur + s, ptr + s, data->iEdgedWidth);
684                    fdct(in);
685                    if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
686                    else sum = quant4_inter(coeff, in, data->lambda16);
687                    if (sum > 0) {
688                            cbp |= 1 << (5 - i);
689                            bits += data->temp[i] = CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
690                    } else data->temp[i] = 0;
691          }          }
692          return iMinSAD;  
693            bits += t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
694    
695            if (bits < data->iMinSAD[0]) { // there is still a chance, adding chroma
696                    xc = (xc >> 1) + roundtab_79[xc & 0x3];
697                    yc = (yc >> 1) + roundtab_79[yc & 0x3];
698    
699                    //chroma U
700                    ptr = interpolate8x8_switch2(data->RefQ + 64, data->RefCU, 0, 0, xc, yc,  data->iEdgedWidth/2, data->rounding);
701                    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 (bits < data->iMinSAD[0]) {
711                            //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                            }
721                    }
722            }
723    
724  int32_t          bits += cbpy_tab[15-(cbp>>2)].len;
725  Full16_MainSearch(const uint8_t * const pRef,          bits += mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len;
                                   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 startx,  
                                   int32_t starty,  
                                   int32_t iMinSAD,  
                                   VECTOR * const currMV,  
                                   const VECTOR * const pmv,  
                                   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 = startx;  
         backupMV.y = starty;  
   
         for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)  
                 for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)  
                         NOCHECK_MV16_CANDIDATE(dx, dy);  
726    
727          return iMinSAD;          if (bits < data->iMinSAD[0]) {
728                    data->iMinSAD[0] = bits;
729                    current[0].x = x; current[0].y = y;
730                    *dir = Direction;
731  }  }
732    
733  int32_t          if (data->temp[0] + t < data->iMinSAD[1]) {
734  AdvDiamond16_MainSearch(const uint8_t * const pRef,                  data->iMinSAD[1] = data->temp[0] + t; current[1].x = x; current[1].y = y; }
735                                                  const uint8_t * const pRefH,          if (data->temp[1] < data->iMinSAD[2]) {
736                                                  const uint8_t * const pRefV,                  data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }
737                                                  const uint8_t * const pRefHV,          if (data->temp[2] < data->iMinSAD[3]) {
738                                                  const uint8_t * const cur,                  data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
739                                                  const int x,          if (data->temp[3] < data->iMinSAD[4]) {
740                                                  const int y,                  data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
741                                                  int32_t startx,  
742                                                  int32_t starty,  }
743                                                  int32_t iMinSAD,  static void
744                                                  VECTOR * const currMV,  CheckCandidateBits8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
                                                 const VECTOR * const pmv,  
                                                 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)  
745  {  {
746    
747          int32_t iSAD;          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  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */          if ( (x > data->max_dx) || (x < data->min_dx)
754                    || (y > data->max_dy) || (y < data->min_dy) ) return;
755    
756          if (iDirection) {          if (!data->qpel_precision) {
757                  CHECK_MV16_CANDIDATE(startx - iDiamondSize, starty);                  ptr = GetReference(x, y, data);
758                  CHECK_MV16_CANDIDATE(startx + iDiamondSize, starty);                  current = data->currentMV;
759                  CHECK_MV16_CANDIDATE(startx, starty - iDiamondSize);          } else { // x and y are in 1/4 precision
760                  CHECK_MV16_CANDIDATE(startx, starty + iDiamondSize);                  ptr = Interpolate8x8qpel(x, y, 0, 0, data);
761          } else {                  current = data->currentQMV;
762                  int bDirection = 1 + 2 + 4 + 8;          }
763    
764                  do {          transfer_8to16subro(in, data->Cur, ptr, data->iEdgedWidth);
765                          iDirection = 0;          fdct(in);
766                          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->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
767                                  CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize, starty, 1);          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 (bDirection & 2)          bits += sum = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
                                 CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize, starty, 2);  
774    
775                          if (bDirection & 4)          if (bits < data->iMinSAD[0]) {
776                                  CHECK_MV16_CANDIDATE_DIR(startx, starty - iDiamondSize, 4);                  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 (bDirection & 8)  /* CHECK_CANDIATE FUNCTIONS END */
                                 CHECK_MV16_CANDIDATE_DIR(startx, starty + iDiamondSize, 8);  
784    
785                          /* now we're doing diagonal checks near our candidate */  /* MAINSEARCH FUNCTIONS START */
786    
787                          if (iDirection)         //checking if anything found  static void
788    AdvDiamondSearch(int x, int y, const SearchData * const data, int bDirection)
789                          {                          {
790    
791    /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
792    
793            int iDirection;
794    
795            for(;;) { //forever
796                    iDirection = 0;
797                    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                    /* now we're doing diagonal checks near our candidate */
803    
804                    if (iDirection) {               //if anything found
805                                  bDirection = iDirection;                                  bDirection = iDirection;
806                                  iDirection = 0;                                  iDirection = 0;
807                                  startx = currMV->x;                          x = data->currentMV->x; y = data->currentMV->y;
808                                  starty = currMV->y;                          if (bDirection & 3) {   //our candidate is left or right
809                                  if (bDirection & 3)     //our candidate is left or right                                  CHECK_CANDIDATE(x, y + iDiamondSize, 8);
810                                  {                                  CHECK_CANDIDATE(x, y - iDiamondSize, 4);
811                                          CHECK_MV16_CANDIDATE_DIR(startx, starty + iDiamondSize, 8);                          } else {                        // what remains here is up or down
812                                          CHECK_MV16_CANDIDATE_DIR(startx, starty - iDiamondSize, 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y, 2);
813                                  } else                  // what remains here is up or down                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);
                                 {  
                                         CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize, starty, 2);  
                                         CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize, starty, 1);  
814                                  }                                  }
815    
816                                  if (iDirection) {                                  if (iDirection) {
817                                          bDirection += iDirection;                                          bDirection += iDirection;
818                                          startx = currMV->x;                                  x = data->currentMV->x; y = data->currentMV->y;
                                         starty = currMV->y;  
819                                  }                                  }
820                          } else                          //about to quit, eh? not so fast....                  } else {                                //about to quit, eh? not so fast....
                         {  
821                                  switch (bDirection) {                                  switch (bDirection) {
822                                  case 2:                                  case 2:
823                                          CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
824                                                                                           starty - iDiamondSize, 2 + 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                         CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                          starty + iDiamondSize, 2 + 8);  
825                                          break;                                          break;
826                                  case 1:                                  case 1:
827                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
828                                                                                           starty - iDiamondSize, 1 + 4);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
                                         CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                          starty + iDiamondSize, 1 + 8);  
829                                          break;                                          break;
830                                  case 2 + 4:                                  case 2 + 4:
831                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
832                                                                                           starty - iDiamondSize, 1 + 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
833                                          CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                                                                          starty - iDiamondSize, 2 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                          starty + iDiamondSize, 2 + 8);  
834                                          break;                                          break;
835                                  case 4:                                  case 4:
836                                          CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
837                                                                                           starty - iDiamondSize, 2 + 4);                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
                                         CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                          starty - iDiamondSize, 1 + 4);  
838                                          break;                                          break;
839                                  case 8:                                  case 8:
840                                          CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
841                                                                                           starty + iDiamondSize, 2 + 8);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
                                         CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                          starty + iDiamondSize, 1 + 8);  
842                                          break;                                          break;
843                                  case 1 + 4:                                  case 1 + 4:
844                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
845                                                                                           starty + iDiamondSize, 1 + 8);                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
846                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
                                                                                          starty - iDiamondSize, 1 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                          starty - iDiamondSize, 2 + 4);  
847                                          break;                                          break;
848                                  case 2 + 8:                                  case 2 + 8:
849                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
850                                                                                           starty - iDiamondSize, 1 + 4);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
851                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                                                                          starty + iDiamondSize, 1 + 8);  
                                         CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                          starty + iDiamondSize, 2 + 8);  
852                                          break;                                          break;
853                                  case 1 + 8:                                  case 1 + 8:
854                                          CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
855                                                                                           starty - iDiamondSize, 2 + 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
856                                          CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
                                                                                          starty + iDiamondSize, 2 + 8);  
                                         CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                          starty + iDiamondSize, 1 + 8);  
857                                          break;                                          break;
858                                  default:                //1+2+4+8 == we didn't find anything at all                                  default:                //1+2+4+8 == we didn't find anything at all
859                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
860                                                                                           starty - iDiamondSize, 1 + 4);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
861                                          CHECK_MV16_CANDIDATE_DIR(startx - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
862                                                                                           starty + iDiamondSize, 1 + 8);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                         CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                          starty - iDiamondSize, 2 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                          starty + iDiamondSize, 2 + 8);  
863                                          break;                                          break;
864                                  }                                  }
865                                  if (!iDirection)                          if (!iDirection) break;         //ok, the end. really
                                         break;          //ok, the end. really  
                                 else {  
866                                          bDirection = iDirection;                                          bDirection = iDirection;
867                                          startx = currMV->x;                          x = data->currentMV->x; y = data->currentMV->y;
                                         starty = currMV->y;  
868                                  }                                  }
869                          }                          }
870                  }                  }
                 while (1);                              //forever  
         }  
         return iMinSAD;  
 }  
871    
872  int32_t  static void
873  AdvDiamond8_MainSearch(const uint8_t * const pRef,  SquareSearch(int x, int y, const SearchData * const data, int bDirection)
                                            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 startx,  
                                            int32_t starty,  
                                            int32_t iMinSAD,  
                                            VECTOR * const currMV,  
                                            const VECTOR * const pmv,  
                                            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)  
874  {  {
875            int iDirection;
876    
877            do {
878                    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                    bDirection = iDirection;
889                    x = data->currentMV->x; y = data->currentMV->y;
890            } while (iDirection);
891    }
892    
893          int32_t iSAD;  static void
894    DiamondSearch(int x, int y, const SearchData * const data, int bDirection)
895    {
896    
897  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
898    
899          if (iDirection) {          int iDirection;
                 CHECK_MV8_CANDIDATE(startx - iDiamondSize, starty);  
                 CHECK_MV8_CANDIDATE(startx + iDiamondSize, starty);  
                 CHECK_MV8_CANDIDATE(startx, starty - iDiamondSize);  
                 CHECK_MV8_CANDIDATE(startx, starty + iDiamondSize);  
         } else {  
                 int bDirection = 1 + 2 + 4 + 8;  
900    
901                  do {                  do {
902                          iDirection = 0;                          iDirection = 0;
903                          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 (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
904                                  CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize, starty, 1);                  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                    /* now we're doing diagonal checks near our candidate */
909    
910                    if (iDirection) {               //checking if anything found
911                            bDirection = iDirection;
912                            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 (bDirection & 2)  /* MAINSEARCH FUNCTIONS END */
                                 CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize, starty, 2);  
929    
930                          if (bDirection & 4)  static void
931                                  CHECK_MV8_CANDIDATE_DIR(startx, starty - iDiamondSize, 4);  SubpelRefine(const SearchData * const data)
932    {
933    /* Do a half-pel or q-pel refinement */
934            const VECTOR centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;
935            int iDirection; //only needed because macro expects it
936    
937                          if (bDirection & 8)          CHECK_CANDIDATE(centerMV.x, centerMV.y - 1, 0);
938                                  CHECK_MV8_CANDIDATE_DIR(startx, starty + iDiamondSize, 8);          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y - 1, 0);
939            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                          /* now we're doing diagonal checks near our candidate */  static __inline int
948    SkipDecisionP(const IMAGE * current, const IMAGE * reference,
949                                                            const int x, const int y,
950                                                            const uint32_t stride, const uint32_t iQuant, int rrv)
951    
                         if (iDirection)         //checking if anything found  
952                          {                          {
953                                  bDirection = iDirection;          if(!rrv) {
954                                  iDirection = 0;                  uint32_t sadC = sad8(current->u + x*8 + y*stride*8,
955                                  startx = currMV->x;                                                  reference->u + x*8 + y*stride*8, stride);
956                                  starty = currMV->y;                  if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
957                                  if (bDirection & 3)     //our candidate is left or right                  sadC += sad8(current->v + (x + y*stride)*8,
958                                  {                                                  reference->v + (x + y*stride)*8, stride);
959                                          CHECK_MV8_CANDIDATE_DIR(startx, starty + iDiamondSize, 8);                  if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
960                                          CHECK_MV8_CANDIDATE_DIR(startx, starty - iDiamondSize, 4);                  return 1;
961                                  } else                  // what remains here is up or down  
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    SkipMacroblockP(MACROBLOCK *pMB, const int32_t sad)
975                                  {                                  {
976                                          CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize, starty, 2);          pMB->mode = MODE_NOT_CODED;
977                                          CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize, starty, 1);          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                                  if (iDirection) {  bool
983                                          bDirection += iDirection;  MotionEstimation(MBParam * const pParam,
984                                          startx = currMV->x;                                   FRAMEINFO * const current,
985                                          starty = currMV->y;                                   FRAMEINFO * const reference,
986                                     const IMAGE * const pRefH,
987                                     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            uint32_t mb_width = pParam->mb_width;
996            uint32_t mb_height = pParam->mb_height;
997            const uint32_t iEdgedWidth = pParam->edged_width;
998            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                          } else                          //about to quit, eh? not so fast....  
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                                  switch (bDirection) {                  current->warp = GlobalMotionEst( pMBs, pParam, current, reference, pRefH, pRefV, pRefHV);
1092                                  case 2:          }
1093                                          CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,          return 0;
1094                                                                                          starty - iDiamondSize, 2 + 4);  }
1095                                          CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
1096                                                                                          starty + iDiamondSize, 2 + 8);  
1097                                          break;  static __inline int
1098                                  case 1:  make_mask(const VECTOR * const pmv, const int i)
1099                                          CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  {
1100                                                                                          starty - iDiamondSize, 1 + 4);          int mask = 255, j;
1101                                          CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,          for (j = 0; j < i; j++) {
1102                                                                                          starty + iDiamondSize, 1 + 8);                  if (MVequal(pmv[i], pmv[j])) return 0; // same vector has been checked already
1103                                          break;                  if (pmv[i].x == pmv[j].x) {
1104                                  case 2 + 4:                          if (pmv[i].y == pmv[j].y + iDiamondSize) mask &= ~4;
1105                                          CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,                          else if (pmv[i].y == pmv[j].y - iDiamondSize) mask &= ~8;
1106                                                                                          starty - iDiamondSize, 1 + 4);                  } else
1107                                          CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,                          if (pmv[i].y == pmv[j].y) {
1108                                                                                          starty - iDiamondSize, 2 + 4);                                  if (pmv[i].x == pmv[j].x + iDiamondSize) mask &= ~1;
1109                                          CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,                                  else if (pmv[i].x == pmv[j].x - iDiamondSize) mask &= ~2;
                                                                                         starty + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 4:  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty - iDiamondSize, 1 + 4);  
                                         break;  
                                 case 8:  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty + iDiamondSize, 2 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty + iDiamondSize, 1 + 8);  
                                         break;  
                                 case 1 + 4:  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty - iDiamondSize, 2 + 4);  
                                         break;  
                                 case 2 + 8:  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 1 + 8:  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty + iDiamondSize, 2 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty + iDiamondSize, 1 + 8);  
                                         break;  
                                 default:                //1+2+4+8 == we didn't find anything at all  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty + iDiamondSize, 2 + 8);  
                                         break;  
1110                                  }                                  }
                                 if (!(iDirection))  
                                         break;          //ok, the end. really  
                                 else {  
                                         bDirection = iDirection;  
                                         startx = currMV->x;  
                                         starty = currMV->y;  
1111                                  }                                  }
1112            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            if (x != 0) { pmv[3].x = EVEN(pmv[1].x); pmv[3].y = EVEN(pmv[1].y); }// pmv[3] is left neighbour
1129            else pmv[3].x = pmv[3].y = 0;
1130    
1131            if (y != 0) { pmv[4].x = EVEN(pmv[2].x); pmv[4].y = EVEN(pmv[2].y); }// [4] top neighbour
1132            else pmv[4].x = pmv[4].y = 0;
1133    
1134            // [1] median prediction
1135            pmv[1].x = EVEN(pmv[0].x); pmv[1].y = EVEN(pmv[0].y);
1136    
1137            pmv[0].x = pmv[0].y = 0; // [0] is zero; not used in the loop (checked before) but needed here for make_mask
1138    
1139            pmv[2].x = EVEN(prevMB->mvs[0].x); // [2] is last frame
1140            pmv[2].y = EVEN(prevMB->mvs[0].y);
1141    
1142            if ((x < iWcount-1) && (y < iHcount-1)) {
1143                    pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); //[6] right-down neighbour in last frame
1144                    pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y);
1145            } else pmv[6].x = pmv[6].y = 0;
1146    
1147            if (rrv) {
1148                    int i;
1149                    for (i = 0; i < 7; i++) {
1150                            pmv[i].x = RRV_MV_SCALEUP(pmv[i].x);
1151                            pmv[i].y = RRV_MV_SCALEUP(pmv[i].y);
1152                  }                  }
                 while (1);                              //forever  
1153          }          }
         return iMinSAD;  
1154  }  }
1155    
1156    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  int32_t          int mode = MODE_INTER;
 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,  
                                  int32_t startx,  
                                  int32_t starty,  
                                  int32_t iMinSAD,  
                                  VECTOR * const currMV,  
                                  const VECTOR * const pmv,  
                                  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 = startx;  
         backupMV.y = starty;  
   
         for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)  
                 for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)  
                         NOCHECK_MV8_CANDIDATE(dx, dy);  
1168    
1169          return iMinSAD;          if (!(VopFlags & XVID_VOP_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision
1170    //              int intra = 0;
1171                    int sad;
1172                    int InterBias = MV16_INTER_BIAS;
1173                    if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +
1174                            Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) {
1175                                    mode = 0; //inter
1176                                    sad = Data->iMinSAD[0];
1177                    } else {
1178                            mode = MODE_INTER4V;
1179                            sad = Data->iMinSAD[1] + Data->iMinSAD[2] +
1180                                                    Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant;
1181                            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  int32_t                  if (Data->chroma) InterBias += 50; // to compensate bigger SAD
1193  Halfpel16_Refine(const uint8_t * const pRef,                  if (Data->rrv) InterBias *= 4;
1194                                   const uint8_t * const pRefH,  
1195                                   const uint8_t * const pRefV,                  if (InterBias < pMB->sad16) {
1196                                   const uint8_t * const pRefHV,                          int32_t deviation;
1197                                   const uint8_t * const cur,                          if (!Data->rrv) deviation = dev16(Data->Cur, Data->iEdgedWidth);
1198                                   const int x,                          else deviation = dev16(Data->Cur, Data->iEdgedWidth) +
1199                                   const int y,                                  dev16(Data->Cur+8, Data->iEdgedWidth) +
1200                                   VECTOR * const currMV,                                  dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) +
1201                                   int32_t iMinSAD,                                  dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth);
1202                                   const VECTOR * const pmv,  
1203                                   const int32_t min_dx,                          if (deviation < (sad - InterBias))  return MODE_INTRA;// intra
1204                                   const int32_t max_dx,                  }
1205                                   const int32_t min_dy,                  return mode;
1206                                   const int32_t max_dy,  
1207                                   const int32_t iFcode,          } else {
                                  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_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);  
         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);  
1208    
1209          return iMinSAD;                  int bits, intra, i;
1210                    VECTOR backup[5], *v;
1211                    Data->lambda16 = iQuant;
1212            Data->lambda8 = (pParam->vol_flags & XVID_VOL_MPEGQUANT)?1:0;
1213    
1214                    v = Data->qpel ? Data->currentQMV : Data->currentMV;
1215                    for (i = 0; i < 5; i++) {
1216                            Data->iMinSAD[i] = 256*4096;
1217                            backup[i] = v[i];
1218                    }
1219    
1220                    bits = CountMBBitsInter(Data, pMBs, x, y, pParam, MotionFlags);
1221                    if (bits == 0) return MODE_INTER; // quick stop
1222    
1223                    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    
 #define PMV_HALFPEL16 (PMV_HALFPELDIAMOND16|PMV_HALFPELREFINE16)  
1228    
1229                    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  PMVfastSearch16(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,
# Line 1097  Line 1243 
1243                                  const int x,                                  const int x,
1244                                  const int y,                                  const int 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 * 16 + y * 16 * iEdgedWidth;  
   
         int32_t iDiamondSize;  
   
         int32_t min_dx;  
         int32_t max_dx;  
         int32_t min_dy;  
         int32_t max_dy;  
1255    
1256          int32_t iFound;          int i, iDirection = 255, mask, threshA;
1257            VECTOR pmv[7];
1258    
1259          VECTOR newMV;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1260          VECTOR backupMV;                        /* just for PMVFAST */                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
1261    
1262          VECTOR pmv[4];          get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp);
1263          int32_t psad[4];  
1264            Data->temp[5] = Data->temp[6] = 0; // chroma-sad cache
1265            i = Data->rrv ? 2 : 1;
1266            Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;
1267            Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1268            Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1269    
1270            Data->Ref = pRef->y + (x + Data->iEdgedWidth*y) * 16*i;
1271            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          MainSearch16FuncPtr MainSearchPtr;          PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height,
1304                                            prevMBs + x + y * pParam->mb_width, Data->rrv);
1305    
1306          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;          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          int32_t threshA, threshB;                  MainSearchFunc * MainSearchPtr;
1326          int32_t bPredEq;                  if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1327          int32_t iMinSAD, iSAD;                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1328                            else MainSearchPtr = DiamondSearch;
1329    
1330  /* Get maximum range */                  MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
         get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,  
                           iFcode);  
1331    
1332  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */  /* extended search, diamond starting in 0,0 and in prediction.
1333            note that this search is/might be done in halfpel positions,
1334            which makes it more different than the diamond above */
1335    
1336          if (!(MotionFlags & PMV_HALFPEL16)) {                  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 something like IF (dx>max_dx) THEN dx=max_dx; */                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1347          //bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);
1348          bPredEq = get_pmvdata2(pMBs, iWcount, 0, x, y, 0, pmv, psad);                                  if (bSAD < Data->iMinSAD[0]) {
1349                                            Data->currentMV[0] = backupMV;
1350  /*      fprintf(stderr,"pmv: %d %d / %d --- %d %d   %d %d   %d %d - %d %d %d\n",                                          Data->iMinSAD[0] = bSAD; }
                 pmv[0].x,pmv[0].y,psad[0],  
                 pmv[1].x,pmv[1].y,pmv[2].x,pmv[2].y,pmv[3].x,pmv[3].y,  
                 psad[1],psad[2],psad[3]);  
 */  
         if ((x == 0) && (y == 0)) {  
                 threshA = 512;  
                 threshB = 1024;  
         } else {  
                 threshA = psad[0];  
                 threshB = threshA + 256;  
                 if (threshA < 512)  
                         threshA = 512;  
                 if (threshA > 1024)  
                         threshA = 1024;  
                 if (threshB > 1792)  
                         threshB = 1792;  
1351          }          }
1352    
1353          iFound = 0;                          backupMV = Data->currentMV[0];
1354                            startMV.x = startMV.y = 1;
1355  /* Step 4: Calculate SAD around the Median prediction.                          if (!(MVequal(startMV, backupMV))) {
1356     MinSAD=SAD                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
    If Motion Vector equal to Previous frame motion vector  
    and MinSAD<PrevFrmSAD goto Step 10.  
    If SAD<=256 goto Step 10.  
 */  
   
         *currMV = pmv[0];                       /* current best := prediction */  
         if (!(MotionFlags & PMV_HALFPEL16)) {   /* This should NOT be necessary! */  
                 currMV->x = EVEN(currMV->x);  
                 currMV->y = EVEN(currMV->y);  
         }  
1357    
1358          if (currMV->x > max_dx) {                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1359                  currMV->x = max_dx;                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);
1360          }                                  if (bSAD < Data->iMinSAD[0]) {
1361          if (currMV->x < min_dx) {                                          Data->currentMV[0] = backupMV;
1362                  currMV->x = min_dx;                                          Data->iMinSAD[0] = bSAD; }
1363          }          }
         if (currMV->y > max_dy) {  
                 currMV->y = max_dy;  
1364          }          }
         if (currMV->y < min_dy) {  
                 currMV->y = min_dy;  
1365          }          }
1366    
1367          iMinSAD =          if (MotionFlags & XVID_ME_HALFPELREFINE16)
1368                  sad16(cur,                  if ((!(MotionFlags & XVID_ME_HALFPELREFINE16_BITS)) || Data->iMinSAD[0] < 200*(int)iQuant)
1369                            get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,                          SubpelRefine(Data);
                                                  iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);  
         iMinSAD +=  
                 calc_delta_16(currMV->x - pmv[0].x, currMV->y - pmv[0].y,  
                                           (uint8_t) iFcode, iQuant);  
1370    
1371          if ((iMinSAD < 256) ||          for(i = 0; i < 5; i++) {
1372                  ((MVequal(*currMV, prevMB->mvs[0])) &&                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // initialize qpel vectors
1373                   ((uint32_t) iMinSAD < prevMB->sad16))) {                  Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
                 if (iMinSAD < 2 * iQuant)       // high chances for SKIP-mode  
                 {  
                         if (!MVzero(*currMV)) {  
                                 iMinSAD += MV16_00_BIAS;  
                                 CHECK_MV16_ZERO;        // (0,0) saves space for letterboxed pictures  
                                 iMinSAD -= MV16_00_BIAS;  
                         }  
                 }  
   
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast16_Terminate_with_Refine;  
1374          }          }
1375    
1376            if (MotionFlags & XVID_ME_QUARTERPELREFINE16)
1377                    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  /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion                          SubpelRefine(Data);
1383     vector of the median.                  }
    If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2  
 */  
1384    
1385          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[0])))          if ((!(VopFlags & XVID_VOP_MODEDECISION_BITS)) && (Data->iMinSAD[0] < (int32_t)iQuant * 30)) inter4v = 0;
                 iFound = 2;  
1386    
1387  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.          if (inter4v && (!(VopFlags & XVID_VOP_MODEDECISION_BITS) ||
1388     Otherwise select large Diamond Search.                          (!(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 ((!MVzero(pmv[0])) || (threshB < 1536) || (bPredEq))                  SearchData Data8;
1393                  iDiamondSize = 1;               // halfpel!                  memcpy(&Data8, Data, sizeof(SearchData)); //quick copy of common data
         else  
                 iDiamondSize = 2;               // halfpel!  
1394    
1395          if (!(MotionFlags & PMV_HALFPELDIAMOND16))                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8);
1396                  iDiamondSize *= 2;                  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  /*                  if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_BITS))) {
1401     Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.                          // 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     Also calculate (0,0) but do not subtract offset.                          int sumx = 0, sumy = 0;
1403     Let MinSAD be the smallest SAD up to this point.                          const int div = 1 + Data->qpel;
1404     If MV is (0,0) subtract offset.                          const VECTOR * const mv = Data->qpel ? pMB->qmvs : pMB->mvs;
 */  
1405    
1406  // (0,0) is always possible                          for (i = 0; i < 4; i++) {
1407                                    sumx += mv[i].x / div;
1408                                    sumy += mv[i].y / div;
1409                            }
1410    
1411          if (!MVzero(pmv[0]))                          Data->iMinSAD[1] += ChromaSAD(  (sumx >> 3) + roundtab_76[sumx & 0xf],
1412                  CHECK_MV16_ZERO;                                                                                          (sumy >> 3) + roundtab_76[sumy & 0xf], Data);
1413                    }
1414            }
1415    
1416  // previous frame MV is always possible          inter4v = ModeDecision(iQuant, Data, inter4v, pMB, pMBs, x, y, pParam, MotionFlags, VopFlags);
1417    
1418          if (!MVzero(prevMB->mvs[0]))          if (Data->rrv) {
1419                  if (!MVequal(prevMB->mvs[0], pmv[0]))                          Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
1420                          CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);                          Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
1421            }
1422    
1423  // left neighbour, if allowed          if (inter4v == MODE_INTER) {
1424                    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];
1427    
1428          if (!MVzero(pmv[1]))                  if(Data->qpel) {
1429                  if (!MVequal(pmv[1], prevMB->mvs[0]))                          pMB->qmvs[0] = pMB->qmvs[1]
1430                          if (!MVequal(pmv[1], pmv[0])) {                                  = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0];
1431                                  if (!(MotionFlags & PMV_HALFPEL16)) {                          pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x;
1432                                          pmv[1].x = EVEN(pmv[1].x);                          pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y;
1433                                          pmv[1].y = EVEN(pmv[1].y);                  } 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                                  CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);          } else if (inter4v == MODE_INTER4V) {
1439                          }                  pMB->mode = MODE_INTER4V;
1440  // top neighbour, if allowed                  pMB->sad16 = Data->iMinSAD[0];
1441          if (!MVzero(pmv[2]))          } else { // INTRA mode
1442                  if (!MVequal(pmv[2], prevMB->mvs[0]))                  SkipMacroblockP(pMB, 0); // not skip, but similar enough
1443                          if (!MVequal(pmv[2], pmv[0]))                  pMB->mode = MODE_INTRA;
                                 if (!MVequal(pmv[2], pmv[1])) {  
                                         if (!(MotionFlags & PMV_HALFPEL16)) {  
                                                 pmv[2].x = EVEN(pmv[2].x);  
                                                 pmv[2].y = EVEN(pmv[2].y);  
1444                                          }                                          }
                                         CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
1445    
 // top right neighbour, if allowed  
                                         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);  
                                                                                 }  
                                                                                 CHECK_MV16_CANDIDATE(pmv[3].x,  
                                                                                                                          pmv[3].y);  
1446                                                                          }                                                                          }
1447    
1448    static void
1449    Search8(const SearchData * const OldData,
1450                    const int x, const int y,
1451                    const uint32_t MotionFlags,
1452                    const MBParam * const pParam,
1453                    MACROBLOCK * const pMB,
1454                    const MACROBLOCK * const pMBs,
1455                    const int block,
1456                    SearchData * const Data)
1457    {
1458            int i = 0;
1459            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          if ((MVzero(*currMV)) &&          *(Data->iMinSAD) += (Data->lambda8 * i * (*Data->iMinSAD + NEIGH_8X8_BIAS))>>10;
                 (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )  
                 iMinSAD -= MV16_00_BIAS;  
   
1474    
1475  /* Step 6: If MinSAD <= thresa goto Step 10.          if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) {
1476     If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.                  if (Data->rrv) i = 2; else i = 1;
 */  
   
         if ((iMinSAD <= threshA) ||  
                 (MVequal(*currMV, prevMB->mvs[0]) &&  
                  ((uint32_t) iMinSAD < prevMB->sad16))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast16_Terminate_with_Refine;  
         }  
1477    
1478                    Data->Ref = OldData->Ref + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1479                    Data->RefH = OldData->RefH + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1480                    Data->RefV = OldData->RefV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1481                    Data->RefHV = OldData->RefHV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1482    
1483  /************ (Diamond Search)  **************/                  Data->Cur = OldData->Cur + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1484  /*                  Data->qpel_precision = 0;
    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.  
 */  
1485    
1486          if (MotionFlags & PMV_USESQUARES16)                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1487                  MainSearchPtr = Square16_MainSearch;                                          pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
         else if (MotionFlags & PMV_ADVANCEDDIAMOND16)  
                 MainSearchPtr = AdvDiamond16_MainSearch;  
         else  
                 MainSearchPtr = Diamond16_MainSearch;  
1488    
1489          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                  if (!Data->rrv) CheckCandidate = CheckCandidate8;
1490                    else CheckCandidate = CheckCandidate16no4v;
1491    
1492                    if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_BITS))) {
1493                            int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
1494    
1495  //      fprintf(stderr,"Entering Diamond %d %d (%d):\n",x,y,iMinSAD);                          MainSearchFunc *MainSearchPtr;
1496                            if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = SquareSearch;
1497                                    else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;
1498                                            else MainSearchPtr = DiamondSearch;
1499    
1500  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255);
         iSAD =  
                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,  
                                                   currMV->y, iMinSAD, &newMV, pmv, min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, iFound);  
1501    
1502          if (iSAD < iMinSAD) {                          if(*(Data->iMinSAD) < temp_sad) {
1503                  *currMV = newMV;                                          Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1504                  iMinSAD = iSAD;                                          Data->currentQMV->y = 2 * Data->currentMV->y;
1505                            }
1506          }          }
1507    
1508          if (MotionFlags & PMV_EXTSEARCH16) {                  if (MotionFlags & XVID_ME_HALFPELREFINE8) {
1509  /* extended: search (up to) two more times: orignal prediction and (0,0) */                          int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
1510    
1511                  if (!(MVequal(pmv[0], backupMV))) {                          SubpelRefine(Data); // perform halfpel refine of current best vector
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  
                                                                   pmv[0].x, pmv[0].y, iMinSAD, &newMV, pmv,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
1512    
1513                          if (iSAD < iMinSAD) {                          if(*(Data->iMinSAD) < temp_sad) { // we have found a better match
1514                                  *currMV = newMV;                                  Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1515                                  iMinSAD = iSAD;                                  Data->currentQMV->y = 2 * Data->currentMV->y;
1516                          }                          }
1517                  }                  }
1518    
1519                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                  if (Data->qpel && MotionFlags & XVID_ME_QUARTERPELREFINE8) {
1520                          iSAD =                                  Data->qpel_precision = 1;
1521                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,                                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1522                                                                    iMinSAD, &newMV, pmv, min_dx, max_dx, min_dy,                                          pParam->width, pParam->height, Data->iFcode, 1, 0);
1523                                                                    max_dy, iEdgedWidth, iDiamondSize, iFcode,                                  SubpelRefine(Data);
1524                                                                    iQuant, iFound);                  }
   
                         if (iSAD < iMinSAD) {  
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
1525                          }                          }
1526    
1527            if (Data->rrv) {
1528                            Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);
1529                            Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);
1530                  }                  }
1531    
1532            if(Data->qpel) {
1533                    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 {
1537                    pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x;
1538                    pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;
1539          }          }
1540    
1541  /*          pMB->mvs[block] = *Data->currentMV;
1542     Step 10:  The motion vector is chosen according to the block corresponding to MinSAD.          pMB->sad8[block] = 4 * *Data->iMinSAD;
1543  */  }
1544    
1545    PMVfast16_Terminate_with_Refine:  /* motion estimation for B-frames */
         if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step  
                 iMinSAD =  
                         Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                          iMinSAD, pmv, min_dx, max_dx, min_dy, max_dy,  
                                                          iFcode, iQuant, iEdgedWidth);  
1546    
1547  /*fprintf(stderr,"Chosen for %d %d: %d %d - %d %d\n",x,y,currMV->x,currMV->y,pmv[0].x,pmv[0].y);  static __inline VECTOR
1548  */  ChoosePred(const MACROBLOCK * const pMB, const uint32_t mode)
1549    PMVfast16_Terminate_without_Refine:  {
1550          currPMV->x = currMV->x - pmv[0].x;  /* the stupidiest function ever */
1551          currPMV->y = currMV->y - pmv[0].y;          return (mode == MODE_FORWARD ? pMB->mvs[0] : pMB->b_mvs[0]);
         return iMinSAD;  
1552  }  }
1553    
1554    static void __inline
1555    PreparePredictionsBF(VECTOR * const pmv, const int x, const int y,
1556                                                            const uint32_t iWcount,
1557                                                            const MACROBLOCK * const pMB,
1558                                                            const uint32_t mode_curr)
1559    {
1560    
1561            // [0] is prediction
1562            pmv[0].x = EVEN(pmv[0].x); pmv[0].y = EVEN(pmv[0].y);
1563    
1564            pmv[1].x = pmv[1].y = 0; // [1] is zero
1565    
1566            pmv[2] = ChoosePred(pMB, mode_curr);
1567            pmv[2].x = EVEN(pmv[2].x); pmv[2].y = EVEN(pmv[2].y);
1568    
1569            if ((y != 0)&&(x != (int)(iWcount+1))) {                        // [3] top-right neighbour
1570                    pmv[3] = ChoosePred(pMB+1-iWcount, mode_curr);
1571                    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  int32_t          if (y != 0) {
1575  Diamond8_MainSearch(const uint8_t * const pRef,                  pmv[4] = ChoosePred(pMB-iWcount, mode_curr);
1576                                          const uint8_t * const pRefH,                  pmv[4].x = EVEN(pmv[4].x); pmv[4].y = EVEN(pmv[4].y);
1577                                          const uint8_t * const pRefV,          } else pmv[4].x = pmv[4].y = 0;
                                         const uint8_t * const pRefHV,  
                                         const uint8_t * const cur,  
                                         const int x,  
                                         const int y,  
                                         int32_t startx,  
                                         int32_t starty,  
                                         int32_t iMinSAD,  
                                         VECTOR * const currMV,  
                                         const VECTOR * const pmv,  
                                         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 iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = startx;  
         backupMV.y = starty;  
   
 /* 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!  
   
                         if (iDirection != 2)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                   backupMV.y, 1);  
                         if (iDirection != 1)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                   backupMV.y, 2);  
                         if (iDirection != 4)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x,  
                                                                                   backupMV.y - iDiamondSize, 3);  
                         if (iDirection != 3)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x,  
                                                                                   backupMV.y + iDiamondSize, 4);  
         } else {  
                 currMV->x = startx;  
                 currMV->y = starty;  
         }  
         return iMinSAD;  
 }  
1578    
1579  int32_t          if (x != 0) {
1580  Halfpel8_Refine(const uint8_t * const pRef,                  pmv[5] = ChoosePred(pMB-1, mode_curr);
1581                                  const uint8_t * const pRefH,                  pmv[5].x = EVEN(pmv[5].x); pmv[5].y = EVEN(pmv[5].y);
1582                                  const uint8_t * const pRefV,          } else pmv[5].x = pmv[5].y = 0;
                                 const uint8_t * const pRefHV,  
                                 const uint8_t * const cur,  
                                 const int x,  
                                 const int y,  
                                 VECTOR * const currMV,  
                                 int32_t iMinSAD,  
                                 const VECTOR * const pmv,  
                                 const int32_t min_dx,  
                                 const int32_t max_dx,  
                                 const int32_t min_dy,  
                                 const int32_t max_dy,  
                                 const int32_t iFcode,  
                                 const int32_t iQuant,  
                                 const int32_t iEdgedWidth)  
 {  
 /* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */  
   
         int32_t iSAD;  
         VECTOR backupMV = *currMV;  
   
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y);  
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y + 1);  
         CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y + 1);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y + 1);  
1583    
1584          return iMinSAD;          if (x != 0 && y != 0) {
1585                    pmv[6] = ChoosePred(pMB-1-iWcount, mode_curr);
1586                    pmv[6].x = EVEN(pmv[6].x); pmv[6].y = EVEN(pmv[6].y);
1587            } else pmv[6].x = pmv[6].y = 0;
1588  }  }
1589    
1590    
1591  #define PMV_HALFPEL8 (PMV_HALFPELDIAMOND8|PMV_HALFPELREFINE8)  /* search backward or forward */
1592    static void
1593  int32_t  SearchBF(       const IMAGE * const pRef,
 PMVfastSearch8(const uint8_t * const pRef,  
1594                             const uint8_t * const pRefH,                             const uint8_t * const pRefH,
1595                             const uint8_t * const pRefV,                             const uint8_t * const pRefV,
1596                             const uint8_t * const pRefHV,                             const uint8_t * const pRefHV,
1597                             const IMAGE * const pCur,                             const IMAGE * const pCur,
1598                             const int x,                          const int x, const int y,
                            const int y,  
                            const int start_x,  
                            const int start_y,  
1599                             const uint32_t MotionFlags,                             const uint32_t MotionFlags,
                            const uint32_t iQuant,  
1600                             const uint32_t iFcode,                             const uint32_t iFcode,
1601                             const MBParam * const pParam,                             const MBParam * const pParam,
1602                             const MACROBLOCK * const pMBs,                          MACROBLOCK * const pMB,
1603                             const MACROBLOCK * const prevMBs,                          const VECTOR * const predMV,
1604                             VECTOR * const currMV,                          int32_t * const best_sad,
1605                             VECTOR * const currPMV)                          const int32_t mode_current,
1606                            SearchData * const Data)
1607  {  {
         const uint32_t iWcount = pParam->mb_width;  
         const int32_t iWidth = pParam->width;  
         const int32_t iHeight = pParam->height;  
         const int32_t iEdgedWidth = pParam->edged_width;  
   
         const uint8_t *cur = pCur->y + x * 8 + y * 8 * iEdgedWidth;  
   
         int32_t iDiamondSize;  
1608    
1609          int32_t min_dx;          int i, iDirection = 255, mask;
1610          int32_t max_dx;          VECTOR pmv[7];
1611          int32_t min_dy;          MainSearchFunc *MainSearchPtr;
1612          int32_t max_dy;          *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          VECTOR pmv[4];          Data->Ref = pRef->y + (x + y * Data->iEdgedWidth) * 16;
1618          int32_t psad[4];          Data->RefH = pRefH + (x + y * Data->iEdgedWidth) * 16;
1619          VECTOR newMV;          Data->RefV = pRefV + (x + y * Data->iEdgedWidth) * 16;
1620          VECTOR backupMV;          Data->RefHV = pRefHV + (x + y * Data->iEdgedWidth) * 16;
1621          VECTOR startMV;          Data->RefCU = pRef->u + (x + y * Data->iEdgedWidth/2) * 8;
1622            Data->RefCV = pRef->v + (x + y * Data->iEdgedWidth/2) * 8;
1623    
1624  //  const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;          Data->predMV = *predMV;
         const MACROBLOCK *const prevMB = prevMBs + (x >> 1) + (y >> 1) * iWcount;  
1625    
1626           int32_t threshA, threshB;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1627          int32_t iFound, bPredEq;                                  pParam->width, pParam->height, iFcode - Data->qpel, 0, 0);
         int32_t iMinSAD, iSAD;  
1628    
1629          int32_t iSubBlock = (y & 1) + (y & 1) + (x & 1);          pmv[0] = Data->predMV;
1630            if (Data->qpel) { pmv[0].x /= 2; pmv[0].y /= 2; }
1631    
1632          MainSearch8FuncPtr MainSearchPtr;          PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current);
1633    
1634          /* Init variables */          Data->currentMV->x = Data->currentMV->y = 0;
1635          startMV.x = start_x;          CheckCandidate = CheckCandidate16no4v;
         startMV.y = start_y;  
1636    
1637          /* Get maximum range */  // main loop. checking all predictions
1638          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,          for (i = 0; i < 7; i++) {
1639                            iFcode);                  if (!(mask = make_mask(pmv, i)) ) continue;
1640                    CheckCandidate16no4v(pmv[i].x, pmv[i].y, mask, &iDirection, Data);
         if (!(MotionFlags & PMV_HALFPELDIAMOND8)) {  
                 min_dx = EVEN(min_dx);  
                 max_dx = EVEN(max_dx);  
                 min_dy = EVEN(min_dy);  
                 max_dy = EVEN(max_dy);  
1641          }          }
1642    
1643          /* because we might use IF (dx>max_dx) THEN dx=max_dx; */          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1644          //bPredEq = get_pmvdata(pMBs, (x >> 1), (y >> 1), iWcount, iSubBlock, pmv, psad);          else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1645          bPredEq = get_pmvdata2(pMBs, iWcount, 0, (x >> 1), (y >> 1), iSubBlock, pmv, psad);                  else MainSearchPtr = DiamondSearch;
1646    
1647          if ((x == 0) && (y == 0)) {          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
                 threshA = 512 / 4;  
                 threshB = 1024 / 4;  
1648    
1649          } else {          SubpelRefine(Data);
                 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.  
 */  
1650    
1651            if (Data->qpel && *Data->iMinSAD < *best_sad + 300) {
1652                    Data->currentQMV->x = 2*Data->currentMV->x;
1653                    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  // Prepare for main loop  // three bits are needed to code backward mode. four for forward
1661    
1662  //  if (MotionFlags & PMV_USESQUARES8)          if (mode_current == MODE_FORWARD) *Data->iMinSAD += 4 * Data->lambda16;
1663  //      MainSearchPtr = Square8_MainSearch;          else *Data->iMinSAD += 3 * Data->lambda16;
 //  else  
1664    
1665          if (MotionFlags & PMV_ADVANCEDDIAMOND8)          if (*Data->iMinSAD < *best_sad) {
1666                  MainSearchPtr = AdvDiamond8_MainSearch;                  *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          else
1674                  MainSearchPtr = Diamond8_MainSearch;                                  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            if (mode_current == MODE_FORWARD) *(Data->currentMV+2) = *Data->currentMV;
1684            else *(Data->currentMV+1) = *Data->currentMV; //we store currmv for interpolate search
1685    }
1686    
1687          *currMV = startMV;  static void
1688    SkipDecisionB(const IMAGE * const pCur,
1689                                    const IMAGE * const f_Ref,
1690                                    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          iMinSAD =          for (k = 0; k < 4; k++) {
1703                  sad8(cur,                  dy += Data->directmvF[k].y / div;
1704                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,                  dx += Data->directmvF[0].x / div;
1705                                                  iEdgedWidth), iEdgedWidth);                  b_dy += Data->directmvB[0].y / div;
1706          iMinSAD +=                  b_dx += Data->directmvB[0].x / div;
1707                  calc_delta_8(currMV->x - pmv[0].x, currMV->y - pmv[0].y,          }
                                          (uint8_t) iFcode, iQuant);  
   
         if ((iMinSAD < 256 / 4) || ((MVequal(*currMV, prevMB->mvs[iSubBlock]))  
                                                                 && ((uint32_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  
 */  
1708    
1709          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[iSubBlock])))          dy = (dy >> 3) + roundtab_76[dy & 0xf];
1710                  iFound = 2;          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  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.          sum = sad8bi(pCur->u + 8 * x + 8 * y * stride,
1715     Otherwise select large Diamond Search.                                          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 ((!MVzero(pmv[0])) || (threshB < 1536 / 4) || (bPredEq))          if (sum >= 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) return; //no skip
                 iDiamondSize = 1;               // 1 halfpel!  
         else  
                 iDiamondSize = 2;               // 2 halfpel = 1 full pixel!  
1720    
1721          if (!(MotionFlags & PMV_HALFPELDIAMOND8))          sum += sad8bi(pCur->v + 8*x + 8 * y * stride,
1722                  iDiamondSize *= 2;                                          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            if (sum < 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) pMB->mode = MODE_DIRECT_NONE_MV; //skipped
1727    }
1728    
1729  /*  static __inline uint32_t
1730     Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.  SearchDirect(const IMAGE * const f_Ref,
1731     Also calculate (0,0) but do not subtract offset.                                  const uint8_t * const f_RefH,
1732     Let MinSAD be the smallest SAD up to this point.                                  const uint8_t * const f_RefV,
1733     If MV is (0,0) subtract offset.                                  const uint8_t * const f_RefHV,
1734  */                                  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,
1739                                    const int x, const int y,
1740                                    const uint32_t MotionFlags,
1741                                    const int32_t TRB, const int32_t TRD,
1742                                    const MBParam * const pParam,
1743                                    MACROBLOCK * const pMB,
1744                                    const MACROBLOCK * const b_mb,
1745                                    int32_t * const best_sad,
1746                                    SearchData * const Data)
1747    
1748    {
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                    if ( (pMB->b_mvs[k].x > Data->max_dx) | (pMB->b_mvs[k].x < Data->min_dx)
1783                            | (pMB->b_mvs[k].y > Data->max_dy) | (pMB->b_mvs[k].y < Data->min_dy) ) {
1784    
1785                            *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            CheckCandidate = b_mb->mode == MODE_INTER4V ? CheckCandidateDirect : CheckCandidateDirectno4v;
1800    
1801            CheckCandidate(0, 0, 255, &k, Data);
1802    
1803    // initial (fast) skip decision
1804            if (*Data->iMinSAD < pMB->quant * INITIAL_SKIP_THRESH * (2 + Data->chroma?1:0)) {
1805                    //possible skip
1806                    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  // the median prediction might be even better than mv16          skip_sad = *Data->iMinSAD;
1816    
1817          if (!MVequal(pmv[0], startMV))  //      DIRECT MODE DELTA VECTOR SEARCH.
1818                  CHECK_MV8_CANDIDATE(pmv[0].x, pmv[0].y);  //      This has to be made more effective, but at the moment I'm happy it's running at all
1819    
1820  // (0,0) if needed          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1821          if (!MVzero(pmv[0]))                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1822                  if (!MVzero(startMV))                          else MainSearchPtr = DiamondSearch;
                         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]) &&  
                  ((uint32_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;  
1823    
1824            MainSearchPtr(0, 0, Data, 255);
1825    
1826  /* Step 6: If MinSAD <= thresa goto Step 10.          SubpelRefine(Data);
    If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.  
 */  
1827    
1828          if ((iMinSAD <= threshA) ||          *best_sad = *Data->iMinSAD;
                 (MVequal(*currMV, prevMB->mvs[iSubBlock]) &&  
                  ((uint32_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.  
 */  
1829    
1830          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */          if (Data->qpel || b_mb->mode == MODE_INTER4V) pMB->mode = MODE_DIRECT;
1831            else pMB->mode = MODE_DIRECT_NO4V; //for faster compensation
1832    
1833  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */          pMB->pmvs[3] = *Data->currentMV;
         iSAD =  
                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,  
                                                   currMV->y, iMinSAD, &newMV, pmv, min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, iFound);  
1834    
1835          if (iSAD < iMinSAD) {          for (k = 0; k < 4; k++) {
1836                  *currMV = newMV;                  pMB->mvs[k].x = Data->directmvF[k].x + Data->currentMV->x;
1837                  iMinSAD = iSAD;                  pMB->b_mvs[k].x = (     (Data->currentMV->x == 0)
1838                                                            ? Data->directmvB[k].x
1839                                                            :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 (MotionFlags & PMV_EXTSEARCH8) {                  if (b_mb->mode != MODE_INTER4V) {
1852  /* extended: search (up to) two more times: orignal prediction and (0,0) */                          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                  if (!(MVequal(pmv[0], backupMV))) {                          pMB->qmvs[3] = pMB->qmvs[2] = pMB->qmvs[1] = pMB->qmvs[0];
1855                          iSAD =                          pMB->b_qmvs[3] = pMB->b_qmvs[2] = pMB->b_qmvs[1] = pMB->b_qmvs[0];
1856                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,                          break;
                                                                   pmv[0].x, pmv[0].y, iMinSAD, &newMV, pmv,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
   
                         if (iSAD < iMinSAD) {  
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
1857                          }                          }
1858                  }                  }
1859            return skip_sad;
1860    }
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    {
1884    
1885                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {          int iDirection, i, j;
1886                          iSAD =          SearchData bData;
1887                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
1888                                                                    iMinSAD, &newMV, pmv, min_dx, max_dx, min_dy,          fData->qpel_precision = 0;
1889                                                                    max_dy, iEdgedWidth, iDiamondSize, iFcode,          memcpy(&bData, fData, sizeof(SearchData)); //quick copy of common data
1890                                                                    iQuant, iFound);          *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                          if (iSAD < iMinSAD) {          CheckCandidateInt(fData->currentMV[0].x, fData->currentMV[0].y, 255, &iDirection, fData);
1927                                  *currMV = newMV;  
1928                                  iMinSAD = iSAD;  //diamond
1929            do {
1930                    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  /* Step 10: The motion vector is chosen according to the block corresponding to MinSAD.  void
1990     By performing an optional local half-pixel search, we can refine this result even further.  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            VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/
2014    
2015            const int32_t TRB = time_pp - time_bp;
2016            const int32_t TRD = time_pp;
2017    
2018    // 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            Data.RefQ = f_refV->u; // a good place, also used in MC (for similar purpose)
2036            // note: i==horizontal, j==vertical
2037            for (j = 0; j < pParam->mb_height; j++) {
2038    
2039                    f_predMV = b_predMV = zeroMV;   /* prediction is reset at left boundary */
2040    
2041    PMVfast8_Terminate_with_Refine:                  for (i = 0; i < pParam->mb_width; i++) {
2042          if (MotionFlags & PMV_HALFPELREFINE8)   // perform final half-pel step                          MACROBLOCK * const pMB = frame->mbs + i + j * pParam->mb_width;
2043                  iMinSAD =                          const MACROBLOCK * const b_mb = b_mbs + i + j * pParam->mb_width;
2044                          Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
2045                                                          iMinSAD, pmv, min_dx, max_dx, min_dy, max_dy,  /* special case, if collocated block is SKIPed in P-VOP: encoding is forward (0,0), cpb=0 without further ado */
2046                                                          iFcode, iQuant, iEdgedWidth);                          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                            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    PMVfast8_Terminate_without_Refine:                          if (pMB->mode == MODE_DIRECT_NONE_MV) { n_count++; continue; }
2070          currPMV->x = currMV->x - pmv[0].x;  
2071          currPMV->y = currMV->y - pmv[0].y;                          // forward search
2072                            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          return iMinSAD;                          // backward search
2080                            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                            switch (pMB->mode) {
2105                                    case MODE_FORWARD:
2106                                            f_count++;
2107                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2108                                            break;
2109                                    case MODE_BACKWARD:
2110                                            b_count++;
2111                                            b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2112                                            break;
2113                                    case MODE_INTERPOLATE:
2114                                            i_count++;
2115                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2116                                            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                            }
2124                    }
2125            }
2126  }  }
2127    
2128  int32_t  static __inline void
2129  EPZSSearch16(const uint8_t * const pRef,  MEanalyzeMB (   const uint8_t * const pRef,
2130                           const uint8_t * const pRefH,                                  const uint8_t * const pCur,
                          const uint8_t * const pRefV,  
                          const uint8_t * const pRefHV,  
                          const IMAGE * const pCur,  
2131                           const int x,                           const int x,
2132                           const int y,                           const int y,
                          const uint32_t MotionFlags,  
                          const uint32_t iQuant,  
                          const uint32_t iFcode,  
2133                           const MBParam * const pParam,                           const MBParam * const pParam,
2134                           const MACROBLOCK * const pMBs,                                  MACROBLOCK * const pMBs,
2135                           const MACROBLOCK * const prevMBs,                                  SearchData * const Data)
                          VECTOR * const currMV,  
                          VECTOR * const currPMV)  
2136  {  {
         const uint32_t iWcount = pParam->mb_width;  
         const uint32_t iHcount = pParam->mb_height;  
   
         const int32_t iWidth = pParam->width;  
         const int32_t iHeight = pParam->height;  
         const int32_t iEdgedWidth = pParam->edged_width;  
2137    
2138          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;          int i, mask;
2139            VECTOR pmv[3];
2140            MACROBLOCK * pMB = &pMBs[x + y * pParam->mb_width];
2141    
2142          int32_t min_dx;          for (i = 0; i < 5; i++) Data->iMinSAD[i] = MV_MAX_ERROR;
         int32_t max_dx;  
         int32_t min_dy;  
         int32_t max_dy;  
2143    
2144          VECTOR newMV;          //median is only used as prediction. it doesn't have to be real
2145          VECTOR backupMV;          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          VECTOR pmv[4];          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2154          int32_t psad[8];          pParam->width, pParam->height, Data->iFcode - (pParam->vol_flags&XVID_VOL_QUARTERPEL?1:0), 0, Data->rrv);
2155    
2156          static MACROBLOCK *oldMBs = NULL;          Data->Cur = pCur + (x + y * pParam->edged_width) * 16;
2157            Data->Ref = pRef + (x + y * pParam->edged_width) * 16;
2158    
2159  //  const MACROBLOCK * const pMB = pMBs + x + y * iWcount;          pmv[1].x = EVEN(pMB->mvs[0].x);
2160          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;          pmv[1].y = EVEN(pMB->mvs[0].y);
2161          MACROBLOCK *oldMB = NULL;          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           int32_t thresh2;          CheckCandidate32I(0, 0, 255, &i, Data);
         int32_t bPredEq;  
         int32_t iMinSAD, iSAD = 9999;  
2166    
2167          MainSearch16FuncPtr MainSearchPtr;          if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP * 4) {
2168    
2169          if (oldMBs == NULL) {                  if (!(mask = make_mask(pmv, 1)))
2170                  oldMBs = (MACROBLOCK *) calloc(iWcount * iHcount, sizeof(MACROBLOCK));                          CheckCandidate32I(pmv[1].x, pmv[1].y, mask, &i, Data);
2171  //      fprintf(stderr,"allocated %d bytes for oldMBs\n",iWcount*iHcount*sizeof(MACROBLOCK));                  if (!(mask = make_mask(pmv, 2)))
2172          }                          CheckCandidate32I(pmv[2].x, pmv[2].y, mask, &i, Data);
         oldMB = oldMBs + x + y * iWcount;  
2173    
2174  /* Get maximum range */                  if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP * 4) // diamond only if needed
2175          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,                          DiamondSearch(Data->currentMV->x, Data->currentMV->y, Data, i);
                           iFcode);  
2176    
2177          if (!(MotionFlags & PMV_HALFPEL16)) {                  for (i = 0; i < 4; i++) {
2178                  min_dx = EVEN(min_dx);                          MACROBLOCK * MB = &pMBs[x + (i&1) + (y+(i>>1)) * pParam->mb_width];
2179                  max_dx = EVEN(max_dx);                          MB->mvs[0] = MB->mvs[1] = MB->mvs[2] = MB->mvs[3] = Data->currentMV[i];
2180                  min_dy = EVEN(min_dy);                          MB->mode = MODE_INTER;
2181                  max_dy = EVEN(max_dy);                          MB->sad16 = Data->iMinSAD[i+1];
2182                    }
2183            }
2184          }          }
         /* 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.  
 */  
   
 // Prepare for main loop  
2185    
2186          *currMV = pmv[0];                       /* current best := median prediction */  #define INTRA_BIAS              2500
2187          if (!(MotionFlags & PMV_HALFPEL16)) {  #define INTRA_THRESH    1500
2188                  currMV->x = EVEN(currMV->x);  #define INTER_THRESH    1400
                 currMV->y = EVEN(currMV->y);  
         }  
   
         if (currMV->x > max_dx)  
                 currMV->x = max_dx;  
         if (currMV->x < min_dx)  
                 currMV->x = min_dx;  
         if (currMV->y > max_dy)  
                 currMV->y = max_dy;  
         if (currMV->y < min_dy)  
                 currMV->y = min_dy;  
   
 /***************** This is predictor SET A: only median prediction ******************/  
   
         iMinSAD =  
                 sad16(cur,  
                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,  
                                                  iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);  
         iMinSAD +=  
                 calc_delta_16(currMV->x - pmv[0].x, currMV->y - pmv[0].y,  
                                           (uint8_t) iFcode, iQuant);  
   
 // thresh1 is fixed to 256  
         if ((iMinSAD < 256) ||  
                 ((MVequal(*currMV, prevMB->mvs[0])) &&  
                  ((uint32_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 **************/  
2189    
2190  // previous frame MV  int
2191          CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);  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  // set threshhold based on Min of Prediction and SAD of collocated block          if (intraCount != 0 && intraCount < 10) // we're right after an I frame
2216  // CHECK_MV16 always uses iSAD for the SAD of last vector to check, so now iSAD is what we want                  IntraThresh += 4 * (intraCount - 10) * (intraCount - 10);
2217            else
2218                    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          if ((x == 0) && (y == 0)) {          InterThresh += 400 * (1 - bCount);
2222                  thresh2 = 512;          if (InterThresh < 300) InterThresh = 300;
         } else {  
 /* T_k = 1.2 * MIN(SAD_top,SAD_left,SAD_topleft,SAD_coll) +128;   [Tourapis, 2002] */  
2223    
2224                  thresh2 = MIN(psad[0], iSAD) * 6 / 5 + 128;          if (sadInit) (*sadInit) ();
         }  
2225    
2226  // MV=(0,0) is often a good choice          for (y = 1; y < pParam->mb_height-1; y += 2) {
2227                    for (x = 1; x < pParam->mb_width-1; x += 2) {
2228                            int i;
2229    
2230          CHECK_MV16_ZERO;                          if (bCount == 0) pMBs[x + y * pParam->mb_width].mvs[0] = zeroMV;
2231    
2232                            MEanalyzeMB(pRef->y, pCurrent->y, x, y, pParam, pMBs, &Data);
2233    
2234  // left neighbour, if allowed                          for (i = 0; i < 4; i++) {
2235          if (x != 0) {                                  int dev;
2236                  if (!(MotionFlags & PMV_HALFPEL16)) {                                  MACROBLOCK *pMB = &pMBs[x+(i&1) + (y+(i>>1)) * pParam->mb_width];
2237                          pmv[1].x = EVEN(pmv[1].x);                                  if (pMB->sad16 > IntraThresh) {
2238                          pmv[1].y = EVEN(pmv[1].y);                                          dev = dev16(pCurrent->y + (x + (i&1) + (y + (i>>1)) * pParam->edged_width) * 16,
2239                  }                                                                          pParam->edged_width);
2240                  CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);                                          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          }          }
 // 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);  
2244                  }                  }
2245                  CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);                                  sSAD += pMB->sad16;
   
 // top right neighbour, if allowed  
                 if ((uint32_t) x != (iWcount - 1)) {  
                         if (!(MotionFlags & PMV_HALFPEL16)) {  
                                 pmv[3].x = EVEN(pmv[3].x);  
                                 pmv[3].y = EVEN(pmv[3].y);  
2246                          }                          }
                         CHECK_MV16_CANDIDATE(pmv[3].x, pmv[3].y);  
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    
 /* Terminate if MinSAD <= T_2  
    Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]  
 */  
   
         if ((iMinSAD <= thresh2)  
                 || (MVequal(*currMV, prevMB->mvs[0]) &&  
                         ((uint32_t) iMinSAD <= prevMB->sad16))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto EPZS16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto EPZS16_Terminate_with_Refine;  
2255          }          }
2256    
 /***** predictor SET C: acceleration MV (new!), neighbours in prev. frame(new!) ****/  
   
         backupMV = prevMB->mvs[0];      // collocated MV  
         backupMV.x += (prevMB->mvs[0].x - oldMB->mvs[0].x);     // acceleration X  
         backupMV.y += (prevMB->mvs[0].y - oldMB->mvs[0].y);     // acceleration Y  
2257    
2258          CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y);  static WARPPOINTS
2259    GlobalMotionEst(const MACROBLOCK * const pMBs,
2260  // left neighbour                                  const MBParam * const pParam,
2261          if (x != 0)                                  const FRAMEINFO * const current,
2262                  CHECK_MV16_CANDIDATE((prevMB - 1)->mvs[0].x, (prevMB - 1)->mvs[0].y);                                  const FRAMEINFO * const reference,
2263                                    const IMAGE * const pRefH,
2264  // top neighbour                                  const IMAGE * const pRefV,
2265          if (y != 0)                                  const IMAGE * const pRefHV      )
2266                  CHECK_MV16_CANDIDATE((prevMB - iWcount)->mvs[0].x,  {
                                                          (prevMB - iWcount)->mvs[0].y);  
2267    
2268  // right neighbour, if allowed (this value is not written yet, so take it from   pMB->mvs          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          if ((uint32_t) x != iWcount - 1)          WARPPOINTS gmc;
                 CHECK_MV16_CANDIDATE((prevMB + 1)->mvs[0].x, (prevMB + 1)->mvs[0].y);  
2273    
2274  // bottom neighbour, dito          uint32_t mx, my;
         if ((uint32_t) y != iHcount - 1)  
                 CHECK_MV16_CANDIDATE((prevMB + iWcount)->mvs[0].x,  
                                                          (prevMB + iWcount)->mvs[0].y);  
2275    
2276  /* Terminate if MinSAD <= T_3 (here T_3 = T_2)  */          int MBh = pParam->mb_height;
2277          if (iMinSAD <= thresh2) {          int MBw = pParam->mb_width;
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto EPZS16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto EPZS16_Terminate_with_Refine;  
         }  
2278    
2279  /************ (if Diamond Search)  **************/          int *MBmask= calloc(MBh*MBw,sizeof(int));
2280            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          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */          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          if (MotionFlags & PMV_USESQUARES16)  // filter mask of all blocks
                 MainSearchPtr = Square16_MainSearch;  
         else  
          if (MotionFlags & PMV_ADVANCEDDIAMOND16)  
                 MainSearchPtr = AdvDiamond16_MainSearch;  
         else  
                 MainSearchPtr = Diamond16_MainSearch;  
2293    
2294  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */          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          iSAD =                  if (pMB->mode == MODE_INTRA || pMB->mode == MODE_NOT_CODED)
2302                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,                          continue;
                                                   currMV->y, iMinSAD, &newMV, pmv, min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);  
2303    
2304          if (iSAD < iMinSAD) {                  if ( ( (ABS(mv.x -   (pMB-1)->mvs[0].x) < deltax) && (ABS(mv.y -   (pMB-1)->mvs[0].y) < deltay) )
2305                  *currMV = newMV;                  &&   ( (ABS(mv.x -   (pMB+1)->mvs[0].x) < deltax) && (ABS(mv.y -   (pMB+1)->mvs[0].y) < deltay) )
2306                  iMinSAD = iSAD;                  &&   ( (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            for (my = 1; my < (uint32_t)MBh-1; my++)
2312            for (mx = 1; mx < (uint32_t)MBw-1; mx++)
2313            {
2314                    const uint8_t *const pCur = current->image.y + 16*my*pParam->edged_width + 16*mx;
2315    
2316          if (MotionFlags & PMV_EXTSEARCH16) {                  const int mbnum = mx + my * MBw;
2317  /* extended mode: search (up to) two more times: orignal prediction and (0,0) */                  if (!MBmask[mbnum])
2318                            continue;
2319    
2320                  if (!(MVequal(pmv[0], backupMV))) {                  if (sad16 ( pCur, pCur+1 , pParam->edged_width, 65536) <= (uint32_t)grad )
2321                          iSAD =                          MBmask[mbnum] = 0;
2322                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,                  if (sad16 ( pCur, pCur+pParam->edged_width, pParam->edged_width, 65536) <= (uint32_t)grad )
2323                                                                    pmv[0].x, pmv[0].y, iMinSAD, &newMV, pmv,                          MBmask[mbnum] = 0;
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   2, iFcode, iQuant, 0);  
                 }  
2324    
                 if (iSAD < iMinSAD) {  
                         *currMV = newMV;  
                         iMinSAD = iSAD;  
2325                  }                  }
2326    
2327                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {          emms();
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, pmv, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);  
2328    
2329                          if (iSAD < iMinSAD) {          do {            /* until convergence */
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
                         }  
                 }  
         }  
2330    
2331  /***************        Choose best MV found     **************/          a = b = c = n = 0;
2332            DtimesF[0] = DtimesF[1] = DtimesF[2] = DtimesF[3] = 0.;
2333            for (my = 0; my < (uint32_t)MBh; my++)
2334                    for (mx = 0; mx < (uint32_t)MBw; mx++)
2335                    {
2336                            const int mbnum = mx + my * MBw;
2337                            const MACROBLOCK *pMB = &pMBs[mbnum];
2338                            const VECTOR mv = pMB->mvs[0];
2339    
2340    EPZS16_Terminate_with_Refine:                          if (!MBmask[mbnum])
2341          if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step                                  continue;
                 iMinSAD =  
                         Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                          iMinSAD, pmv, min_dx, max_dx, min_dy, max_dy,  
                                                          iFcode, iQuant, iEdgedWidth);  
2342    
2343    EPZS16_Terminate_without_Refine:                          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          *oldMB = *prevMB;                          if (!MBmask[mbnum])
2379                                    continue;
2380    
2381          currPMV->x = currMV->x - pmv[0].x;                          oldnum++;
2382          currPMV->y = currMV->y - pmv[0].y;                          meanx += ABS(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - mv.x );
2383          return iMinSAD;                          meany += ABS(( sol[3] - (16*mx+8)*sol[2] + (16*my+8)*sol[1] ) - mv.y );
2384  }  }
2385    
2386            if (4*meanx > oldnum)   /* better fit than 0.25 is useless */
2387                    meanx /= oldnum;
2388            else
2389                    meanx = 0.25;
2390    
2391  int32_t          if (4*meany > oldnum)
2392  EPZSSearch8(const uint8_t * const pRef,                  meany /= oldnum;
2393                          const uint8_t * const pRefH,          else
2394                          const uint8_t * const pRefV,                  meany = 0.25;
                         const uint8_t * const pRefHV,  
                         const IMAGE * const pCur,  
                         const int x,  
                         const int y,  
                         const int start_x,  
                         const int start_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)  
 {  
 /* Please not that EPZS might not be a good choice for 8x8-block motion search ! */  
   
         const uint32_t iWcount = pParam->mb_width;  
         const int32_t iWidth = pParam->width;  
         const int32_t iHeight = pParam->height;  
         const int32_t iEdgedWidth = pParam->edged_width;  
   
         const uint8_t *cur = pCur->y + x * 8 + y * 8 * iEdgedWidth;  
   
         int32_t iDiamondSize = 1;  
   
         int32_t min_dx;  
         int32_t max_dx;  
         int32_t min_dy;  
         int32_t max_dy;  
   
         VECTOR newMV;  
         VECTOR backupMV;  
2395    
2396          VECTOR pmv[4];  /*      fprintf(stderr,"sol = (%8.5f, %8.5f, %8.5f, %8.5f)\n",sol[0],sol[1],sol[2],sol[3]);
2397          int32_t psad[8];          fprintf(stderr,"meanx = %8.5f  meany = %8.5f   %d\n",meanx,meany, oldnum);
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          const int32_t iSubBlock = ((y & 1) << 1) + (x & 1);                          if (!MBmask[mbnum])
2408                                    continue;
2409    
2410  //  const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;                          if  ( ( ABS(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - mv.x ) > meanx )
2411          const MACROBLOCK *const prevMB = prevMBs + (x >> 1) + (y >> 1) * iWcount;                             || ( 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          int32_t bPredEq;          } while ( (oldnum != num) && (num>=4) );
         int32_t iMinSAD, iSAD = 9999;  
2418    
2419          MainSearch8FuncPtr MainSearchPtr;          if (num < 4)
2420            {
2421                    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 {
2423    
2424  /* Get maximum range */                  gmc.duv[0].x=(int)(sol[0]+0.5);
2425          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,                  gmc.duv[0].y=(int)(sol[3]+0.5);
                           iFcode);  
2426    
2427  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */                  gmc.duv[1].x=(int)(sol[1]*pParam->width+0.5);
2428                    gmc.duv[1].y=(int)(-sol[2]*pParam->width+0.5);
2429    
2430          if (!(MotionFlags & PMV_HALFPEL8)) {                  gmc.duv[2].x=0;
2431                  min_dx = EVEN(min_dx);                  gmc.duv[2].y=0;
                 max_dx = EVEN(max_dx);  
                 min_dy = EVEN(min_dy);  
                 max_dy = EVEN(max_dy);  
2432          }          }
2433          /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */  //      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);
         //bPredEq = get_pmvdata(pMBs, x >> 1, y >> 1, iWcount, iSubBlock, pmv, psad);  
         bPredEq = get_pmvdata2(pMBs, iWcount, 0, x >> 1, y >> 1, iSubBlock, 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.  
 */  
2434    
2435  // Prepare for main loop          free(MBmask);
2436    
2437            return gmc;
         if (!(MotionFlags & PMV_HALFPEL8)) {  
                 currMV->x = EVEN(currMV->x);  
                 currMV->y = EVEN(currMV->y);  
2438          }          }
2439    
2440          if (currMV->x > max_dx)  // functions which perform BITS-based search/bitcount
                 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;  
2441    
2442  /***************** This is predictor SET A: only median prediction ******************/  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            CheckCandidate = CheckCandidateBits16;
2452    
2453          iMinSAD =          if (Data->qpel) {
2454                  sad8(cur,                  for(i = 0; i < 5; i++) {
2455                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,                          Data->currentMV[i].x = Data->currentQMV[i].x/2;
2456                                                  iEdgedWidth), iEdgedWidth);                          Data->currentMV[i].y = Data->currentQMV[i].y/2;
2457          iMinSAD +=                  }
2458                  calc_delta_8(currMV->x - pmv[0].x, currMV->y - pmv[0].y,                  Data->qpel_precision = 1;
2459                                           (uint8_t) iFcode, iQuant);                  CheckCandidateBits16(Data->currentQMV[0].x, Data->currentQMV[0].y, 255, &iDirection, Data);
2460    
2461                    //checking if this vector is perfect. if it is, we stop.
2462                    if (Data->temp[0] == 0 && Data->temp[1] == 0 && Data->temp[2] == 0 && Data->temp[3] == 0)
2463                            return 0; //quick stop
2464    
2465  // thresh1 is fixed to 256                  if (MotionFlags & (XVID_ME_HALFPELREFINE16_BITS | XVID_ME_EXTSEARCH_BITS)) { //we have to prepare for halfpixel-precision search
2466          if (iMinSAD < 256 / 4) {                          for(i = 0; i < 5; i++) bsad[i] = Data->iMinSAD[i];
2467                  if (MotionFlags & PMV_QUICKSTOP8)                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2468                          goto EPZS8_Terminate_without_Refine;                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
2469                  if (MotionFlags & PMV_EARLYSTOP8)                          Data->qpel_precision = 0;
2470                          goto EPZS8_Terminate_with_Refine;                          if (Data->currentQMV->x & 1 || Data->currentQMV->y & 1)
2471                                    CheckCandidateBits16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);
2472          }          }
2473    
2474  /************** This is predictor SET B: (0,0), prev.frame MV, neighbours **************/          } else { // not qpel
2475    
2476                    CheckCandidateBits16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);
2477                    //checking if this vector is perfect. if it is, we stop.
2478                    if (Data->temp[0] == 0 && Data->temp[1] == 0 && Data->temp[2] == 0 && Data->temp[3] == 0) {
2479                            return 0; //inter
2480                    }
2481            }
2482    
2483  // MV=(0,0) is often a good choice          if (MotionFlags&XVID_ME_EXTSEARCH_BITS) SquareSearch(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
         CHECK_MV8_ZERO;  
2484    
2485  // previous frame MV          if (MotionFlags&XVID_ME_HALFPELREFINE16_BITS) SubpelRefine(Data);
         CHECK_MV8_CANDIDATE(prevMB->mvs[iSubBlock].x, prevMB->mvs[iSubBlock].y);  
2486    
2487  // left neighbour, if allowed          if (Data->qpel) {
2488          if (psad[1] != MV_MAX_ERROR) {                  if (MotionFlags&(XVID_ME_EXTSEARCH_BITS | XVID_ME_HALFPELREFINE16_BITS)) { // there was halfpel-precision search
2489                  if (!(MotionFlags & PMV_HALFPEL8)) {                          for(i = 0; i < 5; i++) if (bsad[i] > Data->iMinSAD[i]) {
2490                          pmv[1].x = EVEN(pmv[1].x);                                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // we have found a better match
2491                          pmv[1].y = EVEN(pmv[1].y);                                  Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
2492                  }                  }
2493                  CHECK_MV8_CANDIDATE(pmv[1].x, pmv[1].y);  
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  // top neighbour, if allowed                  if (MotionFlags&XVID_ME_QUARTERPELREFINE16_BITS) SubpelRefine(Data);
         if (psad[2] != MV_MAX_ERROR) {  
                 if (!(MotionFlags & PMV_HALFPEL8)) {  
                         pmv[2].x = EVEN(pmv[2].x);  
                         pmv[2].y = EVEN(pmv[2].y);  
2500                  }                  }
                 CHECK_MV8_CANDIDATE(pmv[2].x, pmv[2].y);  
2501    
2502  // top right neighbour, if allowed          if (MotionFlags&XVID_ME_CHECKPREDICTION_BITS) { //let's check vector equal to prediction
2503                  if (psad[3] != MV_MAX_ERROR) {                  VECTOR * v = Data->qpel ? Data->currentQMV : Data->currentMV;
2504                          if (!(MotionFlags & PMV_HALFPEL8)) {                  if (!(Data->predMV.x == v->x && Data->predMV.y == v->y))
2505                                  pmv[3].x = EVEN(pmv[3].x);                          CheckCandidateBits16(Data->predMV.x, Data->predMV.y, 255, &iDirection, Data);
                                 pmv[3].y = EVEN(pmv[3].y);  
                         }  
                         CHECK_MV8_CANDIDATE(pmv[3].x, pmv[3].y);  
2506                  }                  }
2507            return Data->iMinSAD[0];
2508          }          }
2509    
 /*  // this bias is zero anyway, at the moment!  
2510    
2511          if ( (MVzero(*currMV)) && (!MVzero(pmv[0])) ) // && (iMinSAD <= iQuant * 96)  static int
2512                  iMinSAD -= MV8_00_BIAS;  CountMBBitsInter4v(const SearchData * const Data,
2513                                            MACROBLOCK * const pMB, const MACROBLOCK * const pMBs,
2514  */                                          const int x, const int y,
2515                                            const MBParam * const pParam, const uint32_t MotionFlags,
2516  /* Terminate if MinSAD <= T_2                                          const VECTOR * const backup)
2517     Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]  {
 */  
2518    
2519          if (iMinSAD < 512 / 4) {        /* T_2 == 512/4 hardcoded */          int cbp = 0, bits = 0, t = 0, i, iDirection;
2520                  if (MotionFlags & PMV_QUICKSTOP8)          SearchData Data2, *Data8 = &Data2;
2521                          goto EPZS8_Terminate_without_Refine;          int sumx = 0, sumy = 0;
2522                  if (MotionFlags & PMV_EARLYSTOP8)          int16_t in[64], coeff[64];
2523                          goto EPZS8_Terminate_with_Refine;  
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  /************ (Diamond Search)  **************/                  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          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                  *Data8->iMinSAD += t;
2551    
2552          if (!(MotionFlags & PMV_HALFPELDIAMOND8))                  Data8->qpel_precision = Data8->qpel;
2553                  iDiamondSize *= 2;                  // 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  /* default: use best prediction as starting point for one call of EPZS_MainSearch */                  if (Data8->qpel) {
2563                            if (MotionFlags&XVID_ME_HALFPELREFINE8_BITS || (MotionFlags&XVID_ME_EXTSEARCH8 && MotionFlags&XVID_ME_EXTSEARCH_BITS)) { // halfpixel motion search follows
2564                                    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  // there is no EPZS^2 for inter4v at the moment                                  if (Data8->currentQMV->x & 1 || Data8->currentQMV->y & 1)
2572                                            CheckCandidateBits8(Data8->currentMV->x, Data8->currentMV->y, 255, &iDirection, Data8);
2573    
2574  //  if (MotionFlags & PMV_USESQUARES8)                                  if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_BITS)
2575  //      MainSearchPtr = Square8_MainSearch;                                          SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255);
 //  else  
2576    
2577          if (MotionFlags & PMV_ADVANCEDDIAMOND8)                                  if (MotionFlags & XVID_ME_HALFPELREFINE8_BITS) SubpelRefine(Data8);
                 MainSearchPtr = AdvDiamond8_MainSearch;  
         else  
                 MainSearchPtr = Diamond8_MainSearch;  
2578    
2579          iSAD =                                  if(s > *Data8->iMinSAD) { //we have found a better match
2580                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,                                          Data8->currentQMV->x = 2*Data8->currentMV->x;
2581                                                    currMV->y, iMinSAD, &newMV, pmv, min_dx, max_dx,                                          Data8->currentQMV->y = 2*Data8->currentMV->y;
2582                                                    min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,                                  }
                                                   iQuant, 0);  
2583    
2584                                    Data8->qpel_precision = 1;
2585                                    get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 8,
2586                                                            pParam->width, pParam->height, Data8->iFcode, 1, 0);
2587    
         if (iSAD < iMinSAD) {  
                 *currMV = newMV;  
                 iMinSAD = iSAD;  
2588          }          }
2589                            if (MotionFlags & XVID_ME_QUARTERPELREFINE8_BITS) SubpelRefine(Data8);
2590    
2591          if (MotionFlags & PMV_EXTSEARCH8) {                  } else // not qpel
2592  /* extended mode: search (up to) two more times: orignal prediction and (0,0) */                          if (MotionFlags & XVID_ME_HALFPELREFINE8_BITS) SubpelRefine(Data8); //halfpel mode, halfpel refinement
   
                 if (!(MVequal(pmv[0], backupMV))) {  
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  
                                                                   pmv[0].x, pmv[0].y, iMinSAD, &newMV, pmv,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, 0);  
2593    
2594                          if (iSAD < iMinSAD) {                  //checking vector equal to predicion
2595                                  *currMV = newMV;                  if (i != 0 && MotionFlags & XVID_ME_CHECKPREDICTION_BITS) {
2596                                  iMinSAD = iSAD;                          const VECTOR * v = Data->qpel ? Data8->currentQMV : Data8->currentMV;
2597                          }                          if (!(Data8->predMV.x == v->x && Data8->predMV.y == v->y))
2598                                    CheckCandidateBits8(Data8->predMV.x, Data8->predMV.y, 255, &iDirection, Data8);
2599                  }                  }
2600    
2601                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                  bits += *Data8->iMinSAD;
2602                          iSAD =                  if (bits >= Data->iMinSAD[0]) break; // no chances for INTER4V
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, pmv, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                                   iQuant, 0);  
2603    
2604                          if (iSAD < iMinSAD) {                  // MB structures for INTER4V mode; we have to set them here, we don't have predictor anywhere else
2605                                  *currMV = newMV;                  if(Data->qpel) {
2606                                  iMinSAD = iSAD;                          pMB->pmvs[i].x = Data8->currentQMV->x - Data8->predMV.x;
2607                          }                          pMB->pmvs[i].y = Data8->currentQMV->y - Data8->predMV.y;
2608                            pMB->qmvs[i] = *Data8->currentQMV;
2609                            sumx += Data8->currentQMV->x/2;
2610                            sumy += Data8->currentQMV->y/2;
2611                    } else {
2612                            pMB->pmvs[i].x = Data8->currentMV->x - Data8->predMV.x;
2613                            pMB->pmvs[i].y = Data8->currentMV->y - Data8->predMV.y;
2614                            sumx += Data8->currentMV->x;
2615                            sumy += Data8->currentMV->y;
2616                  }                  }
2617                    pMB->mvs[i] = *Data8->currentMV;
2618                    pMB->sad8[i] = 4 * *Data8->iMinSAD;
2619                    if (Data8->temp[0]) cbp |= 1 << (5 - i);
2620          }          }
2621    
2622  /***************        Choose best MV found     **************/          if (bits < *Data->iMinSAD) { // there is still a chance for inter4v mode. let's check chroma
2623                    const uint8_t * ptr;
2624    EPZS8_Terminate_with_Refine:                  sumx = (sumx >> 3) + roundtab_76[sumx & 0xf];
2625          if (MotionFlags & PMV_HALFPELREFINE8)   // perform final half-pel step                  sumy = (sumy >> 3) + roundtab_76[sumy & 0xf];
                 iMinSAD =  
                         Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                         iMinSAD, pmv, min_dx, max_dx, min_dy, max_dy,  
                                                         iFcode, iQuant, iEdgedWidth);  
2626    
2627    EPZS8_Terminate_without_Refine:                  //chroma U
2628                    ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefCU, 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
2629          currPMV->x = currMV->x - pmv[0].x;                  transfer_8to16subro(in, Data->CurU, ptr, Data->iEdgedWidth/2);
2630          currPMV->y = currMV->y - pmv[0].y;                  fdct(in);
2631          return iMinSAD;                  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  }  }
2637    
2638                    if (bits < *Data->iMinSAD) { // still possible
2639                            //chroma V
2640                            ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefCV, 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
2641                            transfer_8to16subro(in, Data->CurV, ptr, Data->iEdgedWidth/2);
2642                            fdct(in);
2643                            if (Data->lambda8 == 0) i = quant_inter(coeff, in, Data->lambda16);
2644                            else i = quant4_inter(coeff, in, Data->lambda16);
2645                            if (i > 0) {
2646                                    bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
2647                                    cbp |= 1 << (5 - 5);
2648                            }
2649                            bits += cbpy_tab[15-(cbp>>2)].len;
2650                            bits += mcbpc_inter_tab[(MODE_INTER4V & 7) | ((cbp & 3) << 3)].len;
2651                    }
2652            }
2653    
2654            return bits;
2655    }
2656    
2657    
2658    static int
2659  /* ***********************************************************  CountMBBitsIntra(const SearchData * const Data)
         bvop motion estimation  
 // TODO: need to incorporate prediction here (eg. sad += calc_delta_16)  
 ***************************************************************/  
   
   
 void  
 MotionEstimationBVOP(MBParam * const pParam,  
                                          FRAMEINFO * const frame,  
                                          // forward (past) reference  
                                          const MACROBLOCK * const f_mbs,  
                                          const IMAGE * const f_ref,  
                                          const IMAGE * const f_refH,  
                                          const IMAGE * const f_refV,  
                                          const IMAGE * const f_refHV,  
                                          // backward (future) reference  
                                          const MACROBLOCK * const b_mbs,  
                                          const IMAGE * const b_ref,  
                                          const IMAGE * const b_refH,  
                                          const IMAGE * const b_refV,  
                                          const IMAGE * const b_refHV)  
2660  {  {
2661          const uint32_t mb_width = pParam->mb_width;          int bits = 1; //this one is ac/dc prediction flag. always 1.
2662          const uint32_t mb_height = pParam->mb_height;          int cbp = 0, i, t, dc = 0, b_dc = 1024;
2663          const int32_t edged_width = pParam->edged_width;          const uint32_t iQuant = Data->lambda16;
2664            int16_t in[64], coeff[64];
2665    
2666          uint32_t i, j;          for(i = 0; i < 4; i++) {
2667                    uint32_t iDcScaler = get_dc_scaler(iQuant, 1);
2668    
2669          int32_t f_sad16;                  int s = 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2670          int32_t b_sad16;                  transfer_8to16copy(in, Data->Cur + s, Data->iEdgedWidth);
2671          int32_t i_sad16;                  fdct(in);
2672          int32_t d_sad16;                  b_dc = dc;
2673          int32_t best_sad;                  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          VECTOR pmv_dontcare;                  b_dc = dc;
2679                    dc = coeff[0];
2680                    if (i != 0) coeff[0] -= b_dc;
2681    
2682          // note: i==horizontal, j==vertical                  bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcy_tab[coeff[0] + 255].len;;
2683          for (j = 0; j < mb_height; j++) {                  Data->temp[i] = t;
2684                  for (i = 0; i < mb_width; i++) {                  if (t != 0)  cbp |= 1 << (5 - i);
2685                          MACROBLOCK *mb = &frame->mbs[i + j * mb_width];                  if (bits >= Data->iMinSAD[0]) break;
                         const MACROBLOCK *f_mb = &f_mbs[i + j * mb_width];  
                         const MACROBLOCK *b_mb = &b_mbs[i + j * mb_width];  
   
                         if (b_mb->mode == MODE_INTER && b_mb->cbp == 0 &&  
                                 b_mb->mvs[0].x == 0 && b_mb->mvs[0].y == 0) {  
                                 mb->mode = MODE_NOT_CODED;  
                                 mb->mvs[0].x = 0;  
                                 mb->mvs[0].y = 0;  
                                 mb->b_mvs[0].x = 0;  
                                 mb->b_mvs[0].y = 0;  
                                 continue;  
2686                          }                          }
                 /* force F_SAD16  
                         f_sad16 = 100;  
                         b_sad16 = 65535;  
   
                         mb->mode = MODE_FORWARD;  
                         mb->mvs[0].x = 1;  
                         mb->mvs[0].y = 1;  
                         mb->b_mvs[0].x = 1;  
                         mb->b_mvs[0].y = 1;  
                         continue;  
                  ^^ force F_SAD16 */  
   
2687    
2688                          // forward search          if (bits < Data->iMinSAD[0]) { // INTRA still looks good, let's add chroma
2689                          f_sad16 =                  uint32_t iDcScaler = get_dc_scaler(iQuant, 0);
2690                                  SEARCH16(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,                  //chroma U
2691                                                   &frame->image, i, j, frame->motion_flags,                  transfer_8to16copy(in, Data->CurU, Data->iEdgedWidth/2);
2692                                                   frame->quant, frame->fcode, pParam,                  fdct(in);
2693                                                   f_mbs,  f_mbs, /* todo */                  in[0] -= 1024;
2694                                                   &mb->mvs[0], &pmv_dontcare);   // ignore pmv                  if (Data->lambda8 == 0) quant_intra(coeff, in, iQuant, iDcScaler);
2695                    else quant4_intra(coeff, in, iQuant, iDcScaler);
2696    
2697                          // backward search                  bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len;
2698                          b_sad16 = SEARCH16(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,                  if (t != 0) cbp |= 1 << (5 - 4);
2699                                                  &frame->image, i, j, frame->motion_flags,                  Data->temp[4] = t;
                                                 frame->quant, frame->bcode, pParam,  
                                                 b_mbs, b_mbs,   /* todo */  
                                                 &mb->b_mvs[0], &pmv_dontcare);  // ignore pmv  
   
                         // interpolate search (simple, but effective)  
                         i_sad16 = 65535;  
   
                         /*  
                         x/y range somewhat buggy  
                         i_sad16 =  
                                 sad16bi_c(frame->image.y + i * 16 + j * 16 * edged_width,  
                                                   get_ref(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                                   i, j, 16, mb->mvs[0].x, mb->mvs[0].y,  
                                                                   edged_width), get_ref(b_ref->y, b_refH->y,  
                                                                                                                 b_refV->y, b_refHV->y,  
                                                                                                                 i, j, 16,  
                                                                                                                 mb->b_mvs[0].x,  
                                                                                                                 mb->b_mvs[0].x,  
                                                                                                                 edged_width),  
                                                   edged_width);  
                         */  
2700    
2701                          // TODO: direct search                  if (bits < Data->iMinSAD[0]) {
2702                          // predictor + range of [-32,32]                          //chroma V
2703                          d_sad16 = 65535;                          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                            bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len;
2710                            if (t != 0) cbp |= 1 << (5 - 5);
2711    
2712                          if (f_sad16 < b_sad16) {                          Data->temp[5] = t;
                                 best_sad = f_sad16;  
                                 mb->mode = MODE_FORWARD;  
                         } else {  
                                 best_sad = b_sad16;  
                                 mb->mode = MODE_BACKWARD;  
                         }  
2713    
2714                          if (i_sad16 < best_sad) {                          bits += t = cbpy_tab[cbp>>2].len;
2715                                  best_sad = i_sad16;                          Data->temp[6] = t;
                                 mb->mode = MODE_INTERPOLATE;  
                         }  
2716    
2717                          if (d_sad16 < best_sad) {                          bits += t = mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp & 3) << 3)].len;
2718                                  best_sad = d_sad16;                          Data->temp[7] = t;
                                 mb->mode = MODE_DIRECT;  
                         }  
2719    
2720                  }                  }
2721          }          }
2722    
2723            return bits;
2724  }  }

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

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