user specified motion estimation range limit
[ffmpeg.git] / libavcodec / motion_est.c
1 /*
2  * Motion estimation 
3  * Copyright (c) 2000,2001 Fabrice Bellard.
4  * Copyright (c) 2002-2003 Michael Niedermayer
5  * 
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  * new Motion Estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at>
22  */
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include "avcodec.h"
26 #include "dsputil.h"
27 #include "mpegvideo.h"
28
29 //#undef NDEBUG
30 //#include <assert.h>
31
32 #define SQ(a) ((a)*(a))
33
34 #define P_LEFT P[1]
35 #define P_TOP P[2]
36 #define P_TOPRIGHT P[3]
37 #define P_MEDIAN P[4]
38 #define P_MV1 P[9]
39
40 static inline int sad_hpel_motion_search(MpegEncContext * s,
41                                   int *mx_ptr, int *my_ptr, int dmin,
42                                   int xmin, int ymin, int xmax, int ymax,
43                                   int pred_x, int pred_y, Picture *picture,
44                                   int n, int size, uint16_t * const mv_penalty);
45
46 static inline int update_map_generation(MpegEncContext * s)
47 {
48     s->me.map_generation+= 1<<(ME_MAP_MV_BITS*2);
49     if(s->me.map_generation==0){
50         s->me.map_generation= 1<<(ME_MAP_MV_BITS*2);
51         memset(s->me.map, 0, sizeof(uint32_t)*ME_MAP_SIZE);
52     }
53     return s->me.map_generation;
54 }
55
56 /* shape adaptive search stuff */
57 typedef struct Minima{
58     int height;
59     int x, y;
60     int checked;
61 }Minima;
62
63 static int minima_cmp(const void *a, const void *b){
64     const Minima *da = (const Minima *) a;
65     const Minima *db = (const Minima *) b;
66     
67     return da->height - db->height;
68 }
69                                   
70 /* SIMPLE */
71 #define RENAME(a) simple_ ## a
72
73 #define CMP(d, x, y, size)\
74 d = cmp(s, src_y, (ref_y) + (x) + (y)*(stride), stride);
75
76 #define CMP_HPEL(d, dx, dy, x, y, size)\
77 {\
78     const int dxy= (dx) + 2*(dy);\
79     hpel_put[0][dxy](s->me.scratchpad, (ref_y) + (x) + (y)*(stride), stride, (16>>size));\
80     d = cmp_sub(s, s->me.scratchpad, src_y, stride);\
81 }
82
83 #define CMP_QPEL(d, dx, dy, x, y, size)\
84 {\
85     const int dxy= (dx) + 4*(dy);\
86     qpel_put[0][dxy](s->me.scratchpad, (ref_y) + (x) + (y)*(stride), stride);\
87     d = cmp_sub(s, s->me.scratchpad, src_y, stride);\
88 }
89
90 #include "motion_est_template.c"
91 #undef RENAME
92 #undef CMP
93 #undef CMP_HPEL
94 #undef CMP_QPEL
95 #undef INIT
96
97 /* SIMPLE CHROMA */
98 #define RENAME(a) simple_chroma_ ## a
99
100 #define CMP(d, x, y, size)\
101 d = cmp(s, src_y, (ref_y) + (x) + (y)*(stride), stride);\
102 if(chroma_cmp){\
103     int dxy= ((x)&1) + 2*((y)&1);\
104     int c= ((x)>>1) + ((y)>>1)*uvstride;\
105 \
106     chroma_hpel_put[0][dxy](s->me.scratchpad, ref_u + c, uvstride, 8);\
107     d += chroma_cmp(s, s->me.scratchpad, src_u, uvstride);\
108     chroma_hpel_put[0][dxy](s->me.scratchpad, ref_v + c, uvstride, 8);\
109     d += chroma_cmp(s, s->me.scratchpad, src_v, uvstride);\
110 }
111
112 #define CMP_HPEL(d, dx, dy, x, y, size)\
113 {\
114     const int dxy= (dx) + 2*(dy);\
115     hpel_put[0][dxy](s->me.scratchpad, (ref_y) + (x) + (y)*(stride), stride, (16>>size));\
116     d = cmp_sub(s, s->me.scratchpad, src_y, stride);\
117     if(chroma_cmp_sub){\
118         int cxy= (dxy) | ((x)&1) | (2*((y)&1));\
119         int c= ((x)>>1) + ((y)>>1)*uvstride;\
120         chroma_hpel_put[0][cxy](s->me.scratchpad, ref_u + c, uvstride, 8);\
121         d += chroma_cmp_sub(s, s->me.scratchpad, src_u, uvstride);\
122         chroma_hpel_put[0][cxy](s->me.scratchpad, ref_v + c, uvstride, 8);\
123         d += chroma_cmp_sub(s, s->me.scratchpad, src_v, uvstride);\
124     }\
125 }
126
127 #define CMP_QPEL(d, dx, dy, x, y, size)\
128 {\
129     const int dxy= (dx) + 4*(dy);\
130     qpel_put[0][dxy](s->me.scratchpad, (ref_y) + (x) + (y)*(stride), stride);\
131     d = cmp_sub(s, s->me.scratchpad, src_y, stride);\
132     if(chroma_cmp_sub){\
133         int cxy, c;\
134         int cx= (4*(x) + (dx))/2;\
135         int cy= (4*(y) + (dy))/2;\
136         cx= (cx>>1)|(cx&1);\
137         cy= (cy>>1)|(cy&1);\
138         cxy= (cx&1) + 2*(cy&1);\
139         c= ((cx)>>1) + ((cy)>>1)*uvstride;\
140         chroma_hpel_put[0][cxy](s->me.scratchpad, ref_u + c, uvstride, 8);\
141         d += chroma_cmp_sub(s, s->me.scratchpad, src_u, uvstride);\
142         chroma_hpel_put[0][cxy](s->me.scratchpad, ref_v + c, uvstride, 8);\
143         d += chroma_cmp_sub(s, s->me.scratchpad, src_v, uvstride);\
144     }\
145 }
146
147 #include "motion_est_template.c"
148 #undef RENAME
149 #undef CMP
150 #undef CMP_HPEL
151 #undef CMP_QPEL
152 #undef INIT
153
154 /* SIMPLE DIRECT HPEL */
155 #define RENAME(a) simple_direct_hpel_ ## a
156 //FIXME precalc divisions stuff
157
158 #define CMP_DIRECT(d, dx, dy, x, y, size, cmp_func)\
159 if((x) >= xmin && 2*(x) + (dx) <= 2*xmax && (y) >= ymin && 2*(y) + (dy) <= 2*ymax){\
160     const int hx= 2*(x) + (dx);\
161     const int hy= 2*(y) + (dy);\
162     if(s->mv_type==MV_TYPE_8X8){\
163         int i;\
164         for(i=0; i<4; i++){\
165             int fx = s->me.direct_basis_mv[i][0] + hx;\
166             int fy = s->me.direct_basis_mv[i][1] + hy;\
167             int bx = hx ? fx - s->me.co_located_mv[i][0] : s->me.co_located_mv[i][0]*(time_pb - time_pp)/time_pp + (i &1)*16;\
168             int by = hy ? fy - s->me.co_located_mv[i][1] : s->me.co_located_mv[i][1]*(time_pb - time_pp)/time_pp + (i>>1)*16;\
169             int fxy= (fx&1) + 2*(fy&1);\
170             int bxy= (bx&1) + 2*(by&1);\
171 \
172             uint8_t *dst= s->me.scratchpad + 8*(i&1) + 8*stride*(i>>1);\
173             hpel_put[1][fxy](dst, (ref_y ) + (fx>>1) + (fy>>1)*(stride), stride, 8);\
174             hpel_avg[1][bxy](dst, (ref2_y) + (bx>>1) + (by>>1)*(stride), stride, 8);\
175         }\
176     }else{\
177         int fx = s->me.direct_basis_mv[0][0] + hx;\
178         int fy = s->me.direct_basis_mv[0][1] + hy;\
179         int bx = hx ? fx - s->me.co_located_mv[0][0] : (s->me.co_located_mv[0][0]*(time_pb - time_pp)/time_pp);\
180         int by = hy ? fy - s->me.co_located_mv[0][1] : (s->me.co_located_mv[0][1]*(time_pb - time_pp)/time_pp);\
181         int fxy= (fx&1) + 2*(fy&1);\
182         int bxy= (bx&1) + 2*(by&1);\
183         \
184         assert((fx>>1) + 16*s->mb_x >= -16);\
185         assert((fy>>1) + 16*s->mb_y >= -16);\
186         assert((fx>>1) + 16*s->mb_x <= s->width);\
187         assert((fy>>1) + 16*s->mb_y <= s->height);\
188         assert((bx>>1) + 16*s->mb_x >= -16);\
189         assert((by>>1) + 16*s->mb_y >= -16);\
190         assert((bx>>1) + 16*s->mb_x <= s->width);\
191         assert((by>>1) + 16*s->mb_y <= s->height);\
192 \
193         hpel_put[0][fxy](s->me.scratchpad, (ref_y ) + (fx>>1) + (fy>>1)*(stride), stride, 16);\
194         hpel_avg[0][bxy](s->me.scratchpad, (ref2_y) + (bx>>1) + (by>>1)*(stride), stride, 16);\
195     }\
196     d = cmp_func(s, s->me.scratchpad, src_y, stride);\
197 }else\
198     d= 256*256*256*32;
199
200
201 #define CMP_HPEL(d, dx, dy, x, y, size)\
202     CMP_DIRECT(d, dx, dy, x, y, size, cmp_sub)
203
204 #define CMP(d, x, y, size)\
205     CMP_DIRECT(d, 0, 0, x, y, size, cmp)
206     
207 #include "motion_est_template.c"
208 #undef RENAME
209 #undef CMP
210 #undef CMP_HPEL
211 #undef CMP_QPEL
212 #undef INIT
213 #undef CMP_DIRECT
214
215 /* SIMPLE DIRECT QPEL */
216 #define RENAME(a) simple_direct_qpel_ ## a
217
218 #define CMP_DIRECT(d, dx, dy, x, y, size, cmp_func)\
219 if((x) >= xmin && 4*(x) + (dx) <= 4*xmax && (y) >= ymin && 4*(y) + (dy) <= 4*ymax){\
220     const int qx= 4*(x) + (dx);\
221     const int qy= 4*(y) + (dy);\
222     if(s->mv_type==MV_TYPE_8X8){\
223         int i;\
224         for(i=0; i<4; i++){\
225             int fx = s->me.direct_basis_mv[i][0] + qx;\
226             int fy = s->me.direct_basis_mv[i][1] + qy;\
227             int bx = qx ? fx - s->me.co_located_mv[i][0] : s->me.co_located_mv[i][0]*(time_pb - time_pp)/time_pp + (i &1)*16;\
228             int by = qy ? fy - s->me.co_located_mv[i][1] : s->me.co_located_mv[i][1]*(time_pb - time_pp)/time_pp + (i>>1)*16;\
229             int fxy= (fx&3) + 4*(fy&3);\
230             int bxy= (bx&3) + 4*(by&3);\
231 \
232             uint8_t *dst= s->me.scratchpad + 8*(i&1) + 8*stride*(i>>1);\
233             qpel_put[1][fxy](dst, (ref_y ) + (fx>>2) + (fy>>2)*(stride), stride);\
234             qpel_avg[1][bxy](dst, (ref2_y) + (bx>>2) + (by>>2)*(stride), stride);\
235         }\
236     }else{\
237         int fx = s->me.direct_basis_mv[0][0] + qx;\
238         int fy = s->me.direct_basis_mv[0][1] + qy;\
239         int bx = qx ? fx - s->me.co_located_mv[0][0] : s->me.co_located_mv[0][0]*(time_pb - time_pp)/time_pp;\
240         int by = qy ? fy - s->me.co_located_mv[0][1] : s->me.co_located_mv[0][1]*(time_pb - time_pp)/time_pp;\
241         int fxy= (fx&3) + 4*(fy&3);\
242         int bxy= (bx&3) + 4*(by&3);\
243 \
244         qpel_put[1][fxy](s->me.scratchpad               , (ref_y ) + (fx>>2) + (fy>>2)*(stride)               , stride);\
245         qpel_put[1][fxy](s->me.scratchpad + 8           , (ref_y ) + (fx>>2) + (fy>>2)*(stride) + 8           , stride);\
246         qpel_put[1][fxy](s->me.scratchpad     + 8*stride, (ref_y ) + (fx>>2) + (fy>>2)*(stride)     + 8*stride, stride);\
247         qpel_put[1][fxy](s->me.scratchpad + 8 + 8*stride, (ref_y ) + (fx>>2) + (fy>>2)*(stride) + 8 + 8*stride, stride);\
248         qpel_avg[1][bxy](s->me.scratchpad               , (ref2_y) + (bx>>2) + (by>>2)*(stride)               , stride);\
249         qpel_avg[1][bxy](s->me.scratchpad + 8           , (ref2_y) + (bx>>2) + (by>>2)*(stride) + 8           , stride);\
250         qpel_avg[1][bxy](s->me.scratchpad     + 8*stride, (ref2_y) + (bx>>2) + (by>>2)*(stride)     + 8*stride, stride);\
251         qpel_avg[1][bxy](s->me.scratchpad + 8 + 8*stride, (ref2_y) + (bx>>2) + (by>>2)*(stride) + 8 + 8*stride, stride);\
252     }\
253     d = cmp_func(s, s->me.scratchpad, src_y, stride);\
254 }else\
255     d= 256*256*256*32;
256
257
258 #define CMP_QPEL(d, dx, dy, x, y, size)\
259     CMP_DIRECT(d, dx, dy, x, y, size, cmp_sub)
260
261 #define CMP(d, x, y, size)\
262     CMP_DIRECT(d, 0, 0, x, y, size, cmp)
263
264 #include "motion_est_template.c"
265 #undef RENAME
266 #undef CMP
267 #undef CMP_HPEL
268 #undef CMP_QPEL
269 #undef INIT
270 #undef CMP__DIRECT
271
272
273 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride){
274     return 0;
275 }
276
277 static void set_cmp(MpegEncContext *s, me_cmp_func *cmp, int type){
278     DSPContext* c= &s->dsp;
279     int i;
280     
281     memset(cmp, 0, sizeof(void*)*11);
282
283     switch(type&0xFF){
284     case FF_CMP_SAD:
285         cmp[0]= c->sad[0];
286         cmp[1]= c->sad[1];
287         break;
288     case FF_CMP_SATD:
289         cmp[0]= c->hadamard8_diff[0];
290         cmp[1]= c->hadamard8_diff[1];
291         break;
292     case FF_CMP_SSE:
293         cmp[0]= c->sse[0];
294         cmp[1]= c->sse[1];
295         break;
296     case FF_CMP_DCT:
297         cmp[0]= c->dct_sad[0];
298         cmp[1]= c->dct_sad[1];
299         break;
300     case FF_CMP_PSNR:
301         cmp[0]= c->quant_psnr[0];
302         cmp[1]= c->quant_psnr[1];
303         break;
304     case FF_CMP_BIT:
305         cmp[0]= c->bit[0];
306         cmp[1]= c->bit[1];
307         break;
308     case FF_CMP_RD:
309         cmp[0]= c->rd[0];
310         cmp[1]= c->rd[1];
311         break;
312     case FF_CMP_ZERO:
313         for(i=0; i<7; i++){
314             cmp[i]= zero_cmp;
315         }
316         break;
317     default:
318         fprintf(stderr,"internal error in cmp function selection\n");
319     }
320 }
321
322 static inline int get_penalty_factor(MpegEncContext *s, int type){
323     switch(type&0xFF){
324     default:
325     case FF_CMP_SAD:
326         return s->qscale*2;
327     case FF_CMP_DCT:
328         return s->qscale*3;
329     case FF_CMP_SATD:
330         return s->qscale*6;
331     case FF_CMP_SSE:
332         return s->qscale*s->qscale*2;
333     case FF_CMP_BIT:
334         return 1;
335     case FF_CMP_RD:
336     case FF_CMP_PSNR:
337         return (s->qscale*s->qscale*185 + 64)>>7;
338     }
339 }
340
341 void ff_init_me(MpegEncContext *s){
342     set_cmp(s, s->dsp.me_pre_cmp, s->avctx->me_pre_cmp);
343     set_cmp(s, s->dsp.me_cmp, s->avctx->me_cmp);
344     set_cmp(s, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);
345     set_cmp(s, s->dsp.mb_cmp, s->avctx->mb_cmp);
346
347     if(s->flags&CODEC_FLAG_QPEL){
348         if(s->avctx->me_sub_cmp&FF_CMP_CHROMA)
349             s->me.sub_motion_search= simple_chroma_qpel_motion_search;
350         else
351             s->me.sub_motion_search= simple_qpel_motion_search;
352     }else{
353         if(s->avctx->me_sub_cmp&FF_CMP_CHROMA)
354             s->me.sub_motion_search= simple_chroma_hpel_motion_search;
355         else if(   s->avctx->me_sub_cmp == FF_CMP_SAD 
356                 && s->avctx->    me_cmp == FF_CMP_SAD 
357                 && s->avctx->    mb_cmp == FF_CMP_SAD)
358             s->me.sub_motion_search= sad_hpel_motion_search;
359         else
360             s->me.sub_motion_search= simple_hpel_motion_search;
361     }
362
363     if(s->avctx->me_cmp&FF_CMP_CHROMA){
364         s->me.motion_search[0]= simple_chroma_epzs_motion_search;
365         s->me.motion_search[1]= simple_chroma_epzs_motion_search4;
366     }else{
367         s->me.motion_search[0]= simple_epzs_motion_search;
368         s->me.motion_search[1]= simple_epzs_motion_search4;
369     }
370     
371     if(s->avctx->me_pre_cmp&FF_CMP_CHROMA){
372         s->me.pre_motion_search= simple_chroma_epzs_motion_search;
373     }else{
374         s->me.pre_motion_search= simple_epzs_motion_search;
375     }
376     
377     if(s->flags&CODEC_FLAG_QPEL){
378         if(s->avctx->mb_cmp&FF_CMP_CHROMA)
379             s->me.get_mb_score= simple_chroma_qpel_get_mb_score;
380         else
381             s->me.get_mb_score= simple_qpel_get_mb_score;
382     }else{
383         if(s->avctx->mb_cmp&FF_CMP_CHROMA)
384             s->me.get_mb_score= simple_chroma_hpel_get_mb_score;
385         else
386             s->me.get_mb_score= simple_hpel_get_mb_score;
387     }
388 }
389       
390 static int pix_dev(uint8_t * pix, int line_size, int mean)
391 {
392     int s, i, j;
393
394     s = 0;
395     for (i = 0; i < 16; i++) {
396         for (j = 0; j < 16; j += 8) {
397             s += ABS(pix[0]-mean);
398             s += ABS(pix[1]-mean);
399             s += ABS(pix[2]-mean);
400             s += ABS(pix[3]-mean);
401             s += ABS(pix[4]-mean);
402             s += ABS(pix[5]-mean);
403             s += ABS(pix[6]-mean);
404             s += ABS(pix[7]-mean);
405             pix += 8;
406         }
407         pix += line_size - 16;
408     }
409     return s;
410 }
411
412 static inline void no_motion_search(MpegEncContext * s,
413                                     int *mx_ptr, int *my_ptr)
414 {
415     *mx_ptr = 16 * s->mb_x;
416     *my_ptr = 16 * s->mb_y;
417 }
418
419 static int full_motion_search(MpegEncContext * s,
420                               int *mx_ptr, int *my_ptr, int range,
421                               int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
422 {
423     int x1, y1, x2, y2, xx, yy, x, y;
424     int mx, my, dmin, d;
425     uint8_t *pix;
426
427     xx = 16 * s->mb_x;
428     yy = 16 * s->mb_y;
429     x1 = xx - range + 1;        /* we loose one pixel to avoid boundary pb with half pixel pred */
430     if (x1 < xmin)
431         x1 = xmin;
432     x2 = xx + range - 1;
433     if (x2 > xmax)
434         x2 = xmax;
435     y1 = yy - range + 1;
436     if (y1 < ymin)
437         y1 = ymin;
438     y2 = yy + range - 1;
439     if (y2 > ymax)
440         y2 = ymax;
441     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
442     dmin = 0x7fffffff;
443     mx = 0;
444     my = 0;
445     for (y = y1; y <= y2; y++) {
446         for (x = x1; x <= x2; x++) {
447             d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x,
448                              s->linesize);
449             if (d < dmin ||
450                 (d == dmin &&
451                  (abs(x - xx) + abs(y - yy)) <
452                  (abs(mx - xx) + abs(my - yy)))) {
453                 dmin = d;
454                 mx = x;
455                 my = y;
456             }
457         }
458     }
459
460     *mx_ptr = mx;
461     *my_ptr = my;
462
463 #if 0
464     if (*mx_ptr < -(2 * range) || *mx_ptr >= (2 * range) ||
465         *my_ptr < -(2 * range) || *my_ptr >= (2 * range)) {
466         fprintf(stderr, "error %d %d\n", *mx_ptr, *my_ptr);
467     }
468 #endif
469     return dmin;
470 }
471
472
473 static int log_motion_search(MpegEncContext * s,
474                              int *mx_ptr, int *my_ptr, int range,
475                              int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
476 {
477     int x1, y1, x2, y2, xx, yy, x, y;
478     int mx, my, dmin, d;
479     uint8_t *pix;
480
481     xx = s->mb_x << 4;
482     yy = s->mb_y << 4;
483
484     /* Left limit */
485     x1 = xx - range;
486     if (x1 < xmin)
487         x1 = xmin;
488
489     /* Right limit */
490     x2 = xx + range;
491     if (x2 > xmax)
492         x2 = xmax;
493
494     /* Upper limit */
495     y1 = yy - range;
496     if (y1 < ymin)
497         y1 = ymin;
498
499     /* Lower limit */
500     y2 = yy + range;
501     if (y2 > ymax)
502         y2 = ymax;
503
504     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
505     dmin = 0x7fffffff;
506     mx = 0;
507     my = 0;
508
509     do {
510         for (y = y1; y <= y2; y += range) {
511             for (x = x1; x <= x2; x += range) {
512                 d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
513                 if (d < dmin || (d == dmin && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
514                     dmin = d;
515                     mx = x;
516                     my = y;
517                 }
518             }
519         }
520
521         range = range >> 1;
522
523         x1 = mx - range;
524         if (x1 < xmin)
525             x1 = xmin;
526
527         x2 = mx + range;
528         if (x2 > xmax)
529             x2 = xmax;
530
531         y1 = my - range;
532         if (y1 < ymin)
533             y1 = ymin;
534
535         y2 = my + range;
536         if (y2 > ymax)
537             y2 = ymax;
538
539     } while (range >= 1);
540
541 #ifdef DEBUG
542     fprintf(stderr, "log       - MX: %d\tMY: %d\n", mx, my);
543 #endif
544     *mx_ptr = mx;
545     *my_ptr = my;
546     return dmin;
547 }
548
549 static int phods_motion_search(MpegEncContext * s,
550                                int *mx_ptr, int *my_ptr, int range,
551                                int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
552 {
553     int x1, y1, x2, y2, xx, yy, x, y, lastx, d;
554     int mx, my, dminx, dminy;
555     uint8_t *pix;
556
557     xx = s->mb_x << 4;
558     yy = s->mb_y << 4;
559
560     /* Left limit */
561     x1 = xx - range;
562     if (x1 < xmin)
563         x1 = xmin;
564
565     /* Right limit */
566     x2 = xx + range;
567     if (x2 > xmax)
568         x2 = xmax;
569
570     /* Upper limit */
571     y1 = yy - range;
572     if (y1 < ymin)
573         y1 = ymin;
574
575     /* Lower limit */
576     y2 = yy + range;
577     if (y2 > ymax)
578         y2 = ymax;
579
580     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
581     mx = 0;
582     my = 0;
583
584     x = xx;
585     y = yy;
586     do {
587         dminx = 0x7fffffff;
588         dminy = 0x7fffffff;
589
590         lastx = x;
591         for (x = x1; x <= x2; x += range) {
592             d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
593             if (d < dminx || (d == dminx && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
594                 dminx = d;
595                 mx = x;
596             }
597         }
598
599         x = lastx;
600         for (y = y1; y <= y2; y += range) {
601             d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
602             if (d < dminy || (d == dminy && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
603                 dminy = d;
604                 my = y;
605             }
606         }
607
608         range = range >> 1;
609
610         x = mx;
611         y = my;
612         x1 = mx - range;
613         if (x1 < xmin)
614             x1 = xmin;
615
616         x2 = mx + range;
617         if (x2 > xmax)
618             x2 = xmax;
619
620         y1 = my - range;
621         if (y1 < ymin)
622             y1 = ymin;
623
624         y2 = my + range;
625         if (y2 > ymax)
626             y2 = ymax;
627
628     } while (range >= 1);
629
630 #ifdef DEBUG
631     fprintf(stderr, "phods     - MX: %d\tMY: %d\n", mx, my);
632 #endif
633
634     /* half pixel search */
635     *mx_ptr = mx;
636     *my_ptr = my;
637     return dminy;
638 }
639
640
641 #define Z_THRESHOLD 256
642
643 #define CHECK_SAD_HALF_MV(suffix, x, y) \
644 {\
645     d= pix_abs_ ## suffix(pix, ptr+((x)>>1), s->linesize);\
646     d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*penalty_factor;\
647     COPY3_IF_LT(dminh, d, dx, x, dy, y)\
648 }
649
650 static inline int sad_hpel_motion_search(MpegEncContext * s,
651                                   int *mx_ptr, int *my_ptr, int dmin,
652                                   int xmin, int ymin, int xmax, int ymax,
653                                   int pred_x, int pred_y, Picture *picture,
654                                   int n, int size, uint16_t * const mv_penalty)
655 {
656     uint8_t *ref_picture= picture->data[0];
657     uint32_t *score_map= s->me.score_map;
658     const int penalty_factor= s->me.sub_penalty_factor;
659     int mx, my, xx, yy, dminh;
660     uint8_t *pix, *ptr;
661     op_pixels_abs_func pix_abs_x2;
662     op_pixels_abs_func pix_abs_y2;
663     op_pixels_abs_func pix_abs_xy2;
664     
665     if(size==0){
666         pix_abs_x2 = s->dsp.pix_abs16x16_x2;
667         pix_abs_y2 = s->dsp.pix_abs16x16_y2;
668         pix_abs_xy2= s->dsp.pix_abs16x16_xy2;
669     }else{
670         pix_abs_x2 = s->dsp.pix_abs8x8_x2;
671         pix_abs_y2 = s->dsp.pix_abs8x8_y2;
672         pix_abs_xy2= s->dsp.pix_abs8x8_xy2;
673     }
674
675     if(s->me.skip){
676 //    printf("S");
677         *mx_ptr = 0;
678         *my_ptr = 0;
679         return dmin;
680     }
681 //    printf("N");
682         
683     xx = 16 * s->mb_x + 8*(n&1);
684     yy = 16 * s->mb_y + 8*(n>>1);
685     pix =  s->new_picture.data[0] + (yy * s->linesize) + xx;
686
687     mx = *mx_ptr;
688     my = *my_ptr;
689     ptr = ref_picture + ((yy + my) * s->linesize) + (xx + mx);
690     
691     dminh = dmin;
692
693     if (mx > xmin && mx < xmax && 
694         my > ymin && my < ymax) {
695         int dx=0, dy=0;
696         int d, pen_x, pen_y; 
697         const int index= (my<<ME_MAP_SHIFT) + mx;
698         const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
699         const int l= score_map[(index- 1               )&(ME_MAP_SIZE-1)];
700         const int r= score_map[(index+ 1               )&(ME_MAP_SIZE-1)];
701         const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
702         mx<<=1;
703         my<<=1;
704
705         
706         pen_x= pred_x + mx;
707         pen_y= pred_y + my;
708
709         ptr-= s->linesize;
710         if(t<=b){
711             CHECK_SAD_HALF_MV(y2 , 0, -1)
712             if(l<=r){
713                 CHECK_SAD_HALF_MV(xy2, -1, -1)
714                 if(t+r<=b+l){
715                     CHECK_SAD_HALF_MV(xy2, +1, -1)
716                     ptr+= s->linesize;
717                 }else{
718                     ptr+= s->linesize;
719                     CHECK_SAD_HALF_MV(xy2, -1, +1)
720                 }
721                 CHECK_SAD_HALF_MV(x2 , -1,  0)
722             }else{
723                 CHECK_SAD_HALF_MV(xy2, +1, -1)
724                 if(t+l<=b+r){
725                     CHECK_SAD_HALF_MV(xy2, -1, -1)
726                     ptr+= s->linesize;
727                 }else{
728                     ptr+= s->linesize;
729                     CHECK_SAD_HALF_MV(xy2, +1, +1)
730                 }
731                 CHECK_SAD_HALF_MV(x2 , +1,  0)
732             }
733         }else{
734             if(l<=r){
735                 if(t+l<=b+r){
736                     CHECK_SAD_HALF_MV(xy2, -1, -1)
737                     ptr+= s->linesize;
738                 }else{
739                     ptr+= s->linesize;
740                     CHECK_SAD_HALF_MV(xy2, +1, +1)
741                 }
742                 CHECK_SAD_HALF_MV(x2 , -1,  0)
743                 CHECK_SAD_HALF_MV(xy2, -1, +1)
744             }else{
745                 if(t+r<=b+l){
746                     CHECK_SAD_HALF_MV(xy2, +1, -1)
747                     ptr+= s->linesize;
748                 }else{
749                     ptr+= s->linesize;
750                     CHECK_SAD_HALF_MV(xy2, -1, +1)
751                 }
752                 CHECK_SAD_HALF_MV(x2 , +1,  0)
753                 CHECK_SAD_HALF_MV(xy2, +1, +1)
754             }
755             CHECK_SAD_HALF_MV(y2 ,  0, +1)
756         }
757         mx+=dx;
758         my+=dy;
759
760     }else{
761         mx<<=1;
762         my<<=1;
763     }
764
765     *mx_ptr = mx;
766     *my_ptr = my;
767     return dminh;
768 }
769
770 static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4)
771 {
772     const int xy= s->mb_x + 1 + (s->mb_y + 1)*(s->mb_width + 2);
773     
774     s->p_mv_table[xy][0] = mx;
775     s->p_mv_table[xy][1] = my;
776
777     /* has allready been set to the 4 MV if 4MV is done */
778     if(mv4){
779         int mot_xy= s->block_index[0];
780
781         s->motion_val[mot_xy  ][0]= mx;
782         s->motion_val[mot_xy  ][1]= my;
783         s->motion_val[mot_xy+1][0]= mx;
784         s->motion_val[mot_xy+1][1]= my;
785
786         mot_xy += s->block_wrap[0];
787         s->motion_val[mot_xy  ][0]= mx;
788         s->motion_val[mot_xy  ][1]= my;
789         s->motion_val[mot_xy+1][0]= mx;
790         s->motion_val[mot_xy+1][1]= my;
791     }
792 }
793
794 /**
795  * get fullpel ME search limits.
796  * @param range the approximate search range for the old ME code, unused for EPZS and newer
797  */
798 static inline void get_limits(MpegEncContext *s, int *range, int *xmin, int *ymin, int *xmax, int *ymax)
799 {
800     if(s->avctx->me_range) *range= s->avctx->me_range >> 1;
801     else                   *range= 16;
802
803     if (s->unrestricted_mv) {
804         *xmin = -16;
805         *ymin = -16;
806         if(s->avctx->codec->id!=CODEC_ID_MPEG4){
807             *xmax = s->mb_width*16;
808             *ymax = s->mb_height*16;
809         }else {
810             *xmax = s->width;
811             *ymax = s->height;
812         }
813     } else {
814         *xmin = 0;
815         *ymin = 0;
816         *xmax = s->mb_width*16 - 16;
817         *ymax = s->mb_height*16 - 16;
818     }
819     
820     //FIXME try to limit x/y min/max if me_range is set
821 }
822
823 static inline int h263_mv4_search(MpegEncContext *s, int xmin, int ymin, int xmax, int ymax, int mx, int my, int shift)
824 {
825     int block;
826     int P[10][2];
827     int dmin_sum=0, mx4_sum=0, my4_sum=0;
828     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;
829
830     for(block=0; block<4; block++){
831         int mx4, my4;
832         int pred_x4, pred_y4;
833         int dmin4;
834         static const int off[4]= {2, 1, 1, -1};
835         const int mot_stride = s->block_wrap[0];
836         const int mot_xy = s->block_index[block];
837 //        const int block_x= (block&1);
838 //        const int block_y= (block>>1);
839 #if 1 // this saves us a bit of cliping work and shouldnt affect compression in a negative way
840         const int rel_xmin4= xmin;
841         const int rel_xmax4= xmax;
842         const int rel_ymin4= ymin;
843         const int rel_ymax4= ymax;
844 #else
845         const int rel_xmin4= xmin - block_x*8;
846         const int rel_xmax4= xmax - block_x*8 + 8;
847         const int rel_ymin4= ymin - block_y*8;
848         const int rel_ymax4= ymax - block_y*8 + 8;
849 #endif
850         P_LEFT[0] = s->motion_val[mot_xy - 1][0];
851         P_LEFT[1] = s->motion_val[mot_xy - 1][1];
852
853         if(P_LEFT[0]       > (rel_xmax4<<shift)) P_LEFT[0]       = (rel_xmax4<<shift);
854
855         /* special case for first line */
856         if (s->mb_y == 0 && block<2) {
857             pred_x4= P_LEFT[0];
858             pred_y4= P_LEFT[1];
859         } else {
860             P_TOP[0]      = s->motion_val[mot_xy - mot_stride             ][0];
861             P_TOP[1]      = s->motion_val[mot_xy - mot_stride             ][1];
862             P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + off[block]][0];
863             P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + off[block]][1];
864             if(P_TOP[1]      > (rel_ymax4<<shift)) P_TOP[1]     = (rel_ymax4<<shift);
865             if(P_TOPRIGHT[0] < (rel_xmin4<<shift)) P_TOPRIGHT[0]= (rel_xmin4<<shift);
866             if(P_TOPRIGHT[0] > (rel_xmax4<<shift)) P_TOPRIGHT[0]= (rel_xmax4<<shift);
867             if(P_TOPRIGHT[1] > (rel_ymax4<<shift)) P_TOPRIGHT[1]= (rel_ymax4<<shift);
868     
869             P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
870             P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
871
872 //            if(s->out_format == FMT_H263){
873                 pred_x4 = P_MEDIAN[0];
874                 pred_y4 = P_MEDIAN[1];
875 #if 0
876             }else { /* mpeg1 at least */
877                 pred_x4= P_LEFT[0];
878                 pred_y4= P_LEFT[1];
879             }
880 #endif
881         }
882         P_MV1[0]= mx;
883         P_MV1[1]= my;
884
885         dmin4 = s->me.motion_search[1](s, block, &mx4, &my4, P, pred_x4, pred_y4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, 
886                                        &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);
887
888         dmin4= s->me.sub_motion_search(s, &mx4, &my4, dmin4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, 
889                                           pred_x4, pred_y4, &s->last_picture, block, 1, mv_penalty);
890         
891         if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
892             int dxy;
893             const int offset= ((block&1) + (block>>1)*s->linesize)*8;
894             uint8_t *dest_y = s->me.scratchpad + offset;
895
896             if(s->quarter_sample){
897                 uint8_t *ref= s->last_picture.data[0] + (s->mb_x*16 + (mx4>>2)) + (s->mb_y*16 + (my4>>2))*s->linesize + offset;
898                 dxy = ((my4 & 3) << 2) | (mx4 & 3);
899
900                 if(s->no_rounding)
901                     s->dsp.put_no_rnd_qpel_pixels_tab[1][dxy](dest_y   , ref    , s->linesize);
902                 else
903                     s->dsp.put_qpel_pixels_tab       [1][dxy](dest_y   , ref    , s->linesize);
904             }else{
905                 uint8_t *ref= s->last_picture.data[0] + (s->mb_x*16 + (mx4>>1)) + (s->mb_y*16 + (my4>>1))*s->linesize + offset;
906                 dxy = ((my4 & 1) << 1) | (mx4 & 1);
907
908                 if(s->no_rounding)
909                     s->dsp.put_no_rnd_pixels_tab[1][dxy](dest_y    , ref    , s->linesize, 8);
910                 else
911                     s->dsp.put_pixels_tab       [1][dxy](dest_y    , ref    , s->linesize, 8);
912             }
913             dmin_sum+= (mv_penalty[mx4-pred_x4] + mv_penalty[my4-pred_y4])*s->me.mb_penalty_factor;
914         }else
915             dmin_sum+= dmin4;
916
917         if(s->quarter_sample){
918             mx4_sum+= mx4/2;
919             my4_sum+= my4/2;
920         }else{
921             mx4_sum+= mx4;
922             my4_sum+= my4;
923         }
924             
925         s->motion_val[ s->block_index[block] ][0]= mx4;
926         s->motion_val[ s->block_index[block] ][1]= my4;
927     }
928     
929     if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
930         dmin_sum += s->dsp.mb_cmp[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*16*s->linesize, s->me.scratchpad, s->linesize);
931     }
932     
933     if(s->avctx->mb_cmp&FF_CMP_CHROMA){
934         int dxy;
935         int mx, my;
936         int offset;
937
938         mx= ff_h263_round_chroma(mx4_sum);
939         my= ff_h263_round_chroma(my4_sum);
940         dxy = ((my & 1) << 1) | (mx & 1);
941         
942         offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize;
943        
944         if(s->no_rounding){
945             s->dsp.put_no_rnd_pixels_tab[1][dxy](s->me.scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);
946             s->dsp.put_no_rnd_pixels_tab[1][dxy](s->me.scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);
947         }else{
948             s->dsp.put_pixels_tab       [1][dxy](s->me.scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);
949             s->dsp.put_pixels_tab       [1][dxy](s->me.scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);
950         }
951
952         dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, s->me.scratchpad  , s->uvlinesize);
953         dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, s->me.scratchpad+8, s->uvlinesize);
954     }
955
956     switch(s->avctx->mb_cmp&0xFF){
957     /*case FF_CMP_SSE:
958         return dmin_sum+ 32*s->qscale*s->qscale;*/
959     case FF_CMP_RD:
960         return dmin_sum;
961     default:
962         return dmin_sum+ 11*s->me.mb_penalty_factor;
963     }
964 }
965
966 void ff_estimate_p_frame_motion(MpegEncContext * s,
967                                 int mb_x, int mb_y)
968 {
969     uint8_t *pix, *ppix;
970     int sum, varc, vard, mx, my, range, dmin, xx, yy;
971     int xmin, ymin, xmax, ymax;
972     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
973     int pred_x=0, pred_y=0;
974     int P[10][2];
975     const int shift= 1+s->quarter_sample;
976     int mb_type=0;
977     uint8_t *ref_picture= s->last_picture.data[0];
978     Picture * const pic= &s->current_picture;
979     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;
980     
981     assert(s->quarter_sample==0 || s->quarter_sample==1);
982
983     s->me.penalty_factor    = get_penalty_factor(s, s->avctx->me_cmp);
984     s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);
985     s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);
986
987     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax);
988     rel_xmin= xmin - mb_x*16;
989     rel_xmax= xmax - mb_x*16;
990     rel_ymin= ymin - mb_y*16;
991     rel_ymax= ymax - mb_y*16;
992     s->me.skip=0;
993
994     switch(s->me_method) {
995     case ME_ZERO:
996     default:
997         no_motion_search(s, &mx, &my);
998         mx-= mb_x*16;
999         my-= mb_y*16;
1000         dmin = 0;
1001         break;
1002     case ME_FULL:
1003         dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
1004         mx-= mb_x*16;
1005         my-= mb_y*16;
1006         break;
1007     case ME_LOG:
1008         dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1009         mx-= mb_x*16;
1010         my-= mb_y*16;
1011         break;
1012     case ME_PHODS:
1013         dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1014         mx-= mb_x*16;
1015         my-= mb_y*16;
1016         break;
1017     case ME_X1:
1018     case ME_EPZS:
1019        {
1020             const int mot_stride = s->block_wrap[0];
1021             const int mot_xy = s->block_index[0];
1022
1023             P_LEFT[0]       = s->motion_val[mot_xy - 1][0];
1024             P_LEFT[1]       = s->motion_val[mot_xy - 1][1];
1025
1026             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);
1027
1028             if(mb_y) {
1029                 P_TOP[0]      = s->motion_val[mot_xy - mot_stride    ][0];
1030                 P_TOP[1]      = s->motion_val[mot_xy - mot_stride    ][1];
1031                 P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + 2][0];
1032                 P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + 2][1];
1033                 if(P_TOP[1]      > (rel_ymax<<shift)) P_TOP[1]     = (rel_ymax<<shift);
1034                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
1035                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
1036         
1037                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1038                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1039
1040                 if(s->out_format == FMT_H263){
1041                     pred_x = P_MEDIAN[0];
1042                     pred_y = P_MEDIAN[1];
1043                 }else { /* mpeg1 at least */
1044                     pred_x= P_LEFT[0];
1045                     pred_y= P_LEFT[1];
1046                 }
1047             }else{
1048                 pred_x= P_LEFT[0];
1049                 pred_y= P_LEFT[1];
1050             }
1051
1052         }
1053         dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1054                                       &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);
1055  
1056         break;
1057     }
1058
1059     /* intra / predictive decision */
1060     xx = mb_x * 16;
1061     yy = mb_y * 16;
1062
1063     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
1064     /* At this point (mx,my) are full-pell and the relative displacement */
1065     ppix = ref_picture + ((yy+my) * s->linesize) + (xx+mx);
1066     
1067     sum = s->dsp.pix_sum(pix, s->linesize);
1068     
1069     varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
1070     vard = (s->dsp.sse[0](NULL, pix, ppix, s->linesize)+128)>>8;
1071
1072 //printf("%d %d %d %X %X %X\n", s->mb_width, mb_x, mb_y,(int)s, (int)s->mb_var, (int)s->mc_mb_var); fflush(stdout);
1073     pic->mb_var   [s->mb_width * mb_y + mb_x] = varc;
1074     pic->mc_mb_var[s->mb_width * mb_y + mb_x] = vard;
1075     pic->mb_mean  [s->mb_width * mb_y + mb_x] = (sum+128)>>8;
1076 //    pic->mb_cmp_score[s->mb_width * mb_y + mb_x] = dmin; 
1077     pic->mb_var_sum    += varc;
1078     pic->mc_mb_var_sum += vard;
1079 //printf("E%d %d %d %X %X %X\n", s->mb_width, mb_x, mb_y,(int)s, (int)s->mb_var, (int)s->mc_mb_var); fflush(stdout);
1080     
1081 #if 0
1082     printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n",
1083            varc, s->avg_mb_var, sum, vard, mx - xx, my - yy);
1084 #endif
1085     if(s->flags&CODEC_FLAG_HQ){
1086         if (vard <= 64 || vard < varc)
1087             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1088         else
1089             s->scene_change_score+= s->qscale;
1090
1091         if (vard*2 + 200 > varc)
1092             mb_type|= MB_TYPE_INTRA;
1093         if (varc*2 + 200 > vard){
1094             mb_type|= MB_TYPE_INTER;
1095             s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1096                                    pred_x, pred_y, &s->last_picture, 0, 0, mv_penalty);
1097         }else{
1098             mx <<=shift;
1099             my <<=shift;
1100         }
1101         if((s->flags&CODEC_FLAG_4MV)
1102            && !s->me.skip && varc>50 && vard>10){
1103             h263_mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
1104             mb_type|=MB_TYPE_INTER4V;
1105
1106             set_p_mv_tables(s, mx, my, 0);
1107         }else
1108             set_p_mv_tables(s, mx, my, 1);
1109     }else{
1110         mb_type= MB_TYPE_INTER;
1111
1112         dmin= s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1113                                     pred_x, pred_y, &s->last_picture, 0, 0, mv_penalty);
1114         
1115         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1116             dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, &s->last_picture, mv_penalty);
1117
1118         if((s->flags&CODEC_FLAG_4MV)
1119            && !s->me.skip && varc>50 && vard>10){
1120             int dmin4= h263_mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
1121             if(dmin4 < dmin){
1122                 mb_type= MB_TYPE_INTER4V;
1123                 dmin=dmin4;
1124             }
1125         }
1126         pic->mb_cmp_score[s->mb_width * mb_y + mb_x] = dmin; 
1127         set_p_mv_tables(s, mx, my, mb_type!=MB_TYPE_INTER4V);
1128         
1129         if (vard <= 64 || vard < varc) {
1130             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1131         }else{
1132             s->scene_change_score+= s->qscale;
1133         }
1134     }
1135
1136     s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1137 }
1138
1139 int ff_pre_estimate_p_frame_motion(MpegEncContext * s,
1140                                     int mb_x, int mb_y)
1141 {
1142     int mx, my, range, dmin;
1143     int xmin, ymin, xmax, ymax;
1144     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
1145     int pred_x=0, pred_y=0;
1146     int P[10][2];
1147     const int shift= 1+s->quarter_sample;
1148     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;
1149     const int mv_stride= s->mb_width + 2;
1150     const int xy= mb_x + 1 + (mb_y + 1)*mv_stride;
1151     
1152     assert(s->quarter_sample==0 || s->quarter_sample==1);
1153
1154     s->me.pre_penalty_factor    = get_penalty_factor(s, s->avctx->me_pre_cmp);
1155
1156     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax);
1157     rel_xmin= xmin - mb_x*16;
1158     rel_xmax= xmax - mb_x*16;
1159     rel_ymin= ymin - mb_y*16;
1160     rel_ymax= ymax - mb_y*16;
1161     s->me.skip=0;
1162
1163     P_LEFT[0]       = s->p_mv_table[xy + 1][0];
1164     P_LEFT[1]       = s->p_mv_table[xy + 1][1];
1165
1166     if(P_LEFT[0]       < (rel_xmin<<shift)) P_LEFT[0]       = (rel_xmin<<shift);
1167
1168     /* special case for first line */
1169     if (mb_y == s->mb_height-1) {
1170         pred_x= P_LEFT[0];
1171         pred_y= P_LEFT[1];
1172         P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]=
1173         P_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0; //FIXME 
1174     } else {
1175         P_TOP[0]      = s->p_mv_table[xy + mv_stride    ][0];
1176         P_TOP[1]      = s->p_mv_table[xy + mv_stride    ][1];
1177         P_TOPRIGHT[0] = s->p_mv_table[xy + mv_stride - 1][0];
1178         P_TOPRIGHT[1] = s->p_mv_table[xy + mv_stride - 1][1];
1179         if(P_TOP[1]      < (rel_ymin<<shift)) P_TOP[1]     = (rel_ymin<<shift);
1180         if(P_TOPRIGHT[0] > (rel_xmax<<shift)) P_TOPRIGHT[0]= (rel_xmax<<shift);
1181         if(P_TOPRIGHT[1] < (rel_ymin<<shift)) P_TOPRIGHT[1]= (rel_ymin<<shift);
1182     
1183         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1184         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1185
1186         pred_x = P_MEDIAN[0];
1187         pred_y = P_MEDIAN[1];
1188     }
1189     dmin = s->me.pre_motion_search(s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1190                                    &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);
1191
1192     s->p_mv_table[xy][0] = mx<<shift;
1193     s->p_mv_table[xy][1] = my<<shift;
1194     
1195     return dmin;
1196 }
1197
1198 static int ff_estimate_motion_b(MpegEncContext * s,
1199                        int mb_x, int mb_y, int16_t (*mv_table)[2], Picture *picture, int f_code)
1200 {
1201     int mx, my, range, dmin;
1202     int xmin, ymin, xmax, ymax;
1203     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
1204     int pred_x=0, pred_y=0;
1205     int P[10][2];
1206     const int shift= 1+s->quarter_sample;
1207     const int mot_stride = s->mb_width + 2;
1208     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
1209     uint8_t * const ref_picture= picture->data[0];
1210     uint16_t * const mv_penalty= s->me.mv_penalty[f_code] + MAX_MV;
1211     int mv_scale;
1212         
1213     s->me.penalty_factor    = get_penalty_factor(s, s->avctx->me_cmp);
1214     s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);
1215     s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);
1216
1217     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax);
1218     rel_xmin= xmin - mb_x*16;
1219     rel_xmax= xmax - mb_x*16;
1220     rel_ymin= ymin - mb_y*16;
1221     rel_ymax= ymax - mb_y*16;
1222
1223     switch(s->me_method) {
1224     case ME_ZERO:
1225     default:
1226         no_motion_search(s, &mx, &my);
1227         dmin = 0;
1228         mx-= mb_x*16;
1229         my-= mb_y*16;
1230         break;
1231     case ME_FULL:
1232         dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
1233         mx-= mb_x*16;
1234         my-= mb_y*16;
1235         break;
1236     case ME_LOG:
1237         dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1238         mx-= mb_x*16;
1239         my-= mb_y*16;
1240         break;
1241     case ME_PHODS:
1242         dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1243         mx-= mb_x*16;
1244         my-= mb_y*16;
1245         break;
1246     case ME_X1:
1247     case ME_EPZS:
1248        {
1249             P_LEFT[0]        = mv_table[mot_xy - 1][0];
1250             P_LEFT[1]        = mv_table[mot_xy - 1][1];
1251
1252             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);
1253
1254             /* special case for first line */
1255             if (mb_y) {
1256                 P_TOP[0] = mv_table[mot_xy - mot_stride             ][0];
1257                 P_TOP[1] = mv_table[mot_xy - mot_stride             ][1];
1258                 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1         ][0];
1259                 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1         ][1];
1260                 if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1]= (rel_ymax<<shift);
1261                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
1262                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
1263         
1264                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1265                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1266             }
1267             pred_x= P_LEFT[0];
1268             pred_y= P_LEFT[1];
1269         }
1270         
1271         if(mv_table == s->b_forw_mv_table){
1272             mv_scale= (s->pb_time<<16) / (s->pp_time<<shift);
1273         }else{
1274             mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift);
1275         }
1276         
1277         dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1278                                       picture, s->p_mv_table, mv_scale, mv_penalty);
1279  
1280         break;
1281     }
1282     
1283     dmin= s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1284                                    pred_x, pred_y, picture, 0, 0, mv_penalty);
1285                                    
1286     if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1287         dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, picture, mv_penalty);
1288
1289 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);
1290 //    s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1291     mv_table[mot_xy][0]= mx;
1292     mv_table[mot_xy][1]= my;
1293
1294     return dmin;
1295 }
1296
1297 static inline int check_bidir_mv(MpegEncContext * s,
1298                    int mb_x, int mb_y,
1299                    int motion_fx, int motion_fy,
1300                    int motion_bx, int motion_by,
1301                    int pred_fx, int pred_fy,
1302                    int pred_bx, int pred_by)
1303 {
1304     //FIXME optimize?
1305     //FIXME move into template?
1306     //FIXME better f_code prediction (max mv & distance)
1307     uint16_t *mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
1308     uint8_t *dest_y = s->me.scratchpad;
1309     uint8_t *ptr;
1310     int dxy;
1311     int src_x, src_y;
1312     int fbmin;
1313
1314     if(s->quarter_sample){
1315         dxy = ((motion_fy & 3) << 2) | (motion_fx & 3);
1316         src_x = mb_x * 16 + (motion_fx >> 2);
1317         src_y = mb_y * 16 + (motion_fy >> 2);
1318         assert(src_x >=-16 && src_x<=s->width);
1319         assert(src_y >=-16 && src_y<=s->height);
1320
1321         ptr = s->last_picture.data[0] + (src_y * s->linesize) + src_x;
1322         s->dsp.put_qpel_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize);
1323
1324         dxy = ((motion_by & 3) << 2) | (motion_bx & 3);
1325         src_x = mb_x * 16 + (motion_bx >> 2);
1326         src_y = mb_y * 16 + (motion_by >> 2);
1327         assert(src_x >=-16 && src_x<=s->width);
1328         assert(src_y >=-16 && src_y<=s->height);
1329     
1330         ptr = s->next_picture.data[0] + (src_y * s->linesize) + src_x;
1331         s->dsp.avg_qpel_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize);
1332     }else{
1333         dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
1334         src_x = mb_x * 16 + (motion_fx >> 1);
1335         src_y = mb_y * 16 + (motion_fy >> 1);
1336         assert(src_x >=-16 && src_x<=s->width);
1337         assert(src_y >=-16 && src_y<=s->height);
1338
1339         ptr = s->last_picture.data[0] + (src_y * s->linesize) + src_x;
1340         s->dsp.put_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize, 16);
1341
1342         dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
1343         src_x = mb_x * 16 + (motion_bx >> 1);
1344         src_y = mb_y * 16 + (motion_by >> 1);
1345         assert(src_x >=-16 && src_x<=s->width);
1346         assert(src_y >=-16 && src_y<=s->height);
1347     
1348         ptr = s->next_picture.data[0] + (src_y * s->linesize) + src_x;
1349         s->dsp.avg_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize, 16);
1350     }
1351
1352     fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*s->me.mb_penalty_factor
1353            +(mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*s->me.mb_penalty_factor
1354            + s->dsp.mb_cmp[0](s, s->new_picture.data[0] + mb_x*16 + mb_y*16*s->linesize, dest_y, s->linesize);
1355            
1356     if(s->avctx->mb_cmp&FF_CMP_CHROMA){
1357     }
1358     //FIXME CHROMA !!!
1359            
1360     return fbmin;
1361 }
1362
1363 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
1364 static inline int bidir_refine(MpegEncContext * s,
1365                                   int mb_x, int mb_y)
1366 {
1367     const int mot_stride = s->mb_width + 2;
1368     const int xy = (mb_y + 1)*mot_stride + mb_x + 1;
1369     int fbmin;
1370     int pred_fx= s->b_bidir_forw_mv_table[xy-1][0];
1371     int pred_fy= s->b_bidir_forw_mv_table[xy-1][1];
1372     int pred_bx= s->b_bidir_back_mv_table[xy-1][0];
1373     int pred_by= s->b_bidir_back_mv_table[xy-1][1];
1374     int motion_fx= s->b_bidir_forw_mv_table[xy][0]= s->b_forw_mv_table[xy][0];
1375     int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1];
1376     int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0];
1377     int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1];
1378
1379     //FIXME do refinement and add flag
1380     
1381     fbmin= check_bidir_mv(s, mb_x, mb_y, 
1382                           motion_fx, motion_fy,
1383                           motion_bx, motion_by,
1384                           pred_fx, pred_fy,
1385                           pred_bx, pred_by);
1386
1387    return fbmin;
1388 }
1389
1390 static inline int direct_search(MpegEncContext * s,
1391                                 int mb_x, int mb_y)
1392 {
1393     int P[10][2];
1394     const int mot_stride = s->mb_width + 2;
1395     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
1396     const int shift= 1+s->quarter_sample;
1397     int dmin, i;
1398     const int time_pp= s->pp_time;
1399     const int time_pb= s->pb_time;
1400     int mx, my, xmin, xmax, ymin, ymax;
1401     int16_t (*mv_table)[2]= s->b_direct_mv_table;
1402     uint16_t * const mv_penalty= s->me.mv_penalty[1] + MAX_MV;
1403     
1404     ymin= xmin=(-32)>>shift;
1405     ymax= xmax=   31>>shift;
1406
1407     if(s->co_located_type_table[mb_x + mb_y*s->mb_width]==CO_LOCATED_TYPE_4MV){
1408         s->mv_type= MV_TYPE_8X8;
1409     }else{
1410         s->mv_type= MV_TYPE_16X16;
1411     }
1412
1413     for(i=0; i<4; i++){
1414         int index= s->block_index[i];
1415         int min, max;
1416     
1417         s->me.co_located_mv[i][0]= s->motion_val[index][0];
1418         s->me.co_located_mv[i][1]= s->motion_val[index][1];
1419         s->me.direct_basis_mv[i][0]= s->me.co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3));
1420         s->me.direct_basis_mv[i][1]= s->me.co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3));
1421 //        s->me.direct_basis_mv[1][i][0]= s->me.co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3);
1422 //        s->me.direct_basis_mv[1][i][1]= s->me.co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(shift+3);
1423
1424         max= FFMAX(s->me.direct_basis_mv[i][0], s->me.direct_basis_mv[i][0] - s->me.co_located_mv[i][0])>>shift;
1425         min= FFMIN(s->me.direct_basis_mv[i][0], s->me.direct_basis_mv[i][0] - s->me.co_located_mv[i][0])>>shift;
1426         max+= (2*mb_x + (i& 1))*8 + 1; // +-1 is for the simpler rounding
1427         min+= (2*mb_x + (i& 1))*8 - 1;
1428         xmax= FFMIN(xmax, s->width - max);
1429         xmin= FFMAX(xmin, - 16     - min);
1430
1431         max= FFMAX(s->me.direct_basis_mv[i][1], s->me.direct_basis_mv[i][1] - s->me.co_located_mv[i][1])>>shift;
1432         min= FFMIN(s->me.direct_basis_mv[i][1], s->me.direct_basis_mv[i][1] - s->me.co_located_mv[i][1])>>shift;
1433         max+= (2*mb_y + (i>>1))*8 + 1; // +-1 is for the simpler rounding
1434         min+= (2*mb_y + (i>>1))*8 - 1;
1435         ymax= FFMIN(ymax, s->height - max);
1436         ymin= FFMAX(ymin, - 16      - min);
1437         
1438         if(s->mv_type == MV_TYPE_16X16) break;
1439     }
1440     
1441     assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);
1442     
1443     if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){
1444         s->b_direct_mv_table[mot_xy][0]= 0;
1445         s->b_direct_mv_table[mot_xy][1]= 0;
1446
1447         return 256*256*256*64;
1448     }
1449
1450     P_LEFT[0]        = clip(mv_table[mot_xy - 1][0], xmin<<shift, xmax<<shift);
1451     P_LEFT[1]        = clip(mv_table[mot_xy - 1][1], ymin<<shift, ymax<<shift);
1452
1453     /* special case for first line */
1454     if (mb_y) {
1455         P_TOP[0]      = clip(mv_table[mot_xy - mot_stride             ][0], xmin<<shift, xmax<<shift);
1456         P_TOP[1]      = clip(mv_table[mot_xy - mot_stride             ][1], ymin<<shift, ymax<<shift);
1457         P_TOPRIGHT[0] = clip(mv_table[mot_xy - mot_stride + 1         ][0], xmin<<shift, xmax<<shift);
1458         P_TOPRIGHT[1] = clip(mv_table[mot_xy - mot_stride + 1         ][1], ymin<<shift, ymax<<shift);
1459     
1460         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1461         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1462     }
1463  
1464     //FIXME direct_search  ptr in context!!! (needed for chroma anyway or this will get messy)   
1465     if(s->flags&CODEC_FLAG_QPEL){
1466         dmin = simple_direct_qpel_epzs_motion_search(s, 0, &mx, &my, P, 0, 0, xmin, ymin, xmax, ymax, 
1467                                                      &s->last_picture, mv_table, 1<<14, mv_penalty);
1468         dmin = simple_direct_qpel_qpel_motion_search(s, &mx, &my, dmin, xmin, ymin, xmax, ymax,
1469                                                 0, 0, &s->last_picture, 0, 0, mv_penalty);
1470         
1471         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1472             dmin= simple_direct_qpel_qpel_get_mb_score(s, mx, my, 0, 0, &s->last_picture, mv_penalty);
1473     }else{
1474         dmin = simple_direct_hpel_epzs_motion_search(s, 0, &mx, &my, P, 0, 0, xmin, ymin, xmax, ymax, 
1475                                                      &s->last_picture, mv_table, 1<<15, mv_penalty);
1476         dmin = simple_direct_hpel_hpel_motion_search(s, &mx, &my, dmin, xmin, ymin, xmax, ymax,
1477                                                 0, 0, &s->last_picture, 0, 0, mv_penalty);
1478
1479         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1480             dmin= simple_direct_hpel_hpel_get_mb_score(s, mx, my, 0, 0, &s->last_picture, mv_penalty);
1481     }
1482
1483     s->b_direct_mv_table[mot_xy][0]= mx;
1484     s->b_direct_mv_table[mot_xy][1]= my;
1485     return dmin;
1486 }
1487
1488 void ff_estimate_b_frame_motion(MpegEncContext * s,
1489                              int mb_x, int mb_y)
1490 {
1491     const int penalty_factor= s->me.mb_penalty_factor;
1492     int fmin, bmin, dmin, fbmin;
1493     int type=0;
1494     
1495     dmin= direct_search(s, mb_x, mb_y);
1496
1497     fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, &s->last_picture, s->f_code) + 3*penalty_factor;
1498     bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, &s->next_picture, s->b_code) + 2*penalty_factor;
1499 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]);
1500
1501     fbmin= bidir_refine(s, mb_x, mb_y) + penalty_factor;
1502 //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin);
1503     {
1504         int score= fmin;
1505         type = MB_TYPE_FORWARD;
1506         
1507         // RAL: No MB_TYPE_DIRECT in MPEG-1 video (only MPEG-4)
1508         if (s->codec_id != CODEC_ID_MPEG1VIDEO && dmin <= score){
1509             score = dmin;
1510             type = MB_TYPE_DIRECT;
1511         }
1512         if(bmin<score){
1513             score=bmin;
1514             type= MB_TYPE_BACKWARD; 
1515         }
1516         if(fbmin<score){
1517             score=fbmin;
1518             type= MB_TYPE_BIDIR;
1519         }
1520         
1521         score= ((unsigned)(score*score + 128*256))>>16;
1522         s->current_picture.mc_mb_var_sum += score;
1523         s->current_picture.mc_mb_var[mb_y*s->mb_width + mb_x] = score; //FIXME use SSE
1524     }
1525
1526     if(s->flags&CODEC_FLAG_HQ){
1527         type= MB_TYPE_FORWARD | MB_TYPE_BACKWARD | MB_TYPE_BIDIR | MB_TYPE_DIRECT; //FIXME something smarter
1528         if(dmin>256*256*16) type&= ~MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB
1529     }
1530
1531     s->mb_type[mb_y*s->mb_width + mb_x]= type;
1532 }
1533
1534 /* find best f_code for ME which do unlimited searches */
1535 int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
1536 {
1537     if(s->me_method>=ME_EPZS){
1538         int score[8];
1539         int i, y;
1540         uint8_t * fcode_tab= s->fcode_tab;
1541         int best_fcode=-1;
1542         int best_score=-10000000;
1543
1544         for(i=0; i<8; i++) score[i]= s->mb_num*(8-i);
1545
1546         for(y=0; y<s->mb_height; y++){
1547             int x;
1548             int xy= (y+1)* (s->mb_width+2) + 1;
1549             i= y*s->mb_width;
1550             for(x=0; x<s->mb_width; x++){
1551                 if(s->mb_type[i] & type){
1552                     int fcode= FFMAX(fcode_tab[mv_table[xy][0] + MAX_MV],
1553                                      fcode_tab[mv_table[xy][1] + MAX_MV]);
1554                     int j;
1555                     
1556                     for(j=0; j<fcode && j<8; j++){
1557                         if(s->pict_type==B_TYPE || s->current_picture.mc_mb_var[i] < s->current_picture.mb_var[i])
1558                             score[j]-= 170;
1559                     }
1560                 }
1561                 i++;
1562                 xy++;
1563             }
1564         }
1565         
1566         for(i=1; i<8; i++){
1567             if(score[i] > best_score){
1568                 best_score= score[i];
1569                 best_fcode= i;
1570             }
1571 //            printf("%d %d\n", i, score[i]);
1572         }
1573
1574 //    printf("fcode: %d type: %d\n", i, s->pict_type);
1575         return best_fcode;
1576 /*        for(i=0; i<=MAX_FCODE; i++){
1577             printf("%d ", mv_num[i]);
1578         }
1579         printf("\n");*/
1580     }else{
1581         return 1;
1582     }
1583 }
1584
1585 void ff_fix_long_p_mvs(MpegEncContext * s)
1586 {
1587     const int f_code= s->f_code;
1588     int y, range;
1589
1590     range = (((s->codec_id == CODEC_ID_MPEG1VIDEO) ? 8 : 16) << f_code);
1591     
1592     if(s->msmpeg4_version) range= 16;
1593     
1594     if(s->avctx->me_range && range > s->avctx->me_range) range= s->avctx->me_range;
1595     
1596     /* clip / convert to intra 16x16 type MVs */
1597     for(y=0; y<s->mb_height; y++){
1598         int x;
1599         int xy= (y+1)* (s->mb_width+2)+1;
1600         int i= y*s->mb_width;
1601         for(x=0; x<s->mb_width; x++){
1602             if(s->mb_type[i]&MB_TYPE_INTER){
1603                 if(   s->p_mv_table[xy][0] >=range || s->p_mv_table[xy][0] <-range
1604                    || s->p_mv_table[xy][1] >=range || s->p_mv_table[xy][1] <-range){
1605                     s->mb_type[i] &= ~MB_TYPE_INTER;
1606                     s->mb_type[i] |= MB_TYPE_INTRA;
1607                     s->p_mv_table[xy][0] = 0;
1608                     s->p_mv_table[xy][1] = 0;
1609 //clip++;
1610                 }
1611 //else
1612 //  noclip++;
1613             }
1614             xy++;
1615             i++;
1616         }
1617     }
1618 //printf("%d no:%d %d//\n", clip, noclip, f_code);
1619     if(s->flags&CODEC_FLAG_4MV){
1620         const int wrap= 2+ s->mb_width*2;
1621
1622         /* clip / convert to intra 8x8 type MVs */
1623         for(y=0; y<s->mb_height; y++){
1624             int xy= (y*2 + 1)*wrap + 1;
1625             int i= y*s->mb_width;
1626             int x;
1627
1628             for(x=0; x<s->mb_width; x++){
1629                 if(s->mb_type[i]&MB_TYPE_INTER4V){
1630                     int block;
1631                     for(block=0; block<4; block++){
1632                         int off= (block& 1) + (block>>1)*wrap;
1633                         int mx= s->motion_val[ xy + off ][0];
1634                         int my= s->motion_val[ xy + off ][1];
1635
1636                         if(   mx >=range || mx <-range
1637                            || my >=range || my <-range){
1638                             s->mb_type[i] &= ~MB_TYPE_INTER4V;
1639                             s->mb_type[i] |= MB_TYPE_INTRA;
1640                         }
1641                     }
1642                 }
1643                 xy+=2;
1644                 i++;
1645             }
1646         }
1647     }
1648 }
1649
1650 void ff_fix_long_b_mvs(MpegEncContext * s, int16_t (*mv_table)[2], int f_code, int type)
1651 {
1652     int y;
1653
1654     // RAL: 8 in MPEG-1, 16 in MPEG-4
1655     int range = (((s->codec_id == CODEC_ID_MPEG1VIDEO) ? 8 : 16) << f_code);
1656     
1657     if(s->avctx->me_range && range > s->avctx->me_range) range= s->avctx->me_range;
1658
1659     /* clip / convert to intra 16x16 type MVs */
1660     for(y=0; y<s->mb_height; y++){
1661         int x;
1662         int xy= (y+1)* (s->mb_width+2)+1;
1663         int i= y*s->mb_width;
1664         for(x=0; x<s->mb_width; x++){
1665             if (s->mb_type[i] & type){    // RAL: "type" test added...
1666                 if(   mv_table[xy][0] >=range || mv_table[xy][0] <-range
1667                    || mv_table[xy][1] >=range || mv_table[xy][1] <-range){
1668
1669                     if(s->codec_id == CODEC_ID_MPEG1VIDEO && 0){
1670                     }else{
1671                         if     (mv_table[xy][0] > range-1) mv_table[xy][0]=  range-1;
1672                         else if(mv_table[xy][0] < -range ) mv_table[xy][0]= -range;
1673                         if     (mv_table[xy][1] > range-1) mv_table[xy][1]=  range-1;
1674                         else if(mv_table[xy][1] < -range ) mv_table[xy][1]= -range;
1675                     }
1676                 }
1677             }
1678             xy++;
1679             i++;
1680         }
1681     }
1682 }