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     Minima *da = (Minima *) a;
  65     Minima *db = (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 * 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 *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 *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 *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 *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 static inline void get_limits(MpegEncContext *s, int *range, int *xmin, int *ymin, int *xmax, int *ymax, int f_code)
 795 {
 796     *range = 8 * (1 << (f_code - 1));
 797     /* XXX: temporary kludge to avoid overflow for msmpeg4 */
 798     if (s->out_format == FMT_H263 && !s->h263_msmpeg4)
 799         *range *= 2;
 800
 801     if (s->unrestricted_mv) {
 802         *xmin = -16;
 803         *ymin = -16;
 804         if (s->h263_plus)
 805             *range *= 2;
 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
 821 static inline int h263_mv4_search(MpegEncContext *s, int xmin, int ymin, int xmax, int ymax, int mx, int my, int shift)
 822 {
 823     int block;
 824     int P[10][2];
 825     int dmin_sum=0, mx4_sum=0, my4_sum=0;
 826     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;
 827
 828     for(block=0; block<4; block++){
 829         int mx4, my4;
 830         int pred_x4, pred_y4;
 831         int dmin4;
 832         static const int off[4]= {2, 1, 1, -1};
 833         const int mot_stride = s->block_wrap[0];
 834         const int mot_xy = s->block_index[block];
 835 //        const int block_x= (block&1);
 836 //        const int block_y= (block>>1);
 837 #if 1 // this saves us a bit of cliping work and shouldnt affect compression in a negative way
 838         const int rel_xmin4= xmin;
 839         const int rel_xmax4= xmax;
 840         const int rel_ymin4= ymin;
 841         const int rel_ymax4= ymax;
 842 #else
 843         const int rel_xmin4= xmin - block_x*8;
 844         const int rel_xmax4= xmax - block_x*8 + 8;
 845         const int rel_ymin4= ymin - block_y*8;
 846         const int rel_ymax4= ymax - block_y*8 + 8;
 847 #endif
 848         P_LEFT[0] = s->motion_val[mot_xy - 1][0];
 849         P_LEFT[1] = s->motion_val[mot_xy - 1][1];
 850
 851         if(P_LEFT[0]       > (rel_xmax4<<shift)) P_LEFT[0]       = (rel_xmax4<<shift);
 852
 853         /* special case for first line */
 854         if (s->mb_y == 0 && block<2) {
 855             pred_x4= P_LEFT[0];
 856             pred_y4= P_LEFT[1];
 857         } else {
 858             P_TOP[0]      = s->motion_val[mot_xy - mot_stride             ][0];
 859             P_TOP[1]      = s->motion_val[mot_xy - mot_stride             ][1];
 860             P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + off[block]][0];
 861             P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + off[block]][1];
 862             if(P_TOP[1]      > (rel_ymax4<<shift)) P_TOP[1]     = (rel_ymax4<<shift);
 863             if(P_TOPRIGHT[0] < (rel_xmin4<<shift)) P_TOPRIGHT[0]= (rel_xmin4<<shift);
 864             if(P_TOPRIGHT[0] > (rel_xmax4<<shift)) P_TOPRIGHT[0]= (rel_xmax4<<shift);
 865             if(P_TOPRIGHT[1] > (rel_ymax4<<shift)) P_TOPRIGHT[1]= (rel_ymax4<<shift);
 866
 867             P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
 868             P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
 869
 870 //            if(s->out_format == FMT_H263){
 871                 pred_x4 = P_MEDIAN[0];
 872                 pred_y4 = P_MEDIAN[1];
 873 #if 0
 874             }else { /* mpeg1 at least */
 875                 pred_x4= P_LEFT[0];
 876                 pred_y4= P_LEFT[1];
 877             }
 878 #endif
 879         }
 880         P_MV1[0]= mx;
 881         P_MV1[1]= my;
 882
 883         dmin4 = s->me.motion_search[1](s, block, &mx4, &my4, P, pred_x4, pred_y4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4,
 884                                        &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);
 885
 886         dmin4= s->me.sub_motion_search(s, &mx4, &my4, dmin4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4,
 887                                           pred_x4, pred_y4, &s->last_picture, block, 1, mv_penalty);
 888
 889         if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
 890             int dxy;
 891             const int offset= ((block&1) + (block>>1)*s->linesize)*8;
 892             uint8_t *dest_y = s->me.scratchpad + offset;
 893
 894             if(s->quarter_sample){
 895                 uint8_t *ref= s->last_picture.data[0] + (s->mb_x*16 + (mx4>>2)) + (s->mb_y*16 + (my4>>2))*s->linesize + offset;
 896                 dxy = ((my4 & 3) << 2) | (mx4 & 3);
 897
 898                 if(s->no_rounding)
 899                     s->dsp.put_no_rnd_qpel_pixels_tab[1][dxy](dest_y   , ref    , s->linesize);
 900                 else
 901                     s->dsp.put_qpel_pixels_tab       [1][dxy](dest_y   , ref    , s->linesize);
 902             }else{
 903                 uint8_t *ref= s->last_picture.data[0] + (s->mb_x*16 + (mx4>>1)) + (s->mb_y*16 + (my4>>1))*s->linesize + offset;
 904                 dxy = ((my4 & 1) << 1) | (mx4 & 1);
 905
 906                 if(s->no_rounding)
 907                     s->dsp.put_no_rnd_pixels_tab[1][dxy](dest_y    , ref    , s->linesize, 8);
 908                 else
 909                     s->dsp.put_pixels_tab       [1][dxy](dest_y    , ref    , s->linesize, 8);
 910             }
 911             dmin_sum+= (mv_penalty[mx4-pred_x4] + mv_penalty[my4-pred_y4])*s->me.mb_penalty_factor;
 912         }else
 913             dmin_sum+= dmin4;
 914
 915         if(s->quarter_sample){
 916             mx4_sum+= mx4/2;
 917             my4_sum+= my4/2;
 918         }else{
 919             mx4_sum+= mx4;
 920             my4_sum+= my4;
 921         }
 922
 923         s->motion_val[ s->block_index[block] ][0]= mx4;
 924         s->motion_val[ s->block_index[block] ][1]= my4;
 925     }
 926
 927     if(s->dsp.me_sub_cmp[0] != s->dsp.mb_cmp[0]){
 928         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);
 929     }
 930
 931     if(s->avctx->mb_cmp&FF_CMP_CHROMA){
 932         int dxy;
 933         int mx, my;
 934         int offset;
 935
 936         mx= ff_h263_round_chroma(mx4_sum);
 937         my= ff_h263_round_chroma(my4_sum);
 938         dxy = ((my & 1) << 1) | (mx & 1);
 939
 940         offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize;
 941
 942         if(s->no_rounding){
 943             s->dsp.put_no_rnd_pixels_tab[1][dxy](s->me.scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);
 944             s->dsp.put_no_rnd_pixels_tab[1][dxy](s->me.scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);
 945         }else{
 946             s->dsp.put_pixels_tab       [1][dxy](s->me.scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);
 947             s->dsp.put_pixels_tab       [1][dxy](s->me.scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);
 948         }
 949
 950         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);
 951         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);
 952     }
 953
 954     switch(s->avctx->mb_cmp&0xFF){
 955     /*case FF_CMP_SSE:
 956         return dmin_sum+ 32*s->qscale*s->qscale;*/
 957     case FF_CMP_RD:
 958         return dmin_sum;
 959     default:
 960         return dmin_sum+ 11*s->me.mb_penalty_factor;
 961     }
 962 }
 963
 964 void ff_estimate_p_frame_motion(MpegEncContext * s,
 965                                 int mb_x, int mb_y)
 966 {
 967     UINT8 *pix, *ppix;
 968     int sum, varc, vard, mx, my, range, dmin, xx, yy;
 969     int xmin, ymin, xmax, ymax;
 970     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
 971     int pred_x=0, pred_y=0;
 972     int P[10][2];
 973     const int shift= 1+s->quarter_sample;
 974     int mb_type=0;
 975     uint8_t *ref_picture= s->last_picture.data[0];
 976     Picture * const pic= &s->current_picture;
 977     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;
 978
 979     assert(s->quarter_sample==0 || s->quarter_sample==1);
 980
 981     s->me.penalty_factor    = get_penalty_factor(s, s->avctx->me_cmp);
 982     s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);
 983     s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);
 984
 985     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, s->f_code);
 986     rel_xmin= xmin - mb_x*16;
 987     rel_xmax= xmax - mb_x*16;
 988     rel_ymin= ymin - mb_y*16;
 989     rel_ymax= ymax - mb_y*16;
 990     s->me.skip=0;
 991
 992     switch(s->me_method) {
 993     case ME_ZERO:
 994     default:
 995         no_motion_search(s, &mx, &my);
 996         mx-= mb_x*16;
 997         my-= mb_y*16;
 998         dmin = 0;
 999         break;
1000     case ME_FULL:
1001         dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
1002         mx-= mb_x*16;
1003         my-= mb_y*16;
1004         break;
1005     case ME_LOG:
1006         dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1007         mx-= mb_x*16;
1008         my-= mb_y*16;
1009         break;
1010     case ME_PHODS:
1011         dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1012         mx-= mb_x*16;
1013         my-= mb_y*16;
1014         break;
1015     case ME_X1:
1016     case ME_EPZS:
1017        {
1018             const int mot_stride = s->block_wrap[0];
1019             const int mot_xy = s->block_index[0];
1020
1021             P_LEFT[0]       = s->motion_val[mot_xy - 1][0];
1022             P_LEFT[1]       = s->motion_val[mot_xy - 1][1];
1023
1024             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);
1025
1026             if(mb_y) {
1027                 P_TOP[0]      = s->motion_val[mot_xy - mot_stride    ][0];
1028                 P_TOP[1]      = s->motion_val[mot_xy - mot_stride    ][1];
1029                 P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + 2][0];
1030                 P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + 2][1];
1031                 if(P_TOP[1]      > (rel_ymax<<shift)) P_TOP[1]     = (rel_ymax<<shift);
1032                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
1033                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
1034
1035                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1036                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1037
1038                 if(s->out_format == FMT_H263){
1039                     pred_x = P_MEDIAN[0];
1040                     pred_y = P_MEDIAN[1];
1041                 }else { /* mpeg1 at least */
1042                     pred_x= P_LEFT[0];
1043                     pred_y= P_LEFT[1];
1044                 }
1045             }else{
1046                 pred_x= P_LEFT[0];
1047                 pred_y= P_LEFT[1];
1048             }
1049
1050         }
1051         dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1052                                       &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);
1053
1054         break;
1055     }
1056
1057     /* intra / predictive decision */
1058     xx = mb_x * 16;
1059     yy = mb_y * 16;
1060
1061     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
1062     /* At this point (mx,my) are full-pell and the relative displacement */
1063     ppix = ref_picture + ((yy+my) * s->linesize) + (xx+mx);
1064
1065     sum = s->dsp.pix_sum(pix, s->linesize);
1066
1067     varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
1068     vard = (s->dsp.sse[0](NULL, pix, ppix, s->linesize)+128)>>8;
1069
1070 //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);
1071     pic->mb_var   [s->mb_width * mb_y + mb_x] = varc;
1072     pic->mc_mb_var[s->mb_width * mb_y + mb_x] = vard;
1073     pic->mb_mean  [s->mb_width * mb_y + mb_x] = (sum+128)>>8;
1074 //    pic->mb_cmp_score[s->mb_width * mb_y + mb_x] = dmin;
1075     pic->mb_var_sum    += varc;
1076     pic->mc_mb_var_sum += vard;
1077 //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);
1078
1079 #if 0
1080     printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n",
1081            varc, s->avg_mb_var, sum, vard, mx - xx, my - yy);
1082 #endif
1083     if(s->flags&CODEC_FLAG_HQ){
1084         if (vard <= 64 || vard < varc)
1085             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1086         else
1087             s->scene_change_score+= s->qscale;
1088
1089         if (vard*2 + 200 > varc)
1090             mb_type|= MB_TYPE_INTRA;
1091         if (varc*2 + 200 > vard){
1092             mb_type|= MB_TYPE_INTER;
1093             s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1094                                    pred_x, pred_y, &s->last_picture, 0, 0, mv_penalty);
1095         }else{
1096             mx <<=shift;
1097             my <<=shift;
1098         }
1099         if((s->flags&CODEC_FLAG_4MV)
1100            && !s->me.skip && varc>50 && vard>10){
1101             h263_mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
1102             mb_type|=MB_TYPE_INTER4V;
1103
1104             set_p_mv_tables(s, mx, my, 0);
1105         }else
1106             set_p_mv_tables(s, mx, my, 1);
1107     }else{
1108         mb_type= MB_TYPE_INTER;
1109
1110         dmin= s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1111                                     pred_x, pred_y, &s->last_picture, 0, 0, mv_penalty);
1112
1113         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1114             dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, &s->last_picture, mv_penalty);
1115
1116         if((s->flags&CODEC_FLAG_4MV)
1117            && !s->me.skip && varc>50 && vard>10){
1118             int dmin4= h263_mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);
1119             if(dmin4 < dmin){
1120                 mb_type= MB_TYPE_INTER4V;
1121                 dmin=dmin4;
1122             }
1123         }
1124         pic->mb_cmp_score[s->mb_width * mb_y + mb_x] = dmin;
1125         set_p_mv_tables(s, mx, my, mb_type!=MB_TYPE_INTER4V);
1126
1127         if (vard <= 64 || vard < varc) {
1128             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1129         }else{
1130             s->scene_change_score+= s->qscale;
1131         }
1132     }
1133
1134     s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1135 }
1136
1137 int ff_pre_estimate_p_frame_motion(MpegEncContext * s,
1138                                     int mb_x, int mb_y)
1139 {
1140     int mx, my, range, dmin;
1141     int xmin, ymin, xmax, ymax;
1142     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
1143     int pred_x=0, pred_y=0;
1144     int P[10][2];
1145     const int shift= 1+s->quarter_sample;
1146     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;
1147     const int mv_stride= s->mb_width + 2;
1148     const int xy= mb_x + 1 + (mb_y + 1)*mv_stride;
1149
1150     assert(s->quarter_sample==0 || s->quarter_sample==1);
1151
1152     s->me.pre_penalty_factor    = get_penalty_factor(s, s->avctx->me_pre_cmp);
1153
1154     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, s->f_code);
1155     rel_xmin= xmin - mb_x*16;
1156     rel_xmax= xmax - mb_x*16;
1157     rel_ymin= ymin - mb_y*16;
1158     rel_ymax= ymax - mb_y*16;
1159     s->me.skip=0;
1160
1161     P_LEFT[0]       = s->p_mv_table[xy + 1][0];
1162     P_LEFT[1]       = s->p_mv_table[xy + 1][1];
1163
1164     if(P_LEFT[0]       < (rel_xmin<<shift)) P_LEFT[0]       = (rel_xmin<<shift);
1165
1166     /* special case for first line */
1167     if (mb_y == s->mb_height-1) {
1168         pred_x= P_LEFT[0];
1169         pred_y= P_LEFT[1];
1170         P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]=
1171         P_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0; //FIXME
1172     } else {
1173         P_TOP[0]      = s->p_mv_table[xy + mv_stride    ][0];
1174         P_TOP[1]      = s->p_mv_table[xy + mv_stride    ][1];
1175         P_TOPRIGHT[0] = s->p_mv_table[xy + mv_stride - 1][0];
1176         P_TOPRIGHT[1] = s->p_mv_table[xy + mv_stride - 1][1];
1177         if(P_TOP[1]      < (rel_ymin<<shift)) P_TOP[1]     = (rel_ymin<<shift);
1178         if(P_TOPRIGHT[0] > (rel_xmax<<shift)) P_TOPRIGHT[0]= (rel_xmax<<shift);
1179         if(P_TOPRIGHT[1] < (rel_ymin<<shift)) P_TOPRIGHT[1]= (rel_ymin<<shift);
1180
1181         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1182         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1183
1184         pred_x = P_MEDIAN[0];
1185         pred_y = P_MEDIAN[1];
1186     }
1187     dmin = s->me.pre_motion_search(s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1188                                    &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);
1189
1190     s->p_mv_table[xy][0] = mx<<shift;
1191     s->p_mv_table[xy][1] = my<<shift;
1192
1193     return dmin;
1194 }
1195
1196 int ff_estimate_motion_b(MpegEncContext * s,
1197                        int mb_x, int mb_y, int16_t (*mv_table)[2], Picture *picture, int f_code)
1198 {
1199     int mx, my, range, dmin;
1200     int xmin, ymin, xmax, ymax;
1201     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
1202     int pred_x=0, pred_y=0;
1203     int P[10][2];
1204     const int shift= 1+s->quarter_sample;
1205     const int mot_stride = s->mb_width + 2;
1206     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
1207     uint8_t * const ref_picture= picture->data[0];
1208     uint16_t * const mv_penalty= s->me.mv_penalty[f_code] + MAX_MV;
1209     int mv_scale;
1210
1211     s->me.penalty_factor    = get_penalty_factor(s, s->avctx->me_cmp);
1212     s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);
1213     s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);
1214
1215     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, f_code);
1216     rel_xmin= xmin - mb_x*16;
1217     rel_xmax= xmax - mb_x*16;
1218     rel_ymin= ymin - mb_y*16;
1219     rel_ymax= ymax - mb_y*16;
1220
1221     switch(s->me_method) {
1222     case ME_ZERO:
1223     default:
1224         no_motion_search(s, &mx, &my);
1225         dmin = 0;
1226         mx-= mb_x*16;
1227         my-= mb_y*16;
1228         break;
1229     case ME_FULL:
1230         dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
1231         mx-= mb_x*16;
1232         my-= mb_y*16;
1233         break;
1234     case ME_LOG:
1235         dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1236         mx-= mb_x*16;
1237         my-= mb_y*16;
1238         break;
1239     case ME_PHODS:
1240         dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
1241         mx-= mb_x*16;
1242         my-= mb_y*16;
1243         break;
1244     case ME_X1:
1245     case ME_EPZS:
1246        {
1247             P_LEFT[0]        = mv_table[mot_xy - 1][0];
1248             P_LEFT[1]        = mv_table[mot_xy - 1][1];
1249
1250             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);
1251
1252             /* special case for first line */
1253             if (mb_y) {
1254                 P_TOP[0] = mv_table[mot_xy - mot_stride             ][0];
1255                 P_TOP[1] = mv_table[mot_xy - mot_stride             ][1];
1256                 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1         ][0];
1257                 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1         ][1];
1258                 if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1]= (rel_ymax<<shift);
1259                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
1260                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
1261
1262                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1263                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1264             }
1265             pred_x= P_LEFT[0];
1266             pred_y= P_LEFT[1];
1267         }
1268
1269         if(mv_table == s->b_forw_mv_table){
1270             mv_scale= (s->pb_time<<16) / (s->pp_time<<shift);
1271         }else{
1272             mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift);
1273         }
1274
1275         dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1276                                       picture, s->p_mv_table, mv_scale, mv_penalty);
1277
1278         break;
1279     }
1280
1281     dmin= s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
1282                                    pred_x, pred_y, picture, 0, 0, mv_penalty);
1283
1284     if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1285         dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, picture, mv_penalty);
1286
1287 //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);
1288 //    s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
1289     mv_table[mot_xy][0]= mx;
1290     mv_table[mot_xy][1]= my;
1291
1292     return dmin;
1293 }
1294
1295 static inline int check_bidir_mv(MpegEncContext * s,
1296                    int mb_x, int mb_y,
1297                    int motion_fx, int motion_fy,
1298                    int motion_bx, int motion_by,
1299                    int pred_fx, int pred_fy,
1300                    int pred_bx, int pred_by)
1301 {
1302     //FIXME optimize?
1303     //FIXME move into template?
1304     //FIXME better f_code prediction (max mv & distance)
1305     UINT16 *mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame
1306     uint8_t *dest_y = s->me.scratchpad;
1307     uint8_t *ptr;
1308     int dxy;
1309     int src_x, src_y;
1310     int fbmin;
1311
1312     if(s->quarter_sample){
1313         dxy = ((motion_fy & 3) << 2) | (motion_fx & 3);
1314         src_x = mb_x * 16 + (motion_fx >> 2);
1315         src_y = mb_y * 16 + (motion_fy >> 2);
1316         assert(src_x >=-16 && src_x<=s->width);
1317         assert(src_y >=-16 && src_y<=s->height);
1318
1319         ptr = s->last_picture.data[0] + (src_y * s->linesize) + src_x;
1320         s->dsp.put_qpel_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize);
1321
1322         dxy = ((motion_by & 3) << 2) | (motion_bx & 3);
1323         src_x = mb_x * 16 + (motion_bx >> 2);
1324         src_y = mb_y * 16 + (motion_by >> 2);
1325         assert(src_x >=-16 && src_x<=s->width);
1326         assert(src_y >=-16 && src_y<=s->height);
1327
1328         ptr = s->next_picture.data[0] + (src_y * s->linesize) + src_x;
1329         s->dsp.avg_qpel_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize);
1330     }else{
1331         dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);
1332         src_x = mb_x * 16 + (motion_fx >> 1);
1333         src_y = mb_y * 16 + (motion_fy >> 1);
1334         assert(src_x >=-16 && src_x<=s->width);
1335         assert(src_y >=-16 && src_y<=s->height);
1336
1337         ptr = s->last_picture.data[0] + (src_y * s->linesize) + src_x;
1338         s->dsp.put_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize, 16);
1339
1340         dxy = ((motion_by & 1) << 1) | (motion_bx & 1);
1341         src_x = mb_x * 16 + (motion_bx >> 1);
1342         src_y = mb_y * 16 + (motion_by >> 1);
1343         assert(src_x >=-16 && src_x<=s->width);
1344         assert(src_y >=-16 && src_y<=s->height);
1345
1346         ptr = s->next_picture.data[0] + (src_y * s->linesize) + src_x;
1347         s->dsp.avg_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize, 16);
1348     }
1349
1350     fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*s->me.mb_penalty_factor
1351            +(mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*s->me.mb_penalty_factor
1352            + s->dsp.mb_cmp[0](s, s->new_picture.data[0] + mb_x*16 + mb_y*16*s->linesize, dest_y, s->linesize);
1353
1354     if(s->avctx->mb_cmp&FF_CMP_CHROMA){
1355     }
1356     //FIXME CHROMA !!!
1357
1358     return fbmin;
1359 }
1360
1361 /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/
1362 static inline int bidir_refine(MpegEncContext * s,
1363                                   int mb_x, int mb_y)
1364 {
1365     const int mot_stride = s->mb_width + 2;
1366     const int xy = (mb_y + 1)*mot_stride + mb_x + 1;
1367     int fbmin;
1368     int pred_fx= s->b_bidir_forw_mv_table[xy-1][0];
1369     int pred_fy= s->b_bidir_forw_mv_table[xy-1][1];
1370     int pred_bx= s->b_bidir_back_mv_table[xy-1][0];
1371     int pred_by= s->b_bidir_back_mv_table[xy-1][1];
1372     int motion_fx= s->b_bidir_forw_mv_table[xy][0]= s->b_forw_mv_table[xy][0];
1373     int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1];
1374     int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0];
1375     int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1];
1376
1377     //FIXME do refinement and add flag
1378
1379     fbmin= check_bidir_mv(s, mb_x, mb_y,
1380                           motion_fx, motion_fy,
1381                           motion_bx, motion_by,
1382                           pred_fx, pred_fy,
1383                           pred_bx, pred_by);
1384
1385    return fbmin;
1386 }
1387
1388 static inline int direct_search(MpegEncContext * s,
1389                                 int mb_x, int mb_y)
1390 {
1391     int P[10][2];
1392     const int mot_stride = s->mb_width + 2;
1393     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
1394     const int shift= 1+s->quarter_sample;
1395     int dmin, i;
1396     const int time_pp= s->pp_time;
1397     const int time_pb= s->pb_time;
1398     int mx, my, xmin, xmax, ymin, ymax;
1399     int16_t (*mv_table)[2]= s->b_direct_mv_table;
1400     uint16_t * const mv_penalty= s->me.mv_penalty[1] + MAX_MV;
1401
1402     ymin= xmin=(-32)>>shift;
1403     ymax= xmax=   31>>shift;
1404
1405     if(s->co_located_type_table[mb_x + mb_y*s->mb_width]==CO_LOCATED_TYPE_4MV){
1406         s->mv_type= MV_TYPE_8X8;
1407     }else{
1408         s->mv_type= MV_TYPE_16X16;
1409     }
1410
1411     for(i=0; i<4; i++){
1412         int index= s->block_index[i];
1413         int min, max;
1414
1415         s->me.co_located_mv[i][0]= s->motion_val[index][0];
1416         s->me.co_located_mv[i][1]= s->motion_val[index][1];
1417         s->me.direct_basis_mv[i][0]= s->me.co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3));
1418         s->me.direct_basis_mv[i][1]= s->me.co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3));
1419 //        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);
1420 //        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);
1421
1422         max= FFMAX(s->me.direct_basis_mv[i][0], s->me.direct_basis_mv[i][0] - s->me.co_located_mv[i][0])>>shift;
1423         min= FFMIN(s->me.direct_basis_mv[i][0], s->me.direct_basis_mv[i][0] - s->me.co_located_mv[i][0])>>shift;
1424         max+= (2*mb_x + (i& 1))*8 + 1; // +-1 is for the simpler rounding
1425         min+= (2*mb_x + (i& 1))*8 - 1;
1426         xmax= FFMIN(xmax, s->width - max);
1427         xmin= FFMAX(xmin, - 16     - min);
1428
1429         max= FFMAX(s->me.direct_basis_mv[i][1], s->me.direct_basis_mv[i][1] - s->me.co_located_mv[i][1])>>shift;
1430         min= FFMIN(s->me.direct_basis_mv[i][1], s->me.direct_basis_mv[i][1] - s->me.co_located_mv[i][1])>>shift;
1431         max+= (2*mb_y + (i>>1))*8 + 1; // +-1 is for the simpler rounding
1432         min+= (2*mb_y + (i>>1))*8 - 1;
1433         ymax= FFMIN(ymax, s->height - max);
1434         ymin= FFMAX(ymin, - 16      - min);
1435
1436         if(s->mv_type == MV_TYPE_16X16) break;
1437     }
1438
1439     assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);
1440
1441     if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){
1442         s->b_direct_mv_table[mot_xy][0]= 0;
1443         s->b_direct_mv_table[mot_xy][1]= 0;
1444
1445         return 256*256*256*64;
1446     }
1447
1448     P_LEFT[0]        = clip(mv_table[mot_xy - 1][0], xmin<<shift, xmax<<shift);
1449     P_LEFT[1]        = clip(mv_table[mot_xy - 1][1], ymin<<shift, ymax<<shift);
1450
1451     /* special case for first line */
1452     if (mb_y) {
1453         P_TOP[0]      = clip(mv_table[mot_xy - mot_stride             ][0], xmin<<shift, xmax<<shift);
1454         P_TOP[1]      = clip(mv_table[mot_xy - mot_stride             ][1], ymin<<shift, ymax<<shift);
1455         P_TOPRIGHT[0] = clip(mv_table[mot_xy - mot_stride + 1         ][0], xmin<<shift, xmax<<shift);
1456         P_TOPRIGHT[1] = clip(mv_table[mot_xy - mot_stride + 1         ][1], ymin<<shift, ymax<<shift);
1457
1458         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1459         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1460     }
1461
1462     //FIXME direct_search  ptr in context!!! (needed for chroma anyway or this will get messy)
1463     if(s->flags&CODEC_FLAG_QPEL){
1464         dmin = simple_direct_qpel_epzs_motion_search(s, 0, &mx, &my, P, 0, 0, xmin, ymin, xmax, ymax,
1465                                                      &s->last_picture, mv_table, 1<<14, mv_penalty);
1466         dmin = simple_direct_qpel_qpel_motion_search(s, &mx, &my, dmin, xmin, ymin, xmax, ymax,
1467                                                 0, 0, &s->last_picture, 0, 0, mv_penalty);
1468
1469         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1470             dmin= simple_direct_qpel_qpel_get_mb_score(s, mx, my, 0, 0, &s->last_picture, mv_penalty);
1471     }else{
1472         dmin = simple_direct_hpel_epzs_motion_search(s, 0, &mx, &my, P, 0, 0, xmin, ymin, xmax, ymax,
1473                                                      &s->last_picture, mv_table, 1<<15, mv_penalty);
1474         dmin = simple_direct_hpel_hpel_motion_search(s, &mx, &my, dmin, xmin, ymin, xmax, ymax,
1475                                                 0, 0, &s->last_picture, 0, 0, mv_penalty);
1476
1477         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
1478             dmin= simple_direct_hpel_hpel_get_mb_score(s, mx, my, 0, 0, &s->last_picture, mv_penalty);
1479     }
1480
1481     s->b_direct_mv_table[mot_xy][0]= mx;
1482     s->b_direct_mv_table[mot_xy][1]= my;
1483     return dmin;
1484 }
1485
1486 void ff_estimate_b_frame_motion(MpegEncContext * s,
1487                              int mb_x, int mb_y)
1488 {
1489     const int penalty_factor= s->me.mb_penalty_factor;
1490     int fmin, bmin, dmin, fbmin;
1491     int type=0;
1492
1493     dmin= direct_search(s, mb_x, mb_y);
1494
1495     fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, &s->last_picture, s->f_code) + 3*penalty_factor;
1496     bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, &s->next_picture, s->b_code) + 2*penalty_factor;
1497 //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]);
1498
1499     fbmin= bidir_refine(s, mb_x, mb_y) + penalty_factor;
1500 //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin);
1501     {
1502         int score= fmin;
1503         type = MB_TYPE_FORWARD;
1504
1505         // RAL: No MB_TYPE_DIRECT in MPEG-1 video (only MPEG-4)
1506         if (s->codec_id != CODEC_ID_MPEG1VIDEO && dmin <= score){
1507             score = dmin;
1508             type = MB_TYPE_DIRECT;
1509         }
1510         if(bmin<score){
1511             score=bmin;
1512             type= MB_TYPE_BACKWARD;
1513         }
1514         if(fbmin<score){
1515             score=fbmin;
1516             type= MB_TYPE_BIDIR;
1517         }
1518
1519         score= ((unsigned)(score*score + 128*256))>>16;
1520         s->current_picture.mc_mb_var_sum += score;
1521         s->current_picture.mc_mb_var[mb_y*s->mb_width + mb_x] = score; //FIXME use SSE
1522     }
1523
1524     if(s->flags&CODEC_FLAG_HQ){
1525         type= MB_TYPE_FORWARD | MB_TYPE_BACKWARD | MB_TYPE_BIDIR | MB_TYPE_DIRECT; //FIXME something smarter
1526         if(dmin>256*256*16) type&= ~MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB
1527     }
1528
1529     s->mb_type[mb_y*s->mb_width + mb_x]= type;
1530 }
1531
1532 /* find best f_code for ME which do unlimited searches */
1533 int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)
1534 {
1535     if(s->me_method>=ME_EPZS){
1536         int score[8];
1537         int i, y;
1538         UINT8 * fcode_tab= s->fcode_tab;
1539         int best_fcode=-1;
1540         int best_score=-10000000;
1541
1542         for(i=0; i<8; i++) score[i]= s->mb_num*(8-i);
1543
1544         for(y=0; y<s->mb_height; y++){
1545             int x;
1546             int xy= (y+1)* (s->mb_width+2) + 1;
1547             i= y*s->mb_width;
1548             for(x=0; x<s->mb_width; x++){
1549                 if(s->mb_type[i] & type){
1550                     int fcode= FFMAX(fcode_tab[mv_table[xy][0] + MAX_MV],
1551                                      fcode_tab[mv_table[xy][1] + MAX_MV]);
1552                     int j;
1553
1554                     for(j=0; j<fcode && j<8; j++){
1555                         if(s->pict_type==B_TYPE || s->current_picture.mc_mb_var[i] < s->current_picture.mb_var[i])
1556                             score[j]-= 170;
1557                     }
1558                 }
1559                 i++;
1560                 xy++;
1561             }
1562         }
1563
1564         for(i=1; i<8; i++){
1565             if(score[i] > best_score){
1566                 best_score= score[i];
1567                 best_fcode= i;
1568             }
1569 //            printf("%d %d\n", i, score[i]);
1570         }
1571
1572 //    printf("fcode: %d type: %d\n", i, s->pict_type);
1573         return best_fcode;
1574 /*        for(i=0; i<=MAX_FCODE; i++){
1575             printf("%d ", mv_num[i]);
1576         }
1577         printf("\n");*/
1578     }else{
1579         return 1;
1580     }
1581 }
1582
1583 void ff_fix_long_p_mvs(MpegEncContext * s)
1584 {
1585     const int f_code= s->f_code;
1586     int y;
1587     UINT8 * fcode_tab= s->fcode_tab;
1588 //int clip=0;
1589 //int noclip=0;
1590     /* clip / convert to intra 16x16 type MVs */
1591     for(y=0; y<s->mb_height; y++){
1592         int x;
1593         int xy= (y+1)* (s->mb_width+2)+1;
1594         int i= y*s->mb_width;
1595         for(x=0; x<s->mb_width; x++){
1596             if(s->mb_type[i]&MB_TYPE_INTER){
1597                 if(   fcode_tab[s->p_mv_table[xy][0] + MAX_MV] > f_code
1598                    || fcode_tab[s->p_mv_table[xy][0] + MAX_MV] == 0
1599                    || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] > f_code
1600                    || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] == 0 ){
1601                     s->mb_type[i] &= ~MB_TYPE_INTER;
1602                     s->mb_type[i] |= MB_TYPE_INTRA;
1603                     s->p_mv_table[xy][0] = 0;
1604                     s->p_mv_table[xy][1] = 0;
1605 //clip++;
1606                 }
1607 //else
1608 //  noclip++;
1609             }
1610             xy++;
1611             i++;
1612         }
1613     }
1614 //printf("%d no:%d %d//\n", clip, noclip, f_code);
1615     if(s->flags&CODEC_FLAG_4MV){
1616         const int wrap= 2+ s->mb_width*2;
1617
1618         /* clip / convert to intra 8x8 type MVs */
1619         for(y=0; y<s->mb_height; y++){
1620             int xy= (y*2 + 1)*wrap + 1;
1621             int i= y*s->mb_width;
1622             int x;
1623
1624             for(x=0; x<s->mb_width; x++){
1625                 if(s->mb_type[i]&MB_TYPE_INTER4V){
1626                     int block;
1627                     for(block=0; block<4; block++){
1628                         int off= (block& 1) + (block>>1)*wrap;
1629                         int mx= s->motion_val[ xy + off ][0];
1630                         int my= s->motion_val[ xy + off ][1];
1631
1632                         if(   fcode_tab[mx + MAX_MV] > f_code
1633                            || fcode_tab[mx + MAX_MV] == 0
1634                            || fcode_tab[my + MAX_MV] > f_code
1635                            || fcode_tab[my + MAX_MV] == 0 ){
1636                             s->mb_type[i] &= ~MB_TYPE_INTER4V;
1637                             s->mb_type[i] |= MB_TYPE_INTRA;
1638                         }
1639                     }
1640                 }
1641                 xy+=2;
1642                 i++;
1643             }
1644         }
1645     }
1646 }
1647
1648 void ff_fix_long_b_mvs(MpegEncContext * s, int16_t (*mv_table)[2], int f_code, int type)
1649 {
1650     int y;
1651     UINT8 * fcode_tab= s->fcode_tab;
1652
1653     // RAL: 8 in MPEG-1, 16 in MPEG-4
1654     int range = (((s->codec_id == CODEC_ID_MPEG1VIDEO) ? 8 : 16) << f_code);
1655
1656     /* clip / convert to intra 16x16 type MVs */
1657     for(y=0; y<s->mb_height; y++){
1658         int x;
1659         int xy= (y+1)* (s->mb_width+2)+1;
1660         int i= y*s->mb_width;
1661         for(x=0; x<s->mb_width; x++)
1662             {
1663             if (s->mb_type[i] & type)    // RAL: "type" test added...
1664                 {
1665                 if (fcode_tab[mv_table[xy][0] + MAX_MV] > f_code || fcode_tab[mv_table[xy][0] + MAX_MV] == 0)
1666                     {
1667                     if(mv_table[xy][0]>0)
1668                         mv_table[xy][0]=  range-1;
1669                     else
1670                         mv_table[xy][0]= -range;
1671                     }
1672                 if (fcode_tab[mv_table[xy][1] + MAX_MV] > f_code || fcode_tab[mv_table[xy][1] + MAX_MV] == 0)
1673                     {
1674                     if(mv_table[xy][1]>0)
1675                         mv_table[xy][1]=  range-1;
1676                     else
1677                         mv_table[xy][1]= -range;
1678             }
1679             }
1680             xy++;
1681             i++;
1682         }
1683     }
1684 }