d81ab32a4457869c9da5ea4bda7a64d6f10d7bcd
[ffmpeg.git] / libavcodec / motion_est.c
1 /*
2  * Motion estimation
3  * Copyright (c) 2000,2001 Fabrice Bellard.
4  * Copyright (c) 2002-2004 Michael Niedermayer
5  *
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  * new Motion Estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at>
24  */
25
26 /**
27  * @file motion_est.c
28  * Motion estimation.
29  */
30
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <limits.h>
34 #include "avcodec.h"
35 #include "dsputil.h"
36 #include "mpegvideo.h"
37
38 #undef NDEBUG
39 #include <assert.h>
40
41 #define SQ(a) ((a)*(a))
42
43 #define P_LEFT P[1]
44 #define P_TOP P[2]
45 #define P_TOPRIGHT P[3]
46 #define P_MEDIAN P[4]
47 #define P_MV1 P[9]
48
49 static inline int sad_hpel_motion_search(MpegEncContext * s,
50                                   int *mx_ptr, int *my_ptr, int dmin,
51                                   int src_index, int ref_index,
52                                   int size, int h);
53
54 static inline int update_map_generation(MotionEstContext *c)
55 {
56     c->map_generation+= 1<<(ME_MAP_MV_BITS*2);
57     if(c->map_generation==0){
58         c->map_generation= 1<<(ME_MAP_MV_BITS*2);
59         memset(c->map, 0, sizeof(uint32_t)*ME_MAP_SIZE);
60     }
61     return c->map_generation;
62 }
63
64 /* shape adaptive search stuff */
65 typedef struct Minima{
66     int height;
67     int x, y;
68     int checked;
69 }Minima;
70
71 static int minima_cmp(const void *a, const void *b){
72     const Minima *da = (const Minima *) a;
73     const Minima *db = (const Minima *) b;
74
75     return da->height - db->height;
76 }
77
78 #define FLAG_QPEL   1 //must be 1
79 #define FLAG_CHROMA 2
80 #define FLAG_DIRECT 4
81
82 static inline void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index){
83     const int offset[3]= {
84           y*c->  stride + x,
85         ((y*c->uvstride + x)>>1),
86         ((y*c->uvstride + x)>>1),
87     };
88     int i;
89     for(i=0; i<3; i++){
90         c->src[0][i]= src [i] + offset[i];
91         c->ref[0][i]= ref [i] + offset[i];
92     }
93     if(ref_index){
94         for(i=0; i<3; i++){
95             c->ref[ref_index][i]= ref2[i] + offset[i];
96         }
97     }
98 }
99
100 static int get_flags(MotionEstContext *c, int direct, int chroma){
101     return   ((c->avctx->flags&CODEC_FLAG_QPEL) ? FLAG_QPEL : 0)
102            + (direct ? FLAG_DIRECT : 0)
103            + (chroma ? FLAG_CHROMA : 0);
104 }
105
106 static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby,
107                       const int size, const int h, int ref_index, int src_index,
108                       me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags){
109     MotionEstContext * const c= &s->me;
110     const int stride= c->stride;
111     const int uvstride= c->uvstride;
112     const int qpel= flags&FLAG_QPEL;
113     const int chroma= flags&FLAG_CHROMA;
114     const int dxy= subx + (suby<<(1+qpel)); //FIXME log2_subpel?
115     const int hx= subx + (x<<(1+qpel));
116     const int hy= suby + (y<<(1+qpel));
117     uint8_t * const * const ref= c->ref[ref_index];
118     uint8_t * const * const src= c->src[src_index];
119     int d;
120     //FIXME check chroma 4mv, (no crashes ...)
121     if(flags&FLAG_DIRECT){
122         if(x >= c->xmin && hx <= c->xmax<<(qpel+1) && y >= c->ymin && hy <= c->ymax<<(qpel+1)){
123             const int time_pp= s->pp_time;
124             const int time_pb= s->pb_time;
125             const int mask= 2*qpel+1;
126             if(s->mv_type==MV_TYPE_8X8){
127                 int i;
128                 for(i=0; i<4; i++){
129                     int fx = c->direct_basis_mv[i][0] + hx;
130                     int fy = c->direct_basis_mv[i][1] + hy;
131                     int bx = hx ? fx - c->co_located_mv[i][0] : c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(qpel+4));
132                     int by = hy ? fy - c->co_located_mv[i][1] : c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(qpel+4));
133                     int fxy= (fx&mask) + ((fy&mask)<<(qpel+1));
134                     int bxy= (bx&mask) + ((by&mask)<<(qpel+1));
135
136                     uint8_t *dst= c->temp + 8*(i&1) + 8*stride*(i>>1);
137                     if(qpel){
138                         c->qpel_put[1][fxy](dst, ref[0] + (fx>>2) + (fy>>2)*stride, stride);
139                         c->qpel_avg[1][bxy](dst, ref[8] + (bx>>2) + (by>>2)*stride, stride);
140                     }else{
141                         c->hpel_put[1][fxy](dst, ref[0] + (fx>>1) + (fy>>1)*stride, stride, 8);
142                         c->hpel_avg[1][bxy](dst, ref[8] + (bx>>1) + (by>>1)*stride, stride, 8);
143                     }
144                 }
145             }else{
146                 int fx = c->direct_basis_mv[0][0] + hx;
147                 int fy = c->direct_basis_mv[0][1] + hy;
148                 int bx = hx ? fx - c->co_located_mv[0][0] : (c->co_located_mv[0][0]*(time_pb - time_pp)/time_pp);
149                 int by = hy ? fy - c->co_located_mv[0][1] : (c->co_located_mv[0][1]*(time_pb - time_pp)/time_pp);
150                 int fxy= (fx&mask) + ((fy&mask)<<(qpel+1));
151                 int bxy= (bx&mask) + ((by&mask)<<(qpel+1));
152
153                 if(qpel){
154                     c->qpel_put[1][fxy](c->temp               , ref[0] + (fx>>2) + (fy>>2)*stride               , stride);
155                     c->qpel_put[1][fxy](c->temp + 8           , ref[0] + (fx>>2) + (fy>>2)*stride + 8           , stride);
156                     c->qpel_put[1][fxy](c->temp     + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride     + 8*stride, stride);
157                     c->qpel_put[1][fxy](c->temp + 8 + 8*stride, ref[0] + (fx>>2) + (fy>>2)*stride + 8 + 8*stride, stride);
158                     c->qpel_avg[1][bxy](c->temp               , ref[8] + (bx>>2) + (by>>2)*stride               , stride);
159                     c->qpel_avg[1][bxy](c->temp + 8           , ref[8] + (bx>>2) + (by>>2)*stride + 8           , stride);
160                     c->qpel_avg[1][bxy](c->temp     + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride     + 8*stride, stride);
161                     c->qpel_avg[1][bxy](c->temp + 8 + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8 + 8*stride, stride);
162                 }else{
163                     assert((fx>>1) + 16*s->mb_x >= -16);
164                     assert((fy>>1) + 16*s->mb_y >= -16);
165                     assert((fx>>1) + 16*s->mb_x <= s->width);
166                     assert((fy>>1) + 16*s->mb_y <= s->height);
167                     assert((bx>>1) + 16*s->mb_x >= -16);
168                     assert((by>>1) + 16*s->mb_y >= -16);
169                     assert((bx>>1) + 16*s->mb_x <= s->width);
170                     assert((by>>1) + 16*s->mb_y <= s->height);
171
172                     c->hpel_put[0][fxy](c->temp, ref[0] + (fx>>1) + (fy>>1)*stride, stride, 16);
173                     c->hpel_avg[0][bxy](c->temp, ref[8] + (bx>>1) + (by>>1)*stride, stride, 16);
174                 }
175             }
176             d = cmp_func(s, c->temp, src[0], stride, 16);
177         }else
178             d= 256*256*256*32;
179     }else{
180         int uvdxy;              /* no, it might not be used uninitialized */
181         if(dxy){
182             if(qpel){
183                 c->qpel_put[size][dxy](c->temp, ref[0] + x + y*stride, stride); //FIXME prototype (add h)
184                 if(chroma){
185                     int cx= hx/2;
186                     int cy= hy/2;
187                     cx= (cx>>1)|(cx&1);
188                     cy= (cy>>1)|(cy&1);
189                     uvdxy= (cx&1) + 2*(cy&1);
190                     //FIXME x/y wrong, but mpeg4 qpel is sick anyway, we should drop as much of it as possible in favor for h264
191                 }
192             }else{
193                 c->hpel_put[size][dxy](c->temp, ref[0] + x + y*stride, stride, h);
194                 if(chroma)
195                     uvdxy= dxy | (x&1) | (2*(y&1));
196             }
197             d = cmp_func(s, c->temp, src[0], stride, h);
198         }else{
199             d = cmp_func(s, src[0], ref[0] + x + y*stride, stride, h);
200             if(chroma)
201                 uvdxy= (x&1) + 2*(y&1);
202         }
203         if(chroma){
204             uint8_t * const uvtemp= c->temp + 16*stride;
205             c->hpel_put[size+1][uvdxy](uvtemp  , ref[1] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1);
206             c->hpel_put[size+1][uvdxy](uvtemp+8, ref[2] + (x>>1) + (y>>1)*uvstride, uvstride, h>>1);
207             d += chroma_cmp_func(s, uvtemp  , src[1], uvstride, h>>1);
208             d += chroma_cmp_func(s, uvtemp+8, src[2], uvstride, h>>1);
209         }
210     }
211 #if 0
212     if(full_pel){
213         const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);
214         score_map[index]= d;
215     }
216
217     d += (c->mv_penalty[hx - c->pred_x] + c->mv_penalty[hy - c->pred_y])*c->penalty_factor;
218 #endif
219     return d;
220 }
221
222 #include "motion_est_template.c"
223
224 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
225     return 0;
226 }
227
228 static void zero_hpel(uint8_t *a, const uint8_t *b, int stride, int h){
229 }
230
231 void ff_init_me(MpegEncContext *s){
232     MotionEstContext * const c= &s->me;
233     c->avctx= s->avctx;
234
235     ff_set_cmp(&s->dsp, s->dsp.me_pre_cmp, c->avctx->me_pre_cmp);
236     ff_set_cmp(&s->dsp, s->dsp.me_cmp, c->avctx->me_cmp);
237     ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, c->avctx->me_sub_cmp);
238     ff_set_cmp(&s->dsp, s->dsp.mb_cmp, c->avctx->mb_cmp);
239
240     c->flags    = get_flags(c, 0, c->avctx->me_cmp    &FF_CMP_CHROMA);
241     c->sub_flags= get_flags(c, 0, c->avctx->me_sub_cmp&FF_CMP_CHROMA);
242     c->mb_flags = get_flags(c, 0, c->avctx->mb_cmp    &FF_CMP_CHROMA);
243
244 /*FIXME s->no_rounding b_type*/
245     if(s->flags&CODEC_FLAG_QPEL){
246         c->sub_motion_search= qpel_motion_search;
247         c->qpel_avg= s->dsp.avg_qpel_pixels_tab;
248         if(s->no_rounding) c->qpel_put= s->dsp.put_no_rnd_qpel_pixels_tab;
249         else               c->qpel_put= s->dsp.put_qpel_pixels_tab;
250     }else{
251         if(c->avctx->me_sub_cmp&FF_CMP_CHROMA)
252             c->sub_motion_search= hpel_motion_search;
253         else if(   c->avctx->me_sub_cmp == FF_CMP_SAD
254                 && c->avctx->    me_cmp == FF_CMP_SAD
255                 && c->avctx->    mb_cmp == FF_CMP_SAD)
256             c->sub_motion_search= sad_hpel_motion_search; // 2050 vs. 2450 cycles
257         else
258             c->sub_motion_search= hpel_motion_search;
259     }
260     c->hpel_avg= s->dsp.avg_pixels_tab;
261     if(s->no_rounding) c->hpel_put= s->dsp.put_no_rnd_pixels_tab;
262     else               c->hpel_put= s->dsp.put_pixels_tab;
263
264     if(s->linesize){
265         c->stride  = s->linesize;
266         c->uvstride= s->uvlinesize;
267     }else{
268         c->stride  = 16*s->mb_width + 32;
269         c->uvstride=  8*s->mb_width + 16;
270     }
271
272     // 8x8 fullpel search would need a 4x4 chroma compare, which we dont have yet, and even if we had the motion estimation code doesnt expect it
273     if(s->codec_id != CODEC_ID_SNOW){
274         if((c->avctx->me_cmp&FF_CMP_CHROMA)/* && !s->dsp.me_cmp[2]*/){
275             s->dsp.me_cmp[2]= zero_cmp;
276         }
277         if((c->avctx->me_sub_cmp&FF_CMP_CHROMA) && !s->dsp.me_sub_cmp[2]){
278             s->dsp.me_sub_cmp[2]= zero_cmp;
279         }
280         c->hpel_put[2][0]= c->hpel_put[2][1]=
281         c->hpel_put[2][2]= c->hpel_put[2][3]= zero_hpel;
282     }
283
284     if(s->codec_id == CODEC_ID_H261){
285         c->sub_motion_search= no_sub_motion_search;
286     }
287
288     c->temp= c->scratchpad;
289 }
290
291 #if 0
292 static int pix_dev(uint8_t * pix, int line_size, int mean)
293 {
294     int s, i, j;
295
296     s = 0;
297     for (i = 0; i < 16; i++) {
298         for (j = 0; j < 16; j += 8) {
299             s += FFABS(pix[0]-mean);
300             s += FFABS(pix[1]-mean);
301             s += FFABS(pix[2]-mean);
302             s += FFABS(pix[3]-mean);
303             s += FFABS(pix[4]-mean);
304             s += FFABS(pix[5]-mean);
305             s += FFABS(pix[6]-mean);
306             s += FFABS(pix[7]-mean);
307             pix += 8;
308         }
309         pix += line_size - 16;
310     }
311     return s;
312 }
313 #endif
314
315 static inline void no_motion_search(MpegEncContext * s,
316                                     int *mx_ptr, int *my_ptr)
317 {
318     *mx_ptr = 16 * s->mb_x;
319     *my_ptr = 16 * s->mb_y;
320 }
321
322 #if 0  /* the use of these functions is inside #if 0 */
323 static int full_motion_search(MpegEncContext * s,
324                               int *mx_ptr, int *my_ptr, int range,
325                               int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
326 {
327     int x1, y1, x2, y2, xx, yy, x, y;
328     int mx, my, dmin, d;
329     uint8_t *pix;
330
331     xx = 16 * s->mb_x;
332     yy = 16 * s->mb_y;
333     x1 = xx - range + 1;        /* we loose one pixel to avoid boundary pb with half pixel pred */
334     if (x1 < xmin)
335         x1 = xmin;
336     x2 = xx + range - 1;
337     if (x2 > xmax)
338         x2 = xmax;
339     y1 = yy - range + 1;
340     if (y1 < ymin)
341         y1 = ymin;
342     y2 = yy + range - 1;
343     if (y2 > ymax)
344         y2 = ymax;
345     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
346     dmin = 0x7fffffff;
347     mx = 0;
348     my = 0;
349     for (y = y1; y <= y2; y++) {
350         for (x = x1; x <= x2; x++) {
351             d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x,
352                              s->linesize, 16);
353             if (d < dmin ||
354                 (d == dmin &&
355                  (abs(x - xx) + abs(y - yy)) <
356                  (abs(mx - xx) + abs(my - yy)))) {
357                 dmin = d;
358                 mx = x;
359                 my = y;
360             }
361         }
362     }
363
364     *mx_ptr = mx;
365     *my_ptr = my;
366
367 #if 0
368     if (*mx_ptr < -(2 * range) || *mx_ptr >= (2 * range) ||
369         *my_ptr < -(2 * range) || *my_ptr >= (2 * range)) {
370         av_log(NULL, AV_LOG_ERROR, "error %d %d\n", *mx_ptr, *my_ptr);
371     }
372 #endif
373     return dmin;
374 }
375
376
377 static int log_motion_search(MpegEncContext * s,
378                              int *mx_ptr, int *my_ptr, int range,
379                              int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
380 {
381     int x1, y1, x2, y2, xx, yy, x, y;
382     int mx, my, dmin, d;
383     uint8_t *pix;
384
385     xx = s->mb_x << 4;
386     yy = s->mb_y << 4;
387
388     /* Left limit */
389     x1 = xx - range;
390     if (x1 < xmin)
391         x1 = xmin;
392
393     /* Right limit */
394     x2 = xx + range;
395     if (x2 > xmax)
396         x2 = xmax;
397
398     /* Upper limit */
399     y1 = yy - range;
400     if (y1 < ymin)
401         y1 = ymin;
402
403     /* Lower limit */
404     y2 = yy + range;
405     if (y2 > ymax)
406         y2 = ymax;
407
408     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
409     dmin = 0x7fffffff;
410     mx = 0;
411     my = 0;
412
413     do {
414         for (y = y1; y <= y2; y += range) {
415             for (x = x1; x <= x2; x += range) {
416                 d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x, s->linesize, 16);
417                 if (d < dmin || (d == dmin && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
418                     dmin = d;
419                     mx = x;
420                     my = y;
421                 }
422             }
423         }
424
425         range = range >> 1;
426
427         x1 = mx - range;
428         if (x1 < xmin)
429             x1 = xmin;
430
431         x2 = mx + range;
432         if (x2 > xmax)
433             x2 = xmax;
434
435         y1 = my - range;
436         if (y1 < ymin)
437             y1 = ymin;
438
439         y2 = my + range;
440         if (y2 > ymax)
441             y2 = ymax;
442
443     } while (range >= 1);
444
445 #ifdef DEBUG
446     av_log(s->avctx, AV_LOG_DEBUG, "log       - MX: %d\tMY: %d\n", mx, my);
447 #endif
448     *mx_ptr = mx;
449     *my_ptr = my;
450     return dmin;
451 }
452
453 static int phods_motion_search(MpegEncContext * s,
454                                int *mx_ptr, int *my_ptr, int range,
455                                int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
456 {
457     int x1, y1, x2, y2, xx, yy, x, y, lastx, d;
458     int mx, my, dminx, dminy;
459     uint8_t *pix;
460
461     xx = s->mb_x << 4;
462     yy = s->mb_y << 4;
463
464     /* Left limit */
465     x1 = xx - range;
466     if (x1 < xmin)
467         x1 = xmin;
468
469     /* Right limit */
470     x2 = xx + range;
471     if (x2 > xmax)
472         x2 = xmax;
473
474     /* Upper limit */
475     y1 = yy - range;
476     if (y1 < ymin)
477         y1 = ymin;
478
479     /* Lower limit */
480     y2 = yy + range;
481     if (y2 > ymax)
482         y2 = ymax;
483
484     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
485     mx = 0;
486     my = 0;
487
488     x = xx;
489     y = yy;
490     do {
491         dminx = 0x7fffffff;
492         dminy = 0x7fffffff;
493
494         lastx = x;
495         for (x = x1; x <= x2; x += range) {
496             d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x, s->linesize, 16);
497             if (d < dminx || (d == dminx && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
498                 dminx = d;
499                 mx = x;
500             }
501         }
502
503         x = lastx;
504         for (y = y1; y <= y2; y += range) {
505             d = s->dsp.pix_abs[0][0](NULL, pix, ref_picture + (y * s->linesize) + x, s->linesize, 16);
506             if (d < dminy || (d == dminy && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
507                 dminy = d;
508                 my = y;
509             }
510         }
511
512         range = range >> 1;
513
514         x = mx;
515         y = my;
516         x1 = mx - range;
517         if (x1 < xmin)
518             x1 = xmin;
519
520         x2 = mx + range;
521         if (x2 > xmax)
522             x2 = xmax;
523
524         y1 = my - range;
525         if (y1 < ymin)
526             y1 = ymin;
527
528         y2 = my + range;
529         if (y2 > ymax)
530             y2 = ymax;
531
532     } while (range >= 1);
533
534 #ifdef DEBUG
535     av_log(s->avctx, AV_LOG_DEBUG, "phods     - MX: %d\tMY: %d\n", mx, my);
536 #endif
537
538     /* half pixel search */
539     *mx_ptr = mx;
540     *my_ptr = my;
541     return dminy;
542 }
543 #endif /* 0 */
544
545 #define Z_THRESHOLD 256
546
547 #define CHECK_SAD_HALF_MV(suffix, x, y) \
548 {\
549     d= s->dsp.pix_abs[size][(x?1:0)+(y?2:0)](NULL, pix, ptr+((x)>>1), stride, h);\
550     d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*penalty_factor;\
551     COPY3_IF_LT(dminh, d, dx, x, dy, y)\
552 }
553
554 static inline int sad_hpel_motion_search(MpegEncContext * s,
555                                   int *mx_ptr, int *my_ptr, int dmin,
556                                   int src_index, int ref_index,
557                                   int size, int h)
558 {
559     MotionEstContext * const c= &s->me;
560     const int penalty_factor= c->sub_penalty_factor;
561     int mx, my, dminh;
562     uint8_t *pix, *ptr;
563     int stride= c->stride;
564     const int flags= c->sub_flags;
565     LOAD_COMMON
566
567     assert(flags == 0);
568
569     if(c->skip){
570 //    printf("S");
571         *mx_ptr = 0;
572         *my_ptr = 0;
573         return dmin;
574     }
575 //    printf("N");
576
577     pix = c->src[src_index][0];
578
579     mx = *mx_ptr;
580     my = *my_ptr;
581     ptr = c->ref[ref_index][0] + (my * stride) + mx;
582
583     dminh = dmin;
584
585     if (mx > xmin && mx < xmax &&
586         my > ymin && my < ymax) {
587         int dx=0, dy=0;
588         int d, pen_x, pen_y;
589         const int index= (my<<ME_MAP_SHIFT) + mx;
590         const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
591         const int l= score_map[(index- 1               )&(ME_MAP_SIZE-1)];
592         const int r= score_map[(index+ 1               )&(ME_MAP_SIZE-1)];
593         const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
594         mx<<=1;
595         my<<=1;
596
597
598         pen_x= pred_x + mx;
599         pen_y= pred_y + my;
600
601         ptr-= stride;
602         if(t<=b){
603             CHECK_SAD_HALF_MV(y2 , 0, -1)
604             if(l<=r){
605                 CHECK_SAD_HALF_MV(xy2, -1, -1)
606                 if(t+r<=b+l){
607                     CHECK_SAD_HALF_MV(xy2, +1, -1)
608                     ptr+= stride;
609                 }else{
610                     ptr+= stride;
611                     CHECK_SAD_HALF_MV(xy2, -1, +1)
612                 }
613                 CHECK_SAD_HALF_MV(x2 , -1,  0)
614             }else{
615                 CHECK_SAD_HALF_MV(xy2, +1, -1)
616                 if(t+l<=b+r){
617                     CHECK_SAD_HALF_MV(xy2, -1, -1)
618                     ptr+= stride;
619                 }else{
620                     ptr+= stride;
621                     CHECK_SAD_HALF_MV(xy2, +1, +1)
622                 }
623                 CHECK_SAD_HALF_MV(x2 , +1,  0)
624             }
625         }else{
626             if(l<=r){
627                 if(t+l<=b+r){
628                     CHECK_SAD_HALF_MV(xy2, -1, -1)
629                     ptr+= stride;
630                 }else{
631                     ptr+= stride;
632                     CHECK_SAD_HALF_MV(xy2, +1, +1)
633                 }
634                 CHECK_SAD_HALF_MV(x2 , -1,  0)
635                 CHECK_SAD_HALF_MV(xy2, -1, +1)
636             }else{
637                 if(t+r<=b+l){
638                     CHECK_SAD_HALF_MV(xy2, +1, -1)
639                     ptr+= stride;
640                 }else{
641                     ptr+= stride;
642                     CHECK_SAD_HALF_MV(xy2, -1, +1)
643                 }
644                 CHECK_SAD_HALF_MV(x2 , +1,  0)
645                 CHECK_SAD_HALF_MV(xy2, +1, +1)
646             }
647             CHECK_SAD_HALF_MV(y2 ,  0, +1)
648         }
649         mx+=dx;
650         my+=dy;
651
652     }else{
653         mx<<=1;
654         my<<=1;
655     }
656
657     *mx_ptr = mx;
658     *my_ptr = my;
659     return dminh;
660 }
661
662 static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4)
663 {
664     const int xy= s->mb_x + s->mb_y*s->mb_stride;
665
666     s->p_mv_table[xy][0] = mx;
667     s->p_mv_table[xy][1] = my;
668
669     /* has already been set to the 4 MV if 4MV is done */
670     if(mv4){
671         int mot_xy= s->block_index[0];
672
673         s->current_picture.motion_val[0][mot_xy  ][0]= mx;
674         s->current_picture.motion_val[0][mot_xy  ][1]= my;
675         s->current_picture.motion_val[0][mot_xy+1][0]= mx;
676         s->current_picture.motion_val[0][mot_xy+1][1]= my;
677
678         mot_xy += s->b8_stride;
679         s->current_picture.motion_val[0][mot_xy  ][0]= mx;
680         s->current_picture.motion_val[0][mot_xy  ][1]= my;
681         s->current_picture.motion_val[0][mot_xy+1][0]= mx;
682         s->current_picture.motion_val[0][mot_xy+1][1]= my;
683     }
684 }
685
686 /**
687  * get fullpel ME search limits.
688  */
689 static inline void get_limits(MpegEncContext *s, int x, int y)
690 {
691     MotionEstContext * const c= &s->me;
692     int range= c->avctx->me_range >> (1 + !!(c->flags&FLAG_QPEL));
693 /*
694     if(c->avctx->me_range) c->range= c->avctx->me_range >> 1;
695     else                   c->range= 16;
696 */
697     if (s->unrestricted_mv) {
698         c->xmin = - x - 16;
699         c->ymin = - y - 16;
700         c->xmax = - x + s->mb_width *16;
701         c->ymax = - y + s->mb_height*16;
702     } else if (s->out_format == FMT_H261){
703         // Search range of H261 is different from other codec standards
704         c->xmin = (x > 15) ? - 15 : 0;
705         c->ymin = (y > 15) ? - 15 : 0;
706         c->xmax = (x < s->mb_width * 16 - 16) ? 15 : 0;
707         c->ymax = (y < s->mb_height * 16 - 16) ? 15 : 0;
708     } else {
709         c->xmin = - x;
710         c->ymin = - y;
711         c->xmax = - x + s->mb_width *16 - 16;
712         c->ymax = - y + s->mb_height*16 - 16;
713     }
714     if(range){
715         c->xmin = FFMAX(c->xmin,-range);
716         c->xmax = FFMIN(c->xmax, range);
717         c->ymin = FFMAX(c->ymin,-range);
718         c->ymax = FFMIN(c->ymax, range);
719     }
720 }
721
722 static inline void init_mv4_ref(MotionEstContext *c){
723     const int stride= c->stride;
724
725     c->ref[1][0] = c->ref[0][0] + 8;
726     c->ref[2][0] = c->ref[0][0] + 8*stride;
727     c->ref[3][0] = c->ref[2][0] + 8;
728     c->src[1][0] = c->src[0][0] + 8;
729     c->src[2][0] = c->src[0][0] + 8*stride;
730     c->src[3][0] = c->src[2][0] + 8;
731 }
732
733 static inline int h263_mv4_search(MpegEncContext *s, int mx, int my, int shift)
734 {
735     MotionEstContext * const c= &s->me;
736     const int size= 1;
737     const int h=8;
738     int block;
739     int P[10][2];
740     int dmin_sum=0, mx4_sum=0, my4_sum=0;
741     int same=1;
742     const int stride= c->stride;
743     uint8_t *mv_penalty= c->current_mv_penalty;
744
745     init_mv4_ref(c);
746
747     for(block=0; block<4; block++){
748         int mx4, my4;
749         int pred_x4, pred_y4;
750         int dmin4;
751         static const int off[4]= {2, 1, 1, -1};
752         const int mot_stride = s->b8_stride;
753         const int mot_xy = s->block_index[block];
754
755         P_LEFT[0] = s->current_picture.motion_val[0][mot_xy - 1][0];
756         P_LEFT[1] = s->current_picture.motion_val[0][mot_xy - 1][1];
757
758         if(P_LEFT[0]       > (c->xmax<<shift)) P_LEFT[0]       = (c->xmax<<shift);
759
760         /* special case for first line */
761         if (s->first_slice_line && block<2) {
762             c->pred_x= pred_x4= P_LEFT[0];
763             c->pred_y= pred_y4= P_LEFT[1];
764         } else {
765             P_TOP[0]      = s->current_picture.motion_val[0][mot_xy - mot_stride             ][0];
766             P_TOP[1]      = s->current_picture.motion_val[0][mot_xy - mot_stride             ][1];
767             P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][0];
768             P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + off[block]][1];
769             if(P_TOP[1]      > (c->ymax<<shift)) P_TOP[1]     = (c->ymax<<shift);
770             if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
771             if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift);
772             if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
773
774             P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
775             P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
776
777             c->pred_x= pred_x4 = P_MEDIAN[0];
778             c->pred_y= pred_y4 = P_MEDIAN[1];
779         }
780         P_MV1[0]= mx;
781         P_MV1[1]= my;
782
783         dmin4 = epzs_motion_search4(s, &mx4, &my4, P, block, block, s->p_mv_table, (1<<16)>>shift);
784
785         dmin4= c->sub_motion_search(s, &mx4, &my4, dmin4, block, block, size, h);
786
787         if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
788             int dxy;
789             const int offset= ((block&1) + (block>>1)*stride)*8;
790             uint8_t *dest_y = c->scratchpad + offset;
791             if(s->quarter_sample){
792                 uint8_t *ref= c->ref[block][0] + (mx4>>2) + (my4>>2)*stride;
793                 dxy = ((my4 & 3) << 2) | (mx4 & 3);
794
795                 if(s->no_rounding)
796                     s->dsp.put_no_rnd_qpel_pixels_tab[1][dxy](dest_y   , ref    , stride);
797                 else
798                     s->dsp.put_qpel_pixels_tab       [1][dxy](dest_y   , ref    , stride);
799             }else{
800                 uint8_t *ref= c->ref[block][0] + (mx4>>1) + (my4>>1)*stride;
801                 dxy = ((my4 & 1) << 1) | (mx4 & 1);
802
803                 if(s->no_rounding)
804                     s->dsp.put_no_rnd_pixels_tab[1][dxy](dest_y    , ref    , stride, h);
805                 else
806                     s->dsp.put_pixels_tab       [1][dxy](dest_y    , ref    , stride, h);
807             }
808             dmin_sum+= (mv_penalty[mx4-pred_x4] + mv_penalty[my4-pred_y4])*c->mb_penalty_factor;
809         }else
810             dmin_sum+= dmin4;
811
812         if(s->quarter_sample){
813             mx4_sum+= mx4/2;
814             my4_sum+= my4/2;
815         }else{
816             mx4_sum+= mx4;
817             my4_sum+= my4;
818         }
819
820         s->current_picture.motion_val[0][ s->block_index[block] ][0]= mx4;
821         s->current_picture.motion_val[0][ s->block_index[block] ][1]= my4;
822
823         if(mx4 != mx || my4 != my) same=0;
824     }
825
826     if(same)
827         return INT_MAX;
828
829     if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
830         dmin_sum += s->dsp.mb_cmp[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*16*stride, c->scratchpad, stride, 16);
831     }
832
833     if(c->avctx->mb_cmp&FF_CMP_CHROMA){
834         int dxy;
835         int mx, my;
836         int offset;
837
838         mx= ff_h263_round_chroma(mx4_sum);
839         my= ff_h263_round_chroma(my4_sum);
840         dxy = ((my & 1) << 1) | (mx & 1);
841
842         offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize;
843
844         if(s->no_rounding){
845             s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);
846             s->dsp.put_no_rnd_pixels_tab[1][dxy](c->scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);
847         }else{
848             s->dsp.put_pixels_tab       [1][dxy](c->scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);
849             s->dsp.put_pixels_tab       [1][dxy](c->scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);
850         }
851
852         dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad  , s->uvlinesize, 8);
853         dmin_sum += s->dsp.mb_cmp[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*8*s->uvlinesize, c->scratchpad+8, s->uvlinesize, 8);
854     }
855
856     c->pred_x= mx;
857     c->pred_y= my;
858
859     switch(c->avctx->mb_cmp&0xFF){
860     /*case FF_CMP_SSE:
861         return dmin_sum+ 32*s->qscale*s->qscale;*/
862     case FF_CMP_RD:
863         return dmin_sum;
864     default:
865         return dmin_sum+ 11*c->mb_penalty_factor;
866     }
867 }
868
869 static inline void init_interlaced_ref(MpegEncContext *s, int ref_index){
870     MotionEstContext * const c= &s->me;
871
872     c->ref[1+ref_index][0] = c->ref[0+ref_index][0] + s->linesize;
873     c->src[1][0] = c->src[0][0] + s->linesize;
874     if(c->flags & FLAG_CHROMA){
875         c->ref[1+ref_index][1] = c->ref[0+ref_index][1] + s->uvlinesize;
876         c->ref[1+ref_index][2] = c->ref[0+ref_index][2] + s->uvlinesize;
877         c->src[1][1] = c->src[0][1] + s->uvlinesize;
878         c->src[1][2] = c->src[0][2] + s->uvlinesize;
879     }
880 }
881
882 static int interlaced_search(MpegEncContext *s, int ref_index,
883                              int16_t (*mv_tables[2][2])[2], uint8_t *field_select_tables[2], int mx, int my, int user_field_select)
884 {
885     MotionEstContext * const c= &s->me;
886     const int size=0;
887     const int h=8;
888     int block;
889     int P[10][2];
890     uint8_t * const mv_penalty= c->current_mv_penalty;
891     int same=1;
892     const int stride= 2*s->linesize;
893     int dmin_sum= 0;
894     const int mot_stride= s->mb_stride;
895     const int xy= s->mb_x + s->mb_y*mot_stride;
896
897     c->ymin>>=1;
898     c->ymax>>=1;
899     c->stride<<=1;
900     c->uvstride<<=1;
901     init_interlaced_ref(s, ref_index);
902
903     for(block=0; block<2; block++){
904         int field_select;
905         int best_dmin= INT_MAX;
906         int best_field= -1;
907
908         for(field_select=0; field_select<2; field_select++){
909             int dmin, mx_i, my_i;
910             int16_t (*mv_table)[2]= mv_tables[block][field_select];
911
912             if(user_field_select){
913                 assert(field_select==0 || field_select==1);
914                 assert(field_select_tables[block][xy]==0 || field_select_tables[block][xy]==1);
915                 if(field_select_tables[block][xy] != field_select)
916                     continue;
917             }
918
919             P_LEFT[0] = mv_table[xy - 1][0];
920             P_LEFT[1] = mv_table[xy - 1][1];
921             if(P_LEFT[0]       > (c->xmax<<1)) P_LEFT[0]       = (c->xmax<<1);
922
923             c->pred_x= P_LEFT[0];
924             c->pred_y= P_LEFT[1];
925
926             if(!s->first_slice_line){
927                 P_TOP[0]      = mv_table[xy - mot_stride][0];
928                 P_TOP[1]      = mv_table[xy - mot_stride][1];
929                 P_TOPRIGHT[0] = mv_table[xy - mot_stride + 1][0];
930                 P_TOPRIGHT[1] = mv_table[xy - mot_stride + 1][1];
931                 if(P_TOP[1]      > (c->ymax<<1)) P_TOP[1]     = (c->ymax<<1);
932                 if(P_TOPRIGHT[0] < (c->xmin<<1)) P_TOPRIGHT[0]= (c->xmin<<1);
933                 if(P_TOPRIGHT[0] > (c->xmax<<1)) P_TOPRIGHT[0]= (c->xmax<<1);
934                 if(P_TOPRIGHT[1] > (c->ymax<<1)) P_TOPRIGHT[1]= (c->ymax<<1);
935
936                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
937                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
938             }
939             P_MV1[0]= mx; //FIXME not correct if block != field_select
940             P_MV1[1]= my / 2;
941
942             dmin = epzs_motion_search2(s, &mx_i, &my_i, P, block, field_select+ref_index, mv_table, (1<<16)>>1);
943
944             dmin= c->sub_motion_search(s, &mx_i, &my_i, dmin, block, field_select+ref_index, size, h);
945
946             mv_table[xy][0]= mx_i;
947             mv_table[xy][1]= my_i;
948
949             if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
950                 int dxy;
951
952                 //FIXME chroma ME
953                 uint8_t *ref= c->ref[field_select+ref_index][0] + (mx_i>>1) + (my_i>>1)*stride;
954                 dxy = ((my_i & 1) << 1) | (mx_i & 1);
955
956                 if(s->no_rounding){
957                     s->dsp.put_no_rnd_pixels_tab[size][dxy](c->scratchpad, ref    , stride, h);
958                 }else{
959                     s->dsp.put_pixels_tab       [size][dxy](c->scratchpad, ref    , stride, h);
960                 }
961                 dmin= s->dsp.mb_cmp[size](s, c->src[block][0], c->scratchpad, stride, h);
962                 dmin+= (mv_penalty[mx_i-c->pred_x] + mv_penalty[my_i-c->pred_y] + 1)*c->mb_penalty_factor;
963             }else
964                 dmin+= c->mb_penalty_factor; //field_select bits
965
966             dmin += field_select != block; //slightly prefer same field
967
968             if(dmin < best_dmin){
969                 best_dmin= dmin;
970                 best_field= field_select;
971             }
972         }
973         {
974             int16_t (*mv_table)[2]= mv_tables[block][best_field];
975
976             if(mv_table[xy][0] != mx) same=0; //FIXME check if these checks work and are any good at all
977             if(mv_table[xy][1]&1) same=0;
978             if(mv_table[xy][1]*2 != my) same=0;
979             if(best_field != block) same=0;
980         }
981
982         field_select_tables[block][xy]= best_field;
983         dmin_sum += best_dmin;
984     }
985
986     c->ymin<<=1;
987     c->ymax<<=1;
988     c->stride>>=1;
989     c->uvstride>>=1;
990
991     if(same)
992         return INT_MAX;
993
994     switch(c->avctx->mb_cmp&0xFF){
995     /*case FF_CMP_SSE:
996         return dmin_sum+ 32*s->qscale*s->qscale;*/
997     case FF_CMP_RD:
998         return dmin_sum;
999     default:
1000         return dmin_sum+ 11*c->mb_penalty_factor;
1001     }
1002 }
1003
1004 static void clip_input_mv(MpegEncContext * s, int16_t *mv, int interlaced){
1005     int ymax= s->me.ymax>>interlaced;
1006     int ymin= s->me.ymin>>interlaced;
1007
1008     if(mv[0] < s->me.xmin) mv[0] = s->me.xmin;
1009     if(mv[0] > s->me.xmax) mv[0] = s->me.xmax;
1010     if(mv[1] <       ymin) mv[1] =       ymin;
1011     if(mv[1] >       ymax) mv[1] =       ymax;
1012 }
1013
1014 static inline int check_input_motion(MpegEncContext * s, int mb_x, int mb_y, int p_type){
1015     MotionEstContext * const c= &s->me;
1016     Picture *p= s->current_picture_ptr;
1017     int mb_xy= mb_x + mb_y*s->mb_stride;
1018     int xy= 2*mb_x + 2*mb_y*s->b8_stride;
1019     int mb_type= s->current_picture.mb_type[mb_xy];
1020     int flags= c->flags;
1021     int shift= (flags&FLAG_QPEL) + 1;
1022     int mask= (1<<shift)-1;
1023     int x, y, i;
1024     int d=0;
1025     me_cmp_func cmpf= s->dsp.sse[0];
1026     me_cmp_func chroma_cmpf= s->dsp.sse[1];
1027
1028     if(p_type && USES_LIST(mb_type, 1)){
1029         av_log(c->avctx, AV_LOG_ERROR, "backward motion vector in P frame\n");
1030         return INT_MAX/2;
1031     }
1032     assert(IS_INTRA(mb_type) || USES_LIST(mb_type,0) || USES_LIST(mb_type,1));
1033
1034     for(i=0; i<4; i++){
1035         int xy= s->block_index[i];
1036         clip_input_mv(s, p->motion_val[0][xy], !!IS_INTERLACED(mb_type));
1037         clip_input_mv(s, p->motion_val[1][xy], !!IS_INTERLACED(mb_type));
1038     }
1039
1040     if(IS_INTERLACED(mb_type)){
1041         int xy2= xy  + s->b8_stride;
1042         s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA;
1043         c->stride<<=1;
1044         c->uvstride<<=1;
1045
1046         if(!(s->flags & CODEC_FLAG_INTERLACED_ME)){
1047             av_log(c->avctx, AV_LOG_ERROR, "Interlaced macroblock selected but interlaced motion estimation disabled\n");
1048             return INT_MAX/2;
1049         }
1050
1051         if(USES_LIST(mb_type, 0)){
1052             int field_select0= p->ref_index[0][xy ];
1053             int field_select1= p->ref_index[0][xy2];
1054             assert(field_select0==0 ||field_select0==1);
1055             assert(field_select1==0 ||field_select1==1);
1056             init_interlaced_ref(s, 0);
1057
1058             if(p_type){
1059                 s->p_field_select_table[0][mb_xy]= field_select0;
1060                 s->p_field_select_table[1][mb_xy]= field_select1;
1061                 *(uint32_t*)s->p_field_mv_table[0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[0][xy ];
1062                 *(uint32_t*)s->p_field_mv_table[1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[0][xy2];
1063                 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER_I;
1064             }else{
1065                 s->b_field_select_table[0][0][mb_xy]= field_select0;
1066                 s->b_field_select_table[0][1][mb_xy]= field_select1;
1067                 *(uint32_t*)s->b_field_mv_table[0][0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[0][xy ];
1068                 *(uint32_t*)s->b_field_mv_table[0][1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[0][xy2];
1069                 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_FORWARD_I;
1070             }
1071
1072             x= p->motion_val[0][xy ][0];
1073             y= p->motion_val[0][xy ][1];
1074             d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0, 0, cmpf, chroma_cmpf, flags);
1075             x= p->motion_val[0][xy2][0];
1076             y= p->motion_val[0][xy2][1];
1077             d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1, 1, cmpf, chroma_cmpf, flags);
1078         }
1079         if(USES_LIST(mb_type, 1)){
1080             int field_select0= p->ref_index[1][xy ];
1081             int field_select1= p->ref_index[1][xy2];
1082             assert(field_select0==0 ||field_select0==1);
1083             assert(field_select1==0 ||field_select1==1);
1084             init_interlaced_ref(s, 2);
1085
1086             s->b_field_select_table[1][0][mb_xy]= field_select0;
1087             s->b_field_select_table[1][1][mb_xy]= field_select1;
1088             *(uint32_t*)s->b_field_mv_table[1][0][field_select0][mb_xy]= *(uint32_t*)p->motion_val[1][xy ];
1089             *(uint32_t*)s->b_field_mv_table[1][1][field_select1][mb_xy]= *(uint32_t*)p->motion_val[1][xy2];
1090             if(USES_LIST(mb_type, 0)){
1091                 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BIDIR_I;
1092             }else{
1093                 s->mb_type[mb_xy]= CANDIDATE_MB_TYPE_BACKWARD_I;
1094             }
1095
1096             x= p->motion_val[1][xy ][0];
1097             y= p->motion_val[1][xy ][1];
1098             d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select0+2, 0, cmpf, chroma_cmpf, flags);
1099             x= p->motion_val[1][xy2][0];
1100             y= p->motion_val[1][xy2][1];
1101             d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 8, field_select1+2, 1, cmpf, chroma_cmpf, flags);
1102             //FIXME bidir scores
1103         }
1104         c->stride>>=1;
1105         c->uvstride>>=1;
1106     }else if(IS_8X8(mb_type)){
1107         if(!(s->flags & CODEC_FLAG_4MV)){
1108             av_log(c->avctx, AV_LOG_ERROR, "4MV macroblock selected but 4MV encoding disabled\n");
1109             return INT_MAX/2;
1110         }
1111         cmpf= s->dsp.sse[1];
1112         chroma_cmpf= s->dsp.sse[1];
1113         init_mv4_ref(c);
1114         for(i=0; i<4; i++){
1115             xy= s->block_index[i];
1116             x= p->motion_val[0][xy][0];
1117             y= p->motion_val[0][xy][1];
1118             d+= cmp(s, x>>shift, y>>shift, x&mask, y&mask, 1, 8, i, i, cmpf, chroma_cmpf, flags);
1119         }
1120         s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER4V;
1121     }else{
1122         if(USES_LIST(mb_type, 0)){
1123             if(p_type){
1124                 *(uint32_t*)s->p_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy];
1125                 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTER;
1126             }else if(USES_LIST(mb_type, 1)){
1127                 *(uint32_t*)s->b_bidir_forw_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy];
1128                 *(uint32_t*)s->b_bidir_back_mv_table[mb_xy]= *(uint32_t*)p->motion_val[1][xy];
1129                 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BIDIR;
1130             }else{
1131                 *(uint32_t*)s->b_forw_mv_table[mb_xy]= *(uint32_t*)p->motion_val[0][xy];
1132                 s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_FORWARD;
1133             }
1134             x= p->motion_val[0][xy][0];
1135             y= p->motion_val[0][xy][1];
1136             d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 0, 0, cmpf, chroma_cmpf, flags);
1137         }else if(USES_LIST(mb_type, 1)){
1138             *(uint32_t*)s->b_back_mv_table[mb_xy]= *(uint32_t*)p->motion_val[1][xy];
1139             s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_BACKWARD;
1140
1141             x= p->motion_val[1][xy][0];
1142             y= p->motion_val[1][xy][1];
1143             d = cmp(s, x>>shift, y>>shift, x&mask, y&mask, 0, 16, 2, 0, cmpf, chroma_cmpf, flags);
1144         }else
1145             s->mb_type[mb_xy]=CANDIDATE_MB_TYPE_INTRA;
1146     }
1147     return d;
1148 }
1149
1150 void ff_estimate_p_frame_motion(MpegEncContext * s,
1151                                 int mb_x, int mb_y)
1152 {
1153     MotionEstContext * const c= &s->me;
1154     uint8_t *pix, *ppix;
1155     int sum, mx, my, dmin;
1156     int varc;            ///< the variance of the block (sum of squared (p[y][x]-average))
1157     int vard;            ///< sum of squared differences with the estimated motion vector
1158     int P[10][2];
1159     const int shift= 1+s->quarter_sample;
1160     int mb_type=0;
1161     Picture * const pic= &s->current_picture;
1162
1163     init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0);
1164
1165     assert(s->quarter_sample==0 || s->quarter_sample==1);
1166     assert(s->linesize == c->stride);
1167     assert(s->uvlinesize == c->uvstride);
1168
1169     c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
1170     c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
1171     c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
1172     c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV;
1173
1174     get_limits(s, 16*mb_x, 16*mb_y);
1175     c->skip=0;
1176
1177     /* intra / predictive decision */
1178     pix = c->src[0][0];
1179     sum = s->dsp.pix_sum(pix, s->linesize);
1180     varc = s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500;
1181
1182     pic->mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
1183     pic->mb_var [s->mb_stride * mb_y + mb_x] = (varc+128)>>8;
1184     c->mb_var_sum_temp += (varc+128)>>8;
1185
1186     if(c->avctx->me_threshold){
1187         vard= check_input_motion(s, mb_x, mb_y, 1);
1188
1189         if((vard+128)>>8 < c->avctx->me_threshold){
1190             int p_score= FFMIN(vard, varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*100);
1191             int i_score= varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*20;
1192             pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = (vard+128)>>8;
1193             c->mc_mb_var_sum_temp += (vard+128)>>8;
1194             c->scene_change_score+= ff_sqrt(p_score) - ff_sqrt(i_score);
1195             return;
1196         }
1197         if((vard+128)>>8 < c->avctx->mb_threshold)
1198             mb_type= s->mb_type[mb_x + mb_y*s->mb_stride];
1199     }
1200
1201     switch(s->me_method) {
1202     case ME_ZERO:
1203     default:
1204         no_motion_search(s, &mx, &my);
1205         mx-= mb_x*16;
1206         my-= mb_y*16;
1207         dmin = 0;
1208         break;
1209 #if 0
1210     case ME_FULL:
1211         dmin = full_motion_search(s, &mx, &my, range, ref_picture);
1212         mx-= mb_x*16;
1213         my-= mb_y*16;
1214         break;
1215     case ME_LOG:
1216         dmin = log_motion_search(s, &mx, &my, range / 2, ref_picture);
1217         mx-= mb_x*16;
1218         my-= mb_y*16;
1219         break;
1220     case ME_PHODS:
1221         dmin = phods_motion_search(s, &mx, &my, range / 2, ref_picture);
1222         mx-= mb_x*16;
1223         my-= mb_y*16;
1224         break;
1225 #endif
1226     case ME_X1:
1227     case ME_EPZS:
1228        {
1229             const int mot_stride = s->b8_stride;
1230             const int mot_xy = s->block_index[0];
1231
1232             P_LEFT[0]       = s->current_picture.motion_val[0][mot_xy - 1][0];
1233             P_LEFT[1]       = s->current_picture.motion_val[0][mot_xy - 1][1];
1234
1235             if(P_LEFT[0]       > (c->xmax<<shift)) P_LEFT[0]       = (c->xmax<<shift);
1236
1237             if(!s->first_slice_line) {
1238                 P_TOP[0]      = s->current_picture.motion_val[0][mot_xy - mot_stride    ][0];
1239                 P_TOP[1]      = s->current_picture.motion_val[0][mot_xy - mot_stride    ][1];
1240                 P_TOPRIGHT[0] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][0];
1241                 P_TOPRIGHT[1] = s->current_picture.motion_val[0][mot_xy - mot_stride + 2][1];
1242                 if(P_TOP[1]      > (c->ymax<<shift)) P_TOP[1]     = (c->ymax<<shift);
1243                 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
1244                 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
1245
1246                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1247                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1248
1249                 if(s->out_format == FMT_H263){
1250                     c->pred_x = P_MEDIAN[0];
1251                     c->pred_y = P_MEDIAN[1];
1252                 }else { /* mpeg1 at least */
1253                     c->pred_x= P_LEFT[0];
1254                     c->pred_y= P_LEFT[1];
1255                 }
1256             }else{
1257                 c->pred_x= P_LEFT[0];
1258                 c->pred_y= P_LEFT[1];
1259             }
1260
1261         }
1262         dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16);
1263
1264         break;
1265     }
1266
1267     /* At this point (mx,my) are full-pell and the relative displacement */
1268     ppix = c->ref[0][0] + (my * s->linesize) + mx;
1269
1270     vard = s->dsp.sse[0](NULL, pix, ppix, s->linesize, 16);
1271
1272     pic->mc_mb_var[s->mb_stride * mb_y + mb_x] = (vard+128)>>8;
1273 //    pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin;
1274     c->mc_mb_var_sum_temp += (vard+128)>>8;
1275
1276 #if 0
1277     printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n",
1278            varc, s->avg_mb_var, sum, vard, mx - xx, my - yy);
1279 #endif
1280     if(mb_type){
1281         int p_score= FFMIN(vard, varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*100);
1282         int i_score= varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*20;
1283         c->scene_change_score+= ff_sqrt(p_score) - ff_sqrt(i_score);
1284
1285         if(mb_type == CANDIDATE_MB_TYPE_INTER){
1286             c->sub_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16);
1287             set_p_mv_tables(s, mx, my, 1);
1288         }else{
1289             mx <<=shift;
1290             my <<=shift;
1291         }
1292         if(mb_type == CANDIDATE_MB_TYPE_INTER4V){
1293             h263_mv4_search(s, mx, my, shift);
1294
1295             set_p_mv_tables(s, mx, my, 0);
1296         }
1297         if(mb_type == CANDIDATE_MB_TYPE_INTER_I){
1298             interlaced_search(s, 0, s->p_field_mv_table, s->p_field_select_table, mx, my, 1);
1299         }
1300     }else if(c->avctx->mb_decision > FF_MB_DECISION_SIMPLE){
1301         int p_score= FFMIN(vard, varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*100);
1302         int i_score= varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*20;
1303         c->scene_change_score+= ff_sqrt(p_score) - ff_sqrt(i_score);
1304
1305         if (vard*2 + 200*256 > varc)
1306             mb_type|= CANDIDATE_MB_TYPE_INTRA;
1307         if (varc*2 + 200*256 > vard || s->qscale > 24){
1308 //        if (varc*2 + 200*256 + 50*(s->lambda2>>FF_LAMBDA_SHIFT) > vard){
1309             mb_type|= CANDIDATE_MB_TYPE_INTER;
1310             c->sub_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16);
1311             if(s->flags&CODEC_FLAG_MV0)
1312                 if(mx || my)
1313                     mb_type |= CANDIDATE_MB_TYPE_SKIPPED; //FIXME check difference
1314         }else{
1315             mx <<=shift;
1316             my <<=shift;
1317         }
1318         if((s->flags&CODEC_FLAG_4MV)
1319            && !c->skip && varc>50<<8 && vard>10<<8){
1320             if(h263_mv4_search(s, mx, my, shift) < INT_MAX)
1321                 mb_type|=CANDIDATE_MB_TYPE_INTER4V;
1322
1323             set_p_mv_tables(s, mx, my, 0);
1324         }else
1325             set_p_mv_tables(s, mx, my, 1);
1326         if((s->flags&CODEC_FLAG_INTERLACED_ME)
1327            && !c->skip){ //FIXME varc/d checks
1328             if(interlaced_search(s, 0, s->p_field_mv_table, s->p_field_select_table, mx, my, 0) < INT_MAX)
1329                 mb_type |= CANDIDATE_MB_TYPE_INTER_I;
1330         }
1331     }else{
1332         int intra_score, i;
1333         mb_type= CANDIDATE_MB_TYPE_INTER;
1334
1335         dmin= c->sub_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16);
1336         if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip)
1337             dmin= ff_get_mb_score(s, mx, my, 0, 0, 0, 16, 1);
1338
1339         if((s->flags&CODEC_FLAG_4MV)
1340            && !c->skip && varc>50<<8 && vard>10<<8){
1341             int dmin4= h263_mv4_search(s, mx, my, shift);
1342             if(dmin4 < dmin){
1343                 mb_type= CANDIDATE_MB_TYPE_INTER4V;
1344                 dmin=dmin4;
1345             }
1346         }
1347         if((s->flags&CODEC_FLAG_INTERLACED_ME)
1348            && !c->skip){ //FIXME varc/d checks
1349             int dmin_i= interlaced_search(s, 0, s->p_field_mv_table, s->p_field_select_table, mx, my, 0);
1350             if(dmin_i < dmin){
1351                 mb_type = CANDIDATE_MB_TYPE_INTER_I;
1352                 dmin= dmin_i;
1353             }
1354         }
1355
1356 //        pic->mb_cmp_score[s->mb_stride * mb_y + mb_x] = dmin;
1357         set_p_mv_tables(s, mx, my, mb_type!=CANDIDATE_MB_TYPE_INTER4V);
1358
1359         /* get intra luma score */
1360         if((c->avctx->mb_cmp&0xFF)==FF_CMP_SSE){
1361             intra_score= varc - 500;
1362         }else{
1363             int mean= (sum+128)>>8;
1364             mean*= 0x01010101;
1365
1366             for(i=0; i<16; i++){
1367                 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 0]) = mean;
1368                 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 4]) = mean;
1369                 *(uint32_t*)(&c->scratchpad[i*s->linesize+ 8]) = mean;
1370                 *(uint32_t*)(&c->scratchpad[i*s->linesize+12]) = mean;
1371             }
1372
1373             intra_score= s->dsp.mb_cmp[0](s, c->scratchpad, pix, s->linesize, 16);
1374         }
1375 #if 0 //FIXME
1376         /* get chroma score */
1377         if(c->avctx->mb_cmp&FF_CMP_CHROMA){
1378             for(i=1; i<3; i++){
1379                 uint8_t *dest_c;
1380                 int mean;
1381
1382                 if(s->out_format == FMT_H263){
1383                     mean= (s->dc_val[i][mb_x + mb_y*s->b8_stride] + 4)>>3; //FIXME not exact but simple ;)
1384                 }else{
1385                     mean= (s->last_dc[i] + 4)>>3;
1386                 }
1387                 dest_c = s->new_picture.data[i] + (mb_y * 8  * (s->uvlinesize)) + mb_x * 8;
1388
1389                 mean*= 0x01010101;
1390                 for(i=0; i<8; i++){
1391                     *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 0]) = mean;
1392                     *(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 4]) = mean;
1393                 }
1394
1395                 intra_score+= s->dsp.mb_cmp[1](s, c->scratchpad, dest_c, s->uvlinesize);
1396             }
1397         }
1398 #endif
1399         intra_score += c->mb_penalty_factor*16;
1400
1401         if(intra_score < dmin){
1402             mb_type= CANDIDATE_MB_TYPE_INTRA;
1403             s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= CANDIDATE_MB_TYPE_INTRA; //FIXME cleanup
1404         }else
1405             s->current_picture.mb_type[mb_y*s->mb_stride + mb_x]= 0;
1406
1407         {
1408             int p_score= FFMIN(vard, varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*100);
1409             int i_score= varc-500+(s->lambda2>>FF_LAMBDA_SHIFT)*20;
1410             c->scene_change_score+= ff_sqrt(p_score) - ff_sqrt(i_score);
1411         }
1412     }
1413
1414     s->mb_type[mb_y*s->mb_stride + mb_x]= mb_type;
1415 }
1416
1417 int ff_pre_estimate_p_frame_motion(MpegEncContext * s,
1418                                     int mb_x, int mb_y)
1419 {
1420     MotionEstContext * const c= &s->me;
1421     int mx, my, dmin;
1422     int P[10][2];
1423     const int shift= 1+s->quarter_sample;
1424     const int xy= mb_x + mb_y*s->mb_stride;
1425     init_ref(c, s->new_picture.data, s->last_picture.data, NULL, 16*mb_x, 16*mb_y, 0);
1426
1427     assert(s->quarter_sample==0 || s->quarter_sample==1);
1428
1429     c->pre_penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_pre_cmp);
1430     c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV;
1431
1432     get_limits(s, 16*mb_x, 16*mb_y);
1433     c->skip=0;
1434
1435     P_LEFT[0]       = s->p_mv_table[xy + 1][0];
1436     P_LEFT[1]       = s->p_mv_table[xy + 1][1];
1437
1438     if(P_LEFT[0]       < (c->xmin<<shift)) P_LEFT[0]       = (c->xmin<<shift);
1439
1440     /* special case for first line */
1441     if (s->first_slice_line) {
1442         c->pred_x= P_LEFT[0];
1443         c->pred_y= P_LEFT[1];
1444         P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]=
1445         P_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0; //FIXME
1446     } else {
1447         P_TOP[0]      = s->p_mv_table[xy + s->mb_stride    ][0];
1448         P_TOP[1]      = s->p_mv_table[xy + s->mb_stride    ][1];
1449         P_TOPRIGHT[0] = s->p_mv_table[xy + s->mb_stride - 1][0];
1450         P_TOPRIGHT[1] = s->p_mv_table[xy + s->mb_stride - 1][1];
1451         if(P_TOP[1]      < (c->ymin<<shift)) P_TOP[1]     = (c->ymin<<shift);
1452         if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift);
1453         if(P_TOPRIGHT[1] < (c->ymin<<shift)) P_TOPRIGHT[1]= (c->ymin<<shift);
1454
1455         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1456         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1457
1458         c->pred_x = P_MEDIAN[0];
1459         c->pred_y = P_MEDIAN[1];
1460     }
1461
1462     dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, s->p_mv_table, (1<<16)>>shift, 0, 16);
1463
1464     s->p_mv_table[xy][0] = mx<<shift;
1465     s->p_mv_table[xy][1] = my<<shift;
1466
1467     return dmin;
1468 }
1469
1470 static int ff_estimate_motion_b(MpegEncContext * s,
1471                        int mb_x, int mb_y, int16_t (*mv_table)[2], int ref_index, int f_code)
1472 {
1473     MotionEstContext * const c= &s->me;
1474     int mx, my, dmin;
1475     int P[10][2];
1476     const int shift= 1+s->quarter_sample;
1477     const int mot_stride = s->mb_stride;
1478     const int mot_xy = mb_y*mot_stride + mb_x;
1479     uint8_t * const mv_penalty= c->mv_penalty[f_code] + MAX_MV;
1480     int mv_scale;
1481
1482     c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
1483     c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
1484     c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
1485     c->current_mv_penalty= mv_penalty;
1486
1487     get_limits(s, 16*mb_x, 16*mb_y);
1488
1489     switch(s->me_method) {
1490     case ME_ZERO:
1491     default:
1492         no_motion_search(s, &mx, &my);
1493         dmin = 0;
1494         mx-= mb_x*16;
1495         my-= mb_y*16;
1496         break;
1497 #if 0
1498     case ME_FULL:
1499         dmin = full_motion_search(s, &mx, &my, range, ref_picture);
1500         mx-= mb_x*16;
1501         my-= mb_y*16;
1502         break;
1503     case ME_LOG:
1504         dmin = log_motion_search(s, &mx, &my, range / 2, ref_picture);
1505         mx-= mb_x*16;
1506         my-= mb_y*16;
1507         break;
1508     case ME_PHODS:
1509         dmin = phods_motion_search(s, &mx, &my, range / 2, ref_picture);
1510         mx-= mb_x*16;
1511         my-= mb_y*16;
1512         break;
1513 #endif
1514     case ME_X1:
1515     case ME_EPZS:
1516        {
1517             P_LEFT[0]        = mv_table[mot_xy - 1][0];
1518             P_LEFT[1]        = mv_table[mot_xy - 1][1];
1519
1520             if(P_LEFT[0]       > (c->xmax<<shift)) P_LEFT[0]       = (c->xmax<<shift);
1521
1522             /* special case for first line */
1523             if (!s->first_slice_line) {
1524                 P_TOP[0] = mv_table[mot_xy - mot_stride             ][0];
1525                 P_TOP[1] = mv_table[mot_xy - mot_stride             ][1];
1526                 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1         ][0];
1527                 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1         ][1];
1528                 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1]= (c->ymax<<shift);
1529                 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
1530                 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
1531
1532                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1533                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1534             }
1535             c->pred_x= P_LEFT[0];
1536             c->pred_y= P_LEFT[1];
1537         }
1538
1539         if(mv_table == s->b_forw_mv_table){
1540             mv_scale= (s->pb_time<<16) / (s->pp_time<<shift);
1541         }else{
1542             mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift);
1543         }
1544
1545         dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, ref_index, s->p_mv_table, mv_scale, 0, 16);
1546
1547         break;
1548     }
1549
1550     dmin= c->sub_motion_search(s, &mx, &my, dmin, 0, ref_index, 0, 16);
1551
1552     if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip)
1553         dmin= ff_get_mb_score(s, mx, my, 0, ref_index, 0, 16, 1);
1554
1555 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);
1556 //    s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1557     mv_table[mot_xy][0]= mx;
1558     mv_table[mot_xy][1]= my;
1559
1560     return dmin;
1561 }
1562
1563 static inline int check_bidir_mv(MpegEncContext * s,
1564                    int motion_fx, int motion_fy,
1565                    int motion_bx, int motion_by,
1566                    int pred_fx, int pred_fy,
1567                    int pred_bx, int pred_by,
1568                    int size, int h)
1569 {
1570     //FIXME optimize?
1571     //FIXME better f_code prediction (max mv & distance)
1572     //FIXME pointers
1573     MotionEstContext * const c= &s->me;
1574     uint8_t * const mv_penalty_f= c->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
1575     uint8_t * const mv_penalty_b= c->mv_penalty[s->b_code] + MAX_MV; // f_code of the prev frame
1576     int stride= c->stride;
1577     uint8_t *dest_y = c->scratchpad;
1578     uint8_t *ptr;
1579     int dxy;
1580     int src_x, src_y;
1581     int fbmin;
1582     uint8_t **src_data= c->src[0];
1583     uint8_t **ref_data= c->ref[0];
1584     uint8_t **ref2_data= c->ref[2];
1585
1586     if(s->quarter_sample){
1587         dxy = ((motion_fy & 3) << 2) | (motion_fx & 3);
1588         src_x = motion_fx >> 2;
1589         src_y = motion_fy >> 2;
1590
1591         ptr = ref_data[0] + (src_y * stride) + src_x;
1592         s->dsp.put_qpel_pixels_tab[0][dxy](dest_y    , ptr    , stride);
1593
1594         dxy = ((motion_by & 3) << 2) | (motion_bx & 3);
1595         src_x = motion_bx >> 2;
1596         src_y = motion_by >> 2;
1597
1598         ptr = ref2_data[0] + (src_y * stride) + src_x;
1599         s->dsp.avg_qpel_pixels_tab[size][dxy](dest_y    , ptr    , stride);
1600     }else{
1601         dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
1602         src_x = motion_fx >> 1;
1603         src_y = motion_fy >> 1;
1604
1605         ptr = ref_data[0] + (src_y * stride) + src_x;
1606         s->dsp.put_pixels_tab[size][dxy](dest_y    , ptr    , stride, h);
1607
1608         dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
1609         src_x = motion_bx >> 1;
1610         src_y = motion_by >> 1;
1611
1612         ptr = ref2_data[0] + (src_y * stride) + src_x;
1613         s->dsp.avg_pixels_tab[size][dxy](dest_y    , ptr    , stride, h);
1614     }
1615
1616     fbmin = (mv_penalty_f[motion_fx-pred_fx] + mv_penalty_f[motion_fy-pred_fy])*c->mb_penalty_factor
1617            +(mv_penalty_b[motion_bx-pred_bx] + mv_penalty_b[motion_by-pred_by])*c->mb_penalty_factor
1618            + s->dsp.mb_cmp[size](s, src_data[0], dest_y, stride, h); //FIXME new_pic
1619
1620     if(c->avctx->mb_cmp&FF_CMP_CHROMA){
1621     }
1622     //FIXME CHROMA !!!
1623
1624     return fbmin;
1625 }
1626
1627 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
1628 static inline int bidir_refine(MpegEncContext * s, int mb_x, int mb_y)
1629 {
1630     MotionEstContext * const c= &s->me;
1631     const int mot_stride = s->mb_stride;
1632     const int xy = mb_y *mot_stride + mb_x;
1633     int fbmin;
1634     int pred_fx= s->b_bidir_forw_mv_table[xy-1][0];
1635     int pred_fy= s->b_bidir_forw_mv_table[xy-1][1];
1636     int pred_bx= s->b_bidir_back_mv_table[xy-1][0];
1637     int pred_by= s->b_bidir_back_mv_table[xy-1][1];
1638     int motion_fx= s->b_bidir_forw_mv_table[xy][0]= s->b_forw_mv_table[xy][0];
1639     int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1];
1640     int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0];
1641     int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1];
1642     const int flags= c->sub_flags;
1643     const int qpel= flags&FLAG_QPEL;
1644     const int shift= 1+qpel;
1645     const int xmin= c->xmin<<shift;
1646     const int ymin= c->ymin<<shift;
1647     const int xmax= c->xmax<<shift;
1648     const int ymax= c->ymax<<shift;
1649     uint8_t map[8][8][8][8];
1650
1651     memset(map,0,sizeof(map));
1652 #define BIDIR_MAP(fx,fy,bx,by) \
1653     map[(motion_fx+fx)&7][(motion_fy+fy)&7][(motion_bx+bx)&7][(motion_by+by)&7]
1654     BIDIR_MAP(0,0,0,0) = 1;
1655
1656     fbmin= check_bidir_mv(s, motion_fx, motion_fy,
1657                           motion_bx, motion_by,
1658                           pred_fx, pred_fy,
1659                           pred_bx, pred_by,
1660                           0, 16);
1661
1662     if(s->avctx->bidir_refine){
1663         int score, end;
1664 #define CHECK_BIDIR(fx,fy,bx,by)\
1665     if( !BIDIR_MAP(fx,fy,bx,by)\
1666        &&(fx<=0 || motion_fx+fx<=xmax) && (fy<=0 || motion_fy+fy<=ymax) && (bx<=0 || motion_bx+bx<=xmax) && (by<=0 || motion_by+by<=ymax)\
1667        &&(fx>=0 || motion_fx+fx>=xmin) && (fy>=0 || motion_fy+fy>=ymin) && (bx>=0 || motion_bx+bx>=xmin) && (by>=0 || motion_by+by>=ymin)){\
1668         BIDIR_MAP(fx,fy,bx,by) = 1;\
1669         score= check_bidir_mv(s, motion_fx+fx, motion_fy+fy, motion_bx+bx, motion_by+by, pred_fx, pred_fy, pred_bx, pred_by, 0, 16);\
1670         if(score < fbmin){\
1671             fbmin= score;\
1672             motion_fx+=fx;\
1673             motion_fy+=fy;\
1674             motion_bx+=bx;\
1675             motion_by+=by;\
1676             end=0;\
1677         }\
1678     }
1679 #define CHECK_BIDIR2(a,b,c,d)\
1680 CHECK_BIDIR(a,b,c,d)\
1681 CHECK_BIDIR(-(a),-(b),-(c),-(d))
1682
1683 #define CHECK_BIDIRR(a,b,c,d)\
1684 CHECK_BIDIR2(a,b,c,d)\
1685 CHECK_BIDIR2(b,c,d,a)\
1686 CHECK_BIDIR2(c,d,a,b)\
1687 CHECK_BIDIR2(d,a,b,c)
1688
1689         do{
1690             end=1;
1691
1692             CHECK_BIDIRR( 0, 0, 0, 1)
1693             if(s->avctx->bidir_refine > 1){
1694                 CHECK_BIDIRR( 0, 0, 1, 1)
1695                 CHECK_BIDIR2( 0, 1, 0, 1)
1696                 CHECK_BIDIR2( 1, 0, 1, 0)
1697                 CHECK_BIDIRR( 0, 0,-1, 1)
1698                 CHECK_BIDIR2( 0,-1, 0, 1)
1699                 CHECK_BIDIR2(-1, 0, 1, 0)
1700                 if(s->avctx->bidir_refine > 2){
1701                     CHECK_BIDIRR( 0, 1, 1, 1)
1702                     CHECK_BIDIRR( 0,-1, 1, 1)
1703                     CHECK_BIDIRR( 0, 1,-1, 1)
1704                     CHECK_BIDIRR( 0, 1, 1,-1)
1705                     if(s->avctx->bidir_refine > 3){
1706                         CHECK_BIDIR2( 1, 1, 1, 1)
1707                         CHECK_BIDIRR( 1, 1, 1,-1)
1708                         CHECK_BIDIR2( 1, 1,-1,-1)
1709                         CHECK_BIDIR2( 1,-1,-1, 1)
1710                         CHECK_BIDIR2( 1,-1, 1,-1)
1711                     }
1712                 }
1713             }
1714         }while(!end);
1715     }
1716
1717     s->b_bidir_forw_mv_table[xy][0]= motion_fx;
1718     s->b_bidir_forw_mv_table[xy][1]= motion_fy;
1719     s->b_bidir_back_mv_table[xy][0]= motion_bx;
1720     s->b_bidir_back_mv_table[xy][1]= motion_by;
1721
1722     return fbmin;
1723 }
1724
1725 static inline int direct_search(MpegEncContext * s, int mb_x, int mb_y)
1726 {
1727     MotionEstContext * const c= &s->me;
1728     int P[10][2];
1729     const int mot_stride = s->mb_stride;
1730     const int mot_xy = mb_y*mot_stride + mb_x;
1731     const int shift= 1+s->quarter_sample;
1732     int dmin, i;
1733     const int time_pp= s->pp_time;
1734     const int time_pb= s->pb_time;
1735     int mx, my, xmin, xmax, ymin, ymax;
1736     int16_t (*mv_table)[2]= s->b_direct_mv_table;
1737
1738     c->current_mv_penalty= c->mv_penalty[1] + MAX_MV;
1739     ymin= xmin=(-32)>>shift;
1740     ymax= xmax=   31>>shift;
1741
1742     if(IS_8X8(s->next_picture.mb_type[mot_xy])){
1743         s->mv_type= MV_TYPE_8X8;
1744     }else{
1745         s->mv_type= MV_TYPE_16X16;
1746     }
1747
1748     for(i=0; i<4; i++){
1749         int index= s->block_index[i];
1750         int min, max;
1751
1752         c->co_located_mv[i][0]= s->next_picture.motion_val[0][index][0];
1753         c->co_located_mv[i][1]= s->next_picture.motion_val[0][index][1];
1754         c->direct_basis_mv[i][0]= c->co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3));
1755         c->direct_basis_mv[i][1]= c->co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3));
1756 //        c->direct_basis_mv[1][i][0]= c->co_located_mv[i][0]*(time_pb - time_pp)/time_pp + ((i &1)<<(shift+3);
1757 //        c->direct_basis_mv[1][i][1]= c->co_located_mv[i][1]*(time_pb - time_pp)/time_pp + ((i>>1)<<(shift+3);
1758
1759         max= FFMAX(c->direct_basis_mv[i][0], c->direct_basis_mv[i][0] - c->co_located_mv[i][0])>>shift;
1760         min= FFMIN(c->direct_basis_mv[i][0], c->direct_basis_mv[i][0] - c->co_located_mv[i][0])>>shift;
1761         max+= 16*mb_x + 1; // +-1 is for the simpler rounding
1762         min+= 16*mb_x - 1;
1763         xmax= FFMIN(xmax, s->width - max);
1764         xmin= FFMAX(xmin, - 16     - min);
1765
1766         max= FFMAX(c->direct_basis_mv[i][1], c->direct_basis_mv[i][1] - c->co_located_mv[i][1])>>shift;
1767         min= FFMIN(c->direct_basis_mv[i][1], c->direct_basis_mv[i][1] - c->co_located_mv[i][1])>>shift;
1768         max+= 16*mb_y + 1; // +-1 is for the simpler rounding
1769         min+= 16*mb_y - 1;
1770         ymax= FFMIN(ymax, s->height - max);
1771         ymin= FFMAX(ymin, - 16      - min);
1772
1773         if(s->mv_type == MV_TYPE_16X16) break;
1774     }
1775
1776     assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);
1777
1778     if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){
1779         s->b_direct_mv_table[mot_xy][0]= 0;
1780         s->b_direct_mv_table[mot_xy][1]= 0;
1781
1782         return 256*256*256*64;
1783     }
1784
1785     c->xmin= xmin;
1786     c->ymin= ymin;
1787     c->xmax= xmax;
1788     c->ymax= ymax;
1789     c->flags     |= FLAG_DIRECT;
1790     c->sub_flags |= FLAG_DIRECT;
1791     c->pred_x=0;
1792     c->pred_y=0;
1793
1794     P_LEFT[0]        = clip(mv_table[mot_xy - 1][0], xmin<<shift, xmax<<shift);
1795     P_LEFT[1]        = clip(mv_table[mot_xy - 1][1], ymin<<shift, ymax<<shift);
1796
1797     /* special case for first line */
1798     if (!s->first_slice_line) { //FIXME maybe allow this over thread boundary as its clipped
1799         P_TOP[0]      = clip(mv_table[mot_xy - mot_stride             ][0], xmin<<shift, xmax<<shift);
1800         P_TOP[1]      = clip(mv_table[mot_xy - mot_stride             ][1], ymin<<shift, ymax<<shift);
1801         P_TOPRIGHT[0] = clip(mv_table[mot_xy - mot_stride + 1         ][0], xmin<<shift, xmax<<shift);
1802         P_TOPRIGHT[1] = clip(mv_table[mot_xy - mot_stride + 1         ][1], ymin<<shift, ymax<<shift);
1803
1804         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1805         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1806     }
1807
1808     dmin = ff_epzs_motion_search(s, &mx, &my, P, 0, 0, mv_table, 1<<(16-shift), 0, 16);
1809     if(c->sub_flags&FLAG_QPEL)
1810         dmin = qpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16);
1811     else
1812         dmin = hpel_motion_search(s, &mx, &my, dmin, 0, 0, 0, 16);
1813
1814     if(c->avctx->me_sub_cmp != c->avctx->mb_cmp && !c->skip)
1815         dmin= ff_get_mb_score(s, mx, my, 0, 0, 0, 16, 1);
1816
1817     get_limits(s, 16*mb_x, 16*mb_y); //restore c->?min/max, maybe not needed
1818
1819     s->b_direct_mv_table[mot_xy][0]= mx;
1820     s->b_direct_mv_table[mot_xy][1]= my;
1821     c->flags     &= ~FLAG_DIRECT;
1822     c->sub_flags &= ~FLAG_DIRECT;
1823
1824     return dmin;
1825 }
1826
1827 void ff_estimate_b_frame_motion(MpegEncContext * s,
1828                              int mb_x, int mb_y)
1829 {
1830     MotionEstContext * const c= &s->me;
1831     const int penalty_factor= c->mb_penalty_factor;
1832     int fmin, bmin, dmin, fbmin, bimin, fimin;
1833     int type=0;
1834     const int xy = mb_y*s->mb_stride + mb_x;
1835     init_ref(c, s->new_picture.data, s->last_picture.data, s->next_picture.data, 16*mb_x, 16*mb_y, 2);
1836
1837     get_limits(s, 16*mb_x, 16*mb_y);
1838
1839     c->skip=0;
1840     if(c->avctx->me_threshold){
1841         int vard= check_input_motion(s, mb_x, mb_y, 0);
1842
1843         if((vard+128)>>8 < c->avctx->me_threshold){
1844 //            pix = c->src[0][0];
1845 //            sum = s->dsp.pix_sum(pix, s->linesize);
1846 //            varc = s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500;
1847
1848 //            pic->mb_var   [s->mb_stride * mb_y + mb_x] = (varc+128)>>8;
1849              s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] = (vard+128)>>8;
1850 /*            pic->mb_mean  [s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
1851             c->mb_var_sum_temp    += (varc+128)>>8;*/
1852             c->mc_mb_var_sum_temp += (vard+128)>>8;
1853 /*            if (vard <= 64<<8 || vard < varc) {
1854                 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1855             }else{
1856                 c->scene_change_score+= s->qscale * s->avctx->scenechange_factor;
1857             }*/
1858             return;
1859         }
1860         if((vard+128)>>8 < c->avctx->mb_threshold){
1861             type= s->mb_type[mb_y*s->mb_stride + mb_x];
1862             if(type == CANDIDATE_MB_TYPE_DIRECT){
1863                 direct_search(s, mb_x, mb_y);
1864             }
1865             if(type == CANDIDATE_MB_TYPE_FORWARD || type == CANDIDATE_MB_TYPE_BIDIR){
1866                 c->skip=0;
1867                 ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, 0, s->f_code);
1868             }
1869             if(type == CANDIDATE_MB_TYPE_BACKWARD || type == CANDIDATE_MB_TYPE_BIDIR){
1870                 c->skip=0;
1871                 ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, 2, s->b_code);
1872             }
1873             if(type == CANDIDATE_MB_TYPE_FORWARD_I || type == CANDIDATE_MB_TYPE_BIDIR_I){
1874                 c->skip=0;
1875                 c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV;
1876                 interlaced_search(s, 0,
1877                                         s->b_field_mv_table[0], s->b_field_select_table[0],
1878                                         s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1], 1);
1879             }
1880             if(type == CANDIDATE_MB_TYPE_BACKWARD_I || type == CANDIDATE_MB_TYPE_BIDIR_I){
1881                 c->skip=0;
1882                 c->current_mv_penalty= c->mv_penalty[s->b_code] + MAX_MV;
1883                 interlaced_search(s, 2,
1884                                         s->b_field_mv_table[1], s->b_field_select_table[1],
1885                                         s->b_back_mv_table[xy][0], s->b_back_mv_table[xy][1], 1);
1886             }
1887             return;
1888         }
1889     }
1890
1891     if (s->codec_id == CODEC_ID_MPEG4)
1892         dmin= direct_search(s, mb_x, mb_y);
1893     else
1894         dmin= INT_MAX;
1895 //FIXME penalty stuff for non mpeg4
1896     c->skip=0;
1897     fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, 0, s->f_code) + 3*penalty_factor;
1898
1899     c->skip=0;
1900     bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, 2, s->b_code) + 2*penalty_factor;
1901 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]);
1902
1903     c->skip=0;
1904     fbmin= bidir_refine(s, mb_x, mb_y) + penalty_factor;
1905 //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin);
1906
1907     if(s->flags & CODEC_FLAG_INTERLACED_ME){
1908 //FIXME mb type penalty
1909         c->skip=0;
1910         c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV;
1911         fimin= interlaced_search(s, 0,
1912                                  s->b_field_mv_table[0], s->b_field_select_table[0],
1913                                  s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1], 0);
1914         c->current_mv_penalty= c->mv_penalty[s->b_code] + MAX_MV;
1915         bimin= interlaced_search(s, 2,
1916                                  s->b_field_mv_table[1], s->b_field_select_table[1],
1917                                  s->b_back_mv_table[xy][0], s->b_back_mv_table[xy][1], 0);
1918     }else
1919         fimin= bimin= INT_MAX;
1920
1921     {
1922         int score= fmin;
1923         type = CANDIDATE_MB_TYPE_FORWARD;
1924
1925         if (dmin <= score){
1926             score = dmin;
1927             type = CANDIDATE_MB_TYPE_DIRECT;
1928         }
1929         if(bmin<score){
1930             score=bmin;
1931             type= CANDIDATE_MB_TYPE_BACKWARD;
1932         }
1933         if(fbmin<score){
1934             score=fbmin;
1935             type= CANDIDATE_MB_TYPE_BIDIR;
1936         }
1937         if(fimin<score){
1938             score=fimin;
1939             type= CANDIDATE_MB_TYPE_FORWARD_I;
1940         }
1941         if(bimin<score){
1942             score=bimin;
1943             type= CANDIDATE_MB_TYPE_BACKWARD_I;
1944         }
1945
1946         score= ((unsigned)(score*score + 128*256))>>16;
1947         c->mc_mb_var_sum_temp += score;
1948         s->current_picture.mc_mb_var[mb_y*s->mb_stride + mb_x] = score; //FIXME use SSE
1949     }
1950
1951     if(c->avctx->mb_decision > FF_MB_DECISION_SIMPLE){
1952         type= CANDIDATE_MB_TYPE_FORWARD | CANDIDATE_MB_TYPE_BACKWARD | CANDIDATE_MB_TYPE_BIDIR | CANDIDATE_MB_TYPE_DIRECT;
1953         if(fimin < INT_MAX)
1954             type |= CANDIDATE_MB_TYPE_FORWARD_I;
1955         if(bimin < INT_MAX)
1956             type |= CANDIDATE_MB_TYPE_BACKWARD_I;
1957         if(fimin < INT_MAX && bimin < INT_MAX){
1958             type |= CANDIDATE_MB_TYPE_BIDIR_I;
1959         }
1960          //FIXME something smarter
1961         if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB
1962 #if 0
1963         if(s->out_format == FMT_MPEG1)
1964             type |= CANDIDATE_MB_TYPE_INTRA;
1965 #endif
1966     }
1967
1968     s->mb_type[mb_y*s->mb_stride + mb_x]= type;
1969 }
1970
1971 /* find best f_code for ME which do unlimited searches */
1972 int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
1973 {
1974     if(s->me_method>=ME_EPZS){
1975         int score[8];
1976         int i, y, range= s->avctx->me_range ? s->avctx->me_range : (INT_MAX/2);
1977         uint8_t * fcode_tab= s->fcode_tab;
1978         int best_fcode=-1;
1979         int best_score=-10000000;
1980
1981         if(s->msmpeg4_version)
1982             range= FFMIN(range, 16);
1983         else if(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL)
1984             range= FFMIN(range, 256);
1985
1986         for(i=0; i<8; i++) score[i]= s->mb_num*(8-i);
1987
1988         for(y=0; y<s->mb_height; y++){
1989             int x;
1990             int xy= y*s->mb_stride;
1991             for(x=0; x<s->mb_width; x++){
1992                 if(s->mb_type[xy] & type){
1993                     int mx= mv_table[xy][0];
1994                     int my= mv_table[xy][1];
1995                     int fcode= FFMAX(fcode_tab[mx + MAX_MV],
1996                                      fcode_tab[my + MAX_MV]);
1997                     int j;
1998
1999                         if(mx >= range || mx < -range ||
2000                            my >= range || my < -range)
2001                             continue;
2002
2003                     for(j=0; j<fcode && j<8; j++){
2004                         if(s->pict_type==B_TYPE || s->current_picture.mc_mb_var[xy] < s->current_picture.mb_var[xy])
2005                             score[j]-= 170;
2006                     }
2007                 }
2008                 xy++;
2009             }
2010         }
2011
2012         for(i=1; i<8; i++){
2013             if(score[i] > best_score){
2014                 best_score= score[i];
2015                 best_fcode= i;
2016             }
2017 //            printf("%d %d\n", i, score[i]);
2018         }
2019
2020 //    printf("fcode: %d type: %d\n", i, s->pict_type);
2021         return best_fcode;
2022 /*        for(i=0; i<=MAX_FCODE; i++){
2023             printf("%d ", mv_num[i]);
2024         }
2025         printf("\n");*/
2026     }else{
2027         return 1;
2028     }
2029 }
2030
2031 void ff_fix_long_p_mvs(MpegEncContext * s)
2032 {
2033     MotionEstContext * const c= &s->me;
2034     const int f_code= s->f_code;
2035     int y, range;
2036     assert(s->pict_type==P_TYPE);
2037
2038     range = (((s->out_format == FMT_MPEG1 || s->msmpeg4_version) ? 8 : 16) << f_code);
2039
2040     assert(range <= 16 || !s->msmpeg4_version);
2041     assert(range <=256 || !(s->codec_id == CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL));
2042
2043     if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range;
2044
2045 //printf("%d no:%d %d//\n", clip, noclip, f_code);
2046     if(s->flags&CODEC_FLAG_4MV){
2047         const int wrap= s->b8_stride;
2048
2049         /* clip / convert to intra 8x8 type MVs */
2050         for(y=0; y<s->mb_height; y++){
2051             int xy= y*2*wrap;
2052             int i= y*s->mb_stride;
2053             int x;
2054
2055             for(x=0; x<s->mb_width; x++){
2056                 if(s->mb_type[i]&CANDIDATE_MB_TYPE_INTER4V){
2057                     int block;
2058                     for(block=0; block<4; block++){
2059                         int off= (block& 1) + (block>>1)*wrap;
2060                         int mx= s->current_picture.motion_val[0][ xy + off ][0];
2061                         int my= s->current_picture.motion_val[0][ xy + off ][1];
2062
2063                         if(   mx >=range || mx <-range
2064                            || my >=range || my <-range){
2065                             s->mb_type[i] &= ~CANDIDATE_MB_TYPE_INTER4V;
2066                             s->mb_type[i] |= CANDIDATE_MB_TYPE_INTRA;
2067                             s->current_picture.mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
2068                         }
2069                     }
2070                 }
2071                 xy+=2;
2072                 i++;
2073             }
2074         }
2075     }
2076 }
2077
2078 /**
2079  *
2080  * @param truncate 1 for truncation, 0 for using intra
2081  */
2082 void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_select,
2083                      int16_t (*mv_table)[2], int f_code, int type, int truncate)
2084 {
2085     MotionEstContext * const c= &s->me;
2086     int y, h_range, v_range;
2087
2088     // RAL: 8 in MPEG-1, 16 in MPEG-4
2089     int range = (((s->out_format == FMT_MPEG1 || s->msmpeg4_version) ? 8 : 16) << f_code);
2090
2091     if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range;
2092
2093     h_range= range;
2094     v_range= field_select_table ? range>>1 : range;
2095
2096     /* clip / convert to intra 16x16 type MVs */
2097     for(y=0; y<s->mb_height; y++){
2098         int x;
2099         int xy= y*s->mb_stride;
2100         for(x=0; x<s->mb_width; x++){
2101             if (s->mb_type[xy] & type){    // RAL: "type" test added...
2102                 if(field_select_table==NULL || field_select_table[xy] == field_select){
2103                     if(   mv_table[xy][0] >=h_range || mv_table[xy][0] <-h_range
2104                        || mv_table[xy][1] >=v_range || mv_table[xy][1] <-v_range){
2105
2106                         if(truncate){
2107                             if     (mv_table[xy][0] > h_range-1) mv_table[xy][0]=  h_range-1;
2108                             else if(mv_table[xy][0] < -h_range ) mv_table[xy][0]= -h_range;
2109                             if     (mv_table[xy][1] > v_range-1) mv_table[xy][1]=  v_range-1;
2110                             else if(mv_table[xy][1] < -v_range ) mv_table[xy][1]= -v_range;
2111                         }else{
2112                             s->mb_type[xy] &= ~type;
2113                             s->mb_type[xy] |= CANDIDATE_MB_TYPE_INTRA;
2114                             mv_table[xy][0]=
2115                             mv_table[xy][1]= 0;
2116                         }
2117                     }
2118                 }
2119             }
2120             xy++;
2121         }
2122     }
2123 }