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

Legend:
Removed from v.3  
changed lines
  Added in v.1107

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