[svn] / trunk / xvidcore / src / motion / motion_est.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/motion/motion_est.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

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

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