[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 348, Sun Jul 28 17:10:39 2002 UTC branches/dev-api-4/xvidcore/src/motion/motion_est.c revision 1138, Sat Sep 6 11:24:50 2003 UTC
# Line 1  Line 1 
1  /**************************************************************************  /*****************************************************************************
2   *   *
3   *      XVID MPEG-4 VIDEO CODEC   *      XVID MPEG-4 VIDEO CODEC
4   *      motion estimation   *  - Motion Estimation related code  -
5   *   *
6   *      This program is an implementation of a part of one or more MPEG-4   *  Copyright(C) 2002 Christoph Lampert <gruel@web.de>
7   *      Video tools as specified in ISO/IEC 14496-2 standard.  Those intending   *               2002 Michael Militzer <michael@xvid.org>
8   *      to use this software module in hardware or software products are   *               2002-2003 Radoslaw Czyz <xvid@syskin.cjb.net>
  *      advised that its use may infringe existing patents or copyrights, and  
  *      any such use would be at such party's own risk.  The original  
  *      developer of this software module and his/her company, and subsequent  
  *      editors and their companies, will have no liability for use of this  
  *      software or modifications or derivatives thereof.  
9   *   *
10   *      This program is free software; you can redistribute it and/or modify   *      This program is free software; you can redistribute it and/or modify
11   *      it under the terms of the GNU General Public License as published by   *      it under the terms of the GNU General Public License as published by
# Line 24  Line 19 
19   *   *
20   *      You should have received a copy of the GNU General Public License   *      You should have received a copy of the GNU General Public License
21   *      along with this program; if not, write to the Free Software   *      along with this program; if not, write to the Free Software
22   *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
23   *   *
24   *************************************************************************/   * $Id: motion_est.c,v 1.58.2.35 2003-09-06 11:24:50 Isibaar Exp $
   
 /**************************************************************************  
  *  
  *  Modifications:  
  *  
  *      01.05.2002      updated MotionEstimationBVOP  
  *      25.04.2002 partial prevMB conversion  
  *  22.04.2002 remove some compile warning by chenm001 <chenm001@163.com>  
  *  14.04.2002 added MotionEstimationBVOP()  
  *  02.04.2002 add EPZS(^2) as ME algorithm, use PMV_USESQUARES to choose between  
  *             EPZS and EPZS^2  
  *  08.02.2002 split up PMVfast into three routines: PMVFast, PMVFast_MainLoop  
  *             PMVFast_Refine to support multiple searches with different start points  
  *  07.01.2002 uv-block-based interpolation  
  *  06.01.2002 INTER/INTRA-decision is now done before any SEARCH8 (speedup)  
  *             changed INTER_BIAS to 150 (as suggested by suxen_drol)  
  *             removed halfpel refinement step in PMVfastSearch8 + quality=5  
  *             added new quality mode = 6 which performs halfpel refinement  
  *             filesize difference between quality 5 and 6 is smaller than 1%  
  *             (Isibaar)  
  *  31.12.2001 PMVfastSearch16 and PMVfastSearch8 (gruel)  
  *  30.12.2001 get_range/MotionSearchX simplified; blue/green bug fix  
  *  22.12.2001 commented best_point==99 check  
  *  19.12.2001 modified get_range (purple bug fix)  
  *  15.12.2001 moved pmv displacement from mbprediction  
  *  02.12.2001 motion estimation/compensation split (Isibaar)  
  *  16.11.2001 rewrote/tweaked search algorithms; pross@cs.rmit.edu.au  
  *  10.11.2001 support for sad16/sad8 functions  
  *  28.08.2001 reactivated MODE_INTER4V for EXT_MODE  
  *  24.08.2001 removed MODE_INTER4V_Q, disabled MODE_INTER4V for EXT_MODE  
  *  22.08.2001 added MODE_INTER4V_Q  
  *  20.08.2001 added pragma to get rid of internal compiler error with VC6  
  *             idea by Cyril. Thanks.  
25   *   *
26   *  Michael Militzer <isibaar@videocoding.de>   ****************************************************************************/
  *  
  **************************************************************************/  
27    
28  #include <assert.h>  #include <assert.h>
29  #include <stdio.h>  #include <stdio.h>
30  #include <stdlib.h>  #include <stdlib.h>
31    #include <string.h>     /* memcpy */
32    #include <math.h>       /* lrint */
33    
34  #include "../encoder.h"  #include "../encoder.h"
35  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
36  #include "../prediction/mbprediction.h"  #include "../prediction/mbprediction.h"
37  #include "../global.h"  #include "../global.h"
38  #include "../utils/timer.h"  #include "../utils/timer.h"
39    #include "../image/interpolate8x8.h"
40    #include "motion_est.h"
41  #include "motion.h"  #include "motion.h"
42  #include "sad.h"  #include "sad.h"
43    #include "gmc.h"
44    #include "../utils/emms.h"
45    #include "../dct/fdct.h"
46    
47    /*****************************************************************************
48     * Modified rounding tables -- declared in motion.h
49     * Original tables see ISO spec tables 7-6 -> 7-9
50     ****************************************************************************/
51    
52    const uint32_t roundtab[16] =
53    {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
54    
55    /* K = 4 */
56    const uint32_t roundtab_76[16] =
57    { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1 };
58    
59    /* K = 2 */
60    const uint32_t roundtab_78[8] =
61    { 0, 0, 1, 1, 0, 0, 0, 1  };
62    
63    /* K = 1 */
64    const uint32_t roundtab_79[4] =
65    { 0, 1, 0, 0 };
66    
67    #define INITIAL_SKIP_THRESH     (10)
68    #define FINAL_SKIP_THRESH       (50)
69    #define MAX_SAD00_FOR_SKIP      (20)
70    #define MAX_CHROMA_SAD_FOR_SKIP (22)
71    
72    #define CHECK_CANDIDATE(X,Y,D) { \
73    CheckCandidate((X),(Y), data, (D) ); }
74    
75    
76    /*****************************************************************************
77     * Code
78     ****************************************************************************/
79    
80    static __inline uint32_t
81    d_mv_bits(int x, int y, const VECTOR pred, const uint32_t iFcode, const int qpel, const int rrv)
82    {
83            int bits;
84            const int q = (1 << (iFcode - 1)) - 1;
85    
86            x <<= qpel;
87  static int32_t lambda_vec16[32] =       /* rounded values for lambda param for weight of motion bits as in modified H.26L */          y <<= qpel;
88  { 0, (int) (1.00235 + 0.5), (int) (1.15582 + 0.5), (int) (1.31976 + 0.5),          if (rrv) { x = RRV_MV_SCALEDOWN(x); y = RRV_MV_SCALEDOWN(y); }
89                  (int) (1.49591 + 0.5), (int) (1.68601 + 0.5),  
90          (int) (1.89187 + 0.5), (int) (2.11542 + 0.5), (int) (2.35878 + 0.5),          x -= pred.x;
91                  (int) (2.62429 + 0.5), (int) (2.91455 + 0.5),          bits = (x != 0 ? iFcode:0);
92          (int) (3.23253 + 0.5), (int) (3.58158 + 0.5), (int) (3.96555 + 0.5),          x = abs(x);
93                  (int) (4.38887 + 0.5), (int) (4.85673 + 0.5),          x += q;
94          (int) (5.37519 + 0.5), (int) (5.95144 + 0.5), (int) (6.59408 + 0.5),          x >>= (iFcode - 1);
95                  (int) (7.31349 + 0.5), (int) (8.12242 + 0.5),          bits += mvtab[x];
96          (int) (9.03669 + 0.5), (int) (10.0763 + 0.5), (int) (11.2669 + 0.5),  
97                  (int) (12.6426 + 0.5), (int) (14.2493 + 0.5),          y -= pred.y;
98          (int) (16.1512 + 0.5), (int) (18.442 + 0.5), (int) (21.2656 + 0.5),          bits += (y != 0 ? iFcode:0);
99                  (int) (24.8580 + 0.5), (int) (29.6436 + 0.5),          y = abs(y);
100          (int) (36.4949 + 0.5)          y += q;
101            y >>= (iFcode - 1);
102            bits += mvtab[y];
103    
104            return bits;
105    }
106    
107    static int32_t ChromaSAD2(const int fx, const int fy, const int bx, const int by,
108                                                            const SearchData * const data)
109    {
110            int sad;
111            const uint32_t stride = data->iEdgedWidth/2;
112            uint8_t *f_refu, *f_refv, *b_refu, *b_refv;
113    
114            const INTERPOLATE8X8_PTR interpolate8x8_halfpel[] = {
115                    NULL,
116                    interpolate8x8_halfpel_v,
117                    interpolate8x8_halfpel_h,
118                    interpolate8x8_halfpel_hv
119  };  };
120    
121  static int32_t *lambda_vec8 = lambda_vec16;     /* same table for INTER and INTER4V for now */          int offset = (fx>>1) + (fy>>1)*stride;
122            int filter = ((fx & 1) << 1) | (fy & 1);
123    
124            if (filter != 0) {
125                    f_refu = data->RefQ;
126                    f_refv = data->RefQ + 8;
127                    interpolate8x8_halfpel[filter](f_refu, data->RefP[4] + offset, stride, data->rounding);
128                    interpolate8x8_halfpel[filter](f_refv, data->RefP[5] + offset, stride, data->rounding);
129            } else {
130                    f_refu = (uint8_t*)data->RefP[4] + offset;
131                    f_refv = (uint8_t*)data->RefP[5] + offset;
132            }
133    
134            offset = (bx>>1) + (by>>1)*stride;
135            filter = ((bx & 1) << 1) | (by & 1);
136    
137  // mv.length table          if (filter != 0) {
138  static const uint32_t mvtab[33] = {                  b_refu = data->RefQ + 16;
139          1, 2, 3, 4, 6, 7, 7, 7,                  b_refv = data->RefQ + 24;
140          9, 9, 9, 10, 10, 10, 10, 10,                  interpolate8x8_halfpel[filter](b_refu, data->b_RefP[4] + offset, stride, data->rounding);
141          10, 10, 10, 10, 10, 10, 10, 10,                  interpolate8x8_halfpel[filter](b_refv, data->b_RefP[5] + offset, stride, data->rounding);
142          10, 11, 11, 11, 11, 11, 11, 12, 12          } else {
143  };                  b_refu = (uint8_t*)data->b_RefP[4] + offset;
144                    b_refv = (uint8_t*)data->b_RefP[5] + offset;
145            }
146    
147            sad = sad8bi(data->CurU, b_refu, f_refu, stride);
148            sad += sad8bi(data->CurV, b_refv, f_refv, stride);
149    
150  static __inline uint32_t          return sad;
151  mv_bits(int32_t component,  }
152                  const uint32_t iFcode)  
153    static int32_t
154    ChromaSAD(const int dx, const int dy, const SearchData * const data)
155  {  {
156          if (component == 0)          int sad;
157                  return 1;          const uint32_t stride = data->iEdgedWidth/2;
158            int offset = (dx>>1) + (dy>>1)*stride;
159            int next = 1;
160    
161          if (component < 0)          if (dx == data->temp[5] && dy == data->temp[6]) return data->temp[7]; /* it has been checked recently */
162                  component = -component;          data->temp[5] = dx; data->temp[6] = dy; /* backup */
163    
164          if (iFcode == 1) {          switch (((dx & 1) << 1) | (dy & 1))     {
165                  if (component > 32)                  case 0:
166                          component = 32;                          sad = sad8(data->CurU, data->RefP[4] + offset, stride);
167                            sad += sad8(data->CurV, data->RefP[5] + offset, stride);
168                            break;
169                    case 1:
170                            next = stride;
171                    case 2:
172                            sad = sad8bi(data->CurU, data->RefP[4] + offset, data->RefP[4] + offset + next, stride);
173                            sad += sad8bi(data->CurV, data->RefP[5] + offset, data->RefP[5] + offset + next, stride);
174                            break;
175                    default:
176                            interpolate8x8_halfpel_hv(data->RefQ, data->RefP[4] + offset, stride, data->rounding);
177                            sad = sad8(data->CurU, data->RefQ, stride);
178    
179                  return mvtab[component] + 1;                          interpolate8x8_halfpel_hv(data->RefQ, data->RefP[5] + offset, stride, data->rounding);
180                            sad += sad8(data->CurV, data->RefQ, stride);
181                            break;
182          }          }
183            data->temp[7] = sad; /* backup, part 2 */
184          component += (1 << (iFcode - 1)) - 1;          return sad;
         component >>= (iFcode - 1);  
   
         if (component > 32)  
                 component = 32;  
   
         return mvtab[component] + 1 + iFcode - 1;  
185  }  }
186    
187    static __inline const uint8_t *
188  static __inline uint32_t  GetReferenceB(const int x, const int y, const uint32_t dir, const SearchData * const data)
 calc_delta_16(const int32_t dx,  
                           const int32_t dy,  
                           const uint32_t iFcode,  
                           const uint32_t iQuant)  
189  {  {
190          return NEIGH_TEND_16X16 * lambda_vec16[iQuant] * (mv_bits(dx, iFcode) +          /* dir : 0 = forward, 1 = backward */
191                                                                                                            mv_bits(dy, iFcode));          const uint8_t *const *const direction = ( dir == 0 ? data->RefP : data->b_RefP );
192            const int picture = ((x&1)<<1) | (y&1);
193            const int offset = (x>>1) + (y>>1)*data->iEdgedWidth;
194            return direction[picture] + offset;
195  }  }
196    
197  static __inline uint32_t  /* this is a simpler copy of GetReferenceB, but as it's __inline anyway, we can keep the two separate */
198  calc_delta_8(const int32_t dx,  static __inline const uint8_t *
199                           const int32_t dy,  GetReference(const int x, const int y, const SearchData * const data)
                          const uint32_t iFcode,  
                          const uint32_t iQuant)  
200  {  {
201          return NEIGH_TEND_8X8 * lambda_vec8[iQuant] * (mv_bits(dx, iFcode) +          const int picture = ((x&1)<<1) | (y&1);
202                                                                                                     mv_bits(dy, iFcode));          const int offset = (x>>1) + (y>>1)*data->iEdgedWidth;
203            return data->RefP[picture] + offset;
204  }  }
205    
206  bool  static uint8_t *
207  MotionEstimation(MBParam * const pParam,  Interpolate8x8qpel(const int x, const int y, const uint32_t block, const uint32_t dir, const SearchData * const data)
                                  FRAMEINFO * const current,  
                                  FRAMEINFO * const reference,  
                                  const IMAGE * const pRefH,  
                                  const IMAGE * const pRefV,  
                                  const IMAGE * const pRefHV,  
                                  const uint32_t iLimit)  
208  {  {
209          const uint32_t iWcount = pParam->mb_width;          /* create or find a qpel-precision reference picture; return pointer to it */
210          const uint32_t iHcount = pParam->mb_height;          uint8_t * Reference = data->RefQ + 16*dir;
211          MACROBLOCK *const pMBs = current->mbs;          const uint32_t iEdgedWidth = data->iEdgedWidth;
212          MACROBLOCK *const prevMBs = reference->mbs;          const uint32_t rounding = data->rounding;
213          const IMAGE *const pCurrent = &current->image;          const int halfpel_x = x/2;
214          const IMAGE *const pRef = &reference->image;          const int halfpel_y = y/2;
215            const uint8_t *ref1, *ref2, *ref3, *ref4;
216    
217            ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
218            ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
219            switch( ((x&1)<<1) + (y&1) ) {
220            case 3: /* x and y in qpel resolution - the "corners" (top left/right and */
221                            /* bottom left/right) during qpel refinement */
222                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
223                    ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
224                    ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
225                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
226                    ref3 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
227                    ref4 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
228                    interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
229                    break;
230    
231          static const VECTOR zeroMV = { 0, 0 };          case 1: /* x halfpel, y qpel - top or bottom during qpel refinement */
232          VECTOR predMV;                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
233                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
234                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
235                    break;
236    
237          int32_t x, y;          case 2: /* x qpel, y halfpel - left or right during qpel refinement */
238          int32_t iIntra = 0;                  ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
239          VECTOR pmv;                  ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
240                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
241                    break;
242    
243          if (sadInit)          default: /* pure halfpel position */
244                  (*sadInit) ();                  return (uint8_t *) ref1;
245    
246          for (y = 0; y < iHcount; y++)   {          }
247                  for (x = 0; x < iWcount; x ++)  {          return Reference;
248    }
249    
250                          MACROBLOCK *const pMB = &pMBs[x + y * iWcount];  static uint8_t *
251    Interpolate16x16qpel(const int x, const int y, const uint32_t dir, const SearchData * const data)
252    {
253            /* create or find a qpel-precision reference picture; return pointer to it */
254            uint8_t * Reference = data->RefQ + 16*dir;
255            const uint32_t iEdgedWidth = data->iEdgedWidth;
256            const uint32_t rounding = data->rounding;
257            const int halfpel_x = x/2;
258            const int halfpel_y = y/2;
259            const uint8_t *ref1, *ref2, *ref3, *ref4;
260    
261                          predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);          ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
262            switch( ((x&1)<<1) + (y&1) ) {
263            case 3:
264                    /*
265                     * x and y in qpel resolution - the "corners" (top left/right and
266                     * bottom left/right) during qpel refinement
267                     */
268                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
269                    ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
270                    ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
271                    interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
272                    interpolate8x8_avg4(Reference+8, ref1+8, ref2+8, ref3+8, ref4+8, iEdgedWidth, rounding);
273                    interpolate8x8_avg4(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, ref3+8*iEdgedWidth, ref4+8*iEdgedWidth, iEdgedWidth, rounding);
274                    interpolate8x8_avg4(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, ref3+8*iEdgedWidth+8, ref4+8*iEdgedWidth+8, iEdgedWidth, rounding);
275                    break;
276    
277                          pMB->sad16 =          case 1: /* x halfpel, y qpel - top or bottom during qpel refinement */
278                                  SEARCH16(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent,                  ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
279                                                   x, y, predMV.x, predMV.y, predMV.x, predMV.y,                  interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
280                                                   current->motion_flags, current->quant,                  interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
281                                                   current->fcode, pParam, pMBs, prevMBs, &pMB->mv16,                  interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
282                                                   &pMB->pmvs[0]);                  interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
283                    break;
284    
285                          if (0 < (pMB->sad16 - MV16_INTER_BIAS)) {          case 2: /* x qpel, y halfpel - left or right during qpel refinement */
286                                  int32_t deviation;                  ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
287                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
288                    interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
289                    interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
290                    interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
291                    break;
292    
                                 deviation =  
                                         dev16(pCurrent->y + x * 16 + y * 16 * pParam->edged_width,  
                                                   pParam->edged_width);  
293    
294                                  if (deviation < (pMB->sad16 - MV16_INTER_BIAS)) {          default: /* pure halfpel position */
295                                          pMB->mode = MODE_INTRA;                  return (uint8_t *) ref1;
296                                          pMB->mv16 = pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] =          }
297                                                  pMB->mvs[3] = zeroMV;          return Reference;
298                                          pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] =  }
                                                 pMB->sad8[3] = 0;  
299    
300                                          iIntra++;  /* CHECK_CANDIATE FUNCTIONS START */
                                         if (iIntra >= iLimit)  
                                                 return 1;  
301    
302                                          continue;  static void
303    CheckCandidate16(const int x, const int y, const SearchData * const data, const int Direction)
304    {
305            int xc, yc;
306            const uint8_t * Reference;
307            VECTOR * current;
308            int32_t sad; uint32_t t;
309    
310            if ( (x > data->max_dx) || (x < data->min_dx)
311                    || (y > data->max_dy) || (y < data->min_dy) ) return;
312    
313            if (!data->qpel_precision) {
314                    Reference = GetReference(x, y, data);
315                    current = data->currentMV;
316                    xc = x; yc = y;
317            } else { /* x and y are in 1/4 precision */
318                    Reference = Interpolate16x16qpel(x, y, 0, data);
319                    xc = x/2; yc = y/2; /* for chroma sad */
320                    current = data->currentQMV;
321                                  }                                  }
322    
323            sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);
324            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
325    
326            sad += (data->lambda16 * t * sad)>>10;
327            data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
328    
329            if (data->chroma && sad < data->iMinSAD[0])
330                    sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
331                                                            (yc >> 1) + roundtab_79[yc & 0x3], data);
332    
333            if (sad < data->iMinSAD[0]) {
334                    data->iMinSAD[0] = sad;
335                    current[0].x = x; current[0].y = y;
336                    *data->dir = Direction;
337                          }                          }
338    
339                          pmv = pMB->pmvs[0];          if (data->temp[0] < data->iMinSAD[1]) {
340                          if (current->global_flags & XVID_INTER4V)                  data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; }
341                                  if ((!(current->global_flags & XVID_LUMIMASKING) ||          if (data->temp[1] < data->iMinSAD[2]) {
342                                           pMB->dquant == NO_CHANGE)) {                  data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }
343                                          int32_t sad8 = IMV16X16 * current->quant;          if (data->temp[2] < data->iMinSAD[3]) {
344                    data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
345                                          if (sad8 < pMB->sad16) {          if (data->temp[3] < data->iMinSAD[4]) {
346                                                  sad8 += pMB->sad8[0] =                  data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x, 2 * y,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[0],  
                                                                         &pMB->pmvs[0]);  
                                         }  
                                         if (sad8 < pMB->sad16) {  
   
                                                 predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 1);  
                                                 sad8 += pMB->sad8[1] =  
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x + 1, 2 * y,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[1],  
                                                                         &pMB->pmvs[1]);  
                                         }  
                                         if (sad8 < pMB->sad16) {  
                                                 predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 2);  
                                                 sad8 += pMB->sad8[2] =  
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x, 2 * y + 1,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs, &pMB->mvs[2],  
                                                                         &pMB->pmvs[2]);  
                                         }  
                                         if (sad8 < pMB->sad16) {  
                                                 predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 3);  
                                                 sad8 += pMB->sad8[3] =  
                                                         SEARCH8(pRef->y, pRefH->y, pRefV->y, pRefHV->y,  
                                                                         pCurrent, 2 * x + 1, 2 * y + 1,  
                                                                         pMB->mv16.x, pMB->mv16.y, predMV.x, predMV.y,  
                                                                         current->motion_flags,  
                                                                         current->quant, current->fcode, pParam,  
                                                                         pMBs, prevMBs,  
                                                                         &pMB->mvs[3],  
                                                                         &pMB->pmvs[3]);  
347                                          }                                          }
348    
349                                          /* decide: MODE_INTER or MODE_INTER4V  static void
350                                             mpeg4:   if (sad8 < pMB->sad16 - nb/2+1) use_inter4v  CheckCandidate16_subpel(const int x, const int y, const SearchData * const data, const int Direction)
351                                           */  {
352            int xc, yc;
353            const uint8_t *Reference;
354            VECTOR *current, *current2;
355            int32_t sad; uint32_t t;
356    
357                                          if (sad8 < pMB->sad16) {          if ( (x > data->max_dx) || (x < data->min_dx)
358                                                  pMB->mode = MODE_INTER4V;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
359                                                  pMB->sad8[0] *= 4;  
360                                                  pMB->sad8[1] *= 4;          if (!data->qpel_precision) {
361                                                  pMB->sad8[2] *= 4;                  Reference = GetReference(x, y, data);
362                                                  pMB->sad8[3] *= 4;                  current = data->currentMV;
363                                                  continue;                  current2 = data->currentMV2;
364                    xc = x; yc = y;
365            } else { /* x and y are in 1/4 precision */
366                    Reference = Interpolate16x16qpel(x, y, 0, data);
367                    xc = x/2; yc = y/2; /* for chroma sad */
368                    current = data->currentQMV;
369                    current2 = data->currentQMV2;
370                                          }                                          }
371    
372            sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);
373            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
374    
375            sad += (data->lambda16 * t * sad)>>10;
376            data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
377    
378            if (data->chroma && sad < data->iMinSAD[0])
379                    sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
380                                                            (yc >> 1) + roundtab_79[yc & 0x3], data);
381    
382            if (data->temp[0] < data->iMinSAD[1]) {
383                    data->iMinSAD[1] = data->temp[0]; current[1].x = x; current[1].y = y; }
384            if (data->temp[1] < data->iMinSAD[2]) {
385                    data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }
386            if (data->temp[2] < data->iMinSAD[3]) {
387                    data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
388            if (data->temp[3] < data->iMinSAD[4]) {
389                    data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
390    
391            if (sad < data->iMinSAD[0]) {
392                    *(data->iMinSAD2) = *(data->iMinSAD);
393                    current2->x = current->x; current2->y = current->y;
394    
395                    data->iMinSAD[0] = sad;
396                    current[0].x = x; current[0].y = y;
397                    *data->dir = Direction;
398                    return;
399                                  }                                  }
400    
401                          pMB->mode = MODE_INTER;          if (sad < *(data->iMinSAD2)) {
402                          pMB->pmvs[0] = pmv;     /* pMB->pmvs[1] = pMB->pmvs[2] = pMB->pmvs[3]  are not needed for INTER */                  *(data->iMinSAD2) = sad;
403                          pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mv16;                  current2->x = x; current2->y = y;
404                          pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] =                  *data->dir = Direction;
                                 pMB->sad16;  
405                          }                          }
406                          }                          }
407    
408          return 0;  static void
409    CheckCandidate8(const int x, const int y, const SearchData * const data, const int Direction)
410    {
411            int32_t sad; uint32_t t;
412            const uint8_t * Reference;
413            VECTOR * current;
414    
415            if ( (x > data->max_dx) || (x < data->min_dx)
416                    || (y > data->max_dy) || (y < data->min_dy) ) return;
417    
418            if (!data->qpel_precision) {
419                    Reference = GetReference(x, y, data);
420                    current = data->currentMV;
421            } else { /* x and y are in 1/4 precision */
422                    Reference = Interpolate8x8qpel(x, y, 0, 0, data);
423                    current = data->currentQMV;
424            }
425    
426            sad = sad8(data->Cur, Reference, data->iEdgedWidth);
427            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
428    
429            sad += (data->lambda8 * t * (sad+NEIGH_8X8_BIAS))>>10;
430    
431            if (sad < *(data->iMinSAD)) {
432                    *(data->iMinSAD) = sad;
433                    current->x = x; current->y = y;
434                    *data->dir = Direction;
435            }
436  }  }
437    
438    static void
439    CheckCandidate32(const int x, const int y, const SearchData * const data, const int Direction)
440    {
441            uint32_t t;
442            const uint8_t * Reference;
443            int sad;
444    
445            if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || /* non-zero even value */
446                    (x > data->max_dx) || (x < data->min_dx)
447                    || (y > data->max_dy) || (y < data->min_dy) ) return;
448    
449            Reference = GetReference(x, y, data);
450            t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);
451    
452  #define CHECK_MV16_ZERO {\          sad = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp);
453    if ( (0 <= max_dx) && (0 >= min_dx) \  
454      && (0 <= max_dy) && (0 >= min_dy) ) \          sad += (data->lambda16 * t * sad) >> 10;
455    { \          data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
456      iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0, 0 , iEdgedWidth), iEdgedWidth, MV_MAX_ERROR); \  
457      iSAD += calc_delta_16(-center_x, -center_y, (uint8_t)iFcode, iQuant);\          if (sad < data->iMinSAD[0]) {
458      if (iSAD < iMinSAD) \                  data->iMinSAD[0] = sad;
459      {  iMinSAD=iSAD; currMV->x=0; currMV->y=0; }  }     \                  data->currentMV[0].x = x; data->currentMV[0].y = y;
460  }                  *data->dir = Direction;
   
 #define NOCHECK_MV16_CANDIDATE(X,Y) { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } \  
 }  
   
 #define CHECK_MV16_CANDIDATE(X,Y) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV16_CANDIDATE_DIR(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \  
 }  
   
 #define CHECK_MV16_CANDIDATE_FOUND(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad16( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, X, Y, iEdgedWidth),iEdgedWidth, iMinSAD); \  
     iSAD += calc_delta_16((X) - center_x, (Y) - center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \  
 }  
   
   
 #define CHECK_MV8_ZERO {\  
   iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, 0, 0 , iEdgedWidth), iEdgedWidth); \  
   iSAD += calc_delta_8(-center_x, -center_y, (uint8_t)iFcode, iQuant);\  
   if (iSAD < iMinSAD) \  
   { iMinSAD=iSAD; currMV->x=0; currMV->y=0; } \  
 }  
   
 #define NOCHECK_MV8_CANDIDATE(X,Y) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } \  
 }  
   
 #define CHECK_MV8_CANDIDATE(X,Y) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV8_CANDIDATE_DIR(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); } } \  
 }  
   
 #define CHECK_MV8_CANDIDATE_FOUND(X,Y,D) { \  
   if ( ((X) <= max_dx) && ((X) >= min_dx) \  
     && ((Y) <= max_dy) && ((Y) >= min_dy) ) \  
   { \  
     iSAD = sad8( cur, get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 8, (X), (Y), iEdgedWidth),iEdgedWidth); \  
     iSAD += calc_delta_8((X)-center_x, (Y)-center_y, (uint8_t)iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iDirection=(D); iFound=0; } } \  
461  }  }
462    
463  /* too slow and not fully functional at the moment */          if (data->temp[0] < data->iMinSAD[1]) {
464  /*                  data->iMinSAD[1] = data->temp[0]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
465  int32_t ZeroSearch16(          if (data->temp[1] < data->iMinSAD[2]) {
466                                          const uint8_t * const pRef,                  data->iMinSAD[2] = data->temp[1]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
467                                          const uint8_t * const pRefH,          if (data->temp[2] < data->iMinSAD[3]) {
468                                          const uint8_t * const pRefV,                  data->iMinSAD[3] = data->temp[2]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
469                                          const uint8_t * const pRefHV,          if (data->temp[3] < data->iMinSAD[4]) {
470                                          const IMAGE * const pCur,                  data->iMinSAD[4] = data->temp[3]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
471                                          const int x, const int y,  }
472                                          const uint32_t MotionFlags,  
473                                          const uint32_t iQuant,  static void
474                                          const uint32_t iFcode,  CheckCandidate16no4v(const int x, const int y, const SearchData * const data, const int Direction)
                                         MBParam * const pParam,  
                                         const MACROBLOCK * const pMBs,  
                                         const MACROBLOCK * const prevMBs,  
                                         VECTOR * const currMV,  
                                         VECTOR * const currPMV)  
475  {  {
476          const int32_t iEdgedWidth = pParam->edged_width;          int32_t sad, xc, yc;
477          const uint8_t * cur = pCur->y + x*16 + y*16*iEdgedWidth;          const uint8_t * Reference;
478          int32_t iSAD;          uint32_t t;
479          VECTOR pred;          VECTOR * current;
480    
481            if ( (x > data->max_dx) || ( x < data->min_dx)
482                    || (y > data->max_dy) || (y < data->min_dy) ) return;
483    
484          pred = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);          if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; /* non-zero even value */
485    
486          iSAD = sad16( cur,          if (data->qpel_precision) { /* x and y are in 1/4 precision */
487                  get_ref(pRef, pRefH, pRefV, pRefHV, x, y, 16, 0,0, iEdgedWidth),                  Reference = Interpolate16x16qpel(x, y, 0, data);
488                  iEdgedWidth, MV_MAX_ERROR);                  current = data->currentQMV;
489          if (iSAD <= iQuant * 96)                  xc = x/2; yc = y/2;
490                  iSAD -= MV16_00_BIAS;          } else {
491                    Reference = GetReference(x, y, data);
492                    current = data->currentMV;
493                    xc = x; yc = y;
494            }
495            t = d_mv_bits(x, y, data->predMV, data->iFcode,
496                                            data->qpel^data->qpel_precision, data->rrv);
497    
498          currMV->x = 0;          sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);
499          currMV->y = 0;          sad += (data->lambda16 * t * sad)>>10;
         currPMV->x = -pred.x;  
         currPMV->y = -pred.y;  
500    
501          return iSAD;          if (data->chroma && sad < *data->iMinSAD)
502                    sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
503                                                            (yc >> 1) + roundtab_79[yc & 0x3], data);
504    
505            if (sad < *(data->iMinSAD)) {
506                    *(data->iMinSAD) = sad;
507                    current->x = x; current->y = y;
508                    *data->dir = Direction;
509            }
510  }  }
511    
512    static void
513    CheckCandidate16I(const int x, const int y, const SearchData * const data, const int Direction)
514    {
515            int sad;
516    //      int xc, yc;
517            const uint8_t * Reference;
518    //      VECTOR * current;
519    
520            if ( (x > data->max_dx) || ( x < data->min_dx)
521                    || (y > data->max_dy) || (y < data->min_dy) ) return;
522    
523            Reference = GetReference(x, y, data);
524    //      xc = x; yc = y;
525    
526            sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);
527    //      sad += d_mv_bits(x, y, data->predMV, data->iFcode, 0, 0);
528    
529    /*      if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
530                                                                                    (yc >> 1) + roundtab_79[yc & 0x3], data);
531  */  */
532    
533  int32_t          if (sad < data->iMinSAD[0]) {
534  Diamond16_MainSearch(const uint8_t * const pRef,                  data->iMinSAD[0] = sad;
535                                           const uint8_t * const pRefH,                  data->currentMV[0].x = x; data->currentMV[0].y = y;
536                                           const uint8_t * const pRefV,                  *data->dir = Direction;
                                          const uint8_t * const pRefHV,  
                                          const uint8_t * const cur,  
                                          const int x,  
                                          const int y,  
                                    const int start_x,  
                                    const int start_y,  
                                    int iMinSAD,  
                                    VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                          const int32_t min_dx,  
                                          const int32_t max_dx,  
                                          const int32_t min_dy,  
                                          const int32_t max_dy,  
                                          const int32_t iEdgedWidth,  
                                          const int32_t iDiamondSize,  
                                          const int32_t iFcode,  
                                          const int32_t iQuant,  
                                          int iFound)  
 {  
 /* Do a diamond search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iDirectionBackup;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */  
   
         CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  
         CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
   
         if (iDirection) {  
                 while (!iFound) {  
                         iFound = 1;  
                         backupMV = *currMV;  
                         iDirectionBackup = iDirection;  
   
                         if (iDirectionBackup != 2)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                    backupMV.y, 1);  
                         if (iDirectionBackup != 1)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                    backupMV.y, 2);  
                         if (iDirectionBackup != 4)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x,  
                                                                                    backupMV.y - iDiamondSize, 3);  
                         if (iDirectionBackup != 3)  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x,  
                                                                                    backupMV.y + iDiamondSize, 4);  
537                  }                  }
         } else {  
                 currMV->x = start_x;  
                 currMV->y = start_y;  
538          }          }
539          return iMinSAD;  
540    static void
541    CheckCandidate32I(const int x, const int y, const SearchData * const data, const int Direction)
542    {
543            /* maximum speed - for P/B/I decision */
544            int32_t sad;
545    
546            if ( (x > data->max_dx) || (x < data->min_dx)
547                    || (y > data->max_dy) || (y < data->min_dy) ) return;
548    
549            sad = sad32v_c(data->Cur, data->RefP[0] + x + y*((int)data->iEdgedWidth),
550                                            data->iEdgedWidth, data->temp);
551    
552            if (sad < *(data->iMinSAD)) {
553                    *(data->iMinSAD) = sad;
554                    data->currentMV[0].x = x; data->currentMV[0].y = y;
555                    *data->dir = Direction;
556  }  }
557            if (data->temp[0] < data->iMinSAD[1]) {
558                    data->iMinSAD[1] = data->temp[0]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
559            if (data->temp[1] < data->iMinSAD[2]) {
560                    data->iMinSAD[2] = data->temp[1]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
561            if (data->temp[2] < data->iMinSAD[3]) {
562                    data->iMinSAD[3] = data->temp[2]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
563            if (data->temp[3] < data->iMinSAD[4]) {
564                    data->iMinSAD[4] = data->temp[3]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
565    
566  int32_t  }
 Square16_MainSearch(const uint8_t * const pRef,  
                                         const uint8_t * const pRefH,  
                                         const uint8_t * const pRefV,  
                                         const uint8_t * const pRefHV,  
                                         const uint8_t * const cur,  
                                         const int x,  
                                         const int y,  
                                    const int start_x,  
                                    const int start_y,  
                                    int iMinSAD,  
                                    VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                         const int32_t min_dx,  
                                         const int32_t max_dx,  
                                         const int32_t min_dy,  
                                         const int32_t max_dy,  
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
                                         const int32_t iFcode,  
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a square search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full square pattern, and new parts for all following diamonds */  
   
 /*   new direction are extra, so 1-4 is normal diamond  
       537  
       1*2  
       648  
 */  
567    
568          CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  static void
569          CHECK_MV16_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  CheckCandidateInt(const int xf, const int yf, const SearchData * const data, const int Direction)
570          CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  {
571          CHECK_MV16_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);          int32_t sad, xb, yb, xcf, ycf, xcb, ycb;
572            uint32_t t;
573          CHECK_MV16_CANDIDATE_DIR(backupMV.x - iDiamondSize,          const uint8_t *ReferenceF, *ReferenceB;
574                                                           backupMV.y - iDiamondSize, 5);          VECTOR *current;
         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;  
575    
576                          switch (iDirection) {          if ((xf > data->max_dx) || (xf < data->min_dx) ||
577                          case 1:                  (yf > data->max_dy) || (yf < data->min_dy))
578                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                  return;
                                                                                    backupMV.y, 1);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 break;  
                         case 2:  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
579    
580                          case 3:          if (!data->qpel_precision) {
581                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,                  ReferenceF = GetReference(xf, yf, data);
582                                                                                   4);                  xb = data->currentMV[1].x; yb = data->currentMV[1].y;
583                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                  ReferenceB = GetReferenceB(xb, yb, 1, data);
584                                                                                   backupMV.y - iDiamondSize, 7);                  current = data->currentMV;
585                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                  xcf = xf; ycf = yf;
586                                                                                   backupMV.y + iDiamondSize, 8);                  xcb = xb; ycb = yb;
587                                  break;          } else {
588                    ReferenceF = Interpolate16x16qpel(xf, yf, 0, data);
589                    xb = data->currentQMV[1].x; yb = data->currentQMV[1].y;
590                    current = data->currentQMV;
591                    ReferenceB = Interpolate16x16qpel(xb, yb, 1, data);
592                    xcf = xf/2; ycf = yf/2;
593                    xcb = xb/2; ycb = yb/2;
594            }
595    
596                          case 4:          t = d_mv_bits(xf, yf, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0)
597                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,                   + d_mv_bits(xb, yb, data->bpredMV, data->iFcode, data->qpel^data->qpel_precision, 0);
                                                                                  3);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 break;  
   
                         case 5:  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,  
                                                                                  1);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 break;  
   
                         case 6:  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
   
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
598    
599                                  break;          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
600            sad += (data->lambda16 * t * sad)>>10;
601    
602                          case 7:          if (data->chroma && sad < *data->iMinSAD)
603                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                  sad += ChromaSAD2((xcf >> 1) + roundtab_79[xcf & 0x3],
604                                                                                     backupMV.y, 1);                                                          (ycf >> 1) + roundtab_79[ycf & 0x3],
605                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,                                                          (xcb >> 1) + roundtab_79[xcb & 0x3],
606                                                                                   4);                                                          (ycb >> 1) + roundtab_79[ycb & 0x3], data);
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
607    
608                          case 8:          if (sad < *(data->iMinSAD)) {
609                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                  *(data->iMinSAD) = sad;
610                                                                                   2);                  current->x = xf; current->y = yf;
611                                  CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,                  *data->dir = Direction;
                                                                                  4);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
                         default:  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,  
                                                                                  1);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
   
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV16_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
612                          }                          }
613                  }                  }
614    
615    static void
616    CheckCandidateDirect(const int x, const int y, const SearchData * const data, const int Direction)
617    {
618            int32_t sad = 0, xcf = 0, ycf = 0, xcb = 0, ycb = 0;
619            uint32_t k;
620            const uint8_t *ReferenceF;
621            const uint8_t *ReferenceB;
622            VECTOR mvs, b_mvs;
623    
624            if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return;
625    
626            for (k = 0; k < 4; k++) {
627                    mvs.x = data->directmvF[k].x + x;
628                    b_mvs.x = ((x == 0) ?
629                            data->directmvB[k].x
630                            : mvs.x - data->referencemv[k].x);
631    
632                    mvs.y = data->directmvF[k].y + y;
633                    b_mvs.y = ((y == 0) ?
634                            data->directmvB[k].y
635                            : mvs.y - data->referencemv[k].y);
636    
637                    if ((mvs.x > data->max_dx)   || (mvs.x < data->min_dx)   ||
638                            (mvs.y > data->max_dy)   || (mvs.y < data->min_dy)   ||
639                            (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx) ||
640                            (b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) )
641                            return;
642    
643                    if (data->qpel) {
644                            xcf += mvs.x/2; ycf += mvs.y/2;
645                            xcb += b_mvs.x/2; ycb += b_mvs.y/2;
646          } else {          } else {
647                  currMV->x = start_x;                          xcf += mvs.x; ycf += mvs.y;
648                  currMV->y = start_y;                          xcb += b_mvs.x; ycb += b_mvs.y;
649                            mvs.x *= 2; mvs.y *= 2; /* we move to qpel precision anyway */
650                            b_mvs.x *= 2; b_mvs.y *= 2;
651          }          }
652          return iMinSAD;  
653                    ReferenceF = Interpolate8x8qpel(mvs.x, mvs.y, k, 0, data);
654                    ReferenceB = Interpolate8x8qpel(b_mvs.x, b_mvs.y, k, 1, data);
655    
656                    sad += sad8bi(data->Cur + 8*(k&1) + 8*(k>>1)*(data->iEdgedWidth),
657                                                    ReferenceF, ReferenceB, data->iEdgedWidth);
658                    if (sad > *(data->iMinSAD)) return;
659  }  }
660    
661            sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
662    
663  int32_t          if (data->chroma && sad < *data->iMinSAD)
664  Full16_MainSearch(const uint8_t * const pRef,                  sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
665                                    const uint8_t * const pRefH,                                                          (ycf >> 3) + roundtab_76[ycf & 0xf],
666                                    const uint8_t * const pRefV,                                                          (xcb >> 3) + roundtab_76[xcb & 0xf],
667                                    const uint8_t * const pRefHV,                                                          (ycb >> 3) + roundtab_76[ycb & 0xf], data);
                                   const uint8_t * const cur,  
                                   const int x,  
                                   const int y,  
                                    const int start_x,  
                                    const int start_y,  
                                    int iMinSAD,  
                                    VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                   const int32_t min_dx,  
                                   const int32_t max_dx,  
                                   const int32_t min_dy,  
                                   const int32_t max_dy,  
                                   const int32_t iEdgedWidth,  
                                   const int32_t iDiamondSize,  
                                   const int32_t iFcode,  
                                   const int32_t iQuant,  
                                   int iFound)  
 {  
         int32_t iSAD;  
         int32_t dx, dy;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
         for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)  
                 for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)  
                         NOCHECK_MV16_CANDIDATE(dx, dy);  
668    
669          return iMinSAD;          if (sad < *(data->iMinSAD)) {
670                    *(data->iMinSAD) = sad;
671                    data->currentMV->x = x; data->currentMV->y = y;
672                    *data->dir = Direction;
673            }
674  }  }
675    
676  int32_t  static void
677  AdvDiamond16_MainSearch(const uint8_t * const pRef,  CheckCandidateDirectno4v(const int x, const int y, const SearchData * const data, const int Direction)
                                                 const uint8_t * const pRefH,  
                                                 const uint8_t * const pRefV,  
                                                 const uint8_t * const pRefHV,  
                                                 const uint8_t * const cur,  
                                                 const int x,  
                                                 const int y,  
                                            int start_x,  
                                            int start_y,  
                                            int iMinSAD,  
                                            VECTOR * const currMV,  
                                            const int center_x,  
                                            const int center_y,  
                                                 const int32_t min_dx,  
                                                 const int32_t max_dx,  
                                                 const int32_t min_dy,  
                                                 const int32_t max_dy,  
                                                 const int32_t iEdgedWidth,  
                                                 const int32_t iDiamondSize,  
                                                 const int32_t iFcode,  
                                                 const int32_t iQuant,  
                                                 int iDirection)  
678  {  {
679            int32_t sad, xcf, ycf, xcb, ycb;
680            const uint8_t *ReferenceF;
681            const uint8_t *ReferenceB;
682            VECTOR mvs, b_mvs;
683    
684          int32_t iSAD;          if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return;
685    
686  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */          mvs.x = data->directmvF[0].x + x;
687            b_mvs.x = ((x == 0) ?
688                    data->directmvB[0].x
689                    : mvs.x - data->referencemv[0].x);
690    
691          if (iDirection) {          mvs.y = data->directmvF[0].y + y;
692                  CHECK_MV16_CANDIDATE(start_x - iDiamondSize, start_y);          b_mvs.y = ((y == 0) ?
693                  CHECK_MV16_CANDIDATE(start_x + iDiamondSize, start_y);                  data->directmvB[0].y
694                  CHECK_MV16_CANDIDATE(start_x, start_y - iDiamondSize);                  : mvs.y - data->referencemv[0].y);
                 CHECK_MV16_CANDIDATE(start_x, start_y + iDiamondSize);  
         } else {  
                 int bDirection = 1 + 2 + 4 + 8;  
695    
696                  do {          if ( (mvs.x > data->max_dx) || (mvs.x < data->min_dx)
697                          iDirection = 0;                  || (mvs.y > data->max_dy) || (mvs.y < data->min_dy)
698                          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)                  || (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx)
699                                  CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);                  || (b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) ) return;
700    
701                          if (bDirection & 2)          if (data->qpel) {
702                                  CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);                  xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2);
703                    xcb = 4*(b_mvs.x/2); ycb = 4*(b_mvs.y/2);
704                    ReferenceF = Interpolate16x16qpel(mvs.x, mvs.y, 0, data);
705                    ReferenceB = Interpolate16x16qpel(b_mvs.x, b_mvs.y, 1, data);
706            } else {
707                    xcf = 4*mvs.x; ycf = 4*mvs.y;
708                    xcb = 4*b_mvs.x; ycb = 4*b_mvs.y;
709                    ReferenceF = GetReference(mvs.x, mvs.y, data);
710                    ReferenceB = GetReferenceB(b_mvs.x, b_mvs.y, 1, data);
711            }
712    
713                          if (bDirection & 4)          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
714                                  CHECK_MV16_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);          sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
715    
716                          if (bDirection & 8)          if (data->chroma && sad < *data->iMinSAD)
717                                  CHECK_MV16_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);                  sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
718                                                            (ycf >> 3) + roundtab_76[ycf & 0xf],
719                                                            (xcb >> 3) + roundtab_76[xcb & 0xf],
720                                                            (ycb >> 3) + roundtab_76[ycb & 0xf], data);
721    
722                          /* now we're doing diagonal checks near our candidate */          if (sad < *(data->iMinSAD)) {
723                    *(data->iMinSAD) = sad;
724                    data->currentMV->x = x; data->currentMV->y = y;
725                    *data->dir = Direction;
726            }
727    }
728    
729                          if (iDirection)         //checking if anything found  
730                          {  static void
731                                  bDirection = iDirection;  CheckCandidateRD16(const int x, const int y, const SearchData * const data, const int Direction)
                                 iDirection = 0;  
                                 start_x = currMV->x;  
                                 start_y = currMV->y;  
                                 if (bDirection & 3)     //our candidate is left or right  
732                                  {                                  {
733                                          CHECK_MV16_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);  
734                                          CHECK_MV16_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);          int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;
735                                  } else                  // what remains here is up or down          int32_t rd = 0;
736            VECTOR * current;
737            const uint8_t * ptr;
738            int i, cbp = 0, t, xc, yc;
739    
740            if ( (x > data->max_dx) || (x < data->min_dx)
741                    || (y > data->max_dy) || (y < data->min_dy) ) return;
742    
743            if (!data->qpel_precision) {
744                    ptr = GetReference(x, y, data);
745                    current = data->currentMV;
746                    xc = x; yc = y;
747            } else { /* x and y are in 1/4 precision */
748                    ptr = Interpolate16x16qpel(x, y, 0, data);
749                    current = data->currentQMV;
750                    xc = x/2; yc = y/2;
751            }
752    
753            for(i = 0; i < 4; i++) {
754                    int s = 8*((i&1) + (i>>1)*data->iEdgedWidth);
755                    transfer_8to16subro(in, data->Cur + s, ptr + s, data->iEdgedWidth);
756                    rd += data->temp[i] = Block_CalcBits(coeff, in, data->dctSpace + 128, data->iQuant, data->quant_type, &cbp, i);
757            }
758    
759            rd += t = BITS_MULT*d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
760    
761            if (data->temp[0] + t < data->iMinSAD[1]) {
762                    data->iMinSAD[1] = data->temp[0] + t; current[1].x = x; current[1].y = y; data->cbp[1] = (data->cbp[1]&~32) | (cbp&32); }
763            if (data->temp[1] < data->iMinSAD[2]) {
764                    data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; data->cbp[1] = (data->cbp[1]&~16) | (cbp&16); }
765            if (data->temp[2] < data->iMinSAD[3]) {
766                    data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; data->cbp[1] = (data->cbp[1]&~8) | (cbp&8); }
767            if (data->temp[3] < data->iMinSAD[4]) {
768                    data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; data->cbp[1] = (data->cbp[1]&~4) | (cbp&4); }
769    
770            rd += BITS_MULT*xvid_cbpy_tab[15-(cbp>>2)].len;
771    
772            if (rd >= data->iMinSAD[0]) return;
773    
774            /* chroma */
775            xc = (xc >> 1) + roundtab_79[xc & 0x3];
776            yc = (yc >> 1) + roundtab_79[yc & 0x3];
777    
778            /* chroma U */
779            ptr = interpolate8x8_switch2(data->RefQ, data->RefP[4], 0, 0, xc, yc, data->iEdgedWidth/2, data->rounding);
780            transfer_8to16subro(in, data->CurU, ptr, data->iEdgedWidth/2);
781            rd += Block_CalcBits(coeff, in, data->dctSpace + 128, data->iQuant, data->quant_type, &cbp, 4);
782            if (rd >= data->iMinSAD[0]) return;
783    
784            /* chroma V */
785            ptr = interpolate8x8_switch2(data->RefQ, data->RefP[5], 0, 0, xc, yc, data->iEdgedWidth/2, data->rounding);
786            transfer_8to16subro(in, data->CurV, ptr, data->iEdgedWidth/2);
787            rd += Block_CalcBits(coeff, in, data->dctSpace + 128, data->iQuant, data->quant_type, &cbp, 5);
788    
789            rd += BITS_MULT*mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len;
790    
791            if (rd < data->iMinSAD[0]) {
792                    data->iMinSAD[0] = rd;
793                    current[0].x = x; current[0].y = y;
794                    *data->dir = Direction;
795                    *data->cbp = cbp;
796            }
797    }
798    
799    static void
800    CheckCandidateRD8(const int x, const int y, const SearchData * const data, const int Direction)
801                                  {                                  {
802                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);  
803                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);          int16_t *in = data->dctSpace, *coeff = data->dctSpace + 64;
804            int32_t rd;
805            VECTOR * current;
806            const uint8_t * ptr;
807            int cbp = 0;
808    
809            if ( (x > data->max_dx) || (x < data->min_dx)
810                    || (y > data->max_dy) || (y < data->min_dy) ) return;
811    
812            if (!data->qpel_precision) {
813                    ptr = GetReference(x, y, data);
814                    current = data->currentMV;
815            } else { /* x and y are in 1/4 precision */
816                    ptr = Interpolate8x8qpel(x, y, 0, 0, data);
817                    current = data->currentQMV;
818                                  }                                  }
819    
820                                  if (iDirection) {          transfer_8to16subro(in, data->Cur, ptr, data->iEdgedWidth);
821                                          bDirection += iDirection;          rd = Block_CalcBits(coeff, in, data->dctSpace + 128, data->iQuant, data->quant_type, &cbp, 5);
822                                          start_x = currMV->x;          rd += BITS_MULT*d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
823                                          start_y = currMV->y;  
824            if (rd < data->iMinSAD[0]) {
825                    *data->cbp = cbp;
826                    data->iMinSAD[0] = rd;
827                    current[0].x = x; current[0].y = y;
828                    *data->dir = Direction;
829                                  }                                  }
830                          } else                          //about to quit, eh? not so fast....  }
831    
832    /* CHECK_CANDIATE FUNCTIONS END */
833    
834    /* MAINSEARCH FUNCTIONS START */
835    
836    static void
837    AdvDiamondSearch(int x, int y, const SearchData * const data, int bDirection, CheckFunc * const CheckCandidate)
838                          {                          {
839    
840    /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
841    
842            unsigned int * const iDirection = data->dir;
843    
844            for(;;) { /* forever */
845                    *iDirection = 0;
846                    if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
847                    if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);
848                    if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);
849                    if (bDirection & 8) CHECK_CANDIDATE(x, y + iDiamondSize, 8);
850    
851                    /* now we're doing diagonal checks near our candidate */
852    
853                    if (*iDirection) {              /* if anything found */
854                            bDirection = *iDirection;
855                            *iDirection = 0;
856                            x = data->currentMV->x; y = data->currentMV->y;
857                            if (bDirection & 3) {   /* our candidate is left or right */
858                                    CHECK_CANDIDATE(x, y + iDiamondSize, 8);
859                                    CHECK_CANDIDATE(x, y - iDiamondSize, 4);
860                            } else {                        /* what remains here is up or down */
861                                    CHECK_CANDIDATE(x + iDiamondSize, y, 2);
862                                    CHECK_CANDIDATE(x - iDiamondSize, y, 1);
863                            }
864    
865                            if (*iDirection) {
866                                    bDirection += *iDirection;
867                                    x = data->currentMV->x; y = data->currentMV->y;
868                            }
869                    } else {                                /* about to quit, eh? not so fast.... */
870                                  switch (bDirection) {                                  switch (bDirection) {
871                                  case 2:                                  case 2:
872                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
873                                                                                           start_y - iDiamondSize, 2 + 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
874                                          break;                                          break;
875                                  case 1:                                  case 1:
876                                    CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
877                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
                                                                                          start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y + iDiamondSize, 1 + 8);  
878                                          break;                                          break;
879                                  case 2 + 4:                                  case 2 + 4:
880                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
881                                                                                           start_y - iDiamondSize, 1 + 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
882                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                                                                          start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
883                                          break;                                          break;
884                                  case 4:                                  case 4:
885                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
886                                                                                           start_y - iDiamondSize, 2 + 4);                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y - iDiamondSize, 1 + 4);  
887                                          break;                                          break;
888                                  case 8:                                  case 8:
889                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
890                                                                                           start_y + iDiamondSize, 2 + 8);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y + iDiamondSize, 1 + 8);  
891                                          break;                                          break;
892                                  case 1 + 4:                                  case 1 + 4:
893                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
894                                                                                           start_y + iDiamondSize, 1 + 8);                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
895                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
                                                                                          start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y - iDiamondSize, 2 + 4);  
896                                          break;                                          break;
897                                  case 2 + 8:                                  case 2 + 8:
898                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
899                                                                                           start_y - iDiamondSize, 1 + 4);                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
900                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                                                                          start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
901                                          break;                                          break;
902                                  case 1 + 8:                                  case 1 + 8:
903                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
904                                                                                           start_y - iDiamondSize, 2 + 4);                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
905                                          CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
906                                                                                           start_y + iDiamondSize, 2 + 8);                                  break;
907                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                          default:                /* 1+2+4+8 == we didn't find anything at all */
908                                                                                           start_y + iDiamondSize, 1 + 8);                                  CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1 + 4);
909                                          break;                                  CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1 + 8);
910                                  default:                //1+2+4+8 == we didn't find anything at all                                  CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2 + 4);
911                                          CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,                                  CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2 + 8);
                                                                                          start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                          start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV16_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                          start_y + iDiamondSize, 2 + 8);  
912                                          break;                                          break;
913                                  }                                  }
914                                  if (!iDirection)                          if (!*iDirection) break;                /* ok, the end. really */
915                                          break;          //ok, the end. really                          bDirection = *iDirection;
916                                  else {                          x = data->currentMV->x; y = data->currentMV->y;
917                                          bDirection = iDirection;                  }
918                                          start_x = currMV->x;          }
919                                          start_y = currMV->y;  }
                                 }  
                         }  
                 }  
                 while (1);                              //forever  
         }  
         return iMinSAD;  
 }  
   
 #define CHECK_MV16_F_INTERPOL(X,Y) { \  
   if ( ((X) <= f_max_dx) && ((X) >= f_min_dx) \  
     && ((Y) <= f_max_dy) && ((Y) >= f_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, b_currMV->x, b_currMV->y, iEdgedWidth),   \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16((X) - f_center_x, (Y) - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16(b_currMV->x - b_center_x, b_currMV->y - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; f_currMV->x=(X); f_currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV16_F_INTERPOL_FOUND(X,Y) { \  
   if ( ((X) <= f_max_dx) && ((X) >= f_min_dx) \  
     && ((Y) <= f_max_dy) && ((Y) >= f_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, b_currMV->x, b_currMV->y, iEdgedWidth),   \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16((X) - f_center_x, (Y) - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16(b_currMV->x - b_center_x, b_currMV->y - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; f_currMV->x=(X); f_currMV->y=(Y); iFound=0;} } \  
 }  
   
 #define CHECK_MV16_B_INTERPOL(X,Y) { \  
   if ( ((X) <= b_max_dx) && ((X) >= b_min_dx) \  
     && ((Y) <= b_max_dy) && ((Y) >= b_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, f_currMV->x, f_currMV->y, iEdgedWidth),   \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16(f_currMV->x - f_center_x, f_currMV->y - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16((X) - b_center_x, (Y) - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; b_currMV->x=(X); b_currMV->y=(Y); } } \  
 }  
   
 #define CHECK_MV16_B_INTERPOL_FOUND(X,Y) { \  
   if ( ((X) <= b_max_dx) && ((X) >= b_min_dx) \  
     && ((Y) <= b_max_dy) && ((Y) >= b_min_dy) ) \  
   { \  
     iSAD = sad16bi( cur, \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, x, y, 16, f_currMV->x, f_currMV->y, iEdgedWidth),   \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, x, y, 16, X, Y, iEdgedWidth),       \  
                         iEdgedWidth); \  
     iSAD += calc_delta_16(f_currMV->x - f_center_x, f_currMV->y - f_center_y, (uint8_t)f_iFcode, iQuant);\  
     iSAD += calc_delta_16((X) - b_center_x, (Y) - b_center_y, (uint8_t)b_iFcode, iQuant);\  
     if (iSAD < iMinSAD) \  
     {  iMinSAD=iSAD; b_currMV->x=(X); b_currMV->y=(Y); iFound=0;} } \  
 }  
   
 int32_t  
 Diamond16_InterpolMainSearch(  
                                         const uint8_t * const f_pRef,  
                                          const uint8_t * const f_pRefH,  
                                          const uint8_t * const f_pRefV,  
                                          const uint8_t * const f_pRefHV,  
   
                                          const uint8_t * const cur,  
   
                                         const uint8_t * const b_pRef,  
                                          const uint8_t * const b_pRefH,  
                                          const uint8_t * const b_pRefV,  
                                          const uint8_t * const b_pRefHV,  
920    
921                                           const int x,  static void
922                                           const int y,  SquareSearch(int x, int y, const SearchData * const data, int bDirection, CheckFunc * const CheckCandidate)
923    {
924            unsigned int * const iDirection = data->dir;
925    
926                                     const int f_start_x,          do {
927                                     const int f_start_y,                  *iDirection = 0;
928                                     const int b_start_x,                  if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1+16+64);
929                                     const int b_start_y,                  if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2+32+128);
930                    if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4+16+32);
931                                     int iMinSAD,                  if (bDirection & 8) CHECK_CANDIDATE(x, y + iDiamondSize, 8+64+128);
932                                     VECTOR * const f_currMV,                  if (bDirection & 16) CHECK_CANDIDATE(x - iDiamondSize, y - iDiamondSize, 1+4+16+32+64);
933                                     VECTOR * const b_currMV,                  if (bDirection & 32) CHECK_CANDIDATE(x + iDiamondSize, y - iDiamondSize, 2+4+16+32+128);
934                    if (bDirection & 64) CHECK_CANDIDATE(x - iDiamondSize, y + iDiamondSize, 1+8+16+64+128);
935                                     const int f_center_x,                  if (bDirection & 128) CHECK_CANDIDATE(x + iDiamondSize, y + iDiamondSize, 2+8+32+64+128);
936                                     const int f_center_y,  
937                                     const int b_center_x,                  bDirection = *iDirection;
938                                     const int b_center_y,                  x = data->currentMV->x; y = data->currentMV->y;
939            } while (*iDirection);
940                                      const int32_t f_min_dx,  }
                                         const int32_t f_max_dx,  
                                         const int32_t f_min_dy,  
                                         const int32_t f_max_dy,  
   
                                     const int32_t b_min_dx,  
                                         const int32_t b_max_dx,  
                                         const int32_t b_min_dy,  
                                         const int32_t b_max_dy,  
   
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
   
                                         const int32_t f_iFcode,  
                                         const int32_t b_iFcode,  
   
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a diamond search around given starting point, return SAD of best */  
   
         int32_t iSAD;  
   
         VECTOR f_backupMV;  
         VECTOR b_backupMV;  
   
         f_currMV->x = f_start_x;  
         f_currMV->y = f_start_y;  
         b_currMV->x = b_start_x;  
         b_currMV->y = b_start_y;  
   
         do  
         {  
                 iFound = 1;  
   
                 f_backupMV = *f_currMV;  
   
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x - iDiamondSize, f_backupMV.y);  
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x + iDiamondSize, f_backupMV.y);  
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x, f_backupMV.y - iDiamondSize);  
                 CHECK_MV16_F_INTERPOL_FOUND(f_backupMV.x, f_backupMV.y + iDiamondSize);  
   
                 b_backupMV = *b_currMV;  
   
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x - iDiamondSize, b_backupMV.y);  
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x + iDiamondSize, b_backupMV.y);  
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x, b_backupMV.y - iDiamondSize);  
                 CHECK_MV16_B_INTERPOL_FOUND(b_backupMV.x, b_backupMV.y + iDiamondSize);  
   
         } while (!iFound);  
   
         return iMinSAD;  
 }  
   
 /* Sorry, these MACROS really got too large... I'll turn them into function soon! */  
   
 #define CHECK_MV16_DIRECT_FOUND(X,Y) \  
         if ( (X)>=(-32) && (X)<=(31) && ((Y)>=-32) && ((Y)<=31) ) \  
         { int k;\  
         VECTOR mvs,b_mvs;       \  
         iSAD = 0;\  
         for (k = 0; k < 4; k++) {       \  
                                         mvs.x = (int32_t) ((TRB * directmv[k].x) / TRD + (X));          \  
                     b_mvs.x = (int32_t) (((X) == 0)                                                     \  
                                                                                 ? ((TRB - TRD) * directmv[k].x) / TRD   \  
                                             : mvs.x - directmv[k].x);                           \  
                                                                                                                                                                 \  
                     mvs.y = (int32_t) ((TRB * directmv[k].y) / TRD + (Y));              \  
                         b_mvs.y = (int32_t) (((Y) == 0)                                                         \  
                                                                                 ? ((TRB - TRD) * directmv[k].y) / TRD   \  
                                             : mvs.y - directmv[k].y);                           \  
                                                                                                                                                                 \  
   if ( (mvs.x <= max_dx) && (mvs.x >= min_dx) \  
     && (mvs.y <= max_dy) && (mvs.y >= min_dy)  \  
         && (b_mvs.x <= max_dx) && (b_mvs.x >= min_dx)  \  
     && (b_mvs.y <= max_dy) && (b_mvs.y >= min_dy) ) { \  
             iSAD += sad8bi( cur + 8*(k&1) + 8*(k>>1)*iEdgedWidth,                                                                                                       \  
                         get_ref(f_pRef, f_pRefH, f_pRefV, f_pRefHV, 2*x+(k&1), 2*y+(k>>1), 8, \  
                                         mvs.x, mvs.y, iEdgedWidth),                                                             \  
                         get_ref(b_pRef, b_pRefH, b_pRefV, b_pRefHV, 2*x+(k&1), 2*y+(k>>1), 8, \  
                                         b_mvs.x, b_mvs.y, iEdgedWidth),                                                         \  
                         iEdgedWidth); \  
                 }       \  
         else    \  
                 iSAD = 65535;   \  
         } \  
         iSAD += calc_delta_16((X),(Y), 1, iQuant);\  
         if (iSAD < iMinSAD) \  
             {  iMinSAD=iSAD; currMV->x=(X); currMV->y=(Y); iFound=0; } \  
 }  
   
   
   
 int32_t  
 Diamond16_DirectMainSearch(  
                                         const uint8_t * const f_pRef,  
                                         const uint8_t * const f_pRefH,  
                                         const uint8_t * const f_pRefV,  
                                         const uint8_t * const f_pRefHV,  
   
                                         const uint8_t * const cur,  
   
                                         const uint8_t * const b_pRef,  
                                         const uint8_t * const b_pRefH,  
                                         const uint8_t * const b_pRefV,  
                                         const uint8_t * const b_pRefHV,  
941    
942                                          const int x,  static void
943                                          const int y,  DiamondSearch(int x, int y, const SearchData * const data, int bDirection, CheckFunc * const CheckCandidate)
944    {
945    
946    /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */
947    
948                                          const int TRB,          unsigned int * const iDirection = data->dir;
                                         const int TRD,  
949    
950                                      const int start_x,          do {
951                                      const int start_y,                  *iDirection = 0;
952                    if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
953                    if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);
954                    if (bDirection & 4) CHECK_CANDIDATE(x, y - iDiamondSize, 4);
955                    if (bDirection & 8) CHECK_CANDIDATE(x, y + iDiamondSize, 8);
956    
957                                      int iMinSAD,                  /* now we're doing diagonal checks near our candidate */
                                     VECTOR * const currMV,  
                                         const VECTOR * const directmv,  
958    
959                                      const int32_t min_dx,                  if (*iDirection) {              /* checking if anything found */
960                                          const int32_t max_dx,                          bDirection = *iDirection;
961                                          const int32_t min_dy,                          *iDirection = 0;
962                                          const int32_t max_dy,                          x = data->currentMV->x; y = data->currentMV->y;
963                            if (bDirection & 3) {   /* our candidate is left or right */
964                                    CHECK_CANDIDATE(x, y + iDiamondSize, 8);
965                                    CHECK_CANDIDATE(x, y - iDiamondSize, 4);
966                            } else {                        /* what remains here is up or down */
967                                    CHECK_CANDIDATE(x + iDiamondSize, y, 2);
968                                    CHECK_CANDIDATE(x - iDiamondSize, y, 1);
969                            }
970                            bDirection += *iDirection;
971                            x = data->currentMV->x; y = data->currentMV->y;
972                    }
973            }
974            while (*iDirection);
975    }
976    
977                                          const int32_t iEdgedWidth,  /* MAINSEARCH FUNCTIONS END */
                                         const int32_t iDiamondSize,  
978    
979                                          const int32_t iQuant,  static void
980                                          int iFound)  SubpelRefine_Fast(SearchData * data, CheckFunc * CheckCandidate)
981  {  {
982  /* Do a diamond search around given starting point, return SAD of best */  /* Do a half-pel or q-pel refinement */
983            VECTOR centerMV;
984            VECTOR second_best;
985            int best_sad = *data->iMinSAD;
986            int xo, yo, xo2, yo2;
987            int size = 2;
988            CheckFunc *backupFunc = CheckCandidate;
989    
990          int32_t iSAD;          if(data->qpel_precision)
991                    size = 1;
992    
993          VECTOR backupMV;          centerMV = *data->currentMV;
994            *data->iMinSAD = 256 * 4096;
995    
996          currMV->x = start_x;          CHECK_CANDIDATE(centerMV.x, centerMV.y - size, 0);
997          currMV->y = start_y;          CHECK_CANDIDATE(centerMV.x + size, centerMV.y - size, 0);
998            CHECK_CANDIDATE(centerMV.x + size, centerMV.y, 0);
999            CHECK_CANDIDATE(centerMV.x + size, centerMV.y + size, 0);
1000    
1001  /* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */          CHECK_CANDIDATE(centerMV.x, centerMV.y + size, 0);
1002            CHECK_CANDIDATE(centerMV.x - size, centerMV.y + size, 0);
1003            CHECK_CANDIDATE(centerMV.x - size, centerMV.y, 0);
1004            CHECK_CANDIDATE(centerMV.x - size, centerMV.y - size, 0);
1005    
1006          do          second_best = *data->currentMV;
         {  
                 iFound = 1;  
1007    
1008                  backupMV = *currMV;          if(data->qpel_precision) {
1009                    second_best.x *= 2;     second_best.y *= 2;
1010            }
1011    
1012                  CHECK_MV16_DIRECT_FOUND(backupMV.x - iDiamondSize, backupMV.y);          data->currentMV[0] = centerMV;
1013                  CHECK_MV16_DIRECT_FOUND(backupMV.x + iDiamondSize, backupMV.y);          *data->iMinSAD = best_sad;
                 CHECK_MV16_DIRECT_FOUND(backupMV.x, backupMV.y - iDiamondSize);  
                 CHECK_MV16_DIRECT_FOUND(backupMV.x, backupMV.y + iDiamondSize);  
1014    
1015          } while (!iFound);      centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;
1016    
1017          return iMinSAD;          xo = centerMV.x;
1018  }          yo = centerMV.y;
1019            xo2 = second_best.x;
1020            yo2 = second_best.y;
1021    
1022            CheckCandidate = CheckCandidate16_subpel;
1023            *data->iMinSAD2 = 256 * 4096;
1024    
1025  int32_t          if (yo == yo2)
 AdvDiamond8_MainSearch(const uint8_t * const pRef,  
                                            const uint8_t * const pRefH,  
                                            const uint8_t * const pRefV,  
                                            const uint8_t * const pRefHV,  
                                            const uint8_t * const cur,  
                                            const int x,  
                                            const int y,  
                                            int start_x,  
                                            int start_y,  
                                            int iMinSAD,  
                                            VECTOR * const currMV,  
                                            const int center_x,  
                                            const int center_y,  
                                            const int32_t min_dx,  
                                            const int32_t max_dx,  
                                            const int32_t min_dy,  
                                            const int32_t max_dy,  
                                            const int32_t iEdgedWidth,  
                                            const int32_t iDiamondSize,  
                                            const int32_t iFcode,  
                                            const int32_t iQuant,  
                                            int iDirection)  
1026  {  {
1027                    CHECK_CANDIDATE((xo+xo2)>>1, yo, 0);
1028                    CHECK_CANDIDATE(xo, yo-1, 0);
1029                    CHECK_CANDIDATE(xo, yo+1, 0);
1030    
1031          int32_t iSAD;                  if(best_sad <= *data->iMinSAD2)
1032                            goto ende;
1033    
1034  /* directions: 1 - left (x-1); 2 - right (x+1), 4 - up (y-1); 8 - down (y+1) */                  if(data->currentQMV[0].x == data->currentQMV2[0].x) {
1035                            CHECK_CANDIDATE((xo+xo2)>>1, yo-1, 0);
1036                            CHECK_CANDIDATE((xo+xo2)>>1, yo+1, 0);
1037                            goto ende;
1038                    }
1039                    else {
1040                            CHECK_CANDIDATE((xo+xo2)>>1,
1041                                    (data->currentQMV[0].x == xo) ? data->currentQMV[0].y : data->currentQMV2[0].y,
1042                                    0);
1043                            goto ende;
1044                    }
1045            }
1046    
1047          if (iDirection) {          if (xo == xo2)
1048                  CHECK_MV8_CANDIDATE(start_x - iDiamondSize, start_y);          {
1049                  CHECK_MV8_CANDIDATE(start_x + iDiamondSize, start_y);                  CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0);
1050                  CHECK_MV8_CANDIDATE(start_x, start_y - iDiamondSize);                  CHECK_CANDIDATE(xo-1, yo, 0);
1051                  CHECK_MV8_CANDIDATE(start_x, start_y + iDiamondSize);                  CHECK_CANDIDATE(xo+1, yo, 0);
         } else {  
                 int bDirection = 1 + 2 + 4 + 8;  
1052    
1053                  do {                  if(best_sad < *data->iMinSAD2)
1054                          iDirection = 0;                          goto ende;
                         if (bDirection & 1)     //we only want to check left if we came from the right (our last motion was to the left, up-left or down-left)  
                                 CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);  
1055    
1056                          if (bDirection & 2)                  if(data->currentQMV[0].y == data->currentQMV2[0].y) {
1057                                  CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);                          CHECK_CANDIDATE(xo-1, (yo+yo2)>>1, 0);
1058                            CHECK_CANDIDATE(xo+1, (yo+yo2)>>1, 0);
1059                            goto ende;
1060                    }
1061                    else {
1062                            CHECK_CANDIDATE((data->currentQMV[0].y == yo) ? data->currentQMV[0].x : data->currentQMV2[0].x, (yo+yo2)>>1, 0);
1063                            goto ende;
1064                    }
1065            }
1066    
1067                          if (bDirection & 4)          CHECK_CANDIDATE(xo, (yo+yo2)>>1, 0);
1068                                  CHECK_MV8_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);          CHECK_CANDIDATE((xo+xo2)>>1, yo, 0);
1069    
1070                          if (bDirection & 8)          if(best_sad <= *data->iMinSAD2)
1071                                  CHECK_MV8_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);                  goto ende;
1072    
1073                          /* now we're doing diagonal checks near our candidate */          CHECK_CANDIDATE((xo+xo2)>>1, (yo+yo2)>>1, 0);
1074    
1075                          if (iDirection)         //checking if anything found  ende:
1076                          {          CheckCandidate = backupFunc;
                                 bDirection = iDirection;  
                                 iDirection = 0;  
                                 start_x = currMV->x;  
                                 start_y = currMV->y;  
                                 if (bDirection & 3)     //our candidate is left or right  
                                 {  
                                         CHECK_MV8_CANDIDATE_DIR(start_x, start_y + iDiamondSize, 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x, start_y - iDiamondSize, 4);  
                                 } else                  // what remains here is up or down  
                                 {  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize, start_y, 2);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize, start_y, 1);  
1077                                  }                                  }
1078    
1079                                  if (iDirection) {  static void
1080                                          bDirection += iDirection;  SubpelRefine(const SearchData * const data, CheckFunc * const CheckCandidate)
                                         start_x = currMV->x;  
                                         start_y = currMV->y;  
                                 }  
                         } else                          //about to quit, eh? not so fast....  
1081                          {                          {
1082                                  switch (bDirection) {  /* Do a half-pel or q-pel refinement */
1083                                  case 2:          const VECTOR centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;
1084                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
1085                                                                                          start_y - iDiamondSize, 2 + 4);          CHECK_CANDIDATE(centerMV.x, centerMV.y - 1, 0);
1086                                          CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y - 1, 0);
1087                                                                                          start_y + iDiamondSize, 2 + 8);          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y, 0);
1088                                          break;          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y + 1, 0);
1089                                  case 1:          CHECK_CANDIDATE(centerMV.x, centerMV.y + 1, 0);
1090                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,          CHECK_CANDIDATE(centerMV.x - 1, centerMV.y + 1, 0);
1091                                                                                          start_y - iDiamondSize, 1 + 4);          CHECK_CANDIDATE(centerMV.x - 1, centerMV.y, 0);
1092                                          CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,          CHECK_CANDIDATE(centerMV.x - 1, centerMV.y - 1, 0);
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         break;  
                                 case 2 + 4:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 4:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         break;  
                                 case 8:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         break;  
                                 case 1 + 4:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y - iDiamondSize, 2 + 4);  
                                         break;  
                                 case 2 + 8:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
                                         break;  
                                 case 1 + 8:  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         break;  
                                 default:                //1+2+4+8 == we didn't find anything at all  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y - iDiamondSize, 1 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x - iDiamondSize,  
                                                                                         start_y + iDiamondSize, 1 + 8);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y - iDiamondSize, 2 + 4);  
                                         CHECK_MV8_CANDIDATE_DIR(start_x + iDiamondSize,  
                                                                                         start_y + iDiamondSize, 2 + 8);  
                                         break;  
                                 }  
                                 if (!(iDirection))  
                                         break;          //ok, the end. really  
                                 else {  
                                         bDirection = iDirection;  
                                         start_x = currMV->x;  
                                         start_y = currMV->y;  
                                 }  
                         }  
1093                  }                  }
1094                  while (1);                              //forever  
1095    static __inline int
1096    SkipDecisionP(const IMAGE * current, const IMAGE * reference,
1097                                                            const int x, const int y,
1098                                                            const uint32_t stride, const uint32_t iQuant, int rrv)
1099    
1100    {
1101            int offset = (x + y*stride)*8;
1102            if(!rrv) {
1103                    uint32_t sadC = sad8(current->u + offset,
1104                                                    reference->u + offset, stride);
1105                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
1106                    sadC += sad8(current->v + offset,
1107                                                    reference->v + offset, stride);
1108                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
1109                    return 1;
1110    
1111            } else {
1112                    uint32_t sadC = sad16(current->u + 2*offset,
1113                                                    reference->u + 2*offset, stride, 256*4096);
1114                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
1115                    sadC += sad16(current->v + 2*offset,
1116                                                    reference->v + 2*offset, stride, 256*4096);
1117                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
1118                    return 1;
1119          }          }
         return iMinSAD;  
1120  }  }
1121    
1122    static __inline void
1123    ZeroMacroblockP(MACROBLOCK *pMB, const int32_t sad)
1124    {
1125            pMB->mode = MODE_INTER;
1126            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = zeroMV;
1127            pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = zeroMV;
1128            pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
1129    }
1130    
1131  int32_t  static __inline void
1132  Full8_MainSearch(const uint8_t * const pRef,  ModeDecision_Fast(SearchData * const Data,
1133                                   const uint8_t * const pRefH,                          MACROBLOCK * const pMB,
1134                                   const uint8_t * const pRefV,                          const MACROBLOCK * const pMBs,
1135                                   const uint8_t * const pRefHV,                          const int x, const int y,
1136                                   const uint8_t * const cur,                          const MBParam * const pParam,
1137                                   const int x,                          const uint32_t MotionFlags,
1138                                   const int y,                          const uint32_t VopFlags,
1139                             const int start_x,                          const uint32_t VolFlags,
1140                             const int start_y,                          const IMAGE * const pCurrent,
1141                             int iMinSAD,                          const IMAGE * const pRef,
1142                             VECTOR * const currMV,                          const IMAGE * const vGMC,
1143                             const int center_x,                          const int coding_type)
1144                             const int center_y,  {
1145                                   const int32_t min_dx,          int mode = MODE_INTER;
1146                                   const int32_t max_dx,          int mcsel = 0;
1147                                   const int32_t min_dy,          int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0);
1148                                   const int32_t max_dy,          const uint32_t iQuant = pMB->quant;
1149                                   const int32_t iEdgedWidth,          const int skip_possible = (coding_type == P_VOP) && (pMB->dquant == 0);
1150                                   const int32_t iDiamondSize,      int sad;
1151                                   const int32_t iFcode,          int min_rd = -1, intra_rd, i, cbp, c[2] = {0, 0};
1152                                   const int32_t iQuant,          VECTOR backup[5], *v;
1153                                   int iFound)          int sad_backup[5];
1154  {          int InterBias = MV16_INTER_BIAS;
1155          int32_t iSAD;          int thresh = 0;
1156          int32_t dx, dy;          int count = 0;
1157          VECTOR backupMV;          int top = 0, top_right = 0, left = 0;
1158    
1159          backupMV.x = start_x;          pMB->mcsel = 0;
1160          backupMV.y = start_y;  
1161            /* INTER <-> INTER4V decision */
1162          for (dx = min_dx; dx <= max_dx; dx += iDiamondSize)          if ((Data->iMinSAD[0] + 75 < Data->iMinSAD[1] +
1163                  for (dy = min_dy; dy <= max_dy; dy += iDiamondSize)                  Data->iMinSAD[2] + Data->iMinSAD[3] + Data->iMinSAD[4])) { /* normal, fast, SAD-based mode decision */
1164                          NOCHECK_MV8_CANDIDATE(dx, dy);                  if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +
1165                            Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) {
1166          return iMinSAD;                          mode = MODE_INTER;
1167                            sad = Data->iMinSAD[0];
1168                    } else {
1169                            mode = MODE_INTER4V;
1170                            sad = Data->iMinSAD[1] + Data->iMinSAD[2] +
1171                                                    Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant;
1172                            Data->iMinSAD[0] = sad;
1173  }  }
1174    
1175  Halfpel8_RefineFuncPtr Halfpel8_Refine;                  /* final skip decision, a.k.a. "the vector you found, really that good?" */
1176                    if (skip_possible && (pMB->sad16 < (int)iQuant * MAX_SAD00_FOR_SKIP))
1177                            if ( (100*sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH)
1178                                    if (Data->chroma || SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {
1179                                            mode = MODE_NOT_CODED;
1180                                            goto early_out;
1181                                    }
1182    
1183  int32_t                  /* mcsel */
1184  Halfpel16_Refine(const uint8_t * const pRef,                  if (coding_type == S_VOP) {
                                  const uint8_t * const pRefH,  
                                  const uint8_t * const pRefV,  
                                  const uint8_t * const pRefHV,  
                                  const uint8_t * const cur,  
                                  const int x,  
                                  const int y,  
                                  VECTOR * const currMV,  
                                  int32_t iMinSAD,  
                            const int center_x,  
                            const int center_y,  
                                  const int32_t min_dx,  
                                  const int32_t max_dx,  
                                  const int32_t min_dy,  
                                  const int32_t max_dy,  
                                  const int32_t iFcode,  
                                  const int32_t iQuant,  
                                  const int32_t iEdgedWidth)  
 {  
 /* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */  
1185    
1186          int32_t iSAD;                          int32_t iSAD = sad16(Data->Cur,
1187          VECTOR backupMV = *currMV;                                  vGMC->y + 16*y*Data->iEdgedWidth + 16*x, Data->iEdgedWidth, 65536);
1188    
1189          CHECK_MV16_CANDIDATE(backupMV.x - 1, backupMV.y - 1);                          if (Data->chroma) {
1190          CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y - 1);                                  iSAD += sad8(Data->CurU, vGMC->u + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1191          CHECK_MV16_CANDIDATE(backupMV.x + 1, backupMV.y - 1);                                  iSAD += sad8(Data->CurV, vGMC->v + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1192          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);  
1193    
1194          return iMinSAD;                          if (iSAD <= sad) {              /* mode decision GMC */
1195                                    mode = MODE_INTER;
1196                                    mcsel = 1;
1197                                    sad = iSAD;
1198  }  }
1199    
1200  #define PMV_HALFPEL16 (PMV_HALFPELDIAMOND16|PMV_HALFPELREFINE16)                  }
1201            } else { /* Rate-Distortion INTER<->INTER4V */
1202                    Data->iQuant = iQuant;
1203                    Data->cbp = c;
1204                    v = Data->qpel ? Data->currentQMV : Data->currentMV;
1205    
1206                    /* final skip decision, a.k.a. "the vector you found, really that good?" */
1207                    if (skip_possible && (pMB->sad16 < (int)iQuant * MAX_SAD00_FOR_SKIP))
1208                            if ( (100*Data->iMinSAD[0])/(pMB->sad16+1) > FINAL_SKIP_THRESH)
1209                                    if (Data->chroma || SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {
1210                                            mode = MODE_NOT_CODED;
1211                                            goto early_out;
1212                                    }
1213    
1214                    for (i = 0; i < 5; i++) {
1215                            sad_backup[i] = Data->iMinSAD[i];
1216                            Data->iMinSAD[i] = 256*4096;
1217                            backup[i] = v[i];
1218                    }
1219    
1220  int32_t                  min_rd = findRDinter(Data, pMBs, x, y, pParam, MotionFlags);
1221  PMVfastSearch16(const uint8_t * const pRef,                  cbp = *Data->cbp;
1222                                  const uint8_t * const pRefH,                  sad = sad_backup[0];
                                 const uint8_t * const pRefV,  
                                 const uint8_t * const pRefHV,  
                                 const IMAGE * const pCur,  
                                 const int x,  
                                 const int y,  
                                 const int start_x,      /* start is searched first, so it should contain the most */  
                                 const int start_y,  /* likely motion vector for this block */  
                                 const int center_x,     /* center is from where length of MVs is measured */  
                                 const int center_y,  
                                 const uint32_t MotionFlags,  
                                 const uint32_t iQuant,  
                                 const uint32_t iFcode,  
                                 const MBParam * const pParam,  
                                 const MACROBLOCK * const pMBs,  
                                 const MACROBLOCK * const prevMBs,  
                                 VECTOR * const currMV,  
                                 VECTOR * const currPMV)  
 {  
         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;  
1223    
1224          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;                  if (coding_type == S_VOP) {
1225                            int gmc_rd;
1226                            int32_t iSAD = sad16(Data->Cur,
1227                                    vGMC->y + 16*y*Data->iEdgedWidth + 16*x, Data->iEdgedWidth, 65536);
1228    
1229          int32_t iDiamondSize;                          if (Data->chroma) {
1230                                    iSAD += sad8(Data->CurU, vGMC->u + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1231                                    iSAD += sad8(Data->CurV, vGMC->v + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1232                            }
1233    
1234          int32_t min_dx;                          *Data->iMinSAD = min_rd += BITS_MULT*1; /* mcsel */
1235          int32_t max_dx;                          gmc_rd = findRDgmc(Data, vGMC, x, y);
1236          int32_t min_dy;                          if (gmc_rd < min_rd) {
1237          int32_t max_dy;                                  mcsel = 1;
1238                                    *Data->iMinSAD = min_rd = gmc_rd;
1239                                    mode = MODE_INTER;
1240                                    cbp = *Data->cbp;
1241                                    sad = iSAD;
1242                            }
1243                    }
1244    
1245          int32_t iFound;                  if (inter4v) {
1246                            int v4_rd;
1247                            v4_rd = findRDinter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1248                            if (v4_rd < min_rd) {
1249                                    Data->iMinSAD[0] = min_rd = v4_rd;
1250                                    mode = MODE_INTER4V;
1251                                    cbp = *Data->cbp;
1252                                    sad = sad_backup[1] + sad_backup[2] +
1253                                              sad_backup[3] + sad_backup[4] + IMV16X16 * (int32_t)iQuant;
1254                            }
1255                    }
1256            }
1257    
1258          VECTOR newMV;          left = top = top_right = -1;
1259          VECTOR backupMV;                        /* just for PMVFAST */          thresh = 0;
1260    
1261          VECTOR pmv[4];          if((x > 0) && (y > 0) && (x < (int32_t) pParam->mb_width)) {
1262          int32_t psad[4];                  left = (&pMBs[(x-1) + y * pParam->mb_width])->sad16; // left
1263                    top = (&pMBs[x + (y-1) * pParam->mb_width])->sad16; // top
1264                    top_right = (&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16; // top right
1265    
1266          MainSearch16FuncPtr MainSearchPtr;                  if(((&pMBs[(x-1) + y * pParam->mb_width])->mode != MODE_INTRA) &&
1267                       ((&pMBs[x + (y-1) * pParam->mb_width])->mode != MODE_INTRA) &&
1268                       ((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mode != MODE_INTRA)) {
1269                            thresh = MAX(MAX(top, left), top_right);
1270                    }
1271                    else
1272                            thresh = MIN(MIN(top, left), top_right);
1273            }
1274    
1275          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;          /* INTRA <-> INTER decision */
1276            if (sad < thresh) { /* normal, fast, SAD-based mode decision */
1277                    /* intra decision */
1278    
1279          int32_t threshA, threshB;                  if (iQuant > 8) InterBias += 100 * (iQuant - 8); /* to make high quants work */
1280          int32_t bPredEq;                  if (y != 0)
1281          int32_t iMinSAD, iSAD;                          if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;
1282                    if (x != 0)
1283                            if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80;
1284    
1285  /* Get maximum range */                  if (Data->chroma) InterBias += 50; /* dev8(chroma) ??? <-- yes, we need dev8 (no big difference though) */
1286          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,                  if (Data->rrv) InterBias *= 4;
                           iFcode);  
1287    
1288  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */                  if (InterBias < sad) {
1289                            int32_t deviation;
1290                            if (!Data->rrv)
1291                                    deviation = dev16(Data->Cur, Data->iEdgedWidth);
1292                            else
1293                                    deviation = dev16(Data->Cur, Data->iEdgedWidth) + /* dev32() */
1294                                                            dev16(Data->Cur+16, Data->iEdgedWidth) +
1295                                                            dev16(Data->Cur + 16*Data->iEdgedWidth, Data->iEdgedWidth) +
1296                                                            dev16(Data->Cur+16+16*Data->iEdgedWidth, Data->iEdgedWidth);
1297    
1298          if (!(MotionFlags & PMV_HALFPEL16)) {                          if (deviation < (sad - InterBias)) mode = MODE_INTRA;
                 min_dx = EVEN(min_dx);  
                 max_dx = EVEN(max_dx);  
                 min_dy = EVEN(min_dy);  
                 max_dy = EVEN(max_dy);  
1299          }          }
1300    
1301          /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */                  pMB->cbp = 63;
1302          //bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);          } else { /* Rate-Distortion INTRA<->INTER */
1303          bPredEq = get_pmvdata2(pMBs, iWcount, 0, x, y, 0, pmv, psad);                  if(min_rd < 0) {
1304                            Data->iQuant = iQuant;
1305                            Data->cbp = c;
1306                            v = Data->qpel ? Data->currentQMV : Data->currentMV;
1307    
1308          if ((x == 0) && (y == 0)) {                          for (i = 0; i < 5; i++) {
1309                  threshA = 512;                                  Data->iMinSAD[i] = 256*4096;
1310                  threshB = 1024;                                  backup[i] = v[i];
         } else {  
                 threshA = psad[0];  
                 threshB = threshA + 256;  
                 if (threshA < 512)  
                         threshA = 512;  
                 if (threshA > 1024)  
                         threshA = 1024;  
                 if (threshB > 1792)  
                         threshB = 1792;  
1311          }          }
1312    
1313          iFound = 0;                          if(mode == MODE_INTER) {
1314                                    min_rd = findRDinter(Data, pMBs, x, y, pParam, MotionFlags);
1315  /* Step 4: Calculate SAD around the Median prediction.                                  cbp = *Data->cbp;
    MinSAD=SAD  
    If Motion Vector equal to Previous frame motion vector  
    and MinSAD<PrevFrmSAD goto Step 10.  
    If SAD<=256 goto Step 10.  
 */  
1316    
1317          currMV->x = start_x;                                  if (coding_type == S_VOP) {
1318          currMV->y = start_y;                                          int gmc_rd;
1319    
1320          if (!(MotionFlags & PMV_HALFPEL16)) {   /* This should NOT be necessary! */                                          *Data->iMinSAD = min_rd += BITS_MULT*1; /* mcsel */
1321                  currMV->x = EVEN(currMV->x);                                          gmc_rd = findRDgmc(Data, vGMC, x, y);
1322                  currMV->y = EVEN(currMV->y);                                          if (gmc_rd < min_rd) {
1323                                                    mcsel = 1;
1324                                                    *Data->iMinSAD = min_rd = gmc_rd;
1325                                                    mode = MODE_INTER;
1326                                                    cbp = *Data->cbp;
1327                                            }
1328          }          }
   
         if (currMV->x > max_dx) {  
                 currMV->x = max_dx;  
1329          }          }
1330          if (currMV->x < min_dx) {  
1331                  currMV->x = min_dx;                          if(mode == MODE_INTER4V) {
1332                                    int v4_rd;
1333                                    v4_rd = findRDinter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1334                                    if (v4_rd < min_rd) {
1335                                            Data->iMinSAD[0] = min_rd = v4_rd;
1336                                            mode = MODE_INTER4V;
1337                                            cbp = *Data->cbp;
1338          }          }
         if (currMV->y > max_dy) {  
                 currMV->y = max_dy;  
1339          }          }
         if (currMV->y < min_dy) {  
                 currMV->y = min_dy;  
1340          }          }
1341    
1342          iMinSAD =                  intra_rd = findRDintra(Data);
1343                  sad16(cur,                  if (intra_rd < min_rd) {
1344                            get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,                          *Data->iMinSAD = min_rd = intra_rd;
1345                                                   iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);                          mode = MODE_INTRA;
         iMinSAD +=  
                 calc_delta_16(currMV->x - center_x, currMV->y - center_y,  
                                           (uint8_t) iFcode, iQuant);  
   
         if ((iMinSAD < 256) ||  
                 ((MVequal(*currMV, prevMB->mvs[0])) &&  
                  ((int32_t) iMinSAD < prevMB->sad16))) {  
                 if (iMinSAD < 2 * iQuant)       // high chances for SKIP-mode  
                 {  
                         if (!MVzero(*currMV)) {  
                                 iMinSAD += MV16_00_BIAS;  
                                 CHECK_MV16_ZERO;        // (0,0) saves space for letterboxed pictures  
                                 iMinSAD -= MV16_00_BIAS;  
                         }  
1346                  }                  }
1347    
1348                  if (MotionFlags & PMV_QUICKSTOP16)                  pMB->cbp = cbp;
                         goto PMVfast16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast16_Terminate_with_Refine;  
1349          }          }
1350    
1351    early_out:
1352            pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
1353    
1354  /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion          if (Data->rrv) {
1355     vector of the median.                          Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
1356     If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2                          Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
1357  */          }
1358    
1359          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[0])))          if (mode == MODE_INTER && mcsel == 0) {
1360                  iFound = 2;                  pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
1361    
1362  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.                  if(Data->qpel) {
1363     Otherwise select large Diamond Search.                          pMB->qmvs[0] = pMB->qmvs[1]
1364  */                                  = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0];
1365                            pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x;
1366                            pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y;
1367                    } else {
1368                            pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x;
1369                            pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;
1370                    }
1371    
1372          if ((!MVzero(pmv[0])) || (threshB < 1536) || (bPredEq))          } else if (mode == MODE_INTER ) { // but mcsel == 1
                 iDiamondSize = 1;               // halfpel!  
         else  
                 iDiamondSize = 2;               // halfpel!  
1373    
1374          if (!(MotionFlags & PMV_HALFPELDIAMOND16))                  pMB->mcsel = 1;
1375                  iDiamondSize *= 2;                  if (Data->qpel) {
1376                            pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv;
1377                            pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2;
1378                            pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2;
1379                    } else
1380                            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
1381    
1382  /*          } else
1383     Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.                  if (mode == MODE_INTER4V) ; /* anything here? */
1384     Also calculate (0,0) but do not subtract offset.          else    /* INTRA, NOT_CODED */
1385     Let MinSAD be the smallest SAD up to this point.                  ZeroMacroblockP(pMB, 0);
    If MV is (0,0) subtract offset.  
 */  
1386    
1387  // (0,0) is always possible          pMB->mode = mode;
1388    }
1389    
1390          if (!MVzero(pmv[0]))  static __inline void
1391                  CHECK_MV16_ZERO;  ModeDecision(SearchData * const Data,
1392                            MACROBLOCK * const pMB,
1393                            const MACROBLOCK * const pMBs,
1394                            const int x, const int y,
1395                            const MBParam * const pParam,
1396                            const uint32_t MotionFlags,
1397                            const uint32_t VopFlags,
1398                            const uint32_t VolFlags,
1399                            const IMAGE * const pCurrent,
1400                            const IMAGE * const pRef,
1401                            const IMAGE * const vGMC,
1402                            const int coding_type)
1403    {
1404            int mode = MODE_INTER;
1405            int mcsel = 0;
1406            int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0);
1407            const uint32_t iQuant = pMB->quant;
1408    
1409            const int skip_possible = (coding_type == P_VOP) && (pMB->dquant == 0);
1410    
1411            pMB->mcsel = 0;
1412    
1413            if (!(VopFlags & XVID_VOP_MODEDECISION_RD)) { /* normal, fast, SAD-based mode decision */
1414                    int sad;
1415                    int InterBias = MV16_INTER_BIAS;
1416                    if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +
1417                            Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) {
1418                            mode = MODE_INTER;
1419                            sad = Data->iMinSAD[0];
1420                    } else {
1421                            mode = MODE_INTER4V;
1422                            sad = Data->iMinSAD[1] + Data->iMinSAD[2] +
1423                                                    Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant;
1424                            Data->iMinSAD[0] = sad;
1425                    }
1426    
1427  // previous frame MV is always possible                  /* final skip decision, a.k.a. "the vector you found, really that good?" */
1428                    if (skip_possible && (pMB->sad16 < (int)iQuant * MAX_SAD00_FOR_SKIP))
1429                            if ( (100*sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH)
1430                                    if (Data->chroma || SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {
1431                                            mode = MODE_NOT_CODED;
1432                                            sad = 0;
1433                                    }
1434    
1435          if (!MVzero(prevMB->mvs[0]))                  /* mcsel */
1436                  if (!MVequal(prevMB->mvs[0], pmv[0]))                  if (coding_type == S_VOP) {
                         CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);  
1437    
1438  // left neighbour, if allowed                          int32_t iSAD = sad16(Data->Cur,
1439                                    vGMC->y + 16*y*Data->iEdgedWidth + 16*x, Data->iEdgedWidth, 65536);
1440    
1441          if (!MVzero(pmv[1]))                          if (Data->chroma) {
1442                  if (!MVequal(pmv[1], prevMB->mvs[0]))                                  iSAD += sad8(Data->CurU, vGMC->u + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
1443                          if (!MVequal(pmv[1], pmv[0])) {                                  iSAD += sad8(Data->CurV, vGMC->v + 8*y*(Data->iEdgedWidth/2) + 8*x, Data->iEdgedWidth/2);
                                 if (!(MotionFlags & PMV_HALFPEL16)) {  
                                         pmv[1].x = EVEN(pmv[1].x);  
                                         pmv[1].y = EVEN(pmv[1].y);  
1444                                  }                                  }
1445    
1446                                  CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);                          if (iSAD <= sad) {              /* mode decision GMC */
1447                                    mode = MODE_INTER;
1448                                    mcsel = 1;
1449                                    sad = iSAD;
1450                          }                          }
 // top neighbour, if allowed  
         if (!MVzero(pmv[2]))  
                 if (!MVequal(pmv[2], prevMB->mvs[0]))  
                         if (!MVequal(pmv[2], pmv[0]))  
                                 if (!MVequal(pmv[2], pmv[1])) {  
                                         if (!(MotionFlags & PMV_HALFPEL16)) {  
                                                 pmv[2].x = EVEN(pmv[2].x);  
                                                 pmv[2].y = EVEN(pmv[2].y);  
                                         }  
                                         CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
1451    
 // top right neighbour, if allowed  
                                         if (!MVzero(pmv[3]))  
                                                 if (!MVequal(pmv[3], prevMB->mvs[0]))  
                                                         if (!MVequal(pmv[3], pmv[0]))  
                                                                 if (!MVequal(pmv[3], pmv[1]))  
                                                                         if (!MVequal(pmv[3], pmv[2])) {  
                                                                                 if (!(MotionFlags & PMV_HALFPEL16)) {  
                                                                                         pmv[3].x = EVEN(pmv[3].x);  
                                                                                         pmv[3].y = EVEN(pmv[3].y);  
                                                                                 }  
                                                                                 CHECK_MV16_CANDIDATE(pmv[3].x,  
                                                                                                                          pmv[3].y);  
1452                                                                          }                                                                          }
                                 }  
   
         if ((MVzero(*currMV)) &&  
                 (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )  
                 iMinSAD -= MV16_00_BIAS;  
1453    
1454                    /* intra decision */
1455    
1456  /* Step 6: If MinSAD <= thresa goto Step 10.                  if (iQuant > 8) InterBias += 100 * (iQuant - 8); /* to make high quants work */
1457     If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.                  if (y != 0)
1458  */                          if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;
1459                    if (x != 0)
1460          if ((iMinSAD <= threshA) ||                          if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80;
                 (MVequal(*currMV, prevMB->mvs[0]) &&  
                  ((int32_t) iMinSAD < prevMB->sad16))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast16_Terminate_with_Refine;  
         }  
   
1461    
1462  /************ (Diamond Search)  **************/                  if (Data->chroma) InterBias += 50; /* dev8(chroma) ??? <-- yes, we need dev8 (no big difference though) */
1463  /*                  if (Data->rrv) InterBias *= 4;
    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.  
 */  
1464    
1465          if (MotionFlags & PMV_USESQUARES16)                  if (InterBias < sad) {
1466                  MainSearchPtr = Square16_MainSearch;                          int32_t deviation;
1467          else if (MotionFlags & PMV_ADVANCEDDIAMOND16)                          if (!Data->rrv)
1468                  MainSearchPtr = AdvDiamond16_MainSearch;                                  deviation = dev16(Data->Cur, Data->iEdgedWidth);
1469          else          else
1470                  MainSearchPtr = Diamond16_MainSearch;                                  deviation = dev16(Data->Cur, Data->iEdgedWidth) + /* dev32() */
1471                                                            dev16(Data->Cur+16, Data->iEdgedWidth) +
1472                                                            dev16(Data->Cur + 16*Data->iEdgedWidth, Data->iEdgedWidth) +
1473                                                            dev16(Data->Cur+16+16*Data->iEdgedWidth, Data->iEdgedWidth);
1474    
1475                            if (deviation < (sad - InterBias)) mode = MODE_INTRA;
1476                    }
1477    
1478          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                  pMB->cbp = 63;
1479                    pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
1480    
1481            } else { /* Rate-Distortion */
1482    
1483  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */                  int min_rd, intra_rd, i, cbp, c[2] = {0, 0};
1484          iSAD =                  VECTOR backup[5], *v;
1485                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,                  Data->iQuant = iQuant;
1486                                                    currMV->x, currMV->y, iMinSAD, &newMV, center_x, center_y,                  Data->cbp = c;
                                                   min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, iFound);  
1487    
1488          if (iSAD < iMinSAD) {                  v = Data->qpel ? Data->currentQMV : Data->currentMV;
1489                  *currMV = newMV;                  for (i = 0; i < 5; i++) {
1490                  iMinSAD = iSAD;                          Data->iMinSAD[i] = 256*4096;
1491                            backup[i] = v[i];
1492          }          }
1493    
1494          if (MotionFlags & PMV_EXTSEARCH16) {                  min_rd = findRDinter(Data, pMBs, x, y, pParam, MotionFlags);
1495  /* extended: search (up to) two more times: orignal prediction and (0,0) */                  cbp = *Data->cbp;
   
                 if (!(MVequal(pmv[0], backupMV))) {  
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  
                                                                   center_x, center_y, iMinSAD, &newMV, center_x, center_y,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
1496    
1497                          if (iSAD < iMinSAD) {                  if (coding_type == S_VOP) {
1498                                  *currMV = newMV;                          int gmc_rd;
1499                                  iMinSAD = iSAD;                          *Data->iMinSAD = min_rd += BITS_MULT*1; /* mcsel */
1500                            gmc_rd = findRDgmc(Data, vGMC, x, y);
1501                            if (gmc_rd < min_rd) {
1502                                    mcsel = 1;
1503                                    *Data->iMinSAD = min_rd = gmc_rd;
1504                                    mode = MODE_INTER;
1505                                    cbp = *Data->cbp;
1506                          }                          }
1507                  }                  }
1508    
1509                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                  if (inter4v) {
1510                          iSAD =                          int v4_rd;
1511                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,                          v4_rd = findRDinter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1512                                                                    iMinSAD, &newMV, center_x, center_y,                          if (v4_rd < min_rd) {
1513                                                                    min_dx, max_dx, min_dy, max_dy,                                  Data->iMinSAD[0] = min_rd = v4_rd;
1514                                                                    iEdgedWidth, iDiamondSize, iFcode,                                  mode = MODE_INTER4V;
1515                                                                    iQuant, iFound);                                  cbp = *Data->cbp;
   
                         if (iSAD < iMinSAD) {  
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
                         }  
1516                  }                  }
1517          }          }
1518    
1519  /*                  intra_rd = findRDintra(Data);
1520     Step 10:  The motion vector is chosen according to the block corresponding to MinSAD.                  if (intra_rd < min_rd) {
1521  */                          *Data->iMinSAD = min_rd = intra_rd;
1522                            mode = MODE_INTRA;
   PMVfast16_Terminate_with_Refine:  
         if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step  
                 iMinSAD =  
                         Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                          iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,  
                                                          iFcode, iQuant, iEdgedWidth);  
   
   PMVfast16_Terminate_without_Refine:  
         currPMV->x = currMV->x - center_x;  
         currPMV->y = currMV->y - center_y;  
         return iMinSAD;  
1523  }  }
1524    
1525                    pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = 0;
1526                    pMB->cbp = cbp;
1527            }
1528    
1529            if (Data->rrv) {
1530                            Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
1531                            Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
1532            }
1533    
1534            if (mode == MODE_INTER && mcsel == 0) {
1535                    pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
1536    
1537                    if(Data->qpel) {
1538                            pMB->qmvs[0] = pMB->qmvs[1]
1539  int32_t                                  = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0];
1540  Diamond8_MainSearch(const uint8_t * const pRef,                          pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x;
1541                                          const uint8_t * const pRefH,                          pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y;
                                         const uint8_t * const pRefV,  
                                         const uint8_t * const pRefHV,  
                                         const uint8_t * const cur,  
                                         const int x,  
                                         const int y,  
                                         int32_t start_x,  
                                         int32_t start_y,  
                                         int32_t iMinSAD,  
                                         VECTOR * const currMV,  
                                    const int center_x,  
                                    const int center_y,  
                                         const int32_t min_dx,  
                                         const int32_t max_dx,  
                                         const int32_t min_dy,  
                                         const int32_t max_dy,  
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
                                         const int32_t iFcode,  
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a diamond search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iDirectionBackup;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full Diamond pattern, and only 3 of 4 for all following diamonds */  
   
         CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);  
         CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);  
   
         if (iDirection) {  
                 while (!iFound) {  
                         iFound = 1;  
                         backupMV = *currMV;     // since iDirection!=0, this is well defined!  
                         iDirectionBackup = iDirection;  
   
                         if (iDirectionBackup != 2)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                   backupMV.y, 1);  
                         if (iDirectionBackup != 1)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                   backupMV.y, 2);  
                         if (iDirectionBackup != 4)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x,  
                                                                                   backupMV.y - iDiamondSize, 3);  
                         if (iDirectionBackup != 3)  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x,  
                                                                                   backupMV.y + iDiamondSize, 4);  
                 }  
1542          } else {          } else {
1543                  currMV->x = start_x;                          pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x;
1544                  currMV->y = start_y;                          pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;
         }  
         return iMinSAD;  
1545  }  }
1546    
1547            } else if (mode == MODE_INTER ) { // but mcsel == 1
1548    
1549                    pMB->mcsel = 1;
1550                    if (Data->qpel) {
1551                            pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv;
1552                            pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = pMB->amv.x/2;
1553                            pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = pMB->amv.y/2;
1554                    } else
1555                            pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
1556    
1557            } else
1558                    if (mode == MODE_INTER4V) ; /* anything here? */
1559            else    /* INTRA, NOT_CODED */
1560                    ZeroMacroblockP(pMB, 0);
1561    
1562            pMB->mode = mode;
1563    }
1564    
1565  int32_t  bool
1566  Square8_MainSearch(const uint8_t * const pRef,  MotionEstimation(MBParam * const pParam,
1567                                          const uint8_t * const pRefH,                                   FRAMEINFO * const current,
1568                                          const uint8_t * const pRefV,                                   FRAMEINFO * const reference,
1569                                          const uint8_t * const pRefHV,                                   const IMAGE * const pRefH,
1570                                          const uint8_t * const cur,                                   const IMAGE * const pRefV,
1571                                          const int x,                                   const IMAGE * const pRefHV,
1572                                          const int y,                                  const IMAGE * const pGMC,
1573                                          int32_t start_x,                                   const uint32_t iLimit)
1574                                          int32_t start_y,  {
1575                                          int32_t iMinSAD,          MACROBLOCK *const pMBs = current->mbs;
1576                                          VECTOR * const currMV,          const IMAGE *const pCurrent = &current->image;
1577                                     const int center_x,          const IMAGE *const pRef = &reference->image;
                                    const int center_y,  
                                         const int32_t min_dx,  
                                         const int32_t max_dx,  
                                         const int32_t min_dy,  
                                         const int32_t max_dy,  
                                         const int32_t iEdgedWidth,  
                                         const int32_t iDiamondSize,  
                                         const int32_t iFcode,  
                                         const int32_t iQuant,  
                                         int iFound)  
 {  
 /* Do a square search around given starting point, return SAD of best */  
   
         int32_t iDirection = 0;  
         int32_t iSAD;  
         VECTOR backupMV;  
   
         backupMV.x = start_x;  
         backupMV.y = start_y;  
   
 /* It's one search with full square pattern, and new parts for all following diamonds */  
   
 /*   new direction are extra, so 1-4 is normal diamond  
       537  
       1*2  
       648  
 */  
1578    
1579          CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize, backupMV.y, 1);          uint32_t mb_width = pParam->mb_width;
1580          CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize, backupMV.y, 2);          uint32_t mb_height = pParam->mb_height;
1581          CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y - iDiamondSize, 3);          const uint32_t iEdgedWidth = pParam->edged_width;
1582          CHECK_MV8_CANDIDATE_DIR(backupMV.x, backupMV.y + iDiamondSize, 4);          const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags);
1583            int stat_thresh = 0;
1584          CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize,  
1585                                                           backupMV.y - iDiamondSize, 5);          uint32_t x, y;
1586          CHECK_MV8_CANDIDATE_DIR(backupMV.x - iDiamondSize,          uint32_t iIntra = 0;
1587                                                           backupMV.y + iDiamondSize, 6);          int32_t sad00;
1588          CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize,          int skip_thresh = INITIAL_SKIP_THRESH * \
1589                                                           backupMV.y - iDiamondSize, 7);                  (current->vop_flags & XVID_VOP_REDUCED ? 4:1) * \
1590          CHECK_MV8_CANDIDATE_DIR(backupMV.x + iDiamondSize,                  (current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);
1591                                                           backupMV.y + iDiamondSize, 8);  
1592            /* some pre-initialized thingies for SearchP */
1593            int32_t temp[8]; uint32_t dir;
1594          if (iDirection) {          VECTOR currentMV[5];
1595                  while (!iFound) {          VECTOR currentQMV[5];
1596                          iFound = 1;          VECTOR currentMV2[5];
1597                          backupMV = *currMV;          VECTOR currentQMV2[5];
1598            int32_t iMinSAD[5];
1599            int32_t iMinSAD2[5];
1600            DECLARE_ALIGNED_MATRIX(dct_space, 3, 64, int16_t, CACHE_LINE);
1601            SearchData Data;
1602            memset(&Data, 0, sizeof(SearchData));
1603            Data.iEdgedWidth = iEdgedWidth;
1604            Data.currentMV = currentMV;
1605            Data.currentQMV = currentQMV;
1606            Data.currentMV2 = currentMV2;
1607            Data.currentQMV2 = currentQMV2;
1608            Data.iMinSAD = iMinSAD;
1609            Data.iMinSAD2 = iMinSAD2;
1610            Data.temp = temp;
1611            Data.dir = &dir;
1612            Data.iFcode = current->fcode;
1613            Data.rounding = pParam->m_rounding_type;
1614            Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0);
1615            Data.chroma = MotionFlags & XVID_ME_CHROMA_PVOP;
1616            Data.rrv = (current->vop_flags & XVID_VOP_REDUCED) ? 1:0;
1617            Data.dctSpace = dct_space;
1618            Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT);
1619    
1620            if ((current->vop_flags & XVID_VOP_REDUCED)) {
1621                    mb_width = (pParam->width + 31) / 32;
1622                    mb_height = (pParam->height + 31) / 32;
1623                    Data.qpel = 0;
1624            }
1625    
1626            Data.RefQ = pRefV->u; /* a good place, also used in MC (for similar purpose) */
1627            if (sadInit) (*sadInit) ();
1628    
1629            for (y = 0; y < mb_height; y++) {
1630                    for (x = 0; x < mb_width; x++)  {
1631                            MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];
1632                            MACROBLOCK *prevMB = &reference->mbs[x + y * pParam->mb_width];
1633    
1634                            if (!Data.rrv) pMB->sad16 =
1635                                    sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,
1636                                                            pRef->y + (x + y * iEdgedWidth) * 16,
1637                                                            pParam->edged_width, pMB->sad8 );
1638    
1639                            else pMB->sad16 =
1640                                    sad32v_c(pCurrent->y + (x + y * iEdgedWidth) * 32,
1641                                                            pRef->y + (x + y * iEdgedWidth) * 32,
1642                                                            pParam->edged_width, pMB->sad8 );
1643    
1644                            if (Data.chroma) {
1645                                    Data.temp[7] = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8,
1646                                                                            pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2)
1647                                                                    + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8,
1648                                                                            pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2);
1649                                    pMB->sad16 += Data.temp[7];
1650                            }
1651    
1652                            sad00 = pMB->sad16;
1653    
1654                            /* initial skip decision */
1655                            /* no early skip for GMC (global vector = skip vector is unknown!)  */
1656                            if (current->coding_type != S_VOP)      { /* no fast SKIP for S(GMC)-VOPs */
1657                                    if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh)
1658                                            if (Data.chroma || SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv)) {
1659                                                    ZeroMacroblockP(pMB, sad00);
1660                                                    pMB->mode = MODE_NOT_CODED;
1661                                                    continue;
1662                                            }
1663                            }
1664    
1665                          switch (iDirection) {                          if(MotionFlags & XVID_ME_DETECT_STATIC_MOTION) {
1666                          case 1:                                  if(x > 0 && y > 0 && x < pParam->mb_width)
1667                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                                          if(MVequal((&pMBs[(x-1) + y * pParam->mb_width])->mvs[0], zeroMV) &&
1668                                                                                     backupMV.y, 1);                                             MVequal((&pMBs[x + (y-1) * pParam->mb_width])->mvs[0], zeroMV) &&
1669                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                                         MVequal((&pMBs[(x+1) + (y-1) * pParam->mb_width])->mvs[0], zeroMV) &&
1670                                                                                   backupMV.y - iDiamondSize, 5);                                         MVequal(prevMB->mvs[0], zeroMV)) {
1671                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                                                  stat_thresh = MAX((&pMBs[(x-1) + y * pParam->mb_width])->sad16,
1672                                                                                   backupMV.y - iDiamondSize, 7);                                                                            MAX((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
1673                                  break;                                                                            MAX((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,
1674                          case 2:                                                                            prevMB->sad16)));
1675                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,                                          }
1676                                                                                   2);                                  else
1677                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                                          stat_thresh = MIN((&pMBs[(x-1) + y * pParam->mb_width])->sad16,
1678                                                                                   backupMV.y + iDiamondSize, 6);                                                                            MIN((&pMBs[x + (y-1) * pParam->mb_width])->sad16,
1679                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                                                                            MIN((&pMBs[(x+1) + (y-1) * pParam->mb_width])->sad16,
1680                                                                                   backupMV.y + iDiamondSize, 8);                                                                            prevMB->sad16)));
1681                                  break;                          }
1682    
1683                          case 3:                          if ((current->vop_flags & XVID_VOP_CARTOON) &&
1684                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,                                  (sad00 < pMB->quant * 4 * skip_thresh) || (sad00 < stat_thresh)) { /* favorize (0,0) vector for cartoons */
1685                                                                                   4);                                  ZeroMacroblockP(pMB, sad00);
1686                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,                                  continue;
1687                                                                                   backupMV.y - iDiamondSize, 7);                          }
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
1688    
1689                          case 4:                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,
1690                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,                                          y, MotionFlags, current->vop_flags, current->vol_flags,
1691                                                                                   3);                                          &Data, pParam, pMBs, reference->mbs, pMB);
1692                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
1693                                                                                   backupMV.y - iDiamondSize, 5);                          if(current->vop_flags & XVID_VOP_FAST_MODEDECISION_RD) {
1694                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,                                  ModeDecision_Fast(&Data, pMB, pMBs, x, y, pParam,
1695                                                                                   backupMV.y + iDiamondSize, 6);                                                           MotionFlags, current->vop_flags, current->vol_flags,
1696                                  break;                                                           pCurrent, pRef, pGMC, current->coding_type);
1697                            }
1698                          case 5:                          else {
1699                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,                                  ModeDecision(&Data, pMB, pMBs, x, y, pParam,
1700                                                                                   1);                                                           MotionFlags, current->vop_flags, current->vol_flags,
1701                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,                                                           pCurrent, pRef, pGMC, current->coding_type);
1702                                                                                   3);                          }
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 break;  
   
                         case 6:  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
   
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
1703    
1704                                  break;                          if (pMB->mode == MODE_INTRA)
1705                                    if (++iIntra > iLimit) return 1;
1706                    }
1707            }
1708    
1709                          case 7:          return 0;
1710                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  }
                                                                                    backupMV.y, 1);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
1711    
1712                          case 8:  /* check if given vector is equal to any vector checked before */
1713                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  static __inline int
1714                                                                                   2);  vector_repeats(const VECTOR * const pmv, const int i)
1715                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  {
1716                                                                                   4);          unsigned int j;
1717                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,          for (j = 0; j < i; j++)
1718                                                                                   backupMV.y + iDiamondSize, 6);                  if (MVequal(pmv[i], pmv[j])) return 1; /* same vector has been checked already */
1719                                  CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,          return 0;
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
                         default:  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize, backupMV.y,  
                                                                                  1);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize, backupMV.y,  
                                                                                  2);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y - iDiamondSize,  
                                                                                  3);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x, backupMV.y + iDiamondSize,  
                                                                                  4);  
   
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 5);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x - iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 6);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y - iDiamondSize, 7);  
                                 CHECK_MV8_CANDIDATE_FOUND(backupMV.x + iDiamondSize,  
                                                                                  backupMV.y + iDiamondSize, 8);  
                                 break;  
1720                          }                          }
1721    
1722    /*      make a binary mask that prevents diamonds/squares
1723            from checking a vector which has been checked as a prediction */
1724    static __inline int
1725    make_mask(const VECTOR * const pmv, const int i, const int current)
1726    {
1727            unsigned int mask = 255, j;
1728            for (j = 0; j < i; j++) {
1729                    if (pmv[current].x == pmv[j].x) {
1730                            if (pmv[current].y == pmv[j].y + iDiamondSize) mask &= ~4;
1731                            else if (pmv[current].y == pmv[j].y - iDiamondSize) mask &= ~8;
1732                    } else
1733                            if (pmv[current].y == pmv[j].y) {
1734                                    if (pmv[current].x == pmv[j].x + iDiamondSize) mask &= ~1;
1735                                    else if (pmv[current].x == pmv[j].x - iDiamondSize) mask &= ~2;
1736                  }                  }
         } else {  
                 currMV->x = start_x;  
                 currMV->y = start_y;  
1737          }          }
1738          return iMinSAD;          return mask;
1739  }  }
1740    
1741    static __inline void
1742    PreparePredictionsP(VECTOR * const pmv, int x, int y, int iWcount,
1743                            int iHcount, const MACROBLOCK * const prevMB, int rrv)
1744    {
1745            /* this function depends on get_pmvdata which means that it sucks. It should get the predictions by itself */
1746            if (rrv) { iWcount /= 2; iHcount /= 2; }
1747    
1748            if ( (y != 0) && (x < (iWcount-1)) ) {          /* [5] top-right neighbour */
1749                    pmv[5].x = EVEN(pmv[3].x);
1750                    pmv[5].y = EVEN(pmv[3].y);
1751            } else pmv[5].x = pmv[5].y = 0;
1752    
1753            if (x != 0) { pmv[3].x = EVEN(pmv[1].x); pmv[3].y = EVEN(pmv[1].y); }/* pmv[3] is left neighbour */
1754            else pmv[3].x = pmv[3].y = 0;
1755    
1756            if (y != 0) { pmv[4].x = EVEN(pmv[2].x); pmv[4].y = EVEN(pmv[2].y); }/* [4] top neighbour */
1757            else pmv[4].x = pmv[4].y = 0;
1758    
1759  int32_t          /* [1] median prediction */
1760  Halfpel8_Refine_c(const uint8_t * const pRef,          pmv[1].x = EVEN(pmv[0].x); pmv[1].y = EVEN(pmv[0].y);
                                 const uint8_t * const pRefH,  
                                 const uint8_t * const pRefV,  
                                 const uint8_t * const pRefHV,  
                                 const uint8_t * const cur,  
                                 const int x,  
                                 const int y,  
                                 VECTOR * const currMV,  
                                 int32_t iMinSAD,  
                            const int center_x,  
                            const int center_y,  
                                 const int32_t min_dx,  
                                 const int32_t max_dx,  
                                 const int32_t min_dy,  
                                 const int32_t max_dy,  
                                 const int32_t iFcode,  
                                 const int32_t iQuant,  
                                 const int32_t iEdgedWidth)  
 {  
 /* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */  
   
         int32_t iSAD;  
         VECTOR backupMV = *currMV;  
   
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y - 1);  
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y);  
         CHECK_MV8_CANDIDATE(backupMV.x - 1, backupMV.y + 1);  
         CHECK_MV8_CANDIDATE(backupMV.x, backupMV.y + 1);  
         CHECK_MV8_CANDIDATE(backupMV.x + 1, backupMV.y + 1);  
1761    
1762          return iMinSAD;          pmv[0].x = pmv[0].y = 0; /* [0] is zero; not used in the loop (checked before) but needed here for make_mask */
1763  }  
1764            pmv[2].x = EVEN(prevMB->mvs[0].x); /* [2] is last frame */
1765            pmv[2].y = EVEN(prevMB->mvs[0].y);
1766    
1767            if ((x < iWcount-1) && (y < iHcount-1)) {
1768                    pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); /* [6] right-down neighbour in last frame */
1769                    pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y);
1770            } else pmv[6].x = pmv[6].y = 0;
1771    
1772  #define PMV_HALFPEL8 (PMV_HALFPELDIAMOND8|PMV_HALFPELREFINE8)          if (rrv) {
1773                    int i;
1774                    for (i = 0; i < 7; i++) {
1775                            pmv[i].x = RRV_MV_SCALEUP(pmv[i].x);
1776                            pmv[i].y = RRV_MV_SCALEUP(pmv[i].y);
1777                    }
1778            }
1779    }
1780    
1781  int32_t  static void
1782  PMVfastSearch8(const uint8_t * const pRef,  SearchP(const IMAGE * const pRef,
1783                             const uint8_t * const pRefH,                             const uint8_t * const pRefH,
1784                             const uint8_t * const pRefV,                             const uint8_t * const pRefV,
1785                             const uint8_t * const pRefHV,                             const uint8_t * const pRefHV,
1786                             const IMAGE * const pCur,                             const IMAGE * const pCur,
1787                             const int x,                             const int x,
1788                             const int y,                             const int y,
                            const int start_x,  
                            const int start_y,  
                                 const int center_x,  
                                 const int center_y,  
1789                             const uint32_t MotionFlags,                             const uint32_t MotionFlags,
1790                             const uint32_t iQuant,                  const uint32_t VopFlags,
1791                             const uint32_t iFcode,                  const uint32_t VolFlags,
1792                    SearchData * const Data,
1793                             const MBParam * const pParam,                             const MBParam * const pParam,
1794                             const MACROBLOCK * const pMBs,                             const MACROBLOCK * const pMBs,
1795                             const MACROBLOCK * const prevMBs,                             const MACROBLOCK * const prevMBs,
1796                             VECTOR * const currMV,                  MACROBLOCK * const pMB)
                            VECTOR * const currPMV)  
1797  {  {
         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;  
1798    
1799          const uint8_t *cur = pCur->y + x * 8 + y * 8 * iEdgedWidth;          int i, threshA;
1800            VECTOR pmv[7];
1801          int32_t iDiamondSize;          int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0);
1802            CheckFunc * CheckCandidate;
1803          int32_t min_dx;  
1804          int32_t max_dx;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
1805          int32_t min_dy;                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
1806          int32_t max_dy;  
1807            get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp);
1808          VECTOR pmv[4];  
1809          int32_t psad[4];          Data->temp[5] = Data->temp[6] = 0; /* chroma-sad cache */
1810          VECTOR newMV;          i = Data->rrv ? 2 : 1;
1811          VECTOR backupMV;          Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;
1812          VECTOR startMV;          Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1813            Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1814    
1815            Data->RefP[0] = pRef->y + (x + Data->iEdgedWidth*y) * 16*i;
1816            Data->RefP[2] = pRefH + (x + Data->iEdgedWidth*y) * 16*i;
1817            Data->RefP[1] = pRefV + (x + Data->iEdgedWidth*y) * 16*i;
1818            Data->RefP[3] = pRefHV + (x + Data->iEdgedWidth*y) * 16*i;
1819            Data->RefP[4] = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1820            Data->RefP[5] = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1821    
1822            Data->lambda16 = lambda_vec16[pMB->quant];
1823            Data->lambda8 = lambda_vec8[pMB->quant];
1824            Data->qpel_precision = 0;
1825            *Data->dir = 0;
1826    
1827            memset(Data->currentMV, 0, 5*sizeof(VECTOR));
1828    
1829            if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0);
1830            else Data->predMV = pmv[0];
1831    
1832            i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0, 0);
1833            Data->iMinSAD[0] = pMB->sad16 + ((Data->lambda16 * i * pMB->sad16)>>10);
1834            Data->iMinSAD[1] = pMB->sad8[0] + ((Data->lambda8 * i * (pMB->sad8[0]+NEIGH_8X8_BIAS)) >> 10);
1835            Data->iMinSAD[2] = pMB->sad8[1];
1836            Data->iMinSAD[3] = pMB->sad8[2];
1837            Data->iMinSAD[4] = pMB->sad8[3];
1838    
1839            if ((!(VopFlags & XVID_VOP_MODEDECISION_RD)) && (x | y)) {
1840                    threshA = Data->temp[0]; /* that's where we keep this SAD atm */
1841                    if (threshA < 512) threshA = 512;
1842                    else if (threshA > 1024) threshA = 1024;
1843            } else
1844                    threshA = 512;
1845    
1846  //  const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;          PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height,
1847          const MACROBLOCK *const prevMB = prevMBs + (x >> 1) + (y >> 1) * iWcount;                                          prevMBs + x + y * pParam->mb_width, Data->rrv);
1848    
1849           int32_t threshA, threshB;          if (!Data->rrv) {
1850          int32_t iFound, bPredEq;                  if (inter4v) CheckCandidate = CheckCandidate16;
1851          int32_t iMinSAD, iSAD;                          else CheckCandidate = CheckCandidate16no4v; /* for extra speed */
1852            } else CheckCandidate = CheckCandidate32;
1853    
1854    /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/
1855    
1856            for (i = 1; i < 7; i++)
1857                    if (!vector_repeats(pmv, i)) {
1858                            CheckCandidate(pmv[i].x, pmv[i].y, Data, i);
1859                            if (Data->iMinSAD[0] <= threshA) { i++; break; }
1860                    }
1861    
1862            if ((Data->iMinSAD[0] <= threshA) ||
1863                            (MVequal(Data->currentMV[0], (prevMBs+x+y*pParam->mb_width)->mvs[0]) &&
1864                            (Data->iMinSAD[0] < (prevMBs+x+y*pParam->mb_width)->sad16)))
1865                    inter4v = 0;
1866            else {
1867    
1868          int32_t iSubBlock = (y & 1) + (y & 1) + (x & 1);                  MainSearchFunc * MainSearchPtr;
1869                    int mask = make_mask(pmv, i, *Data->dir); // all vectors pmv[0..i-1] have been checked
1870    
1871          MainSearch8FuncPtr MainSearchPtr;                  if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1872                    else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1873                            else MainSearchPtr = DiamondSearch;
1874    
1875          /* Init variables */                  MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate);
         startMV.x = start_x;  
         startMV.y = start_y;  
1876    
1877          /* Get maximum range */  /* extended search, diamond starting in 0,0 and in prediction.
1878          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,          note that this search is/might be done in halfpel positions,
1879                            iFcode);          which makes it more different than the diamond above */
1880    
1881          if (!(MotionFlags & PMV_HALFPELDIAMOND8)) {                  if (MotionFlags & XVID_ME_EXTSEARCH16) {
1882                  min_dx = EVEN(min_dx);                          int32_t bSAD;
1883                  max_dx = EVEN(max_dx);                          VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0];
1884                  min_dy = EVEN(min_dy);                          if (Data->rrv) {
1885                  max_dy = EVEN(max_dy);                                  startMV.x = RRV_MV_SCALEUP(startMV.x);
1886                                    startMV.y = RRV_MV_SCALEUP(startMV.y);
1887          }          }
1888                            if (!(MVequal(startMV, backupMV))) {
1889                                    bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1890    
1891          /* because we might use IF (dx>max_dx) THEN dx=max_dx; */                                  CheckCandidate(startMV.x, startMV.y, Data, 255);
1892          //bPredEq = get_pmvdata(pMBs, (x >> 1), (y >> 1), iWcount, iSubBlock, pmv, psad);                                  MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate);
1893          bPredEq = get_pmvdata2(pMBs, iWcount, 0, (x >> 1), (y >> 1), iSubBlock, pmv, psad);                                  if (bSAD < Data->iMinSAD[0]) {
1894                                            Data->currentMV[0] = backupMV;
1895          if ((x == 0) && (y == 0)) {                                          Data->iMinSAD[0] = bSAD; }
1896                  threshA = 512 / 4;                          }
                 threshB = 1024 / 4;  
1897    
1898          } else {                          backupMV = Data->currentMV[0];
1899                  threshA = psad[0] / 4;  /* good estimate? */                          startMV.x = startMV.y = 1;
1900                  threshB = threshA + 256 / 4;                          if (!(MVequal(startMV, backupMV))) {
1901                  if (threshA < 512 / 4)                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
                         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.  
 */  
1902    
1903                                    CheckCandidate(startMV.x, startMV.y, Data, 255);
1904                                    MainSearchPtr(startMV.x, startMV.y, Data, 255, CheckCandidate);
1905                                    if (bSAD < Data->iMinSAD[0]) {
1906                                            Data->currentMV[0] = backupMV;
1907                                            Data->iMinSAD[0] = bSAD;
1908                                    }
1909                            }
1910                    }
1911            }
1912    
1913  // Prepare for main loop          if (MotionFlags & XVID_ME_HALFPELREFINE16)
1914                            SubpelRefine(Data, CheckCandidate);
1915    
1916    if (MotionFlags & PMV_USESQUARES8)          for(i = 0; i < 5; i++) {
1917        MainSearchPtr = Square8_MainSearch;                  Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* initialize qpel vectors */
1918    else                  Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
1919            }
1920    
1921          if (MotionFlags & PMV_ADVANCEDDIAMOND8)          if (Data->qpel) {
1922                  MainSearchPtr = AdvDiamond8_MainSearch;                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
1923                                    pParam->width, pParam->height, Data->iFcode, 2, 0);
1924                    Data->qpel_precision = 1;
1925                    if (MotionFlags & XVID_ME_QUARTERPELREFINE16)
1926                            if(MotionFlags & XVID_ME_FASTREFINE16)
1927                                    SubpelRefine_Fast(Data, CheckCandidate);
1928          else          else
1929                  MainSearchPtr = Diamond8_MainSearch;                                  SubpelRefine(Data, CheckCandidate);
1930            }
1931    
1932          *currMV = startMV;          if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30)
1933                    inter4v = 0;
1934    
1935          iMinSAD =          if (inter4v) {
1936                  sad8(cur,                  SearchData Data8;
1937                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,                  memcpy(&Data8, Data, sizeof(SearchData)); /* quick copy of common data */
                                                 iEdgedWidth), iEdgedWidth);  
         iMinSAD +=  
                 calc_delta_8(currMV->x - center_x, currMV->y - center_y,  
                                          (uint8_t) iFcode, iQuant);  
   
         if ((iMinSAD < 256 / 4) || ((MVequal(*currMV, prevMB->mvs[iSubBlock]))  
                                                                 && ((int32_t) iMinSAD <  
                                                                         prevMB->sad8[iSubBlock]))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast8_Terminate_with_Refine;  
         }  
   
 /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion  
    vector of the median.  
    If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2  
 */  
1938    
1939          if ((bPredEq) && (MVequal(pmv[0], prevMB->mvs[iSubBlock])))                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8);
1940                  iFound = 2;                  Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8);
1941                    Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8);
1942                    Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);
1943    
1944  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.                  if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_RD))) {
1945     Otherwise select large Diamond Search.                          /* chroma is only used for comparsion to INTER. if the comparsion will be done in BITS domain, it will not be used */
1946  */                          int sumx = 0, sumy = 0;
1947    
1948          if ((!MVzero(pmv[0])) || (threshB < 1536 / 4) || (bPredEq))                          if (Data->qpel)
1949                  iDiamondSize = 1;               // 1 halfpel!                                  for (i = 1; i < 5; i++) {
1950                                            sumx += Data->currentQMV[i].x/2;
1951                                            sumy += Data->currentQMV[i].y/2;
1952                                    }
1953          else          else
1954                  iDiamondSize = 2;               // 2 halfpel = 1 full pixel!                                  for (i = 1; i < 5; i++) {
1955                                            sumx += Data->currentMV[i].x;
1956                                            sumy += Data->currentMV[i].y;
1957                                    }
1958    
1959          if (!(MotionFlags & PMV_HALFPELDIAMOND8))                          Data->iMinSAD[1] += ChromaSAD(  (sumx >> 3) + roundtab_76[sumx & 0xf],
1960                  iDiamondSize *= 2;                                                                                          (sumy >> 3) + roundtab_76[sumy & 0xf], Data);
1961                    }
1962            } else Data->iMinSAD[1] = 4096*256;
1963    }
1964    
1965    static void
1966    Search8(const SearchData * const OldData,
1967                    const int x, const int y,
1968                    const uint32_t MotionFlags,
1969                    const MBParam * const pParam,
1970                    MACROBLOCK * const pMB,
1971                    const MACROBLOCK * const pMBs,
1972                    const int block,
1973                    SearchData * const Data)
1974    {
1975            int i = 0;
1976            CheckFunc * CheckCandidate;
1977            Data->iMinSAD = OldData->iMinSAD + 1 + block;
1978            Data->currentMV = OldData->currentMV + 1 + block;
1979            Data->currentQMV = OldData->currentQMV + 1 + block;
1980    
1981            if(Data->qpel) {
1982                    Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1983                    if (block != 0) i = d_mv_bits(  Data->currentQMV->x, Data->currentQMV->y,
1984                                                                                    Data->predMV, Data->iFcode, 0, 0);
1985            } else {
1986                    Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1987                    if (block != 0) i = d_mv_bits(  Data->currentMV->x, Data->currentMV->y,
1988                                                                                    Data->predMV, Data->iFcode, 0, Data->rrv);
1989            }
1990    
1991  /*          *(Data->iMinSAD) += (Data->lambda8 * i * (*Data->iMinSAD + NEIGH_8X8_BIAS))>>10;
    Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.  
    Also calculate (0,0) but do not subtract offset.  
    Let MinSAD be the smallest SAD up to this point.  
    If MV is (0,0) subtract offset.  
 */  
1992    
1993  // the median prediction might be even better than mv16          if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) {
1994    
1995          if (!MVequal(pmv[0], startMV))                  if (Data->rrv) i = 16; else i = 8;
                 CHECK_MV8_CANDIDATE(center_x, center_y);  
1996    
1997  // (0,0) if needed                  Data->RefP[0] = OldData->RefP[0] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
1998          if (!MVzero(pmv[0]))                  Data->RefP[1] = OldData->RefP[1] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
1999                  if (!MVzero(startMV))                  Data->RefP[2] = OldData->RefP[2] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
2000                          CHECK_MV8_ZERO;                  Data->RefP[3] = OldData->RefP[3] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
   
 // previous frame MV if needed  
         if (!MVzero(prevMB->mvs[iSubBlock]))  
                 if (!MVequal(prevMB->mvs[iSubBlock], startMV))  
                         if (!MVequal(prevMB->mvs[iSubBlock], pmv[0]))  
                                 CHECK_MV8_CANDIDATE(prevMB->mvs[iSubBlock].x,  
                                                                         prevMB->mvs[iSubBlock].y);  
   
         if ((iMinSAD <= threshA) ||  
                 (MVequal(*currMV, prevMB->mvs[iSubBlock]) &&  
                  ((int32_t) iMinSAD < prevMB->sad8[iSubBlock]))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast8_Terminate_with_Refine;  
         }  
   
 // left neighbour, if allowed and needed  
         if (!MVzero(pmv[1]))  
                 if (!MVequal(pmv[1], startMV))  
                         if (!MVequal(pmv[1], prevMB->mvs[iSubBlock]))  
                                 if (!MVequal(pmv[1], pmv[0])) {  
                                         if (!(MotionFlags & PMV_HALFPEL8)) {  
                                                 pmv[1].x = EVEN(pmv[1].x);  
                                                 pmv[1].y = EVEN(pmv[1].y);  
                                         }  
                                         CHECK_MV8_CANDIDATE(pmv[1].x, pmv[1].y);  
                                 }  
 // top neighbour, if allowed and needed  
         if (!MVzero(pmv[2]))  
                 if (!MVequal(pmv[2], startMV))  
                         if (!MVequal(pmv[2], prevMB->mvs[iSubBlock]))  
                                 if (!MVequal(pmv[2], pmv[0]))  
                                         if (!MVequal(pmv[2], pmv[1])) {  
                                                 if (!(MotionFlags & PMV_HALFPEL8)) {  
                                                         pmv[2].x = EVEN(pmv[2].x);  
                                                         pmv[2].y = EVEN(pmv[2].y);  
                                                 }  
                                                 CHECK_MV8_CANDIDATE(pmv[2].x, pmv[2].y);  
   
 // top right neighbour, if allowed and needed  
                                                 if (!MVzero(pmv[3]))  
                                                         if (!MVequal(pmv[3], startMV))  
                                                                 if (!MVequal(pmv[3], prevMB->mvs[iSubBlock]))  
                                                                         if (!MVequal(pmv[3], pmv[0]))  
                                                                                 if (!MVequal(pmv[3], pmv[1]))  
                                                                                         if (!MVequal(pmv[3], pmv[2])) {  
                                                                                                 if (!  
                                                                                                         (MotionFlags &  
                                                                                                          PMV_HALFPEL8)) {  
                                                                                                         pmv[3].x = EVEN(pmv[3].x);  
                                                                                                         pmv[3].y = EVEN(pmv[3].y);  
                                                                                                 }  
                                                                                                 CHECK_MV8_CANDIDATE(pmv[3].x,  
                                                                                                                                         pmv[3].y);  
                                                                                         }  
                                         }  
   
         if ((MVzero(*currMV)) &&  
                 (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )  
                 iMinSAD -= MV8_00_BIAS;  
2001    
2002                    Data->Cur = OldData->Cur + i * ((block&1) + Data->iEdgedWidth*(block>>1));
2003                    Data->qpel_precision = 0;
2004    
2005  /* Step 6: If MinSAD <= thresa goto Step 10.                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3,
2006     If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.                                          pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
 */  
2007    
2008          if ((iMinSAD <= threshA) ||                  if (!Data->rrv) CheckCandidate = CheckCandidate8;
2009                  (MVequal(*currMV, prevMB->mvs[iSubBlock]) &&                  else CheckCandidate = CheckCandidate16no4v;
                  ((int32_t) iMinSAD < prevMB->sad8[iSubBlock]))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto PMVfast8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfast8_Terminate_with_Refine;  
         }  
2010    
2011  /************ (Diamond Search)  **************/                  if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_RD))) {
2012  /*                          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.  
 */  
2013    
2014          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                          MainSearchFunc *MainSearchPtr;
2015                            if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = SquareSearch;
2016                                    else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;
2017                                            else MainSearchPtr = DiamondSearch;
2018    
2019  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate);
         iSAD =  
                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,  
                                                   currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, iFound);  
2020    
2021          if (iSAD < iMinSAD) {                          if(*(Data->iMinSAD) < temp_sad) {
2022                  *currMV = newMV;                                          Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */
2023                  iMinSAD = iSAD;                                          Data->currentQMV->y = 2 * Data->currentMV->y;
2024                            }
2025          }          }
2026    
2027          if (MotionFlags & PMV_EXTSEARCH8) {                  if (MotionFlags & XVID_ME_HALFPELREFINE8) {
2028  /* extended: search (up to) two more times: orignal prediction and (0,0) */                          int32_t temp_sad = *(Data->iMinSAD); /* store current MinSAD */
2029    
2030                  if (!(MVequal(pmv[0], backupMV))) {                          SubpelRefine(Data, CheckCandidate); /* perform halfpel refine of current best vector */
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,  
                                                                   pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
2031    
2032                          if (iSAD < iMinSAD) {                          if(*(Data->iMinSAD) < temp_sad) { /* we have found a better match */
2033                                  *currMV = newMV;                                  Data->currentQMV->x = 2 * Data->currentMV->x; /* update our qpel vector */
2034                                  iMinSAD = iSAD;                                  Data->currentQMV->y = 2 * Data->currentMV->y;
2035                          }                          }
2036                  }                  }
2037    
2038                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                  if (Data->qpel && MotionFlags & XVID_ME_QUARTERPELREFINE8) {
2039                          iSAD =                                  Data->qpel_precision = 1;
2040                                  (*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, 3,
2041                                                                    iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,                                          pParam->width, pParam->height, Data->iFcode, 2, 0);
2042                                                                    max_dy, iEdgedWidth, iDiamondSize, iFcode,                                  SubpelRefine(Data, CheckCandidate);
2043                                                                    iQuant, iFound);                  }
2044            }
2045    
2046                          if (iSAD < iMinSAD) {          if (Data->rrv) {
2047                                  *currMV = newMV;                          Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);
2048                                  iMinSAD = iSAD;                          Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);
2049                          }                          }
2050    
2051            if(Data->qpel) {
2052                    pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x;
2053                    pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y;
2054                    pMB->qmvs[block] = *Data->currentQMV;
2055            } else {
2056                    pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x;
2057                    pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;
2058                  }                  }
2059    
2060            pMB->mvs[block] = *Data->currentMV;
2061            pMB->sad8[block] = 4 * *Data->iMinSAD;
2062          }          }
2063    
2064  /* Step 10: The motion vector is chosen according to the block corresponding to MinSAD.  /* motion estimation for B-frames */
2065     By performing an optional local half-pixel search, we can refine this result even further.  
2066  */  static __inline VECTOR
2067    ChoosePred(const MACROBLOCK * const pMB, const uint32_t mode)
2068    {
2069    /* the stupidiest function ever */
2070            return (mode == MODE_FORWARD ? pMB->mvs[0] : pMB->b_mvs[0]);
2071    }
2072    
2073    static void __inline
2074    PreparePredictionsBF(VECTOR * const pmv, const int x, const int y,
2075                                                            const uint32_t iWcount,
2076                                                            const MACROBLOCK * const pMB,
2077                                                            const uint32_t mode_curr)
2078    {
2079    
2080    PMVfast8_Terminate_with_Refine:          /* [0] is prediction */
2081          if (MotionFlags & PMV_HALFPELREFINE8)   // perform final half-pel step          pmv[0].x = EVEN(pmv[0].x); pmv[0].y = EVEN(pmv[0].y);
                 iMinSAD =  
                         Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                         iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,  
                                                         iFcode, iQuant, iEdgedWidth);  
2082    
2083            pmv[1].x = pmv[1].y = 0; /* [1] is zero */
2084    
2085            pmv[2] = ChoosePred(pMB, mode_curr);
2086            pmv[2].x = EVEN(pmv[2].x); pmv[2].y = EVEN(pmv[2].y);
2087    
2088            if ((y != 0)&&(x != (int)(iWcount+1))) {                        /* [3] top-right neighbour */
2089                    pmv[3] = ChoosePred(pMB+1-iWcount, mode_curr);
2090                    pmv[3].x = EVEN(pmv[3].x); pmv[3].y = EVEN(pmv[3].y);
2091            } else pmv[3].x = pmv[3].y = 0;
2092    
2093            if (y != 0) {
2094                    pmv[4] = ChoosePred(pMB-iWcount, mode_curr);
2095                    pmv[4].x = EVEN(pmv[4].x); pmv[4].y = EVEN(pmv[4].y);
2096            } else pmv[4].x = pmv[4].y = 0;
2097    
2098    PMVfast8_Terminate_without_Refine:          if (x != 0) {
2099          currPMV->x = currMV->x - center_x;                  pmv[5] = ChoosePred(pMB-1, mode_curr);
2100          currPMV->y = currMV->y - center_y;                  pmv[5].x = EVEN(pmv[5].x); pmv[5].y = EVEN(pmv[5].y);
2101            } else pmv[5].x = pmv[5].y = 0;
2102    
2103          return iMinSAD;          if (x != 0 && y != 0) {
2104                    pmv[6] = ChoosePred(pMB-1-iWcount, mode_curr);
2105                    pmv[6].x = EVEN(pmv[6].x); pmv[6].y = EVEN(pmv[6].y);
2106            } else pmv[6].x = pmv[6].y = 0;
2107  }  }
2108    
2109  int32_t  
2110  EPZSSearch16(const uint8_t * const pRef,  /* search backward or forward */
2111    static void
2112    SearchBF(       const IMAGE * const pRef,
2113                           const uint8_t * const pRefH,                           const uint8_t * const pRefH,
2114                           const uint8_t * const pRefV,                           const uint8_t * const pRefV,
2115                           const uint8_t * const pRefHV,                           const uint8_t * const pRefHV,
2116                           const IMAGE * const pCur,                           const IMAGE * const pCur,
2117                           const int x,                          const int x, const int y,
                          const int y,  
                         const int start_x,  
                         const int start_y,  
                         const int center_x,  
                         const int center_y,  
2118                           const uint32_t MotionFlags,                           const uint32_t MotionFlags,
                          const uint32_t iQuant,  
2119                           const uint32_t iFcode,                           const uint32_t iFcode,
2120                           const MBParam * const pParam,                           const MBParam * const pParam,
2121                           const MACROBLOCK * const pMBs,                          MACROBLOCK * const pMB,
2122                           const MACROBLOCK * const prevMBs,                          const VECTOR * const predMV,
2123                           VECTOR * const currMV,                          int32_t * const best_sad,
2124                           VECTOR * const currPMV)                          const int32_t mode_current,
2125  {                          SearchData * const Data)
2126          const uint32_t iWcount = pParam->mb_width;  {
2127          const uint32_t iHcount = pParam->mb_height;  
2128            int i;
2129          const int32_t iWidth = pParam->width;          VECTOR pmv[7];
2130          const int32_t iHeight = pParam->height;          MainSearchFunc *MainSearchPtr;
2131          const int32_t iEdgedWidth = pParam->edged_width;          *Data->iMinSAD = MV_MAX_ERROR;
2132            Data->iFcode = iFcode;
2133          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;          Data->qpel_precision = 0;
2134            Data->temp[5] = Data->temp[6] = Data->temp[7] = 256*4096; /* reset chroma-sad cache */
2135    
2136            Data->RefP[0] = pRef->y + (x + Data->iEdgedWidth*y) * 16;
2137            Data->RefP[2] = pRefH + (x + Data->iEdgedWidth*y) * 16;
2138            Data->RefP[1] = pRefV + (x + Data->iEdgedWidth*y) * 16;
2139            Data->RefP[3] = pRefHV + (x + Data->iEdgedWidth*y) * 16;
2140            Data->RefP[4] = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8;
2141            Data->RefP[5] = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8;
2142    
2143            Data->predMV = *predMV;
2144    
2145            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
2146                                    pParam->width, pParam->height, iFcode - Data->qpel, 1, 0);
2147    
2148            pmv[0] = Data->predMV;
2149            if (Data->qpel) { pmv[0].x /= 2; pmv[0].y /= 2; }
2150    
2151            PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current);
2152    
2153            Data->currentMV->x = Data->currentMV->y = 0;
2154    
2155            /* main loop. checking all predictions */
2156            for (i = 0; i < 7; i++)
2157                    if (!vector_repeats(pmv, i) )
2158                            CheckCandidate16no4v(pmv[i].x, pmv[i].y, Data, i);
2159    
2160            if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
2161            else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
2162                    else MainSearchPtr = DiamondSearch;
2163    
2164            if (*Data->iMinSAD > 512) {
2165                    unsigned int mask = make_mask(pmv, 7, *Data->dir);
2166                    MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate16no4v);
2167            }
2168    
2169            SubpelRefine(Data, CheckCandidate16no4v);
2170    
2171            if (Data->qpel && *Data->iMinSAD < *best_sad + 300) {
2172                    Data->currentQMV->x = 2*Data->currentMV->x;
2173                    Data->currentQMV->y = 2*Data->currentMV->y;
2174                    Data->qpel_precision = 1;
2175                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
2176                                            pParam->width, pParam->height, iFcode, 2, 0);
2177                    SubpelRefine(Data, CheckCandidate16no4v);
2178            }
2179    
2180            /* three bits are needed to code backward mode. four for forward */
2181    
2182            if (mode_current == MODE_FORWARD) *Data->iMinSAD += 4 * Data->lambda16;
2183            else *Data->iMinSAD += 3 * Data->lambda16;
2184    
2185            if (*Data->iMinSAD < *best_sad) {
2186                    *best_sad = *Data->iMinSAD;
2187                    pMB->mode = mode_current;
2188                    if (Data->qpel) {
2189                            pMB->pmvs[0].x = Data->currentQMV->x - predMV->x;
2190                            pMB->pmvs[0].y = Data->currentQMV->y - predMV->y;
2191                            if (mode_current == MODE_FORWARD)
2192                                    pMB->qmvs[0] = *Data->currentQMV;
2193                            else
2194                                    pMB->b_qmvs[0] = *Data->currentQMV;
2195                    } else {
2196                            pMB->pmvs[0].x = Data->currentMV->x - predMV->x;
2197                            pMB->pmvs[0].y = Data->currentMV->y - predMV->y;
2198                    }
2199                    if (mode_current == MODE_FORWARD) pMB->mvs[0] = *Data->currentMV;
2200                    else pMB->b_mvs[0] = *Data->currentMV;
2201            }
2202    
2203          int32_t min_dx;          if (mode_current == MODE_FORWARD) *(Data->currentMV+2) = *Data->currentMV;
2204          int32_t max_dx;          else *(Data->currentMV+1) = *Data->currentMV; /* we store currmv for interpolate search */
2205          int32_t min_dy;  }
2206          int32_t max_dy;  
2207    static void
2208    SkipDecisionB(const IMAGE * const pCur,
2209                                    const IMAGE * const f_Ref,
2210                                    const IMAGE * const b_Ref,
2211                                    MACROBLOCK * const pMB,
2212                                    const uint32_t x, const uint32_t y,
2213                                    const SearchData * const Data)
2214    {
2215            int dx = 0, dy = 0, b_dx = 0, b_dy = 0;
2216            int32_t sum;
2217            int k;
2218            const uint32_t stride = Data->iEdgedWidth/2;
2219            /* this is not full chroma compensation, only it's fullpel approximation. should work though */
2220    
2221          VECTOR newMV;          for (k = 0; k < 4; k++) {
2222          VECTOR backupMV;                  dy += Data->directmvF[k].y >> Data->qpel;
2223                    dx += Data->directmvF[k].x >> Data->qpel;
2224                    b_dy += Data->directmvB[k].y >> Data->qpel;
2225                    b_dx += Data->directmvB[k].x >> Data->qpel;
2226            }
2227    
2228            dy = (dy >> 3) + roundtab_76[dy & 0xf];
2229            dx = (dx >> 3) + roundtab_76[dx & 0xf];
2230            b_dy = (b_dy >> 3) + roundtab_76[b_dy & 0xf];
2231            b_dx = (b_dx >> 3) + roundtab_76[b_dx & 0xf];
2232    
2233            sum = sad8bi(pCur->u + 8 * x + 8 * y * stride,
2234                                            f_Ref->u + (y*8 + dy/2) * stride + x*8 + dx/2,
2235                                            b_Ref->u + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
2236                                            stride);
2237    
2238            if (sum >= MAX_CHROMA_SAD_FOR_SKIP * Data->iQuant) return; /* no skip */
2239    
2240            sum += sad8bi(pCur->v + 8*x + 8 * y * stride,
2241                                            f_Ref->v + (y*8 + dy/2) * stride + x*8 + dx/2,
2242                                            b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
2243                                            stride);
2244    
2245          VECTOR pmv[4];          if (sum < MAX_CHROMA_SAD_FOR_SKIP * Data->iQuant) {
2246          int32_t psad[8];                  pMB->mode = MODE_DIRECT_NONE_MV; /* skipped */
2247                    for (k = 0; k < 4; k++) {
2248                            pMB->qmvs[k] = pMB->mvs[k];
2249                            pMB->b_qmvs[k] = pMB->b_mvs[k];
2250                    }
2251            }
2252    }
2253    
2254          static MACROBLOCK *oldMBs = NULL;  static __inline uint32_t
2255    SearchDirect(const IMAGE * const f_Ref,
2256                                    const uint8_t * const f_RefH,
2257                                    const uint8_t * const f_RefV,
2258                                    const uint8_t * const f_RefHV,
2259                                    const IMAGE * const b_Ref,
2260                                    const uint8_t * const b_RefH,
2261                                    const uint8_t * const b_RefV,
2262                                    const uint8_t * const b_RefHV,
2263                                    const IMAGE * const pCur,
2264                                    const int x, const int y,
2265                                    const uint32_t MotionFlags,
2266                                    const int32_t TRB, const int32_t TRD,
2267                                    const MBParam * const pParam,
2268                                    MACROBLOCK * const pMB,
2269                                    const MACROBLOCK * const b_mb,
2270                                    int32_t * const best_sad,
2271                                    SearchData * const Data)
2272    
2273    {
2274            int32_t skip_sad;
2275            int k = (x + Data->iEdgedWidth*y) * 16;
2276            MainSearchFunc *MainSearchPtr;
2277            CheckFunc * CheckCandidate;
2278    
2279            *Data->iMinSAD = 256*4096;
2280            Data->RefP[0] = f_Ref->y + k;
2281            Data->RefP[2] = f_RefH + k;
2282            Data->RefP[1] = f_RefV + k;
2283            Data->RefP[3] = f_RefHV + k;
2284            Data->b_RefP[0] = b_Ref->y + k;
2285            Data->b_RefP[2] = b_RefH + k;
2286            Data->b_RefP[1] = b_RefV + k;
2287            Data->b_RefP[3] = b_RefHV + k;
2288            Data->RefP[4] = f_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
2289            Data->RefP[5] = f_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
2290            Data->b_RefP[4] = b_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
2291            Data->b_RefP[5] = b_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
2292    
2293            k = Data->qpel ? 4 : 2;
2294            Data->max_dx = k * (pParam->width - x * 16);
2295            Data->max_dy = k * (pParam->height - y * 16);
2296            Data->min_dx = -k * (16 + x * 16);
2297            Data->min_dy = -k * (16 + y * 16);
2298    
2299  //  const MACROBLOCK * const pMB = pMBs + x + y * iWcount;          Data->referencemv = Data->qpel ? b_mb->qmvs : b_mb->mvs;
2300          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;          Data->qpel_precision = 0;
         MACROBLOCK *oldMB = NULL;  
2301    
2302           int32_t thresh2;          for (k = 0; k < 4; k++) {
2303          int32_t bPredEq;                  pMB->mvs[k].x = Data->directmvF[k].x = ((TRB * Data->referencemv[k].x) / TRD);
2304          int32_t iMinSAD, iSAD = 9999;                  pMB->b_mvs[k].x = Data->directmvB[k].x = ((TRB - TRD) * Data->referencemv[k].x) / TRD;
2305                    pMB->mvs[k].y = Data->directmvF[k].y = ((TRB * Data->referencemv[k].y) / TRD);
2306                    pMB->b_mvs[k].y = Data->directmvB[k].y = ((TRB - TRD) * Data->referencemv[k].y) / TRD;
2307    
2308          MainSearch16FuncPtr MainSearchPtr;                  if ( (pMB->b_mvs[k].x > Data->max_dx) | (pMB->b_mvs[k].x < Data->min_dx)
2309                            | (pMB->b_mvs[k].y > Data->max_dy) | (pMB->b_mvs[k].y < Data->min_dy) ) {
2310    
2311          if (oldMBs == NULL) {                          *best_sad = 256*4096; /* in that case, we won't use direct mode */
2312                  oldMBs = (MACROBLOCK *) calloc(iWcount * iHcount, sizeof(MACROBLOCK));                          pMB->mode = MODE_DIRECT; /* just to make sure it doesn't say "MODE_DIRECT_NONE_MV" */
2313  //      fprintf(stderr,"allocated %d bytes for oldMBs\n",iWcount*iHcount*sizeof(MACROBLOCK));                          pMB->b_mvs[0].x = pMB->b_mvs[0].y = 0;
2314                            return 256*4096;
2315                    }
2316                    if (b_mb->mode != MODE_INTER4V) {
2317                            pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mvs[0];
2318                            pMB->b_mvs[1] = pMB->b_mvs[2] = pMB->b_mvs[3] = pMB->b_mvs[0];
2319                            Data->directmvF[1] = Data->directmvF[2] = Data->directmvF[3] = Data->directmvF[0];
2320                            Data->directmvB[1] = Data->directmvB[2] = Data->directmvB[3] = Data->directmvB[0];
2321                            break;
2322                    }
2323          }          }
         oldMB = oldMBs + x + y * iWcount;  
2324    
2325  /* Get maximum range */          CheckCandidate = b_mb->mode == MODE_INTER4V ? CheckCandidateDirect : CheckCandidateDirectno4v;
         get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,  
                           iFcode);  
2326    
2327          if (!(MotionFlags & PMV_HALFPEL16)) {          CheckCandidate(0, 0, Data, 255);
2328                  min_dx = EVEN(min_dx);  
2329                  max_dx = EVEN(max_dx);          /* initial (fast) skip decision */
2330                  min_dy = EVEN(min_dy);          if (*Data->iMinSAD < Data->iQuant * INITIAL_SKIP_THRESH * (Data->chroma?3:2)) {
2331                  max_dy = EVEN(max_dy);                  /* possible skip */
2332                    if (Data->chroma) {
2333                            pMB->mode = MODE_DIRECT_NONE_MV;
2334                            return *Data->iMinSAD; /* skip. */
2335                    } else {
2336                            SkipDecisionB(pCur, f_Ref, b_Ref, pMB, x, y, Data);
2337                            if (pMB->mode == MODE_DIRECT_NONE_MV) return *Data->iMinSAD; /* skip. */
2338          }          }
2339          /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */          }
2340          //bPredEq = get_pmvdata(pMBs, x, y, iWcount, 0, pmv, psad);  
2341          bPredEq = get_pmvdata2(pMBs, iWcount, 0, x, y, 0, pmv, psad);          *Data->iMinSAD += Data->lambda16;
2342            skip_sad = *Data->iMinSAD;
2343    
2344  /* Step 4: Calculate SAD around the Median prediction.          /*
2345          MinSAD=SAD           * DIRECT MODE DELTA VECTOR SEARCH.
2346          If Motion Vector equal to Previous frame motion vector           * This has to be made more effective, but at the moment I'm happy it's running at all
                 and MinSAD<PrevFrmSAD goto Step 10.  
         If SAD<=256 goto Step 10.  
2347  */  */
2348    
2349  // Prepare for main loop          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
2350                    else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
2351                            else MainSearchPtr = DiamondSearch;
2352    
2353          currMV->x = start_x;          MainSearchPtr(0, 0, Data, 255, CheckCandidate);
         currMV->y = start_y;  
2354    
2355          if (!(MotionFlags & PMV_HALFPEL16)) {          SubpelRefine(Data, CheckCandidate);
                 currMV->x = EVEN(currMV->x);  
                 currMV->y = EVEN(currMV->y);  
         }  
   
         if (currMV->x > max_dx)  
                 currMV->x = max_dx;  
         if (currMV->x < min_dx)  
                 currMV->x = min_dx;  
         if (currMV->y > max_dy)  
                 currMV->y = max_dy;  
         if (currMV->y < min_dy)  
                 currMV->y = min_dy;  
   
 /***************** This is predictor SET A: only median prediction ******************/  
   
         iMinSAD =  
                 sad16(cur,  
                           get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 16, currMV,  
                                                  iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);  
         iMinSAD +=  
                 calc_delta_16(currMV->x - center_x, currMV->y - center_y,  
                                           (uint8_t) iFcode, iQuant);  
   
 // thresh1 is fixed to 256  
         if ((iMinSAD < 256) ||  
                 ((MVequal(*currMV, prevMB->mvs[0])) &&  
                  ((int32_t) iMinSAD < prevMB->sad16))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto EPZS16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto EPZS16_Terminate_with_Refine;  
         }  
   
 /************** This is predictor SET B: (0,0), prev.frame MV, neighbours **************/  
2356    
2357  // previous frame MV          *best_sad = *Data->iMinSAD;
         CHECK_MV16_CANDIDATE(prevMB->mvs[0].x, prevMB->mvs[0].y);  
2358    
2359  // set threshhold based on Min of Prediction and SAD of collocated block          if (Data->qpel || b_mb->mode == MODE_INTER4V) pMB->mode = MODE_DIRECT;
2360  // CHECK_MV16 always uses iSAD for the SAD of last vector to check, so now iSAD is what we want          else pMB->mode = MODE_DIRECT_NO4V; /* for faster compensation */
2361    
2362          if ((x == 0) && (y == 0)) {          pMB->pmvs[3] = *Data->currentMV;
                 thresh2 = 512;  
         } else {  
 /* T_k = 1.2 * MIN(SAD_top,SAD_left,SAD_topleft,SAD_coll) +128;   [Tourapis, 2002] */  
2363    
2364                  thresh2 = MIN(psad[0], iSAD) * 6 / 5 + 128;          for (k = 0; k < 4; k++) {
2365                    pMB->mvs[k].x = Data->directmvF[k].x + Data->currentMV->x;
2366                    pMB->b_mvs[k].x = (     (Data->currentMV->x == 0)
2367                                                            ? Data->directmvB[k].x
2368                                                            :pMB->mvs[k].x - Data->referencemv[k].x);
2369                    pMB->mvs[k].y = (Data->directmvF[k].y + Data->currentMV->y);
2370                    pMB->b_mvs[k].y = ((Data->currentMV->y == 0)
2371                                                            ? Data->directmvB[k].y
2372                                                            : pMB->mvs[k].y - Data->referencemv[k].y);
2373                    if (Data->qpel) {
2374                            pMB->qmvs[k].x = pMB->mvs[k].x; pMB->mvs[k].x /= 2;
2375                            pMB->b_qmvs[k].x = pMB->b_mvs[k].x; pMB->b_mvs[k].x /= 2;
2376                            pMB->qmvs[k].y = pMB->mvs[k].y; pMB->mvs[k].y /= 2;
2377                            pMB->b_qmvs[k].y = pMB->b_mvs[k].y; pMB->b_mvs[k].y /= 2;
2378                    }
2379    
2380                    if (b_mb->mode != MODE_INTER4V) {
2381                            pMB->mvs[3] = pMB->mvs[2] = pMB->mvs[1] = pMB->mvs[0];
2382                            pMB->b_mvs[3] = pMB->b_mvs[2] = pMB->b_mvs[1] = pMB->b_mvs[0];
2383                            pMB->qmvs[3] = pMB->qmvs[2] = pMB->qmvs[1] = pMB->qmvs[0];
2384                            pMB->b_qmvs[3] = pMB->b_qmvs[2] = pMB->b_qmvs[1] = pMB->b_qmvs[0];
2385                            break;
2386          }          }
2387            }
2388            return skip_sad;
2389    }
2390    
2391    static void
2392    SearchInterpolate(const IMAGE * const f_Ref,
2393                                    const uint8_t * const f_RefH,
2394                                    const uint8_t * const f_RefV,
2395                                    const uint8_t * const f_RefHV,
2396                                    const IMAGE * const b_Ref,
2397                                    const uint8_t * const b_RefH,
2398                                    const uint8_t * const b_RefV,
2399                                    const uint8_t * const b_RefHV,
2400                                    const IMAGE * const pCur,
2401                                    const int x, const int y,
2402                                    const uint32_t fcode,
2403                                    const uint32_t bcode,
2404                                    const uint32_t MotionFlags,
2405                                    const MBParam * const pParam,
2406                                    const VECTOR * const f_predMV,
2407                                    const VECTOR * const b_predMV,
2408                                    MACROBLOCK * const pMB,
2409                                    int32_t * const best_sad,
2410                                    SearchData * const fData)
2411    
2412  // MV=(0,0) is often a good choice  {
2413    
2414          CHECK_MV16_ZERO;          int i, j;
2415            SearchData bData;
2416    
2417            fData->qpel_precision = 0;
2418            memcpy(&bData, fData, sizeof(SearchData)); /* quick copy of common data */
2419            *fData->iMinSAD = 4096*256;
2420            bData.currentMV++; bData.currentQMV++;
2421            fData->iFcode = bData.bFcode = fcode; fData->bFcode = bData.iFcode = bcode;
2422    
2423            i = (x + y * fData->iEdgedWidth) * 16;
2424    
2425            bData.b_RefP[0] = fData->RefP[0] = f_Ref->y + i;
2426            bData.b_RefP[2] = fData->RefP[2] = f_RefH + i;
2427            bData.b_RefP[1] = fData->RefP[1] = f_RefV + i;
2428            bData.b_RefP[3] = fData->RefP[3] = f_RefHV + i;
2429            bData.RefP[0] = fData->b_RefP[0] = b_Ref->y + i;
2430            bData.RefP[2] = fData->b_RefP[2] = b_RefH + i;
2431            bData.RefP[1] = fData->b_RefP[1] = b_RefV + i;
2432            bData.RefP[3] = fData->b_RefP[3] = b_RefHV + i;
2433            bData.b_RefP[4] = fData->RefP[4] = f_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
2434            bData.b_RefP[5] = fData->RefP[5] = f_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
2435            bData.RefP[4] = fData->b_RefP[4] = b_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
2436            bData.RefP[5] = fData->b_RefP[5] = b_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
2437            bData.dir = fData->dir;
2438    
2439            bData.bpredMV = fData->predMV = *f_predMV;
2440            fData->bpredMV = bData.predMV = *b_predMV;
2441            fData->currentMV[0] = fData->currentMV[2];
2442    
2443            get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 4, pParam->width, pParam->height, fcode - fData->qpel, 1, 0);
2444            get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 4, pParam->width, pParam->height, bcode - fData->qpel, 1, 0);
2445    
2446            if (fData->currentMV[0].x > fData->max_dx) fData->currentMV[0].x = fData->max_dx;
2447            if (fData->currentMV[0].x < fData->min_dx) fData->currentMV[0].x = fData->min_dx;
2448            if (fData->currentMV[0].y > fData->max_dy) fData->currentMV[0].y = fData->max_dy;
2449            if (fData->currentMV[0].y < fData->min_dy) fData->currentMV[0].y = fData->min_dy;
2450    
2451            if (fData->currentMV[1].x > bData.max_dx) fData->currentMV[1].x = bData.max_dx;
2452            if (fData->currentMV[1].x < bData.min_dx) fData->currentMV[1].x = bData.min_dx;
2453            if (fData->currentMV[1].y > bData.max_dy) fData->currentMV[1].y = bData.max_dy;
2454            if (fData->currentMV[1].y < bData.min_dy) fData->currentMV[1].y = bData.min_dy;
2455    
2456            CheckCandidateInt(fData->currentMV[0].x, fData->currentMV[0].y, fData, 255);
2457    
2458  // left neighbour, if allowed          /* diamond */
2459          if (x != 0) {          do {
2460                  if (!(MotionFlags & PMV_HALFPEL16)) {                  *fData->dir = 255;
2461                          pmv[1].x = EVEN(pmv[1].x);                  /* forward MV moves */
2462                          pmv[1].y = EVEN(pmv[1].y);                  i = fData->currentMV[0].x; j = fData->currentMV[0].y;
2463    
2464                    CheckCandidateInt(i + 1, j, fData, 0);
2465                    CheckCandidateInt(i, j + 1, fData, 0);
2466                    CheckCandidateInt(i - 1, j, fData, 0);
2467                    CheckCandidateInt(i, j - 1, fData, 0);
2468    
2469                    /* backward MV moves */
2470                    i = fData->currentMV[1].x; j = fData->currentMV[1].y;
2471                    fData->currentMV[2] = fData->currentMV[0];
2472                    CheckCandidateInt(i + 1, j, &bData, 0);
2473                    CheckCandidateInt(i, j + 1, &bData, 0);
2474                    CheckCandidateInt(i - 1, j, &bData, 0);
2475                    CheckCandidateInt(i, j - 1, &bData, 0);
2476    
2477            } while (!(*fData->dir));
2478    
2479            /* qpel refinement */
2480            if (fData->qpel) {
2481                    if (*fData->iMinSAD > *best_sad + 500) return;
2482                    fData->qpel_precision = bData.qpel_precision = 1;
2483                    get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 4, pParam->width, pParam->height, fcode, 2, 0);
2484                    get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 4, pParam->width, pParam->height, bcode, 2, 0);
2485                    fData->currentQMV[2].x = fData->currentQMV[0].x = 2 * fData->currentMV[0].x;
2486                    fData->currentQMV[2].y = fData->currentQMV[0].y = 2 * fData->currentMV[0].y;
2487                    fData->currentQMV[1].x = 2 * fData->currentMV[1].x;
2488                    fData->currentQMV[1].y = 2 * fData->currentMV[1].y;
2489                    SubpelRefine(fData, CheckCandidateInt);
2490                    if (*fData->iMinSAD > *best_sad + 300) return;
2491                    fData->currentQMV[2] = fData->currentQMV[0];
2492                    SubpelRefine(&bData, CheckCandidateInt);
2493            }
2494    
2495            *fData->iMinSAD += (2+3) * fData->lambda16; /* two bits are needed to code interpolate mode. */
2496    
2497            if (*fData->iMinSAD < *best_sad) {
2498                    *best_sad = *fData->iMinSAD;
2499                    pMB->mvs[0] = fData->currentMV[0];
2500                    pMB->b_mvs[0] = fData->currentMV[1];
2501                    pMB->mode = MODE_INTERPOLATE;
2502                    if (fData->qpel) {
2503                            pMB->qmvs[0] = fData->currentQMV[0];
2504                            pMB->b_qmvs[0] = fData->currentQMV[1];
2505                            pMB->pmvs[1].x = pMB->qmvs[0].x - f_predMV->x;
2506                            pMB->pmvs[1].y = pMB->qmvs[0].y - f_predMV->y;
2507                            pMB->pmvs[0].x = pMB->b_qmvs[0].x - b_predMV->x;
2508                            pMB->pmvs[0].y = pMB->b_qmvs[0].y - b_predMV->y;
2509                    } else {
2510                            pMB->pmvs[1].x = pMB->mvs[0].x - f_predMV->x;
2511                            pMB->pmvs[1].y = pMB->mvs[0].y - f_predMV->y;
2512                            pMB->pmvs[0].x = pMB->b_mvs[0].x - b_predMV->x;
2513                            pMB->pmvs[0].y = pMB->b_mvs[0].y - b_predMV->y;
2514                  }                  }
                 CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);  
2515          }          }
 // top neighbour, if allowed  
         if (y != 0) {  
                 if (!(MotionFlags & PMV_HALFPEL16)) {  
                         pmv[2].x = EVEN(pmv[2].x);  
                         pmv[2].y = EVEN(pmv[2].y);  
2516                  }                  }
                 CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
2517    
2518  // top right neighbour, if allowed  void
2519                  if ((uint32_t) x != (iWcount - 1)) {  MotionEstimationBVOP(MBParam * const pParam,
2520                          if (!(MotionFlags & PMV_HALFPEL16)) {                                           FRAMEINFO * const frame,
2521                                  pmv[3].x = EVEN(pmv[3].x);                                           const int32_t time_bp,
2522                                  pmv[3].y = EVEN(pmv[3].y);                                           const int32_t time_pp,
2523                                             /* forward (past) reference */
2524                                             const MACROBLOCK * const f_mbs,
2525                                             const IMAGE * const f_ref,
2526                                             const IMAGE * const f_refH,
2527                                             const IMAGE * const f_refV,
2528                                             const IMAGE * const f_refHV,
2529                                             /* backward (future) reference */
2530                                             const FRAMEINFO * const b_reference,
2531                                             const IMAGE * const b_ref,
2532                                             const IMAGE * const b_refH,
2533                                             const IMAGE * const b_refV,
2534                                             const IMAGE * const b_refHV)
2535    {
2536            uint32_t i, j;
2537            int32_t best_sad;
2538            uint32_t skip_sad;
2539            int f_count = 0, b_count = 0, i_count = 0, d_count = 0, n_count = 0;
2540            const MACROBLOCK * const b_mbs = b_reference->mbs;
2541    
2542            VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/
2543    
2544            const int32_t TRB = time_pp - time_bp;
2545            const int32_t TRD = time_pp;
2546    
2547            /* some pre-inintialized data for the rest of the search */
2548    
2549            SearchData Data;
2550            int32_t iMinSAD;
2551            uint32_t dir;
2552            VECTOR currentMV[3];
2553            VECTOR currentQMV[3];
2554            int32_t temp[8];
2555            memset(&Data, 0, sizeof(SearchData));
2556            Data.iEdgedWidth = pParam->edged_width;
2557            Data.currentMV = currentMV; Data.currentQMV = currentQMV;
2558            Data.iMinSAD = &iMinSAD;
2559            Data.lambda16 = lambda_vec16[MAX(frame->quant-2, 2)];
2560            Data.qpel = pParam->vol_flags & XVID_VOL_QUARTERPEL ? 1 : 0;
2561            Data.rounding = 0;
2562            Data.chroma = frame->motion_flags & XVID_ME_CHROMA_BVOP;
2563            Data.temp = temp;
2564            Data.dir = &dir;
2565            Data.iQuant = frame->quant;
2566    
2567            Data.RefQ = f_refV->u; /* a good place, also used in MC (for similar purpose) */
2568    
2569            /* note: i==horizontal, j==vertical */
2570            for (j = 0; j < pParam->mb_height; j++) {
2571    
2572                    f_predMV = b_predMV = zeroMV;   /* prediction is reset at left boundary */
2573    
2574                    for (i = 0; i < pParam->mb_width; i++) {
2575                            MACROBLOCK * const pMB = frame->mbs + i + j * pParam->mb_width;
2576                            const MACROBLOCK * const b_mb = b_mbs + i + j * pParam->mb_width;
2577    
2578    /* special case, if collocated block is SKIPed in P-VOP: encoding is forward (0,0), cpb=0 without further ado */
2579                            if (b_reference->coding_type != S_VOP)
2580                                    if (b_mb->mode == MODE_NOT_CODED) {
2581                                            pMB->mode = MODE_NOT_CODED;
2582                                            continue;
2583                                    }
2584    
2585                            Data.Cur = frame->image.y + (j * Data.iEdgedWidth + i) * 16;
2586                            Data.CurU = frame->image.u + (j * Data.iEdgedWidth/2 + i) * 8;
2587                            Data.CurV = frame->image.v + (j * Data.iEdgedWidth/2 + i) * 8;
2588    
2589    /* direct search comes first, because it (1) checks for SKIP-mode
2590            and (2) sets very good predictions for forward and backward search */
2591                            skip_sad = SearchDirect(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2592                                                                            b_ref, b_refH->y, b_refV->y, b_refHV->y,
2593                                                                            &frame->image,
2594                                                                            i, j,
2595                                                                            frame->motion_flags,
2596                                                                            TRB, TRD,
2597                                                                            pParam,
2598                                                                            pMB, b_mb,
2599                                                                            &best_sad,
2600                                                                            &Data);
2601    
2602                            if (pMB->mode == MODE_DIRECT_NONE_MV) { n_count++; continue; }
2603    
2604                            /* forward search */
2605                            SearchBF(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2606                                                    &frame->image, i, j,
2607                                                    frame->motion_flags,
2608                                                    frame->fcode, pParam,
2609                                                    pMB, &f_predMV, &best_sad,
2610                                                    MODE_FORWARD, &Data);
2611    
2612                            /* backward search */
2613                            SearchBF(b_ref, b_refH->y, b_refV->y, b_refHV->y,
2614                                                    &frame->image, i, j,
2615                                                    frame->motion_flags,
2616                                                    frame->bcode, pParam,
2617                                                    pMB, &b_predMV, &best_sad,
2618                                                    MODE_BACKWARD, &Data);
2619    
2620                            /* interpolate search comes last, because it uses data from forward and backward as prediction */
2621                            SearchInterpolate(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2622                                                    b_ref, b_refH->y, b_refV->y, b_refHV->y,
2623                                                    &frame->image,
2624                                                    i, j,
2625                                                    frame->fcode, frame->bcode,
2626                                                    frame->motion_flags,
2627                                                    pParam,
2628                                                    &f_predMV, &b_predMV,
2629                                                    pMB, &best_sad,
2630                                                    &Data);
2631    
2632                            /* final skip decision */
2633                            if ( (skip_sad < Data.iQuant * MAX_SAD00_FOR_SKIP * 2)
2634                                            && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) )
2635                                    SkipDecisionB(&frame->image, f_ref, b_ref, pMB, i, j, &Data);
2636    
2637                            switch (pMB->mode) {
2638                                    case MODE_FORWARD:
2639                                            f_count++;
2640                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2641                                            break;
2642                                    case MODE_BACKWARD:
2643                                            b_count++;
2644                                            b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2645                                            break;
2646                                    case MODE_INTERPOLATE:
2647                                            i_count++;
2648                                            f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2649                                            b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2650                                            break;
2651                                    case MODE_DIRECT:
2652                                    case MODE_DIRECT_NO4V:
2653                                            d_count++;
2654                                    default:
2655                                            break;
2656                          }                          }
                         CHECK_MV16_CANDIDATE(pmv[3].x, pmv[3].y);  
2657                  }                  }
2658          }          }
   
 /* Terminate if MinSAD <= T_2  
    Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]  
 */  
   
         if ((iMinSAD <= thresh2)  
                 || (MVequal(*currMV, prevMB->mvs[0]) &&  
                         ((int32_t) iMinSAD <= prevMB->sad16))) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto EPZS16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto EPZS16_Terminate_with_Refine;  
2659          }          }
2660    
2661  /***** predictor SET C: acceleration MV (new!), neighbours in prev. frame(new!) ****/  static __inline void
2662    MEanalyzeMB (   const uint8_t * const pRef,
2663          backupMV = prevMB->mvs[0];      // collocated MV                                  const uint8_t * const pCur,
2664          backupMV.x += (prevMB->mvs[0].x - oldMB->mvs[0].x);     // acceleration X                                  const int x,
2665          backupMV.y += (prevMB->mvs[0].y - oldMB->mvs[0].y);     // acceleration Y                                  const int y,
2666                                    const MBParam * const pParam,
2667                                    MACROBLOCK * const pMBs,
2668                                    SearchData * const Data)
2669    {
2670    
2671          CHECK_MV16_CANDIDATE(backupMV.x, backupMV.y);          int i;
2672            VECTOR pmv[3];
2673            MACROBLOCK * const pMB = &pMBs[x + y * pParam->mb_width];
2674    
2675  // left neighbour          unsigned int simplicity = 0;
         if (x != 0)  
                 CHECK_MV16_CANDIDATE((prevMB - 1)->mvs[0].x, (prevMB - 1)->mvs[0].y);  
2676    
2677  // top neighbour          for (i = 0; i < 5; i++) Data->iMinSAD[i] = MV_MAX_ERROR;
         if (y != 0)  
                 CHECK_MV16_CANDIDATE((prevMB - iWcount)->mvs[0].x,  
                                                          (prevMB - iWcount)->mvs[0].y);  
2678    
2679  // right neighbour, if allowed (this value is not written yet, so take it from   pMB->mvs          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
2680                            pParam->width, pParam->height, Data->iFcode - Data->qpel - 1, 0, 0);
2681    
2682          if ((uint32_t) x != iWcount - 1)          Data->Cur = pCur + (x + y * pParam->edged_width) * 16;
2683                  CHECK_MV16_CANDIDATE((prevMB + 1)->mvs[0].x, (prevMB + 1)->mvs[0].y);          Data->RefP[0] = pRef + (x + y * pParam->edged_width) * 16;
2684    
2685  // bottom neighbour, dito          pmv[0].x = pMB->mvs[0].x;
2686          if ((uint32_t) y != iHcount - 1)          pmv[0].y = pMB->mvs[0].y;
                 CHECK_MV16_CANDIDATE((prevMB + iWcount)->mvs[0].x,  
                                                          (prevMB + iWcount)->mvs[0].y);  
2687    
2688  /* Terminate if MinSAD <= T_3 (here T_3 = T_2)  */          CheckCandidate32I(pmv[0].x, pmv[0].y, Data, 0);
         if (iMinSAD <= thresh2) {  
                 if (MotionFlags & PMV_QUICKSTOP16)  
                         goto EPZS16_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto EPZS16_Terminate_with_Refine;  
         }  
2689    
2690  /************ (if Diamond Search)  **************/          if (*Data->iMinSAD > 200) {
2691    
2692          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                  pmv[1].x = pmv[1].y = 0;
2693    
2694          if (MotionFlags & PMV_USESQUARES16)                  /* median is only used as prediction. it doesn't have to be real */
2695                  MainSearchPtr = Square16_MainSearch;                  if (x == 1 && y == 1) Data->predMV.x = Data->predMV.y = 0;
2696          else          else
2697           if (MotionFlags & PMV_ADVANCEDDIAMOND16)                          if (x == 1) /* left macroblock does not have any vector now */
2698                  MainSearchPtr = AdvDiamond16_MainSearch;                                  Data->predMV = (pMB - pParam->mb_width)->mvs[0]; /* top instead of median */
2699                            else if (y == 1) /* top macroblock doesn't have it's vector */
2700                                    Data->predMV = (pMB - 1)->mvs[0]; /* left instead of median */
2701                            else Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); /* else median */
2702    
2703                    pmv[2].x = Data->predMV.x;
2704                    pmv[2].y = Data->predMV.y;
2705    
2706                    if (!vector_repeats(pmv, 1))
2707                            CheckCandidate32I(pmv[1].x, pmv[1].y, Data, 1);
2708                    if (!vector_repeats(pmv, 2))
2709                            CheckCandidate32I(pmv[2].x, pmv[2].y, Data, 2);
2710    
2711                    if (*Data->iMinSAD > 500) { /* diamond only if needed */
2712                            unsigned int mask = make_mask(pmv, 3, *Data->dir);
2713                            DiamondSearch(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate32I);
2714                    } else simplicity++;
2715    
2716                    if (*Data->iMinSAD > 500) /* refinement from 2-pixel to 1-pixel */
2717                            SubpelRefine(Data, CheckCandidate32I);
2718                    else simplicity++;
2719            } else simplicity++;
2720    
2721            for (i = 0; i < 4; i++) {
2722                    MACROBLOCK * MB = &pMBs[x + (i&1) + (y+(i>>1)) * pParam->mb_width];
2723                    MB->mvs[0] = MB->mvs[1] = MB->mvs[2] = MB->mvs[3] = Data->currentMV[i];
2724                    MB->mode = MODE_INTER;
2725                    /* if we skipped some search steps, we have to assume that SAD would be lower with them */
2726                    MB->sad16 = Data->iMinSAD[i+1] - (simplicity<<7);
2727            }
2728    }
2729    
2730    #define INTRA_THRESH    2200
2731    #define INTER_THRESH    40
2732    #define INTRA_THRESH2   95
2733    
2734    int
2735    MEanalysis(     const IMAGE * const pRef,
2736                            const FRAMEINFO * const Current,
2737                            const MBParam * const pParam,
2738                            const int maxIntra, //maximum number if non-I frames
2739                            const int intraCount, //number of non-I frames after last I frame; 0 if we force P/B frame
2740                            const int bCount, // number of B frames in a row
2741                            const int b_thresh)
2742    {
2743            uint32_t x, y, intra = 0;
2744            int sSAD = 0;
2745            MACROBLOCK * const pMBs = Current->mbs;
2746            const IMAGE * const pCurrent = &Current->image;
2747            int IntraThresh = INTRA_THRESH, InterThresh = INTER_THRESH + b_thresh;
2748            int blocks = 0;
2749            int complexity = 0;
2750    
2751            int32_t iMinSAD[5], temp[5];
2752            uint32_t dir;
2753            VECTOR currentMV[5];
2754            SearchData Data;
2755            Data.iEdgedWidth = pParam->edged_width;
2756            Data.currentMV = currentMV;
2757            Data.iMinSAD = iMinSAD;
2758            Data.iFcode = Current->fcode;
2759            Data.temp = temp;
2760            Data.dir = &dir;
2761            Data.qpel = (pParam->vol_flags & XVID_VOL_QUARTERPEL)? 1: 0;
2762            Data.qpel_precision = 0;
2763    
2764            if (intraCount != 0) {
2765                    if (intraCount < 10) // we're right after an I frame
2766                            IntraThresh += 15* (intraCount - 10) * (intraCount - 10);
2767          else          else
2768                  MainSearchPtr = Diamond16_MainSearch;                          if ( 5*(maxIntra - intraCount) < maxIntra) // we're close to maximum. 2 sec when max is 10 sec
2769                                    IntraThresh -= (IntraThresh * (maxIntra - 8*(maxIntra - intraCount)))/maxIntra;
2770            }
2771    
2772  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */          InterThresh -= 20 * bCount;
2773            if (InterThresh < 10 + b_thresh) InterThresh = 10 + b_thresh;
2774    
2775          iSAD =          if (sadInit) (*sadInit) ();
                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,  
                                                   currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,  
                                                   min_dy, max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);  
2776    
2777          if (iSAD < iMinSAD) {          for (y = 1; y < pParam->mb_height-1; y += 2) {
2778                  *currMV = newMV;                  for (x = 1; x < pParam->mb_width-1; x += 2) {
2779                  iMinSAD = iSAD;                          int i;
2780          }                          blocks += 10;
2781    
2782                            if (bCount == 0) pMBs[x + y * pParam->mb_width].mvs[0] = zeroMV;
2783                            else { //extrapolation of the vector found for last frame
2784                                    pMBs[x + y * pParam->mb_width].mvs[0].x =
2785                                            (pMBs[x + y * pParam->mb_width].mvs[0].x * (bCount+1) ) / bCount;
2786                                    pMBs[x + y * pParam->mb_width].mvs[0].y =
2787                                            (pMBs[x + y * pParam->mb_width].mvs[0].y * (bCount+1) ) / bCount;
2788                            }
2789    
2790          if (MotionFlags & PMV_EXTSEARCH16) {                          MEanalyzeMB(pRef->y, pCurrent->y, x, y, pParam, pMBs, &Data);
 /* extended mode: search (up to) two more times: orignal prediction and (0,0) */  
2791    
2792                  if (!(MVequal(pmv[0], backupMV))) {                          for (i = 0; i < 4; i++) {
2793                          iSAD =                                  int dev;
2794                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,                                  MACROBLOCK *pMB = &pMBs[x+(i&1) + (y+(i>>1)) * pParam->mb_width];
2795                                                                    pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,                                  dev = dev16(pCurrent->y + (x + (i&1) + (y + (i>>1)) * pParam->edged_width) * 16,
2796                                                                    min_dx, max_dx, min_dy, max_dy, iEdgedWidth,                                                                  pParam->edged_width);
                                                                   2, iFcode, iQuant, 0);  
                 }  
2797    
2798                  if (iSAD < iMinSAD) {                                  complexity += MAX(dev, 300);
2799                          *currMV = newMV;                                  if (dev + IntraThresh < pMB->sad16) {
2800                          iMinSAD = iSAD;                                          pMB->mode = MODE_INTRA;
2801                                            if (++intra > ((pParam->mb_height-2)*(pParam->mb_width-2))/2) return I_VOP;
2802                  }                  }
2803    
2804                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {                                  if (pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0)
2805                          iSAD =                                          if (dev > 1000 && pMB->sad16 < 1000)
2806                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,                                                  sSAD += 1000;
                                                                   iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, 2, iFcode, iQuant, 0);  
2807    
2808                          if (iSAD < iMinSAD) {                                  sSAD += (dev < 4000) ? pMB->sad16 : pMB->sad16/2; /* blocks with big contrast differences usually have large SAD - while they look very good in b-frames */
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
2809                          }                          }
2810                  }                  }
2811          }          }
2812            complexity >>= 7;
2813    
2814  /***************        Choose best MV found     **************/          sSAD /= complexity + 4*blocks;
2815    
2816    EPZS16_Terminate_with_Refine:          if (intraCount > 80 && sSAD > INTRA_THRESH2 ) return I_VOP;
2817          if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step          if (sSAD > InterThresh ) return P_VOP;
2818                  iMinSAD =          emms();
2819                          Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,          return B_VOP;
                                                          iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,  
                                                          iFcode, iQuant, iEdgedWidth);  
   
   EPZS16_Terminate_without_Refine:  
   
         *oldMB = *prevMB;  
   
         currPMV->x = currMV->x - center_x;  
         currPMV->y = currMV->y - center_y;  
         return iMinSAD;  
2820  }  }
2821    
2822    
2823  int32_t  /* functions which perform BITS-based search/bitcount */
2824  EPZSSearch8(const uint8_t * const pRef,  
2825                          const uint8_t * const pRefH,  static int
2826                          const uint8_t * const pRefV,  findRDinter(SearchData * const Data,
2827                          const uint8_t * const pRefHV,                          const MACROBLOCK * const pMBs, const int x, const int y,
                         const IMAGE * const pCur,  
                         const int x,  
                         const int y,  
                         const int start_x,  
                         const int start_y,  
                         const int center_x,  
                         const int center_y,  
                         const uint32_t MotionFlags,  
                         const uint32_t iQuant,  
                         const uint32_t iFcode,  
2828                          const MBParam * const pParam,                          const MBParam * const pParam,
2829                          const MACROBLOCK * const pMBs,                          const uint32_t MotionFlags)
                         const MACROBLOCK * const prevMBs,  
                         VECTOR * const currMV,  
                         VECTOR * const currPMV)  
2830  {  {
2831  /* Please not that EPZS might not be a good choice for 8x8-block motion search ! */          int i;
2832            int32_t bsad[5];
2833    
2834            if (Data->qpel) {
2835                    for(i = 0; i < 5; i++) {
2836                            Data->currentMV[i].x = Data->currentQMV[i].x/2;
2837                            Data->currentMV[i].y = Data->currentQMV[i].y/2;
2838                    }
2839                    Data->qpel_precision = 1;
2840                    CheckCandidateRD16(Data->currentQMV[0].x, Data->currentQMV[0].y, Data, 255);
2841    
2842          const uint32_t iWcount = pParam->mb_width;                  if (MotionFlags & (XVID_ME_HALFPELREFINE16_RD | XVID_ME_EXTSEARCH_RD)) { /* we have to prepare for halfpixel-precision search */
2843          const int32_t iWidth = pParam->width;                          for(i = 0; i < 5; i++) bsad[i] = Data->iMinSAD[i];
2844          const int32_t iHeight = pParam->height;                          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
2845          const int32_t iEdgedWidth = pParam->edged_width;                                                  pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
2846                            Data->qpel_precision = 0;
2847                            if (Data->currentQMV->x & 1 || Data->currentQMV->y & 1)
2848                                    CheckCandidateRD16(Data->currentMV[0].x, Data->currentMV[0].y, Data, 255);
2849                    }
2850    
2851          const uint8_t *cur = pCur->y + x * 8 + y * 8 * iEdgedWidth;          } else { /* not qpel */
2852    
2853          int32_t iDiamondSize = 1;                  CheckCandidateRD16(Data->currentMV[0].x, Data->currentMV[0].y, Data, 255);
2854            }
2855    
2856          int32_t min_dx;          if (MotionFlags&XVID_ME_EXTSEARCH_RD)
2857          int32_t max_dx;                  SquareSearch(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidateRD16);
         int32_t min_dy;  
         int32_t max_dy;  
2858    
2859          VECTOR newMV;          if (MotionFlags&XVID_ME_HALFPELREFINE16_RD)
2860          VECTOR backupMV;                  SubpelRefine(Data, CheckCandidateRD16);
2861    
2862          VECTOR pmv[4];          if (Data->qpel) {
2863          int32_t psad[8];                  if (MotionFlags&(XVID_ME_EXTSEARCH_RD | XVID_ME_HALFPELREFINE16_RD)) { /* there was halfpel-precision search */
2864                            for(i = 0; i < 5; i++) if (bsad[i] > Data->iMinSAD[i]) {
2865                                    Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* we have found a better match */
2866                                    Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
2867                            }
2868    
2869          const int32_t iSubBlock = ((y & 1) << 1) + (x & 1);                          /* preparing for qpel-precision search */
2870                            Data->qpel_precision = 1;
2871                            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
2872                                            pParam->width, pParam->height, Data->iFcode, 2, 0);
2873                    }
2874                    if (MotionFlags&XVID_ME_QUARTERPELREFINE16_RD)
2875                            SubpelRefine(Data, CheckCandidateRD16);
2876            }
2877    
2878  //  const MACROBLOCK * const pMB = pMBs + (x>>1) + (y>>1) * iWcount;          if (MotionFlags&XVID_ME_CHECKPREDICTION_RD) { /* let's check vector equal to prediction */
2879          const MACROBLOCK *const prevMB = prevMBs + (x >> 1) + (y >> 1) * iWcount;                  VECTOR * v = Data->qpel ? Data->currentQMV : Data->currentMV;
2880                    if (!(Data->predMV.x == v->x && Data->predMV.y == v->y))
2881                            CheckCandidateRD16(Data->predMV.x, Data->predMV.y, Data, 255);
2882            }
2883            return Data->iMinSAD[0];
2884    }
2885    
2886          int32_t bPredEq;  static int
2887          int32_t iMinSAD, iSAD = 9999;  findRDinter4v(const SearchData * const Data,
2888                                    MACROBLOCK * const pMB, const MACROBLOCK * const pMBs,
2889                                    const int x, const int y,
2890                                    const MBParam * const pParam, const uint32_t MotionFlags,
2891                                    const VECTOR * const backup)
2892    {
2893    
2894          MainSearch8FuncPtr MainSearchPtr;          int cbp = 0, bits = 0, t = 0, i;
2895            SearchData Data2, *Data8 = &Data2;
2896            int sumx = 0, sumy = 0;
2897            int16_t *in = Data->dctSpace, *coeff = Data->dctSpace + 64;
2898            uint8_t * ptr;
2899    
2900            memcpy(Data8, Data, sizeof(SearchData));
2901    
2902            for (i = 0; i < 4; i++) { /* for all luma blocks */
2903    
2904                    Data8->iMinSAD = Data->iMinSAD + i + 1;
2905                    Data8->currentMV = Data->currentMV + i + 1;
2906                    Data8->currentQMV = Data->currentQMV + i + 1;
2907                    Data8->Cur = Data->Cur + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2908                    Data8->RefP[0] = Data->RefP[0] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2909                    Data8->RefP[2] = Data->RefP[2] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2910                    Data8->RefP[1] = Data->RefP[1] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2911                    Data8->RefP[3] = Data->RefP[3] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2912                    *Data8->cbp = (Data->cbp[1] & (1<<(5-i))) ? 1:0; // copy corresponding cbp bit
2913    
2914                    if(Data->qpel) {
2915                            Data8->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, i);
2916                            if (i != 0)     t = d_mv_bits(  Data8->currentQMV->x, Data8->currentQMV->y,
2917                                                                                    Data8->predMV, Data8->iFcode, 0, 0);
2918                    } else {
2919                            Data8->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, i);
2920                            if (i != 0)     t = d_mv_bits(  Data8->currentMV->x, Data8->currentMV->y,
2921                                                                                    Data8->predMV, Data8->iFcode, 0, 0);
2922                    }
2923    
2924  /* Get maximum range */                  get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 3,
2925          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 8, iWidth, iHeight,                                          pParam->width, pParam->height, Data8->iFcode, Data8->qpel+1, 0);
                           iFcode);  
2926    
2927  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */                  *Data8->iMinSAD += BITS_MULT*t;
2928    
2929          if (!(MotionFlags & PMV_HALFPEL8)) {                  Data8->qpel_precision = Data8->qpel;
2930                  min_dx = EVEN(min_dx);                  /* checking the vector which has been found by SAD-based 8x8 search (if it's different than the one found so far) */
2931                  max_dx = EVEN(max_dx);                  {
2932                  min_dy = EVEN(min_dy);                          VECTOR *v = Data8->qpel ? Data8->currentQMV : Data8->currentMV;
2933                  max_dy = EVEN(max_dy);                          if (!MVequal (*v, backup[i+1]) )
2934                                    CheckCandidateRD8(backup[i+1].x, backup[i+1].y, Data8, 255);
2935          }          }
         /* because we might use something like IF (dx>max_dx) THEN dx=max_dx; */  
         //bPredEq = get_pmvdata(pMBs, x >> 1, y >> 1, iWcount, iSubBlock, pmv[0].x, pmv[0].y, psad);  
         bPredEq = get_pmvdata2(pMBs, iWcount, 0, x >> 1, y >> 1, iSubBlock, pmv, psad);  
2936    
2937                    if (Data8->qpel) {
2938                            if (MotionFlags&XVID_ME_HALFPELREFINE8_RD || (MotionFlags&XVID_ME_EXTSEARCH8 && MotionFlags&XVID_ME_EXTSEARCH_RD)) { /* halfpixel motion search follows */
2939                                    int32_t s = *Data8->iMinSAD;
2940                                    Data8->currentMV->x = Data8->currentQMV->x/2;
2941                                    Data8->currentMV->y = Data8->currentQMV->y/2;
2942                                    Data8->qpel_precision = 0;
2943                                    get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 3,
2944                                                            pParam->width, pParam->height, Data8->iFcode - 1, 1, 0);
2945    
2946  /* Step 4: Calculate SAD around the Median prediction.                                  if (Data8->currentQMV->x & 1 || Data8->currentQMV->y & 1)
2947          MinSAD=SAD                                          CheckCandidateRD8(Data8->currentMV->x, Data8->currentMV->y, Data8, 255);
         If Motion Vector equal to Previous frame motion vector  
                 and MinSAD<PrevFrmSAD goto Step 10.  
         If SAD<=256 goto Step 10.  
 */  
2948    
2949  // Prepare for main loop                                  if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD)
2950                                            SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255, CheckCandidateRD8);
2951    
2952                                    if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)
2953                                            SubpelRefine(Data8, CheckCandidateRD8);
2954    
2955          if (!(MotionFlags & PMV_HALFPEL8)) {                                  if(s > *Data8->iMinSAD) { /* we have found a better match */
2956                  currMV->x = EVEN(currMV->x);                                          Data8->currentQMV->x = 2*Data8->currentMV->x;
2957                  currMV->y = EVEN(currMV->y);                                          Data8->currentQMV->y = 2*Data8->currentMV->y;
2958          }          }
2959    
2960          if (currMV->x > max_dx)                                  Data8->qpel_precision = 1;
2961                  currMV->x = max_dx;                                  get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 3,
2962          if (currMV->x < min_dx)                                                          pParam->width, pParam->height, Data8->iFcode, 2, 0);
                 currMV->x = min_dx;  
         if (currMV->y > max_dy)  
                 currMV->y = max_dy;  
         if (currMV->y < min_dy)  
                 currMV->y = min_dy;  
   
 /***************** This is predictor SET A: only median prediction ******************/  
2963    
2964                            }
2965                            if (MotionFlags & XVID_ME_QUARTERPELREFINE8_RD)
2966                                    SubpelRefine(Data8, CheckCandidateRD8);
2967    
2968          iMinSAD =                  } else { /* not qpel */
                 sad8(cur,  
                          get_ref_mv(pRef, pRefH, pRefV, pRefHV, x, y, 8, currMV,  
                                                 iEdgedWidth), iEdgedWidth);  
         iMinSAD +=  
                 calc_delta_8(currMV->x - center_x, currMV->y - center_y,  
                                          (uint8_t) iFcode, iQuant);  
2969    
2970                            if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD) /* extsearch */
2971                                    SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255, CheckCandidateRD8);
2972    
2973  // thresh1 is fixed to 256                          if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)
2974          if (iMinSAD < 256 / 4) {                                  SubpelRefine(Data8, CheckCandidateRD8); /* halfpel refinement */
                 if (MotionFlags & PMV_QUICKSTOP8)  
                         goto EPZS8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP8)  
                         goto EPZS8_Terminate_with_Refine;  
2975          }          }
2976    
2977  /************** This is predictor SET B: (0,0), prev.frame MV, neighbours **************/                  /* checking vector equal to predicion */
2978                    if (i != 0 && MotionFlags & XVID_ME_CHECKPREDICTION_RD) {
2979                            const VECTOR * v = Data->qpel ? Data8->currentQMV : Data8->currentMV;
2980                            if (!MVequal(*v, Data8->predMV))
2981                                    CheckCandidateRD8(Data8->predMV.x, Data8->predMV.y, Data8, 255);
2982                    }
2983    
2984                    bits += *Data8->iMinSAD;
2985                    if (bits >= Data->iMinSAD[0]) return bits; /* no chances for INTER4V */
2986    
2987  // MV=(0,0) is often a good choice                  /* MB structures for INTER4V mode; we have to set them here, we don't have predictor anywhere else */
2988          CHECK_MV8_ZERO;                  if(Data->qpel) {
2989                            pMB->pmvs[i].x = Data8->currentQMV->x - Data8->predMV.x;
2990                            pMB->pmvs[i].y = Data8->currentQMV->y - Data8->predMV.y;
2991                            pMB->qmvs[i] = *Data8->currentQMV;
2992                            sumx += Data8->currentQMV->x/2;
2993                            sumy += Data8->currentQMV->y/2;
2994                    } else {
2995                            pMB->pmvs[i].x = Data8->currentMV->x - Data8->predMV.x;
2996                            pMB->pmvs[i].y = Data8->currentMV->y - Data8->predMV.y;
2997                            sumx += Data8->currentMV->x;
2998                            sumy += Data8->currentMV->y;
2999                    }
3000                    pMB->mvs[i] = *Data8->currentMV;
3001                    pMB->sad8[i] = 4 * *Data8->iMinSAD;
3002                    if (Data8->cbp[0]) cbp |= 1 << (5 - i);
3003    
3004  // previous frame MV          } /* end - for all luma blocks */
         CHECK_MV8_CANDIDATE(prevMB->mvs[iSubBlock].x, prevMB->mvs[iSubBlock].y);  
3005    
3006  // left neighbour, if allowed          bits += BITS_MULT*xvid_cbpy_tab[15-(cbp>>2)].len;
         if (psad[1] != MV_MAX_ERROR) {  
                 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  
         if (psad[2] != MV_MAX_ERROR) {  
                 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);  
3007    
3008  // top right neighbour, if allowed          /* let's check chroma */
3009                  if (psad[3] != MV_MAX_ERROR) {          sumx = (sumx >> 3) + roundtab_76[sumx & 0xf];
3010                          if (!(MotionFlags & PMV_HALFPEL8)) {          sumy = (sumy >> 3) + roundtab_76[sumy & 0xf];
                                 pmv[3].x = EVEN(pmv[3].x);  
                                 pmv[3].y = EVEN(pmv[3].y);  
                         }  
                         CHECK_MV8_CANDIDATE(pmv[3].x, pmv[3].y);  
                 }  
         }  
3011    
3012  /*  // this bias is zero anyway, at the moment!          /* chroma U */
3013            ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefP[4], 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
3014            transfer_8to16subro(in, Data->CurU, ptr, Data->iEdgedWidth/2);
3015            bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 4);
3016    
3017          if ( (MVzero(*currMV)) && (!MVzero(pmv[0])) ) // && (iMinSAD <= iQuant * 96)          if (bits >= *Data->iMinSAD) return bits;
                 iMinSAD -= MV8_00_BIAS;  
3018    
3019  */          /* chroma V */
3020            ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefP[5], 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
3021            transfer_8to16subro(in, Data->CurV, ptr, Data->iEdgedWidth/2);
3022            bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 5);
3023    
3024  /* Terminate if MinSAD <= T_2          bits += BITS_MULT*mcbpc_inter_tab[(MODE_INTER4V & 7) | ((cbp & 3) << 3)].len;
    Terminate if MV[t] == MV[t-1] and MinSAD[t] <= MinSAD[t-1]  
 */  
3025    
3026          if (iMinSAD < 512 / 4) {        /* T_2 == 512/4 hardcoded */          *Data->cbp = cbp;
3027                  if (MotionFlags & PMV_QUICKSTOP8)          return bits;
                         goto EPZS8_Terminate_without_Refine;  
                 if (MotionFlags & PMV_EARLYSTOP8)  
                         goto EPZS8_Terminate_with_Refine;  
3028          }          }
3029    
3030  /************ (Diamond Search)  **************/  static int
3031    findRDintra(const SearchData * const Data)
3032          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */  {
3033            int bits = BITS_MULT*1; /* this one is ac/dc prediction flag bit */
3034            int cbp = 0, i, dc = 0;
3035            int16_t *in = Data->dctSpace, * coeff = Data->dctSpace + 64;
3036    
3037          if (!(MotionFlags & PMV_HALFPELDIAMOND8))          for(i = 0; i < 4; i++) {
3038                  iDiamondSize *= 2;                  int s = 8*((i&1) + (i>>1)*Data->iEdgedWidth);
3039                    transfer_8to16copy(in, Data->Cur + s, Data->iEdgedWidth);
3040                    bits += Block_CalcBitsIntra(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, i, &dc);
3041    
3042  /* default: use best prediction as starting point for one call of EPZS_MainSearch */                  if (bits >= Data->iMinSAD[0]) return bits;
3043            }
3044    
3045  // there is no EPZS^2 for inter4v at the moment          bits += BITS_MULT*xvid_cbpy_tab[cbp>>2].len;
3046    
3047    if (MotionFlags & PMV_USESQUARES8)          /*chroma U */
3048        MainSearchPtr = Square8_MainSearch;          transfer_8to16copy(in, Data->CurU, Data->iEdgedWidth/2);
3049    else          bits += Block_CalcBitsIntra(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 4, &dc);
3050    
3051          if (MotionFlags & PMV_ADVANCEDDIAMOND8)          if (bits >= Data->iMinSAD[0]) return bits;
                 MainSearchPtr = AdvDiamond8_MainSearch;  
         else  
                 MainSearchPtr = Diamond8_MainSearch;  
3052    
3053          iSAD =          /* chroma V */
3054                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,          transfer_8to16copy(in, Data->CurV, Data->iEdgedWidth/2);
3055                                                    currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,          bits += Block_CalcBitsIntra(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 5, &dc);
                                                   min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                   iQuant, 0);  
3056    
3057            bits += BITS_MULT*mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp & 3) << 3)].len;
3058    
3059          if (iSAD < iMinSAD) {          return bits;
                 *currMV = newMV;  
                 iMinSAD = iSAD;  
3060          }          }
3061    
3062          if (MotionFlags & PMV_EXTSEARCH8) {  static int
3063  /* extended mode: search (up to) two more times: orignal prediction and (0,0) */  findRDgmc(const SearchData * const Data, const IMAGE * const vGMC, const int x, const int y)
3064    {
3065                  if (!(MVequal(pmv[0], backupMV))) {          int bits = BITS_MULT*1; /* this one is mcsel */
3066                          iSAD =          int cbp = 0, i;
3067                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,          int16_t *in = Data->dctSpace, * coeff = Data->dctSpace + 64;
                                                                   pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,  
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, 0);  
3068    
3069                          if (iSAD < iMinSAD) {          for(i = 0; i < 4; i++) {
3070                                  *currMV = newMV;                  int s = 8*((i&1) + (i>>1)*Data->iEdgedWidth);
3071                                  iMinSAD = iSAD;                  transfer_8to16subro(in, Data->Cur + s, vGMC->y + s + 16*(x+y*Data->iEdgedWidth), Data->iEdgedWidth);
3072                          }                  bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, i);
3073                    if (bits >= Data->iMinSAD[0]) return bits;
3074                  }                  }
3075    
3076                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {          bits += BITS_MULT*xvid_cbpy_tab[15-(cbp>>2)].len;
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                                   iQuant, 0);  
3077    
3078                          if (iSAD < iMinSAD) {          /*chroma U */
3079                                  *currMV = newMV;          transfer_8to16subro(in, Data->CurU, vGMC->u + 8*(x+y*(Data->iEdgedWidth/2)), Data->iEdgedWidth/2);
3080                                  iMinSAD = iSAD;          bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 4);
3081                          }  
3082                  }          if (bits >= Data->iMinSAD[0]) return bits;
         }  
3083    
3084  /***************        Choose best MV found     **************/          /* chroma V */
3085            transfer_8to16subro(in, Data->CurV , vGMC->v + 8*(x+y*(Data->iEdgedWidth/2)), Data->iEdgedWidth/2);
3086            bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 5);
3087    
3088    EPZS8_Terminate_with_Refine:          bits += BITS_MULT*mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len;
         if (MotionFlags & PMV_HALFPELREFINE8)   // perform final half-pel step  
                 iMinSAD =  
                         Halfpel8_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,  
                                                         iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,  
                                                         iFcode, iQuant, iEdgedWidth);  
3089    
3090    EPZS8_Terminate_without_Refine:          *Data->cbp = cbp;
3091    
3092          currPMV->x = currMV->x - center_x;          return bits;
         currPMV->y = currMV->y - center_y;  
         return iMinSAD;  
3093  }  }
3094    
3095    
3096    
3097  int32_t  
3098  PMVfastIntSearch16(const uint8_t * const pRef,  static __inline void
3099    GMEanalyzeMB (  const uint8_t * const pCur,
3100                                    const uint8_t * const pRef,
3101                                  const uint8_t * const pRefH,                                  const uint8_t * const pRefH,
3102                                  const uint8_t * const pRefV,                                  const uint8_t * const pRefV,
3103                                  const uint8_t * const pRefHV,                                  const uint8_t * const pRefHV,
                                 const IMAGE * const pCur,  
3104                                  const int x,                                  const int x,
3105                                  const int y,                                  const int y,
                                 const int start_x,              /* start should be most likely vector */  
                                 const int start_y,  
                                 const int center_x,             /* center is from where length of MVs is measured */  
                                 const int center_y,  
                                 const uint32_t MotionFlags,  
                                 const uint32_t iQuant,  
                                 const uint32_t iFcode,  
3106                                  const MBParam * const pParam,                                  const MBParam * const pParam,
3107                                  const MACROBLOCK * const pMBs,                                  MACROBLOCK * const pMBs,
3108                                  const MACROBLOCK * const prevMBs,                                  SearchData * const Data)
                                 VECTOR * const currMV,  
                                 VECTOR * const currPMV)  
3109  {  {
         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;  
3110    
3111          const uint8_t *cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;          int i=0;
3112          const VECTOR zeroMV = { 0, 0 };          MACROBLOCK * const pMB = &pMBs[x + y * pParam->mb_width];
3113    
3114          int32_t iDiamondSize;          Data->iMinSAD[0] = MV_MAX_ERROR;
3115    
3116          int32_t min_dx;          Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);
         int32_t max_dx;  
         int32_t min_dy;  
         int32_t max_dy;  
3117    
3118          int32_t iFound;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
3119                                    pParam->width, pParam->height, 16, 1, 0);
3120    
3121          VECTOR newMV;          Data->Cur = pCur + 16*(x + y * pParam->edged_width);
3122          VECTOR backupMV;          Data->RefP[0] = pRef + 16*(x + y * pParam->edged_width);
3123            Data->RefP[1] = pRefV + 16*(x + y * pParam->edged_width);
3124            Data->RefP[2] = pRefH + 16*(x + y * pParam->edged_width);
3125            Data->RefP[3] = pRefHV + 16*(x + y * pParam->edged_width);
3126    
3127          VECTOR pmv[4];          Data->currentMV[0].x = Data->currentMV[0].y = 0;
3128          int32_t psad[4];          CheckCandidate16I(0, 0, Data, 255);
3129    
3130          MainSearch16FuncPtr MainSearchPtr;          if ( (Data->predMV.x !=0) || (Data->predMV.y != 0) )
3131                    CheckCandidate16I(Data->predMV.x, Data->predMV.y, Data, 255);
3132    
3133          const MACROBLOCK *const prevMB = prevMBs + x + y * iWcount;          DiamondSearch(Data->currentMV[0].x, Data->currentMV[0].y, Data, 255, CheckCandidate16I);
         MACROBLOCK *const pMB = pMBs + x + y * iWcount;  
3134    
3135          int32_t threshA, threshB;          SubpelRefine(Data, CheckCandidate16I);
         int32_t bPredEq;  
         int32_t iMinSAD, iSAD;  
3136    
3137    
3138  /* Get maximum range */          /* for QPel halfpel positions are worse than in halfpel mode :( */
3139          get_range(&min_dx, &max_dx, &min_dy, &max_dy, x, y, 16, iWidth, iHeight,  /*      if (Data->qpel) {
3140                            iFcode);                  Data->currentQMV->x = 2*Data->currentMV->x;
3141                    Data->currentQMV->y = 2*Data->currentMV->y;
3142                    Data->qpel_precision = 1;
3143                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
3144                                            pParam->width, pParam->height, iFcode, 2, 0);
3145                    SubpelRefine(Data);
3146            }
3147    */
3148    
3149  /* we work with abs. MVs, not relative to prediction, so get_range is called relative to 0,0 */          pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
3150            pMB->sad16 = Data->iMinSAD[0];
3151            pMB->mode = MODE_INTER;
3152            pMB->sad16 += 10*d_mv_bits(pMB->mvs[0].x, pMB->mvs[0].y, Data->predMV, Data->iFcode, 0, 0);
3153            return;
3154    }
3155    
3156          if ((x == 0) && (y == 0)) {  void
3157                  threshA = 512;  GMEanalysis(const MBParam * const pParam,
3158                  threshB = 1024;                          const FRAMEINFO * const current,
3159                            const FRAMEINFO * const reference,
3160                            const IMAGE * const pRefH,
3161                            const IMAGE * const pRefV,
3162                            const IMAGE * const pRefHV)
3163    {
3164            uint32_t x, y;
3165            MACROBLOCK * const pMBs = current->mbs;
3166            const IMAGE * const pCurrent = &current->image;
3167            const IMAGE * const pReference = &reference->image;
3168    
3169                  bPredEq = 0;          int32_t iMinSAD[5], temp[5];
3170                  psad[0] = psad[1] = psad[2] = psad[3] = 0;          VECTOR currentMV[5];
3171                  *currMV = pmv[0] = pmv[1] = pmv[2] = pmv[3] = zeroMV;          uint32_t dir;
3172            SearchData Data;
3173            memset(&Data, 0, sizeof(SearchData));
3174    
3175          } else {          Data.iEdgedWidth = pParam->edged_width;
3176                  threshA = psad[0];          Data.rounding = pParam->m_rounding_type;
                 threshB = threshA + 256;  
                 if (threshA < 512)  
                         threshA = 512;  
                 if (threshA > 1024)  
                         threshA = 1024;  
                 if (threshB > 1792)  
                         threshB = 1792;  
   
                 bPredEq = get_ipmvdata(pMBs, iWcount, 0, x, y, 0, pmv, psad);  
                 *currMV = pmv[0];                       /* current best := prediction */  
         }  
   
         iFound = 0;  
   
 /* Step 4: Calculate SAD around the Median prediction.  
    MinSAD=SAD  
    If Motion Vector equal to Previous frame motion vector  
    and MinSAD<PrevFrmSAD goto Step 10.  
    If SAD<=256 goto Step 10.  
 */  
3177    
3178          if (currMV->x > max_dx) {          Data.currentMV = &currentMV[0];
3179                  currMV->x = EVEN(max_dx);          Data.iMinSAD = &iMinSAD[0];
3180          }          Data.iFcode = current->fcode;
3181          if (currMV->x < min_dx) {          Data.temp = temp;
3182                  currMV->x = EVEN(min_dx);          Data.dir = &dir;
         }  
         if (currMV->y > max_dy) {  
                 currMV->y = EVEN(max_dy);  
         }  
         if (currMV->y < min_dy) {  
                 currMV->y = EVEN(min_dy);  
         }  
3183    
3184          iMinSAD =          if (sadInit) (*sadInit) ();
                 sad16(cur,  
                           get_iref_mv(pRef, x, y, 16, currMV,  
                                                  iEdgedWidth), iEdgedWidth, MV_MAX_ERROR);  
         iMinSAD +=  
                 calc_delta_16(currMV->x - center_x, currMV->y - center_y,  
                                           (uint8_t) iFcode, iQuant);  
3185    
3186          if ((iMinSAD < 256) ||          for (y = 0; y < pParam->mb_height; y ++) {
3187                  ((MVequal(*currMV, prevMB->i_mvs[0])) &&                  for (x = 0; x < pParam->mb_width; x ++) {
3188                   ((int32_t) iMinSAD < prevMB->i_sad16))) {                          GMEanalyzeMB(pCurrent->y, pReference->y, pRefH->y, pRefV->y, pRefHV->y, x, y, pParam, pMBs, &Data);
                 if (iMinSAD < 2 * iQuant)       // high chances for SKIP-mode  
                 {  
                         if (!MVzero(*currMV)) {  
                                 iMinSAD += MV16_00_BIAS;  
                                 CHECK_MV16_ZERO;        // (0,0) saves space for letterboxed pictures  
                                 iMinSAD -= MV16_00_BIAS;  
3189                          }                          }
3190                  }                  }
3191            return;
                 if (MotionFlags & PMV_EARLYSTOP16)  
                         goto PMVfastInt16_Terminate_with_Refine;  
3192          }          }
3193    
3194    
3195  /* Step 2 (lazy eval): Calculate Distance= |MedianMVX| + |MedianMVY| where MedianMV is the motion  WARPPOINTS
3196     vector of the median.  GlobalMotionEst(MACROBLOCK * const pMBs,
3197     If PredEq=1 and MVpredicted = Previous Frame MV, set Found=2                                  const MBParam * const pParam,
3198  */                                  const FRAMEINFO * const current,
3199                                    const FRAMEINFO * const reference,
3200          if ((bPredEq) && (MVequal(pmv[0], prevMB->i_mvs[0])))                                  const IMAGE * const pRefH,
3201                  iFound = 2;                                  const IMAGE * const pRefV,
3202                                    const IMAGE * const pRefHV)
3203    {
3204    
3205  /* Step 3 (lazy eval): If Distance>0 or thresb<1536 or PredEq=1 Select small Diamond Search.          const int deltax=8;             // upper bound for difference between a MV and it's neighbour MVs
3206     Otherwise select large Diamond Search.          const int deltay=8;
3207  */          const unsigned int gradx=512;           // lower bound for gradient in MB (ignore "flat" blocks)
3208            const unsigned int grady=512;
3209    
3210          if ((!MVzero(pmv[0])) || (threshB < 1536) || (bPredEq))          double sol[4] = { 0., 0., 0., 0. };
                 iDiamondSize = 2;               // halfpel units!  
         else  
                 iDiamondSize = 4;               // halfpel units!  
3211    
3212  /*          WARPPOINTS gmc;
    Step 5: Calculate SAD for motion vectors taken from left block, top, top-right, and Previous frame block.  
    Also calculate (0,0) but do not subtract offset.  
    Let MinSAD be the smallest SAD up to this point.  
    If MV is (0,0) subtract offset.  
 */  
3213    
3214  // (0,0) is often a good choice          uint32_t mx, my;
3215    
3216          if (!MVzero(pmv[0]))          int MBh = pParam->mb_height;
3217                  CHECK_MV16_ZERO;          int MBw = pParam->mb_width;
3218            const int minblocks = 9; //MBh*MBw/32+3;                /* just some reasonable number 3% + 3 */
3219            const int maxblocks = MBh*MBw/4;                /* just some reasonable number 3% + 3 */
3220    
3221  // previous frame MV is always possible          int num=0;
3222            int oldnum;
3223    
3224          if (!MVzero(prevMB->i_mvs[0]))          gmc.duv[0].x = gmc.duv[0].y = gmc.duv[1].x = gmc.duv[1].y = gmc.duv[2].x = gmc.duv[2].y = 0;
                 if (!MVequal(prevMB->i_mvs[0], pmv[0]))  
                         CHECK_MV16_CANDIDATE(prevMB->i_mvs[0].x, prevMB->i_mvs[0].y);  
   
 // left neighbour, if allowed  
   
         if (!MVzero(pmv[1]))  
                 if (!MVequal(pmv[1], prevMB->i_mvs[0]))  
                         if (!MVequal(pmv[1], pmv[0]))  
                                 CHECK_MV16_CANDIDATE(pmv[1].x, pmv[1].y);  
   
 // top neighbour, if allowed  
         if (!MVzero(pmv[2]))  
                 if (!MVequal(pmv[2], prevMB->i_mvs[0]))  
                         if (!MVequal(pmv[2], pmv[0]))  
                                 if (!MVequal(pmv[2], pmv[1]))  
                                         CHECK_MV16_CANDIDATE(pmv[2].x, pmv[2].y);  
   
 // top right neighbour, if allowed  
                                         if (!MVzero(pmv[3]))  
                                                 if (!MVequal(pmv[3], prevMB->i_mvs[0]))  
                                                         if (!MVequal(pmv[3], pmv[0]))  
                                                                 if (!MVequal(pmv[3], pmv[1]))  
                                                                         if (!MVequal(pmv[3], pmv[2]))  
                                                                                 CHECK_MV16_CANDIDATE(pmv[3].x,  
                                                                                                                          pmv[3].y);  
   
         if ((MVzero(*currMV)) &&  
                 (!MVzero(pmv[0])) /* && (iMinSAD <= iQuant * 96) */ )  
                 iMinSAD -= MV16_00_BIAS;  
3225    
3226            GMEanalysis(pParam,current, reference, pRefH, pRefV, pRefHV);
3227    
3228  /* Step 6: If MinSAD <= thresa goto Step 10.          /* block based ME isn't done, yet, so do a quick presearch */
    If Motion Vector equal to Previous frame motion vector and MinSAD<PrevFrmSAD goto Step 10.  
 */  
3229    
3230          if ((iMinSAD <= threshA) ||  // filter mask of all blocks
                 (MVequal(*currMV, prevMB->i_mvs[0]) &&  
                  ((int32_t) iMinSAD < prevMB->i_sad16))) {  
3231    
3232                  if (MotionFlags & PMV_EARLYSTOP16)          for (my = 0; my < (uint32_t)MBh; my++)
3233                          goto PMVfastInt16_Terminate_with_Refine;          for (mx = 0; mx < (uint32_t)MBw; mx++)
3234            {
3235                    const int mbnum = mx + my * MBw;
3236                            pMBs[mbnum].mcsel = 0;
3237          }          }
3238    
3239    
3240  /************ (Diamond Search)  **************/          for (my = 1; my < (uint32_t)MBh-1; my++) /* ignore boundary blocks */
3241  /*          for (mx = 1; mx < (uint32_t)MBw-1; mx++) /* theirs MVs are often wrong */
3242     Step 7: Perform Diamond search, with either the small or large diamond.          {
3243     If Found=2 only examine one Diamond pattern, and afterwards goto step 10                  const int mbnum = mx + my * MBw;
3244     Step 8: If small diamond, iterate small diamond search pattern until motion vector lies in the center of the diamond.                  MACROBLOCK *const pMB = &pMBs[mbnum];
3245     If center then goto step 10.                  const VECTOR mv = pMB->mvs[0];
    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.  
 */  
3246    
3247          if (MotionFlags & PMV_USESQUARES16)                  /* don't use object boundaries */
3248                  MainSearchPtr = Square16_MainSearch;                  if   ( (abs(mv.x -   (pMB-1)->mvs[0].x) < deltax)
3249          else if (MotionFlags & PMV_ADVANCEDDIAMOND16)                          && (abs(mv.y -   (pMB-1)->mvs[0].y) < deltay)
3250                  MainSearchPtr = AdvDiamond16_MainSearch;                          && (abs(mv.x -   (pMB+1)->mvs[0].x) < deltax)
3251          else                          && (abs(mv.y -   (pMB+1)->mvs[0].y) < deltay)
3252                  MainSearchPtr = Diamond16_MainSearch;                          && (abs(mv.x - (pMB-MBw)->mvs[0].x) < deltax)
3253                            && (abs(mv.y - (pMB-MBw)->mvs[0].y) < deltay)
3254                            && (abs(mv.x - (pMB+MBw)->mvs[0].x) < deltax)
3255                            && (abs(mv.y - (pMB+MBw)->mvs[0].y) < deltay) )
3256                    {       const int iEdgedWidth = pParam->edged_width;
3257                            const uint8_t *const pCur = current->image.y + 16*(my*iEdgedWidth + mx);
3258                            if ( (sad16 ( pCur, pCur+1 , iEdgedWidth, 65536) >= gradx )
3259                             &&  (sad16 ( pCur, pCur+iEdgedWidth, iEdgedWidth, 65536) >= grady ) )
3260                             {      pMB->mcsel = 1;
3261                                    num++;
3262                             }
3263    
3264          backupMV = *currMV;                     /* save best prediction, actually only for EXTSEARCH */                  /* only use "structured" blocks */
3265                    }
3266            }
3267            emms();
3268    
3269            /*      further filtering would be possible, but during iteration, remaining
3270                    outliers usually are removed, too */
3271    
3272  /* default: use best prediction as starting point for one call of PMVfast_MainSearch */          if (num>= minblocks)
3273          iSAD =          do {            /* until convergence */
3274                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV->x,                  double DtimesF[4];
3275                                                    currMV->y, iMinSAD, &newMV, center_x, center_y, min_dx, max_dx,                  double a,b,c,n,invdenom;
3276                                                    min_dy, max_dy, iEdgedWidth, iDiamondSize, iFcode,                  double meanx,meany;
                                                   iQuant, iFound);  
3277    
3278          if (iSAD < iMinSAD) {                  a = b = c = n = 0;
3279                  *currMV = newMV;                  DtimesF[0] = DtimesF[1] = DtimesF[2] = DtimesF[3] = 0.;
3280                  iMinSAD = iSAD;                  for (my = 1; my < (uint32_t)MBh-1; my++)
3281          }                  for (mx = 1; mx < (uint32_t)MBw-1; mx++)
3282                    {
3283                            const int mbnum = mx + my * MBw;
3284                            const VECTOR mv = pMBs[mbnum].mvs[0];
3285    
3286          if (MotionFlags & PMV_EXTSEARCH16) {                          if (!pMBs[mbnum].mcsel)
3287  /* extended: search (up to) two more times: orignal prediction and (0,0) */                                  continue;
3288    
3289                  if (!(MVequal(pmv[0], backupMV))) {                          n++;
3290                          iSAD =                          a += 16*mx+8;
3291                                  (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y,                          b += 16*my+8;
3292                                                                    pmv[0].x, pmv[0].y, iMinSAD, &newMV, center_x, center_y,                          c += (16*mx+8)*(16*mx+8)+(16*my+8)*(16*my+8);
                                                                   min_dx, max_dx, min_dy, max_dy, iEdgedWidth,  
                                                                   iDiamondSize, iFcode, iQuant, iFound);  
3293    
3294                          if (iSAD < iMinSAD) {                          DtimesF[0] += (double)mv.x;
3295                                  *currMV = newMV;                          DtimesF[1] += (double)mv.x*(16*mx+8) + (double)mv.y*(16*my+8);
3296                                  iMinSAD = iSAD;                          DtimesF[2] += (double)mv.x*(16*my+8) - (double)mv.y*(16*mx+8);
3297                          }                          DtimesF[3] += (double)mv.y;
3298                  }                  }
3299    
3300                  if ((!(MVzero(pmv[0]))) && (!(MVzero(backupMV)))) {          invdenom = a*a+b*b-c*n;
                         iSAD =  
                                 (*MainSearchPtr) (pRef, pRefH, pRefV, pRefHV, cur, x, y, 0, 0,  
                                                                   iMinSAD, &newMV, center_x, center_y, min_dx, max_dx, min_dy,  
                                                                   max_dy, iEdgedWidth, iDiamondSize, iFcode,  
                                                                   iQuant, iFound);  
   
                         if (iSAD < iMinSAD) {  
                                 *currMV = newMV;  
                                 iMinSAD = iSAD;  
                         }  
                 }  
         }  
3301    
3302  /*  /* Solve the system:    sol = (D'*E*D)^{-1} D'*E*F   */
3303     Step 10:  The motion vector is chosen according to the block corresponding to MinSAD.  /* D'*E*F has been calculated in the same loop as matrix */
 */  
3304    
3305  PMVfastInt16_Terminate_with_Refine:          sol[0] = -c*DtimesF[0] + a*DtimesF[1] + b*DtimesF[2];
3306            sol[1] =  a*DtimesF[0] - n*DtimesF[1]                           + b*DtimesF[3];
3307            sol[2] =  b*DtimesF[0]                          - n*DtimesF[2] - a*DtimesF[3];
3308            sol[3] =                                 b*DtimesF[1] - a*DtimesF[2] - c*DtimesF[3];
3309    
3310          pMB->i_mvs[0] = pMB->i_mvs[1] = pMB->i_mvs[2] = pMB->i_mvs[3] = pMB->i_mv16 = *currMV;          sol[0] /= invdenom;
3311          pMB->i_sad8[0] = pMB->i_sad8[1] = pMB->i_sad8[2] = pMB->i_sad8[3] = pMB->i_sad16 = iMinSAD;          sol[1] /= invdenom;
3312            sol[2] /= invdenom;
3313            sol[3] /= invdenom;
3314    
3315          if (MotionFlags & PMV_HALFPELREFINE16)  // perform final half-pel step          meanx = meany = 0.;
3316                  iMinSAD =          oldnum = 0;
3317                          Halfpel16_Refine(pRef, pRefH, pRefV, pRefHV, cur, x, y, currMV,          for (my = 1; my < (uint32_t)MBh-1; my++)
3318                                                           iMinSAD, center_x, center_y, min_dx, max_dx, min_dy, max_dy,                  for (mx = 1; mx < (uint32_t)MBw-1; mx++)
3319                                                           iFcode, iQuant, iEdgedWidth);                  {
3320                            const int mbnum = mx + my * MBw;
3321                            const VECTOR mv = pMBs[mbnum].mvs[0];
3322    
3323          pmv[0] = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);          // get _REAL_ prediction (halfpel possible)                          if (!pMBs[mbnum].mcsel)
3324                                    continue;
3325    
3326  PMVfastInt16_Terminate_without_Refine:                          oldnum++;
3327          currPMV->x = currMV->x - center_x;                          meanx += fabs(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - (double)mv.x );
3328          currPMV->y = currMV->y - center_y;                          meany += fabs(( sol[3] - (16*mx+8)*sol[2] + (16*my+8)*sol[1] ) - (double)mv.y );
         return iMinSAD;  
3329  }  }
3330    
3331            if (4*meanx > oldnum)   /* better fit than 0.25 (=1/4pel) is useless */
3332                    meanx /= oldnum;
3333            else
3334                    meanx = 0.25;
3335    
3336            if (4*meany > oldnum)
3337                    meany /= oldnum;
3338            else
3339                    meany = 0.25;
3340    
3341  /* ***********************************************************          num = 0;
3342          bvop motion estimation          for (my = 0; my < (uint32_t)MBh; my++)
3343  ***************************************************************/                  for (mx = 0; mx < (uint32_t)MBw; mx++)
   
 void  
 MotionEstimationBVOP(MBParam * const pParam,  
                                          FRAMEINFO * const frame,  
                                          const int32_t time_bp,  
                                          const int32_t time_pp,  
                                          // forward (past) reference  
                                          const MACROBLOCK * const f_mbs,  
                                          const IMAGE * const f_ref,  
                                          const IMAGE * const f_refH,  
                                          const IMAGE * const f_refV,  
                                          const IMAGE * const f_refHV,  
                                          // backward (future) reference  
                                          const MACROBLOCK * const b_mbs,  
                                          const IMAGE * const b_ref,  
                                          const IMAGE * const b_refH,  
                                          const IMAGE * const b_refV,  
                                          const IMAGE * const b_refHV)  
3344  {  {
3345          const int mb_width = pParam->mb_width;                          const int mbnum = mx + my * MBw;
3346          const int mb_height = pParam->mb_height;                          const VECTOR mv = pMBs[mbnum].mvs[0];
         const int edged_width = pParam->edged_width;  
   
         const int32_t iWidth = pParam->width;  
         const int32_t iHeight = pParam->height;  
3347    
3348          int i, j, k;                          if (!pMBs[mbnum].mcsel)
3349                                    continue;
         static const VECTOR zeroMV={0,0};  
3350    
3351          int f_sad16;    /* forward (as usual) search */                          if  ( ( fabs(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - (double)mv.x ) > meanx )
3352          int b_sad16;    /* backward (only in b-frames) search */                                  || ( fabs(( sol[3] - (16*mx+8)*sol[2] + (16*my+8)*sol[1] ) - (double)mv.y ) > meany ) )
3353          int i_sad16;    /* interpolated (both direction, b-frames only) */                                  pMBs[mbnum].mcsel=0;
3354          int d_sad16;    /* direct mode (assume almost linear motion) */                          else
3355                                    num++;
3356                    }
3357    
3358          int best_sad;          } while ( (oldnum != num) && (num>= minblocks) );
3359    
3360          VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/          if (num < minblocks)
3361          VECTOR f_interpolMV, b_interpolMV;          {
3362          VECTOR pmv_dontcare;                  const int iEdgedWidth = pParam->edged_width;
3363                    num = 0;
3364    
3365          int min_dx, max_dx, min_dy, max_dy;  /*              fprintf(stderr,"Warning! Unreliable GME (%d/%d blocks), falling back to translation.\n",num,MBh*MBw);
3366          int f_min_dx, f_max_dx, f_min_dy, f_max_dy;  */
3367          int b_min_dx, b_max_dx, b_min_dy, b_max_dy;                  gmc.duv[0].x= gmc.duv[0].y= gmc.duv[1].x= gmc.duv[1].y= gmc.duv[2].x= gmc.duv[2].y=0;
3368    
3369          int f_count=0;                  if (!(current->motion_flags & XVID_ME_GME_REFINE))
3370          int b_count=0;                          return gmc;
         int i_count=0;  
         int d_count=0;  
3371    
3372          const int64_t TRB = (int32_t)time_pp - (int32_t)time_bp;                  for (my = 1; my < (uint32_t)MBh-1; my++) /* ignore boundary blocks */
3373      const int64_t TRD = (int32_t)time_pp;                  for (mx = 1; mx < (uint32_t)MBw-1; mx++) /* theirs MVs are often wrong */
3374                    {
3375                            const int mbnum = mx + my * MBw;
3376                            MACROBLOCK *const pMB = &pMBs[mbnum];
3377                            const uint8_t *const pCur = current->image.y + 16*(my*iEdgedWidth + mx);
3378                            if ( (sad16 ( pCur, pCur+1 , iEdgedWidth, 65536) >= gradx )
3379                             &&  (sad16 ( pCur, pCur+iEdgedWidth, iEdgedWidth, 65536) >= grady ) )
3380                             {      pMB->mcsel = 1;
3381                                    gmc.duv[0].x += pMB->mvs[0].x;
3382                                    gmc.duv[0].y += pMB->mvs[0].y;
3383                                    num++;
3384                             }
3385                    }
3386    
3387          // fprintf(stderr,"TRB = %lld  TRD = %lld  time_bp =%d time_pp =%d\n\n",TRB,TRD,time_bp,time_pp);                  if (gmc.duv[0].x)
3388          // note: i==horizontal, j==vertical                          gmc.duv[0].x /= num;
3389          for (j = 0; j < mb_height; j++) {                  if (gmc.duv[0].y)
3390                            gmc.duv[0].y /= num;
3391            } else {
3392    
3393                  f_predMV = zeroMV;      /* prediction is reset at left boundary */                  gmc.duv[0].x=(int)(sol[0]+0.5);
3394                  b_predMV = zeroMV;                  gmc.duv[0].y=(int)(sol[3]+0.5);
3395    
3396                  for (i = 0; i < mb_width; i++) {                  gmc.duv[1].x=(int)(sol[1]*pParam->width+0.5);
3397                          MACROBLOCK *mb = &frame->mbs[i + j * mb_width];                  gmc.duv[1].y=(int)(-sol[2]*pParam->width+0.5);
                         const MACROBLOCK *f_mb = &f_mbs[i + j * mb_width];  
                         const MACROBLOCK *b_mb = &b_mbs[i + j * mb_width];  
3398    
3399                          mb->deltamv=zeroMV;                  gmc.duv[2].x=-gmc.duv[1].y;             /* two warp points only */
3400                    gmc.duv[2].y=gmc.duv[1].x;
3401            }
3402            if (num>maxblocks)
3403            {       for (my = 1; my < (uint32_t)MBh-1; my++)
3404                    for (mx = 1; mx < (uint32_t)MBw-1; mx++)
3405                    {
3406                            const int mbnum = mx + my * MBw;
3407                            if (pMBs[mbnum-1].mcsel)
3408                                    pMBs[mbnum].mcsel=0;
3409                            else
3410                                    if (pMBs[mbnum-MBw].mcsel)
3411                                            pMBs[mbnum].mcsel=0;
3412                    }
3413            }
3414            return gmc;
3415    }
3416    
3417  /* special case, if collocated block is SKIPed: encoding is forward (0,0), cpb=0 without further ado */  int
3418    GlobalMotionEstRefine(
3419                                    WARPPOINTS *const startwp,
3420                                    MACROBLOCK * const pMBs,
3421                                    const MBParam * const pParam,
3422                                    const FRAMEINFO * const current,
3423                                    const FRAMEINFO * const reference,
3424                                    const IMAGE * const pCurr,
3425                                    const IMAGE * const pRef,
3426                                    const IMAGE * const pRefH,
3427                                    const IMAGE * const pRefV,
3428                                    const IMAGE * const pRefHV)
3429    {
3430            uint8_t* GMCblock = (uint8_t*)malloc(16*pParam->edged_width);
3431            WARPPOINTS bestwp=*startwp;
3432            WARPPOINTS centerwp,currwp;
3433            int gmcminSAD=0;
3434            int gmcSAD=0;
3435            int direction;
3436    //      int mx,my;
3437    
3438                          if (b_mb->mode == MODE_INTER && b_mb->cbp == 0 &&  /* use many blocks... */
3439                                  b_mb->mvs[0].x == 0 && b_mb->mvs[0].y == 0) {  /*              for (my = 0; my < (uint32_t)pParam->mb_height; my++)
3440                                  mb->mode = MODE_NOT_CODED;                  for (mx = 0; mx < (uint32_t)pParam->mb_width; mx++)
3441                                  mb->b_mvs[0] = mb->mvs[0] = zeroMV;                  {
3442                                  continue;                          const int mbnum = mx + my * pParam->mb_width;
3443                            pMBs[mbnum].mcsel=1;
3444                          }                          }
3445    */
3446    
3447                          if (b_mb->mode == MODE_INTER4V)  /* or rather don't use too many blocks... */
3448    /*
3449                    for (my = 1; my < (uint32_t)MBh-1; my++)
3450                    for (mx = 1; mx < (uint32_t)MBw-1; mx++)
3451                          {                          {
3452                                  d_sad16 = 0;                          const int mbnum = mx + my * MBw;
3453                          /* same method of scaling as in decoder.c, so we copy from there */                          if (MBmask[mbnum-1])
3454                      for (k = 0; k < 4; k++) {                                  MBmask[mbnum-1]=0;
3455                            else
3456                                          mb->directmv[k] = b_mb->mvs[k];                                  if (MBmask[mbnum-MBw])
3457                                            MBmask[mbnum-1]=0;
3458    
                                         mb->mvs[k].x = (int32_t) ((TRB * mb->directmv[k].x) / TRD + mb->deltamv.x);  
                     mb->b_mvs[k].x = (int32_t) ((mb->deltamv.x == 0)  
                                                                                 ? ((TRB - TRD) * mb->directmv[k].x) / TRD  
                                             : mb->mvs[k].x - mb->directmv[k].x);  
   
                     mb->mvs[k].y = (int32_t) ((TRB * mb->directmv[k].y) / TRD + mb->deltamv.y);  
                         mb->b_mvs[k].y = (int32_t) ((mb->deltamv.y == 0)  
                                                                                 ? ((TRB - TRD) * mb->directmv[k].y) / TRD  
                                             : mb->mvs[k].y - mb->directmv[k].y);  
   
                                         d_sad16 +=  
                                                 sad8bi(frame->image.y + 2*(i+(k&1))*8 + 2*(j+(k>>1))*8*edged_width,  
                                                   get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                                 2*(i+(k&1)), 2*(j+(k>>1)), 8, &mb->mvs[k], edged_width),  
                                                   get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                                 2*(i+(k&1)), 2*(j+(k>>1)), 8, &mb->b_mvs[k], edged_width),  
                                                   edged_width);  
                                 }  
3459                          }                          }
3460                          else  */
3461                          {                  gmcminSAD = globalSAD(&bestwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
                                 mb->directmv[3] = mb->directmv[2] = mb->directmv[1] =  
                                         mb->directmv[0] = b_mb->mvs[0];  
3462    
3463                                  mb->mvs[0].x = (int32_t) ((TRB * mb->directmv[0].x) / TRD + mb->deltamv.x);                  if ( (reference->coding_type == S_VOP)
3464                      mb->b_mvs[0].x = (int32_t) ((mb->deltamv.x == 0)                          && ( (reference->warp.duv[1].x != bestwp.duv[1].x)
3465                                                                          ? ((TRB - TRD) * mb->directmv[0].x) / TRD                            || (reference->warp.duv[1].y != bestwp.duv[1].y)
3466                                      : mb->mvs[0].x - mb->directmv[0].x);                            || (reference->warp.duv[0].x != bestwp.duv[0].x)
3467                              || (reference->warp.duv[0].y != bestwp.duv[0].y)
3468                      mb->mvs[0].y = (int32_t) ((TRB * mb->directmv[0].y) / TRD + mb->deltamv.y);                            || (reference->warp.duv[2].x != bestwp.duv[2].x)
3469                  mb->b_mvs[0].y = (int32_t) ((mb->directmv[0].y == 0)                            || (reference->warp.duv[2].y != bestwp.duv[2].y) ) )
3470                                                                          ? ((TRB - TRD) * mb->directmv[0].y) / TRD                  {
3471                                      : mb->mvs[0].y - mb->directmv[0].y);                          gmcSAD = globalSAD(&reference->warp, pParam, pMBs,
3472                                                                    current, pRef, pCurr, GMCblock);
                                 d_sad16 = sad16bi(frame->image.y + i * 16 + j * 16 * edged_width,  
                                                   get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                                 i, j, 16, &mb->mvs[0], edged_width),  
                                                   get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                                 i, j, 16, &mb->b_mvs[0], edged_width),  
                                                   edged_width);  
3473    
3474                            if (gmcSAD < gmcminSAD)
3475                            {       bestwp = reference->warp;
3476                                    gmcminSAD = gmcSAD;
3477                            }
3478              }              }
                     d_sad16 += calc_delta_16(mb->deltamv.x, mb->deltamv.y, 1, frame->quant);  
3479    
3480                          // forward search          do {
3481                          f_sad16 = SEARCH16(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,                  direction = 0;
3482                                                  &frame->image, i, j,                  centerwp = bestwp;
                                                 mb->mvs[0].x, mb->mvs[0].y,                     /* start point f_directMV */  
                                                 f_predMV.x, f_predMV.y,                         /* center is f-prediction */  
                                                 frame->motion_flags,  
                                                 frame->quant, frame->fcode, pParam,  
                                                 f_mbs, f_mbs,  
                                                 &mb->mvs[0], &pmv_dontcare);  
3483    
3484                    currwp = centerwp;
3485    
3486                          // backward search                  currwp.duv[0].x--;
3487                          b_sad16 = SEARCH16(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,                  gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3488                                                  &frame->image, i, j,                  if (gmcSAD < gmcminSAD)
3489                                                  mb->b_mvs[0].x, mb->b_mvs[0].y,         /* start point b_directMV */                  {       bestwp = currwp;
3490                                                  b_predMV.x, b_predMV.y,                         /* center is b-prediction */                          gmcminSAD = gmcSAD;
3491                                                  frame->motion_flags,                          direction = 1;
                                                 frame->quant, frame->bcode, pParam,  
                                                 b_mbs, b_mbs,  
                                                 &mb->b_mvs[0], &pmv_dontcare);  
   
                         i_sad16 =  
                                 sad16bi(frame->image.y + i * 16 + j * 16 * edged_width,  
                                                   get_ref_mv(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                                 i, j, 16, &mb->mvs[0], edged_width),  
                                                   get_ref_mv(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                                 i, j, 16, &mb->b_mvs[0], edged_width),  
                                                   edged_width);  
                     i_sad16 += calc_delta_16(mb->mvs[0].x-f_predMV.x, mb->mvs[0].y-f_predMV.y,  
                                                                 frame->fcode, frame->quant);  
                     i_sad16 += calc_delta_16(mb->b_mvs[0].x-b_predMV.x, mb->b_mvs[0].y-b_predMV.y,  
                                                                 frame->bcode, frame->quant);  
   
                         get_range(&f_min_dx, &f_max_dx, &f_min_dy, &f_max_dy, i, j, 16, iWidth, iHeight,  
                           frame->fcode);  
                         get_range(&b_min_dx, &b_max_dx, &b_min_dy, &b_max_dy, i, j, 16, iWidth, iHeight,  
                           frame->bcode);  
   
 /* Interpolated MC motion vector search, this is tedious and more complicated because there are  
    two values for everything, always one for backward and one for forward ME. Still, we don't gain  
    much from this search, maybe it should simply be skipped and simply current i_sad16 value used  
    as "optimal". */  
   
                         i_sad16 = Diamond16_InterpolMainSearch(  
                                                 f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                 frame->image.y + i * 16 + j * 16 * edged_width,  
                                                 b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                 i, j,  
                                                 mb->mvs[0].x, mb->mvs[0].y,  
                                                 mb->b_mvs[0].x, mb->b_mvs[0].y,  
                                                 i_sad16,  
                                                 &f_interpolMV, &b_interpolMV,  
                                                 f_predMV.x, f_predMV.y, b_predMV.x, b_predMV.y,  
                                                 f_min_dx, f_max_dx, f_min_dy, f_max_dy,  
                                                 b_min_dx, b_max_dx, b_min_dy, b_max_dy,  
                                                 edged_width,  2,  
                                                 frame->fcode, frame->bcode,frame->quant,0);  
   
                         i_sad16 = Diamond16_InterpolMainSearch(  
                                                 f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                 frame->image.y + i * 16 + j * 16 * edged_width,  
                                                 b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                 i, j,  
                                                 f_interpolMV.x, f_interpolMV.y,  
                                                 b_interpolMV.x, b_interpolMV.y,  
                                                 i_sad16,  
                                                 &f_interpolMV, &b_interpolMV,  
                                                 f_predMV.x, f_predMV.y, b_predMV.x, b_predMV.y,  
                                                 f_min_dx, f_max_dx, f_min_dy, f_max_dy,  
                                                 b_min_dx, b_max_dx, b_min_dy, b_max_dy,  
                                                 edged_width,  1,  
                                                 frame->fcode, frame->bcode,frame->quant,0);             // equiv to halfpel refine  
   
   
 /*  DIRECT MODE DELTA VECTOR SEARCH.  
     This has to be made more effective, but at the moment I'm happy it's running at all */  
   
 /* There are two range restrictions for direct mode: deltaMV is limited to [-32,31] in halfpel units, and  
    absolute vector must not lie outside of image dimensions. Constraint one is dealt with by CHECK_MV16_DIRECT  
    and for constraint two we need distance to boundary. This is done by get_range very large fcode (hack!) */  
   
                         get_range(&min_dx, &max_dx, &min_dy, &max_dy, i, j, 16, iWidth, iHeight, 19);  
   
                         d_sad16 = Diamond16_DirectMainSearch(  
                                                 f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                 frame->image.y + i*16 + j*16*edged_width,  
                                                 b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                 i, j,  
                                                 TRB,TRD,  
                                                 0,0,  
                                                 d_sad16,  
                                                 &mb->deltamv,  
                                                 mb->directmv, // this has to be pre-initialized with b_mb->mvs[]  
                                         min_dx, max_dx, min_dy, max_dy,  
                                                 edged_width, 2, frame->quant, 0);  
   
                         d_sad16 = Diamond16_DirectMainSearch(  
                                                 f_ref->y, f_refH->y, f_refV->y, f_refHV->y,  
                                                 frame->image.y + i*16 + j*16*edged_width,  
                                                 b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
                                                 i, j,  
                                                 TRB,TRD,  
                                                 mb->deltamv.x, mb->deltamv.y,  
                                                 d_sad16,  
                                                 &mb->deltamv,  
                                                 mb->directmv, // this has to be pre-initialized with b_mb->mvs[]  
                                         min_dx, max_dx, min_dy, max_dy,  
                                                 edged_width, 1, frame->quant, 0);               // equiv to halfpel refine  
   
   
 //                      i_sad16 = 65535;                /* remove the comment to disable any of the MODEs */  
 //                      f_sad16 = 65535;  
 //                      b_sad16 = 65535;  
 //                      d_sad16 = 65535;  
   
                         if (f_sad16 < b_sad16) {  
                                 best_sad = f_sad16;  
                                 mb->mode = MODE_FORWARD;  
                         } else {  
                                 best_sad = b_sad16;  
                                 mb->mode = MODE_BACKWARD;  
3492                          }                          }
3493                    else
3494                          if (i_sad16 < best_sad) {                  {
3495                                  best_sad = i_sad16;                  currwp = centerwp; currwp.duv[0].x++;
3496                                  mb->mode = MODE_INTERPOLATE;                  gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3497                    if (gmcSAD < gmcminSAD)
3498                    {       bestwp = currwp;
3499                            gmcminSAD = gmcSAD;
3500                            direction = 2;
3501                    }
3502                    }
3503                    if (direction) continue;
3504    
3505                    currwp = centerwp; currwp.duv[0].y--;
3506                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3507                    if (gmcSAD < gmcminSAD)
3508                    {       bestwp = currwp;
3509                            gmcminSAD = gmcSAD;
3510                            direction = 4;
3511                          }                          }
3512                    else
                         if (d_sad16 < best_sad) {  
   
                                 if (b_mb->mode == MODE_INTER4V)  
3513                                  {                                  {
3514                    currwp = centerwp; currwp.duv[0].y++;
3515                                  /* how to calc vectors is defined in standard. mvs[] and b_mvs[] are only for motion compensation */                  gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3516                                  /* for the bitstream, the value mb->deltamv is read directly */                  if (gmcSAD < gmcminSAD)
3517                    {       bestwp = currwp;
3518                              for (k = 0; k < 4; k++) {                          gmcminSAD = gmcSAD;
3519                            direction = 8;
3520                                                  mb->mvs[k].x = (int32_t) ((TRB * mb->directmv[k].x) / TRD + mb->deltamv.x);                  }
3521                              mb->b_mvs[k].x = (int32_t) ((mb->deltamv.x == 0)                  }
3522                                                                                          ? ((TRB - TRD) * mb->directmv[k].x) / TRD                  if (direction) continue;
3523                                                      : mb->mvs[k].x - mb->directmv[k].x);  
3524                    currwp = centerwp; currwp.duv[1].x++;
3525                              mb->mvs[k].y = (int32_t) ((TRB * mb->directmv[k].y) / TRD + mb->deltamv.y);                  gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3526                          mb->b_mvs[k].y = (int32_t) ((mb->deltamv.y == 0)                  if (gmcSAD < gmcminSAD)
3527                                                                                          ? ((TRB - TRD) * mb->directmv[k].y) / TRD                  {       bestwp = currwp;
3528                                              : mb->mvs[k].y - mb->directmv[k].y);                          gmcminSAD = gmcSAD;
3529                            direction = 32;
3530                    }
3531                    currwp.duv[2].y++;
3532                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3533                    if (gmcSAD < gmcminSAD)
3534                    {       bestwp = currwp;
3535                            gmcminSAD = gmcSAD;
3536                            direction = 1024;
3537                    }
3538    
3539                    currwp = centerwp; currwp.duv[1].x--;
3540                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3541                    if (gmcSAD < gmcminSAD)
3542                    {       bestwp = currwp;
3543                            gmcminSAD = gmcSAD;
3544                            direction = 16;
3545                    }
3546                    else
3547                    {
3548                    currwp = centerwp; currwp.duv[1].x++;
3549                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3550                    if (gmcSAD < gmcminSAD)
3551                    {       bestwp = currwp;
3552                            gmcminSAD = gmcSAD;
3553                            direction = 32;
3554                    }
3555                    }
3556                    if (direction) continue;
3557    
3558    
3559                    currwp = centerwp; currwp.duv[1].y--;
3560                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3561                    if (gmcSAD < gmcminSAD)
3562                    {       bestwp = currwp;
3563                            gmcminSAD = gmcSAD;
3564                            direction = 64;
3565                                          }                                          }
3566                    else
3567                    {
3568                    currwp = centerwp; currwp.duv[1].y++;
3569                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3570                    if (gmcSAD < gmcminSAD)
3571                    {       bestwp = currwp;
3572                            gmcminSAD = gmcSAD;
3573                            direction = 128;
3574                    }
3575                    }
3576                    if (direction) continue;
3577    
3578                    currwp = centerwp; currwp.duv[2].x--;
3579                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3580                    if (gmcSAD < gmcminSAD)
3581                    {       bestwp = currwp;
3582                            gmcminSAD = gmcSAD;
3583                            direction = 256;
3584                    }
3585                    else
3586                    {
3587                    currwp = centerwp; currwp.duv[2].x++;
3588                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3589                    if (gmcSAD < gmcminSAD)
3590                    {       bestwp = currwp;
3591                            gmcminSAD = gmcSAD;
3592                            direction = 512;
3593                    }
3594                    }
3595                    if (direction) continue;
3596    
3597                    currwp = centerwp; currwp.duv[2].y--;
3598                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3599                    if (gmcSAD < gmcminSAD)
3600                    {       bestwp = currwp;
3601                            gmcminSAD = gmcSAD;
3602                            direction = 1024;
3603                                  }                                  }
3604                                  else                                  else
3605                                  {                                  {
3606                                          mb->mvs[0].x = (int32_t) ((TRB * mb->directmv[0].x) / TRD + mb->deltamv.x);                  currwp = centerwp; currwp.duv[2].y++;
3607                    gmcSAD = globalSAD(&currwp, pParam, pMBs, current, pRef, pCurr, GMCblock);
3608                    if (gmcSAD < gmcminSAD)
3609                    {       bestwp = currwp;
3610                            gmcminSAD = gmcSAD;
3611                            direction = 2048;
3612                    }
3613                    }
3614            } while (direction);
3615            free(GMCblock);
3616    
3617                      mb->b_mvs[0].x = (int32_t) ((mb->deltamv.x == 0)          *startwp = bestwp;
                                                                                 ? ((TRB - TRD) * mb->directmv[0].x) / TRD  
                                         : mb->mvs[0].x - mb->directmv[0].x);  
3618    
3619                              mb->mvs[0].y = (int32_t) ((TRB * mb->directmv[0].y) / TRD + mb->deltamv.y);          return gmcminSAD;
3620    }
3621    
3622                          mb->b_mvs[0].y = (int32_t) ((mb->deltamv.y == 0)  int
3623                                                                                  ? ((TRB - TRD) * mb->directmv[0].y) / TRD  globalSAD(const WARPPOINTS *const wp,
3624                                              : mb->mvs[0].y - mb->directmv[0].y);                    const MBParam * const pParam,
3625                      const MACROBLOCK * const pMBs,
3626                      const FRAMEINFO * const current,
3627                      const IMAGE * const pRef,
3628                      const IMAGE * const pCurr,
3629                      uint8_t *const GMCblock)
3630    {
3631            NEW_GMC_DATA gmc_data;
3632            int iSAD, gmcSAD=0;
3633            int num=0;
3634            unsigned int mx, my;
3635    
3636                                          mb->mvs[3] = mb->mvs[2] = mb->mvs[1] = mb->mvs[0];          generate_GMCparameters( 3, 3, wp, pParam->width, pParam->height, &gmc_data);
                                         mb->b_mvs[3] = mb->b_mvs[2] = mb->b_mvs[1] = mb->b_mvs[0];  
                 }  
3637    
3638                                  best_sad = d_sad16;          for (my = 0; my < (uint32_t)pParam->mb_height; my++)
3639                                  mb->mode = MODE_DIRECT;                  for (mx = 0; mx < (uint32_t)pParam->mb_width; mx++) {
                         }  
3640    
3641                          switch (mb->mode)                  const int mbnum = mx + my * pParam->mb_width;
3642                          {                  const int iEdgedWidth = pParam->edged_width;
                                 case MODE_FORWARD:  
                                         f_count++;  
                                         f_predMV = mb->mvs[0];  
                                         break;  
                                 case MODE_BACKWARD:  
                                         b_count++;  
                                         b_predMV = mb->b_mvs[0];  
3643    
3644                                          break;                  if (!pMBs[mbnum].mcsel)
3645                                  case MODE_INTERPOLATE:                          continue;
                                         i_count++;  
                                         mb->mvs[0] = f_interpolMV;  
                                         mb->b_mvs[0] = b_interpolMV;  
                                         f_predMV = mb->mvs[0];  
                                         b_predMV = mb->b_mvs[0];  
                                         break;  
                                 case MODE_DIRECT:  
                                         d_count++;  
                                         break;  
                                 default:  
                                         break;  
                         }  
3646    
3647                    gmc_data.predict_16x16(&gmc_data, GMCblock,
3648                                                    pRef->y,
3649                                                    iEdgedWidth,
3650                                                    iEdgedWidth,
3651                                                    mx, my,
3652                                                    pParam->m_rounding_type);
3653    
3654                    iSAD = sad16 ( pCurr->y + 16*(my*iEdgedWidth + mx),
3655                                                    GMCblock , iEdgedWidth, 65536);
3656                    iSAD -= pMBs[mbnum].sad16;
3657    
3658                    if (iSAD<0)
3659                            gmcSAD += iSAD;
3660                    num++;
3661                  }                  }
3662            return gmcSAD;
3663          }          }
3664    
 #ifdef _DEBUG_BFRAME_STAT  
         fprintf(stderr,"B-Stat: F: %04d   B: %04d   I: %04d  D: %04d\n",  
                                 f_count,b_count,i_count,d_count);  
 #endif  
   
 }  
Legend:
Removed from v.348  
changed lines
  Added in v.1138
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4