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

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

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

revision 1.44.2.2, Wed Sep 25 21:27:55 2002 UTC revision 1.58.2.4, Thu Mar 27 17:09:59 2003 UTC
# Line 31  Line 31 
31  #include <assert.h>  #include <assert.h>
32  #include <stdio.h>  #include <stdio.h>
33  #include <stdlib.h>  #include <stdlib.h>
34    #include <string.h>     // memcpy
35    #include <math.h>       // lrint
36    
37  #include "../encoder.h"  #include "../encoder.h"
38  #include "../utils/mbfunctions.h"  #include "../utils/mbfunctions.h"
39  #include "../prediction/mbprediction.h"  #include "../prediction/mbprediction.h"
40  #include "../global.h"  #include "../global.h"
41  #include "../utils/timer.h"  #include "../utils/timer.h"
42    #include "../image/interpolate8x8.h"
43  #include "motion_est.h"  #include "motion_est.h"
44  #include "motion.h"  #include "motion.h"
45  #include "sad.h"  #include "sad.h"
46  #include "../utils/emms.h"  #include "../utils/emms.h"
47    #include "../dct/fdct.h"
48    
49    /*****************************************************************************
50     * Modified rounding tables -- declared in motion.h
51     * Original tables see ISO spec tables 7-6 -> 7-9
52     ****************************************************************************/
53    
54    const uint32_t roundtab[16] =
55    {0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2 };
56    
57    /* K = 4 */
58    const uint32_t roundtab_76[16] =
59    { 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1 };
60    
61    /* K = 2 */
62    const uint32_t roundtab_78[8] =
63    { 0, 0, 1, 1, 0, 0, 0, 1  };
64    
65    /* K = 1 */
66    const uint32_t roundtab_79[4] =
67    { 0, 1, 0, 0 };
68    
69  #define INITIAL_SKIP_THRESH     (10)  #define INITIAL_SKIP_THRESH     (10)
70  #define FINAL_SKIP_THRESH       (50)  #define FINAL_SKIP_THRESH       (50)
71  #define MAX_SAD00_FOR_SKIP      (20)  #define MAX_SAD00_FOR_SKIP      (20)
72  #define MAX_CHROMA_SAD_FOR_SKIP (22)  #define MAX_CHROMA_SAD_FOR_SKIP (22)
 #define SKIP_THRESH_B (25)  
73    
74  #define CHECK_CANDIDATE(X,Y,D) { \  #define CHECK_CANDIDATE(X,Y,D) { \
75  (*CheckCandidate)((const int)(X),(const int)(Y), (D), &iDirection, data ); }  CheckCandidate((X),(Y), (D), &iDirection, data ); }
76    
77  #define iDiamondSize 2  /*****************************************************************************
78     * Code
79     ****************************************************************************/
80    
81  static __inline int  static __inline uint32_t
82  d_mv_bits(int x, int y, const uint32_t iFcode)  d_mv_bits(int x, int y, const VECTOR pred, const uint32_t iFcode, const int qpel, const int rrv)
83  {  {
84          int xb, yb;          int xb, yb;
85            x = qpel ? x<<1 : x;
86            y = qpel ? y<<1 : y;
87            if (rrv) { x = RRV_MV_SCALEDOWN(x); y = RRV_MV_SCALEDOWN(y); }
88    
89          if (x == 0) xb = 1;          x -= pred.x;
90          else {          y -= pred.y;
91                  if (x < 0) x = -x;  
92            if (x) {
93                    x = ABS(x);
94                  x += (1 << (iFcode - 1)) - 1;                  x += (1 << (iFcode - 1)) - 1;
95                  x >>= (iFcode - 1);                  x >>= (iFcode - 1);
96                  if (x > 32) x = 32;                  if (x > 32) x = 32;
97                  xb = mvtab[x] + iFcode;                  xb = mvtab[x] + iFcode;
98          }          } else xb = 1;
99    
100          if (y == 0) yb = 1;          if (y) {
101          else {                  y = ABS(y);
                 if (y < 0) y = -y;  
102                  y += (1 << (iFcode - 1)) - 1;                  y += (1 << (iFcode - 1)) - 1;
103                  y >>= (iFcode - 1);                  y >>= (iFcode - 1);
104                  if (y > 32) y = 32;                  if (y > 32) y = 32;
105                  yb = mvtab[y] + iFcode;                  yb = mvtab[y] + iFcode;
106          }          } else yb = 1;
107          return xb + yb;          return xb + yb;
108  }  }
109    
110    static int32_t ChromaSAD2(int fx, int fy, int bx, int by, const SearchData * const data)
111    {
112            int sad;
113            const uint32_t stride = data->iEdgedWidth/2;
114            uint8_t * f_refu = data->RefQ,
115                    * f_refv = data->RefQ + 8,
116                    * b_refu = data->RefQ + 16,
117                    * b_refv = data->RefQ + 24;
118    
119            switch (((fx & 1) << 1) | (fy & 1))     {
120                    case 0:
121                            fx = fx / 2; fy = fy / 2;
122                            f_refu = (uint8_t*)data->RefCU + fy * stride + fx, stride;
123                            f_refv = (uint8_t*)data->RefCV + fy * stride + fx, stride;
124                            break;
125                    case 1:
126                            fx = fx / 2; fy = (fy - 1) / 2;
127                            interpolate8x8_halfpel_v(f_refu, data->RefCU + fy * stride + fx, stride, data->rounding);
128                            interpolate8x8_halfpel_v(f_refv, data->RefCV + fy * stride + fx, stride, data->rounding);
129                            break;
130                    case 2:
131                            fx = (fx - 1) / 2; fy = fy / 2;
132                            interpolate8x8_halfpel_h(f_refu, data->RefCU + fy * stride + fx, stride, data->rounding);
133                            interpolate8x8_halfpel_h(f_refv, data->RefCV + fy * stride + fx, stride, data->rounding);
134                            break;
135                    default:
136                            fx = (fx - 1) / 2; fy = (fy - 1) / 2;
137                            interpolate8x8_halfpel_hv(f_refu, data->RefCU + fy * stride + fx, stride, data->rounding);
138                            interpolate8x8_halfpel_hv(f_refv, data->RefCV + fy * stride + fx, stride, data->rounding);
139                            break;
140            }
141    
142            switch (((bx & 1) << 1) | (by & 1))     {
143                    case 0:
144                            bx = bx / 2; by = by / 2;
145                            b_refu = (uint8_t*)data->b_RefCU + by * stride + bx, stride;
146                            b_refv = (uint8_t*)data->b_RefCV + by * stride + bx, stride;
147                            break;
148                    case 1:
149                            bx = bx / 2; by = (by - 1) / 2;
150                            interpolate8x8_halfpel_v(b_refu, data->b_RefCU + by * stride + bx, stride, data->rounding);
151                            interpolate8x8_halfpel_v(b_refv, data->b_RefCV + by * stride + bx, stride, data->rounding);
152                            break;
153                    case 2:
154                            bx = (bx - 1) / 2; by = by / 2;
155                            interpolate8x8_halfpel_h(b_refu, data->b_RefCU + by * stride + bx, stride, data->rounding);
156                            interpolate8x8_halfpel_h(b_refv, data->b_RefCV + by * stride + bx, stride, data->rounding);
157                            break;
158                    default:
159                            bx = (bx - 1) / 2; by = (by - 1) / 2;
160                            interpolate8x8_halfpel_hv(b_refu, data->b_RefCU + by * stride + bx, stride, data->rounding);
161                            interpolate8x8_halfpel_hv(b_refv, data->b_RefCV + by * stride + bx, stride, data->rounding);
162                            break;
163            }
164    
165            sad = sad8bi(data->CurU, b_refu, f_refu, stride);
166            sad += sad8bi(data->CurV, b_refv, f_refv, stride);
167    
168            return sad;
169    }
170    
171    
172    static int32_t
173    ChromaSAD(int dx, int dy, const SearchData * const data)
174    {
175            int sad;
176            const uint32_t stride = data->iEdgedWidth/2;
177    
178            if (dx == data->temp[5] && dy == data->temp[6]) return data->temp[7]; //it has been checked recently
179            data->temp[5] = dx; data->temp[6] = dy; // backup
180    
181            switch (((dx & 1) << 1) | (dy & 1))     {
182                    case 0:
183                            dx = dx / 2; dy = dy / 2;
184                            sad = sad8(data->CurU, data->RefCU + dy * stride + dx, stride);
185                            sad += sad8(data->CurV, data->RefCV + dy * stride + dx, stride);
186                            break;
187                    case 1:
188                            dx = dx / 2; dy = (dy - 1) / 2;
189                            sad = sad8bi(data->CurU, data->RefCU + dy * stride + dx, data->RefCU + (dy+1) * stride + dx, stride);
190                            sad += sad8bi(data->CurV, data->RefCV + dy * stride + dx, data->RefCV + (dy+1) * stride + dx, stride);
191                            break;
192                    case 2:
193                            dx = (dx - 1) / 2; dy = dy / 2;
194                            sad = sad8bi(data->CurU, data->RefCU + dy * stride + dx, data->RefCU + dy * stride + dx+1, stride);
195                            sad += sad8bi(data->CurV, data->RefCV + dy * stride + dx, data->RefCV + dy * stride + dx+1, stride);
196                            break;
197                    default:
198                            dx = (dx - 1) / 2; dy = (dy - 1) / 2;
199                            interpolate8x8_halfpel_hv(data->RefQ, data->RefCU + dy * stride + dx, stride, data->rounding);
200                            sad = sad8(data->CurU, data->RefQ, stride);
201    
202                            interpolate8x8_halfpel_hv(data->RefQ, data->RefCV + dy * stride + dx, stride, data->rounding);
203                            sad += sad8(data->CurV, data->RefQ, stride);
204                            break;
205            }
206            data->temp[7] = sad; //backup, part 2
207            return sad;
208    }
209    
210    static __inline const uint8_t *
211    GetReferenceB(const int x, const int y, const uint32_t dir, const SearchData * const data)
212    {
213    //      dir : 0 = forward, 1 = backward
214            switch ( (dir << 2) | ((x&1)<<1) | (y&1) ) {
215                    case 0 : return data->Ref + x/2 + (y/2)*(data->iEdgedWidth);
216                    case 1 : return data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
217                    case 2 : return data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);
218                    case 3 : return data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
219                    case 4 : return data->bRef + x/2 + (y/2)*(data->iEdgedWidth);
220                    case 5 : return data->bRefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
221                    case 6 : return data->bRefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);
222                    default : return data->bRefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
223            }
224    }
225    
226    // this is a simpler copy of GetReferenceB, but as it's __inline anyway, we can keep the two separate
227    static __inline const uint8_t *
228    GetReference(const int x, const int y, const SearchData * const data)
229    {
230            switch ( ((x&1)<<1) | (y&1) ) {
231                    case 0 : return data->Ref + x/2 + (y/2)*(data->iEdgedWidth);
232                    case 3 : return data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth);
233                    case 1 : return data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth);
234                    default : return data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth);      //case 2
235            }
236    }
237    
238    static uint8_t *
239    Interpolate8x8qpel(const int x, const int y, const uint32_t block, const uint32_t dir, const SearchData * const data)
240    {
241    // create or find a qpel-precision reference picture; return pointer to it
242            uint8_t * Reference = data->RefQ + 16*dir;
243            const uint32_t iEdgedWidth = data->iEdgedWidth;
244            const uint32_t rounding = data->rounding;
245            const int halfpel_x = x/2;
246            const int halfpel_y = y/2;
247            const uint8_t *ref1, *ref2, *ref3, *ref4;
248    
249            ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
250            ref1 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
251            switch( ((x&1)<<1) + (y&1) ) {
252            case 0: // pure halfpel position
253                    return (uint8_t *) ref1;
254                    break;
255    
256            case 1: // x halfpel, y qpel - top or bottom during qpel refinement
257                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
258                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
259                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
260                    break;
261    
262            case 2: // x qpel, y halfpel - left or right during qpel refinement
263                    ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
264                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
265                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
266                    break;
267    
268            default: // x and y in qpel resolution - the "corners" (top left/right and
269                             // bottom left/right) during qpel refinement
270                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
271                    ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
272                    ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
273                    ref2 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
274                    ref3 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
275                    ref4 += 8 * (block&1) + 8 * (block>>1) * iEdgedWidth;
276                    interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
277                    break;
278            }
279            return Reference;
280    }
281    
282    static uint8_t *
283    Interpolate16x16qpel(const int x, const int y, const uint32_t dir, const SearchData * const data)
284    {
285    // create or find a qpel-precision reference picture; return pointer to it
286            uint8_t * Reference = data->RefQ + 16*dir;
287            const uint32_t iEdgedWidth = data->iEdgedWidth;
288            const uint32_t rounding = data->rounding;
289            const int halfpel_x = x/2;
290            const int halfpel_y = y/2;
291            const uint8_t *ref1, *ref2, *ref3, *ref4;
292    
293            ref1 = GetReferenceB(halfpel_x, halfpel_y, dir, data);
294            switch( ((x&1)<<1) + (y&1) ) {
295            case 3: // x and y in qpel resolution - the "corners" (top left/right and
296                             // bottom left/right) during qpel refinement
297                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
298                    ref3 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
299                    ref4 = GetReferenceB(x - halfpel_x, y - halfpel_y, dir, data);
300                    interpolate8x8_avg4(Reference, ref1, ref2, ref3, ref4, iEdgedWidth, rounding);
301                    interpolate8x8_avg4(Reference+8, ref1+8, ref2+8, ref3+8, ref4+8, iEdgedWidth, rounding);
302                    interpolate8x8_avg4(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, ref3+8*iEdgedWidth, ref4+8*iEdgedWidth, iEdgedWidth, rounding);
303                    interpolate8x8_avg4(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, ref3+8*iEdgedWidth+8, ref4+8*iEdgedWidth+8, iEdgedWidth, rounding);
304                    break;
305    
306            case 1: // x halfpel, y qpel - top or bottom during qpel refinement
307                    ref2 = GetReferenceB(halfpel_x, y - halfpel_y, dir, data);
308                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
309                    interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
310                    interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
311                    interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
312                    break;
313    
314            case 2: // x qpel, y halfpel - left or right during qpel refinement
315                    ref2 = GetReferenceB(x - halfpel_x, halfpel_y, dir, data);
316                    interpolate8x8_avg2(Reference, ref1, ref2, iEdgedWidth, rounding, 8);
317                    interpolate8x8_avg2(Reference+8, ref1+8, ref2+8, iEdgedWidth, rounding, 8);
318                    interpolate8x8_avg2(Reference+8*iEdgedWidth, ref1+8*iEdgedWidth, ref2+8*iEdgedWidth, iEdgedWidth, rounding, 8);
319                    interpolate8x8_avg2(Reference+8*iEdgedWidth+8, ref1+8*iEdgedWidth+8, ref2+8*iEdgedWidth+8, iEdgedWidth, rounding, 8);
320                    break;
321    
322            case 0: // pure halfpel position
323                    return (uint8_t *) ref1;
324            }
325            return Reference;
326    }
327    
328  /* CHECK_CANDIATE FUNCTIONS START */  /* CHECK_CANDIATE FUNCTIONS START */
329    
330  static void  static void
331  CheckCandidate16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
332  {  {
333          int32_t * const sad = data->temp;          int xc, yc;
         int t;  
334          const uint8_t * Reference;          const uint8_t * Reference;
335            VECTOR * current;
336            int32_t sad; uint32_t t;
337    
338          if (( x > data->max_dx) || ( x < data->min_dx)          if (( x > data->max_dx) || ( x < data->min_dx)
339                  || ( y > data->max_dy) || (y < data->min_dy)) return;                  || ( y > data->max_dy) || (y < data->min_dy)) return;
340    
341          switch ( ((x&1)<<1) + (y&1) ) {          if (!data->qpel_precision) {
342                  case 0 : Reference = data->Ref + x/2 + (y/2)*(data->iEdgedWidth); break;                  Reference = GetReference(x, y, data);
343                  case 1 : Reference = data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth); break;                  current = data->currentMV;
344                  case 2 : Reference = data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth); break;                  xc = x; yc = y;
345                  default : Reference = data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth); break;          } else { // x and y are in 1/4 precision
346                    Reference = Interpolate16x16qpel(x, y, 0, data);
347                    xc = x/2; yc = y/2; //for chroma sad
348                    current = data->currentQMV;
349            }
350    
351            sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
352            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
353    
354            sad += (data->lambda16 * t * sad)>>10;
355            data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
356    
357            if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
358                                                                               (yc >> 1) + roundtab_79[yc & 0x3], data);
359    
360            if (sad < data->iMinSAD[0]) {
361                    data->iMinSAD[0] = sad;
362                    current[0].x = x; current[0].y = y;
363                    *dir = Direction;
364            }
365    
366            if (data->temp[1] < data->iMinSAD[1]) {
367                    data->iMinSAD[1] = data->temp[1]; current[1].x = x; current[1].y = y; }
368            if (data->temp[2] < data->iMinSAD[2]) {
369                    data->iMinSAD[2] = data->temp[2]; current[2].x = x; current[2].y = y; }
370            if (data->temp[3] < data->iMinSAD[3]) {
371                    data->iMinSAD[3] = data->temp[3]; current[3].x = x; current[3].y = y; }
372            if (data->temp[4] < data->iMinSAD[4]) {
373                    data->iMinSAD[4] = data->temp[4]; current[4].x = x; current[4].y = y; }
374    
375    }
376    
377    static void
378    CheckCandidate8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
379    {
380            int32_t sad; uint32_t t;
381            const uint8_t * Reference;
382    
383            if ( (x > data->max_dx) || (x < data->min_dx)
384                    || (y > data->max_dy) || (y < data->min_dy) ) return;
385    
386            if (!data->qpel_precision) Reference = GetReference(x, y, data);
387            else Reference = Interpolate8x8qpel(x, y, 0, 0, data);
388    
389            sad = sad8(data->Cur, Reference, data->iEdgedWidth);
390            t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
391    
392            sad += (data->lambda8 * t * (sad+NEIGH_8X8_BIAS))>>10;
393    
394            if (sad < *(data->iMinSAD)) {
395                    *(data->iMinSAD) = sad;
396                    data->currentMV->x = x; data->currentMV->y = y;
397                    *dir = Direction;
398          }          }
399    }
400    
401    
402          data->temp[0] = sad16v(data->Cur, Reference, data->iEdgedWidth, sad+1);  static void
403    CheckCandidate32(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
404    {
405            uint32_t t;
406            const uint8_t * Reference;
407    
408            if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || //non-zero integer value
409                    (x > data->max_dx) || (x < data->min_dx)
410                    || (y > data->max_dy) || (y < data->min_dy) ) return;
411    
412            Reference = GetReference(x, y, data);
413            t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);
414    
415          t = d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);          data->temp[0] = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp + 1);
416          data->temp[0] += lambda_vec16[data->iQuant] * t;  
417          data->temp[1] += lambda_vec8[data->iQuant] * t;          data->temp[0] += (data->lambda16 * t * data->temp[0]) >> 10;
418            data->temp[1] += (data->lambda8 * t * (data->temp[1] + NEIGH_8X8_BIAS))>>10;
419    
420          if (data->temp[0] < data->iMinSAD[0]) {          if (data->temp[0] < data->iMinSAD[0]) {
421                  data->iMinSAD[0] = data->temp[0];                  data->iMinSAD[0] = data->temp[0];
# Line 117  Line 430 
430                  data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }                  data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
431          if (data->temp[4] < data->iMinSAD[4]) {          if (data->temp[4] < data->iMinSAD[4]) {
432                  data->iMinSAD[4] = data->temp[4]; data->currentMV[4].x = x; data->currentMV[4].y = y; }                  data->iMinSAD[4] = data->temp[4]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
   
433  }  }
434    
435  static void  static void
436  CheckCandidate16no4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate16no4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
437  {  {
438          int32_t sad;          int32_t sad, xc, yc;
439          const uint8_t * Reference;          const uint8_t * Reference;
440            uint32_t t;
441            VECTOR * current;
442    
443          if (( x > data->max_dx) || ( x < data->min_dx)          if ( (x > data->max_dx) | ( x < data->min_dx)
444                  || ( y > data->max_dy) || (y < data->min_dy)) return;                  | (y > data->max_dy) | (y < data->min_dy) ) return;
445    
446          switch ( ((x&1)<<1) + (y&1) )          if (data->rrv && (!(x&1) && x !=0) | (!(y&1) && y !=0) ) return; //non-zero even value
447          {  
448                  case 0 : Reference = data->Ref + x/2 + (y/2)*(data->iEdgedWidth); break;          if (data->qpel_precision) { // x and y are in 1/4 precision
449                  case 1 : Reference = data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth); break;                  Reference = Interpolate16x16qpel(x, y, 0, data);
450                  case 2 : Reference = data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth); break;                  current = data->currentQMV;
451                  default : Reference = data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth); break;                  xc = x/2; yc = y/2;
452            } else {
453                    Reference = GetReference(x, y, data);
454                    current = data->currentMV;
455                    xc = x; yc = y;
456          }          }
457            t = d_mv_bits(x, y, data->predMV, data->iFcode,
458                                            data->qpel^data->qpel_precision, data->rrv);
459    
460          sad = lambda_vec16[data->iQuant] *          sad = sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);
461                          d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);          sad += (data->lambda16 * t * sad)>>10;
462          sad += sad16(data->Cur, Reference, data->iEdgedWidth, 256*4096);  
463            if (data->chroma) sad += ChromaSAD((xc >> 1) + roundtab_79[xc & 0x3],
464                                                                                    (yc >> 1) + roundtab_79[yc & 0x3], data);
465    
466          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
467                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
468                  data->currentMV[0].x = x; data->currentMV[0].y = y;                  current->x = x; current->y = y;
469                  *dir = Direction; }                  *dir = Direction;
470            }
471  }  }
472    
473  static void  static void
474  CheckCandidate16no4vI(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidate32I(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
475  {  {
476    // maximum speed - for P/B/I decision
477          int32_t sad;          int32_t sad;
478    
479          if (( x > data->max_dx) || ( x < data->min_dx)          if (( x > data->max_dx) || ( x < data->min_dx)
480                  || ( y > data->max_dy) || (y < data->min_dy)) return;                  || ( y > data->max_dy) || (y < data->min_dy)) return;
481    
482          sad = lambda_vec16[data->iQuant] *          sad = sad32v_c(data->Cur, data->Ref + x/2 + (y/2)*(data->iEdgedWidth),
483                          d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);                                                          data->iEdgedWidth, data->temp+1);
   
         sad += sad16(data->Cur, data->Ref + x/2 + (y/2)*(data->iEdgedWidth),  
                                         data->iEdgedWidth, 256*4096);  
484    
485          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
486                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
487                  data->currentMV[0].x = x; data->currentMV[0].y = y;                  data->currentMV[0].x = x; data->currentMV[0].y = y;
488                  *dir = Direction; }                  *dir = Direction;
489  }  }
490            if (data->temp[1] < data->iMinSAD[1]) {
491                    data->iMinSAD[1] = data->temp[1]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
492            if (data->temp[2] < data->iMinSAD[2]) {
493                    data->iMinSAD[2] = data->temp[2]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
494            if (data->temp[3] < data->iMinSAD[3]) {
495                    data->iMinSAD[3] = data->temp[3]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
496            if (data->temp[4] < data->iMinSAD[4]) {
497                    data->iMinSAD[4] = data->temp[4]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
498    
499    }
500    
501  static void  static void
502  CheckCandidateInt(const int xf, const int yf, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateInt(const int xf, const int yf, const int Direction, int * const dir, const SearchData * const data)
503  {  {
504          int32_t sad;          int32_t sad, xb, yb, xcf, ycf, xcb, ycb;
505          const int xb = data->currentMV[1].x;          uint32_t t;
         const int yb = data->currentMV[1].y;  
506          const uint8_t *ReferenceF, *ReferenceB;          const uint8_t *ReferenceF, *ReferenceB;
507            VECTOR *current;
508    
509          if (( xf > data->max_dx) || ( xf < data->min_dx)          if ((xf > data->max_dx) || (xf < data->min_dx) ||
510                  || ( yf > data->max_dy) || (yf < data->min_dy)) return;                  (yf > data->max_dy) || (yf < data->min_dy))
511                    return;
512          switch ( ((xf&1)<<1) + (yf&1) ) {  
513                  case 0 : ReferenceF = data->Ref + xf/2 + (yf/2)*(data->iEdgedWidth); break;          if (!data->qpel_precision) {
514                  case 1 : ReferenceF = data->RefV + xf/2 + ((yf-1)/2)*(data->iEdgedWidth); break;                  ReferenceF = GetReference(xf, yf, data);
515                  case 2 : ReferenceF = data->RefH + (xf-1)/2 + (yf/2)*(data->iEdgedWidth); break;                  xb = data->currentMV[1].x; yb = data->currentMV[1].y;
516                  default : ReferenceF = data->RefHV + (xf-1)/2 + ((yf-1)/2)*(data->iEdgedWidth); break;                  ReferenceB = GetReferenceB(xb, yb, 1, data);
517          }                  current = data->currentMV;
518                    xcf = xf; ycf = yf;
519          switch ( ((xb&1)<<1) + (yb&1) ) {                  xcb = xb; ycb = yb;
520                  case 0 : ReferenceB = data->bRef + xb/2 + (yb/2)*(data->iEdgedWidth); break;          } else {
521                  case 1 : ReferenceB = data->bRefV + xb/2 + ((yb-1)/2)*(data->iEdgedWidth); break;                  ReferenceF = Interpolate16x16qpel(xf, yf, 0, data);
522                  case 2 : ReferenceB = data->bRefH + (xb-1)/2 + (yb/2)*(data->iEdgedWidth); break;                  xb = data->currentQMV[1].x; yb = data->currentQMV[1].y;
523                  default : ReferenceB = data->bRefHV + (xb-1)/2 + ((yb-1)/2)*(data->iEdgedWidth); break;                  current = data->currentQMV;
524          }                  ReferenceB = Interpolate16x16qpel(xb, yb, 1, data);
525                    xcf = xf/2; ycf = yf/2;
526          sad = lambda_vec16[data->iQuant] *                  xcb = xb/2; ycb = yb/2;
527                          ( d_mv_bits(xf - data->predMV.x, yf - data->predMV.y, data->iFcode) +          }
528                            d_mv_bits(xb - data->bpredMV.x, yb - data->bpredMV.y, data->iFcode) );  
529            t = d_mv_bits(xf, yf, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0)
530          sad += sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);                   + d_mv_bits(xb, yb, data->bpredMV, data->iFcode, data->qpel^data->qpel_precision, 0);
531    
532            sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
533            sad += (data->lambda16 * t * sad)>>10;
534    
535            if (data->chroma) sad += ChromaSAD2((xcf >> 1) + roundtab_79[xcf & 0x3],
536                                                                                    (ycf >> 1) + roundtab_79[ycf & 0x3],
537                                                                                    (xcb >> 1) + roundtab_79[xcb & 0x3],
538                                                                                    (ycb >> 1) + roundtab_79[ycb & 0x3], data);
539    
540          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
541                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
542                  data->currentMV->x = xf; data->currentMV->y = yf;                  current->x = xf; current->y = yf;
543                  *dir = Direction; }                  *dir = Direction;
544            }
545  }  }
546    
547  static void  static void
548  CheckCandidateDirect(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateDirect(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
549  {  {
550          int32_t sad;          int32_t sad = 0, xcf = 0, ycf = 0, xcb = 0, ycb = 0;
551          int k;          uint32_t k;
552          const uint8_t *ReferenceF;          const uint8_t *ReferenceF;
553          const uint8_t *ReferenceB;          const uint8_t *ReferenceB;
554          VECTOR mvs, b_mvs;          VECTOR mvs, b_mvs;
555    
556          if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return;          if (( x > 31) || ( x < -32) || ( y > 31) || (y < -32)) return;
557    
         sad = lambda_vec16[data->iQuant] * d_mv_bits(x, y, 1);  
   
558          for (k = 0; k < 4; k++) {          for (k = 0; k < 4; k++) {
559                  mvs.x = data->directmvF[k].x + x;                  mvs.x = data->directmvF[k].x + x;
560                  b_mvs.x = ((x == 0) ?                  b_mvs.x = ((x == 0) ?
# Line 229  Line 566 
566                          data->directmvB[k].y                          data->directmvB[k].y
567                          : mvs.y - data->referencemv[k].y);                          : mvs.y - data->referencemv[k].y);
568    
569                  if (( mvs.x > data->max_dx ) || ( mvs.x < data->min_dx )                  if ((mvs.x > data->max_dx)   || (mvs.x < data->min_dx)   ||
570                          || ( mvs.y > data->max_dy ) || ( mvs.y < data->min_dy )                          (mvs.y > data->max_dy)   || (mvs.y < data->min_dy)   ||
571                          || ( b_mvs.x > data->max_dx ) || ( b_mvs.x < data->min_dx )                          (b_mvs.x > data->max_dx) || (b_mvs.x < data->min_dx) ||
572                          || ( b_mvs.y > data->max_dy ) || ( b_mvs.y < data->min_dy )) return;                          (b_mvs.y > data->max_dy) || (b_mvs.y < data->min_dy) )
573                            return;
574                  switch ( ((mvs.x&1)<<1) + (mvs.y&1) ) {  
575                          case 0 : ReferenceF = data->Ref + mvs.x/2 + (mvs.y/2)*(data->iEdgedWidth); break;                  if (data->qpel) {
576                          case 1 : ReferenceF = data->RefV + mvs.x/2 + ((mvs.y-1)/2)*(data->iEdgedWidth); break;                          xcf += mvs.x/2; ycf += mvs.y/2;
577                          case 2 : ReferenceF = data->RefH + (mvs.x-1)/2 + (mvs.y/2)*(data->iEdgedWidth); break;                          xcb += b_mvs.x/2; ycb += b_mvs.y/2;
578                          default : ReferenceF = data->RefHV + (mvs.x-1)/2 + ((mvs.y-1)/2)*(data->iEdgedWidth); break;                  } else {
579                  }                          xcf += mvs.x; ycf += mvs.y;
580                            xcb += b_mvs.x; ycb += b_mvs.y;
581                  switch ( ((b_mvs.x&1)<<1) + (b_mvs.y&1) ) {                          mvs.x *= 2; mvs.y *= 2; //we move to qpel precision anyway
582                          case 0 : ReferenceB = data->bRef + b_mvs.x/2 + (b_mvs.y/2)*(data->iEdgedWidth); break;                          b_mvs.x *= 2; b_mvs.y *= 2;
                         case 1 : ReferenceB = data->bRefV + b_mvs.x/2 + ((b_mvs.y-1)/2)*(data->iEdgedWidth); break;  
                         case 2 : ReferenceB = data->bRefH + (b_mvs.x-1)/2 + (b_mvs.y/2)*(data->iEdgedWidth); break;  
                         default : ReferenceB = data->bRefHV + (b_mvs.x-1)/2 + ((b_mvs.y-1)/2)*(data->iEdgedWidth); break;  
583                  }                  }
584    
585                    ReferenceF = Interpolate8x8qpel(mvs.x, mvs.y, k, 0, data);
586                    ReferenceB = Interpolate8x8qpel(b_mvs.x, b_mvs.y, k, 1, data);
587    
588                  sad += sad8bi(data->Cur + 8*(k&1) + 8*(k>>1)*(data->iEdgedWidth),                  sad += sad8bi(data->Cur + 8*(k&1) + 8*(k>>1)*(data->iEdgedWidth),
589                                                  ReferenceF + 8*(k&1) + 8*(k>>1)*(data->iEdgedWidth),                                                  ReferenceF, ReferenceB, data->iEdgedWidth);
                                                 ReferenceB + 8*(k&1) + 8*(k>>1)*(data->iEdgedWidth),  
                                                 data->iEdgedWidth);  
590                  if (sad > *(data->iMinSAD)) return;                  if (sad > *(data->iMinSAD)) return;
591          }          }
592    
593            sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
594    
595            if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
596                                                                                    (ycf >> 3) + roundtab_76[ycf & 0xf],
597                                                                                    (xcb >> 3) + roundtab_76[xcb & 0xf],
598                                                                                    (ycb >> 3) + roundtab_76[ycb & 0xf], data);
599    
600          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
601                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
602                  data->currentMV->x = x; data->currentMV->y = y;                  data->currentMV->x = x; data->currentMV->y = y;
603                  *dir = Direction; }                  *dir = Direction;
604            }
605  }  }
606    
607  static void  static void
608  CheckCandidateDirectno4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateDirectno4v(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
609  {  {
610          int32_t sad;          int32_t sad, xcf, ycf, xcb, ycb;
611          const uint8_t *ReferenceF;          const uint8_t *ReferenceF;
612          const uint8_t *ReferenceB;          const uint8_t *ReferenceB;
613          VECTOR mvs, b_mvs;          VECTOR mvs, b_mvs;
614    
615          if (( x > 31) || ( x < -31) || ( y > 31) || (y < -31)) return;          if (( x > 31) | ( x < -32) | ( y > 31) | (y < -32)) return;
   
                 sad = lambda_vec16[data->iQuant] * d_mv_bits(x, y, 1);  
616    
617          mvs.x = data->directmvF[0].x + x;          mvs.x = data->directmvF[0].x + x;
618          b_mvs.x = ((x == 0) ?          b_mvs.x = ((x == 0) ?
# Line 283  Line 624 
624                  data->directmvB[0].y                  data->directmvB[0].y
625                  : mvs.y - data->referencemv[0].y);                  : mvs.y - data->referencemv[0].y);
626    
627          if (( mvs.x > data->max_dx ) || ( mvs.x < data->min_dx )          if ( (mvs.x > data->max_dx) | (mvs.x < data->min_dx)
628                  || ( mvs.y > data->max_dy ) || ( mvs.y < data->min_dy )                  | (mvs.y > data->max_dy) | (mvs.y < data->min_dy)
629                  || ( b_mvs.x > data->max_dx ) || ( b_mvs.x < data->min_dx )                  | (b_mvs.x > data->max_dx) | (b_mvs.x < data->min_dx)
630                  || ( b_mvs.y > data->max_dy ) || ( b_mvs.y < data->min_dy )) return;                  | (b_mvs.y > data->max_dy) | (b_mvs.y < data->min_dy) ) return;
631    
632          switch ( ((mvs.x&1)<<1) + (mvs.y&1) ) {          if (data->qpel) {
633                  case 0 : ReferenceF = data->Ref + mvs.x/2 + (mvs.y/2)*(data->iEdgedWidth); break;                  xcf = 4*(mvs.x/2); ycf = 4*(mvs.y/2);
634                  case 1 : ReferenceF = data->RefV + mvs.x/2 + ((mvs.y-1)/2)*(data->iEdgedWidth); break;                  xcb = 4*(b_mvs.x/2); ycb = 4*(b_mvs.y/2);
635                  case 2 : ReferenceF = data->RefH + (mvs.x-1)/2 + (mvs.y/2)*(data->iEdgedWidth); break;                  ReferenceF = Interpolate16x16qpel(mvs.x, mvs.y, 0, data);
636                  default : ReferenceF = data->RefHV + (mvs.x-1)/2 + ((mvs.y-1)/2)*(data->iEdgedWidth); break;                  ReferenceB = Interpolate16x16qpel(b_mvs.x, b_mvs.y, 1, data);
637          }          } else {
638                    xcf = 4*mvs.x; ycf = 4*mvs.y;
639          switch ( ((b_mvs.x&1)<<1) + (b_mvs.y&1) ) {                  xcb = 4*b_mvs.x; ycb = 4*b_mvs.y;
640                  case 0 : ReferenceB = data->bRef + b_mvs.x/2 + (b_mvs.y/2)*(data->iEdgedWidth); break;                  ReferenceF = GetReference(mvs.x, mvs.y, data);
641                  case 1 : ReferenceB = data->bRefV + b_mvs.x/2 + ((b_mvs.y-1)/2)*(data->iEdgedWidth); break;                  ReferenceB = GetReferenceB(b_mvs.x, b_mvs.y, 1, data);
                 case 2 : ReferenceB = data->bRefH + (b_mvs.x-1)/2 + (b_mvs.y/2)*(data->iEdgedWidth); break;  
                 default : ReferenceB = data->bRefHV + (b_mvs.x-1)/2 + ((b_mvs.y-1)/2)*(data->iEdgedWidth); break;  
642          }          }
643    
644          sad += sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);          sad = sad16bi(data->Cur, ReferenceF, ReferenceB, data->iEdgedWidth);
645            sad += (data->lambda16 * d_mv_bits(x, y, zeroMV, 1, 0, 0) * sad)>>10;
646    
647            if (data->chroma) sad += ChromaSAD2((xcf >> 3) + roundtab_76[xcf & 0xf],
648                                                                                    (ycf >> 3) + roundtab_76[ycf & 0xf],
649                                                                                    (xcb >> 3) + roundtab_76[xcb & 0xf],
650                                                                                    (ycb >> 3) + roundtab_76[ycb & 0xf], data);
651    
652          if (sad < *(data->iMinSAD)) {          if (sad < *(data->iMinSAD)) {
653                  *(data->iMinSAD) = sad;                  *(data->iMinSAD) = sad;
654                  data->currentMV->x = x; data->currentMV->y = y;                  data->currentMV->x = x; data->currentMV->y = y;
655                  *dir = Direction; }                  *dir = Direction;
656  }  }
657    }
658    
659    
660  static void  static void
661  CheckCandidate8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)  CheckCandidateBits16(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
662  {  {
663          int32_t sad;  
664          const uint8_t * Reference;          static int16_t in[64], coeff[64];
665            int32_t bits = 0, sum;
666            VECTOR * current;
667            const uint8_t * ptr;
668            int i, cbp = 0, t, xc, yc;
669    
670          if (( x > data->max_dx) || ( x < data->min_dx)          if (( x > data->max_dx) || ( x < data->min_dx)
671                  || ( y > data->max_dy) || (y < data->min_dy)) return;                  || ( y > data->max_dy) || (y < data->min_dy)) return;
672    
673          switch ( ((x&1)<<1) + (y&1) )          if (!data->qpel_precision) {
674          {                  ptr = GetReference(x, y, data);
675                  case 0 : Reference = data->Ref + x/2 + (y/2)*(data->iEdgedWidth); break;                  current = data->currentMV;
676                  case 1 : Reference = data->RefV + x/2 + ((y-1)/2)*(data->iEdgedWidth); break;                  xc = x; yc = y;
677                  case 2 : Reference = data->RefH + (x-1)/2 + (y/2)*(data->iEdgedWidth); break;          } else { // x and y are in 1/4 precision
678                  default : Reference = data->RefHV + (x-1)/2 + ((y-1)/2)*(data->iEdgedWidth); break;                  ptr = Interpolate16x16qpel(x, y, 0, data);
679                    current = data->currentQMV;
680                    xc = x/2; yc = y/2;
681            }
682    
683            for(i = 0; i < 4; i++) {
684                    int s = 8*((i&1) + (i>>1)*data->iEdgedWidth);
685                    transfer_8to16subro(in, data->Cur + s, ptr + s, data->iEdgedWidth);
686                    fdct(in);
687                    if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
688                    else sum = quant4_inter(coeff, in, data->lambda16);
689                    if (sum > 0) {
690                            cbp |= 1 << (5 - i);
691                            bits += data->temp[i] = CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
692                    } else data->temp[i] = 0;
693            }
694    
695            bits += t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
696    
697            if (bits < data->iMinSAD[0]) { // there is still a chance, adding chroma
698                    xc = (xc >> 1) + roundtab_79[xc & 0x3];
699                    yc = (yc >> 1) + roundtab_79[yc & 0x3];
700    
701                    //chroma U
702                    ptr = interpolate8x8_switch2(data->RefQ + 64, data->RefCU, 0, 0, xc, yc,  data->iEdgedWidth/2, data->rounding);
703                    transfer_8to16subro(in, ptr, data->CurU, data->iEdgedWidth/2);
704                    fdct(in);
705                    if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
706                    else sum = quant4_inter(coeff, in, data->lambda16);
707                    if (sum > 0) {
708                            cbp |= 1 << (5 - 4);
709                            bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
710                    }
711    
712                    if (bits < data->iMinSAD[0]) {
713                            //chroma V
714                            ptr = interpolate8x8_switch2(data->RefQ + 64, data->RefCV, 0, 0, xc, yc,  data->iEdgedWidth/2, data->rounding);
715                            transfer_8to16subro(in, ptr, data->CurV, data->iEdgedWidth/2);
716                            fdct(in);
717                            if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
718                            else sum = quant4_inter(coeff, in, data->lambda16);
719                            if (sum > 0) {
720                                    cbp |= 1 << (5 - 5);
721                                    bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
722                            }
723                    }
724            }
725    
726            bits += cbpy_tab[15-(cbp>>2)].len;
727            bits += mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len;
728    
729            if (bits < data->iMinSAD[0]) {
730                    data->iMinSAD[0] = bits;
731                    current[0].x = x; current[0].y = y;
732                    *dir = Direction;
733            }
734    
735            if (data->temp[0] + t < data->iMinSAD[1]) {
736                    data->iMinSAD[1] = data->temp[0] + t; current[1].x = x; current[1].y = y; }
737            if (data->temp[1] < data->iMinSAD[2]) {
738                    data->iMinSAD[2] = data->temp[1]; current[2].x = x; current[2].y = y; }
739            if (data->temp[2] < data->iMinSAD[3]) {
740                    data->iMinSAD[3] = data->temp[2]; current[3].x = x; current[3].y = y; }
741            if (data->temp[3] < data->iMinSAD[4]) {
742                    data->iMinSAD[4] = data->temp[3]; current[4].x = x; current[4].y = y; }
743    
744          }          }
745    static void
746    CheckCandidateBits8(const int x, const int y, const int Direction, int * const dir, const SearchData * const data)
747    {
748    
749          sad = sad8(data->Cur, Reference, data->iEdgedWidth);          static int16_t in[64], coeff[64];
750          sad += lambda_vec8[data->iQuant] * d_mv_bits(x - data->predMV.x, y - data->predMV.y, data->iFcode);          int32_t sum, bits;
751            VECTOR * current;
752            const uint8_t * ptr;
753            int cbp;
754    
755          if (sad < *(data->iMinSAD)) {          if ( (x > data->max_dx) || (x < data->min_dx)
756                  *(data->iMinSAD) = sad;                  || (y > data->max_dy) || (y < data->min_dy) ) return;
757                  data->currentMV->x = x; data->currentMV->y = y;  
758                  *dir = Direction; }          if (!data->qpel_precision) {
759                    ptr = GetReference(x, y, data);
760                    current = data->currentMV;
761            } else { // x and y are in 1/4 precision
762                    ptr = Interpolate8x8qpel(x, y, 0, 0, data);
763                    current = data->currentQMV;
764            }
765    
766            transfer_8to16subro(in, data->Cur, ptr, data->iEdgedWidth);
767            fdct(in);
768            if (data->lambda8 == 0) sum = quant_inter(coeff, in, data->lambda16);
769            else sum = quant4_inter(coeff, in, data->lambda16);
770            if (sum > 0) {
771                    bits = CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
772                    cbp = 1;
773            } else cbp = bits = 0;
774    
775            bits += sum = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
776    
777            if (bits < data->iMinSAD[0]) {
778                    data->temp[0] = cbp;
779                    data->iMinSAD[0] = bits;
780                    current[0].x = x; current[0].y = y;
781                    *dir = Direction;
782            }
783  }  }
784    
785  /* CHECK_CANDIATE FUNCTIONS END */  /* CHECK_CANDIATE FUNCTIONS END */
# Line 348  Line 794 
794    
795                  int iDirection;                  int iDirection;
796    
797                  do {          for(;;) { //forever
798                          iDirection = 0;                          iDirection = 0;
799                          if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);                          if (bDirection & 1) CHECK_CANDIDATE(x - iDiamondSize, y, 1);
800                          if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);                          if (bDirection & 2) CHECK_CANDIDATE(x + iDiamondSize, y, 2);
# Line 357  Line 803 
803    
804                          /* now we're doing diagonal checks near our candidate */                          /* now we're doing diagonal checks near our candidate */
805    
806                          if (iDirection) {               //checking if anything found                  if (iDirection) {               //if anything found
807                                  bDirection = iDirection;                                  bDirection = iDirection;
808                                  iDirection = 0;                                  iDirection = 0;
809                                  x = data->currentMV->x; y = data->currentMV->y;                                  x = data->currentMV->x; y = data->currentMV->y;
# Line 366  Line 812 
812                                          CHECK_CANDIDATE(x, y - iDiamondSize, 4);                                          CHECK_CANDIDATE(x, y - iDiamondSize, 4);
813                                  } else {                        // what remains here is up or down                                  } else {                        // what remains here is up or down
814                                          CHECK_CANDIDATE(x + iDiamondSize, y, 2);                                          CHECK_CANDIDATE(x + iDiamondSize, y, 2);
815                                          CHECK_CANDIDATE(x - iDiamondSize, y, 1); }                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);
816                            }
817    
818                                  if (iDirection) {                                  if (iDirection) {
819                                          bDirection += iDirection;                                          bDirection += iDirection;
820                                          x = data->currentMV->x; y = data->currentMV->y; }                                  x = data->currentMV->x; y = data->currentMV->y;
821                            }
822                          } else {                                //about to quit, eh? not so fast....                          } else {                                //about to quit, eh? not so fast....
823                                  switch (bDirection) {                                  switch (bDirection) {
824                                  case 2:                                  case 2:
# Line 421  Line 869 
869                                  x = data->currentMV->x; y = data->currentMV->y;                                  x = data->currentMV->x; y = data->currentMV->y;
870                          }                          }
871                  }                  }
                 while (1);                              //forever  
872  }  }
873    
874  static void  static void
# Line 471  Line 918 
918                                          CHECK_CANDIDATE(x, y - iDiamondSize, 4);                                          CHECK_CANDIDATE(x, y - iDiamondSize, 4);
919                                  } else {                        // what remains here is up or down                                  } else {                        // what remains here is up or down
920                                          CHECK_CANDIDATE(x + iDiamondSize, y, 2);                                          CHECK_CANDIDATE(x + iDiamondSize, y, 2);
921                                          CHECK_CANDIDATE(x - iDiamondSize, y, 1); }                                  CHECK_CANDIDATE(x - iDiamondSize, y, 1);
922                            }
923                                  bDirection += iDirection;                                  bDirection += iDirection;
924                                  x = data->currentMV->x; y = data->currentMV->y;                                  x = data->currentMV->x; y = data->currentMV->y;
925                          }                          }
# Line 482  Line 929 
929    
930  /* MAINSEARCH FUNCTIONS END */  /* MAINSEARCH FUNCTIONS END */
931    
 /* HALFPELREFINE COULD BE A MAINSEARCH FUNCTION, BUT THERE IS NO NEED FOR IT */  
   
932  static void  static void
933  HalfpelRefine(const SearchData * const data)  SubpelRefine(const SearchData * const data)
934  {  {
935  /* Do a half-pel refinement (or rather a "smallest possible amount" refinement) */  /* Do a half-pel or q-pel refinement */
936            const VECTOR centerMV = data->qpel_precision ? *data->currentQMV : *data->currentMV;
937          VECTOR backupMV = *(data->currentMV);          int iDirection; //only needed because macro expects it
938          int iDirection; //not needed  
939            CHECK_CANDIDATE(centerMV.x, centerMV.y - 1, 0);
940          CHECK_CANDIDATE(backupMV.x - 1, backupMV.y - 1, 0);          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y - 1, 0);
941          CHECK_CANDIDATE(backupMV.x + 1, backupMV.y - 1, 0);          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y, 0);
942          CHECK_CANDIDATE(backupMV.x - 1, backupMV.y + 1, 0);          CHECK_CANDIDATE(centerMV.x + 1, centerMV.y + 1, 0);
943          CHECK_CANDIDATE(backupMV.x + 1, backupMV.y + 1, 0);          CHECK_CANDIDATE(centerMV.x, centerMV.y + 1, 0);
944            CHECK_CANDIDATE(centerMV.x - 1, centerMV.y + 1, 0);
945          CHECK_CANDIDATE(backupMV.x - 1, backupMV.y, 0);          CHECK_CANDIDATE(centerMV.x - 1, centerMV.y, 0);
946          CHECK_CANDIDATE(backupMV.x + 1, backupMV.y, 0);          CHECK_CANDIDATE(centerMV.x - 1, centerMV.y - 1, 0);
   
         CHECK_CANDIDATE(backupMV.x, backupMV.y + 1, 0);  
         CHECK_CANDIDATE(backupMV.x, backupMV.y - 1, 0);  
947  }  }
948    
949  static __inline int  static __inline int
950  SkipDecisionP(const IMAGE * current, const IMAGE * reference,  SkipDecisionP(const IMAGE * current, const IMAGE * reference,
951                                                          const int x, const int y,                                                          const int x, const int y,
952                                                          const uint32_t iEdgedWidth, const uint32_t iQuant)                                                          const uint32_t stride, const uint32_t iQuant, int rrv)
953    
954  {  {
955  /*      keep repeating checks for all b-frames before this P frame,          if(!rrv) {
956          to make sure that SKIP is possible (todo)                  uint32_t sadC = sad8(current->u + x*8 + y*stride*8,
957          how: if skip is not possible set sad00 to a very high value */                                                  reference->u + x*8 + y*stride*8, stride);
   
         uint32_t sadC = sad8(current->u + x*8 + y*(iEdgedWidth/2)*8,  
                                         reference->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2);  
958          if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;          if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
959          sadC += sad8(current->v + x*8 + y*(iEdgedWidth/2)*8,                  sadC += sad8(current->v + (x + y*stride)*8,
960                                          reference->v + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2);                                                  reference->v + (x + y*stride)*8, stride);
961          if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;          if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
962                    return 1;
963    
964            } else {
965                    uint32_t sadC = sad16(current->u + x*16 + y*stride*16,
966                                                    reference->u + x*16 + y*stride*16, stride, 256*4096);
967                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
968                    sadC += sad16(current->v + (x + y*stride)*16,
969                                                    reference->v + (x + y*stride)*16, stride, 256*4096);
970                    if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
971          return 1;          return 1;
972  }  }
973    }
974    
975  static __inline void  static __inline void
976  SkipMacroblockP(MACROBLOCK *pMB, const int32_t sad)  SkipMacroblockP(MACROBLOCK *pMB, const int32_t sad)
977  {  {
978          pMB->mode = MODE_NOT_CODED;          pMB->mode = MODE_NOT_CODED;
979          pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = 0;          pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = zeroMV;
980          pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = 0;          pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = zeroMV;
981          pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;          pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
982  }  }
983    
# Line 546  Line 994 
994          const IMAGE *const pCurrent = &current->image;          const IMAGE *const pCurrent = &current->image;
995          const IMAGE *const pRef = &reference->image;          const IMAGE *const pRef = &reference->image;
996    
997          const VECTOR zeroMV = { 0, 0 };          uint32_t mb_width = pParam->mb_width;
998            uint32_t mb_height = pParam->mb_height;
999            const uint32_t iEdgedWidth = pParam->edged_width;
1000            const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags);
1001    
1002          uint32_t x, y;          uint32_t x, y;
1003          uint32_t iIntra = 0;          uint32_t iIntra = 0;
1004          int32_t InterBias;          int32_t quant = current->quant, sad00;
1005            int skip_thresh = \
1006                    INITIAL_SKIP_THRESH * \
1007                    (current->vop_flags & XVID_VOP_REDUCED ? 4:1) * \
1008                    (current->vop_flags & XVID_VOP_MODEDECISION_BITS ? 2:1);
1009    
1010          // some pre-initialized thingies for SearchP          // some pre-initialized thingies for SearchP
1011          int32_t temp[5];          int32_t temp[8];
1012          VECTOR currentMV[5];          VECTOR currentMV[5];
1013            VECTOR currentQMV[5];
1014          int32_t iMinSAD[5];          int32_t iMinSAD[5];
1015          SearchData Data;          SearchData Data;
1016          Data.iEdgedWidth = pParam->edged_width;          memset(&Data, 0, sizeof(SearchData));
1017            Data.iEdgedWidth = iEdgedWidth;
1018          Data.currentMV = currentMV;          Data.currentMV = currentMV;
1019            Data.currentQMV = currentQMV;
1020          Data.iMinSAD = iMinSAD;          Data.iMinSAD = iMinSAD;
1021          Data.temp = temp;          Data.temp = temp;
1022          Data.iFcode = current->fcode;          Data.iFcode = current->fcode;
1023            Data.rounding = pParam->m_rounding_type;
1024            Data.qpel = current->vol_flags & XVID_VOL_QUARTERPEL;
1025            Data.chroma = MotionFlags & XVID_ME_CHROMA16;
1026            Data.rrv = current->vop_flags & XVID_VOP_REDUCED;
1027    
1028            if ((current->vop_flags & XVID_VOP_REDUCED)) {
1029                    mb_width = (pParam->width + 31) / 32;
1030                    mb_height = (pParam->height + 31) / 32;
1031                    Data.qpel = 0;
1032            }
1033    
1034            Data.RefQ = pRefV->u; // a good place, also used in MC (for similar purpose)
1035          if (sadInit) (*sadInit) ();          if (sadInit) (*sadInit) ();
1036    
1037          for (y = 0; y < pParam->mb_height; y++) {          for (y = 0; y < mb_height; y++) {
1038                  for (x = 0; x < pParam->mb_width; x++)  {                  for (x = 0; x < mb_width; x++)  {
   
1039                          MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];                          MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];
1040                          int32_t sad00 =  pMB->sad16  
1041                                  = sad16v(pCurrent->y + (x + y * pParam->edged_width) * 16,                          if (!Data.rrv) pMB->sad16 =
1042                                                          pRef->y + (x + y * pParam->edged_width) * 16,                                  sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,
1043                                                            pRef->y + (x + y * iEdgedWidth) * 16,
1044                                                          pParam->edged_width, pMB->sad8 );                                                          pParam->edged_width, pMB->sad8 );
1045    
1046                          if (!(current->global_flags & XVID_LUMIMASKING)) {                          else pMB->sad16 =
1047                                  pMB->dquant = NO_CHANGE;                                  sad32v_c(pCurrent->y + (x + y * iEdgedWidth) * 32,
1048                                  pMB->quant = current->quant; }                                                          pRef->y + (x + y * iEdgedWidth) * 32,
1049                                                            pParam->edged_width, pMB->sad8 );
1050    
1051  //initial skip decision                          if (Data.chroma) {
1052                                    Data.temp[7] = sad8(pCurrent->u + x*8 + y*(iEdgedWidth/2)*8,
1053                                                                            pRef->u + x*8 + y*(iEdgedWidth/2)*8, iEdgedWidth/2)
1054                                                                    + sad8(pCurrent->v + (x + y*(iEdgedWidth/2))*8,
1055                                                                            pRef->v + (x + y*(iEdgedWidth/2))*8, iEdgedWidth/2);
1056                                    pMB->sad16 += Data.temp[7];
1057                            }
1058    
1059                          if ((pMB->dquant == NO_CHANGE) && (sad00 <= MAX_SAD00_FOR_SKIP * pMB->quant)                          sad00 = pMB->sad16;
1060                                  && (SkipDecisionP(pCurrent, pRef, x, y, pParam->edged_width, pMB->quant)) ) {  
1061                                  if (pMB->sad16 < pMB->quant * INITIAL_SKIP_THRESH) {                          if (pMB->dquant != 0) {
1062                                    quant += DQtab[pMB->dquant];
1063                                    if (quant > 31) quant = 31;
1064                                    else if (quant < 1) quant = 1;
1065                            }
1066    
1067                            pMB->quant = current->quant;
1068    
1069    //initial skip decision
1070    /* no early skip for GMC (global vector = skip vector is unknown!)  */
1071                            if (!(current->vol_flags & XVID_VOL_GMC))       { /* no fast SKIP for S(GMC)-VOPs */
1072                                    if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh)
1073                                            if (Data.chroma || SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv)) {
1074                                                  SkipMacroblockP(pMB, sad00);                                                  SkipMacroblockP(pMB, sad00);
1075                                                  continue;                                                  continue;
1076                                  }                                  }
1077                          } else sad00 = 256*4096; // skip not allowed - for final skip decision                          }
1078    
1079                          SearchP(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,                          SearchP(pRef, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,
1080                                                  y, current->motion_flags, pMB->quant,                                                  y, MotionFlags, current->vol_flags, pMB->quant,
1081                                                  &Data, pParam, pMBs, reference->mbs,                                                  &Data, pParam, pMBs, reference->mbs,
1082                                                  current->global_flags & XVID_INTER4V, pMB);                                                  current->vop_flags & XVID_VOP_INTER4V, pMB);
1083    
1084  /* final skip decision, a.k.a. "the vector you found, really that good?" */  /* final skip decision, a.k.a. "the vector you found, really that good?" */
1085                          if (sad00 < pMB->quant * MAX_SAD00_FOR_SKIP)                          if (!(current->vol_flags & XVID_VOL_GMC || current->vop_flags & XVID_VOP_MODEDECISION_BITS)) {
1086                                  if ((100*pMB->sad16)/(sad00+1) > FINAL_SKIP_THRESH)                                  if ( pMB->dquant == 0 && sad00 < pMB->quant * MAX_SAD00_FOR_SKIP) {
1087                                  { SkipMacroblockP(pMB, sad00); continue; }                                          if ( (100*pMB->sad16)/(sad00+1) > FINAL_SKIP_THRESH * (Data.rrv ? 4:1) )
1088                                                    if (Data.chroma || SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv))
1089  /* finally, intra decision */                                                          SkipMacroblockP(pMB, sad00);
   
                         InterBias = MV16_INTER_BIAS;  
                         if (pMB->quant > 8)  InterBias += 50 * (pMB->quant - 8); // to make high quants work  
                         if (y != 0)  
                                 if ((pMB - pParam->mb_width)->mode == MODE_INTER ) InterBias -= 50;  
                         if (x != 0)  
                                 if ((pMB - 1)->mode == MODE_INTER ) InterBias -= 50;  
   
                         if (InterBias < pMB->sad16)  {  
                                 const int32_t deviation =  
                                         dev16(pCurrent->y + (x + y * pParam->edged_width) * 16,  
                                                   pParam->edged_width);  
   
                                 if (deviation < (pMB->sad16 - InterBias)) {  
                                         if (++iIntra >= iLimit) return 1;  
                                         pMB->mode = MODE_INTRA;  
                                         pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] =  
                                                         pMB->mvs[3] = zeroMV;  
                                         pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] =  
                                                 pMB->sad8[3] = 0;  
1090                                  }                                  }
1091                          }                          }
1092                            if (pMB->mode == MODE_INTRA)
1093                                    if (++iIntra > iLimit) return 1;
1094                  }                  }
1095          }          }
1096    
1097            if (current->vol_flags & XVID_VOL_GMC ) /* GMC only for S(GMC)-VOPs */
1098            {
1099                    current->warp = GlobalMotionEst( pMBs, pParam, current, reference, pRefH, pRefV, pRefHV);
1100            }
1101          return 0;          return 0;
1102  }  }
1103    
1104    
 #define PMV_HALFPEL16 (PMV_HALFPELDIAMOND16|PMV_HALFPELREFINE16)  
   
1105  static __inline int  static __inline int
1106  make_mask(const VECTOR * const pmv, const int i)  make_mask(const VECTOR * const pmv, const int i)
1107  {  {
# Line 636  Line 1109 
1109          for (j = 0; j < i; j++) {          for (j = 0; j < i; j++) {
1110                  if (MVequal(pmv[i], pmv[j])) return 0; // same vector has been checked already                  if (MVequal(pmv[i], pmv[j])) return 0; // same vector has been checked already
1111                  if (pmv[i].x == pmv[j].x) {                  if (pmv[i].x == pmv[j].x) {
1112                          if (pmv[i].y == pmv[j].y + iDiamondSize) { mask &= ~4; continue; }                          if (pmv[i].y == pmv[j].y + iDiamondSize) mask &= ~4;
1113                          if (pmv[i].y == pmv[j].y - iDiamondSize) { mask &= ~8; continue; }                          else if (pmv[i].y == pmv[j].y - iDiamondSize) mask &= ~8;
1114                  } else                  } else
1115                          if (pmv[i].y == pmv[j].y) {                          if (pmv[i].y == pmv[j].y) {
1116                                  if (pmv[i].x == pmv[j].x + iDiamondSize) { mask &= ~1; continue; }                                  if (pmv[i].x == pmv[j].x + iDiamondSize) mask &= ~1;
1117                                  if (pmv[i].x == pmv[j].x - iDiamondSize) { mask &= ~2; continue; }                                  else if (pmv[i].x == pmv[j].x - iDiamondSize) mask &= ~2;
1118                          }                          }
1119          }          }
1120          return mask;          return mask;
1121  }  }
1122    
1123  static __inline void  static __inline void
1124  PreparePredictionsP(VECTOR * const pmv, int x, int y, const int iWcount,  PreparePredictionsP(VECTOR * const pmv, int x, int y, int iWcount,
1125                          const int iHcount, const MACROBLOCK * const prevMB)                          int iHcount, const MACROBLOCK * const prevMB, int rrv)
1126  {  {
1127    
1128  //this function depends on get_pmvdata which means that it sucks. It should get the predictions by itself  //this function depends on get_pmvdata which means that it sucks. It should get the predictions by itself
1129            if (rrv) { iWcount /= 2; iHcount /= 2; }
1130    
1131          if ( (y != 0) && (x != (iWcount-1)) ) {         // [5] top-right neighbour          if ( (y != 0) && (x < (iWcount-1)) ) {          // [5] top-right neighbour
1132                  pmv[5].x = EVEN(pmv[3].x);                  pmv[5].x = EVEN(pmv[3].x);
1133                  pmv[5].y = EVEN(pmv[3].y);                  pmv[5].y = EVEN(pmv[3].y);
1134          } else pmv[5].x = pmv[5].y = 0;          } else pmv[5].x = pmv[5].y = 0;
# Line 673  Line 1147 
1147          pmv[2].x = EVEN(prevMB->mvs[0].x); // [2] is last frame          pmv[2].x = EVEN(prevMB->mvs[0].x); // [2] is last frame
1148          pmv[2].y = EVEN(prevMB->mvs[0].y);          pmv[2].y = EVEN(prevMB->mvs[0].y);
1149    
1150          if ((x != iWcount-1) && (y != iHcount-1)) {          if ((x < iWcount-1) && (y < iHcount-1)) {
1151                  pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); //[6] right-down neighbour in last frame                  pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); //[6] right-down neighbour in last frame
1152                  pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y);                  pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y);
1153          } else pmv[6].x = pmv[6].y = 0;          } else pmv[6].x = pmv[6].y = 0;
1154    
1155            if (rrv) {
1156                    int i;
1157                    for (i = 0; i < 7; i++) {
1158                            pmv[i].x = RRV_MV_SCALEUP(pmv[i].x);
1159                            pmv[i].y = RRV_MV_SCALEUP(pmv[i].y);
1160                    }
1161            }
1162  }  }
1163    
1164  static void  static int
1165  SearchP(const uint8_t * const pRef,  ModeDecision(const uint32_t iQuant, SearchData * const Data,
                 const uint8_t * const pRefH,  
                 const uint8_t * const pRefV,  
                 const uint8_t * const pRefHV,  
                 const IMAGE * const pCur,  
                 const int x,  
                 const int y,  
                 const uint32_t MotionFlags,  
                 const uint32_t iQuant,  
                 SearchData * const Data,  
                 const MBParam * const pParam,  
                 const MACROBLOCK * const pMBs,  
                 const MACROBLOCK * const prevMBs,  
1166                  int inter4v,                  int inter4v,
1167                  MACROBLOCK * const pMB)                  MACROBLOCK * const pMB,
1168                    const MACROBLOCK * const pMBs,
1169                    const int x, const int y,
1170                    const MBParam * const pParam,
1171                    const uint32_t MotionFlags,
1172                    const uint32_t VopFlags)
1173  {  {
1174    
1175          int i, iDirection = 255, mask, threshA;          int mode = MODE_INTER;
         VECTOR pmv[7];  
1176    
1177          get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp);  //has to be changed to get_pmv(2)()          if (!(VopFlags & XVID_VOP_MODEDECISION_BITS)) { //normal, fast, SAD-based mode decision
1178          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,  //              int intra = 0;
1179                                  pParam->width, pParam->height, Data->iFcode);                  int sad;
1180                    int InterBias = MV16_INTER_BIAS;
1181                    if (inter4v == 0 || Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +
1182                            Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant) {
1183                                    mode = 0; //inter
1184                                    sad = Data->iMinSAD[0];
1185                    } else {
1186                            mode = MODE_INTER4V;
1187                            sad = Data->iMinSAD[1] + Data->iMinSAD[2] +
1188                                                    Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant;
1189                            Data->iMinSAD[0] = sad;
1190                    }
1191    
1192          Data->predMV = pmv[0];                  /* intra decision */
         Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16;  
         Data->Ref = pRef + (x + Data->iEdgedWidth*y)*16;  
         Data->RefH = pRefH + (x + Data->iEdgedWidth*y) * 16;  
         Data->RefV = pRefV + (x + Data->iEdgedWidth*y) * 16;  
         Data->RefHV = pRefHV + (x + Data->iEdgedWidth*y) * 16;  
   
         Data->iQuant = iQuant;  
   
         if (!(MotionFlags & PMV_HALFPEL16)) {  
                 Data->min_dx = EVEN(Data->min_dx);  
                 Data->max_dx = EVEN(Data->max_dx);  
                 Data->min_dy = EVEN(Data->min_dy);  
                 Data->max_dy = EVEN(Data->max_dy); }  
1193    
1194          for(i = 0;  i < 5; i++) Data->iMinSAD[i] = 256*4096;                  if (iQuant > 8) InterBias += 100 * (iQuant - 8); // to make high quants work
1195                    if (y != 0)
1196                            if ((pMB - pParam->mb_width)->mode == MODE_INTRA ) InterBias -= 80;
1197                    if (x != 0)
1198                            if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80;
1199    
1200          if (inter4v) CheckCandidate = CheckCandidate16;                  if (Data->chroma) InterBias += 50; // to compensate bigger SAD
1201          else CheckCandidate = CheckCandidate16no4v;                  if (Data->rrv) InterBias *= 4;
1202    
1203          (*CheckCandidate)(Data->predMV.x, Data->predMV.y, 0, &iDirection, Data);                  if (InterBias < pMB->sad16) {
1204                            int32_t deviation;
1205                            if (!Data->rrv) deviation = dev16(Data->Cur, Data->iEdgedWidth);
1206                            else deviation = dev16(Data->Cur, Data->iEdgedWidth) +
1207                                    dev16(Data->Cur+8, Data->iEdgedWidth) +
1208                                    dev16(Data->Cur + 8*Data->iEdgedWidth, Data->iEdgedWidth) +
1209                                    dev16(Data->Cur+8+8*Data->iEdgedWidth, Data->iEdgedWidth);
1210    
1211          for(i = 0;  i < 5; i++) Data->currentMV[i].x = Data->currentMV[i].y = 0;                          if (deviation < (sad - InterBias))  return MODE_INTRA;// intra
1212                    }
1213                    return mode;
1214    
1215          i = d_mv_bits(Data->predMV.x, Data->predMV.y, Data->iFcode);          } else {
         Data->iMinSAD[0] = pMB->sad16 + lambda_vec16[iQuant] * i;  
         Data->iMinSAD[1] = pMB->sad8[0] + lambda_vec8[iQuant] * i;  
         Data->iMinSAD[2] = pMB->sad8[1];  
         Data->iMinSAD[3] = pMB->sad8[2];  
         Data->iMinSAD[4] = pMB->sad8[3];  
1216    
1217          if (pMB->dquant != NO_CHANGE) inter4v = 0;                  int bits, intra, i;
1218                    VECTOR backup[5], *v;
1219                    Data->lambda16 = iQuant;
1220            Data->lambda8 = (pParam->vol_flags & XVID_VOL_MPEGQUANT)?1:0;
1221    
1222                    v = Data->qpel ? Data->currentQMV : Data->currentMV;
1223                    for (i = 0; i < 5; i++) {
1224                            Data->iMinSAD[i] = 256*4096;
1225                            backup[i] = v[i];
1226                    }
1227    
1228          if ((x == 0) && (y == 0)) threshA = 512;                  bits = CountMBBitsInter(Data, pMBs, x, y, pParam, MotionFlags);
1229          else {                  if (bits == 0) return MODE_INTER; // quick stop
1230                  threshA = Data->temp[0] + 20;  
1231                    if (inter4v) {
1232                            int inter4v = CountMBBitsInter4v(Data, pMB, pMBs, x, y, pParam, MotionFlags, backup);
1233                            if (inter4v < bits) { Data->iMinSAD[0] = bits = inter4v; mode = MODE_INTER4V; }
1234                    }
1235    
1236    
1237                    intra = CountMBBitsIntra(Data);
1238    
1239                    if (intra < bits) { *Data->iMinSAD = bits = intra; return MODE_INTRA; }
1240    
1241                    return mode;
1242            }
1243    }
1244    
1245    static void
1246    SearchP(const IMAGE * const pRef,
1247                    const uint8_t * const pRefH,
1248                    const uint8_t * const pRefV,
1249                    const uint8_t * const pRefHV,
1250                    const IMAGE * const pCur,
1251                    const int x,
1252                    const int y,
1253                    const uint32_t MotionFlags,
1254                    const uint32_t VopFlags,
1255                    const uint32_t iQuant,
1256                    SearchData * const Data,
1257                    const MBParam * const pParam,
1258                    const MACROBLOCK * const pMBs,
1259                    const MACROBLOCK * const prevMBs,
1260                    int inter4v,
1261                    MACROBLOCK * const pMB)
1262    {
1263    
1264            int i, iDirection = 255, mask, threshA;
1265            VECTOR pmv[7];
1266    
1267            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1268                                                    pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
1269    
1270            get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, 0, pmv, Data->temp);
1271    
1272            Data->temp[5] = Data->temp[6] = 0; // chroma-sad cache
1273            i = Data->rrv ? 2 : 1;
1274            Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;
1275            Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1276            Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1277    
1278            Data->Ref = pRef->y + (x + Data->iEdgedWidth*y) * 16*i;
1279            Data->RefH = pRefH + (x + Data->iEdgedWidth*y) * 16*i;
1280            Data->RefV = pRefV + (x + Data->iEdgedWidth*y) * 16*i;
1281            Data->RefHV = pRefHV + (x + Data->iEdgedWidth*y) * 16*i;
1282            Data->RefCV = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1283            Data->RefCU = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
1284    
1285            Data->lambda16 = lambda_vec16[iQuant];
1286            Data->lambda8 = lambda_vec8[iQuant];
1287            Data->qpel_precision = 0;
1288    
1289            if (pMB->dquant != 0) inter4v = 0;
1290    
1291            for(i = 0; i < 5; i++)
1292                    Data->currentMV[i].x = Data->currentMV[i].y = 0;
1293    
1294            if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0);
1295            else Data->predMV = pmv[0];
1296    
1297            i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0, 0);
1298            Data->iMinSAD[0] = pMB->sad16 + ((Data->lambda16 * i * pMB->sad16)>>10);
1299            Data->iMinSAD[1] = pMB->sad8[0] + ((Data->lambda8 * i * (pMB->sad8[0]+NEIGH_8X8_BIAS)) >> 10);
1300            Data->iMinSAD[2] = pMB->sad8[1];
1301            Data->iMinSAD[3] = pMB->sad8[2];
1302            Data->iMinSAD[4] = pMB->sad8[3];
1303    
1304            if ((!(VopFlags & XVID_VOP_MODEDECISION_BITS)) || (x | y)) {
1305                    threshA = Data->temp[0]; // that's where we keep this SAD atm
1306                  if (threshA < 512) threshA = 512;                  if (threshA < 512) threshA = 512;
1307                  if (threshA > 1024) threshA = 1024; }                  else if (threshA > 1024) threshA = 1024;
1308            } else
1309                    threshA = 512;
1310    
1311          PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height,          PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height,
1312                                          prevMBs + x + y * pParam->mb_width);                                          prevMBs + x + y * pParam->mb_width, Data->rrv);
1313    
1314            if (!Data->rrv) {
1315                    if (inter4v | Data->chroma) CheckCandidate = CheckCandidate16;
1316                            else CheckCandidate = CheckCandidate16no4v; //for extra speed
1317            } else CheckCandidate = CheckCandidate32;
1318    
1319  /* main loop. checking all predictions */  /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/
1320    
1321          for (i = 1; i < 7; i++) {          for (i = 1; i < 7; i++) {
1322                  if (!(mask = make_mask(pmv, i)) ) continue;                  if (!(mask = make_mask(pmv, i)) ) continue;
1323                  CheckCandidate16(pmv[i].x, pmv[i].y, mask, &iDirection, Data);                  CheckCandidate(pmv[i].x, pmv[i].y, mask, &iDirection, Data);
1324                  if (Data->iMinSAD[0] <= threshA) break;                  if (Data->iMinSAD[0] <= threshA) break;
1325          }          }
1326    
1327          if ((Data->iMinSAD[0] <= threshA) ||          if ((Data->iMinSAD[0] <= threshA) ||
1328                          (MVequal(Data->currentMV[0], (prevMBs+x+y*pParam->mb_width)->mvs[0]) &&                          (MVequal(Data->currentMV[0], (prevMBs+x+y*pParam->mb_width)->mvs[0]) &&
1329                          (Data->iMinSAD[0] < (prevMBs+x+y*pParam->mb_width)->sad16))) {                          (Data->iMinSAD[0] < (prevMBs+x+y*pParam->mb_width)->sad16))) {
1330                  inter4v = 0;                  if (!(VopFlags & XVID_VOP_MODEDECISION_BITS)) inter4v = 0;      }
1331          } else {          else {
1332    
1333                  MainSearchFunc * MainSearchPtr;                  MainSearchFunc * MainSearchPtr;
1334                  if (MotionFlags & PMV_USESQUARES16) MainSearchPtr = SquareSearch;                  if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1335                  else if (MotionFlags & PMV_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1336                          else MainSearchPtr = DiamondSearch;                          else MainSearchPtr = DiamondSearch;
1337    
1338                  (*MainSearchPtr)(Data->currentMV->x, Data->currentMV->y, Data, iDirection);                  MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
1339    
1340  /* extended search, diamond starting in 0,0 and in prediction.  /* extended search, diamond starting in 0,0 and in prediction.
1341          note that this search is/might be done in halfpel positions,          note that this search is/might be done in halfpel positions,
1342          which makes it more different than the diamond above */          which makes it more different than the diamond above */
1343    
1344                  if (MotionFlags & PMV_EXTSEARCH16) {                  if (MotionFlags & XVID_ME_EXTSEARCH16) {
1345                          int32_t bSAD;                          int32_t bSAD;
1346                          VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0];                          VECTOR startMV = Data->predMV, backupMV = Data->currentMV[0];
1347                          if (!(MotionFlags & PMV_HALFPELREFINE16)) // who's gonna use extsearch and no halfpel?                          if (Data->rrv) {
1348                                  startMV.x = EVEN(startMV.x); startMV.y = EVEN(startMV.y);                                  startMV.x = RRV_MV_SCALEUP(startMV.x);
1349                                    startMV.y = RRV_MV_SCALEUP(startMV.y);
1350                            }
1351                          if (!(MVequal(startMV, backupMV))) {                          if (!(MVequal(startMV, backupMV))) {
1352                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1353    
1354                                  CheckCandidate16(startMV.x, startMV.y, 255, &iDirection, Data);                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1355                                  (*MainSearchPtr)(startMV.x, startMV.y, Data, 255);                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);
1356                                  if (bSAD < Data->iMinSAD[0]) {                                  if (bSAD < Data->iMinSAD[0]) {
1357                                          Data->currentMV[0] = backupMV;                                          Data->currentMV[0] = backupMV;
1358                                          Data->iMinSAD[0] = bSAD; }                                          Data->iMinSAD[0] = bSAD; }
1359                          }                          }
1360    
1361                          backupMV = Data->currentMV[0];                          backupMV = Data->currentMV[0];
1362                          if (MotionFlags & PMV_HALFPELREFINE16) startMV.x = startMV.y = 1;                          startMV.x = startMV.y = 1;
                         else startMV.x = startMV.y = 0;  
1363                          if (!(MVequal(startMV, backupMV))) {                          if (!(MVequal(startMV, backupMV))) {
1364                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;                                  bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
1365    
1366                                  CheckCandidate16(startMV.x, startMV.y, 255, &iDirection, Data);                                  CheckCandidate(startMV.x, startMV.y, 255, &iDirection, Data);
1367                                  (*MainSearchPtr)(startMV.x, startMV.y, Data, 255);                                  MainSearchPtr(startMV.x, startMV.y, Data, 255);
1368                                  if (bSAD < Data->iMinSAD[0]) {                                  if (bSAD < Data->iMinSAD[0]) {
1369                                          Data->currentMV[0] = backupMV;                                          Data->currentMV[0] = backupMV;
1370                                          Data->iMinSAD[0] = bSAD; }                                          Data->iMinSAD[0] = bSAD; }
# Line 801  Line 1372 
1372                  }                  }
1373          }          }
1374    
1375          if (MotionFlags & PMV_HALFPELREFINE16) HalfpelRefine(Data);          if (MotionFlags & XVID_ME_HALFPELREFINE16)
1376                    if ((!(MotionFlags & XVID_ME_HALFPELREFINE16_BITS)) || Data->iMinSAD[0] < 200*(int)iQuant)
1377                            SubpelRefine(Data);
1378    
1379            for(i = 0; i < 5; i++) {
1380                    Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // initialize qpel vectors
1381                    Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
1382            }
1383    
1384            if (MotionFlags & XVID_ME_QUARTERPELREFINE16) {
1385    
1386                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1387                                    pParam->width, pParam->height, Data->iFcode, 1, 0);
1388    
1389                    if ((!(MotionFlags & XVID_ME_QUARTERPELREFINE16_BITS)) || (Data->iMinSAD[0] < 200*(int)iQuant)) {
1390                            Data->qpel_precision = 1;
1391                            SubpelRefine(Data);
1392                    }
1393            }
1394    
1395            if ((!(VopFlags & XVID_VOP_MODEDECISION_BITS)) && (Data->iMinSAD[0] < (int32_t)iQuant * 30)) inter4v = 0;
1396    
1397            if (inter4v && (!(VopFlags & XVID_VOP_MODEDECISION_BITS) ||
1398                            (!(MotionFlags & XVID_ME_QUARTERPELREFINE8_BITS)) || (!(MotionFlags & XVID_ME_HALFPELREFINE8_BITS)) ||
1399                            ((!(MotionFlags & XVID_ME_EXTSEARCH_BITS)) && (!(MotionFlags&XVID_ME_EXTSEARCH8)) ))) {
1400                    // if decision is BITS-based and all refinement steps will be done in BITS domain, there is no reason to call this loop
1401    
         if (inter4v) {  
1402                  SearchData Data8;                  SearchData Data8;
1403                  Data8.iFcode = Data->iFcode;                  memcpy(&Data8, Data, sizeof(SearchData)); //quick copy of common data
1404                  Data8.iQuant = Data->iQuant;  
                 Data8.iEdgedWidth = Data->iEdgedWidth;  
1405                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8);                  Search8(Data, 2*x, 2*y, MotionFlags, pParam, pMB, pMBs, 0, &Data8);
1406                  Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8);                  Search8(Data, 2*x + 1, 2*y, MotionFlags, pParam, pMB, pMBs, 1, &Data8);
1407                  Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8);                  Search8(Data, 2*x, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 2, &Data8);
1408                  Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);                  Search8(Data, 2*x + 1, 2*y + 1, MotionFlags, pParam, pMB, pMBs, 3, &Data8);
1409    
1410                    if ((Data->chroma) && (!(VopFlags & XVID_VOP_MODEDECISION_BITS))) {
1411                            // chroma is only used for comparsion to INTER. if the comparsion will be done in BITS domain, there is no reason to compute it
1412                            int sumx = 0, sumy = 0;
1413                            const int div = 1 + Data->qpel;
1414                            const VECTOR * const mv = Data->qpel ? pMB->qmvs : pMB->mvs;
1415    
1416                            for (i = 0; i < 4; i++) {
1417                                    sumx += mv[i].x / div;
1418                                    sumy += mv[i].y / div;
1419          }          }
1420    
1421          if (!(inter4v) ||                          Data->iMinSAD[1] += ChromaSAD(  (sumx >> 3) + roundtab_76[sumx & 0xf],
1422                  (Data->iMinSAD[0] < Data->iMinSAD[1] + Data->iMinSAD[2] +                                                                                          (sumy >> 3) + roundtab_76[sumy & 0xf], Data);
1423                          Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * (int32_t)iQuant )) {                  }
1424  // INTER MODE          }
1425                  pMB->mode = MODE_INTER;  
1426                  pMB->mvs[0] = pMB->mvs[1]          inter4v = ModeDecision(iQuant, Data, inter4v, pMB, pMBs, x, y, pParam, MotionFlags, VopFlags);
                         = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];  
1427    
1428                  pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] =          if (Data->rrv) {
1429                          pMB->sad8[2] = pMB->sad8[3] =  Data->iMinSAD[0];                          Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
1430                            Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
1431            }
1432    
1433            if (inter4v == MODE_INTER) {
1434                    pMB->mode = MODE_INTER;
1435                    pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
1436                    pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = Data->iMinSAD[0];
1437    
1438                    if(Data->qpel) {
1439                            pMB->qmvs[0] = pMB->qmvs[1]
1440                                    = pMB->qmvs[2] = pMB->qmvs[3] = Data->currentQMV[0];
1441                            pMB->pmvs[0].x = Data->currentQMV[0].x - Data->predMV.x;
1442                            pMB->pmvs[0].y = Data->currentQMV[0].y - Data->predMV.y;
1443                    } else {
1444                  pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x;                  pMB->pmvs[0].x = Data->currentMV[0].x - Data->predMV.x;
1445                  pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;                  pMB->pmvs[0].y = Data->currentMV[0].y - Data->predMV.y;
1446          } else {                  }
1447  // INTER4V MODE; all other things are already set in Search8  
1448            } else if (inter4v == MODE_INTER4V) {
1449                  pMB->mode = MODE_INTER4V;                  pMB->mode = MODE_INTER4V;
1450                  pMB->sad16 = Data->iMinSAD[1] + Data->iMinSAD[2] +                  pMB->sad16 = Data->iMinSAD[0];
1451                          Data->iMinSAD[3] + Data->iMinSAD[4] + IMV16X16 * iQuant;          } else { // INTRA mode
1452                    SkipMacroblockP(pMB, 0); // not skip, but similar enough
1453                    pMB->mode = MODE_INTRA;
1454          }          }
1455    
1456  }  }
# Line 846  Line 1465 
1465                  const int block,                  const int block,
1466                  SearchData * const Data)                  SearchData * const Data)
1467  {  {
1468          Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2 , y/2, block);          int i = 0;
1469          Data->iMinSAD = OldData->iMinSAD + 1 + block;          Data->iMinSAD = OldData->iMinSAD + 1 + block;
1470          Data->currentMV = OldData->currentMV + 1 + block;          Data->currentMV = OldData->currentMV + 1 + block;
1471            Data->currentQMV = OldData->currentQMV + 1 + block;
1472    
1473            if(Data->qpel) {
1474                    Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1475                    if (block != 0) i = d_mv_bits(  Data->currentQMV->x, Data->currentQMV->y,
1476                                                                                    Data->predMV, Data->iFcode, 0, 0);
1477            } else {
1478                    Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
1479                    if (block != 0) i = d_mv_bits(  Data->currentMV->x, Data->currentMV->y,
1480                                                                                    Data->predMV, Data->iFcode, 0, Data->rrv);
1481            }
1482    
1483            *(Data->iMinSAD) += (Data->lambda8 * i * (*Data->iMinSAD + NEIGH_8X8_BIAS))>>10;
1484    
1485          if (block != 0)          if (MotionFlags & (XVID_ME_EXTSEARCH8|XVID_ME_HALFPELREFINE8|XVID_ME_QUARTERPELREFINE8)) {
1486                  *(Data->iMinSAD) += lambda_vec8[Data->iQuant] *                  if (Data->rrv) i = 2; else i = 1;
                                                                 d_mv_bits(      Data->currentMV->x - Data->predMV.x,  
                                                                                         Data->currentMV->y - Data->predMV.y,  
                                                                                         Data->iFcode);  
   
         if (MotionFlags & (PMV_EXTSEARCH8|PMV_HALFPELREFINE8)) {  
   
                 Data->Ref = OldData->Ref + 8 * ((block&1) + pParam->edged_width*(block>>1));  
                 Data->RefH = OldData->RefH + 8 * ((block&1) + pParam->edged_width*(block>>1));  
                 Data->RefV = OldData->RefV + 8 * ((block&1) + pParam->edged_width*(block>>1));  
                 Data->RefHV = OldData->RefHV + 8 * ((block&1) + pParam->edged_width*(block>>1));  
1487    
1488                  Data->Cur = OldData->Cur + 8 * ((block&1) + pParam->edged_width*(block>>1));                  Data->Ref = OldData->Ref + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1489                    Data->RefH = OldData->RefH + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1490                    Data->RefV = OldData->RefV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1491                    Data->RefHV = OldData->RefHV + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1492    
1493                    Data->Cur = OldData->Cur + i * 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
1494                    Data->qpel_precision = 0;
1495    
1496                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,                  get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1497                                  pParam->width, pParam->height, OldData->iFcode);                                          pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
1498    
1499                  CheckCandidate = CheckCandidate8;                  if (!Data->rrv) CheckCandidate = CheckCandidate8;
1500                    else CheckCandidate = CheckCandidate16no4v;
1501    
1502                  if (MotionFlags & PMV_EXTSEARCH8) {                  if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_BITS))) {
1503                            int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
1504    
1505                          MainSearchFunc *MainSearchPtr;                          MainSearchFunc *MainSearchPtr;
1506                          if (MotionFlags & PMV_USESQUARES8) MainSearchPtr = SquareSearch;                          if (MotionFlags & XVID_ME_USESQUARES8) MainSearchPtr = SquareSearch;
1507                                  else if (MotionFlags & PMV_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;                                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;
1508                                          else MainSearchPtr = DiamondSearch;                                          else MainSearchPtr = DiamondSearch;
1509    
1510                          (*MainSearchPtr)(Data->currentMV->x, Data->currentMV->y, Data, 255);    }                          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255);
1511    
1512                            if(*(Data->iMinSAD) < temp_sad) {
1513                                            Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1514                                            Data->currentQMV->y = 2 * Data->currentMV->y;
1515                            }
1516                    }
1517    
1518                    if (MotionFlags & XVID_ME_HALFPELREFINE8) {
1519                            int32_t temp_sad = *(Data->iMinSAD); // store current MinSAD
1520    
1521                            SubpelRefine(Data); // perform halfpel refine of current best vector
1522    
1523                  if (MotionFlags & PMV_HALFPELREFINE8) HalfpelRefine(Data);                          if(*(Data->iMinSAD) < temp_sad) { // we have found a better match
1524                                    Data->currentQMV->x = 2 * Data->currentMV->x; // update our qpel vector
1525                                    Data->currentQMV->y = 2 * Data->currentMV->y;
1526                            }
1527          }          }
1528    
1529                    if (Data->qpel && MotionFlags & XVID_ME_QUARTERPELREFINE8) {
1530                                    Data->qpel_precision = 1;
1531                                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 8,
1532                                            pParam->width, pParam->height, Data->iFcode, 1, 0);
1533                                    SubpelRefine(Data);
1534                    }
1535            }
1536    
1537            if (Data->rrv) {
1538                            Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);
1539                            Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);
1540            }
1541    
1542            if(Data->qpel) {
1543                    pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x;
1544                    pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y;
1545                    pMB->qmvs[block] = *Data->currentQMV;
1546            } else {
1547          pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x;          pMB->pmvs[block].x = Data->currentMV->x - Data->predMV.x;
1548          pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;          pMB->pmvs[block].y = Data->currentMV->y - Data->predMV.y;
1549          pMB->mvs[block] = *(Data->currentMV);          }
         pMB->sad8[block] =  4 * (*Data->iMinSAD);  
1550    
1551            pMB->mvs[block] = *Data->currentMV;
1552            pMB->sad8[block] = 4 * *Data->iMinSAD;
1553  }  }
1554    
1555  /* B-frames code starts here */  /* motion estimation for B-frames */
1556    
1557  static __inline VECTOR  static __inline VECTOR
1558  ChoosePred(const MACROBLOCK * const pMB, const uint32_t mode)  ChoosePred(const MACROBLOCK * const pMB, const uint32_t mode)
1559  {  {
1560  /* the stupidiest function ever */  /* the stupidiest function ever */
1561          if (mode == MODE_FORWARD) return pMB->mvs[0];          return (mode == MODE_FORWARD ? pMB->mvs[0] : pMB->b_mvs[0]);
         else return pMB->b_mvs[0];  
1562  }  }
1563    
1564  static void __inline  static void __inline
# Line 929  Line 1591 
1591                  pmv[5].x = EVEN(pmv[5].x); pmv[5].y = EVEN(pmv[5].y);                  pmv[5].x = EVEN(pmv[5].x); pmv[5].y = EVEN(pmv[5].y);
1592          } else pmv[5].x = pmv[5].y = 0;          } else pmv[5].x = pmv[5].y = 0;
1593    
1594          if ((x != 0)&&(y != 0)) {          if (x != 0 && y != 0) {
1595                  pmv[6] = ChoosePred(pMB-1-iWcount, mode_curr);                  pmv[6] = ChoosePred(pMB-1-iWcount, mode_curr);
1596                  pmv[6].x = EVEN(pmv[5].x); pmv[5].y = EVEN(pmv[5].y);                  pmv[6].x = EVEN(pmv[6].x); pmv[6].y = EVEN(pmv[6].y);
1597          } else pmv[6].x = pmv[6].y = 0;          } else pmv[6].x = pmv[6].y = 0;
   
 // more?  
1598  }  }
1599    
1600    
1601  /* search backward or forward, for b-frames */  /* search backward or forward */
1602  static void  static void
1603  SearchBF(       const uint8_t * const pRef,  SearchBF(       const IMAGE * const pRef,
1604                          const uint8_t * const pRefH,                          const uint8_t * const pRefH,
1605                          const uint8_t * const pRefV,                          const uint8_t * const pRefV,
1606                          const uint8_t * const pRefHV,                          const uint8_t * const pRefHV,
1607                          const IMAGE * const pCur,                          const IMAGE * const pCur,
1608                          const int x, const int y,                          const int x, const int y,
1609                          const uint32_t MotionFlags,                          const uint32_t MotionFlags,
                         const uint32_t iQuant,  
1610                          const uint32_t iFcode,                          const uint32_t iFcode,
1611                          const MBParam * const pParam,                          const MBParam * const pParam,
1612                          MACROBLOCK * const pMB,                          MACROBLOCK * const pMB,
1613                          const VECTOR * const predMV,                          const VECTOR * const predMV,
1614                          int32_t * const best_sad,                          int32_t * const best_sad,
1615                          const int32_t mode_current)                          const int32_t mode_current,
1616                            SearchData * const Data)
1617  {  {
1618    
1619          const int32_t iEdgedWidth = pParam->edged_width;          int i, iDirection = 255, mask;
1620            VECTOR pmv[7];
         int i, iDirection, mask;  
         VECTOR currentMV, pmv[7];  
1621          MainSearchFunc *MainSearchPtr;          MainSearchFunc *MainSearchPtr;
1622          int32_t iMinSAD = MV_MAX_ERROR;          *Data->iMinSAD = MV_MAX_ERROR;
1623          SearchData Data;          Data->iFcode = iFcode;
1624            Data->qpel_precision = 0;
1625            Data->temp[5] = Data->temp[6] = Data->temp[7] = 256*4096; // reset chroma-sad cache
1626    
1627            Data->Ref = pRef->y + (x + y * Data->iEdgedWidth) * 16;
1628            Data->RefH = pRefH + (x + y * Data->iEdgedWidth) * 16;
1629            Data->RefV = pRefV + (x + y * Data->iEdgedWidth) * 16;
1630            Data->RefHV = pRefHV + (x + y * Data->iEdgedWidth) * 16;
1631            Data->RefCU = pRef->u + (x + y * Data->iEdgedWidth/2) * 8;
1632            Data->RefCV = pRef->v + (x + y * Data->iEdgedWidth/2) * 8;
1633    
1634          Data.iMinSAD = &iMinSAD;          Data->predMV = *predMV;
1635          Data.Cur = pCur->y + (x + y * iEdgedWidth) * 16;  
1636          Data.iEdgedWidth = iEdgedWidth;          get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1637          Data.currentMV = &currentMV;                                  pParam->width, pParam->height, iFcode - Data->qpel, 0, 0);
         Data.iMinSAD = &iMinSAD;  
         Data.Ref = pRef + (x + y * iEdgedWidth) * 16;  
         Data.RefH = pRefH + (x + y * iEdgedWidth) * 16;  
         Data.RefV = pRefV + (x + y * iEdgedWidth) * 16;  
         Data.RefHV = pRefHV + (x + y * iEdgedWidth) * 16;  
   
         Data.iQuant = iQuant;  
         Data.iFcode = iFcode;  
         Data.predMV = *predMV;  
   
         get_range(&Data.min_dx, &Data.max_dx, &Data.min_dy, &Data.max_dy, x, y, 16,  
                                 pParam->width, pParam->height, iFcode);  
   
         if (!(MotionFlags & PMV_HALFPEL16)) {  
                 Data.min_dx = EVEN(Data.min_dx);  
                 Data.max_dx = EVEN(Data.max_dx);  
                 Data.min_dy = EVEN(Data.min_dy);  
                 Data.max_dy = EVEN(Data.max_dy); } // no-halpel and b-frames. do we need it?  
   
   
         pmv[0] = Data.predMV;  
         PreparePredictionsBF(pmv, x, y, pParam->mb_width,  
                                         pMB, mode_current);  
1638    
1639          currentMV.x = currentMV.y = 0;          pmv[0] = Data->predMV;
1640            if (Data->qpel) { pmv[0].x /= 2; pmv[0].y /= 2; }
1641    
1642            PreparePredictionsBF(pmv, x, y, pParam->mb_width, pMB, mode_current);
1643    
1644            Data->currentMV->x = Data->currentMV->y = 0;
1645          CheckCandidate = CheckCandidate16no4v;          CheckCandidate = CheckCandidate16no4v;
1646    
1647  // main loop. checking all predictions  // main loop. checking all predictions
1648          for (i = 0; i < 8; i++) {          for (i = 0; i < 7; i++) {
1649                  if (!(mask = make_mask(pmv, i)) ) continue;                  if (!(mask = make_mask(pmv, i)) ) continue;
1650                  CheckCandidate16no4v(pmv[i].x, pmv[i].y, mask, &iDirection, &Data);                  CheckCandidate16no4v(pmv[i].x, pmv[i].y, mask, &iDirection, Data);
1651          }          }
1652    
1653          if (MotionFlags & PMV_USESQUARES16)          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1654                  MainSearchPtr = SquareSearch;          else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
         else if (MotionFlags & PMV_ADVANCEDDIAMOND16)  
                 MainSearchPtr = AdvDiamondSearch;  
1655                  else MainSearchPtr = DiamondSearch;                  else MainSearchPtr = DiamondSearch;
1656    
1657          (*MainSearchPtr)(currentMV.x, currentMV.y, &Data, 255);          MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
1658    
1659          if (MotionFlags & PMV_HALFPELREFINE16) HalfpelRefine(&Data);          SubpelRefine(Data);
1660    
1661            if (Data->qpel && *Data->iMinSAD < *best_sad + 300) {
1662                    Data->currentQMV->x = 2*Data->currentMV->x;
1663                    Data->currentQMV->y = 2*Data->currentMV->y;
1664                    Data->qpel_precision = 1;
1665                    get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
1666                                            pParam->width, pParam->height, iFcode, 1, 0);
1667                    SubpelRefine(Data);
1668            }
1669    
1670  // three bits are needed to code backward mode. four for forward  // three bits are needed to code backward mode. four for forward
 // we treat the bits just like they were vector's  
         if (mode_current == MODE_FORWARD) iMinSAD +=  4 * lambda_vec16[iQuant];  
         else iMinSAD +=  3 * lambda_vec16[iQuant];  
1671    
1672            if (mode_current == MODE_FORWARD) *Data->iMinSAD += 4 * Data->lambda16;
1673            else *Data->iMinSAD += 3 * Data->lambda16;
1674    
1675          if (iMinSAD < *best_sad) {          if (*Data->iMinSAD < *best_sad) {
1676                  *best_sad = iMinSAD;                  *best_sad = *Data->iMinSAD;
1677                  pMB->mode = mode_current;                  pMB->mode = mode_current;
1678                  pMB->pmvs[0].x = currentMV.x - predMV->x;                  if (Data->qpel) {
1679                  pMB->pmvs[0].y = currentMV.y - predMV->y;                          pMB->pmvs[0].x = Data->currentQMV->x - predMV->x;
1680                  if (mode_current == MODE_FORWARD) pMB->mvs[0] = currentMV;                          pMB->pmvs[0].y = Data->currentQMV->y - predMV->y;
1681                  else pMB->b_mvs[0] = currentMV;                          if (mode_current == MODE_FORWARD)
1682                                    pMB->qmvs[0] = *Data->currentQMV;
1683                            else
1684                                    pMB->b_qmvs[0] = *Data->currentQMV;
1685                    } else {
1686                            pMB->pmvs[0].x = Data->currentMV->x - predMV->x;
1687                            pMB->pmvs[0].y = Data->currentMV->y - predMV->y;
1688                    }
1689                    if (mode_current == MODE_FORWARD) pMB->mvs[0] = *Data->currentMV;
1690                    else pMB->b_mvs[0] = *Data->currentMV;
1691          }          }
1692    
1693            if (mode_current == MODE_FORWARD) *(Data->currentMV+2) = *Data->currentMV;
1694            else *(Data->currentMV+1) = *Data->currentMV; //we store currmv for interpolate search
1695  }  }
1696    
1697  static int32_t  static void
1698    SkipDecisionB(const IMAGE * const pCur,
1699                                    const IMAGE * const f_Ref,
1700                                    const IMAGE * const b_Ref,
1701                                    MACROBLOCK * const pMB,
1702                                    const uint32_t x, const uint32_t y,
1703                                    const SearchData * const Data)
1704    {
1705            int dx = 0, dy = 0, b_dx = 0, b_dy = 0;
1706            int32_t sum;
1707            const int div = 1 + Data->qpel;
1708            int k;
1709            const uint32_t stride = Data->iEdgedWidth/2;
1710    //this is not full chroma compensation, only it's fullpel approximation. should work though
1711    
1712            for (k = 0; k < 4; k++) {
1713                    dy += Data->directmvF[k].y / div;
1714                    dx += Data->directmvF[0].x / div;
1715                    b_dy += Data->directmvB[0].y / div;
1716                    b_dx += Data->directmvB[0].x / div;
1717            }
1718    
1719            dy = (dy >> 3) + roundtab_76[dy & 0xf];
1720            dx = (dx >> 3) + roundtab_76[dx & 0xf];
1721            b_dy = (b_dy >> 3) + roundtab_76[b_dy & 0xf];
1722            b_dx = (b_dx >> 3) + roundtab_76[b_dx & 0xf];
1723    
1724            sum = sad8bi(pCur->u + 8 * x + 8 * y * stride,
1725                                            f_Ref->u + (y*8 + dy/2) * stride + x*8 + dx/2,
1726                                            b_Ref->u + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
1727                                            stride);
1728    
1729            if (sum >= 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) return; //no skip
1730    
1731            sum += sad8bi(pCur->v + 8*x + 8 * y * stride,
1732                                            f_Ref->v + (y*8 + dy/2) * stride + x*8 + dx/2,
1733                                            b_Ref->v + (y*8 + b_dy/2) * stride + x*8 + b_dx/2,
1734                                            stride);
1735    
1736            if (sum < 2 * MAX_CHROMA_SAD_FOR_SKIP * pMB->quant) pMB->mode = MODE_DIRECT_NONE_MV; //skipped
1737    }
1738    
1739    static __inline uint32_t
1740  SearchDirect(const IMAGE * const f_Ref,  SearchDirect(const IMAGE * const f_Ref,
1741                                  const uint8_t * const f_RefH,                                  const uint8_t * const f_RefH,
1742                                  const uint8_t * const f_RefV,                                  const uint8_t * const f_RefV,
# Line 1041  Line 1748 
1748                                  const IMAGE * const pCur,                                  const IMAGE * const pCur,
1749                                  const int x, const int y,                                  const int x, const int y,
1750                                  const uint32_t MotionFlags,                                  const uint32_t MotionFlags,
                                 const uint32_t iQuant,  
1751                                  const int32_t TRB, const int32_t TRD,                                  const int32_t TRB, const int32_t TRD,
1752                                  const MBParam * const pParam,                                  const MBParam * const pParam,
1753                                  MACROBLOCK * const pMB,                                  MACROBLOCK * const pMB,
1754                                  const MACROBLOCK * const b_mb,                                  const MACROBLOCK * const b_mb,
1755                                  int32_t * const best_sad)                                  int32_t * const best_sad,
1756                                    SearchData * const Data)
1757    
1758  {  {
1759          const uint32_t iEdgedWidth = pParam->edged_width;          int32_t skip_sad;
1760          int32_t iMinSAD = 266*4096, skip_sad;          int k = (x + Data->iEdgedWidth*y) * 16;
         int k;  
         VECTOR currentMV;  
1761          MainSearchFunc *MainSearchPtr;          MainSearchFunc *MainSearchPtr;
         SearchData Data;  
1762    
1763          Data.iMinSAD = &iMinSAD;          *Data->iMinSAD = 256*4096;
1764          Data.Cur = pCur->y + x * 16 + y * 16 * iEdgedWidth;          Data->Ref = f_Ref->y + k;
1765          Data.iEdgedWidth = iEdgedWidth;          Data->RefH = f_RefH + k;
1766          Data.currentMV = &currentMV;          Data->RefV = f_RefV + k;
1767          Data.iQuant = iQuant;          Data->RefHV = f_RefHV + k;
1768          Data.referencemv = b_mb->mvs;          Data->bRef = b_Ref->y + k;
1769            Data->bRefH = b_RefH + k;
1770          Data.Ref= f_Ref->y + (x + iEdgedWidth*y) * 16;          Data->bRefV = b_RefV + k;
1771          Data.RefH = f_RefH + (x + iEdgedWidth*y) * 16;          Data->bRefHV = b_RefHV + k;
1772          Data.RefV = f_RefV + (x + iEdgedWidth*y) * 16;          Data->RefCU = f_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
1773          Data.RefHV = f_RefHV + (x + iEdgedWidth*y) * 16;          Data->RefCV = f_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
1774          Data.bRef = b_Ref->y + (x + iEdgedWidth*y) * 16;          Data->b_RefCU = b_Ref->u + (x + (Data->iEdgedWidth/2) * y) * 8;
1775          Data.bRefH = b_RefH + (x + iEdgedWidth*y) * 16;          Data->b_RefCV = b_Ref->v + (x + (Data->iEdgedWidth/2) * y) * 8;
1776          Data.bRefV = b_RefV + (x + iEdgedWidth*y) * 16;  
1777          Data.bRefHV = b_RefHV + (x + iEdgedWidth*y) * 16;          k = Data->qpel ? 4 : 2;
1778  /*          Data->max_dx = k * (pParam->width - x * 16);
1779  //What we do here is a complicated version of CheckCandidateDirect(0,0);          Data->max_dy = k * (pParam->height - y * 16);
1780  get_range(&Data.min_dx, &Data.max_dx, &Data.min_dy, &Data.max_dy, x, y, 16, pParam->width, pParam->height, 19);          Data->min_dx = -k * (16 + x * 16);
1781            Data->min_dy = -k * (16 + y * 16);
1782    
1783  */          Data->referencemv = Data->qpel ? b_mb->qmvs : b_mb->mvs;
1784          Data.max_dx = 2 * pParam->width - 2 * (x) * 16;          Data->qpel_precision = 0;
         Data.max_dy = 2 * pParam->height - 2 * (y) * 16;  
         Data.min_dx = -(2 * 16 + 2 * (x) * 16);  
         Data.min_dy = -(2 * 16 + 2 * (y) * 16);  
1785    
1786          for (k = 0; k < 4; k++) {          for (k = 0; k < 4; k++) {
1787                  pMB->mvs[k].x = Data.directmvF[k].x = ((TRB * Data.referencemv[k].x) / TRD);                  pMB->mvs[k].x = Data->directmvF[k].x = ((TRB * Data->referencemv[k].x) / TRD);
1788                  pMB->b_mvs[k].x = Data.directmvB[k].x = ((TRB - TRD) * Data.referencemv[k].x) / TRD;                  pMB->b_mvs[k].x = Data->directmvB[k].x = ((TRB - TRD) * Data->referencemv[k].x) / TRD;
1789                  pMB->mvs[k].y = Data.directmvF[k].y = ((TRB * Data.referencemv[k].y) / TRD);                  pMB->mvs[k].y = Data->directmvF[k].y = ((TRB * Data->referencemv[k].y) / TRD);
1790                  pMB->b_mvs[k].y = Data.directmvB[k].y = ((TRB - TRD) * Data.referencemv[k].y) / TRD;                  pMB->b_mvs[k].y = Data->directmvB[k].y = ((TRB - TRD) * Data->referencemv[k].y) / TRD;
1791    
1792                  if (( pMB->mvs[k].x > Data.max_dx ) || ( pMB->mvs[k].x < Data.min_dx )                  if ( (pMB->b_mvs[k].x > Data->max_dx) | (pMB->b_mvs[k].x < Data->min_dx)
1793                          || ( pMB->mvs[k].y > Data.max_dy ) || ( pMB->mvs[k].y < Data.min_dy )                          | (pMB->b_mvs[k].y > Data->max_dy) | (pMB->b_mvs[k].y < Data->min_dy) ) {
                         || ( pMB->b_mvs[k].x > Data.max_dx ) || ( pMB->b_mvs[k].x < Data.min_dx )  
                         || ( pMB->b_mvs[k].y > Data.max_dy ) || ( pMB->b_mvs[k].y < Data.min_dy )) {  
1794    
1795                          *best_sad = 256*4096; // in that case, we won't use direct mode                          *best_sad = 256*4096; // in that case, we won't use direct mode
1796                          pMB->mode = MODE_DIRECT; // just to make sure it doesn't say "MODE_DIRECT_NONE_MV"                          pMB->mode = MODE_DIRECT; // just to make sure it doesn't say "MODE_DIRECT_NONE_MV"
1797                          pMB->b_mvs[0].x = pMB->b_mvs[0].y = 0;                          pMB->b_mvs[0].x = pMB->b_mvs[0].y = 0;
1798                          return 0;                          return 256*4096;
1799                  }                  }
1800                  if (b_mb->mode != MODE_INTER4V) {                  if (b_mb->mode != MODE_INTER4V) {
1801                          pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mvs[0];                          pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->mvs[0];
1802                          pMB->b_mvs[1] = pMB->b_mvs[2] = pMB->b_mvs[3] = pMB->b_mvs[0];                          pMB->b_mvs[1] = pMB->b_mvs[2] = pMB->b_mvs[3] = pMB->b_mvs[0];
1803                          Data.directmvF[1] = Data.directmvF[2] = Data.directmvF[3] = Data.directmvF[0];                          Data->directmvF[1] = Data->directmvF[2] = Data->directmvF[3] = Data->directmvF[0];
1804                          Data.directmvB[1] = Data.directmvB[2] = Data.directmvB[3] = Data.directmvB[0];                          Data->directmvB[1] = Data->directmvB[2] = Data->directmvB[3] = Data->directmvB[0];
1805                          break;                          break;
1806                  }                  }
1807          }          }
1808    
1809          if (b_mb->mode == MODE_INTER4V)          CheckCandidate = b_mb->mode == MODE_INTER4V ? CheckCandidateDirect : CheckCandidateDirectno4v;
                 CheckCandidate = CheckCandidateDirect;  
         else CheckCandidate = CheckCandidateDirectno4v;  
   
         (*CheckCandidate)(0, 0, 255, &k, &Data);  
   
 // skip decision  
         if (iMinSAD - 2 * lambda_vec16[iQuant] < (int32_t)iQuant * SKIP_THRESH_B) {  
                 //checking chroma. everything copied from MC  
                 //this is not full chroma compensation, only it's fullpel approximation. should work though  
                 int sum, dx, dy, b_dx, b_dy;  
   
                 sum = pMB->mvs[0].x + pMB->mvs[1].x + pMB->mvs[2].x + pMB->mvs[3].x;  
                 dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));  
   
                 sum = pMB->mvs[0].y + pMB->mvs[1].y + pMB->mvs[2].y + pMB->mvs[3].y;  
                 dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));  
1810    
1811                  sum = pMB->b_mvs[0].x + pMB->b_mvs[1].x + pMB->b_mvs[2].x + pMB->b_mvs[3].x;          CheckCandidate(0, 0, 255, &k, Data);
                 b_dx = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));  
   
                 sum = pMB->b_mvs[0].y + pMB->b_mvs[1].y + pMB->b_mvs[2].y + pMB->b_mvs[3].y;  
                 b_dy = (sum == 0 ? 0 : SIGN(sum) * (roundtab[ABS(sum) % 16] + (ABS(sum) / 16) * 2));  
   
                 sum = sad8bi(pCur->u + 8*x + 8*y*(iEdgedWidth/2),  
                                         f_Ref->u + (y*8 + dy/2) * (iEdgedWidth/2) + x*8 + dx/2,  
                                         b_Ref->u + (y*8 + b_dy/2) * (iEdgedWidth/2) + x*8 + b_dx/2,  
                                         iEdgedWidth/2);  
                 sum += sad8bi(pCur->v + 8*x + 8*y*(iEdgedWidth/2),  
                                         f_Ref->v + (y*8 + dy/2) * (iEdgedWidth/2) + x*8 + dx/2,  
                                         b_Ref->v + (y*8 + b_dy/2) * (iEdgedWidth/2) + x*8 + b_dx/2,  
                                         iEdgedWidth/2);  
1812    
1813                  if ((uint32_t) sum < MAX_CHROMA_SAD_FOR_SKIP * Data.iQuant) {  // initial (fast) skip decision
1814            if (*Data->iMinSAD < pMB->quant * INITIAL_SKIP_THRESH * (2 + Data->chroma?1:0)) {
1815                    //possible skip
1816                    if (Data->chroma) {
1817                          pMB->mode = MODE_DIRECT_NONE_MV;                          pMB->mode = MODE_DIRECT_NONE_MV;
1818                          return iMinSAD;                          return *Data->iMinSAD; // skip.
1819                    } else {
1820                            SkipDecisionB(pCur, f_Ref, b_Ref, pMB, x, y, Data);
1821                            if (pMB->mode == MODE_DIRECT_NONE_MV) return *Data->iMinSAD; // skip.
1822                  }                  }
1823          }          }
1824    
1825          skip_sad = iMinSAD;          *Data->iMinSAD += Data->lambda16;
1826            skip_sad = *Data->iMinSAD;
1827    
1828  //  DIRECT MODE DELTA VECTOR SEARCH.  //  DIRECT MODE DELTA VECTOR SEARCH.
1829  //      This has to be made more effective, but at the moment I'm happy it's running at all  //      This has to be made more effective, but at the moment I'm happy it's running at all
1830    
1831          if (MotionFlags & PMV_USESQUARES16) MainSearchPtr = SquareSearch;          if (MotionFlags & XVID_ME_USESQUARES16) MainSearchPtr = SquareSearch;
1832                  else if (MotionFlags & PMV_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;                  else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND16) MainSearchPtr = AdvDiamondSearch;
1833                          else MainSearchPtr = DiamondSearch;                          else MainSearchPtr = DiamondSearch;
1834    
1835          (*MainSearchPtr)(0, 0, &Data, 255);          MainSearchPtr(0, 0, Data, 255);
1836    
1837          HalfpelRefine(&Data);          SubpelRefine(Data);
1838    
1839          iMinSAD +=  1 * lambda_vec16[iQuant]; // one bit is needed to code direct mode. we treat this bit just like it was vector's          *best_sad = *Data->iMinSAD;
         *best_sad = iMinSAD;  
1840    
1841          if (b_mb->mode == MODE_INTER4V)          if (Data->qpel || b_mb->mode == MODE_INTER4V) pMB->mode = MODE_DIRECT;
                 pMB->mode = MODE_DIRECT;  
1842          else pMB->mode = MODE_DIRECT_NO4V; //for faster compensation          else pMB->mode = MODE_DIRECT_NO4V; //for faster compensation
1843    
1844          pMB->pmvs[3] = currentMV;          pMB->pmvs[3] = *Data->currentMV;
1845    
1846          for (k = 0; k < 4; k++) {          for (k = 0; k < 4; k++) {
1847                  pMB->mvs[k].x = Data.directmvF[k].x + currentMV.x;                  pMB->mvs[k].x = Data->directmvF[k].x + Data->currentMV->x;
1848                  pMB->b_mvs[k].x = ((currentMV.x == 0)                  pMB->b_mvs[k].x = (     (Data->currentMV->x == 0)
1849                                                          ? Data.directmvB[k].x                                                          ? Data->directmvB[k].x
1850                                                          : pMB->mvs[k].x - Data.referencemv[k].x);                                                          :pMB->mvs[k].x - Data->referencemv[k].x);
1851                  pMB->mvs[k].y = (Data.directmvF[k].y + currentMV.y);                  pMB->mvs[k].y = (Data->directmvF[k].y + Data->currentMV->y);
1852                  pMB->b_mvs[k].y = ((currentMV.y == 0)                  pMB->b_mvs[k].y = ((Data->currentMV->y == 0)
1853                                                          ? Data.directmvB[k].y                                                          ? Data->directmvB[k].y
1854                                                          : pMB->mvs[k].y - Data.referencemv[k].y);                                                          : pMB->mvs[k].y - Data->referencemv[k].y);
1855                    if (Data->qpel) {
1856                            pMB->qmvs[k].x = pMB->mvs[k].x; pMB->mvs[k].x /= 2;
1857                            pMB->b_qmvs[k].x = pMB->b_mvs[k].x; pMB->b_mvs[k].x /= 2;
1858                            pMB->qmvs[k].y = pMB->mvs[k].y; pMB->mvs[k].y /= 2;
1859                            pMB->b_qmvs[k].y = pMB->b_mvs[k].y; pMB->b_mvs[k].y /= 2;
1860                    }
1861    
1862                  if (b_mb->mode != MODE_INTER4V) {                  if (b_mb->mode != MODE_INTER4V) {
1863                          pMB->mvs[3] = pMB->mvs[2] = pMB->mvs[1] = pMB->mvs[0];                          pMB->mvs[3] = pMB->mvs[2] = pMB->mvs[1] = pMB->mvs[0];
1864                          pMB->b_mvs[3] = pMB->b_mvs[2] = pMB->b_mvs[1] = pMB->b_mvs[0];                          pMB->b_mvs[3] = pMB->b_mvs[2] = pMB->b_mvs[1] = pMB->b_mvs[0];
1865                            pMB->qmvs[3] = pMB->qmvs[2] = pMB->qmvs[1] = pMB->qmvs[0];
1866                            pMB->b_qmvs[3] = pMB->b_qmvs[2] = pMB->b_qmvs[1] = pMB->b_qmvs[0];
1867                          break;                          break;
1868                  }                  }
1869          }          }
1870          return 0;//skip_sad;          return skip_sad;
1871  }  }
1872    
1873  static __inline void  static void
1874  SearchInterpolate(const uint8_t * const f_Ref,  SearchInterpolate(const IMAGE * const f_Ref,
1875                                  const uint8_t * const f_RefH,                                  const uint8_t * const f_RefH,
1876                                  const uint8_t * const f_RefV,                                  const uint8_t * const f_RefV,
1877                                  const uint8_t * const f_RefHV,                                  const uint8_t * const f_RefHV,
1878                                  const uint8_t * const b_Ref,                                  const IMAGE * const b_Ref,
1879                                  const uint8_t * const b_RefH,                                  const uint8_t * const b_RefH,
1880                                  const uint8_t * const b_RefV,                                  const uint8_t * const b_RefV,
1881                                  const uint8_t * const b_RefHV,                                  const uint8_t * const b_RefHV,
# Line 1199  Line 1884 
1884                                  const uint32_t fcode,                                  const uint32_t fcode,
1885                                  const uint32_t bcode,                                  const uint32_t bcode,
1886                                  const uint32_t MotionFlags,                                  const uint32_t MotionFlags,
                                 const uint32_t iQuant,  
1887                                  const MBParam * const pParam,                                  const MBParam * const pParam,
1888                                  const VECTOR * const f_predMV,                                  const VECTOR * const f_predMV,
1889                                  const VECTOR * const b_predMV,                                  const VECTOR * const b_predMV,
1890                                  MACROBLOCK * const pMB,                                  MACROBLOCK * const pMB,
1891                                  int32_t * const best_sad)                                  int32_t * const best_sad,
1892                                    SearchData * const fData)
1893    
1894  {  {
 /* Interpolated MC motion vector search, this is tedious and more complicated because there are  
    two values for everything, always one for backward and one for forward ME. Still, we don't gain  
    much from this search, maybe it should simply be skipped and simply current i_sad16 value used  
    as "optimal". */  
   
         const int32_t iEdgedWidth = pParam->edged_width;  
1895    
1896          int iDirection, i, j;          int iDirection, i, j;
1897          int32_t iMinSAD = 256*4096;          SearchData bData;
         VECTOR currentMV[3];  
         SearchData fData, bData;  
   
         fData.iMinSAD = bData.iMinSAD = &iMinSAD;  
   
         fData.Cur = bData.Cur = pCur->y + (x + y * iEdgedWidth) * 16;  
         fData.iEdgedWidth = bData.iEdgedWidth = iEdgedWidth;  
         fData.currentMV = currentMV; bData.currentMV = currentMV + 1;  
         fData.iQuant = bData.iQuant = iQuant;  
         fData.iFcode = bData.bFcode = fcode; fData.bFcode = bData.iFcode = bcode;  
   
         bData.bRef = fData.Ref = f_Ref + (x + y * iEdgedWidth) * 16;  
         bData.bRefH = fData.RefH = f_RefH + (x + y * iEdgedWidth) * 16;  
         bData.bRefV = fData.RefV = f_RefV + (x + y * iEdgedWidth) * 16;  
         bData.bRefHV = fData.RefHV = f_RefHV + (x + y * iEdgedWidth) * 16;  
         bData.Ref = fData.bRef = b_Ref + (x + y * iEdgedWidth) * 16;  
         bData.RefH = fData.bRefH = b_RefH + (x + y * iEdgedWidth) * 16;  
         bData.RefV = fData.bRefV = b_RefV + (x + y * iEdgedWidth) * 16;  
         bData.RefHV = fData.bRefHV = b_RefHV + (x + y * iEdgedWidth) * 16;  
   
         bData.bpredMV = fData.predMV = *f_predMV;  
         fData.bpredMV = bData.predMV = *b_predMV;  
   
         currentMV[0] = pMB->mvs[0];  
         currentMV[1] = pMB->b_mvs[0];  
         get_range(&fData.min_dx, &fData.max_dx, &fData.min_dy, &fData.max_dy, x, y, 16, pParam->width, pParam->height, fcode);  
         get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode);  
   
         if (currentMV[0].x > fData.max_dx) currentMV[0].x = fData.max_dx;  
         if (currentMV[0].x < fData.min_dx) currentMV[0].x = fData.min_dy;  
         if (currentMV[0].y > fData.max_dy) currentMV[0].y = fData.max_dx;  
         if (currentMV[0].y > fData.min_dy) currentMV[0].y = fData.min_dy;  
   
         if (currentMV[1].x > bData.max_dx) currentMV[1].x = bData.max_dx;  
         if (currentMV[1].x < bData.min_dx) currentMV[1].x = bData.min_dy;  
         if (currentMV[1].y > bData.max_dy) currentMV[1].y = bData.max_dx;  
         if (currentMV[1].y > bData.min_dy) currentMV[1].y = bData.min_dy;  
1898    
1899          CheckCandidateInt(currentMV[0].x, currentMV[0].y, 255, &iDirection, &fData);          fData->qpel_precision = 0;
1900            memcpy(&bData, fData, sizeof(SearchData)); //quick copy of common data
1901            *fData->iMinSAD = 4096*256;
1902            bData.currentMV++; bData.currentQMV++;
1903            fData->iFcode = bData.bFcode = fcode; fData->bFcode = bData.iFcode = bcode;
1904    
1905            i = (x + y * fData->iEdgedWidth) * 16;
1906            bData.bRef = fData->Ref = f_Ref->y + i;
1907            bData.bRefH = fData->RefH = f_RefH + i;
1908            bData.bRefV = fData->RefV = f_RefV + i;
1909            bData.bRefHV = fData->RefHV = f_RefHV + i;
1910            bData.Ref = fData->bRef = b_Ref->y + i;
1911            bData.RefH = fData->bRefH = b_RefH + i;
1912            bData.RefV = fData->bRefV = b_RefV + i;
1913            bData.RefHV = fData->bRefHV = b_RefHV + i;
1914            bData.b_RefCU = fData->RefCU = f_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
1915            bData.b_RefCV = fData->RefCV = f_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
1916            bData.RefCU = fData->b_RefCU = b_Ref->u + (x + (fData->iEdgedWidth/2) * y) * 8;
1917            bData.RefCV = fData->b_RefCV = b_Ref->v + (x + (fData->iEdgedWidth/2) * y) * 8;
1918    
1919    
1920            bData.bpredMV = fData->predMV = *f_predMV;
1921            fData->bpredMV = bData.predMV = *b_predMV;
1922            fData->currentMV[0] = fData->currentMV[2];
1923    
1924            get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 16, pParam->width, pParam->height, fcode - fData->qpel, 0, 0);
1925            get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode - fData->qpel, 0, 0);
1926    
1927            if (fData->currentMV[0].x > fData->max_dx) fData->currentMV[0].x = fData->max_dx;
1928            if (fData->currentMV[0].x < fData->min_dx) fData->currentMV[0].x = fData->min_dx;
1929            if (fData->currentMV[0].y > fData->max_dy) fData->currentMV[0].y = fData->max_dy;
1930            if (fData->currentMV[0].y < fData->min_dy) fData->currentMV[0].y = fData->min_dy;
1931    
1932            if (fData->currentMV[1].x > bData.max_dx) fData->currentMV[1].x = bData.max_dx;
1933            if (fData->currentMV[1].x < bData.min_dx) fData->currentMV[1].x = bData.min_dx;
1934            if (fData->currentMV[1].y > bData.max_dy) fData->currentMV[1].y = bData.max_dy;
1935            if (fData->currentMV[1].y < bData.min_dy) fData->currentMV[1].y = bData.min_dy;
1936    
1937  //diamond. I wish we could use normal mainsearch functions (square, advdiamond)          CheckCandidateInt(fData->currentMV[0].x, fData->currentMV[0].y, 255, &iDirection, fData);
1938    
1939    //diamond
1940          do {          do {
1941                  iDirection = 255;                  iDirection = 255;
1942                  // forward MV moves                  // forward MV moves
1943                  i = currentMV[0].x; j = currentMV[0].y;                  i = fData->currentMV[0].x; j = fData->currentMV[0].y;
1944    
1945                  CheckCandidateInt(i + 1, j, 0, &iDirection, &fData);                  CheckCandidateInt(i + 1, j, 0, &iDirection, fData);
1946                  CheckCandidateInt(i, j + 1, 0, &iDirection, &fData);                  CheckCandidateInt(i, j + 1, 0, &iDirection, fData);
1947                  CheckCandidateInt(i - 1, j, 0, &iDirection, &fData);                  CheckCandidateInt(i - 1, j, 0, &iDirection, fData);
1948                  CheckCandidateInt(i, j - 1, 0, &iDirection, &fData);                  CheckCandidateInt(i, j - 1, 0, &iDirection, fData);
1949    
1950                  // backward MV moves                  // backward MV moves
1951                  i = currentMV[1].x; j = currentMV[1].y;                  i = fData->currentMV[1].x; j = fData->currentMV[1].y;
1952                  currentMV[2] = currentMV[0];                  fData->currentMV[2] = fData->currentMV[0];
   
1953                  CheckCandidateInt(i + 1, j, 0, &iDirection, &bData);                  CheckCandidateInt(i + 1, j, 0, &iDirection, &bData);
1954                  CheckCandidateInt(i, j + 1, 0, &iDirection, &bData);                  CheckCandidateInt(i, j + 1, 0, &iDirection, &bData);
1955                  CheckCandidateInt(i - 1, j, 0, &iDirection, &bData);                  CheckCandidateInt(i - 1, j, 0, &iDirection, &bData);
# Line 1279  Line 1957 
1957    
1958          } while (!(iDirection));          } while (!(iDirection));
1959    
1960  // two bits are needed to code interpolate mode. we treat the bits just like they were vector's  //qpel refinement
1961          iMinSAD +=  2 * lambda_vec16[iQuant];          if (fData->qpel) {
1962          if (iMinSAD < *best_sad) {                  if (*fData->iMinSAD > *best_sad + 500) return;
1963                  *best_sad = iMinSAD;                  CheckCandidate = CheckCandidateInt;
1964                  pMB->mvs[0] = currentMV[0];                  fData->qpel_precision = bData.qpel_precision = 1;
1965                  pMB->b_mvs[0] = currentMV[1];                  get_range(&fData->min_dx, &fData->max_dx, &fData->min_dy, &fData->max_dy, x, y, 16, pParam->width, pParam->height, fcode, 1, 0);
1966                    get_range(&bData.min_dx, &bData.max_dx, &bData.min_dy, &bData.max_dy, x, y, 16, pParam->width, pParam->height, bcode, 1, 0);
1967                    fData->currentQMV[2].x = fData->currentQMV[0].x = 2 * fData->currentMV[0].x;
1968                    fData->currentQMV[2].y = fData->currentQMV[0].y = 2 * fData->currentMV[0].y;
1969                    fData->currentQMV[1].x = 2 * fData->currentMV[1].x;
1970                    fData->currentQMV[1].y = 2 * fData->currentMV[1].y;
1971                    SubpelRefine(fData);
1972                    if (*fData->iMinSAD > *best_sad + 300) return;
1973                    fData->currentQMV[2] = fData->currentQMV[0];
1974                    SubpelRefine(&bData);
1975            }
1976    
1977            *fData->iMinSAD += (2+3) * fData->lambda16; // two bits are needed to code interpolate mode.
1978    
1979            if (*fData->iMinSAD < *best_sad) {
1980                    *best_sad = *fData->iMinSAD;
1981                    pMB->mvs[0] = fData->currentMV[0];
1982                    pMB->b_mvs[0] = fData->currentMV[1];
1983                  pMB->mode = MODE_INTERPOLATE;                  pMB->mode = MODE_INTERPOLATE;
1984                    if (fData->qpel) {
1985                            pMB->qmvs[0] = fData->currentQMV[0];
1986                            pMB->b_qmvs[0] = fData->currentQMV[1];
1987                            pMB->pmvs[1].x = pMB->qmvs[0].x - f_predMV->x;
1988                            pMB->pmvs[1].y = pMB->qmvs[0].y - f_predMV->y;
1989                            pMB->pmvs[0].x = pMB->b_qmvs[0].x - b_predMV->x;
1990                            pMB->pmvs[0].y = pMB->b_qmvs[0].y - b_predMV->y;
1991                    } else {
1992                  pMB->pmvs[1].x = pMB->mvs[0].x - f_predMV->x;                  pMB->pmvs[1].x = pMB->mvs[0].x - f_predMV->x;
1993                  pMB->pmvs[1].y = pMB->mvs[0].y - f_predMV->y;                  pMB->pmvs[1].y = pMB->mvs[0].y - f_predMV->y;
1994                  pMB->pmvs[0].x = pMB->b_mvs[0].x - b_predMV->x;                  pMB->pmvs[0].x = pMB->b_mvs[0].x - b_predMV->x;
1995                  pMB->pmvs[0].y = pMB->b_mvs[0].y - b_predMV->y;                  pMB->pmvs[0].y = pMB->b_mvs[0].y - b_predMV->y;
1996          }          }
1997  }  }
1998    }
1999    
2000  void  void
2001  MotionEstimationBVOP(MBParam * const pParam,  MotionEstimationBVOP(MBParam * const pParam,
# Line 1306  Line 2009 
2009                                           const IMAGE * const f_refV,                                           const IMAGE * const f_refV,
2010                                           const IMAGE * const f_refHV,                                           const IMAGE * const f_refHV,
2011                                           // backward (future) reference                                           // backward (future) reference
2012                                           const MACROBLOCK * const b_mbs,                                           const FRAMEINFO * const b_reference,
2013                                           const IMAGE * const b_ref,                                           const IMAGE * const b_ref,
2014                                           const IMAGE * const b_refH,                                           const IMAGE * const b_refH,
2015                                           const IMAGE * const b_refV,                                           const IMAGE * const b_refV,
2016                                           const IMAGE * const b_refHV)                                           const IMAGE * const b_refHV)
2017  {  {
2018          uint32_t i, j;          uint32_t i, j;
2019          int32_t best_sad, skip_sad;          int32_t best_sad;
2020            uint32_t skip_sad;
2021          int f_count = 0, b_count = 0, i_count = 0, d_count = 0, n_count = 0;          int f_count = 0, b_count = 0, i_count = 0, d_count = 0, n_count = 0;
2022          static const VECTOR zeroMV={0,0};          const MACROBLOCK * const b_mbs = b_reference->mbs;
2023    
2024          VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/          VECTOR f_predMV, b_predMV;      /* there is no prediction for direct mode*/
2025    
2026          const int32_t TRB = time_pp - time_bp;          const int32_t TRB = time_pp - time_bp;
2027          const int32_t TRD = time_pp;          const int32_t TRD = time_pp;
2028    
2029          // note: i==horizontal, j==vertical  // some pre-inintialized data for the rest of the search
2030    
2031            SearchData Data;
2032            int32_t iMinSAD;
2033            VECTOR currentMV[3];
2034            VECTOR currentQMV[3];
2035            int32_t temp[8];
2036            memset(&Data, 0, sizeof(SearchData));
2037            Data.iEdgedWidth = pParam->edged_width;
2038            Data.currentMV = currentMV; Data.currentQMV = currentQMV;
2039            Data.iMinSAD = &iMinSAD;
2040            Data.lambda16 = lambda_vec16[frame->quant];
2041            Data.qpel = pParam->vol_flags & XVID_VOL_QUARTERPEL;
2042            Data.rounding = 0;
2043            Data.chroma = frame->motion_flags & XVID_ME_CHROMA8;
2044            Data.temp = temp;
2045    
2046            Data.RefQ = f_refV->u; // a good place, also used in MC (for similar purpose)
2047            // note: i==horizontal, j==vertical
2048          for (j = 0; j < pParam->mb_height; j++) {          for (j = 0; j < pParam->mb_height; j++) {
2049    
2050                  f_predMV = b_predMV = zeroMV;   /* prediction is reset at left boundary */                  f_predMV = b_predMV = zeroMV;   /* prediction is reset at left boundary */
# Line 1332  Line 2053 
2053                          MACROBLOCK * const pMB = frame->mbs + i + j * pParam->mb_width;                          MACROBLOCK * const pMB = frame->mbs + i + j * pParam->mb_width;
2054                          const MACROBLOCK * const b_mb = b_mbs + i + j * pParam->mb_width;                          const MACROBLOCK * const b_mb = b_mbs + i + j * pParam->mb_width;
2055    
2056  /* special case, if collocated block is SKIPed: encoding is forward (0,0), cpb=0 without further ado */  /* special case, if collocated block is SKIPed in P-VOP: encoding is forward (0,0), cpb=0 without further ado */
2057                            if (b_reference->coding_type != S_VOP)
2058                          if (b_mb->mode == MODE_NOT_CODED) {                          if (b_mb->mode == MODE_NOT_CODED) {
2059                                  pMB->mode = MODE_NOT_CODED;                                  pMB->mode = MODE_NOT_CODED;
2060                                  continue;                                  continue;
2061                          }                          }
2062    
2063                            Data.Cur = frame->image.y + (j * Data.iEdgedWidth + i) * 16;
2064                            Data.CurU = frame->image.u + (j * Data.iEdgedWidth/2 + i) * 8;
2065                            Data.CurV = frame->image.v + (j * Data.iEdgedWidth/2 + i) * 8;
2066                            pMB->quant = frame->quant;
2067    
2068  /* direct search comes first, because it (1) checks for SKIP-mode  /* direct search comes first, because it (1) checks for SKIP-mode
2069          and (2) sets very good predictions for forward and backward search */          and (2) sets very good predictions for forward and backward search */
   
2070                          skip_sad = SearchDirect(f_ref, f_refH->y, f_refV->y, f_refHV->y,                          skip_sad = SearchDirect(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2071                                                                          b_ref, b_refH->y, b_refV->y, b_refHV->y,                                                                          b_ref, b_refH->y, b_refV->y, b_refHV->y,
2072                                                                          &frame->image,                                                                          &frame->image,
2073                                                                          i, j,                                                                          i, j,
2074                                                                          frame->motion_flags,                                                                          frame->motion_flags,
                                                                         frame->quant,  
2075                                                                          TRB, TRD,                                                                          TRB, TRD,
2076                                                                          pParam,                                                                          pParam,
2077                                                                          pMB, b_mb,                                                                          pMB, b_mb,
2078                                                                          &best_sad);                                                                          &best_sad,
2079                                                                            &Data);
2080    
2081                          if (pMB->mode == MODE_DIRECT_NONE_MV) { n_count++; continue; }                          if (pMB->mode == MODE_DIRECT_NONE_MV) { n_count++; continue; }
2082    
 //                      best_sad = 256*4096; //uncomment to disable Directsearch.  
 //      To disable any other mode, just comment the function call  
   
2083                          // forward search                          // forward search
2084                          SearchBF(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,                          SearchBF(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2085                                                  &frame->image, i, j,                                                  &frame->image, i, j,
2086                                                  frame->motion_flags,                                                  frame->motion_flags,
2087                                                  frame->quant, frame->fcode, pParam,                                                  frame->fcode, pParam,
2088                                                  pMB, &f_predMV, &best_sad,                                                  pMB, &f_predMV, &best_sad,
2089                                                  MODE_FORWARD);                                                  MODE_FORWARD, &Data);
2090    
2091                          // backward search                          // backward search
2092                          SearchBF(b_ref->y, b_refH->y, b_refV->y, b_refHV->y,                          SearchBF(b_ref, b_refH->y, b_refV->y, b_refHV->y,
2093                                                  &frame->image, i, j,                                                  &frame->image, i, j,
2094                                                  frame->motion_flags,                                                  frame->motion_flags,
2095                                                  frame->quant, frame->bcode, pParam,                                                  frame->bcode, pParam,
2096                                                  pMB, &b_predMV, &best_sad,                                                  pMB, &b_predMV, &best_sad,
2097                                                  MODE_BACKWARD);                                                  MODE_BACKWARD, &Data);
2098    
2099                          // interpolate search comes last, because it uses data from forward and backward as prediction                          // interpolate search comes last, because it uses data from forward and backward as prediction
2100                            SearchInterpolate(f_ref, f_refH->y, f_refV->y, f_refHV->y,
2101                          SearchInterpolate(f_ref->y, f_refH->y, f_refV->y, f_refHV->y,                                                  b_ref, b_refH->y, b_refV->y, b_refHV->y,
                                                 b_ref->y, b_refH->y, b_refV->y, b_refHV->y,  
2102                                                  &frame->image,                                                  &frame->image,
2103                                                  i, j,                                                  i, j,
2104                                                  frame->fcode, frame->bcode,                                                  frame->fcode, frame->bcode,
2105                                                  frame->motion_flags,                                                  frame->motion_flags,
2106                                                  frame->quant, pParam,                                                  pParam,
2107                                                  &f_predMV, &b_predMV,                                                  &f_predMV, &b_predMV,
2108                                                  pMB, &best_sad);                                                  pMB, &best_sad,
2109                                                    &Data);
2110    
2111    // final skip decision
2112                            if ( (skip_sad < frame->quant * MAX_SAD00_FOR_SKIP * 2)
2113                                            && ((100*best_sad)/(skip_sad+1) > FINAL_SKIP_THRESH) )
2114                                    SkipDecisionB(&frame->image, f_ref, b_ref, pMB, i, j, &Data);
2115    
2116                          switch (pMB->mode) {                          switch (pMB->mode) {
2117                                  case MODE_FORWARD:                                  case MODE_FORWARD:
2118                                          f_count++;                                          f_count++;
2119                                          f_predMV = pMB->mvs[0];                                          f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2120                                          break;                                          break;
2121                                  case MODE_BACKWARD:                                  case MODE_BACKWARD:
2122                                          b_count++;                                          b_count++;
2123                                          b_predMV = pMB->b_mvs[0];                                          b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2124                                          break;                                          break;
2125                                  case MODE_INTERPOLATE:                                  case MODE_INTERPOLATE:
2126                                          i_count++;                                          i_count++;
2127                                          f_predMV = pMB->mvs[0];                                          f_predMV = Data.qpel ? pMB->qmvs[0] : pMB->mvs[0];
2128                                          b_predMV = pMB->b_mvs[0];                                          b_predMV = Data.qpel ? pMB->b_qmvs[0] : pMB->b_mvs[0];
2129                                          break;                                          break;
2130                                  case MODE_DIRECT:                                  case MODE_DIRECT:
2131                                  case MODE_DIRECT_NO4V:                                  case MODE_DIRECT_NO4V:
2132                                          d_count++;                                          d_count++;
                                         break;  
2133                                  default:                                  default:
2134                                          break;                                          break;
2135                          }                          }
2136                  }                  }
2137          }          }
2138    }
2139    
2140    static __inline void
2141    MEanalyzeMB (   const uint8_t * const pRef,
2142                                    const uint8_t * const pCur,
2143                                    const int x,
2144                                    const int y,
2145                                    const MBParam * const pParam,
2146                                    MACROBLOCK * const pMBs,
2147                                    SearchData * const Data)
2148    {
2149    
2150            int i, mask;
2151            int quarterpel = (pParam->vol_flags & XVID_VOL_QUARTERPEL)? 1: 0;
2152            VECTOR pmv[3];
2153            MACROBLOCK * const pMB = &pMBs[x + y * pParam->mb_width];
2154    
2155            for (i = 0; i < 5; i++) Data->iMinSAD[i] = MV_MAX_ERROR;
2156    
2157            //median is only used as prediction. it doesn't have to be real
2158            if (x == 1 && y == 1) Data->predMV.x = Data->predMV.y = 0;
2159            else
2160                    if (x == 1) //left macroblock does not have any vector now
2161                            Data->predMV = (pMB - pParam->mb_width)->mvs[0]; // top instead of median
2162                    else if (y == 1) // top macroblock doesn't have it's vector
2163                            Data->predMV = (pMB - 1)->mvs[0]; // left instead of median
2164                            else Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); //else median
2165    
2166            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2167            pParam->width, pParam->height, Data->iFcode - quarterpel, 0, 0);
2168    
2169            Data->Cur = pCur + (x + y * pParam->edged_width) * 16;
2170            Data->Ref = pRef + (x + y * pParam->edged_width) * 16;
2171    
2172            pmv[1].x = EVEN(pMB->mvs[0].x);
2173            pmv[1].y = EVEN(pMB->mvs[0].y);
2174            pmv[2].x = EVEN(Data->predMV.x);
2175            pmv[2].y = EVEN(Data->predMV.y);
2176            pmv[0].x = pmv[0].y = 0;
2177    
2178            CheckCandidate32I(0, 0, 255, &i, Data);
2179            Data->iMinSAD[1] -= 50;
2180            Data->iMinSAD[2] -= 50;
2181            Data->iMinSAD[3] -= 50;
2182            Data->iMinSAD[4] -= 50;
2183    
2184            if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP) {
2185    
2186  //      fprintf(debug,"B-Stat: F: %04d   B: %04d   I: %04d  D: %04d, N: %04d\n",                  if (!(mask = make_mask(pmv, 1)))
2187  //                              f_count,b_count,i_count,d_count,n_count);                          CheckCandidate32I(pmv[1].x, pmv[1].y, mask, &i, Data);
2188                    if (!(mask = make_mask(pmv, 2)))
2189                            CheckCandidate32I(pmv[2].x, pmv[2].y, mask, &i, Data);
2190    
2191                    if (*Data->iMinSAD > 4 * MAX_SAD00_FOR_SKIP) // diamond only if needed
2192                            DiamondSearch(Data->currentMV->x, Data->currentMV->y, Data, i);
2193  }  }
2194    
2195  /* Hinted ME starts here */          for (i = 0; i < 4; i++) {
2196                    MACROBLOCK * MB = &pMBs[x + (i&1) + (y+(i>>1)) * pParam->mb_width];
2197                    MB->mvs[0] = MB->mvs[1] = MB->mvs[2] = MB->mvs[3] = Data->currentMV[i];
2198                    MB->mode = MODE_INTER;
2199                    MB->sad16 = Data->iMinSAD[i+1];
2200            }
2201    }
2202    
2203  static __inline void  #define INTRA_THRESH    2400
2204  Search8hinted(  const SearchData * const OldData,  #define INTER_THRESH    1100
2205                                  const int x, const int y,  
2206                                  const uint32_t MotionFlags,  int
2207    MEanalysis(     const IMAGE * const pRef,
2208                            const FRAMEINFO * const Current,
2209                                  const MBParam * const pParam,                                  const MBParam * const pParam,
2210                                  MACROBLOCK * const pMB,                          const int maxIntra, //maximum number if non-I frames
2211                                  const MACROBLOCK * const pMBs,                          const int intraCount, //number of non-I frames after last I frame; 0 if we force P/B frame
2212                                  const int block)                          const int bCount,  // number of B frames in a row
2213                            const int b_thresh)
2214  {  {
2215          SearchData Data;          uint32_t x, y, intra = 0;
2216          MainSearchFunc *MainSearchPtr;          int sSAD = 0;
2217            MACROBLOCK * const pMBs = Current->mbs;
2218            const IMAGE * const pCurrent = &Current->image;
2219            int IntraThresh = INTRA_THRESH, InterThresh = INTER_THRESH + 10*b_thresh;
2220            int s = 0, blocks = 0;
2221    
2222          Data.predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2 , y/2, block);          int32_t iMinSAD[5], temp[5];
2223          Data.iMinSAD = OldData->iMinSAD + 1 + block;          VECTOR currentMV[5];
2224          Data.currentMV = OldData->currentMV+1+block;          SearchData Data;
         Data.iFcode = OldData->iFcode;  
         Data.iQuant = OldData->iQuant;  
   
         Data.Ref = OldData->Ref + 8 * ((block&1) + pParam->edged_width*(block>>1));  
         Data.RefH = OldData->RefH + 8 * ((block&1) + pParam->edged_width*(block>>1));  
         Data.RefV = OldData->RefV + 8 * ((block&1) + pParam->edged_width*(block>>1));  
         Data.RefHV = OldData->RefHV + 8 * ((block&1) + pParam->edged_width*(block>>1));  
2225          Data.iEdgedWidth = pParam->edged_width;          Data.iEdgedWidth = pParam->edged_width;
2226          Data.Cur = OldData->Cur + 8 * ((block&1) + pParam->edged_width*(block>>1));          Data.currentMV = currentMV;
2227            Data.iMinSAD = iMinSAD;
2228            Data.iFcode = Current->fcode;
2229            Data.temp = temp;
2230            CheckCandidate = CheckCandidate32I;
2231    
2232          CheckCandidate = CheckCandidate8;          if (intraCount != 0 && intraCount < 10) // we're right after an I frame
2233                    IntraThresh += 8 * (intraCount - 10) * (intraCount - 10);
2234            else
2235                    if ( 5*(maxIntra - intraCount) < maxIntra) // we're close to maximum. 2 sec when max is 10 sec
2236                            IntraThresh -= (IntraThresh * (maxIntra - 5*(maxIntra - intraCount)))/maxIntra;
2237    
2238          if (block != 0)          InterThresh -= (350 - 8*b_thresh) * bCount;
2239                  *(Data.iMinSAD) += lambda_vec8[Data.iQuant] *          if (InterThresh < 300 + 5*b_thresh) InterThresh = 300 + 5*b_thresh;
                                                                 d_mv_bits(      Data.currentMV->x - Data.predMV.x,  
                                                                                         Data.currentMV->y - Data.predMV.y,  
                                                                                         Data.iFcode);  
2240    
2241            if (sadInit) (*sadInit) ();
2242    
2243          get_range(&Data.min_dx, &Data.max_dx, &Data.min_dy, &Data.max_dy, x, y, 8,          for (y = 1; y < pParam->mb_height-1; y += 2) {
2244                                  pParam->width, pParam->height, OldData->iFcode);                  for (x = 1; x < pParam->mb_width-1; x += 2) {
2245                            int i;
2246                            blocks += 4;
2247    
2248          if (pMB->mode == MODE_INTER4V) {                          if (bCount == 0) pMBs[x + y * pParam->mb_width].mvs[0] = zeroMV;
2249                  int dummy;                          else { //extrapolation of the vector found for last frame
2250                  CheckCandidate8(pMB->mvs[block].x, pMB->mvs[block].y, 0, &dummy, &Data); }                                  pMBs[x + y * pParam->mb_width].mvs[0].x =
2251                                            (pMBs[x + y * pParam->mb_width].mvs[0].x * (bCount+1) ) / bCount;
2252                                    pMBs[x + y * pParam->mb_width].mvs[0].y =
2253                                            (pMBs[x + y * pParam->mb_width].mvs[0].y * (bCount+1) ) / bCount;
2254                            }
2255    
2256                            MEanalyzeMB(pRef->y, pCurrent->y, x, y, pParam, pMBs, &Data);
2257    
2258                            for (i = 0; i < 4; i++) {
2259                                    int dev;
2260                                    MACROBLOCK *pMB = &pMBs[x+(i&1) + (y+(i>>1)) * pParam->mb_width];
2261                                    if (pMB->sad16 > IntraThresh) {
2262                                            dev = dev16(pCurrent->y + (x + (i&1) + (y + (i>>1)) * pParam->edged_width) * 16,
2263                                                                            pParam->edged_width);
2264                                            if (dev + IntraThresh < pMB->sad16) {
2265                                                    pMB->mode = MODE_INTRA;
2266                                                    if (++intra > ((pParam->mb_height-2)*(pParam->mb_width-2))/2) return I_VOP;
2267                                            }
2268                                    }
2269                                    if (pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0) s++;
2270    
2271          if (MotionFlags & PMV_USESQUARES8) MainSearchPtr = SquareSearch;                                  sSAD += pMB->sad16;
2272                  else if (MotionFlags & PMV_ADVANCEDDIAMOND8) MainSearchPtr = AdvDiamondSearch;                          }
2273                          else MainSearchPtr = DiamondSearch;                  }
2274            }
2275    
2276          (*MainSearchPtr)(Data.currentMV->x, Data.currentMV->y, &Data, 255);          sSAD /= blocks;
2277            s = (10*s) / blocks;
2278    
2279          if (MotionFlags & PMV_HALFPELREFINE8) HalfpelRefine(&Data);          if (s > 5) sSAD += (s - 4) * (180 - 2*b_thresh); //static block - looks bad when in bframe...
2280    
2281          pMB->pmvs[block].x = Data.currentMV->x - Data.predMV.x;          if (sSAD > InterThresh ) return P_VOP;
2282          pMB->pmvs[block].y = Data.currentMV->y - Data.predMV.y;          emms();
2283          pMB->mvs[block] = *(Data.currentMV);          return B_VOP;
         pMB->sad8[block] =  4 * (*(Data.iMinSAD));  
2284  }  }
2285    
2286    
2287  static void  static WARPPOINTS
2288  SearchPhinted ( const uint8_t * const pRef,  GlobalMotionEst(const MACROBLOCK * const pMBs,
                                 const uint8_t * const pRefH,  
                                 const uint8_t * const pRefV,  
                                 const uint8_t * const pRefHV,  
                                 const IMAGE * const pCur,  
                                 const int x,  
                                 const int y,  
                                 const uint32_t MotionFlags,  
                                 const uint32_t iQuant,  
                                 const uint32_t iFcode,  
2289                                  const MBParam * const pParam,                                  const MBParam * const pParam,
2290                                  const MACROBLOCK * const pMBs,                                  const FRAMEINFO * const current,
2291                                  int inter4v,                                  const FRAMEINFO * const reference,
2292                                  MACROBLOCK * const pMB)                                  const IMAGE * const pRefH,
2293                                    const IMAGE * const pRefV,
2294                                    const IMAGE * const pRefHV      )
2295  {  {
2296    
2297          const int32_t iEdgedWidth = pParam->edged_width;          const int deltax=8;             // upper bound for difference between a MV and it's neighbour MVs
2298            const int deltay=8;
2299            const int grad=512;             // lower bound for deviation in MB
2300    
2301          int i;          WARPPOINTS gmc;
         VECTOR currentMV[5];  
         int32_t iMinSAD[5];  
         int32_t temp[5];  
         MainSearchFunc * MainSearchPtr;  
         SearchData Data;  
2302    
2303          Data.predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);          uint32_t mx, my;
         get_range(&Data.min_dx, &Data.max_dx, &Data.min_dy, &Data.max_dy, x, y, 16,  
                                 pParam->width, pParam->height, iFcode);  
2304    
2305          Data.Cur = pCur->y + (x + y * iEdgedWidth) * 16;          int MBh = pParam->mb_height;
2306          Data.iEdgedWidth = iEdgedWidth;          int MBw = pParam->mb_width;
2307          Data.currentMV = currentMV;  
2308          Data.iMinSAD = iMinSAD;          int *MBmask= calloc(MBh*MBw,sizeof(int));
2309          Data.Ref = pRef + (x + iEdgedWidth*y)*16;          double DtimesF[4] = { 0.,0., 0., 0. };
2310          Data.RefH = pRefH + (x + iEdgedWidth*y) * 16;          double sol[4] = { 0., 0., 0., 0. };
2311          Data.RefV = pRefV + (x + iEdgedWidth*y) * 16;          double a,b,c,n,denom;
2312          Data.RefHV = pRefHV + (x + iEdgedWidth*y) * 16;          double meanx,meany;
2313          Data.temp = temp;          int num,oldnum;
2314          Data.iQuant = iQuant;  
2315          Data.iFcode = iFcode;          if (!MBmask) { fprintf(stderr,"Mem error\n");
2316                                   gmc.duv[0].x= gmc.duv[0].y =
2317                                                    gmc.duv[1].x= gmc.duv[1].y =
2318                                                    gmc.duv[2].x= gmc.duv[2].y = 0;
2319                                            return gmc; }
2320    
2321    // filter mask of all blocks
2322    
2323          if (!(MotionFlags & PMV_HALFPEL16)) {          for (my = 1; my < (uint32_t)MBh-1; my++)
2324                  Data.min_dx = EVEN(Data.min_dx);          for (mx = 1; mx < (uint32_t)MBw-1; mx++)
2325                  Data.max_dx = EVEN(Data.max_dx);          {
2326                  Data.min_dy = EVEN(Data.min_dy);                  const int mbnum = mx + my * MBw;
2327                  Data.max_dy = EVEN(Data.max_dy);                  const MACROBLOCK *pMB = &pMBs[mbnum];
2328                    const VECTOR mv = pMB->mvs[0];
2329    
2330                    if (pMB->mode == MODE_INTRA || pMB->mode == MODE_NOT_CODED)
2331                            continue;
2332    
2333                    if ( ( (ABS(mv.x -   (pMB-1)->mvs[0].x) < deltax) && (ABS(mv.y -   (pMB-1)->mvs[0].y) < deltay) )
2334                    &&   ( (ABS(mv.x -   (pMB+1)->mvs[0].x) < deltax) && (ABS(mv.y -   (pMB+1)->mvs[0].y) < deltay) )
2335                    &&   ( (ABS(mv.x - (pMB-MBw)->mvs[0].x) < deltax) && (ABS(mv.y - (pMB-MBw)->mvs[0].y) < deltay) )
2336                    &&   ( (ABS(mv.x - (pMB+MBw)->mvs[0].x) < deltax) && (ABS(mv.y - (pMB+MBw)->mvs[0].y) < deltay) ) )
2337                            MBmask[mbnum]=1;
2338          }          }
2339    
2340          for(i = 0; i < 5; i++) iMinSAD[i] = MV_MAX_ERROR;          for (my = 1; my < (uint32_t)MBh-1; my++)
2341            for (mx = 1; mx < (uint32_t)MBw-1; mx++)
2342            {
2343                    const uint8_t *const pCur = current->image.y + 16*my*pParam->edged_width + 16*mx;
2344    
2345          if (pMB->dquant != NO_CHANGE) inter4v = 0;                  const int mbnum = mx + my * MBw;
2346                    if (!MBmask[mbnum])
2347                            continue;
2348    
2349          if (inter4v)                  if (sad16 ( pCur, pCur+1 , pParam->edged_width, 65536) <= (uint32_t)grad )
2350                  CheckCandidate = CheckCandidate16;                          MBmask[mbnum] = 0;
2351          else CheckCandidate = CheckCandidate16no4v;                  if (sad16 ( pCur, pCur+pParam->edged_width, pParam->edged_width, 65536) <= (uint32_t)grad )
2352                            MBmask[mbnum] = 0;
2353    
2354            }
2355    
2356          pMB->mvs[0].x = EVEN(pMB->mvs[0].x);          emms();
         pMB->mvs[0].y = EVEN(pMB->mvs[0].y);  
         if (pMB->mvs[0].x > Data.max_dx) pMB->mvs[0].x = Data.max_dx; // this is in case iFcode changed  
         if (pMB->mvs[0].x < Data.min_dx) pMB->mvs[0].x = Data.min_dx;  
         if (pMB->mvs[0].y > Data.max_dy) pMB->mvs[0].y = Data.max_dy;  
         if (pMB->mvs[0].y < Data.min_dy) pMB->mvs[0].y = Data.min_dy;  
   
         CheckCandidate16(pMB->mvs[0].x, pMB->mvs[0].y, 0, &i, &Data);  
   
         if (pMB->mode == MODE_INTER4V)  
                 for (i = 1; i < 4; i++) { // all four vectors will be used as four predictions for 16x16 search  
                         pMB->mvs[i].x = EVEN(pMB->mvs[i].x);  
                         pMB->mvs[i].y = EVEN(pMB->mvs[i].y);  
                         if (!(make_mask(pMB->mvs, i)))  
                                 CheckCandidate16(pMB->mvs[i].x, pMB->mvs[i].y, 0, &i, &Data);  
                 }  
   
         if (MotionFlags & PMV_USESQUARES16)  
                 MainSearchPtr = SquareSearch;  
         else if (MotionFlags & PMV_ADVANCEDDIAMOND16)  
                 MainSearchPtr = AdvDiamondSearch;  
                 else MainSearchPtr = DiamondSearch;  
2357    
2358          (*MainSearchPtr)(currentMV->x, currentMV->y, &Data, 255);          do {            /* until convergence */
2359    
2360          if (MotionFlags & PMV_HALFPELREFINE16) HalfpelRefine(&Data);          a = b = c = n = 0;
2361            DtimesF[0] = DtimesF[1] = DtimesF[2] = DtimesF[3] = 0.;
2362            for (my = 0; my < (uint32_t)MBh; my++)
2363                    for (mx = 0; mx < (uint32_t)MBw; mx++)
2364                    {
2365                            const int mbnum = mx + my * MBw;
2366                            const MACROBLOCK *pMB = &pMBs[mbnum];
2367                            const VECTOR mv = pMB->mvs[0];
2368    
2369          if (inter4v)                          if (!MBmask[mbnum])
2370                  for(i = 0; i < 4; i++)                                  continue;
                         Search8hinted(&Data, 2*x+(i&1), 2*y+(i>>1), MotionFlags, pParam, pMB, pMBs, i);  
2371    
2372          if (!(inter4v) ||                          n++;
2373                  (iMinSAD[0] < iMinSAD[1] + iMinSAD[2] + iMinSAD[3] + iMinSAD[4] + IMV16X16 * (int32_t)iQuant )) {                          a += 16*mx+8;
2374  // INTER MODE                          b += 16*my+8;
2375                            c += (16*mx+8)*(16*mx+8)+(16*my+8)*(16*my+8);
2376    
2377                            DtimesF[0] += (double)mv.x;
2378                            DtimesF[1] += (double)mv.x*(16*mx+8) + (double)mv.y*(16*my+8);
2379                            DtimesF[2] += (double)mv.x*(16*my+8) - (double)mv.y*(16*mx+8);
2380                            DtimesF[3] += (double)mv.y;
2381                    }
2382    
2383            denom = a*a+b*b-c*n;
2384    
2385    /* Solve the system:     sol = (D'*E*D)^{-1} D'*E*F   */
2386    /* D'*E*F has been calculated in the same loop as matrix */
2387    
2388            sol[0] = -c*DtimesF[0] + a*DtimesF[1] + b*DtimesF[2];
2389            sol[1] =  a*DtimesF[0] - n*DtimesF[1]                + b*DtimesF[3];
2390            sol[2] =  b*DtimesF[0]                - n*DtimesF[2] - a*DtimesF[3];
2391            sol[3] =                 b*DtimesF[1] - a*DtimesF[2] - c*DtimesF[3];
2392    
2393            sol[0] /= denom;
2394            sol[1] /= denom;
2395            sol[2] /= denom;
2396            sol[3] /= denom;
2397    
2398            meanx = meany = 0.;
2399            oldnum = 0;
2400            for (my = 0; my < (uint32_t)MBh; my++)
2401                    for (mx = 0; mx < (uint32_t)MBw; mx++)
2402                    {
2403                            const int mbnum = mx + my * MBw;
2404                            const MACROBLOCK *pMB = &pMBs[mbnum];
2405                            const VECTOR mv = pMB->mvs[0];
2406    
2407                  pMB->mode = MODE_INTER;                          if (!MBmask[mbnum])
2408                  pMB->mvs[0] = pMB->mvs[1]                                  continue;
2409                          = pMB->mvs[2] = pMB->mvs[3] = currentMV[0];  
2410                            oldnum++;
2411                            meanx += ABS(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - mv.x );
2412                            meany += ABS(( sol[3] - (16*mx+8)*sol[2] + (16*my+8)*sol[1] ) - mv.y );
2413                    }
2414    
2415            if (4*meanx > oldnum)   /* better fit than 0.25 is useless */
2416                    meanx /= oldnum;
2417            else
2418                    meanx = 0.25;
2419    
2420            if (4*meany > oldnum)
2421                    meany /= oldnum;
2422            else
2423                    meany = 0.25;
2424    
2425    /*      fprintf(stderr,"sol = (%8.5f, %8.5f, %8.5f, %8.5f)\n",sol[0],sol[1],sol[2],sol[3]);
2426            fprintf(stderr,"meanx = %8.5f  meany = %8.5f   %d\n",meanx,meany, oldnum);
2427    */
2428            num = 0;
2429            for (my = 0; my < (uint32_t)MBh; my++)
2430                    for (mx = 0; mx < (uint32_t)MBw; mx++)
2431                    {
2432                            const int mbnum = mx + my * MBw;
2433                            const MACROBLOCK *pMB = &pMBs[mbnum];
2434                            const VECTOR mv = pMB->mvs[0];
2435    
2436                  pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] =                          if (!MBmask[mbnum])
2437                          pMB->sad8[2] = pMB->sad8[3] =  iMinSAD[0];                                  continue;
2438    
2439                            if  ( ( ABS(( sol[0] + (16*mx+8)*sol[1] + (16*my+8)*sol[2] ) - mv.x ) > meanx )
2440                               || ( ABS(( sol[3] - (16*mx+8)*sol[2] + (16*my+8)*sol[1] ) - mv.y ) > meany ) )
2441                                    MBmask[mbnum]=0;
2442                            else
2443                                    num++;
2444                    }
2445    
2446                  pMB->pmvs[0].x = currentMV[0].x - Data.predMV.x;          } while ( (oldnum != num) && (num>=4) );
2447                  pMB->pmvs[0].y = currentMV[0].y - Data.predMV.y;  
2448            if (num < 4)
2449            {
2450                    gmc.duv[0].x= gmc.duv[0].y= gmc.duv[1].x= gmc.duv[1].y= gmc.duv[2].x= gmc.duv[2].y=0;
2451          } else {          } else {
2452  // INTER4V MODE; all other things are already set in Search8hinted  
2453                  pMB->mode = MODE_INTER4V;                  gmc.duv[0].x=(int)(sol[0]+0.5);
2454                  pMB->sad16 = iMinSAD[1] + iMinSAD[2] + iMinSAD[3] + iMinSAD[4] + IMV16X16 * iQuant;                  gmc.duv[0].y=(int)(sol[3]+0.5);
2455    
2456                    gmc.duv[1].x=(int)(sol[1]*pParam->width+0.5);
2457                    gmc.duv[1].y=(int)(-sol[2]*pParam->width+0.5);
2458    
2459                    gmc.duv[2].x=0;
2460                    gmc.duv[2].y=0;
2461          }          }
2462    //      fprintf(stderr,"wp1 = ( %4d, %4d)  wp2 = ( %4d, %4d) \n", gmc.duv[0].x, gmc.duv[0].y, gmc.duv[1].x, gmc.duv[1].y);
2463    
2464            free(MBmask);
2465    
2466            return gmc;
2467  }  }
2468    
2469  void  // functions which perform BITS-based search/bitcount
2470  MotionEstimationHinted( MBParam * const pParam,  
2471                                                  FRAMEINFO * const current,  static int
2472                                                  FRAMEINFO * const reference,  CountMBBitsInter(SearchData * const Data,
2473                                                  const IMAGE * const pRefH,                                  const MACROBLOCK * const pMBs, const int x, const int y,
2474                                                  const IMAGE * const pRefV,                                  const MBParam * const pParam,
2475                                                  const IMAGE * const pRefHV)                                  const uint32_t MotionFlags)
2476  {  {
2477          MACROBLOCK *const pMBs = current->mbs;          int i, iDirection;
2478          const IMAGE *const pCurrent = &current->image;          int32_t bsad[5];
         const IMAGE *const pRef = &reference->image;  
2479    
2480          uint32_t x, y;          CheckCandidate = CheckCandidateBits16;
2481    
2482          if (sadInit) (*sadInit) ();          if (Data->qpel) {
2483                    for(i = 0; i < 5; i++) {
2484                            Data->currentMV[i].x = Data->currentQMV[i].x/2;
2485                            Data->currentMV[i].y = Data->currentQMV[i].y/2;
2486                    }
2487                    Data->qpel_precision = 1;
2488                    CheckCandidateBits16(Data->currentQMV[0].x, Data->currentQMV[0].y, 255, &iDirection, Data);
2489    
2490          for (y = 0; y < pParam->mb_height; y++) {                  //checking if this vector is perfect. if it is, we stop.
2491                  for (x = 0; x < pParam->mb_width; x++)  {                  if (Data->temp[0] == 0 && Data->temp[1] == 0 && Data->temp[2] == 0 && Data->temp[3] == 0)
2492                            return 0; //quick stop
2493    
2494                          MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];                  if (MotionFlags & (XVID_ME_HALFPELREFINE16_BITS | XVID_ME_EXTSEARCH_BITS)) { //we have to prepare for halfpixel-precision search
2495                            for(i = 0; i < 5; i++) bsad[i] = Data->iMinSAD[i];
2496                            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2497                                                    pParam->width, pParam->height, Data->iFcode - Data->qpel, 0, Data->rrv);
2498                            Data->qpel_precision = 0;
2499                            if (Data->currentQMV->x & 1 || Data->currentQMV->y & 1)
2500                                    CheckCandidateBits16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);
2501                    }
2502    
2503            } else { // not qpel
2504    
2505                    CheckCandidateBits16(Data->currentMV[0].x, Data->currentMV[0].y, 255, &iDirection, Data);
2506                    //checking if this vector is perfect. if it is, we stop.
2507                    if (Data->temp[0] == 0 && Data->temp[1] == 0 && Data->temp[2] == 0 && Data->temp[3] == 0) {
2508                            return 0; //inter
2509                    }
2510            }
2511    
2512            if (MotionFlags&XVID_ME_EXTSEARCH_BITS) SquareSearch(Data->currentMV->x, Data->currentMV->y, Data, iDirection);
2513    
2514  //intra mode is copied from the first pass. At least for the time being          if (MotionFlags&XVID_ME_HALFPELREFINE16_BITS) SubpelRefine(Data);
                         if  ((pMB->mode == MODE_INTRA) || (pMB->mode == MODE_NOT_CODED) ) continue;  
2515    
2516                          if (!(current->global_flags & XVID_LUMIMASKING)) {          if (Data->qpel) {
2517                                  pMB->dquant = NO_CHANGE;                  if (MotionFlags&(XVID_ME_EXTSEARCH_BITS | XVID_ME_HALFPELREFINE16_BITS)) { // there was halfpel-precision search
2518                                  pMB->quant = current->quant; }                          for(i = 0; i < 5; i++) if (bsad[i] > Data->iMinSAD[i]) {
2519                                    Data->currentQMV[i].x = 2 * Data->currentMV[i].x; // we have found a better match
2520                          SearchPhinted(pRef->y, pRefH->y, pRefV->y, pRefHV->y, pCurrent, x,                                  Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
2521                                                          y, current->motion_flags, pMB->quant,                          }
                                                         current->fcode, pParam, pMBs,  
                                                         current->global_flags & XVID_INTER4V, pMB);  
2522    
2523                            // preparing for qpel-precision search
2524                            Data->qpel_precision = 1;
2525                            get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 16,
2526                                            pParam->width, pParam->height, Data->iFcode, 1, 0);
2527                    }
2528                    if (MotionFlags&XVID_ME_QUARTERPELREFINE16_BITS) SubpelRefine(Data);
2529                  }                  }
2530    
2531            if (MotionFlags&XVID_ME_CHECKPREDICTION_BITS) { //let's check vector equal to prediction
2532                    VECTOR * v = Data->qpel ? Data->currentQMV : Data->currentMV;
2533                    if (!(Data->predMV.x == v->x && Data->predMV.y == v->y))
2534                            CheckCandidateBits16(Data->predMV.x, Data->predMV.y, 255, &iDirection, Data);
2535          }          }
2536            return Data->iMinSAD[0];
2537  }  }
2538    
2539  static __inline int  
2540  MEanalyzeMB (   const uint8_t * const pRef,  static int
2541                                  const uint8_t * const pCur,  CountMBBitsInter4v(const SearchData * const Data,
2542                                  const int x,                                          MACROBLOCK * const pMB, const MACROBLOCK * const pMBs,
2543                                  const int y,                                          const int x, const int y,
2544                                  const uint32_t iFcode,                                          const MBParam * const pParam, const uint32_t MotionFlags,
2545                                  const MBParam * const pParam,                                          const VECTOR * const backup)
                                 const MACROBLOCK * const pMBs,  
                                 MACROBLOCK * const pMB)  
2546  {  {
2547    
2548          const int32_t iEdgedWidth = pParam->edged_width;          int cbp = 0, bits = 0, t = 0, i, iDirection;
2549          int i, mask;          SearchData Data2, *Data8 = &Data2;
2550          VECTOR currentMV, pmv[3];          int sumx = 0, sumy = 0;
2551          int32_t iMinSAD = MV_MAX_ERROR;          int16_t in[64], coeff[64];
2552          SearchData Data;  
2553            memcpy(Data8, Data, sizeof(SearchData));
2554            CheckCandidate = CheckCandidateBits8;
2555    
2556            for (i = 0; i < 4; i++) {
2557                    Data8->iMinSAD = Data->iMinSAD + i + 1;
2558                    Data8->currentMV = Data->currentMV + i + 1;
2559                    Data8->currentQMV = Data->currentQMV + i + 1;
2560                    Data8->Cur = Data->Cur + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2561                    Data8->Ref = Data->Ref + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2562                    Data8->RefH = Data->RefH + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2563                    Data8->RefV = Data->RefV + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2564                    Data8->RefHV = Data->RefHV + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2565    
2566                    if(Data->qpel) {
2567                            Data8->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, i);
2568                            if (i != 0)     t = d_mv_bits(  Data8->currentQMV->x, Data8->currentQMV->y,
2569                                                                                    Data8->predMV, Data8->iFcode, 0, 0);
2570                    } else {
2571                            Data8->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, i);
2572                            if (i != 0)     t = d_mv_bits(  Data8->currentMV->x, Data8->currentMV->y,
2573                                                                                    Data8->predMV, Data8->iFcode, 0, 0);
2574                    }
2575    
2576          Data.predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0);                  get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 8,
2577          get_range(&Data.min_dx, &Data.max_dx, &Data.min_dy, &Data.max_dy, x, y, 16,                                          pParam->width, pParam->height, Data8->iFcode, Data8->qpel, 0);
                                 pParam->width, pParam->height, iFcode);  
2578    
2579          Data.Cur = pCur + (x + y * iEdgedWidth) * 16;                  *Data8->iMinSAD += t;
         Data.iEdgedWidth = iEdgedWidth;  
         Data.currentMV = &currentMV;  
         Data.iMinSAD = &iMinSAD;  
         Data.Ref = pRef + (x + iEdgedWidth*y)*16;  
         Data.iQuant = 2;  
         Data.iFcode = iFcode;  
2580    
2581          CheckCandidate = CheckCandidate16no4vI;                  Data8->qpel_precision = Data8->qpel;
2582                    // checking the vector which has been found by SAD-based 8x8 search (if it's different than the one found so far)
2583                    if (Data8->qpel) {
2584                            if (!(Data8->currentQMV->x == backup[i+1].x && Data8->currentQMV->y == backup[i+1].y))
2585                                    CheckCandidateBits8(backup[i+1].x, backup[i+1].y, 255, &iDirection, Data8);
2586                    } else {
2587                            if (!(Data8->currentMV->x == backup[i+1].x && Data8->currentMV->y == backup[i+1].y))
2588                                    CheckCandidateBits8(backup[i+1].x, backup[i+1].y, 255, &iDirection, Data8);
2589                    }
2590    
2591          pmv[1].x = EVEN(pMB->mvs[0].x);                  if (Data8->qpel) {
2592          pmv[1].y = EVEN(pMB->mvs[0].y);                          if (MotionFlags&XVID_ME_HALFPELREFINE8_BITS || (MotionFlags&XVID_ME_EXTSEARCH8 && MotionFlags&XVID_ME_EXTSEARCH_BITS)) { // halfpixel motion search follows
2593          pmv[0].x = EVEN(Data.predMV.x);                                  int32_t s = *Data8->iMinSAD;
2594          pmv[0].y = EVEN(Data.predMV.y);                                  Data8->currentMV->x = Data8->currentQMV->x/2;
2595          pmv[2].x = pmv[2].y = 0;                                  Data8->currentMV->y = Data8->currentQMV->y/2;
2596                                    Data8->qpel_precision = 0;
2597                                    get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 8,
2598                                                            pParam->width, pParam->height, Data8->iFcode - 1, 0, 0);
2599    
2600          CheckCandidate16no4vI(pmv[0].x, pmv[0].y, 255, &i, &Data);                                  if (Data8->currentQMV->x & 1 || Data8->currentQMV->y & 1)
2601          if (!(mask = make_mask(pmv, 1)))                                          CheckCandidateBits8(Data8->currentMV->x, Data8->currentMV->y, 255, &iDirection, Data8);
                 CheckCandidate16no4vI(pmv[1].x, pmv[1].y, mask, &i, &Data);  
         if (!(mask = make_mask(pmv, 2)))  
                 CheckCandidate16no4vI(0, 0, mask, &i, &Data);  
2602    
2603          DiamondSearch(currentMV.x, currentMV.y, &Data, i);                                  if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_BITS)
2604                                            SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255);
2605    
2606          pMB->mvs[0] = pMB->mvs[1]                                  if (MotionFlags & XVID_ME_HALFPELREFINE8_BITS) SubpelRefine(Data8);
                         = pMB->mvs[2] = pMB->mvs[3] = currentMV; // all, for future get_pmv()  
2607    
2608          return iMinSAD;                                  if(s > *Data8->iMinSAD) { //we have found a better match
2609                                            Data8->currentQMV->x = 2*Data8->currentMV->x;
2610                                            Data8->currentQMV->y = 2*Data8->currentMV->y;
2611  }  }
2612    
2613  #define INTRA_THRESH    1350                                  Data8->qpel_precision = 1;
2614  #define INTER_THRESH    900                                  get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 8,
2615                                                            pParam->width, pParam->height, Data8->iFcode, 1, 0);
2616    
2617  int                          }
2618  MEanalysis(     const IMAGE * const pRef,                          if (MotionFlags & XVID_ME_QUARTERPELREFINE8_BITS) SubpelRefine(Data8);
                         const IMAGE * const pCurrent,  
                         MBParam * const pParam,  
                         MACROBLOCK * const pMBs,  
                         const uint32_t iFcode)  
 {  
         uint32_t x, y, intra = 0;  
         int sSAD = 0;  
2619    
2620          if (sadInit) (*sadInit) ();                  } else // not qpel
2621                            if (MotionFlags & XVID_ME_HALFPELREFINE8_BITS) SubpelRefine(Data8); //halfpel mode, halfpel refinement
2622    
2623          for (y = 0; y < pParam->mb_height-1; y++) {                  //checking vector equal to predicion
2624                  for (x = 0; x < pParam->mb_width; x++) {                  if (i != 0 && MotionFlags & XVID_ME_CHECKPREDICTION_BITS) {
2625                          int sad, dev;                          const VECTOR * v = Data->qpel ? Data8->currentQMV : Data8->currentMV;
2626                            if (!(Data8->predMV.x == v->x && Data8->predMV.y == v->y))
2627                                    CheckCandidateBits8(Data8->predMV.x, Data8->predMV.y, 255, &iDirection, Data8);
2628                    }
2629    
2630                          MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];                  bits += *Data8->iMinSAD;
2631                    if (bits >= Data->iMinSAD[0]) break; // no chances for INTER4V
2632    
2633                          sad = MEanalyzeMB(pRef->y, pCurrent->y, x, y,                  // MB structures for INTER4V mode; we have to set them here, we don't have predictor anywhere else
2634                                                                  iFcode, pParam, pMBs, pMB);                  if(Data->qpel) {
2635                            pMB->pmvs[i].x = Data8->currentQMV->x - Data8->predMV.x;
2636                            pMB->pmvs[i].y = Data8->currentQMV->y - Data8->predMV.y;
2637                            pMB->qmvs[i] = *Data8->currentQMV;
2638                            sumx += Data8->currentQMV->x/2;
2639                            sumy += Data8->currentQMV->y/2;
2640                    } else {
2641                            pMB->pmvs[i].x = Data8->currentMV->x - Data8->predMV.x;
2642                            pMB->pmvs[i].y = Data8->currentMV->y - Data8->predMV.y;
2643                            sumx += Data8->currentMV->x;
2644                            sumy += Data8->currentMV->y;
2645                    }
2646                    pMB->mvs[i] = *Data8->currentMV;
2647                    pMB->sad8[i] = 4 * *Data8->iMinSAD;
2648                    if (Data8->temp[0]) cbp |= 1 << (5 - i);
2649            }
2650    
2651            if (bits < *Data->iMinSAD) { // there is still a chance for inter4v mode. let's check chroma
2652                    const uint8_t * ptr;
2653                    sumx = (sumx >> 3) + roundtab_76[sumx & 0xf];
2654                    sumy = (sumy >> 3) + roundtab_76[sumy & 0xf];
2655    
2656                    //chroma U
2657                    ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefCU, 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
2658                    transfer_8to16subro(in, Data->CurU, ptr, Data->iEdgedWidth/2);
2659                    fdct(in);
2660                    if (Data->lambda8 == 0) i = quant_inter(coeff, in, Data->lambda16);
2661                    else i = quant4_inter(coeff, in, Data->lambda16);
2662                    if (i > 0) {
2663                            bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
2664                            cbp |= 1 << (5 - 4);
2665                    }
2666    
2667                    if (bits < *Data->iMinSAD) { // still possible
2668                            //chroma V
2669                            ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefCV, 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
2670                            transfer_8to16subro(in, Data->CurV, ptr, Data->iEdgedWidth/2);
2671                            fdct(in);
2672                            if (Data->lambda8 == 0) i = quant_inter(coeff, in, Data->lambda16);
2673                            else i = quant4_inter(coeff, in, Data->lambda16);
2674                            if (i > 0) {
2675                                    bits += CodeCoeffInter_CalcBits(coeff, scan_tables[0]);
2676                                    cbp |= 1 << (5 - 5);
2677                            }
2678                            bits += cbpy_tab[15-(cbp>>2)].len;
2679                            bits += mcbpc_inter_tab[(MODE_INTER4V & 7) | ((cbp & 3) << 3)].len;
2680                    }
2681            }
2682    
2683            return bits;
2684    }
2685    
2686    
2687    static int
2688    CountMBBitsIntra(const SearchData * const Data)
2689    {
2690            int bits = 1; //this one is ac/dc prediction flag. always 1.
2691            int cbp = 0, i, t, dc = 0, b_dc = 1024;
2692            const uint32_t iQuant = Data->lambda16;
2693            int16_t in[64], coeff[64];
2694    
2695            for(i = 0; i < 4; i++) {
2696                    uint32_t iDcScaler = get_dc_scaler(iQuant, 1);
2697    
2698                    int s = 8*((i&1) + (i>>1)*Data->iEdgedWidth);
2699                    transfer_8to16copy(in, Data->Cur + s, Data->iEdgedWidth);
2700                    fdct(in);
2701                    b_dc = dc;
2702                    dc = in[0];
2703                    in[0] -= b_dc;
2704                    if (Data->lambda8 == 0) quant_intra_c(coeff, in, iQuant, iDcScaler);
2705                    else quant4_intra_c(coeff, in, iQuant, iDcScaler);
2706    
2707                    b_dc = dc;
2708                    dc = coeff[0];
2709                    if (i != 0) coeff[0] -= b_dc;
2710    
2711                    bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcy_tab[coeff[0] + 255].len;;
2712                    Data->temp[i] = t;
2713                    if (t != 0)  cbp |= 1 << (5 - i);
2714                    if (bits >= Data->iMinSAD[0]) break;
2715            }
2716    
2717            if (bits < Data->iMinSAD[0]) { // INTRA still looks good, let's add chroma
2718                    uint32_t iDcScaler = get_dc_scaler(iQuant, 0);
2719                    //chroma U
2720                    transfer_8to16copy(in, Data->CurU, Data->iEdgedWidth/2);
2721                    fdct(in);
2722                    in[0] -= 1024;
2723                    if (Data->lambda8 == 0) quant_intra(coeff, in, iQuant, iDcScaler);
2724                    else quant4_intra(coeff, in, iQuant, iDcScaler);
2725    
2726                    bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len;
2727                    if (t != 0) cbp |= 1 << (5 - 4);
2728    
2729                    if (bits < Data->iMinSAD[0]) {
2730                            iDcScaler = get_dc_scaler(iQuant, 1);
2731                            //chroma V
2732                            transfer_8to16copy(in, Data->CurV, Data->iEdgedWidth/2);
2733                            fdct(in);
2734                            in[0] -= 1024;
2735                            if (Data->lambda8 == 0) quant_intra(coeff, in, iQuant, iDcScaler);
2736                            else quant4_intra(coeff, in, iQuant, iDcScaler);
2737    
2738                          if ( x != 0 && y != 0 && x != pParam->mb_width-1 ) { //no edge macroblocks, they just don't work                          bits += t = CodeCoeffIntra_CalcBits(coeff, scan_tables[0]) + dcc_tab[coeff[0] + 255].len;
2739                                  if (sad > INTRA_THRESH) {                          if (t != 0) cbp |= 1 << (5 - 5);
                                         dev = dev16(pCurrent->y + (x + y * pParam->edged_width) * 16,  
                                                                   pParam->edged_width);  
                                         if (dev + INTRA_THRESH < sad) intra++;  
                                         if (intra > (pParam->mb_height-2)*(pParam->mb_width-2)/2) return 2;  // I frame  
                                 }  
                                 sSAD += sad;  
                         }  
2740    
2741                            bits += cbpy_tab[cbp>>2].len;
2742                            bits += mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp & 3) << 3)].len;
2743                  }                  }
2744          }          }
2745          sSAD /= (pParam->mb_height-2)*(pParam->mb_width-2);          return bits;
         if (sSAD > INTER_THRESH ) return 1; //P frame  
         emms();  
         return 0; // B frame  
   
2746  }  }
Legend:
Removed from v.1.44.2.2  
changed lines
  Added in v.1.58.2.4
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4