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

Legend:
Removed from v.344  
changed lines
  Added in v.1108

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