[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 252, Sun Jun 30 10:46:29 2002 UTC branches/dev-api-4/xvidcore/src/motion/motion_est.c revision 890, Sat Feb 22 08:49:45 2003 UTC
# Line 1  Line 1 
1  /**************************************************************************  /**************************************************************************
2   *   *
3   *  Modifications:   *      XVID MPEG-4 VIDEO CODEC
4     *      motion estimation
5   *   *
6   *      01.05.2002      updated MotionEstimationBVOP   *      This program is an implementation of a part of one or more MPEG-4
7   *      25.04.2002 partial prevMB conversion   *      Video tools as specified in ISO/IEC 14496-2 standard.  Those intending
8   *  22.04.2002 remove some compile warning by chenm001 <chenm001@163.com>   *      to use this software module in hardware or software products are
9   *  14.04.2002 added MotionEstimationBVOP()   *      advised that its use may infringe existing patents or copyrights, and
10   *  02.04.2002 add EPZS(^2) as ME algorithm, use PMV_USESQUARES to choose between   *      any such use would be at such party's own risk.  The original
11   *             EPZS and EPZS^2   *      developer of this software module and his/her company, and subsequent
12   *  08.02.2002 split up PMVfast into three routines: PMVFast, PMVFast_MainLoop   *      editors and their companies, will have no liability for use of this
13   *             PMVFast_Refine to support multiple searches with different start points   *      software or modifications or derivatives thereof.
  *  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.  
14   *   *
15   *  Michael Militzer <isibaar@videocoding.de>   *      This program is free software; you can redistribute it and/or modify
16     *      it under the terms of the GNU General Public License as published by
17     *      the Free Software Foundation; either version 2 of the License, or
18     *      (at your option) any later version.
19   *   *
20   **************************************************************************/   *      This program is distributed in the hope that it will be useful,
21     *      but WITHOUT ANY WARRANTY; without even the implied warranty of
22     *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23     *      GNU General Public License for more details.
24     *
25     *      You should have received a copy of the GNU General Public License
26     *      along with this program; if not, write to the Free Software
27     *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28     *
29     *************************************************************************/
30    
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  // very large value  /*****************************************************************************
50  #define MV_MAX_ERROR    (4096 * 256)   * 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  // stop search if sdelta < THRESHOLD  static __inline uint32_t
82  #define MV16_THRESHOLD  192  d_mv_bits(int x, int y, const VECTOR pred, const uint32_t iFcode, const int qpel, const int rrv)
83  #define MV8_THRESHOLD   56  {
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  #define NEIGH_MOVE_THRESH 0          switch (((bx & 1) << 1) | (by & 1))     {
143  // how much a block's MV must differ from his neighbour                  case 0:
144  // to be search for INTER4V. The more, the faster...                          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  /* sad16(0,0) bias; mpeg4 spec suggests nb/2+1 */          sad = sad8bi(data->CurU, b_refu, f_refu, stride);
166  /* nb  = vop pixels * 2^(bpp-8) */          sad += sad8bi(data->CurV, b_refv, f_refv, stride);
 #define MV16_00_BIAS    (128+1)  
 #define MV8_00_BIAS     (0)  
167    
168  /* INTER bias for INTER/INTRA decision; mpeg4 spec suggests 2*nb */          return sad;
169  #define MV16_INTER_BIAS 512  }
170    
 /* Parameters which control inter/inter4v decision */  
 #define IMV16X16                        5  
171    
172  /* vector map (vlc delta size) smoother parameters */  static int32_t
173  #define NEIGH_TEND_16X16        2  ChromaSAD(int dx, int dy, const SearchData * const data)
174  #define NEIGH_TEND_8X8          2  {
175            int sad;
176            const uint32_t stride = data->iEdgedWidth/2;
177    
178  // fast ((A)/2)*2          if (dx == data->temp[5] && dy == data->temp[6]) return data->temp[7]; //it has been checked recently
179  #define EVEN(A)         (((A)<0?(A)+1:(A)) & ~1)          data->temp[5] = dx; data->temp[6] = dy; // backup
180    
181  #define MVzero(A) ( ((A).x)==(0) && ((A).y)==(0) )          switch (((dx & 1) << 1) | (dy & 1))     {
182  #define MVequal(A,B) ( ((A).x)==((B).x) && ((A).y)==((B).y) )                  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  int32_t PMVfastSearch16(const uint8_t * const pRef,                          interpolate8x8_halfpel_hv(data->RefQ, data->RefCV + dy * stride + dx, stride, data->rounding);
203                                                  const uint8_t * const pRefH,                          sad += sad8(data->CurV, data->RefQ, stride);
204                                                  const uint8_t * const pRefV,                          break;
205                                                  const uint8_t * const pRefHV,          }
206                                                  const IMAGE * const pCur,          data->temp[7] = sad; //backup, part 2
207                                                  const int x,          return sad;
208                                                  const int 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);  
209    
210  int32_t EPZSSearch16(const uint8_t * const pRef,  static __inline const uint8_t *
211                                           const uint8_t * const pRefH,  GetReferenceB(const int x, const int y, const uint32_t dir, const SearchData * const data)
212                                           const uint8_t * const pRefV,  {
213                                           const uint8_t * const pRefHV,  //      dir : 0 = forward, 1 = backward
214                                           const IMAGE * const pCur,          switch ( (dir << 2) | ((x&1)<<1) | (y&1) ) {
215                                           const int x,                  case 0 : return data->Ref + x/2 + (y/2)*(data->iEdgedWidth);
216                                           const int y,                  case 1 : return data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
217                                           const uint32_t MotionFlags,                  case 2 : return data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);
218                                           const uint32_t iQuant,                  case 3 : return data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
219                                           const uint32_t iFcode,                  case 4 : return data->bRef + x/2 + (y/2)*(data->iEdgedWidth);
220                                           const MBParam * const pParam,                  case 5 : return data->bRefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
221                                           const MACROBLOCK * const pMBs,                  case 6 : return data->bRefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);
222                                           const MACROBLOCK * const prevMBs,                  default : return data->bRefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
223                                           VECTOR * const currMV,          }
224                                           VECTOR * const currPMV);  }
225    
226    // this is a simpler copy of GetReferenceB, but as it's __inline anyway, we can keep the two separate
227    static __inline const uint8_t *
228    GetReference(const int x, const int y, const SearchData * const data)
229    {
230            switch ( ((x&1)<<1) | (y&1) ) {
231                    case 0 : return data->Ref + x/2 + (y/2)*(data->iEdgedWidth);
232                    case 3 : return data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
233                    case 1 : return data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
234                    default : return data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);      //case 2
235            }
236    }
237    
238  int32_t PMVfastSearch8(const uint8_t * const pRef,  static uint8_t *
239                                             const uint8_t * const pRefH,  Interpolate8x8qpel(const int x, const int y, const uint32_t block, const uint32_t dir, const SearchData * const data)
240                                             const uint8_t * const pRefV,  {
241                                             const uint8_t * const pRefHV,  // create or find a qpel-precision reference picture; return pointer to it
242                                             const IMAGE * const pCur,          uint8_t * Reference = data->RefQ + 16*dir;
243                                             const int x,          const uint32_t iEdgedWidth = data->iEdgedWidth;
244                                             const int y,          const uint32_t rounding = data->rounding;
245                                             const int start_x,          const int halfpel_x = x/2;
246                                             const int start_y,          const int halfpel_y = y/2;
247                                             const uint32_t MotionFlags,          const uint8_t *ref1, *ref2, *ref3, *ref4;
                                            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);  
248    
249  int32_t EPZSSearch8(const uint8_t * const pRef,          ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
250                                          const uint8_t * const pRefH,          ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
251                                          const uint8_t * const pRefV,          switch( ((x&1)<<1) + (y&1) ) {
252                                          const uint8_t * const pRefHV,          case 0: // pure halfpel position
253                                          const IMAGE * const pCur,                  return (uint8_t *) ref1;
254                                          const int x,                  break;
                                         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);  
255    
256            case 1: // x halfpel, y qpel - top or bottom during qpel refinement
257                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
258                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
259                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
260                    break;
261    
262  typedef int32_t(MainSearch16Func) (const uint8_t * const pRef,          case 2: // x qpel, y halfpel - left or right during qpel refinement
263                                                                     const uint8_t * const pRefH,                  ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
264                                                                     const uint8_t * const pRefV,                  ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
265                                                                     const uint8_t * const pRefHV,                  interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
266                                                                     const uint8_t * const cur,                  break;
                                                                    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);  
267    
268  typedef MainSearch16Func *MainSearch16FuncPtr;          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    static uint8_t *
283    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  typedef int32_t(MainSearch8Func) (const uint8_t * const pRef,          ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
294                                                                    const uint8_t * const pRefH,          switch( ((x&1)<<1) + (y&1) ) {
295                                                                    const uint8_t * const pRefV,          case 3: // x and y in qpel resolution - the "corners" (top left/right and
296                                                                    const uint8_t * const pRefHV,                           // bottom left/right) during qpel refinement
297                                                                    const uint8_t * const cur,                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
298                                                                    const int x,                  ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
299                                                                    const int y,                  ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
300                                                                    int32_t startx,                  interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
301                                                                    int32_t starty,                  interpolate8x8_avg4(Reference+8, ref1+8, ref2+8, ref3+8, ref4+8, iEdgedWidth, rounding);
302                                                                    int32_t iMinSAD,                  interpolate8x8_avg4(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, ref3+8*iEdgedWidth, ref4+8*iEdgedWidth, iEdgedWidth, rounding);
303                                                                    VECTOR * const currMV,                  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                                                                    const VECTOR * const pmv,                  break;
                                                                   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);  
   
 typedef MainSearch8Func *MainSearch8FuncPtr;  
   
 static int32_t lambda_vec16[32] =       /* rounded values for lambda param for weight of motion bits as in modified H.26L */  
 { 0, (int) (1.00235 + 0.5), (int) (1.15582 + 0.5), (int) (1.31976 + 0.5),  
                 (int) (1.49591 + 0.5), (int) (1.68601 + 0.5),  
         (int) (1.89187 + 0.5), (int) (2.11542 + 0.5), (int) (2.35878 + 0.5),  
                 (int) (2.62429 + 0.5), (int) (2.91455 + 0.5),  
         (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 */  
305    
306            case 1: // x halfpel, y qpel - top or bottom during qpel refinement
307                    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  // mv.length table          case 0: // pure halfpel position
323  static const uint32_t mvtab[33] = {                  return (uint8_t *) ref1;
324          1, 2, 3, 4, 6, 7, 7, 7,          }
325          9, 9, 9, 10, 10, 10, 10, 10,          return Reference;
326          10, 10, 10, 10, 10, 10, 10, 10,  }
         10, 11, 11, 11, 11, 11, 11, 12, 12  
 };  
327    
328    /* CHECK_CANDIATE FUNCTIONS START */
329    
330  static __inline uint32_t  static void
331  mv_bits(int32_t component,  CheckCandidate16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
                 const uint32_t iFcode)  
332  {  {
333          if (component == 0)          int xc, yc;
334                  return 1;          const uint8_t * Reference;
335            VECTOR * current;
336            int32_t sad; uint32_t t;
337    
338          if (component < 0)          if ( (x > data->max_dx) || (x < data->min_dx)
339                  component = -component;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
340    
341          if (iFcode == 1) {          if (!data->qpel_precision) {
342                  if (component > 32)                  Reference = GetReference(x, y, data);
343                          component = 32;                  current = data->currentMV;
344                    xc = x; yc = y;
345                  return mvtab[component] + 1;          } 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          component += (1 << (iFcode - 1)) - 1;          sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
352          component >>= (iFcode - 1);          t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
353    
354            sad += (data->lambda16 * t * sad)>>10;
355            data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
356    
357          if (component > 32)          if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
358                  component = 32;                                                                                                          (yc >> 1) + roundtab_79[yc & 0x3], data);
359    
360          return mvtab[component] + 1 + iFcode - 1;          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    
 static __inline uint32_t  
 calc_delta_16(const int32_t dx,  
                           const int32_t dy,  
                           const uint32_t iFcode,  
                           const uint32_t iQuant)  
 {  
         return NEIGH_TEND_16X16 * lambda_vec16[iQuant] * (mv_bits(dx, iFcode) +  
                                                                                                           mv_bits(dy, iFcode));  
375  }  }
376    
377  static __inline uint32_t  static void
378  calc_delta_8(const int32_t dx,  CheckCandidate8(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)  
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    
402    static void
403    CheckCandidate32(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
404    {
405            uint32_t t;
406            const uint8_t * Reference;
407    
408            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            Reference = GetReference(x, y, data);
413            t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);
414    
415  #ifndef SEARCH16          data->temp[0] = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
 #define SEARCH16        PMVfastSearch16  
 //#define SEARCH16  FullSearch16  
 //#define SEARCH16  EPZSSearch16  
 #endif  
416    
417  #ifndef SEARCH8          data->temp[0] += (data->lambda16 * t * data->temp[0]) >> 10;
418  #define SEARCH8         PMVfastSearch8          data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
 //#define SEARCH8   EPZSSearch8  
 #endif  
419    
420  bool          if (data->temp[0] < data->iMinSAD[0]) {
421  MotionEstimation(MBParam * const pParam,                  data->iMinSAD[0] = data->temp[0];
422                                   FRAMEINFO * const current,                  data->currentMV[0].x = x; data->currentMV[0].y = y;
423                                   FRAMEINFO * const reference,                  *dir = Direction; }
424                                   const IMAGE * const pRefH,  
425                                   const IMAGE * const pRefV,          if (data->temp[1] < data->iMinSAD[1]) {
426                                   const IMAGE * const pRefHV,                  data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
427                                   const uint32_t iLimit)          if (data->temp[2] < data->iMinSAD[2]) {
428                    data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
429            if (data->temp[3] < data->iMinSAD[3]) {
430                    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    static void
436    CheckCandidate16no4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
437  {  {
438          const uint32_t iWcount = pParam->mb_width;          int32_t sad, xc, yc;
439          const uint32_t iHcount = pParam->mb_height;          const uint8_t * Reference;
440          MACROBLOCK *const pMBs = current->mbs;          uint32_t t;
441          MACROBLOCK *const prevMBs = reference->mbs;          VECTOR * current;
         const IMAGE *const pCurrent = &current->image;  
         const IMAGE *const pRef = &reference->image;  
442    
443          const VECTOR zeroMV = { 0, 0 };          if ( (x > data->max_dx) | ( x < data->min_dx)
444                    | (y > data->max_dy) | (y < data->min_dy) ) return;
445    
446          int32_t x, y;          if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; //non-zero even value
         int32_t iIntra = 0;  
         VECTOR pmv;  
   
         if (sadInit)  
                 (*sadInit) ();  
   
         for (y = 0; y < iHcount; y++)  
                 for (x = 0; x < iWcount; x++) {  
                         MACROBLOCK *const pMB = &pMBs[x + y * iWcount];  
   
                         pMB->sad16 =  
                                 SEARCH16(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,  
                                                  y, current->motion_flags, current->quant,  
                                                  current->fcode, pParam, pMBs, prevMBs, &pMB->mv16,  
                                                  &pMB->pmvs[0]);  
447    
448                          if (0 < (pMB->sad16 - MV16_INTER_BIAS)) {          if (data->qpel_precision) { // x and y are in 1/4 precision
449                                  int32_t deviation;                  Reference = Interpolate16x16qpel(x, y, 0, data);
450                    current = data->currentQMV;
451                    xc = x/2; yc = y/2;
452            } else {
453                    Reference = GetReference(x, y, data);
454                    current = data->currentMV;
455                    xc = x; yc = y;
456            }
457            t = d_mv_bits(x, y, data->predMV, data->iFcode,
458                                            data->qpel^data->qpel_precision, data->rrv);
459    
460                                  deviation =          sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);
461                                          dev16(pCurrent->y + x * 16 + y * 16 * pParam->edged_width,          sad += (data->lambda16 * t * sad)>>10;
                                                   pParam->edged_width);  
462    
463                                  if (deviation < (pMB->sad16 - MV16_INTER_BIAS)) {          if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
464                                          pMB->mode = MODE_INTRA;                                                                                  (yc >> 1) + roundtab_79[yc & 0x3], data);
                                         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;  
465    
466                                          iIntra++;          if (sad < *(data->iMinSAD)) {
467                                          if (iIntra >= iLimit)                  *(data->iMinSAD) = sad;
468                                                  return 1;                  current->x = x; current->y = y;
469                    *dir = Direction;
470            }
471    }
472    
473                                          continue;  static void
474    CheckCandidate32I(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
475    {
476    // maximum speed - for P/B/I decision
477            int32_t sad;
478    
479            if ( (x > data->max_dx) || (x < data->min_dx)
480                    || (y > data->max_dy) || (y < data->min_dy) ) return;
481    
482            sad = sad32v_c(data->Cur, data->Ref + x/2 + (y/2)*(data->iEdgedWidth),
483                                                            data->iEdgedWidth, data->temp+1);
484    
485            if (sad < *(data->iMinSAD)) {
486                    *(data->iMinSAD) = sad;
487                    data->currentMV[0].x = x; data->currentMV[0].y = y;
488                    *dir = Direction;
489                                  }                                  }
490            if (data->temp[1] < data->iMinSAD[1]) {
491                    data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
492            if (data->temp[2] < data->iMinSAD[2]) {
493                    data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
494            if (data->temp[3] < data->iMinSAD[3]) {
495                    data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
496            if (data->temp[4] < data->iMinSAD[4]) {
497                    data->iMinSAD[4] = data->temp[4]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
498    
499                          }                          }
500    
501                          pmv = pMB->pmvs[0];  static void
502                          if (current->global_flags & XVID_INTER4V)  CheckCandidateInt(const int xf, const int yf, const int Direction, int * const dir, const SearchData * const data)
503                                  if ((!(current->global_flags & XVID_LUMIMASKING) ||  {
504                                           pMB->dquant == NO_CHANGE)) {          int32_t sad, xb, yb, xcf, ycf, xcb, ycb;
505                                          int32_t sad8 = IMV16X16 * current->quant;          uint32_t t;
506            const uint8_t *ReferenceF, *ReferenceB;
507                                          if (sad8 < pMB->sad16)          VECTOR *current;
   
                                                 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]);  
508    
509                                          /* decide: MODE_INTER or MODE_INTER4V          if ( (xf > data->max_dx) | (xf < data->min_dx)
510                                             mpeg4:   if (sad8 < pMB->sad16 - nb/2+1) use_inter4v                  | (yf > data->max_dy) | (yf < data->min_dy) ) return;
                                          */  
511    
512                                          if (sad8 < pMB->sad16) {          if (!data->qpel_precision) {
513                                                  pMB->mode = MODE_INTER4V;                  ReferenceF = GetReference(xf, yf, data);
514                                                  pMB->sad8[0] *= 4;                  xb = data->currentMV[1].x; yb = data->currentMV[1].y;
515                                                  pMB->sad8[1] *= 4;                  ReferenceB = GetReferenceB(xb, yb, 1, data);
516                                                  pMB->sad8[2] *= 4;                  current = data->currentMV;
517                                                  pMB->sad8[3] *= 4;                  xcf = xf; ycf = yf;
518                                                  continue;                  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    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                          pMB->mode = MODE_INTER;                  ReferenceF = Interpolate8x8qpel(mvs.x, mvs.y, k, 0, data);
584                          pMB->pmvs[0] = pmv;     /* pMB->pmvs[1] = pMB->pmvs[2] = pMB->pmvs[3]  are not needed for INTER */                  ReferenceB = Interpolate8x8qpel(b_mvs.x, b_mvs.y, k, 1, data);
                         pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mv16;  
                         pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] =  
                                 pMB->sad16;  
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            sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
592    
593            if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
594                                                                                    (ycf >> 3) + roundtab_76[ycf & 0xf],
595                                                                                    (xcb >> 3) + roundtab_76[xcb & 0xf],
596                                                                                    (ycb >> 3) + roundtab_76[ycb & 0xf], data);
597    
598            if (sad < *(data->iMinSAD)) {
599                    *(data->iMinSAD) = sad;
600                    data->currentMV->x = x; data->currentMV->y = y;
601                    *dir = Direction;
602                  }                  }
         return 0;  
603  }  }
604    
605  #define CHECK_MV16_ZERO {\  static void
606    if ( (0 <= max_dx) && (0 >= min_dx) \  CheckCandidateDirectno4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const 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)  
607  {  {
608          const int32_t iEdgedWidth = pParam->edged_width;          int32_t sad, xcf, ycf, xcb, ycb;
609          const uint8_t * cur = pCur->y + x*16 + y*16*iEdgedWidth;          const uint8_t *ReferenceF;
610          int32_t iSAD;          const uint8_t *ReferenceB;
611          int32_t pred_x,pred_y;          VECTOR mvs, b_mvs;
   
         get_pmv(pMBs, x, y, pParam->mb_width, 0, &pred_x, &pred_y);  
   
         iSAD = sad16( cur,  
                 get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0,0, iEdgedWidth),  
                 iEdgedWidth, MV_MAX_ERROR);  
         if (iSAD <= iQuant * 96)  
                 iSAD -= MV16_00_BIAS;  
   
         currMV->x = 0;  
         currMV->y = 0;  
         currPMV->x = -pred_x;  
         currPMV->y = -pred_y;  
612    
613          return iSAD;          if (( x > 31) | ( x < -32) | ( y > 31) | (y < -32)) return;
614    
615  }          mvs.x = data->directmvF[0].x + x;
616  */          b_mvs.x = ((x == 0) ?
617                    data->directmvB[0].x
618                    : mvs.x - data->referencemv[0].x);
619    
620  int32_t          mvs.y = data->directmvF[0].y + y;
621  Diamond16_MainSearch(const uint8_t * const pRef,          b_mvs.y = ((y == 0) ?
622                                           const uint8_t * const pRefH,                  data->directmvB[0].y
623                                           const uint8_t * const pRefV,                  : mvs.y - data->referencemv[0].y);
624                                           const uint8_t * const pRefHV,  
625                                           const uint8_t * const cur,          if ( (mvs.x > data->max_dx) | (mvs.x < data->min_dx)
626                                           const int x,                  | (mvs.y > data->max_dy) | (mvs.y < data->min_dy)
627                                           const int y,                  | (b_mvs.x > data->max_dx) | (b_mvs.x < data->min_dx)
628                                           int32_t startx,                  | (b_mvs.y > data->max_dy) | (b_mvs.y < data->min_dy) ) return;
629                                           int32_t starty,  
630                                           int32_t iMinSAD,          if (data->qpel) {
631                                           VECTOR * const currMV,                  xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2);
632                                           const VECTOR * const pmv,                  xcb = 4*(b_mvs.x/2); ycb = 4*(b_mvs.y/2);
633                                           const int32_t min_dx,                  ReferenceF = Interpolate16x16qpel(mvs.x, mvs.y, 0, data);
634                                           const int32_t max_dx,                  ReferenceB = Interpolate16x16qpel(b_mvs.x, b_mvs.y, 1, data);
                                          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_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                    ReferenceB = GetReferenceB(b_mvs.x, b_mvs.y, 1, data);
640            }
641    
642            sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
643            sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
644    
645            if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
646                                                                                    (ycf >> 3) + roundtab_76[ycf & 0xf],
647                                                                                    (xcb >> 3) + roundtab_76[xcb & 0xf],
648                                                                                    (ycb >> 3) + roundtab_76[ycb & 0xf], data);
649    
650            if (sad < *(data->iMinSAD)) {
651                    *(data->iMinSAD) = sad;
652                    data->currentMV->x = x; data->currentMV->y = y;
653                    *dir = Direction;
654          }          }
         return iMinSAD;  
655  }  }
656    
 int32_t  
 Square16_MainSearch(const uint8_t * const pRef,  
                                         const uint8_t * const pRefH,  
                                         const uint8_t * const pRefV,  
                                         const uint8_t * const pRefHV,  
                                         const uint8_t * const cur,  
                                         const int x,  
                                         const int y,  
                                         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  
 */  
657    
658          CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  static void
659          CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  CheckCandidateBits16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
660          CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  {
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
   
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                          backupMV.y - iDiamondSize, 5);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
                                                          backupMV.y + iDiamondSize, 6);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                          backupMV.y - iDiamondSize, 7);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,  
                                                          backupMV.y + iDiamondSize, 8);  
   
   
         if (iDirection)  
                 while (!iFound) {  
                         iFound = 1;  
                         backupMV = *currMV;  
661    
662                          switch (iDirection) {          static int16_t in[64], coeff[64];
663                          case 1:          int32_t bits = 0, sum;
664                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,          VECTOR * current;
665                                                                                     backupMV.y, 1);          const uint8_t * ptr;
666                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,          int i, cbp = 0, t, xc, yc;
                                                                                  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;  
667    
668                          case 3:          if ( (x > data->max_dx) || (x < data->min_dx)
669                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,                  || (y > data->max_dy) || (y < data->min_dy) ) return;
                                                                                  4);  
                                 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 4:          if (!data->qpel_precision) {
672                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,                  ptr = GetReference(x, y, data);
673                                                                                   3);                  current = data->currentMV;
674                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,                  xc = x; yc = y;
675                                                                                   backupMV.y - iDiamondSize, 5);          } 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                                  break;                  xc = x/2; yc = y/2;
679            }
                         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);  
680    
681                                  break;          for(i = 0; i < 4; i++) {
682                    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    
693                          case 7:          bits += t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                    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;  
694    
695                          case 8:          if (bits < data->iMinSAD[0]) { // there is still a chance, adding chroma
696                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,                  xc = (xc >> 1) + roundtab_79[xc & 0x3];
697                                                                                   2);                  yc = (yc >> 1) + roundtab_79[yc & 0x3];
698                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,  
699                                                                                   4);                  //chroma U
700                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,                  ptr = interpolate8x8_switch2(data->RefQ + 64, data->RefCU, 0, 0, xc, yc,  data->iEdgedWidth/2, data->rounding);
701                                                                                   backupMV.y + iDiamondSize, 6);                  transfer_8to16subro(in, ptr, data->CurU, data->iEdgedWidth/2);
702                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,                  fdct(in);
703                                                                                   backupMV.y - iDiamondSize, 7);                  if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
704                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize,                  else sum = quant4_inter(coeff, in, data->lambda16);
705                                                                                   backupMV.y + iDiamondSize, 8);                  if (sum > 0) {
706                                  break;                          cbp |= 1 << (5 - 4);
707                          default:                          bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
708                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y,                  }
709                                                                                   1);  
710                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y,                  if (bits < data->iMinSAD[0]) {
711                                                                                   2);                          //chroma V
712                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize,                          ptr = interpolate8x8_switch2(data->RefQ + 64, data->RefCV, 0, 0, xc, yc,  data->iEdgedWidth/2, data->rounding);
713                                                                                   3);                          transfer_8to16subro(in, ptr, data->CurV, data->iEdgedWidth/2);
714                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize,                          fdct(in);
715                                                                                   4);                          if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
716                            else sum = quant4_inter(coeff, in, data->lambda16);
717                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,                          if (sum > 0) {
718                                                                                   backupMV.y - iDiamondSize, 5);                                  cbp |= 1 << (5 - 5);
719                                  CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,                                  bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
                                                                                  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;  
720                          }                          }
         } else {  
                 currMV->x = startx;  
                 currMV->y = starty;  
721          }          }
         return iMinSAD;  
722  }  }
723    
724            bits += cbpy_tab[15-(cbp>>2)].len;
725            bits += mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len;
726    
727  int32_t          if (bits < data->iMinSAD[0]) {
728  Full16_MainSearch(const uint8_t * const pRef,                  data->iMinSAD[0] = bits;
729                                    const uint8_t * const pRefH,                  current[0].x = x; current[0].y = y;
730                                    const uint8_t * const pRefV,                  *dir = Direction;
                                   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);  
   
         return iMinSAD;  
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                  }                  }
                 while (1);                              //forever  
869          }          }
         return iMinSAD;  
870  }  }
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          int32_t iSAD;          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    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 & 2)                  if (bDirection & 8) CHECK_CANDIDATE(x, y + iDiamondSize, 8);
                                 CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize, starty, 2);  
   
                         if (bDirection & 4)  
                                 CHECK_MV8_CANDIDATE_DIR(startx, starty - iDiamondSize, 4);  
   
                         if (bDirection & 8)  
                                 CHECK_MV8_CANDIDATE_DIR(startx, starty + iDiamondSize, 8);  
907    
908                          /* now we're doing diagonal checks near our candidate */                          /* now we're doing diagonal checks near our candidate */
909    
910                          if (iDirection)         //checking if anything found                  if (iDirection) {               //checking if anything found
                         {  
911                                  bDirection = iDirection;                                  bDirection = iDirection;
912                                  iDirection = 0;                                  iDirection = 0;
913                                  startx = currMV->x;                          x = data->currentMV->x; y = data->currentMV->y;
914                                  starty = currMV->y;                          if (bDirection & 3) {   //our candidate is left or right
915                                  if (bDirection & 3)     //our candidate is left or right                                  CHECK_CANDIDATE(x, y + iDiamondSize, 8);
916                                  {                                  CHECK_CANDIDATE(x, y - iDiamondSize, 4);
917                                          CHECK_MV8_CANDIDATE_DIR(startx, starty + iDiamondSize, 8);                          } else {                        // what remains here is up or down
918                                          CHECK_MV8_CANDIDATE_DIR(startx, starty - iDiamondSize, 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y, 2);
919                                  } else                  // what remains here is up or down                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);
                                 {  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize, starty, 2);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize, starty, 1);  
920                                  }                                  }
   
                                 if (iDirection) {  
921                                          bDirection += iDirection;                                          bDirection += iDirection;
922                                          startx = currMV->x;                          x = data->currentMV->x; y = data->currentMV->y;
                                         starty = currMV->y;  
923                                  }                                  }
                         } else                          //about to quit, eh? not so fast....  
                         {  
                                 switch (bDirection) {  
                                 case 2:  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 1:  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty + iDiamondSize, 1 + 8);  
                                         break;  
                                 case 2 + 4:  
                                         CHECK_MV8_CANDIDATE_DIR(startx - iDiamondSize,  
                                                                                         starty - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         starty - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(startx + iDiamondSize,  
                                                                                         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;  
924                                  }                                  }
925                                  if (!(iDirection))          while (iDirection);
                                         break;          //ok, the end. really  
                                 else {  
                                         bDirection = iDirection;  
                                         startx = currMV->x;  
                                         starty = currMV->y;  
926                                  }                                  }
927    
928    /* MAINSEARCH FUNCTIONS END */
929    
930    static void
931    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            CHECK_CANDIDATE(centerMV.x, centerMV.y - 1, 0);
938            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    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    
952    {
953            if(!rrv) {
954                    uint32_t sadC = sad8(current->u + x*8 + y*stride*8,
955                                                    reference->u + x*8 + y*stride*8, stride);
956                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
957                    sadC += sad8(current->v + (x + y*stride)*8,
958                                                    reference->v + (x + y*stride)*8, stride);
959                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
960                    return 1;
961    
962            } else {
963                    uint32_t sadC = sad16(current->u + x*16 + y*stride*16,
964                                                    reference->u + x*16 + y*stride*16, stride, 256*4096);
965                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
966                    sadC += sad16(current->v + (x + y*stride)*16,
967                                                    reference->v + (x + y*stride)*16, stride, 256*4096);
968                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
969                    return 1;
970                  }                  }
                 while (1);                              //forever  
971          }          }
972          return iMinSAD;  
973    static __inline void
974    SkipMacroblockP(MACROBLOCK *pMB, const int32_t sad)
975    {
976            pMB->mode = MODE_NOT_CODED;
977            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = zeroMV;
978            pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = zeroMV;
979            pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
980  }  }
981    
982    bool
983    MotionEstimation(MBParam * const pParam,
984                                     FRAMEINFO * const current,
985                                     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  int32_t          uint32_t mb_width = pParam->mb_width;
996  Full8_MainSearch(const uint8_t * const pRef,          uint32_t mb_height = pParam->mb_height;
997                                   const uint8_t * const pRefH,          const uint32_t iEdgedWidth = pParam->edged_width;
998                                   const uint8_t * const pRefV,          const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags);
999                                   const uint8_t * const pRefHV,  
1000                                   const uint8_t * const cur,          uint32_t x, y;
1001                                   const int x,          uint32_t iIntra = 0;
1002                                   const int y,          int32_t quant = current->quant, sad00;
1003                                   int32_t startx,  
1004                                   int32_t starty,          // some pre-initialized thingies for SearchP
1005                                   int32_t iMinSAD,          int32_t temp[8];
1006                                   VECTOR * const currMV,          VECTOR currentMV[5];
1007                                   const VECTOR * const pmv,          VECTOR currentQMV[5];
1008                                   const int32_t min_dx,          int32_t iMinSAD[5];
1009                                   const int32_t max_dx,          SearchData Data;
1010                                   const int32_t min_dy,          memset(&Data, 0, sizeof(SearchData));
1011                                   const int32_t max_dy,          Data.iEdgedWidth = iEdgedWidth;
1012                                   const int32_t iEdgedWidth,          Data.currentMV = currentMV;
1013                                   const int32_t iDiamondSize,          Data.currentQMV = currentQMV;
1014                                   const int32_t iFcode,          Data.iMinSAD = iMinSAD;
1015                                   const int32_t iQuant,          Data.temp = temp;
1016                                   int iFound)          Data.iFcode = current->fcode;
1017  {          Data.rounding = pParam->m_rounding_type;
1018          int32_t iSAD;          Data.qpel = current->vol_flags & XVID_QUARTERPEL;
1019          int32_t dx, dy;          Data.chroma = MotionFlags & PMV_CHROMA16;
1020          VECTOR backupMV;          Data.rrv = current->vop_flags & XVID_REDUCED;
1021    
1022          backupMV.x = startx;          if ((current->vop_flags & XVID_REDUCED)) {
1023          backupMV.y = starty;                  mb_width = (pParam->width + 31) / 32;
1024                    mb_height = (pParam->height + 31) / 32;
1025          for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)                  Data.qpel = 0;
1026                  for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)          }
1027                          NOCHECK_MV8_CANDIDATE(dx, dy);  
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          return iMinSAD;                          sad00 = pMB->sad16;
1054    
1055                            if (!(current->vop_flags & XVID_LUMIMASKING)) {
1056                                    pMB->dquant = NO_CHANGE;
1057                            } else {
1058                                    if (pMB->dquant != NO_CHANGE) {
1059                                            quant += DQtab[pMB->dquant];
1060                                            if (quant > 31) quant = 31;
1061                                            else if (quant < 1) quant = 1;
1062                                    }
1063                            }
1064                            pMB->quant = current->quant;
1065    
1066    //initial skip decision
1067    /* no early skip for GMC (global vector = skip vector is unknown!)  */
1068                            if (!(current->vol_flags & XVID_GMC))   { /* no fast SKIP for S(GMC)-VOPs */
1069                                    if (pMB->dquant == NO_CHANGE && sad00 < pMB->quant * INITIAL_SKIP_THRESH * (Data.rrv ? 4:1) )
1070                                            if (Data.chroma || SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv)) {
1071                                                    SkipMacroblockP(pMB, sad00);
1072                                                    continue;
1073                                            }
1074  }  }
1075    
1076                            SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,
1077                                                    y, MotionFlags, current->vol_flags, pMB->quant,
1078                                                    &Data, pParam, pMBs, reference->mbs,
1079                                                    current->vop_flags & XVID_INTER4V, pMB);
1080    
1081    /* final skip decision, a.k.a. "the vector you found, really that good?" */
1082                            if (!(current->vol_flags & XVID_GMC))   {
1083                                    if ( pMB->dquant == NO_CHANGE && sad00 < pMB->quant * MAX_SAD00_FOR_SKIP) {
1084                                            if (!(current->vop_flags & XVID_MODEDECISION_BITS)) {
1085                                                    if ( (100*pMB->sad16)/(sad00+1) > FINAL_SKIP_THRESH * (Data.rrv ? 4:1) )
1086                                                            if (Data.chroma || SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv))
1087                                                                    SkipMacroblockP(pMB, sad00);
1088                                            } else { // BITS mode decision
1089                                                    if (pMB->sad16 > 10)
1090                                                            SkipMacroblockP(pMB, sad00);  // more than 10 bits would be used for this MB - skip
1091    
1092  int32_t                                          }
1093  Halfpel16_Refine(const uint8_t * const pRef,                                  }
1094                                   const uint8_t * const pRefH,                          }
1095                                   const uint8_t * const pRefV,                          if (pMB->mode == MODE_INTRA)
1096                                   const uint8_t * const pRefHV,                                  if (++iIntra > iLimit) return 1;
1097                                   const uint8_t * const cur,                  }
1098                                   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_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);  
1099    
1100          return iMinSAD;          if (current->vol_flags & XVID_GMC )     /* GMC only for S(GMC)-VOPs */
1101            {
1102                    current->warp = GlobalMotionEst( pMBs, pParam, current, reference, pRefH, pRefV, pRefHV);
1103            }
1104            return 0;
1105  }  }
1106    
 #define PMV_HALFPEL16 (PMV_HALFPELDIAMOND16|PMV_HALFPELREFINE16)  
1107    
1108    static __inline int
1109    make_mask(const VECTOR * const pmv, const int i)
1110    {
1111            int mask = 255, j;
1112            for (j = 0; j < i; j++) {
1113                    if (MVequal(pmv[i], pmv[j])) return 0; // same vector has been checked already
1114                    if (pmv[i].x == pmv[j].x) {
1115                            if (pmv[i].y == pmv[j].y + iDiamondSize) mask &= ~4;
1116                            else if (pmv[i].y == pmv[j].y - iDiamondSize) mask &= ~8;
1117                    } else
1118                            if (pmv[i].y == pmv[j].y) {
1119                                    if (pmv[i].x == pmv[j].x + iDiamondSize) mask &= ~1;
1120                                    else if (pmv[i].x == pmv[j].x - iDiamondSize) mask &= ~2;
1121                            }
1122            }
1123            return mask;
1124    }
1125    
1126  int32_t  static __inline void
1127  PMVfastSearch16(const uint8_t * const pRef,  PreparePredictionsP(VECTOR * const pmv, int x, int y, int iWcount,
1128                                  const uint8_t * const pRefH,                          int iHcount, const MACROBLOCK * const prevMB, int rrv)
                                 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,  
                                 const MBParam * const pParam,  
                                 const MACROBLOCK * const pMBs,  
                                 const MACROBLOCK * const prevMBs,  
                                 VECTOR * const currMV,  
                                 VECTOR * const currPMV)  
1129  {  {
         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;  
1130    
1131          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;  //this function depends on get_pmvdata which means that it sucks. It should get the predictions by itself
1132            if (rrv) { iWcount /= 2; iHcount /= 2; }
1133    
1134          int32_t iDiamondSize;          if ( (y != 0) && (x < (iWcount-1)) ) {          // [5] top-right neighbour
1135                    pmv[5].x = EVEN(pmv[3].x);
1136                    pmv[5].y = EVEN(pmv[3].y);
1137            } else pmv[5].x = pmv[5].y = 0;
1138    
1139          int32_t min_dx;          if (x != 0) { pmv[3].x = EVEN(pmv[1].x); pmv[3].y = EVEN(pmv[1].y); }// pmv[3] is left neighbour
1140          int32_t max_dx;          else pmv[3].x = pmv[3].y = 0;
         int32_t min_dy;  
         int32_t max_dy;  
1141    
1142          int32_t iFound;          if (y != 0) { pmv[4].x = EVEN(pmv[2].x); pmv[4].y = EVEN(pmv[2].y); }// [4] top neighbour
1143            else pmv[4].x = pmv[4].y = 0;
1144    
1145          VECTOR newMV;          // [1] median prediction
1146          VECTOR backupMV;                        /* just for PMVFAST */          pmv[1].x = EVEN(pmv[0].x); pmv[1].y = EVEN(pmv[0].y);
1147    
1148          VECTOR pmv[4];          pmv[0].x = pmv[0].y = 0; // [0] is zero; not used in the loop (checked before) but needed here for make_mask
         int32_t psad[4];  
1149    
1150          MainSearch16FuncPtr MainSearchPtr;          pmv[2].x = EVEN(prevMB->mvs[0].x); // [2] is last frame
1151            pmv[2].y = EVEN(prevMB->mvs[0].y);
1152    
1153  //  const MACROBLOCK * const pMB = pMBs + x + y * iWcount;          if ((x < iWcount-1) && (y < iHcount-1)) {
1154          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;                  pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); //[6] right-down neighbour in last frame
1155                    pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y);
1156            } else pmv[6].x = pmv[6].y = 0;
1157    
1158          static int32_t threshA, threshB;          if (rrv) {
1159          int32_t bPredEq;                  int i;
1160          int32_t iMinSAD, iSAD;                  for (i = 0; i < 7; i++) {
1161                            pmv[i].x = RRV_MV_SCALEUP(pmv[i].x);
1162                            pmv[i].y = RRV_MV_SCALEUP(pmv[i].y);
1163                    }
1164            }
1165    }
1166    
1167  /* Get maximum range */  static int
1168          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,  ModeDecision(const uint32_t iQuant, SearchData * const Data,
1169                            iFcode);                  int inter4v,
1170                    MACROBLOCK * const pMB,
1171                    const MACROBLOCK * const pMBs,
1172                    const int x, const int y,
1173                    const MBParam * const pParam,
1174                    const uint32_t MotionFlags,
1175                    const uint32_t VopFlags)
1176    {
1177    
1178  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */          int mode = MODE_INTER;
1179    
1180          if (!(MotionFlags & PMV_HALFPEL16)) {          if (!(VopFlags & XVID_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision
1181                  min_dx = EVEN(min_dx);  //              int intra = 0;
1182                  max_dx = EVEN(max_dx);                  int sad;
1183                  min_dy = EVEN(min_dy);                  int InterBias = MV16_INTER_BIAS;
1184                  max_dy = EVEN(max_dy);                  if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +
1185                            Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) {
1186                                    mode = 0; //inter
1187                                    sad = Data->iMinSAD[0];
1188                    } else {
1189                            mode = MODE_INTER4V;
1190                            sad = Data->iMinSAD[1] + Data->iMinSAD[2] +
1191                                                    Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant;
1192                            Data->iMinSAD[0] = sad;
1193          }          }
1194    
1195          /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */                  /* intra decision */
         bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);  
1196    
1197          if ((x == 0) && (y == 0)) {                  if (iQuant > 8) InterBias += 100 * (iQuant - 8); // to make high quants work
1198                  threshA = 512;                  if (y != 0)
1199                  threshB = 1024;                          if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;
1200                    if (x != 0)
1201                            if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80;
1202    
1203                    if (Data->chroma) InterBias += 50; // to compensate bigger SAD
1204                    if (Data->rrv) InterBias *= 4;
1205    
1206                    if (InterBias < pMB->sad16) {
1207                            int32_t deviation;
1208                            if (!Data->rrv) deviation = dev16(Data->Cur, Data->iEdgedWidth);
1209                            else deviation = dev16(Data->Cur, Data->iEdgedWidth) +
1210                                    dev16(Data->Cur+8, Data->iEdgedWidth) +
1211                                    dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) +
1212                                    dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth);
1213    
1214                            if (deviation < (sad - InterBias))  return MODE_INTRA;// intra
1215                    }
1216                    return mode;
1217    
1218          } else {          } else {
1219                  threshA = psad[0];  
1220                  threshB = threshA + 256;                  int bits, intra, i;
1221                  if (threshA < 512)                  VECTOR backup[5], *v;
1222                          threshA = 512;                  Data->lambda16 = iQuant;
1223                  if (threshA > 1024)          Data->lambda8 = (pParam->vol_flags & XVID_MPEGQUANT)?1:0;
1224                          threshA = 1024;  
1225                  if (threshB > 1792)                  v = Data->qpel ? Data->currentQMV : Data->currentMV;
1226                          threshB = 1792;                  for (i = 0; i < 5; i++) {
1227                            Data->iMinSAD[i] = 256*4096;
1228                            backup[i] = v[i];
1229          }          }
1230    
1231          iFound = 0;                  bits = CountMBBitsInter(Data, pMBs, x, y, pParam, MotionFlags);
1232                    if (bits == 0) return MODE_INTER; // quick stop
 /* 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.  
 */  
1233    
1234          *currMV = pmv[0];                       /* current best := prediction */                  if (inter4v) {
1235          if (!(MotionFlags & PMV_HALFPEL16)) {   /* This should NOT be necessary! */                          int inter4v = CountMBBitsInter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1236                  currMV->x = EVEN(currMV->x);                          if (inter4v < bits) { Data->iMinSAD[0] = bits = inter4v; mode = MODE_INTER4V; }
                 currMV->y = EVEN(currMV->y);  
1237          }          }
1238    
1239          if (currMV->x > max_dx) {  
1240                  currMV->x = max_dx;                  intra = CountMBBitsIntra(Data);
1241    
1242                    if (intra < bits) { *Data->iMinSAD = bits = intra; return MODE_INTRA; }
1243    
1244                    return mode;
1245          }          }
         if (currMV->x < min_dx) {  
                 currMV->x = min_dx;  
1246          }          }
1247          if (currMV->y > max_dy) {  
1248                  currMV->y = max_dy;  static void
1249    SearchP(const IMAGE * const pRef,
1250                    const uint8_t * const pRefH,
1251                    const uint8_t * const pRefV,
1252                    const uint8_t * const pRefHV,
1253                    const IMAGE * const pCur,
1254                    const int x,
1255                    const int y,
1256                    const uint32_t MotionFlags,
1257                    const uint32_t VopFlags,
1258                    const uint32_t iQuant,
1259                    SearchData * const Data,
1260                    const MBParam * const pParam,
1261                    const MACROBLOCK * const pMBs,
1262                    const MACROBLOCK * const prevMBs,
1263                    int inter4v,
1264                    MACROBLOCK * const pMB)
1265    {
1266    
1267            int i, iDirection = 255, mask, threshA;
1268            VECTOR pmv[7];
1269    
1270            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1271                                                    pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
1272    
1273            get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp);
1274    
1275            Data->temp[5] = Data->temp[6] = 0; // chroma-sad cache
1276            i = Data->rrv ? 2 : 1;
1277            Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;
1278            Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1279            Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1280    
1281            Data->Ref = pRef->y + (x + Data->iEdgedWidth*y) * 16*i;
1282            Data->RefH = pRefH + (x + Data->iEdgedWidth*y) * 16*i;
1283            Data->RefV = pRefV + (x + Data->iEdgedWidth*y) * 16*i;
1284            Data->RefHV = pRefHV + (x + Data->iEdgedWidth*y) * 16*i;
1285            Data->RefCV = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1286            Data->RefCU = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1287    
1288            Data->lambda16 = lambda_vec16[iQuant];
1289            Data->lambda8 = lambda_vec8[iQuant];
1290            Data->qpel_precision = 0;
1291    
1292            if (pMB->dquant != NO_CHANGE) inter4v = 0;
1293    
1294            for(i = 0; i < 5; i++)
1295                    Data->currentMV[i].x = Data->currentMV[i].y = 0;
1296    
1297            if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0);
1298            else Data->predMV = pmv[0];
1299    
1300            i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0, 0);
1301            Data->iMinSAD[0] = pMB->sad16 + ((Data->lambda16 * i * pMB->sad16)>>10);
1302            Data->iMinSAD[1] = pMB->sad8[0] + ((Data->lambda8 * i * (pMB->sad8[0]+NEIGH_8X8_BIAS)) >> 10);
1303            Data->iMinSAD[2] = pMB->sad8[1];
1304            Data->iMinSAD[3] = pMB->sad8[2];
1305            Data->iMinSAD[4] = pMB->sad8[3];
1306    
1307            if ((!(VopFlags & XVID_MODEDECISION_BITS)) || (x | y)) {
1308                    threshA = Data->temp[0]; // that's where we keep this SAD atm
1309                    if (threshA < 512) threshA = 512;
1310                    else if (threshA > 1024) threshA = 1024;
1311            } else
1312                    threshA = 512;
1313    
1314            PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height,
1315                                            prevMBs + x + y * pParam->mb_width, Data->rrv);
1316    
1317            if (!Data->rrv) {
1318                    if (inter4v | Data->chroma) CheckCandidate = CheckCandidate16;
1319                            else CheckCandidate = CheckCandidate16no4v; //for extra speed
1320            } else CheckCandidate = CheckCandidate32;
1321    
1322    /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/
1323    
1324            for (i = 1; i < 7; i++) {
1325                    if (!(mask = make_mask(pmv, i)) ) continue;
1326                    CheckCandidate(pmv[i].x, pmv[i].y, mask, &iDirection, Data);
1327                    if (Data->iMinSAD[0] <= threshA) break;
1328            }
1329    
1330            if ((Data->iMinSAD[0] <= threshA) ||
1331                            (MVequal(Data->currentMV[0], (prevMBs+x+y*pParam->mb_width)->mvs[0]) &&
1332                            (Data->iMinSAD[0] < (prevMBs+x+y*pParam->mb_width)->sad16))) {
1333                    if (!(VopFlags & XVID_MODEDECISION_BITS)) inter4v = 0;  }
1334            else {
1335    
1336                    MainSearchFunc * MainSearchPtr;
1337                    if (MotionFlags & PMV_USESQUARES16) MainSearchPtr = SquareSearch;
1338                    else if (MotionFlags & PMV_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1339                            else MainSearchPtr = DiamondSearch;
1340    
1341                    MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
1342    
1343    /* extended search, diamond starting in 0,0 and in prediction.
1344            note that this search is/might be done in halfpel positions,
1345            which makes it more different than the diamond above */
1346    
1347                    if (MotionFlags & PMV_EXTSEARCH16) {
1348                            int32_t bSAD;
1349                            VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0];
1350                            if (Data->rrv) {
1351                                    startMV.x = RRV_MV_SCALEUP(startMV.x);
1352                                    startMV.y = RRV_MV_SCALEUP(startMV.y);
1353          }          }
1354          if (currMV->y < min_dy) {                          if (!(MVequal(startMV, backupMV))) {
1355                  currMV->y = min_dy;                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1356    
1357                                    CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1358                                    MainSearchPtr(startMV.x, startMV.y, Data, 255);
1359                                    if (bSAD < Data->iMinSAD[0]) {
1360                                            Data->currentMV[0] = backupMV;
1361                                            Data->iMinSAD[0] = bSAD; }
1362          }          }
1363    
1364          iMinSAD =                          backupMV = Data->currentMV[0];
1365                  sad16(cur,                          startMV.x = startMV.y = 1;
1366                            get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,                          if (!(MVequal(startMV, backupMV))) {
1367                                                   iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
         iMinSAD +=  
                 calc_delta_16(currMV->x - pmv[0].x, currMV->y - pmv[0].y,  
                                           (uint8_t) iFcode, iQuant);  
1368    
1369          if ((iMinSAD < 256) ||                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1370                  ((MVequal(*currMV, prevMB->mvs[0])) &&                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);
1371                   ((uint32_t) iMinSAD < prevMB->sad16))) {                                  if (bSAD < Data->iMinSAD[0]) {
1372                  if (iMinSAD < 2 * iQuant)       // high chances for SKIP-mode                                          Data->currentMV[0] = backupMV;
1373                  {                                          Data->iMinSAD[0] = bSAD; }
                         if (!MVzero(*currMV)) {  
                                 iMinSAD += MV16_00_BIAS;  
                                 CHECK_MV16_ZERO;        // (0,0) saves space for letterboxed pictures  
                                 iMinSAD -= MV16_00_BIAS;  
1374                          }                          }
1375                  }                  }
1376            }
1377    
1378            if (MotionFlags & PMV_HALFPELREFINE16)
1379                    if ((!(MotionFlags & HALFPELREFINE16_BITS)) || Data->iMinSAD[0] < 200*(int)iQuant)
1380                            SubpelRefine(Data);
1381    
1382                  if (MotionFlags & PMV_QUICKSTOP16)          for(i = 0; i < 5; i++) {
1383                          goto PMVfast16_Terminate_without_Refine;                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // initialize qpel vectors
1384                  if (MotionFlags & PMV_EARLYSTOP16)                  Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
                         goto PMVfast16_Terminate_with_Refine;  
1385          }          }
1386    
1387            if (MotionFlags & PMV_QUARTERPELREFINE16)
1388                    if ((!(MotionFlags & QUARTERPELREFINE16_BITS)) || (Data->iMinSAD[0] < 200*(int)iQuant)) {
1389                            Data->qpel_precision = 1;
1390                            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1391                                            pParam->width, pParam->height, Data->iFcode, 1, 0);
1392    
1393  /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion                          SubpelRefine(Data);
1394     vector of the median.                  }
    If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2  
 */  
1395    
1396          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[0])))          if ((!(VopFlags & XVID_MODEDECISION_BITS)) && (Data->iMinSAD[0] < (int32_t)iQuant * 30)) inter4v = 0;
                 iFound = 2;  
1397    
1398  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.          if (inter4v && (!(VopFlags & XVID_MODEDECISION_BITS) ||
1399     Otherwise select large Diamond Search.                          (!(MotionFlags & QUARTERPELREFINE8_BITS)) || (!(MotionFlags & HALFPELREFINE8_BITS)) ||
1400  */                          ((!(MotionFlags & EXTSEARCH_BITS)) && (!(MotionFlags&PMV_EXTSEARCH8)) ))) {
1401                    // if decision is BITS-based and all refinement steps will be done in BITS domain, there is no reason to call this loop
1402    
1403          if ((!MVzero(pmv[0])) || (threshB < 1536) || (bPredEq))                  SearchData Data8;
1404                  iDiamondSize = 1;               // halfpel!                  memcpy(&Data8, Data, sizeof(SearchData)); //quick copy of common data
         else  
                 iDiamondSize = 2;               // halfpel!  
1405    
1406          if (!(MotionFlags & PMV_HALFPELDIAMOND16))                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8);
1407                  iDiamondSize *= 2;                  Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8);
1408                    Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8);
1409                    Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);
1410    
1411  /*                  if ((Data->chroma) && (!(VopFlags & XVID_MODEDECISION_BITS))) {
1412     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
1413     Also calculate (0,0) but do not subtract offset.                          int sumx = 0, sumy = 0;
1414     Let MinSAD be the smallest SAD up to this point.                          const int div = 1 + Data->qpel;
1415     If MV is (0,0) subtract offset.                          const VECTOR * const mv = Data->qpel ? pMB->qmvs : pMB->mvs;
1416  */  
1417                            for (i = 0; i < 4; i++) {
1418                                    sumx += mv[i].x / div;
1419                                    sumy += mv[i].y / div;
1420                            }
1421    
1422  // (0,0) is always possible                          Data->iMinSAD[1] += ChromaSAD(  (sumx >> 3) + roundtab_76[sumx & 0xf],
1423                                                                                            (sumy >> 3) + roundtab_76[sumy & 0xf], Data);
1424                    }
1425            }
1426    
1427          if (!MVzero(pmv[0]))          inter4v = ModeDecision(iQuant, Data, inter4v, pMB, pMBs, x, y, pParam, MotionFlags, VopFlags);
                 CHECK_MV16_ZERO;  
1428    
1429  // previous frame MV is always possible          if (Data->rrv) {
1430                            Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
1431                            Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
1432            }
1433    
1434          if (!MVzero(prevMB->mvs[0]))          if (inter4v == MODE_INTER) {
1435                  if (!MVequal(prevMB->mvs[0], pmv[0]))                  pMB->mode = MODE_INTER;
1436                          CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);                  pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
1437                    pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = Data->iMinSAD[0];
1438    
1439  // left neighbour, if allowed                  if(Data->qpel) {
1440                            pMB->qmvs[0] = pMB->qmvs[1]
1441                                    = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0];
1442                            pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x;
1443                            pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y;
1444                    } else {
1445                            pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x;
1446                            pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;
1447                    }
1448    
1449          if (!MVzero(pmv[1]))          } else if (inter4v == MODE_INTER4V) {
1450                  if (!MVequal(pmv[1], prevMB->mvs[0]))                  pMB->mode = MODE_INTER4V;
1451                          if (!MVequal(pmv[1], pmv[0])) {                  pMB->sad16 = Data->iMinSAD[0];
1452                                  if (!(MotionFlags & PMV_HALFPEL16)) {          } else { // INTRA mode
1453                                          pmv[1].x = EVEN(pmv[1].x);                  SkipMacroblockP(pMB, 0); // not skip, but similar enough
1454                                          pmv[1].y = EVEN(pmv[1].y);                  pMB->mode = MODE_INTRA;
1455                                  }                                  }
1456    
                                 CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);  
1457                          }                          }
1458  // top neighbour, if allowed  
1459          if (!MVzero(pmv[2]))  static void
1460                  if (!MVequal(pmv[2], prevMB->mvs[0]))  Search8(const SearchData * const OldData,
1461                          if (!MVequal(pmv[2], pmv[0]))                  const int x, const int y,
1462                                  if (!MVequal(pmv[2], pmv[1])) {                  const uint32_t MotionFlags,
1463                                          if (!(MotionFlags & PMV_HALFPEL16)) {                  const MBParam * const pParam,
1464                                                  pmv[2].x = EVEN(pmv[2].x);                  MACROBLOCK * const pMB,
1465                                                  pmv[2].y = EVEN(pmv[2].y);                  const MACROBLOCK * const pMBs,
1466                    const int block,
1467                    SearchData * const Data)
1468    {
1469            int i = 0;
1470            Data->iMinSAD = OldData->iMinSAD + 1 + block;
1471            Data->currentMV = OldData->currentMV + 1 + block;
1472            Data->currentQMV = OldData->currentQMV + 1 + block;
1473    
1474            if(Data->qpel) {
1475                    Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1476                    if (block != 0) i = d_mv_bits(  Data->currentQMV->x, Data->currentQMV->y,
1477                                                                                    Data->predMV, Data->iFcode, 0, 0);
1478            } else {
1479                    Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1480                    if (block != 0) i = d_mv_bits(  Data->currentMV->x, Data->currentMV->y,
1481                                                                                    Data->predMV, Data->iFcode, 0, Data->rrv);
1482                                          }                                          }
                                         CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
1483    
1484  // top right neighbour, if allowed          *(Data->iMinSAD) += (Data->lambda8 * i * (*Data->iMinSAD + NEIGH_8X8_BIAS))>>10;
                                         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);  
                                                                         }  
                                 }  
1485    
1486          if ((MVzero(*currMV)) &&          if (MotionFlags & (PMV_EXTSEARCH8|PMV_HALFPELREFINE8|PMV_QUARTERPELREFINE8)) {
1487                  (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )                  if (Data->rrv) i = 2; else i = 1;
                 iMinSAD -= MV16_00_BIAS;  
1488    
1489                    Data->Ref = OldData->Ref + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1490                    Data->RefH = OldData->RefH + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1491                    Data->RefV = OldData->RefV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1492                    Data->RefHV = OldData->RefHV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1493    
1494  /* Step 6: If MinSAD <= thresa goto Step 10.                  Data->Cur = OldData->Cur + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1495     If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.                  Data->qpel_precision = 0;
 */  
1496    
1497          if ((iMinSAD <= threshA) ||                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1498                  (MVequal(*currMV, prevMB->mvs[0]) &&                                          pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
                  ((uint32_t) iMinSAD < prevMB->sad16))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast16_Terminate_with_Refine;  
         }  
1499    
1500                    if (!Data->rrv) CheckCandidate = CheckCandidate8;
1501                    else CheckCandidate = CheckCandidate16no4v;
1502    
1503  /************ (Diamond Search)  **************/                  if (MotionFlags & PMV_EXTSEARCH8 && (!(MotionFlags & EXTSEARCH_BITS))) {
1504  /*                          int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
    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.  
 */  
1505    
1506          if (MotionFlags & PMV_USESQUARES16)                          MainSearchFunc *MainSearchPtr;
1507                  MainSearchPtr = Square16_MainSearch;                          if (MotionFlags & PMV_USESQUARES8) MainSearchPtr = SquareSearch;
1508          else if (MotionFlags & PMV_ADVANCEDDIAMOND16)                                  else if (MotionFlags & PMV_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;
1509                  MainSearchPtr = AdvDiamond16_MainSearch;                                          else MainSearchPtr = DiamondSearch;
         else  
                 MainSearchPtr = Diamond16_MainSearch;  
1510    
1511          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255);
1512    
1513  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */                          if(*(Data->iMinSAD) < temp_sad) {
1514          iSAD =                                          Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1515                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,                                          Data->currentQMV->y = 2 * Data->currentMV->y;
1516                                                    currMV->y, iMinSAD, &newMV, pmv, min_dx, max_dx,                          }
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, iFound);  
   
         if (iSAD < iMinSAD) {  
                 *currMV = newMV;  
                 iMinSAD = iSAD;  
1517          }          }
1518    
1519          if (MotionFlags & PMV_EXTSEARCH16) {                  if (MotionFlags & PMV_HALFPELREFINE8) {
1520  /* extended: search (up to) two more times: orignal prediction and (0,0) */                          int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
1521    
1522                  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);  
1523    
1524                          if (iSAD < iMinSAD) {                          if(*(Data->iMinSAD) < temp_sad) { // we have found a better match
1525                                  *currMV = newMV;                                  Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1526                                  iMinSAD = iSAD;                                  Data->currentQMV->y = 2 * Data->currentMV->y;
1527                          }                          }
1528                  }                  }
1529    
1530                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                  if (Data->qpel && MotionFlags & PMV_QUARTERPELREFINE8) {
1531                          iSAD =                                  Data->qpel_precision = 1;
1532                                  (*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,
1533                                                                    iMinSAD, &newMV, pmv, min_dx, max_dx, min_dy,                                          pParam->width, pParam->height, Data->iFcode, 1, 0);
1534                                                                    max_dy, iEdgedWidth, iDiamondSize, iFcode,                                  SubpelRefine(Data);
                                                                   iQuant, iFound);  
   
                         if (iSAD < iMinSAD) {  
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
1535                          }                          }
1536                  }                  }
1537    
1538            if (Data->rrv) {
1539                            Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);
1540                            Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);
1541          }          }
1542    
1543  /*          if(Data->qpel) {
1544     Step 10:  The motion vector is chosen according to the block corresponding to MinSAD.                  pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x;
1545  */                  pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y;
1546                    pMB->qmvs[block] = *Data->currentQMV;
1547            } else {
1548                    pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x;
1549                    pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;
1550            }
1551    
1552    PMVfast16_Terminate_with_Refine:          pMB->mvs[block] = *Data->currentMV;
1553          if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step          pMB->sad8[block] = 4 * *Data->iMinSAD;
1554                  iMinSAD =  }
1555                          Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
1556                                                           iMinSAD, pmv, min_dx, max_dx, min_dy, max_dy,  /* motion estimation for B-frames */
                                                          iFcode, iQuant, iEdgedWidth);  
1557    
1558    PMVfast16_Terminate_without_Refine:  static __inline VECTOR
1559          currPMV->x = currMV->x - pmv[0].x;  ChoosePred(const MACROBLOCK * const pMB, const uint32_t mode)
1560          currPMV->y = currMV->y - pmv[0].y;  {
1561          return iMinSAD;  /* the stupidiest function ever */
1562            return (mode == MODE_FORWARD ? pMB->mvs[0] : pMB->b_mvs[0]);
1563  }  }
1564    
1565    static void __inline
1566    PreparePredictionsBF(VECTOR * const pmv, const int x, const int y,
1567                                                            const uint32_t iWcount,
1568                                                            const MACROBLOCK * const pMB,
1569                                                            const uint32_t mode_curr)
1570    {
1571    
1572            // [0] is prediction
1573            pmv[0].x = EVEN(pmv[0].x); pmv[0].y = EVEN(pmv[0].y);
1574    
1575            pmv[1].x = pmv[1].y = 0; // [1] is zero
1576    
1577            pmv[2] = ChoosePred(pMB, mode_curr);
1578            pmv[2].x = EVEN(pmv[2].x); pmv[2].y = EVEN(pmv[2].y);
1579    
1580            if ((y != 0)&&(x != (int)(iWcount+1))) {                        // [3] top-right neighbour
1581                    pmv[3] = ChoosePred(pMB+1-iWcount, mode_curr);
1582                    pmv[3].x = EVEN(pmv[3].x); pmv[3].y = EVEN(pmv[3].y);
1583            } else pmv[3].x = pmv[3].y = 0;
1584    
1585  int32_t          if (y != 0) {
1586  Diamond8_MainSearch(const uint8_t * const pRef,                  pmv[4] = ChoosePred(pMB-iWcount, mode_curr);
1587                                          const uint8_t * const pRefH,                  pmv[4].x = EVEN(pmv[4].x); pmv[4].y = EVEN(pmv[4].y);
1588                                          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;  
 }  
1589    
1590  int32_t          if (x != 0) {
1591  Halfpel8_Refine(const uint8_t * const pRef,                  pmv[5] = ChoosePred(pMB-1, mode_curr);
1592                                  const uint8_t * const pRefH,                  pmv[5].x = EVEN(pmv[5].x); pmv[5].y = EVEN(pmv[5].y);
1593                                  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);  
1594    
1595          return iMinSAD;          if (x != 0 && y != 0) {
1596                    pmv[6] = ChoosePred(pMB-1-iWcount, mode_curr);
1597                    pmv[6].x = EVEN(pmv[6].x); pmv[6].y = EVEN(pmv[6].y);
1598            } else pmv[6].x = pmv[6].y = 0;
1599  }  }
1600    
1601    
1602  #define PMV_HALFPEL8 (PMV_HALFPELDIAMOND8|PMV_HALFPELREFINE8)  /* search backward or forward */
1603    static void
1604  int32_t  SearchBF(       const IMAGE * const pRef,
 PMVfastSearch8(const uint8_t * const pRef,  
1605                             const uint8_t * const pRefH,                             const uint8_t * const pRefH,
1606                             const uint8_t * const pRefV,                             const uint8_t * const pRefV,
1607                             const uint8_t * const pRefHV,                             const uint8_t * const pRefHV,
1608                             const IMAGE * const pCur,                             const IMAGE * const pCur,
1609                             const int x,                          const int x, const int y,
                            const int y,  
                            const int start_x,  
                            const int start_y,  
1610                             const uint32_t MotionFlags,                             const uint32_t MotionFlags,
                            const uint32_t iQuant,  
1611                             const uint32_t iFcode,                             const uint32_t iFcode,
1612                             const MBParam * const pParam,                             const MBParam * const pParam,
1613                             const MACROBLOCK * const pMBs,                          MACROBLOCK * const pMB,
1614                             const MACROBLOCK * const prevMBs,                          const VECTOR * const predMV,
1615                             VECTOR * const currMV,                          int32_t * const best_sad,
1616                             VECTOR * const currPMV)                          const int32_t mode_current,
1617                            SearchData * const Data)
1618  {  {
         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;  
1619    
1620          int32_t min_dx;          int i, iDirection = 255, mask;
1621          int32_t max_dx;          VECTOR pmv[7];
1622          int32_t min_dy;          MainSearchFunc *MainSearchPtr;
1623          int32_t max_dy;          *Data->iMinSAD = MV_MAX_ERROR;
1624            Data->iFcode = iFcode;
1625            Data->qpel_precision = 0;
1626            Data->temp[5] = Data->temp[6] = Data->temp[7] = 256*4096; // reset chroma-sad cache
1627    
1628          VECTOR pmv[4];          Data->Ref = pRef->y + (x + y * Data->iEdgedWidth) * 16;
1629          int32_t psad[4];          Data->RefH = pRefH + (x + y * Data->iEdgedWidth) * 16;
1630          VECTOR newMV;          Data->RefV = pRefV + (x + y * Data->iEdgedWidth) * 16;
1631          VECTOR backupMV;          Data->RefHV = pRefHV + (x + y * Data->iEdgedWidth) * 16;
1632          VECTOR startMV;          Data->RefCU = pRef->u + (x + y * Data->iEdgedWidth/2) * 8;
1633            Data->RefCV = pRef->v + (x + y * Data->iEdgedWidth/2) * 8;
1634    
1635  //  const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;          Data->predMV = *predMV;
         const MACROBLOCK *const prevMB = prevMBs + (x >> 1) + (y >> 1) * iWcount;  
1636    
1637          static int32_t threshA, threshB;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1638          int32_t iFound, bPredEq;                                  pParam->width, pParam->height, iFcode - Data->qpel, 0, 0);
         int32_t iMinSAD, iSAD;  
1639    
1640          int32_t iSubBlock = (y & 1) + (y & 1) + (x & 1);          pmv[0] = Data->predMV;
1641            if (Data->qpel) { pmv[0].x /= 2; pmv[0].y /= 2; }
1642    
1643          MainSearch8FuncPtr MainSearchPtr;          PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current);
1644    
1645          /* Init variables */          Data->currentMV->x = Data->currentMV->y = 0;
1646          startMV.x = start_x;          CheckCandidate = CheckCandidate16no4v;
         startMV.y = start_y;  
1647    
1648          /* Get maximum range */  // main loop. checking all predictions
1649          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,          for (i = 0; i < 7; i++) {
1650                            iFcode);                  if (!(mask = make_mask(pmv, i)) ) continue;
1651                    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);  
1652          }          }
1653    
1654          /* because we might use IF (dx>max_dx) THEN dx=max_dx; */          if (MotionFlags & PMV_USESQUARES16) MainSearchPtr = SquareSearch;
1655          bPredEq =          else if (MotionFlags & PMV_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1656                  get_pmvdata(pMBs, (x >> 1), (y >> 1), iWcount, iSubBlock, pmv, psad);                  else MainSearchPtr = DiamondSearch;
1657    
1658          if ((x == 0) && (y == 0)) {          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
                 threshA = 512 / 4;  
                 threshB = 1024 / 4;  
1659    
1660          } 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.  
 */  
1661    
1662            if (Data->qpel && *Data->iMinSAD < *best_sad + 300) {
1663                    Data->currentQMV->x = 2*Data->currentMV->x;
1664                    Data->currentQMV->y = 2*Data->currentMV->y;
1665                    Data->qpel_precision = 1;
1666                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1667                                            pParam->width, pParam->height, iFcode, 1, 0);
1668                    SubpelRefine(Data);
1669            }
1670    
1671  // Prepare for main loop  // three bits are needed to code backward mode. four for forward
1672    
1673  //  if (MotionFlags & PMV_USESQUARES8)          if (mode_current == MODE_FORWARD) *Data->iMinSAD += 4 * Data->lambda16;
1674  //      MainSearchPtr = Square8_MainSearch;          else *Data->iMinSAD += 3 * Data->lambda16;
 //  else  
1675    
1676          if (MotionFlags & PMV_ADVANCEDDIAMOND8)          if (*Data->iMinSAD < *best_sad) {
1677                  MainSearchPtr = AdvDiamond8_MainSearch;                  *best_sad = *Data->iMinSAD;
1678                    pMB->mode = mode_current;
1679                    if (Data->qpel) {
1680                            pMB->pmvs[0].x = Data->currentQMV->x - predMV->x;
1681                            pMB->pmvs[0].y = Data->currentQMV->y - predMV->y;
1682                            if (mode_current == MODE_FORWARD)
1683                                    pMB->qmvs[0] = *Data->currentQMV;
1684          else          else
1685                  MainSearchPtr = Diamond8_MainSearch;                                  pMB->b_qmvs[0] = *Data->currentQMV;
1686                    } else {
1687                            pMB->pmvs[0].x = Data->currentMV->x - predMV->x;
1688                            pMB->pmvs[0].y = Data->currentMV->y - predMV->y;
1689                    }
1690                    if (mode_current == MODE_FORWARD) pMB->mvs[0] = *Data->currentMV;
1691                    else pMB->b_mvs[0] = *Data->currentMV;
1692            }
1693    
1694            if (mode_current == MODE_FORWARD) *(Data->currentMV+2) = *Data->currentMV;
1695            else *(Data->currentMV+1) = *Data->currentMV; //we store currmv for interpolate search
1696    }
1697    
1698          *currMV = startMV;  static void
1699    SkipDecisionB(const IMAGE * const pCur,
1700                                    const IMAGE * const f_Ref,
1701                                    const IMAGE * const b_Ref,
1702                                    MACROBLOCK * const pMB,
1703                                    const uint32_t x, const uint32_t y,
1704                                    const SearchData * const Data)
1705    {
1706            int dx = 0, dy = 0, b_dx = 0, b_dy = 0;
1707            int32_t sum;
1708            const int div = 1 + Data->qpel;
1709            int k;
1710            const uint32_t stride = Data->iEdgedWidth/2;
1711    //this is not full chroma compensation, only it's fullpel approximation. should work though
1712    
1713          iMinSAD =          for (k = 0; k < 4; k++) {
1714                  sad8(cur,                  dy += Data->directmvF[k].y / div;
1715                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,                  dx += Data->directmvF[0].x / div;
1716                                                  iEdgedWidth), iEdgedWidth);                  b_dy += Data->directmvB[0].y / div;
1717          iMinSAD +=                  b_dx += Data->directmvB[0].x / div;
1718                  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  
 */  
1719    
1720          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[iSubBlock])))          dy = (dy >> 3) + roundtab_76[dy & 0xf];
1721                  iFound = 2;          dx = (dx >> 3) + roundtab_76[dx & 0xf];
1722            b_dy = (b_dy >> 3) + roundtab_76[b_dy & 0xf];
1723            b_dx = (b_dx >> 3) + roundtab_76[b_dx & 0xf];
1724    
1725  /* 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,
1726     Otherwise select large Diamond Search.                                          f_Ref->u + (y*8 + dy/2) * stride + x*8 + dx/2,
1727  */                                          b_Ref->u + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
1728                                            stride);
1729    
1730          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!  
1731    
1732          if (!(MotionFlags & PMV_HALFPELDIAMOND8))          sum += sad8bi(pCur->v + 8*x + 8 * y * stride,
1733                  iDiamondSize *= 2;                                          f_Ref->v + (y*8 + dy/2) * stride + x*8 + dx/2,
1734                                            b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
1735                                            stride);
1736    
1737            if (sum < 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) pMB->mode = MODE_DIRECT_NONE_MV; //skipped
1738    }
1739    
1740  /*  static __inline uint32_t
1741     Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.  SearchDirect(const IMAGE * const f_Ref,
1742     Also calculate (0,0) but do not subtract offset.                                  const uint8_t * const f_RefH,
1743     Let MinSAD be the smallest SAD up to this point.                                  const uint8_t * const f_RefV,
1744     If MV is (0,0) subtract offset.                                  const uint8_t * const f_RefHV,
1745  */                                  const IMAGE * const b_Ref,
1746                                    const uint8_t * const b_RefH,
1747                                    const uint8_t * const b_RefV,
1748                                    const uint8_t * const b_RefHV,
1749                                    const IMAGE * const pCur,
1750                                    const int x, const int y,
1751                                    const uint32_t MotionFlags,
1752                                    const int32_t TRB, const int32_t TRD,
1753                                    const MBParam * const pParam,
1754                                    MACROBLOCK * const pMB,
1755                                    const MACROBLOCK * const b_mb,
1756                                    int32_t * const best_sad,
1757                                    SearchData * const Data)
1758    
1759    {
1760            int32_t skip_sad;
1761            int k = (x + Data->iEdgedWidth*y) * 16;
1762            MainSearchFunc *MainSearchPtr;
1763    
1764            *Data->iMinSAD = 256*4096;
1765            Data->Ref = f_Ref->y + k;
1766            Data->RefH = f_RefH + k;
1767            Data->RefV = f_RefV + k;
1768            Data->RefHV = f_RefHV + k;
1769            Data->bRef = b_Ref->y + k;
1770            Data->bRefH = b_RefH + k;
1771            Data->bRefV = b_RefV + k;
1772            Data->bRefHV = b_RefHV + k;
1773            Data->RefCU = f_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
1774            Data->RefCV = f_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
1775            Data->b_RefCU = b_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
1776            Data->b_RefCV = b_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
1777    
1778            k = Data->qpel ? 4 : 2;
1779            Data->max_dx = k * (pParam->width - x * 16);
1780            Data->max_dy = k * (pParam->height - y * 16);
1781            Data->min_dx = -k * (16 + x * 16);
1782            Data->min_dy = -k * (16 + y * 16);
1783    
1784            Data->referencemv = Data->qpel ? b_mb->qmvs : b_mb->mvs;
1785            Data->qpel_precision = 0;
1786    
1787            for (k = 0; k < 4; k++) {
1788                    pMB->mvs[k].x = Data->directmvF[k].x = ((TRB * Data->referencemv[k].x) / TRD);
1789                    pMB->b_mvs[k].x = Data->directmvB[k].x = ((TRB - TRD) * Data->referencemv[k].x) / TRD;
1790                    pMB->mvs[k].y = Data->directmvF[k].y = ((TRB * Data->referencemv[k].y) / TRD);
1791                    pMB->b_mvs[k].y = Data->directmvB[k].y = ((TRB - TRD) * Data->referencemv[k].y) / TRD;
1792    
1793                    if ( (pMB->b_mvs[k].x > Data->max_dx) | (pMB->b_mvs[k].x < Data->min_dx)
1794                            | (pMB->b_mvs[k].y > Data->max_dy) | (pMB->b_mvs[k].y < Data->min_dy) ) {
1795    
1796                            *best_sad = 256*4096; // in that case, we won't use direct mode
1797                            pMB->mode = MODE_DIRECT; // just to make sure it doesn't say "MODE_DIRECT_NONE_MV"
1798                            pMB->b_mvs[0].x = pMB->b_mvs[0].y = 0;
1799                            return 256*4096;
1800                    }
1801                    if (b_mb->mode != MODE_INTER4V) {
1802                            pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mvs[0];
1803                            pMB->b_mvs[1] = pMB->b_mvs[2] = pMB->b_mvs[3] = pMB->b_mvs[0];
1804                            Data->directmvF[1] = Data->directmvF[2] = Data->directmvF[3] = Data->directmvF[0];
1805                            Data->directmvB[1] = Data->directmvB[2] = Data->directmvB[3] = Data->directmvB[0];
1806                            break;
1807                    }
1808            }
1809    
1810            CheckCandidate = b_mb->mode == MODE_INTER4V ? CheckCandidateDirect : CheckCandidateDirectno4v;
1811    
1812            CheckCandidate(0, 0, 255, &k, Data);
1813    
1814    // initial (fast) skip decision
1815            if (*Data->iMinSAD < pMB->quant * INITIAL_SKIP_THRESH * (2 + Data->chroma?1:0)) {
1816                    //possible skip
1817                    if (Data->chroma) {
1818                            pMB->mode = MODE_DIRECT_NONE_MV;
1819                            return *Data->iMinSAD; // skip.
1820                    } else {
1821                            SkipDecisionB(pCur, f_Ref, b_Ref, pMB, x, y, Data);
1822                            if (pMB->mode == MODE_DIRECT_NONE_MV) return *Data->iMinSAD; // skip.
1823                    }
1824            }
1825    
1826  // the median prediction might be even better than mv16          skip_sad = *Data->iMinSAD;
1827    
1828          if (!MVequal(pmv[0], startMV))  //      DIRECT MODE DELTA VECTOR SEARCH.
1829                  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
1830    
1831  // (0,0) if needed          if (MotionFlags & PMV_USESQUARES16) MainSearchPtr = SquareSearch;
1832          if (!MVzero(pmv[0]))                  else if (MotionFlags & PMV_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1833                  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;  
1834    
1835            MainSearchPtr(0, 0, Data, 255);
1836    
1837  /* 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.  
 */  
1838    
1839          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.  
 */  
1840    
1841          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */          if (Data->qpel || b_mb->mode == MODE_INTER4V) pMB->mode = MODE_DIRECT;
1842            else pMB->mode = MODE_DIRECT_NO4V; //for faster compensation
1843    
1844  /* 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);  
1845    
1846          if (iSAD < iMinSAD) {          for (k = 0; k < 4; k++) {
1847                  *currMV = newMV;                  pMB->mvs[k].x = Data->directmvF[k].x + Data->currentMV->x;
1848                  iMinSAD = iSAD;                  pMB->b_mvs[k].x = (     (Data->currentMV->x == 0)
1849                                                            ? Data->directmvB[k].x
1850                                                            :pMB->mvs[k].x - Data->referencemv[k].x);
1851                    pMB->mvs[k].y = (Data->directmvF[k].y + Data->currentMV->y);
1852                    pMB->b_mvs[k].y = ((Data->currentMV->y == 0)
1853                                                            ? Data->directmvB[k].y
1854                                                            : pMB->mvs[k].y - Data->referencemv[k].y);
1855                    if (Data->qpel) {
1856                            pMB->qmvs[k].x = pMB->mvs[k].x; pMB->mvs[k].x /= 2;
1857                            pMB->b_qmvs[k].x = pMB->b_mvs[k].x; pMB->b_mvs[k].x /= 2;
1858                            pMB->qmvs[k].y = pMB->mvs[k].y; pMB->mvs[k].y /= 2;
1859                            pMB->b_qmvs[k].y = pMB->b_mvs[k].y; pMB->b_mvs[k].y /= 2;
1860          }          }
1861    
1862          if (MotionFlags & PMV_EXTSEARCH8) {                  if (b_mb->mode != MODE_INTER4V) {
1863  /* extended: search (up to) two more times: orignal prediction and (0,0) */                          pMB->mvs[3] = pMB->mvs[2] = pMB->mvs[1] = pMB->mvs[0];
1864                            pMB->b_mvs[3] = pMB->b_mvs[2] = pMB->b_mvs[1] = pMB->b_mvs[0];
1865                  if (!(MVequal(pmv[0], backupMV))) {                          pMB->qmvs[3] = pMB->qmvs[2] = pMB->qmvs[1] = pMB->qmvs[0];
1866                          iSAD =                          pMB->b_qmvs[3] = pMB->b_qmvs[2] = pMB->b_qmvs[1] = pMB->b_qmvs[0];
1867                                  (*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;  
1868                          }                          }
1869                  }                  }
1870            return skip_sad;
1871    }
1872    
1873    static void
1874    SearchInterpolate(const IMAGE * const f_Ref,
1875                                    const uint8_t * const f_RefH,
1876                                    const uint8_t * const f_RefV,
1877                                    const uint8_t * const f_RefHV,
1878                                    const IMAGE * const b_Ref,
1879                                    const uint8_t * const b_RefH,
1880                                    const uint8_t * const b_RefV,
1881                                    const uint8_t * const b_RefHV,
1882                                    const IMAGE * const pCur,
1883                                    const int x, const int y,
1884                                    const uint32_t fcode,
1885                                    const uint32_t bcode,
1886                                    const uint32_t MotionFlags,
1887                                    const MBParam * const pParam,
1888                                    const VECTOR * const f_predMV,
1889                                    const VECTOR * const b_predMV,
1890                                    MACROBLOCK * const pMB,
1891                                    int32_t * const best_sad,
1892                                    SearchData * const fData)
1893    
1894    {
1895    
1896                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {          int iDirection, i, j;
1897                          iSAD =          SearchData bData;
1898                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
1899                                                                    iMinSAD, &newMV, pmv, min_dx, max_dx, min_dy,          fData->qpel_precision = 0;
1900                                                                    max_dy, iEdgedWidth, iDiamondSize, iFcode,          memcpy(&bData, fData, sizeof(SearchData)); //quick copy of common data
1901                                                                    iQuant, iFound);          *fData->iMinSAD = 4096*256;
1902            bData.currentMV++; bData.currentQMV++;
1903            fData->iFcode = bData.bFcode = fcode; fData->bFcode = bData.iFcode = bcode;
1904    
1905            i = (x + y * fData->iEdgedWidth) * 16;
1906            bData.bRef = fData->Ref = f_Ref->y + i;
1907            bData.bRefH = fData->RefH = f_RefH + i;
1908            bData.bRefV = fData->RefV = f_RefV + i;
1909            bData.bRefHV = fData->RefHV = f_RefHV + i;
1910            bData.Ref = fData->bRef = b_Ref->y + i;
1911            bData.RefH = fData->bRefH = b_RefH + i;
1912            bData.RefV = fData->bRefV = b_RefV + i;
1913            bData.RefHV = fData->bRefHV = b_RefHV + i;
1914            bData.b_RefCU = fData->RefCU = f_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
1915            bData.b_RefCV = fData->RefCV = f_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
1916            bData.RefCU = fData->b_RefCU = b_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
1917            bData.RefCV = fData->b_RefCV = b_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
1918    
1919    
1920            bData.bpredMV = fData->predMV = *f_predMV;
1921            fData->bpredMV = bData.predMV = *b_predMV;
1922            fData->currentMV[0] = fData->currentMV[2];
1923    
1924            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);
1925            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);
1926    
1927            if (fData->currentMV[0].x > fData->max_dx) fData->currentMV[0].x = fData->max_dx;
1928            if (fData->currentMV[0].x < fData->min_dx) fData->currentMV[0].x = fData->min_dx;
1929            if (fData->currentMV[0].y > fData->max_dy) fData->currentMV[0].y = fData->max_dy;
1930            if (fData->currentMV[0].y < fData->min_dy) fData->currentMV[0].y = fData->min_dy;
1931    
1932            if (fData->currentMV[1].x > bData.max_dx) fData->currentMV[1].x = bData.max_dx;
1933            if (fData->currentMV[1].x < bData.min_dx) fData->currentMV[1].x = bData.min_dx;
1934            if (fData->currentMV[1].y > bData.max_dy) fData->currentMV[1].y = bData.max_dy;
1935            if (fData->currentMV[1].y < bData.min_dy) fData->currentMV[1].y = bData.min_dy;
1936    
1937                          if (iSAD < iMinSAD) {          CheckCandidateInt(fData->currentMV[0].x, fData->currentMV[0].y, 255, &iDirection, fData);
1938                                  *currMV = newMV;  
1939                                  iMinSAD = iSAD;  //diamond
1940            do {
1941                    iDirection = 255;
1942                    // forward MV moves
1943                    i = fData->currentMV[0].x; j = fData->currentMV[0].y;
1944    
1945                    CheckCandidateInt(i + 1, j, 0, &iDirection, fData);
1946                    CheckCandidateInt(i, j + 1, 0, &iDirection, fData);
1947                    CheckCandidateInt(i - 1, j, 0, &iDirection, fData);
1948                    CheckCandidateInt(i, j - 1, 0, &iDirection, fData);
1949    
1950                    // backward MV moves
1951                    i = fData->currentMV[1].x; j = fData->currentMV[1].y;
1952                    fData->currentMV[2] = fData->currentMV[0];
1953                    CheckCandidateInt(i + 1, j, 0, &iDirection, &bData);
1954                    CheckCandidateInt(i, j + 1, 0, &iDirection, &bData);
1955                    CheckCandidateInt(i - 1, j, 0, &iDirection, &bData);
1956                    CheckCandidateInt(i, j - 1, 0, &iDirection, &bData);
1957    
1958            } while (!(iDirection));
1959    
1960    //qpel refinement
1961            if (fData->qpel) {
1962                    if (*fData->iMinSAD > *best_sad + 500) return;
1963                    CheckCandidate = CheckCandidateInt;
1964                    fData->qpel_precision = bData.qpel_precision = 1;
1965                    get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 16, pParam->width, pParam->height, fcode, 1, 0);
1966                    get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode, 1, 0);
1967                    fData->currentQMV[2].x = fData->currentQMV[0].x = 2 * fData->currentMV[0].x;
1968                    fData->currentQMV[2].y = fData->currentQMV[0].y = 2 * fData->currentMV[0].y;
1969                    fData->currentQMV[1].x = 2 * fData->currentMV[1].x;
1970                    fData->currentQMV[1].y = 2 * fData->currentMV[1].y;
1971                    SubpelRefine(fData);
1972                    if (*fData->iMinSAD > *best_sad + 300) return;
1973                    fData->currentQMV[2] = fData->currentQMV[0];
1974                    SubpelRefine(&bData);
1975            }
1976    
1977            *fData->iMinSAD += (2+3) * fData->lambda16; // two bits are needed to code interpolate mode.
1978    
1979            if (*fData->iMinSAD < *best_sad) {
1980                    *best_sad = *fData->iMinSAD;
1981                    pMB->mvs[0] = fData->currentMV[0];
1982                    pMB->b_mvs[0] = fData->currentMV[1];
1983                    pMB->mode = MODE_INTERPOLATE;
1984                    if (fData->qpel) {
1985                            pMB->qmvs[0] = fData->currentQMV[0];
1986                            pMB->b_qmvs[0] = fData->currentQMV[1];
1987                            pMB->pmvs[1].x = pMB->qmvs[0].x - f_predMV->x;
1988                            pMB->pmvs[1].y = pMB->qmvs[0].y - f_predMV->y;
1989                            pMB->pmvs[0].x = pMB->b_qmvs[0].x - b_predMV->x;
1990                            pMB->pmvs[0].y = pMB->b_qmvs[0].y - b_predMV->y;
1991                    } else {
1992                            pMB->pmvs[1].x = pMB->mvs[0].x - f_predMV->x;
1993                            pMB->pmvs[1].y = pMB->mvs[0].y - f_predMV->y;
1994                            pMB->pmvs[0].x = pMB->b_mvs[0].x - b_predMV->x;
1995                            pMB->pmvs[0].y = pMB->b_mvs[0].y - b_predMV->y;
1996                          }                          }
1997                  }                  }
1998          }          }
1999    
2000  /* Step 10: The motion vector is chosen according to the block corresponding to MinSAD.  void
2001     By performing an optional local half-pixel search, we can refine this result even further.  MotionEstimationBVOP(MBParam * const pParam,
2002  */                                           FRAMEINFO * const frame,
2003                                             const int32_t time_bp,
2004                                             const int32_t time_pp,
2005                                             // forward (past) reference
2006                                             const MACROBLOCK * const f_mbs,
2007                                             const IMAGE * const f_ref,
2008                                             const IMAGE * const f_refH,
2009                                             const IMAGE * const f_refV,
2010                                             const IMAGE * const f_refHV,
2011                                             // backward (future) reference
2012                                             const FRAMEINFO * const b_reference,
2013                                             const IMAGE * const b_ref,
2014                                             const IMAGE * const b_refH,
2015                                             const IMAGE * const b_refV,
2016                                             const IMAGE * const b_refHV)
2017    {
2018            uint32_t i, j;
2019            int32_t best_sad;
2020            uint32_t skip_sad;
2021            int f_count = 0, b_count = 0, i_count = 0, d_count = 0, n_count = 0;
2022            const MACROBLOCK * const b_mbs = b_reference->mbs;
2023    
2024            VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/
2025    
2026            const int32_t TRB = time_pp - time_bp;
2027            const int32_t TRD = time_pp;
2028    
2029    // some pre-inintialized data for the rest of the search
2030    
2031            SearchData Data;
2032            int32_t iMinSAD;
2033            VECTOR currentMV[3];
2034            VECTOR currentQMV[3];
2035            int32_t temp[8];
2036            memset(&Data, 0, sizeof(SearchData));
2037            Data.iEdgedWidth = pParam->edged_width;
2038            Data.currentMV = currentMV; Data.currentQMV = currentQMV;
2039            Data.iMinSAD = &iMinSAD;
2040            Data.lambda16 = lambda_vec16[frame->quant];
2041            Data.qpel = pParam->vol_flags & XVID_QUARTERPEL;
2042            Data.rounding = 0;
2043            Data.chroma = frame->motion_flags & PMV_CHROMA8;
2044            Data.temp = temp;
2045    
2046            Data.RefQ = f_refV->u; // a good place, also used in MC (for similar purpose)
2047            // note: i==horizontal, j==vertical
2048            for (j = 0; j < pParam->mb_height; j++) {
2049    
2050                    f_predMV = b_predMV = zeroMV;   /* prediction is reset at left boundary */
2051    
2052    PMVfast8_Terminate_with_Refine:                  for (i = 0; i < pParam->mb_width; i++) {
2053          if (MotionFlags & PMV_HALFPELREFINE8)   // perform final half-pel step                          MACROBLOCK * const pMB = frame->mbs + i + j * pParam->mb_width;
2054                  iMinSAD =                          const MACROBLOCK * const b_mb = b_mbs + i + j * pParam->mb_width;
2055                          Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
2056                                                          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 */
2057                                                          iFcode, iQuant, iEdgedWidth);                          if (b_reference->coding_type != S_VOP)
2058                                    if (b_mb->mode == MODE_NOT_CODED) {
2059                                            pMB->mode = MODE_NOT_CODED;
2060                                            continue;
2061                                    }
2062    
2063                            Data.Cur = frame->image.y + (j * Data.iEdgedWidth + i) * 16;
2064                            Data.CurU = frame->image.u + (j * Data.iEdgedWidth/2 + i) * 8;
2065                            Data.CurV = frame->image.v + (j * Data.iEdgedWidth/2 + i) * 8;
2066                            pMB->quant = frame->quant;
2067    
2068    /* direct search comes first, because it (1) checks for SKIP-mode
2069            and (2) sets very good predictions for forward and backward search */
2070                            skip_sad = SearchDirect(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2071                                                                            b_ref, b_refH->y, b_refV->y, b_refHV->y,
2072                                                                            &frame->image,
2073                                                                            i, j,
2074                                                                            frame->motion_flags,
2075                                                                            TRB, TRD,
2076                                                                            pParam,
2077                                                                            pMB, b_mb,
2078                                                                            &best_sad,
2079                                                                            &Data);
2080    
2081    PMVfast8_Terminate_without_Refine:                          if (pMB->mode == MODE_DIRECT_NONE_MV) { n_count++; continue; }
2082          currPMV->x = currMV->x - pmv[0].x;  
2083          currPMV->y = currMV->y - pmv[0].y;                          // forward search
2084                            SearchBF(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2085                                                    &frame->image, i, j,
2086                                                    frame->motion_flags,
2087                                                    frame->fcode, pParam,
2088                                                    pMB, &f_predMV, &best_sad,
2089                                                    MODE_FORWARD, &Data);
2090    
2091          return iMinSAD;                          // backward search
2092                            SearchBF(b_ref, b_refH->y, b_refV->y, b_refHV->y,
2093                                                    &frame->image, i, j,
2094                                                    frame->motion_flags,
2095                                                    frame->bcode, pParam,
2096                                                    pMB, &b_predMV, &best_sad,
2097                                                    MODE_BACKWARD, &Data);
2098    
2099                            // interpolate search comes last, because it uses data from forward and backward as prediction
2100                            SearchInterpolate(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2101                                                    b_ref, b_refH->y, b_refV->y, b_refHV->y,
2102                                                    &frame->image,
2103                                                    i, j,
2104                                                    frame->fcode, frame->bcode,
2105                                                    frame->motion_flags,
2106                                                    pParam,
2107                                                    &f_predMV, &b_predMV,
2108                                                    pMB, &best_sad,
2109                                                    &Data);
2110    
2111    // final skip decision
2112                            if ( (skip_sad < frame->quant * MAX_SAD00_FOR_SKIP * 2)
2113                                            && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) )
2114                                    SkipDecisionB(&frame->image, f_ref, b_ref, pMB, i, j, &Data);
2115    
2116                            switch (pMB->mode) {
2117                                    case MODE_FORWARD:
2118                                            f_count++;
2119                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2120                                            break;
2121                                    case MODE_BACKWARD:
2122                                            b_count++;
2123                                            b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2124                                            break;
2125                                    case MODE_INTERPOLATE:
2126                                            i_count++;
2127                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2128                                            b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2129                                            break;
2130                                    case MODE_DIRECT:
2131                                    case MODE_DIRECT_NO4V:
2132                                            d_count++;
2133                                    default:
2134                                            break;
2135                            }
2136                    }
2137            }
2138  }  }
2139    
2140  int32_t  static __inline void
2141  EPZSSearch16(const uint8_t * const pRef,  MEanalyzeMB (   const uint8_t * const pRef,
2142                           const uint8_t * const pRefH,                                  const uint8_t * const pCur,
                          const uint8_t * const pRefV,  
                          const uint8_t * const pRefHV,  
                          const IMAGE * const pCur,  
2143                           const int x,                           const int x,
2144                           const int y,                           const int y,
                          const uint32_t MotionFlags,  
                          const uint32_t iQuant,  
                          const uint32_t iFcode,  
2145                           const MBParam * const pParam,                           const MBParam * const pParam,
2146                           const MACROBLOCK * const pMBs,                                  MACROBLOCK * const pMBs,
2147                           const MACROBLOCK * const prevMBs,                                  SearchData * const Data)
                          VECTOR * const currMV,  
                          VECTOR * const currPMV)  
2148  {  {
         const ui