git.sesse.net Git - ffmpeg/blob - libavcodec/motion_est.c

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