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

Legend:
Removed from v.341  
changed lines
  Added in v.1084

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