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