better scene change detection
[ffmpeg.git] / libavcodec / motion_est.c
1 /*
2  * Motion estimation 
3  * Copyright (c) 2000,2001 Fabrice Bellard.
4  * Copyright (c) 2002 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 #define SQ(a) ((a)*(a))
30 #define INTER_BIAS      257
31
32 #define P_LAST P[0]
33 #define P_LEFT P[1]
34 #define P_TOP P[2]
35 #define P_TOPRIGHT P[3]
36 #define P_MEDIAN P[4]
37 #define P_LAST_LEFT P[5]
38 #define P_LAST_RIGHT P[6]
39 #define P_LAST_TOP P[7]
40 #define P_LAST_BOTTOM P[8]
41 #define P_MV1 P[9]
42
43
44 static int pix_sum(UINT8 * pix, int line_size)
45 {
46     int s, i, j;
47
48     s = 0;
49     for (i = 0; i < 16; i++) {
50         for (j = 0; j < 16; j += 8) {
51             s += pix[0];
52             s += pix[1];
53             s += pix[2];
54             s += pix[3];
55             s += pix[4];
56             s += pix[5];
57             s += pix[6];
58             s += pix[7];
59             pix += 8;
60         }
61         pix += line_size - 16;
62     }
63     return s;
64 }
65
66 static int pix_dev(UINT8 * pix, int line_size, int mean)
67 {
68     int s, i, j;
69
70     s = 0;
71     for (i = 0; i < 16; i++) {
72         for (j = 0; j < 16; j += 8) {
73             s += ABS(pix[0]-mean);
74             s += ABS(pix[1]-mean);
75             s += ABS(pix[2]-mean);
76             s += ABS(pix[3]-mean);
77             s += ABS(pix[4]-mean);
78             s += ABS(pix[5]-mean);
79             s += ABS(pix[6]-mean);
80             s += ABS(pix[7]-mean);
81             pix += 8;
82         }
83         pix += line_size - 16;
84     }
85     return s;
86 }
87
88 static int pix_norm1(UINT8 * pix, int line_size)
89 {
90     int s, i, j;
91     UINT32 *sq = squareTbl + 256;
92
93     s = 0;
94     for (i = 0; i < 16; i++) {
95         for (j = 0; j < 16; j += 8) {
96             s += sq[pix[0]];
97             s += sq[pix[1]];
98             s += sq[pix[2]];
99             s += sq[pix[3]];
100             s += sq[pix[4]];
101             s += sq[pix[5]];
102             s += sq[pix[6]];
103             s += sq[pix[7]];
104             pix += 8;
105         }
106         pix += line_size - 16;
107     }
108     return s;
109 }
110
111 static int pix_norm(UINT8 * pix1, UINT8 * pix2, int line_size)
112 {
113     int s, i, j;
114     UINT32 *sq = squareTbl + 256;
115
116     s = 0;
117     for (i = 0; i < 16; i++) {
118         for (j = 0; j < 16; j += 8) {
119             s += sq[pix1[0] - pix2[0]];
120             s += sq[pix1[1] - pix2[1]];
121             s += sq[pix1[2] - pix2[2]];
122             s += sq[pix1[3] - pix2[3]];
123             s += sq[pix1[4] - pix2[4]];
124             s += sq[pix1[5] - pix2[5]];
125             s += sq[pix1[6] - pix2[6]];
126             s += sq[pix1[7] - pix2[7]];
127             pix1 += 8;
128             pix2 += 8;
129         }
130         pix1 += line_size - 16;
131         pix2 += line_size - 16;
132     }
133     return s;
134 }
135
136 static void no_motion_search(MpegEncContext * s,
137                              int *mx_ptr, int *my_ptr)
138 {
139     *mx_ptr = 16 * s->mb_x;
140     *my_ptr = 16 * s->mb_y;
141 }
142
143 static int full_motion_search(MpegEncContext * s,
144                               int *mx_ptr, int *my_ptr, int range,
145                               int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
146 {
147     int x1, y1, x2, y2, xx, yy, x, y;
148     int mx, my, dmin, d;
149     UINT8 *pix;
150
151     xx = 16 * s->mb_x;
152     yy = 16 * s->mb_y;
153     x1 = xx - range + 1;        /* we loose one pixel to avoid boundary pb with half pixel pred */
154     if (x1 < xmin)
155         x1 = xmin;
156     x2 = xx + range - 1;
157     if (x2 > xmax)
158         x2 = xmax;
159     y1 = yy - range + 1;
160     if (y1 < ymin)
161         y1 = ymin;
162     y2 = yy + range - 1;
163     if (y2 > ymax)
164         y2 = ymax;
165     pix = s->new_picture[0] + (yy * s->linesize) + xx;
166     dmin = 0x7fffffff;
167     mx = 0;
168     my = 0;
169     for (y = y1; y <= y2; y++) {
170         for (x = x1; x <= x2; x++) {
171             d = pix_abs16x16(pix, ref_picture + (y * s->linesize) + x,
172                              s->linesize);
173             if (d < dmin ||
174                 (d == dmin &&
175                  (abs(x - xx) + abs(y - yy)) <
176                  (abs(mx - xx) + abs(my - yy)))) {
177                 dmin = d;
178                 mx = x;
179                 my = y;
180             }
181         }
182     }
183
184     *mx_ptr = mx;
185     *my_ptr = my;
186
187 #if 0
188     if (*mx_ptr < -(2 * range) || *mx_ptr >= (2 * range) ||
189         *my_ptr < -(2 * range) || *my_ptr >= (2 * range)) {
190         fprintf(stderr, "error %d %d\n", *mx_ptr, *my_ptr);
191     }
192 #endif
193     return dmin;
194 }
195
196
197 static int log_motion_search(MpegEncContext * s,
198                              int *mx_ptr, int *my_ptr, int range,
199                              int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
200 {
201     int x1, y1, x2, y2, xx, yy, x, y;
202     int mx, my, dmin, d;
203     UINT8 *pix;
204
205     xx = s->mb_x << 4;
206     yy = s->mb_y << 4;
207
208     /* Left limit */
209     x1 = xx - range;
210     if (x1 < xmin)
211         x1 = xmin;
212
213     /* Right limit */
214     x2 = xx + range;
215     if (x2 > xmax)
216         x2 = xmax;
217
218     /* Upper limit */
219     y1 = yy - range;
220     if (y1 < ymin)
221         y1 = ymin;
222
223     /* Lower limit */
224     y2 = yy + range;
225     if (y2 > ymax)
226         y2 = ymax;
227
228     pix = s->new_picture[0] + (yy * s->linesize) + xx;
229     dmin = 0x7fffffff;
230     mx = 0;
231     my = 0;
232
233     do {
234         for (y = y1; y <= y2; y += range) {
235             for (x = x1; x <= x2; x += range) {
236                 d = pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
237                 if (d < dmin || (d == dmin && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
238                     dmin = d;
239                     mx = x;
240                     my = y;
241                 }
242             }
243         }
244
245         range = range >> 1;
246
247         x1 = mx - range;
248         if (x1 < xmin)
249             x1 = xmin;
250
251         x2 = mx + range;
252         if (x2 > xmax)
253             x2 = xmax;
254
255         y1 = my - range;
256         if (y1 < ymin)
257             y1 = ymin;
258
259         y2 = my + range;
260         if (y2 > ymax)
261             y2 = ymax;
262
263     } while (range >= 1);
264
265 #ifdef DEBUG
266     fprintf(stderr, "log       - MX: %d\tMY: %d\n", mx, my);
267 #endif
268     *mx_ptr = mx;
269     *my_ptr = my;
270     return dmin;
271 }
272
273 static int phods_motion_search(MpegEncContext * s,
274                                int *mx_ptr, int *my_ptr, int range,
275                                int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
276 {
277     int x1, y1, x2, y2, xx, yy, x, y, lastx, d;
278     int mx, my, dminx, dminy;
279     UINT8 *pix;
280
281     xx = s->mb_x << 4;
282     yy = s->mb_y << 4;
283
284     /* Left limit */
285     x1 = xx - range;
286     if (x1 < xmin)
287         x1 = xmin;
288
289     /* Right limit */
290     x2 = xx + range;
291     if (x2 > xmax)
292         x2 = xmax;
293
294     /* Upper limit */
295     y1 = yy - range;
296     if (y1 < ymin)
297         y1 = ymin;
298
299     /* Lower limit */
300     y2 = yy + range;
301     if (y2 > ymax)
302         y2 = ymax;
303
304     pix = s->new_picture[0] + (yy * s->linesize) + xx;
305     mx = 0;
306     my = 0;
307
308     x = xx;
309     y = yy;
310     do {
311         dminx = 0x7fffffff;
312         dminy = 0x7fffffff;
313
314         lastx = x;
315         for (x = x1; x <= x2; x += range) {
316             d = pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
317             if (d < dminx || (d == dminx && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
318                 dminx = d;
319                 mx = x;
320             }
321         }
322
323         x = lastx;
324         for (y = y1; y <= y2; y += range) {
325             d = pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);
326             if (d < dminy || (d == dminy && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {
327                 dminy = d;
328                 my = y;
329             }
330         }
331
332         range = range >> 1;
333
334         x = mx;
335         y = my;
336         x1 = mx - range;
337         if (x1 < xmin)
338             x1 = xmin;
339
340         x2 = mx + range;
341         if (x2 > xmax)
342             x2 = xmax;
343
344         y1 = my - range;
345         if (y1 < ymin)
346             y1 = ymin;
347
348         y2 = my + range;
349         if (y2 > ymax)
350             y2 = ymax;
351
352     } while (range >= 1);
353
354 #ifdef DEBUG
355     fprintf(stderr, "phods     - MX: %d\tMY: %d\n", mx, my);
356 #endif
357
358     /* half pixel search */
359     *mx_ptr = mx;
360     *my_ptr = my;
361     return dminy;
362 }
363
364
365 #define Z_THRESHOLD 256
366
367 #define CHECK_MV(x,y)\
368 {\
369     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
370     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
371     if(map[index]!=key){\
372         d = pix_abs16x16(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\
373         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\
374         COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
375         map[index]= key;\
376         score_map[index]= d;\
377     }\
378 }
379
380 #define CHECK_MV_DIR(x,y,new_dir)\
381 {\
382     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
383     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
384     if(map[index]!=key){\
385         d = pix_abs(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\
386         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\
387         if(d<dmin){\
388             best[0]=x;\
389             best[1]=y;\
390             dmin=d;\
391             next_dir= new_dir;\
392         }\
393         map[index]= key;\
394         score_map[index]= d;\
395     }\
396 }
397
398 #define CHECK_MV4(x,y)\
399 {\
400     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\
401     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\
402     if(map[index]!=key){\
403         d = pix_abs8x8(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\
404         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\
405         COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\
406         map[index]= key;\
407         score_map[index]= d;\
408     }\
409 }
410
411 #define check(x,y,S,v)\
412 if( (x)<(xmin<<(S)) ) printf("%d %d %d %d %d xmin" #v, xmin, (x), (y), s->mb_x, s->mb_y);\
413 if( (x)>(xmax<<(S)) ) printf("%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, s->mb_y);\
414 if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\
415 if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\
416
417
418 static inline int small_diamond_search(MpegEncContext * s, int *best, int dmin,
419                                        UINT8 *new_pic, UINT8 *old_pic, int pic_stride,
420                                        int pred_x, int pred_y, UINT16 *mv_penalty, int quant,
421                                        int xmin, int ymin, int xmax, int ymax, int shift,
422                                        uint32_t *map, uint16_t *score_map, int map_generation,
423                                        op_pixels_abs_func pix_abs)
424 {
425     int next_dir=-1;
426
427     for(;;){
428         int d;
429         const int dir= next_dir;
430         const int x= best[0];
431         const int y= best[1];
432         next_dir=-1;
433
434 //printf("%d", dir);
435         if(dir!=2 && x>xmin) CHECK_MV_DIR(x-1, y  , 0)
436         if(dir!=3 && y>ymin) CHECK_MV_DIR(x  , y-1, 1)
437         if(dir!=0 && x<xmax) CHECK_MV_DIR(x+1, y  , 2)
438         if(dir!=1 && y<ymax) CHECK_MV_DIR(x  , y+1, 3)
439
440         if(next_dir==-1){
441             return dmin;
442         }
443     }
444
445 /*    for(;;){
446         int d;
447         const int x= best[0];
448         const int y= best[1];
449         const int last_min=dmin;
450         if(x>xmin) CHECK_MV(x-1, y  )
451         if(y>xmin) CHECK_MV(x  , y-1)
452         if(x<xmax) CHECK_MV(x+1, y  )
453         if(y<xmax) CHECK_MV(x  , y+1)
454         if(x>xmin && y>ymin) CHECK_MV(x-1, y-1)
455         if(x>xmin && y<ymax) CHECK_MV(x-1, y+1)
456         if(x<xmax && y>ymin) CHECK_MV(x+1, y-1)
457         if(x<xmax && y<ymax) CHECK_MV(x+1, y+1)
458         if(x-1>xmin) CHECK_MV(x-2, y  )
459         if(y-1>xmin) CHECK_MV(x  , y-2)
460         if(x+1<xmax) CHECK_MV(x+2, y  )
461         if(y+1<xmax) CHECK_MV(x  , y+2)
462         if(x-1>xmin && y-1>ymin) CHECK_MV(x-2, y-2)
463         if(x-1>xmin && y+1<ymax) CHECK_MV(x-2, y+2)
464         if(x+1<xmax && y-1>ymin) CHECK_MV(x+2, y-2)
465         if(x+1<xmax && y+1<ymax) CHECK_MV(x+2, y+2)
466         if(dmin==last_min) return dmin;
467     }
468     */
469 }
470
471 #if 1
472 #define SNAKE_1 3
473 #define SNAKE_2 2
474 #else
475 #define SNAKE_1 7
476 #define SNAKE_2 3
477 #endif
478 static inline int snake_search(MpegEncContext * s, int *best, int dmin,
479                                        UINT8 *new_pic, UINT8 *old_pic, int pic_stride,
480                                        int pred_x, int pred_y, UINT16 *mv_penalty, int quant,
481                                        int xmin, int ymin, int xmax, int ymax, int shift,
482                                        uint32_t *map, uint16_t *score_map,int map_generation,
483                                        op_pixels_abs_func pix_abs)
484 {
485     int dir=0;
486     int c=1;
487     static int x_dir[8]= {1,1,0,-1,-1,-1, 0, 1};
488     static int y_dir[8]= {0,1,1, 1, 0,-1,-1,-1};
489     int fails=0;
490     int last_d[2]={dmin, dmin};
491
492 /*static int good=0;
493 static int bad=0;
494 static int point=0;
495
496 point++;
497 if(256*256*256*64%point==0)
498 {
499     printf("%d %d %d\n", good, bad, point);
500 }*/
501
502     for(;;){
503         int x= best[0];
504         int y= best[1];
505         int d;
506         x+=x_dir[dir];
507         y+=y_dir[dir];
508         if(x>=xmin && x<=xmax && y>=ymin && y<=ymax){
509             const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;
510             const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);
511             if(map[index]!=key){
512                 d = pix_abs(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);
513                 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;
514                 map[index]=key;
515                 score_map[index]=d;
516             }else
517                 d= dmin+1;
518         }else{
519             d = dmin + 10000; //FIXME smarter boundary handling
520         }
521         if(d<dmin){
522             best[0]=x;
523             best[1]=y;
524             dmin=d;
525
526             if(last_d[1] - last_d[0] > last_d[0] - d) c= -c;
527             dir+=c;
528
529             fails=0;
530 //good++;
531             last_d[1]=last_d[0];
532             last_d[0]=d;
533         }else{
534 //bad++;
535             if(fails){
536                 if(fails>=SNAKE_1+1) return dmin;
537             }else{
538                 if(dir&1) dir-= c*3;
539                 else      c= -c;
540 //                c= -c;
541             }
542             dir+=c*SNAKE_2;
543             fails++;
544         }
545         dir&=7;
546     }
547 }
548
549 static inline int cross_search(MpegEncContext * s, int *best, int dmin,
550                                        UINT8 *new_pic, UINT8 *old_pic, int pic_stride,
551                                        int pred_x, int pred_y, UINT16 *mv_penalty, int quant,
552                                        int xmin, int ymin, int xmax, int ymax, int shift,
553                                        uint32_t *map, uint16_t *score_map,int map_generation,
554                                        op_pixels_abs_func pix_abs)
555 {
556     static int x_dir[4]= {-1, 0, 1, 0};
557     static int y_dir[4]= { 0,-1, 0, 1};
558     int improvement[2]={100000, 100000};
559     int dirs[2]={2, 3};
560     int dir;
561     int last_dir= -1;
562     
563     for(;;){
564         dir= dirs[ improvement[0] > improvement[1] ? 0 : 1 ];
565         if(improvement[dir&1]==-1) return dmin;
566         
567         {
568             const int x= best[0] + x_dir[dir];
569             const int y= best[1] + y_dir[dir];
570             const int key= (y<<ME_MAP_MV_BITS) + x + map_generation;
571             const int index= ((y<<ME_MAP_SHIFT) + x)&(ME_MAP_SIZE-1);
572             int d;
573             if(x>=xmin && x<=xmax && y>=ymin && y<=ymax){
574                 if(map[index]!=key){
575                     d = pix_abs(new_pic, old_pic + x + y*pic_stride, pic_stride);
576                     d += (mv_penalty[(x<<shift)-pred_x] + mv_penalty[(y<<shift)-pred_y])*quant;
577                     map[index]=key;
578                     score_map[index]=d;
579                     if(d<dmin){
580                         improvement[dir&1]= dmin-d;
581                         improvement[(dir&1)^1]++;
582                         dmin=d;
583                         best[0]= x;
584                         best[1]= y;
585                         last_dir=dir;
586                         continue;
587                     }
588                 }else{
589                     d= score_map[index];
590                 }
591             }else{
592                 d= dmin + 1000; //FIXME is this a good idea?
593             }
594             /* evaluated point was cached or checked and worse */
595
596             if(last_dir==dir){
597                 improvement[dir&1]= -1;
598             }else{
599                 improvement[dir&1]= d-dmin;
600                 last_dir= dirs[dir&1]= dir^2;
601             }
602         }
603     }
604 }
605
606 static inline int update_map_generation(MpegEncContext * s)
607 {
608     s->me_map_generation+= 1<<(ME_MAP_MV_BITS*2);
609     if(s->me_map_generation==0){
610         s->me_map_generation= 1<<(ME_MAP_MV_BITS*2);
611         memset(s->me_map, 0, sizeof(uint32_t)*ME_MAP_SIZE);
612     }
613     return s->me_map_generation;
614 }
615
616 static int epzs_motion_search(MpegEncContext * s,
617                              int *mx_ptr, int *my_ptr,
618                              int P[10][2], int pred_x, int pred_y,
619                              int xmin, int ymin, int xmax, int ymax, uint8_t * ref_picture)
620 {
621     int best[2]={0, 0};
622     int d, dmin; 
623     UINT8 *new_pic, *old_pic;
624     const int pic_stride= s->linesize;
625     const int pic_xy= (s->mb_y*pic_stride + s->mb_x)*16;
626     UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
627     int quant= s->qscale; // qscale of the prev frame
628     const int shift= 1+s->quarter_sample;
629     uint32_t *map= s->me_map;
630     uint16_t *score_map= s->me_score_map;
631     int map_generation;
632
633     new_pic = s->new_picture[0] + pic_xy;
634     old_pic = ref_picture + pic_xy;
635     
636     map_generation= update_map_generation(s);
637
638     dmin = pix_abs16x16(new_pic, old_pic, pic_stride);
639     map[0]= map_generation;
640     score_map[0]= dmin;
641
642     /* first line */
643     if ((s->mb_y == 0 || s->first_slice_line)) {
644         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
645         CHECK_MV(P_LAST[0]>>shift, P_LAST[1]>>shift)
646     }else{
647         if(dmin<256 && ( P_LEFT[0]    |P_LEFT[1]
648                         |P_TOP[0]     |P_TOP[1]
649                         |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){
650             *mx_ptr= 0;
651             *my_ptr= 0;
652             s->skip_me=1;
653             return dmin;
654         }
655         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
656         if(dmin>256*2){
657             CHECK_MV(P_LAST[0]    >>shift, P_LAST[1]    >>shift)
658             CHECK_MV(P_LEFT[0]    >>shift, P_LEFT[1]    >>shift)
659             CHECK_MV(P_TOP[0]     >>shift, P_TOP[1]     >>shift)
660             CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
661         }
662     }
663     if(dmin>256*4){
664         CHECK_MV(P_LAST_RIGHT[0] >>shift, P_LAST_RIGHT[1] >>shift)
665         CHECK_MV(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift)
666     }
667 #if 0 //doest only slow things down
668     if(dmin>512*3){
669         int step;
670         dmin= score_map[0];
671         best[0]= best[1]=0;
672         for(step=128; step>0; step>>=1){
673             const int step2= step;
674             int y;
675             for(y=-step2+best[1]; y<=step2+best[1]; y+=step){
676                 int x;
677                 if(y<ymin || y>ymax) continue;
678
679                 for(x=-step2+best[0]; x<=step2+best[0]; x+=step){
680                     if(x<xmin || x>xmax) continue;
681                     if(x==best[0] && y==best[1]) continue;
682                     CHECK_MV(x,y)
683                 }
684             }
685         }
686     }
687 #endif
688 //check(best[0],best[1],0, b0)
689     if(s->me_method==ME_EPZS)
690         dmin= small_diamond_search(s, best, dmin, new_pic, old_pic, pic_stride, 
691                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 
692                                    shift, map, score_map, map_generation, pix_abs16x16);
693     else
694         dmin=         cross_search(s, best, dmin, new_pic, old_pic, pic_stride, 
695                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 
696                                    shift, map, score_map, map_generation, pix_abs16x16);
697 //check(best[0],best[1],0, b1)
698     *mx_ptr= best[0];
699     *my_ptr= best[1];    
700
701 //    printf("%d %d %d \n", best[0], best[1], dmin);
702     return dmin;
703 }
704
705 static int epzs_motion_search4(MpegEncContext * s, int block,
706                              int *mx_ptr, int *my_ptr,
707                              int P[10][2], int pred_x, int pred_y,
708                              int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)
709 {
710     int best[2]={0, 0};
711     int d, dmin; 
712     UINT8 *new_pic, *old_pic;
713     const int pic_stride= s->linesize;
714     const int pic_xy= ((s->mb_y*2 + (block>>1))*pic_stride + s->mb_x*2 + (block&1))*8;
715     UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
716     int quant= s->qscale; // qscale of the prev frame
717     const int shift= 1+s->quarter_sample;
718     uint32_t *map= s->me_map;
719     uint16_t *score_map= s->me_score_map;
720     int map_generation;
721
722     new_pic = s->new_picture[0] + pic_xy;
723     old_pic = ref_picture + pic_xy;
724
725     map_generation= update_map_generation(s);
726
727     dmin = 1000000;
728 //printf("%d %d %d %d //",xmin, ymin, xmax, ymax); 
729     /* first line */
730     if ((s->mb_y == 0 || s->first_slice_line) && block<2) {
731         CHECK_MV4(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
732         CHECK_MV4(P_LAST[0]>>shift, P_LAST[1]>>shift)
733         CHECK_MV4(P_MV1[0]>>shift, P_MV1[1]>>shift)
734     }else{
735         CHECK_MV4(P_MV1[0]>>shift, P_MV1[1]>>shift)
736         //FIXME try some early stop
737         if(dmin>64*2){
738             CHECK_MV4(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)
739             CHECK_MV4(P_LEFT[0]>>shift, P_LEFT[1]>>shift)
740             CHECK_MV4(P_TOP[0]>>shift, P_TOP[1]>>shift)
741             CHECK_MV4(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)
742             CHECK_MV4(P_LAST[0]>>shift, P_LAST[1]>>shift)
743         }
744     }
745     if(dmin>64*4){
746         CHECK_MV4(P_LAST_RIGHT[0]>>shift, P_LAST_RIGHT[1]>>shift)
747         CHECK_MV4(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift)
748     }
749
750     if(s->me_method==ME_EPZS)
751         dmin= small_diamond_search(s, best, dmin, new_pic, old_pic, pic_stride, 
752                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 
753                                    shift, map, score_map, map_generation, pix_abs8x8);
754     else
755         dmin=         cross_search(s, best, dmin, new_pic, old_pic, pic_stride, 
756                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 
757                                    shift, map, score_map, map_generation, pix_abs8x8);
758
759     *mx_ptr= best[0];
760     *my_ptr= best[1];    
761
762 //    printf("%d %d %d \n", best[0], best[1], dmin);
763     return dmin;
764 }
765
766 #define CHECK_HALF_MV(suffix, x, y) \
767 {\
768     d= pix_abs_ ## suffix(pix, ptr+((x)>>1), s->linesize);\
769     d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*quant;\
770     COPY3_IF_LT(dminh, d, dx, x, dy, y)\
771 }
772
773     
774 /* The idea would be to make half pel ME after Inter/Intra decision to 
775    save time. */
776 static inline int halfpel_motion_search(MpegEncContext * s,
777                                   int *mx_ptr, int *my_ptr, int dmin,
778                                   int xmin, int ymin, int xmax, int ymax,
779                                   int pred_x, int pred_y, uint8_t *ref_picture,
780                                   op_pixels_abs_func pix_abs_x2, 
781                                   op_pixels_abs_func pix_abs_y2, op_pixels_abs_func pix_abs_xy2, int n)
782 {
783     UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
784     const int quant= s->qscale;
785     int mx, my, xx, yy, dminh;
786     UINT8 *pix, *ptr;
787
788     if(s->skip_me){
789         *mx_ptr = 0;
790         *my_ptr = 0;
791         return dmin;
792     }else
793
794     xx = 16 * s->mb_x + 8*(n&1);
795     yy = 16 * s->mb_y + 8*(n>>1);
796     pix =  s->new_picture[0] + (yy * s->linesize) + xx;
797
798     mx = *mx_ptr;
799     my = *my_ptr;
800     ptr = ref_picture + ((yy + my) * s->linesize) + (xx + mx);
801     
802     dminh = dmin;
803
804     if (mx > xmin && mx < xmax && 
805         my > ymin && my < ymax) {
806         int dx=0, dy=0;
807         int d, pen_x, pen_y; 
808
809         mx<<=1;
810         my<<=1;
811         
812         pen_x= pred_x + mx;
813         pen_y= pred_y + my;
814
815         ptr-= s->linesize;
816         CHECK_HALF_MV(xy2, -1, -1)
817         CHECK_HALF_MV(y2 ,  0, -1)
818         CHECK_HALF_MV(xy2, +1, -1)
819         
820         ptr+= s->linesize;
821         CHECK_HALF_MV(x2 , -1,  0)
822         CHECK_HALF_MV(x2 , +1,  0)
823         CHECK_HALF_MV(xy2, -1, +1)
824         CHECK_HALF_MV(y2 ,  0, +1)
825         CHECK_HALF_MV(xy2, +1, +1)
826
827         mx+=dx;
828         my+=dy;
829     }else{
830         mx<<=1;
831         my<<=1;
832     }
833
834     *mx_ptr = mx;
835     *my_ptr = my;
836     return dminh;
837 }
838
839 static inline int fast_halfpel_motion_search(MpegEncContext * s,
840                                   int *mx_ptr, int *my_ptr, int dmin,
841                                   int xmin, int ymin, int xmax, int ymax,
842                                   int pred_x, int pred_y, uint8_t *ref_picture,
843                                   op_pixels_abs_func pix_abs_x2, 
844                                   op_pixels_abs_func pix_abs_y2, op_pixels_abs_func pix_abs_xy2, int n)
845 {
846     UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
847     uint16_t *score_map= s->me_score_map;
848     const int quant= s->qscale;
849     int mx, my, xx, yy, dminh;
850     UINT8 *pix, *ptr;
851
852     if(s->skip_me){
853 //    printf("S");
854         *mx_ptr = 0;
855         *my_ptr = 0;
856         return dmin;
857     }
858 //    printf("N");
859         
860     xx = 16 * s->mb_x + 8*(n&1);
861     yy = 16 * s->mb_y + 8*(n>>1);
862     pix =  s->new_picture[0] + (yy * s->linesize) + xx;
863
864     mx = *mx_ptr;
865     my = *my_ptr;
866     ptr = ref_picture + ((yy + my) * s->linesize) + (xx + mx);
867     
868     dminh = dmin;
869
870     if (mx > xmin && mx < xmax && 
871         my > ymin && my < ymax) {
872         int dx=0, dy=0;
873         int d, pen_x, pen_y; 
874         const int index= (my<<ME_MAP_SHIFT) + mx;
875         const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
876         const int l= score_map[(index- 1               )&(ME_MAP_SIZE-1)];
877         const int r= score_map[(index+ 1               )&(ME_MAP_SIZE-1)];
878         const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];
879         mx<<=1;
880         my<<=1;
881
882         
883         pen_x= pred_x + mx;
884         pen_y= pred_y + my;
885
886         ptr-= s->linesize;
887         if(t<=b){
888             CHECK_HALF_MV(y2 ,  0, -1)
889             if(l<=r){
890                 CHECK_HALF_MV(xy2, -1, -1)
891                 if(t+r<=b+l){
892                     CHECK_HALF_MV(xy2, +1, -1)
893                     ptr+= s->linesize;
894                 }else{
895                     ptr+= s->linesize;
896                     CHECK_HALF_MV(xy2, -1, +1)
897                 }
898                 CHECK_HALF_MV(x2 , -1,  0)
899             }else{
900                 CHECK_HALF_MV(xy2, +1, -1)
901                 if(t+l<=b+r){
902                     CHECK_HALF_MV(xy2, -1, -1)
903                     ptr+= s->linesize;
904                 }else{
905                     ptr+= s->linesize;
906                     CHECK_HALF_MV(xy2, +1, +1)
907                 }
908                 CHECK_HALF_MV(x2 , +1,  0)
909             }
910         }else{
911             if(l<=r){
912                 if(t+l<=b+r){
913                     CHECK_HALF_MV(xy2, -1, -1)
914                     ptr+= s->linesize;
915                 }else{
916                     ptr+= s->linesize;
917                     CHECK_HALF_MV(xy2, +1, +1)
918                 }
919                 CHECK_HALF_MV(x2 , -1,  0)
920                 CHECK_HALF_MV(xy2, -1, +1)
921             }else{
922                 if(t+r<=b+l){
923                     CHECK_HALF_MV(xy2, +1, -1)
924                     ptr+= s->linesize;
925                 }else{
926                     ptr+= s->linesize;
927                     CHECK_HALF_MV(xy2, -1, +1)
928                 }
929                 CHECK_HALF_MV(x2 , +1,  0)
930                 CHECK_HALF_MV(xy2, +1, +1)
931             }
932             CHECK_HALF_MV(y2 ,  0, +1)
933         }
934         mx+=dx;
935         my+=dy;
936
937     }else{
938         mx<<=1;
939         my<<=1;
940     }
941
942     *mx_ptr = mx;
943     *my_ptr = my;
944     return dminh;
945 }
946
947 static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4)
948 {
949     const int xy= s->mb_x + 1 + (s->mb_y + 1)*(s->mb_width + 2);
950     
951     s->p_mv_table[xy][0] = mx;
952     s->p_mv_table[xy][1] = my;
953
954     /* has allready been set to the 4 MV if 4MV is done */
955     if(mv4){
956         int mot_xy= s->block_index[0];
957
958         s->motion_val[mot_xy  ][0]= mx;
959         s->motion_val[mot_xy  ][1]= my;
960         s->motion_val[mot_xy+1][0]= mx;
961         s->motion_val[mot_xy+1][1]= my;
962
963         mot_xy += s->block_wrap[0];
964         s->motion_val[mot_xy  ][0]= mx;
965         s->motion_val[mot_xy  ][1]= my;
966         s->motion_val[mot_xy+1][0]= mx;
967         s->motion_val[mot_xy+1][1]= my;
968     }
969 }
970
971 static inline void get_limits(MpegEncContext *s, int *range, int *xmin, int *ymin, int *xmax, int *ymax, int f_code)
972 {
973     *range = 8 * (1 << (f_code - 1));
974     /* XXX: temporary kludge to avoid overflow for msmpeg4 */
975     if (s->out_format == FMT_H263 && !s->h263_msmpeg4)
976         *range *= 2;
977
978     if (s->unrestricted_mv) {
979         *xmin = -16;
980         *ymin = -16;
981         if (s->h263_plus)
982             *range *= 2;
983         if(s->avctx==NULL || s->avctx->codec->id!=CODEC_ID_MPEG4){
984             *xmax = s->mb_width*16;
985             *ymax = s->mb_height*16;
986         }else {
987             /* XXX: dunno if this is correct but ffmpeg4 decoder wont like it otherwise 
988                     (cuz the drawn edge isnt large enough))*/
989             *xmax = s->width;
990             *ymax = s->height;
991         }
992     } else {
993         *xmin = 0;
994         *ymin = 0;
995         *xmax = s->mb_width*16 - 16;
996         *ymax = s->mb_height*16 - 16;
997     }
998 }
999
1000 static inline int mv4_search(MpegEncContext *s, int xmin, int ymin, int xmax, int ymax, int mx, int my, int shift)
1001 {
1002     int block;
1003     int P[10][2];
1004     uint8_t *ref_picture= s->last_picture[0];
1005     int dmin_sum=0;
1006
1007     for(block=0; block<4; block++){
1008         int mx4, my4;
1009         int pred_x4, pred_y4;
1010         int dmin4;
1011         static const int off[4]= {2, 1, 1, -1};
1012         const int mot_stride = s->block_wrap[0];
1013         const int mot_xy = s->block_index[block];
1014 //        const int block_x= (block&1);
1015 //        const int block_y= (block>>1);
1016 #if 1 // this saves us a bit of cliping work and shouldnt affect compression in a negative way
1017         const int rel_xmin4= xmin;
1018         const int rel_xmax4= xmax;
1019         const int rel_ymin4= ymin;
1020         const int rel_ymax4= ymax;
1021 #else
1022         const int rel_xmin4= xmin - block_x*8;
1023         const int rel_xmax4= xmax - block_x*8 + 8;
1024         const int rel_ymin4= ymin - block_y*8;
1025         const int rel_ymax4= ymax - block_y*8 + 8;
1026 #endif
1027         P_LAST[0] = s->motion_val[mot_xy    ][0];
1028         P_LAST[1] = s->motion_val[mot_xy    ][1];
1029         P_LEFT[0] = s->motion_val[mot_xy - 1][0];
1030         P_LEFT[1] = s->motion_val[mot_xy - 1][1];
1031         P_LAST_RIGHT[0] = s->motion_val[mot_xy + 1][0];
1032         P_LAST_RIGHT[1] = s->motion_val[mot_xy + 1][1];
1033         P_LAST_BOTTOM[0]= s->motion_val[mot_xy + 1*mot_stride][0];
1034         P_LAST_BOTTOM[1]= s->motion_val[mot_xy + 1*mot_stride][1];
1035
1036         if(P_LEFT[0]       > (rel_xmax4<<shift)) P_LEFT[0]       = (rel_xmax4<<shift);
1037         if(P_LAST_RIGHT[0] < (rel_xmin4<<shift)) P_LAST_RIGHT[0] = (rel_xmin4<<shift);
1038         if(P_LAST_BOTTOM[1]< (rel_ymin4<<shift)) P_LAST_BOTTOM[1]= (rel_ymin4<<shift);
1039
1040         /* special case for first line */
1041         if ((s->mb_y == 0 || s->first_slice_line) && block<2) {
1042             pred_x4= P_LEFT[0];
1043             pred_y4= P_LEFT[1];
1044         } else {
1045             P_TOP[0]      = s->motion_val[mot_xy - mot_stride             ][0];
1046             P_TOP[1]      = s->motion_val[mot_xy - mot_stride             ][1];
1047             P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + off[block]][0];
1048             P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + off[block]][1];
1049             if(P_TOP[1]      > (rel_ymax4<<shift)) P_TOP[1]     = (rel_ymax4<<shift);
1050             if(P_TOPRIGHT[0] < (rel_xmin4<<shift)) P_TOPRIGHT[0]= (rel_xmin4<<shift);
1051             if(P_TOPRIGHT[0] > (rel_xmax4<<shift)) P_TOPRIGHT[0]= (rel_xmax4<<shift);
1052             if(P_TOPRIGHT[1] > (rel_ymax4<<shift)) P_TOPRIGHT[1]= (rel_ymax4<<shift);
1053     
1054             P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1055             P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1056
1057             if(s->out_format == FMT_H263){
1058                 pred_x4 = P_MEDIAN[0];
1059                 pred_y4 = P_MEDIAN[1];
1060             }else { /* mpeg1 at least */
1061                 pred_x4= P_LEFT[0];
1062                 pred_y4= P_LEFT[1];
1063             }
1064         }
1065         P_MV1[0]= mx;
1066         P_MV1[1]= my;
1067
1068         dmin4 = epzs_motion_search4(s, block, &mx4, &my4, P, pred_x4, pred_y4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, ref_picture);
1069
1070         dmin4= fast_halfpel_motion_search(s, &mx4, &my4, dmin4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, 
1071                                    pred_x4, pred_y4, ref_picture, pix_abs8x8_x2, 
1072                                    pix_abs8x8_y2, pix_abs8x8_xy2, block);
1073  
1074         s->motion_val[ s->block_index[block] ][0]= mx4;
1075         s->motion_val[ s->block_index[block] ][1]= my4;
1076         dmin_sum+= dmin4;
1077     }
1078     return dmin_sum;
1079 }
1080
1081 void ff_estimate_p_frame_motion(MpegEncContext * s,
1082                                 int mb_x, int mb_y)
1083 {
1084     UINT8 *pix, *ppix;
1085     int sum, varc, vard, mx, my, range, dmin, xx, yy;
1086     int xmin, ymin, xmax, ymax;
1087     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
1088     int pred_x=0, pred_y=0;
1089     int P[10][2];
1090     const int shift= 1+s->quarter_sample;
1091     int mb_type=0;
1092     uint8_t *ref_picture= s->last_picture[0];
1093
1094     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, s->f_code);
1095     rel_xmin= xmin - mb_x*16;
1096     rel_xmax= xmax - mb_x*16;
1097     rel_ymin= ymin - mb_y*16;
1098     rel_ymax= ymax - mb_y*16;
1099     s->skip_me=0;
1100
1101     switch(s->me_method) {
1102     case ME_ZERO:
1103     default:
1104         no_motion_search(s, &mx, &my);
1105         mx-= mb_x*16;
1106         my-= mb_y*16;
1107         dmin = 0;
1108         break;
1109     case ME_FULL:
1110         dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
1111         mx-= mb_x*16;
1112         my-= mb_y*16;
1113         break;
1114     case ME_LOG:
1115         dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1116         mx-= mb_x*16;
1117         my-= mb_y*16;
1118         break;
1119     case ME_PHODS:
1120         dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1121         mx-= mb_x*16;
1122         my-= mb_y*16;
1123         break;
1124     case ME_X1:
1125     case ME_EPZS:
1126        {
1127             const int mot_stride = s->block_wrap[0];
1128             const int mot_xy = s->block_index[0];
1129
1130             P_LAST[0]       = s->motion_val[mot_xy    ][0];
1131             P_LAST[1]       = s->motion_val[mot_xy    ][1];
1132             P_LEFT[0]       = s->motion_val[mot_xy - 1][0];
1133             P_LEFT[1]       = s->motion_val[mot_xy - 1][1];
1134             P_LAST_RIGHT[0] = s->motion_val[mot_xy + 2][0];
1135             P_LAST_RIGHT[1] = s->motion_val[mot_xy + 2][1];
1136             P_LAST_BOTTOM[0]= s->motion_val[mot_xy + 2*mot_stride][0];
1137             P_LAST_BOTTOM[1]= s->motion_val[mot_xy + 2*mot_stride][1];
1138
1139             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);
1140             if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);
1141             if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);
1142
1143             /* special case for first line */
1144             if ((mb_y == 0 || s->first_slice_line)) {
1145                 pred_x= P_LEFT[0];
1146                 pred_y= P_LEFT[1];
1147             } else {
1148                 P_TOP[0]      = s->motion_val[mot_xy - mot_stride    ][0];
1149                 P_TOP[1]      = s->motion_val[mot_xy - mot_stride    ][1];
1150                 P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + 2][0];
1151                 P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + 2][1];
1152                 if(P_TOP[1]      > (rel_ymax<<shift)) P_TOP[1]     = (rel_ymax<<shift);
1153                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
1154                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
1155         
1156                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1157                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1158
1159                 if(s->out_format == FMT_H263){
1160                     pred_x = P_MEDIAN[0];
1161                     pred_y = P_MEDIAN[1];
1162                 }else { /* mpeg1 at least */
1163                     pred_x= P_LEFT[0];
1164                     pred_y= P_LEFT[1];
1165                 }
1166             }
1167         }
1168         dmin = epzs_motion_search(s, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, ref_picture);
1169  
1170         break;
1171     }
1172
1173     /* intra / predictive decision */
1174     xx = mb_x * 16;
1175     yy = mb_y * 16;
1176
1177     pix = s->new_picture[0] + (yy * s->linesize) + xx;
1178     /* At this point (mx,my) are full-pell and the relative displacement */
1179     ppix = ref_picture + ((yy+my) * s->linesize) + (xx+mx);
1180     
1181     sum = pix_sum(pix, s->linesize);
1182     
1183     sum= (sum+8)>>4;
1184     varc = (pix_norm1(pix, s->linesize) - sum*sum + 500 + 128)>>8;
1185     vard = (pix_norm(pix, ppix, s->linesize)+128)>>8;
1186
1187 //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);
1188     s->mb_var   [s->mb_width * mb_y + mb_x] = varc;
1189     s->mc_mb_var[s->mb_width * mb_y + mb_x] = vard;
1190     s->mb_var_sum    += varc;
1191     s->mc_mb_var_sum += vard;
1192 //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);
1193     
1194 #if 0
1195     printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n",
1196            varc, s->avg_mb_var, sum, vard, mx - xx, my - yy);
1197 #endif
1198     if(s->flags&CODEC_FLAG_HQ){
1199         if (vard <= 64 || vard < varc)
1200             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1201         else
1202             s->scene_change_score+= 20;
1203
1204         if (vard*2 + 200 > varc)
1205             mb_type|= MB_TYPE_INTRA;
1206         if (varc*2 + 200 > vard){
1207             mb_type|= MB_TYPE_INTER;
1208             if(s->me_method >= ME_EPZS)
1209                 fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1210                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 
1211                                            pix_abs16x16_xy2, 0);
1212             else
1213                 halfpel_motion_search(     s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1214                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 
1215                                            pix_abs16x16_xy2, 0);                                           
1216         }else{
1217             mx <<=1;
1218             my <<=1;
1219         }
1220         if((s->flags&CODEC_FLAG_4MV)
1221            && !s->skip_me && varc>50 && vard>10){
1222             mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
1223             mb_type|=MB_TYPE_INTER4V;
1224
1225             set_p_mv_tables(s, mx, my, 0);
1226         }else
1227             set_p_mv_tables(s, mx, my, 1);
1228     }else{
1229         if (vard <= 64 || vard < varc) {
1230             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1231             mb_type|= MB_TYPE_INTER;
1232             if (s->me_method != ME_ZERO) {
1233                 if(s->me_method >= ME_EPZS)
1234                     dmin= fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1235                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 
1236                                            pix_abs16x16_xy2, 0);
1237                 else
1238                     dmin= halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1239                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 
1240                                            pix_abs16x16_xy2, 0);
1241                 if((s->flags&CODEC_FLAG_4MV)
1242                    && !s->skip_me && varc>50 && vard>10){
1243                     int dmin4= mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
1244                     if(dmin4 + 128 <dmin)
1245                         mb_type= MB_TYPE_INTER4V;
1246                 }
1247                 set_p_mv_tables(s, mx, my, mb_type!=MB_TYPE_INTER4V);
1248
1249             } else {
1250                 mx <<=1;
1251                 my <<=1;
1252             }
1253 #if 0
1254             if (vard < 10) {
1255                 skip++;
1256                 fprintf(stderr,"\nEarly skip: %d vard: %2d varc: %5d dmin: %d", 
1257                                 skip, vard, varc, dmin);
1258             }
1259 #endif
1260         }else{
1261             s->scene_change_score+= 20;
1262             mb_type|= MB_TYPE_INTRA;
1263             mx = 0;
1264             my = 0;
1265         }
1266     }
1267
1268     s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1269 }
1270
1271 int ff_estimate_motion_b(MpegEncContext * s,
1272                        int mb_x, int mb_y, int16_t (*mv_table)[2], uint8_t *ref_picture, int f_code)
1273 {
1274     int mx, my, range, dmin;
1275     int xmin, ymin, xmax, ymax;
1276     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
1277     int pred_x=0, pred_y=0;
1278     int P[10][2];
1279     const int shift= 1+s->quarter_sample;
1280     const int mot_stride = s->mb_width + 2;
1281     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
1282     
1283     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, f_code);
1284     rel_xmin= xmin - mb_x*16;
1285     rel_xmax= xmax - mb_x*16;
1286     rel_ymin= ymin - mb_y*16;
1287     rel_ymax= ymax - mb_y*16;
1288
1289     switch(s->me_method) {
1290     case ME_ZERO:
1291     default:
1292         no_motion_search(s, &mx, &my);
1293         dmin = 0;
1294         mx-= mb_x*16;
1295         my-= mb_y*16;
1296         break;
1297     case ME_FULL:
1298         dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
1299         mx-= mb_x*16;
1300         my-= mb_y*16;
1301         break;
1302     case ME_LOG:
1303         dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1304         mx-= mb_x*16;
1305         my-= mb_y*16;
1306         break;
1307     case ME_PHODS:
1308         dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1309         mx-= mb_x*16;
1310         my-= mb_y*16;
1311         break;
1312     case ME_X1:
1313     case ME_EPZS:
1314        {
1315
1316             P_LAST[0]        = mv_table[mot_xy    ][0];
1317             P_LAST[1]        = mv_table[mot_xy    ][1];
1318             P_LEFT[0]        = mv_table[mot_xy - 1][0];
1319             P_LEFT[1]        = mv_table[mot_xy - 1][1];
1320             P_LAST_RIGHT[0]  = mv_table[mot_xy + 1][0];
1321             P_LAST_RIGHT[1]  = mv_table[mot_xy + 1][1];
1322             P_LAST_BOTTOM[0] = mv_table[mot_xy + mot_stride][0];
1323             P_LAST_BOTTOM[1] = mv_table[mot_xy + mot_stride][1];
1324
1325             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);
1326             if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);
1327             if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);
1328
1329             /* special case for first line */
1330             if ((mb_y == 0 || s->first_slice_line)) {
1331             } else {
1332                 P_TOP[0] = mv_table[mot_xy - mot_stride             ][0];
1333                 P_TOP[1] = mv_table[mot_xy - mot_stride             ][1];
1334                 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1         ][0];
1335                 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1         ][1];
1336                 if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1]= (rel_ymax<<shift);
1337                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
1338                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
1339         
1340                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1341                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1342             }
1343             pred_x= P_LEFT[0];
1344             pred_y= P_LEFT[1];
1345         }
1346         dmin = epzs_motion_search(s, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, ref_picture);
1347  
1348         break;
1349     }
1350     
1351     dmin= fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 
1352                                 pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 
1353                                 pix_abs16x16_xy2, 0);
1354 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);
1355 //    s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1356     mv_table[mot_xy][0]= mx;
1357     mv_table[mot_xy][1]= my;
1358     return dmin;
1359 }
1360
1361
1362 static inline int check_bidir_mv(MpegEncContext * s,
1363                    int mb_x, int mb_y,
1364                    int motion_fx, int motion_fy,
1365                    int motion_bx, int motion_by,
1366                    int pred_fx, int pred_fy,
1367                    int pred_bx, int pred_by)
1368 {
1369     //FIXME optimize?
1370     //FIXME direct mode penalty
1371     UINT16 *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
1372     uint8_t *dest_y = s->me_scratchpad;
1373     uint8_t *ptr;
1374     int dxy;
1375     int src_x, src_y;
1376     int fbmin;
1377
1378     fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*s->qscale;
1379
1380     dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
1381     src_x = mb_x * 16 + (motion_fx >> 1);
1382     src_y = mb_y * 16 + (motion_fy >> 1);
1383             
1384     ptr = s->last_picture[0] + (src_y * s->linesize) + src_x;
1385     put_pixels_tab[dxy](dest_y    , ptr    , s->linesize, 16);
1386     put_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);
1387     
1388     fbmin += (mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*s->qscale;
1389
1390     dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
1391     src_x = mb_x * 16 + (motion_bx >> 1);
1392     src_y = mb_y * 16 + (motion_by >> 1);
1393             
1394     ptr = s->next_picture[0] + (src_y * s->linesize) + src_x;
1395     avg_pixels_tab[dxy](dest_y    , ptr    , s->linesize, 16);
1396     avg_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);
1397     
1398     fbmin += pix_abs16x16(s->new_picture[0] + mb_x*16 + mb_y*16*s->linesize, dest_y, s->linesize);
1399     return fbmin;
1400 }
1401
1402 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
1403 static inline int bidir_refine(MpegEncContext * s,
1404                                   int mb_x, int mb_y)
1405 {
1406     const int mot_stride = s->mb_width + 2;
1407     const int xy = (mb_y + 1)*mot_stride + mb_x + 1;
1408     int fbmin;
1409     int pred_fx= s->b_bidir_forw_mv_table[xy-1][0];
1410     int pred_fy= s->b_bidir_forw_mv_table[xy-1][1];
1411     int pred_bx= s->b_bidir_back_mv_table[xy-1][0];
1412     int pred_by= s->b_bidir_back_mv_table[xy-1][1];
1413     int motion_fx= s->b_bidir_forw_mv_table[xy][0]= s->b_forw_mv_table[xy][0];
1414     int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1];
1415     int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0];
1416     int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1];
1417
1418     //FIXME do refinement and add flag
1419     
1420     fbmin= check_bidir_mv(s, mb_x, mb_y, 
1421                           motion_fx, motion_fy,
1422                           motion_bx, motion_by,
1423                           pred_fx, pred_fy,
1424                           pred_bx, pred_by);
1425
1426    return fbmin;
1427 }
1428
1429 static inline int direct_search(MpegEncContext * s,
1430                                 int mb_x, int mb_y)
1431 {
1432     int P[10][2];
1433     const int mot_stride = s->mb_width + 2;
1434     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
1435     int dmin, dmin2;
1436     int motion_fx, motion_fy, motion_bx, motion_by, motion_bx0, motion_by0;
1437     int motion_dx, motion_dy;
1438     const int motion_px= s->p_mv_table[mot_xy][0];
1439     const int motion_py= s->p_mv_table[mot_xy][1];
1440     const int time_pp= s->pp_time;
1441     const int time_bp= s->bp_time;
1442     const int time_pb= time_pp - time_bp;
1443     int bx, by;
1444     int mx, my, mx2, my2;
1445     uint8_t *ref_picture= s->me_scratchpad - (mb_x - 1 + (mb_y - 1)*s->linesize)*16;
1446     int16_t (*mv_table)[2]= s->b_direct_mv_table;
1447     uint16_t *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
1448
1449     /* thanks to iso-mpeg the rounding is different for the zero vector, so we need to handle that ... */
1450     motion_fx= (motion_px*time_pb)/time_pp;
1451     motion_fy= (motion_py*time_pb)/time_pp;
1452     motion_bx0= (-motion_px*time_bp)/time_pp;
1453     motion_by0= (-motion_py*time_bp)/time_pp;
1454     motion_dx= motion_dy=0;
1455     dmin2= check_bidir_mv(s, mb_x, mb_y, 
1456                           motion_fx, motion_fy,
1457                           motion_bx0, motion_by0,
1458                           motion_fx, motion_fy,
1459                           motion_bx0, motion_by0) - s->qscale;
1460
1461     motion_bx= motion_fx - motion_px;
1462     motion_by= motion_fy - motion_py;
1463     for(by=-1; by<2; by++){
1464         for(bx=-1; bx<2; bx++){
1465             uint8_t *dest_y = s->me_scratchpad + (by+1)*s->linesize*16 + (bx+1)*16;
1466             uint8_t *ptr;
1467             int dxy;
1468             int src_x, src_y;
1469             const int width= s->width;
1470             const int height= s->height;
1471
1472             dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
1473             src_x = (mb_x + bx) * 16 + (motion_fx >> 1);
1474             src_y = (mb_y + by) * 16 + (motion_fy >> 1);
1475             src_x = clip(src_x, -16, width);
1476             if (src_x == width) dxy &= ~1;
1477             src_y = clip(src_y, -16, height);
1478             if (src_y == height) dxy &= ~2;
1479
1480             ptr = s->last_picture[0] + (src_y * s->linesize) + src_x;
1481             put_pixels_tab[dxy](dest_y    , ptr    , s->linesize, 16);
1482             put_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);
1483
1484             dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
1485             src_x = (mb_x + bx) * 16 + (motion_bx >> 1);
1486             src_y = (mb_y + by) * 16 + (motion_by >> 1);
1487             src_x = clip(src_x, -16, width);
1488             if (src_x == width) dxy &= ~1;
1489             src_y = clip(src_y, -16, height);
1490             if (src_y == height) dxy &= ~2;
1491
1492             avg_pixels_tab[dxy](dest_y    , ptr    , s->linesize, 16);
1493             avg_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);
1494         }
1495     }
1496
1497     P_LAST[0]        = mv_table[mot_xy    ][0];
1498     P_LAST[1]        = mv_table[mot_xy    ][1];
1499     P_LEFT[0]        = mv_table[mot_xy - 1][0];
1500     P_LEFT[1]        = mv_table[mot_xy - 1][1];
1501     P_LAST_RIGHT[0]  = mv_table[mot_xy + 1][0];
1502     P_LAST_RIGHT[1]  = mv_table[mot_xy + 1][1];
1503     P_LAST_BOTTOM[0] = mv_table[mot_xy + mot_stride][0];
1504     P_LAST_BOTTOM[1] = mv_table[mot_xy + mot_stride][1];
1505 /*
1506     if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);
1507     if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);
1508     if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);
1509 */
1510     /* special case for first line */
1511     if ((mb_y == 0 || s->first_slice_line)) {
1512     } else {
1513         P_TOP[0] = mv_table[mot_xy - mot_stride             ][0];
1514         P_TOP[1] = mv_table[mot_xy - mot_stride             ][1];
1515         P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1         ][0];
1516         P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1         ][1];
1517     
1518         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1519         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1520     }
1521     dmin = epzs_motion_search(s, &mx, &my, P, 0, 0, -16, -16, 15, 15, ref_picture);
1522     if(mx==0 && my==0) dmin=99999999; // not representable, due to rounding stuff
1523     if(dmin2<dmin){ 
1524         dmin= dmin2;
1525         mx=0;
1526         my=0;
1527     }
1528 #if 1
1529     mx2= mx= mx*2; 
1530     my2= my= my*2;
1531     for(by=-1; by<2; by++){
1532         if(my2+by < -32) continue;
1533         for(bx=-1; bx<2; bx++){
1534             if(bx==0 && by==0) continue;
1535             if(mx2+bx < -32) continue;
1536             dmin2= check_bidir_mv(s, mb_x, mb_y, 
1537                           mx2+bx+motion_fx, my2+by+motion_fy,
1538                           mx2+bx+motion_bx, my2+by+motion_by,
1539                           mx2+bx+motion_fx, my2+by+motion_fy,
1540                           motion_bx, motion_by) - s->qscale;
1541             
1542             if(dmin2<dmin){
1543                 dmin=dmin2;
1544                 mx= mx2 + bx;
1545                 my= my2 + by;
1546             }
1547         }
1548     }
1549 #else
1550     mx*=2; my*=2;
1551 #endif
1552     if(mx==0 && my==0){
1553         motion_bx= motion_bx0;
1554         motion_by= motion_by0;
1555     }
1556
1557     s->b_direct_mv_table[mot_xy][0]= mx;
1558     s->b_direct_mv_table[mot_xy][1]= my;
1559     s->b_direct_forw_mv_table[mot_xy][0]= motion_fx + mx;
1560     s->b_direct_forw_mv_table[mot_xy][1]= motion_fy + my;
1561     s->b_direct_back_mv_table[mot_xy][0]= motion_bx + mx;
1562     s->b_direct_back_mv_table[mot_xy][1]= motion_by + my;
1563     return dmin;
1564 }
1565
1566 void ff_estimate_b_frame_motion(MpegEncContext * s,
1567                              int mb_x, int mb_y)
1568 {
1569     const int quant= s->qscale;
1570     int fmin, bmin, dmin, fbmin;
1571     int type=0;
1572     
1573     dmin= direct_search(s, mb_x, mb_y);
1574
1575     fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, s->last_picture[0], s->f_code);
1576     bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, s->next_picture[0], s->b_code) - quant;
1577 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]);
1578
1579     fbmin= bidir_refine(s, mb_x, mb_y);
1580
1581     if(s->flags&CODEC_FLAG_HQ){
1582         type= MB_TYPE_FORWARD | MB_TYPE_BACKWARD | MB_TYPE_BIDIR | MB_TYPE_DIRECT;
1583     }else{
1584         int score= dmin;
1585         type=MB_TYPE_DIRECT;
1586         
1587         if(fmin<score){
1588             score=fmin;
1589             type= MB_TYPE_FORWARD; 
1590         }
1591         if(bmin<score){
1592             score=bmin;
1593             type= MB_TYPE_BACKWARD; 
1594         }
1595         if(fbmin<score){
1596             score=fbmin;
1597             type= MB_TYPE_BIDIR;
1598         }
1599         s->mc_mb_var_sum += score;
1600         s->mc_mb_var[mb_y*s->mb_width + mb_x] = score;
1601     }
1602 /*
1603 {
1604 static int count=0;
1605 static int sum=0;
1606 if(type==MB_TYPE_DIRECT){
1607   int diff= ABS(s->b_forw_mv_table)
1608 }
1609 }*/
1610
1611     s->mb_type[mb_y*s->mb_width + mb_x]= type;
1612 /*    if(mb_y==0 && mb_x==0) printf("\n");
1613     if(mb_x==0) printf("\n");
1614     printf("%d", av_log2(type));
1615 */
1616 }
1617
1618 /* find best f_code for ME which do unlimited searches */
1619 int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
1620 {
1621     if(s->me_method>=ME_EPZS){
1622         int score[8];
1623         int i, y;
1624         UINT8 * fcode_tab= s->fcode_tab;
1625         int best_fcode=-1;
1626         int best_score=-10000000;
1627
1628         for(i=0; i<8; i++) score[i]= s->mb_num*(8-i); //FIXME *2 and all other too so its the same but nicer
1629
1630         for(y=0; y<s->mb_height; y++){
1631             int x;
1632             int xy= (y+1)* (s->mb_width+2) + 1;
1633             i= y*s->mb_width;
1634             for(x=0; x<s->mb_width; x++){
1635                 if(s->mb_type[i] & type){
1636                     int fcode= MAX(fcode_tab[mv_table[xy][0] + MAX_MV],
1637                                    fcode_tab[mv_table[xy][1] + MAX_MV]);
1638                     int j;
1639                     
1640                     for(j=0; j<fcode && j<8; j++){
1641                         if(s->pict_type==B_TYPE || s->mc_mb_var[i] < s->mb_var[i])
1642                             score[j]-= 170;
1643                     }
1644                 }
1645                 i++;
1646                 xy++;
1647             }
1648         }
1649         
1650         for(i=1; i<8; i++){
1651             if(score[i] > best_score){
1652                 best_score= score[i];
1653                 best_fcode= i;
1654             }
1655 //            printf("%d %d\n", i, score[i]);
1656         }
1657
1658 //    printf("fcode: %d type: %d\n", i, s->pict_type);
1659         return best_fcode;
1660 /*        for(i=0; i<=MAX_FCODE; i++){
1661             printf("%d ", mv_num[i]);
1662         }
1663         printf("\n");*/
1664     }else{
1665         return 1;
1666     }
1667 }
1668
1669 void ff_fix_long_p_mvs(MpegEncContext * s)
1670 {
1671     const int f_code= s->f_code;
1672     int y;
1673     UINT8 * fcode_tab= s->fcode_tab;
1674 //int clip=0;
1675 //int noclip=0;
1676     /* clip / convert to intra 16x16 type MVs */
1677     for(y=0; y<s->mb_height; y++){
1678         int x;
1679         int xy= (y+1)* (s->mb_width+2)+1;
1680         int i= y*s->mb_width;
1681         for(x=0; x<s->mb_width; x++){
1682             if(s->mb_type[i]&MB_TYPE_INTER){
1683                 if(   fcode_tab[s->p_mv_table[xy][0] + MAX_MV] > f_code
1684                    || fcode_tab[s->p_mv_table[xy][0] + MAX_MV] == 0
1685                    || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] > f_code
1686                    || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] == 0 ){
1687                     s->mb_type[i] &= ~MB_TYPE_INTER;
1688                     s->mb_type[i] |= MB_TYPE_INTRA;
1689                     s->p_mv_table[xy][0] = 0;
1690                     s->p_mv_table[xy][1] = 0;
1691 //clip++;
1692                 }
1693 //else
1694 //  noclip++;
1695             }
1696             xy++;
1697             i++;
1698         }
1699     }
1700 //printf("%d no:%d %d//\n", clip, noclip, f_code);
1701     if(s->flags&CODEC_FLAG_4MV){
1702         const int wrap= 2+ s->mb_width*2;
1703
1704         /* clip / convert to intra 8x8 type MVs */
1705         for(y=0; y<s->mb_height; y++){
1706             int xy= (y*2 + 1)*wrap + 1;
1707             int i= y*s->mb_width;
1708             int x;
1709
1710             for(x=0; x<s->mb_width; x++){
1711                 if(s->mb_type[i]&MB_TYPE_INTER4V){
1712                     int block;
1713                     for(block=0; block<4; block++){
1714                         int off= (block& 1) + (block>>1)*wrap;
1715                         int mx= s->motion_val[ xy + off ][0];
1716                         int my= s->motion_val[ xy + off ][1];
1717
1718                         if(   fcode_tab[mx + MAX_MV] > f_code
1719                            || fcode_tab[mx + MAX_MV] == 0
1720                            || fcode_tab[my + MAX_MV] > f_code
1721                            || fcode_tab[my + MAX_MV] == 0 ){
1722                             s->mb_type[i] &= ~MB_TYPE_INTER4V;
1723                             s->mb_type[i] |= MB_TYPE_INTRA;
1724                         }
1725                     }
1726                 }
1727                 xy+=2;
1728                 i++;
1729             }
1730         }
1731     }
1732 }
1733
1734 void ff_fix_long_b_mvs(MpegEncContext * s, int16_t (*mv_table)[2], int f_code, int type)
1735 {
1736     int y;
1737     UINT8 * fcode_tab= s->fcode_tab;
1738
1739     /* clip / convert to intra 16x16 type MVs */
1740     for(y=0; y<s->mb_height; y++){
1741         int x;
1742         int xy= (y+1)* (s->mb_width+2)+1;
1743         int i= y*s->mb_width;
1744         for(x=0; x<s->mb_width; x++){
1745             if(s->mb_type[i]&type){
1746                 if(   fcode_tab[mv_table[xy][0] + MAX_MV] > f_code
1747                    || fcode_tab[mv_table[xy][0] + MAX_MV] == 0
1748                    || fcode_tab[mv_table[xy][1] + MAX_MV] > f_code
1749                    || fcode_tab[mv_table[xy][1] + MAX_MV] == 0 ){
1750                     if(s->mb_type[i]&(~type)) s->mb_type[i] &= ~type;
1751                     else{
1752                         mv_table[xy][0] = 0;
1753                         mv_table[xy][1] = 0;
1754                         //this is certainly bad FIXME            
1755                     }
1756                 }
1757             }
1758             xy++;
1759             i++;
1760         }
1761     }
1762 }