falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1674 Commits
32 Branches
959MB
Tree: ef9f730675
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ef9f730675'
${ noResults }
FFmpeg/libavcodec/motion_est.c

1658 lines
55KB
Raw Blame History 

  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.         hpel_put[0][fxy](s->me.scratchpad, (ref_y ) + (fx>>1) + (fy>>1)*(stride), stride, 16);\

  185.         hpel_avg[0][bxy](s->me.scratchpad, (ref2_y) + (bx>>1) + (by>>1)*(stride), stride, 16);\

  186.     }\

  187.     d = cmp_func(s, s->me.scratchpad, src_y, stride);\

  188. }else\

  189.     d= 256*256*256*32;

  190. 

  191. 

  192. #define CMP_HPEL(d, dx, dy, x, y, size)\

  193.     CMP_DIRECT(d, dx, dy, x, y, size, cmp_sub)

  194. 

  195. #define CMP(d, x, y, size)\

  196.     CMP_DIRECT(d, 0, 0, x, y, size, cmp)

  197.     

  198. #include "motion_est_template.c"

  199. #undef RENAME

  200. #undef CMP

  201. #undef CMP_HPEL

  202. #undef CMP_QPEL

  203. #undef INIT

  204. #undef CMP_DIRECT

  205. 

  206. /* SIMPLE DIRECT QPEL */

  207. #define RENAME(a) simple_direct_qpel_ ## a

  208. 

  209. #define CMP_DIRECT(d, dx, dy, x, y, size, cmp_func)\

  210. if((x) >= xmin && 4*(x) + (dx) <= 4*xmax && (y) >= ymin && 4*(y) + (dy) <= 4*ymax){\

  211.     const int qx= 4*(x) + (dx);\

  212.     const int qy= 4*(y) + (dy);\

  213.     if(s->mv_type==MV_TYPE_8X8){\

  214.         int i;\

  215.         for(i=0; i<4; i++){\

  216.             int fx = s->me.direct_basis_mv[i][0] + qx;\

  217.             int fy = s->me.direct_basis_mv[i][1] + qy;\

  218.             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;\

  219.             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;\

  220.             int fxy= (fx&3) + 4*(fy&3);\

  221.             int bxy= (bx&3) + 4*(by&3);\

  222. \

  223.             uint8_t *dst= s->me.scratchpad + 8*(i&1) + 8*stride*(i>>1);\

  224.             qpel_put[1][fxy](dst, (ref_y ) + (fx>>2) + (fy>>2)*(stride), stride);\

  225.             qpel_avg[1][bxy](dst, (ref2_y) + (bx>>2) + (by>>2)*(stride), stride);\

  226.         }\

  227.     }else{\

  228.         int fx = s->me.direct_basis_mv[0][0] + qx;\

  229.         int fy = s->me.direct_basis_mv[0][1] + qy;\

  230.         int bx = qx ? fx - s->me.co_located_mv[0][0] : s->me.co_located_mv[0][0]*(time_pb - time_pp)/time_pp;\

  231.         int by = qy ? fy - s->me.co_located_mv[0][1] : s->me.co_located_mv[0][1]*(time_pb - time_pp)/time_pp;\

  232.         int fxy= (fx&3) + 4*(fy&3);\

  233.         int bxy= (bx&3) + 4*(by&3);\

  234. \

  235.         qpel_put[0][fxy](s->me.scratchpad, (ref_y ) + (fx>>2) + (fy>>2)*(stride), stride);\

  236.         qpel_avg[0][bxy](s->me.scratchpad, (ref2_y) + (bx>>2) + (by>>2)*(stride), stride);\

  237.     }\

  238.     d = cmp_func(s, s->me.scratchpad, src_y, stride);\

  239. }else\

  240.     d= 256*256*256*32;

  241. 

  242. 

  243. #define CMP_QPEL(d, dx, dy, x, y, size)\

  244.     CMP_DIRECT(d, dx, dy, x, y, size, cmp_sub)

  245. 

  246. #define CMP(d, x, y, size)\

  247.     CMP_DIRECT(d, 0, 0, x, y, size, cmp)

  248. 

  249. #include "motion_est_template.c"

  250. #undef RENAME

  251. #undef CMP

  252. #undef CMP_HPEL

  253. #undef CMP_QPEL

  254. #undef INIT

  255. #undef CMP__DIRECT

  256. 

  257. 

  258. static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride){

  259.     return 0;

  260. }

  261. 

  262. static void set_cmp(MpegEncContext *s, me_cmp_func *cmp, int type){

  263.     DSPContext* c= &s->dsp;

  264.     int i;

  265.     

  266.     memset(cmp, 0, sizeof(void*)*11);

  267. 

  268.     switch(type&0xFF){

  269.     case FF_CMP_SAD:

  270.         cmp[0]= c->sad[0];

  271.         cmp[1]= c->sad[1];

  272.         break;

  273.     case FF_CMP_SATD:

  274.         cmp[0]= c->hadamard8_diff[0];

  275.         cmp[1]= c->hadamard8_diff[1];

  276.         break;

  277.     case FF_CMP_SSE:

  278.         cmp[0]= c->sse[0];

  279.         cmp[1]= c->sse[1];

  280.         break;

  281.     case FF_CMP_DCT:

  282.         cmp[0]= c->dct_sad[0];

  283.         cmp[1]= c->dct_sad[1];

  284.         break;

  285.     case FF_CMP_PSNR:

  286.         cmp[0]= c->quant_psnr[0];

  287.         cmp[1]= c->quant_psnr[1];

  288.         break;

  289.     case FF_CMP_BIT:

  290.         cmp[0]= c->bit[0];

  291.         cmp[1]= c->bit[1];

  292.         break;

  293.     case FF_CMP_RD:

  294.         cmp[0]= c->rd[0];

  295.         cmp[1]= c->rd[1];

  296.         break;

  297.     case FF_CMP_ZERO:

  298.         for(i=0; i<7; i++){

  299.             cmp[i]= zero_cmp;

  300.         }

  301.         break;

  302.     default:

  303.         fprintf(stderr,"internal error in cmp function selection\n");

  304.     }

  305. }

  306. 

  307. static inline int get_penalty_factor(MpegEncContext *s, int type){

  308.     switch(type&0xFF){

  309.     default:

  310.     case FF_CMP_SAD:

  311.         return s->qscale*2;

  312.     case FF_CMP_DCT:

  313.         return s->qscale*3;

  314.     case FF_CMP_SATD:

  315.         return s->qscale*6;

  316.     case FF_CMP_SSE:

  317.         return s->qscale*s->qscale*2;

  318.     case FF_CMP_BIT:

  319.         return 1;

  320.     case FF_CMP_RD:

  321.     case FF_CMP_PSNR:

  322.         return (s->qscale*s->qscale*185 + 64)>>7;

  323.     }

  324. }

  325. 

  326. void ff_init_me(MpegEncContext *s){

  327.     set_cmp(s, s->dsp.me_pre_cmp, s->avctx->me_pre_cmp);

  328.     set_cmp(s, s->dsp.me_cmp, s->avctx->me_cmp);

  329.     set_cmp(s, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);

  330.     set_cmp(s, s->dsp.mb_cmp, s->avctx->mb_cmp);

  331. 

  332.     if(s->flags&CODEC_FLAG_QPEL){

  333.         if(s->avctx->me_sub_cmp&FF_CMP_CHROMA)

  334.             s->me.sub_motion_search= simple_chroma_qpel_motion_search;

  335.         else

  336.             s->me.sub_motion_search= simple_qpel_motion_search;

  337.     }else{

  338.         if(s->avctx->me_sub_cmp&FF_CMP_CHROMA)

  339.             s->me.sub_motion_search= simple_chroma_hpel_motion_search;

  340.         else if(   s->avctx->me_sub_cmp == FF_CMP_SAD 

  341.                 && s->avctx->    me_cmp == FF_CMP_SAD 

  342.                 && s->avctx->    mb_cmp == FF_CMP_SAD)

  343.             s->me.sub_motion_search= sad_hpel_motion_search;

  344.         else

  345.             s->me.sub_motion_search= simple_hpel_motion_search;

  346.     }

  347. 

  348.     if(s->avctx->me_cmp&FF_CMP_CHROMA){

  349.         s->me.motion_search[0]= simple_chroma_epzs_motion_search;

  350.         s->me.motion_search[1]= simple_chroma_epzs_motion_search4;

  351.     }else{

  352.         s->me.motion_search[0]= simple_epzs_motion_search;

  353.         s->me.motion_search[1]= simple_epzs_motion_search4;

  354.     }

  355.     

  356.     if(s->avctx->me_pre_cmp&FF_CMP_CHROMA){

  357.         s->me.pre_motion_search= simple_chroma_epzs_motion_search;

  358.     }else{

  359.         s->me.pre_motion_search= simple_epzs_motion_search;

  360.     }

  361.     

  362.     if(s->flags&CODEC_FLAG_QPEL){

  363.         if(s->avctx->mb_cmp&FF_CMP_CHROMA)

  364.             s->me.get_mb_score= simple_chroma_qpel_get_mb_score;

  365.         else

  366.             s->me.get_mb_score= simple_qpel_get_mb_score;

  367.     }else{

  368.         if(s->avctx->mb_cmp&FF_CMP_CHROMA)

  369.             s->me.get_mb_score= simple_chroma_hpel_get_mb_score;

  370.         else

  371.             s->me.get_mb_score= simple_hpel_get_mb_score;

  372.     }

  373. }

  374.       

  375. static int pix_dev(UINT8 * pix, int line_size, int mean)

  376. {

  377.     int s, i, j;

  378. 

  379.     s = 0;

  380.     for (i = 0; i < 16; i++) {

  381. 	for (j = 0; j < 16; j += 8) {

  382. 	    s += ABS(pix[0]-mean);

  383. 	    s += ABS(pix[1]-mean);

  384. 	    s += ABS(pix[2]-mean);

  385. 	    s += ABS(pix[3]-mean);

  386. 	    s += ABS(pix[4]-mean);

  387. 	    s += ABS(pix[5]-mean);

  388. 	    s += ABS(pix[6]-mean);

  389. 	    s += ABS(pix[7]-mean);

  390. 	    pix += 8;

  391. 	}

  392. 	pix += line_size - 16;

  393.     }

  394.     return s;

  395. }

  396. 

  397. static inline void no_motion_search(MpegEncContext * s,

  398. 				    int *mx_ptr, int *my_ptr)

  399. {

  400.     *mx_ptr = 16 * s->mb_x;

  401.     *my_ptr = 16 * s->mb_y;

  402. }

  403. 

  404. static int full_motion_search(MpegEncContext * s,

  405.                               int *mx_ptr, int *my_ptr, int range,

  406.                               int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)

  407. {

  408.     int x1, y1, x2, y2, xx, yy, x, y;

  409.     int mx, my, dmin, d;

  410.     UINT8 *pix;

  411. 

  412.     xx = 16 * s->mb_x;

  413.     yy = 16 * s->mb_y;

  414.     x1 = xx - range + 1;	/* we loose one pixel to avoid boundary pb with half pixel pred */

  415.     if (x1 < xmin)

  416. 	x1 = xmin;

  417.     x2 = xx + range - 1;

  418.     if (x2 > xmax)

  419. 	x2 = xmax;

  420.     y1 = yy - range + 1;

  421.     if (y1 < ymin)

  422. 	y1 = ymin;

  423.     y2 = yy + range - 1;

  424.     if (y2 > ymax)

  425. 	y2 = ymax;

  426.     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;

  427.     dmin = 0x7fffffff;

  428.     mx = 0;

  429.     my = 0;

  430.     for (y = y1; y <= y2; y++) {

  431. 	for (x = x1; x <= x2; x++) {

  432. 	    d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x,

  433. 			     s->linesize);

  434. 	    if (d < dmin ||

  435. 		(d == dmin &&

  436. 		 (abs(x - xx) + abs(y - yy)) <

  437. 		 (abs(mx - xx) + abs(my - yy)))) {

  438. 		dmin = d;

  439. 		mx = x;

  440. 		my = y;

  441. 	    }

  442. 	}

  443.     }

  444. 

  445.     *mx_ptr = mx;

  446.     *my_ptr = my;

  447. 

  448. #if 0

  449.     if (*mx_ptr < -(2 * range) || *mx_ptr >= (2 * range) ||

  450. 	*my_ptr < -(2 * range) || *my_ptr >= (2 * range)) {

  451. 	fprintf(stderr, "error %d %d\n", *mx_ptr, *my_ptr);

  452.     }

  453. #endif

  454.     return dmin;

  455. }

  456. 

  457. 

  458. static int log_motion_search(MpegEncContext * s,

  459.                              int *mx_ptr, int *my_ptr, int range,

  460.                              int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)

  461. {

  462.     int x1, y1, x2, y2, xx, yy, x, y;

  463.     int mx, my, dmin, d;

  464.     UINT8 *pix;

  465. 

  466.     xx = s->mb_x << 4;

  467.     yy = s->mb_y << 4;

  468. 

  469.     /* Left limit */

  470.     x1 = xx - range;

  471.     if (x1 < xmin)

  472. 	x1 = xmin;

  473. 

  474.     /* Right limit */

  475.     x2 = xx + range;

  476.     if (x2 > xmax)

  477. 	x2 = xmax;

  478. 

  479.     /* Upper limit */

  480.     y1 = yy - range;

  481.     if (y1 < ymin)

  482. 	y1 = ymin;

  483. 

  484.     /* Lower limit */

  485.     y2 = yy + range;

  486.     if (y2 > ymax)

  487. 	y2 = ymax;

  488. 

  489.     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;

  490.     dmin = 0x7fffffff;

  491.     mx = 0;

  492.     my = 0;

  493. 

  494.     do {

  495. 	for (y = y1; y <= y2; y += range) {

  496. 	    for (x = x1; x <= x2; x += range) {

  497. 		d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);

  498. 		if (d < dmin || (d == dmin && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {

  499. 		    dmin = d;

  500. 		    mx = x;

  501. 		    my = y;

  502. 		}

  503. 	    }

  504. 	}

  505. 

  506. 	range = range >> 1;

  507. 

  508. 	x1 = mx - range;

  509. 	if (x1 < xmin)

  510. 	    x1 = xmin;

  511. 

  512. 	x2 = mx + range;

  513. 	if (x2 > xmax)

  514. 	    x2 = xmax;

  515. 

  516. 	y1 = my - range;

  517. 	if (y1 < ymin)

  518. 	    y1 = ymin;

  519. 

  520. 	y2 = my + range;

  521. 	if (y2 > ymax)

  522. 	    y2 = ymax;

  523. 

  524.     } while (range >= 1);

  525. 

  526. #ifdef DEBUG

  527.     fprintf(stderr, "log       - MX: %d\tMY: %d\n", mx, my);

  528. #endif

  529.     *mx_ptr = mx;

  530.     *my_ptr = my;

  531.     return dmin;

  532. }

  533. 

  534. static int phods_motion_search(MpegEncContext * s,

  535.                                int *mx_ptr, int *my_ptr, int range,

  536.                                int xmin, int ymin, int xmax, int ymax, uint8_t *ref_picture)

  537. {

  538.     int x1, y1, x2, y2, xx, yy, x, y, lastx, d;

  539.     int mx, my, dminx, dminy;

  540.     UINT8 *pix;

  541. 

  542.     xx = s->mb_x << 4;

  543.     yy = s->mb_y << 4;

  544. 

  545.     /* Left limit */

  546.     x1 = xx - range;

  547.     if (x1 < xmin)

  548. 	x1 = xmin;

  549. 

  550.     /* Right limit */

  551.     x2 = xx + range;

  552.     if (x2 > xmax)

  553. 	x2 = xmax;

  554. 

  555.     /* Upper limit */

  556.     y1 = yy - range;

  557.     if (y1 < ymin)

  558. 	y1 = ymin;

  559. 

  560.     /* Lower limit */

  561.     y2 = yy + range;

  562.     if (y2 > ymax)

  563. 	y2 = ymax;

  564. 

  565.     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;

  566.     mx = 0;

  567.     my = 0;

  568. 

  569.     x = xx;

  570.     y = yy;

  571.     do {

  572.         dminx = 0x7fffffff;

  573.         dminy = 0x7fffffff;

  574. 

  575. 	lastx = x;

  576. 	for (x = x1; x <= x2; x += range) {

  577. 	    d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);

  578. 	    if (d < dminx || (d == dminx && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {

  579. 		dminx = d;

  580. 		mx = x;

  581. 	    }

  582. 	}

  583. 

  584. 	x = lastx;

  585. 	for (y = y1; y <= y2; y += range) {

  586. 	    d = s->dsp.pix_abs16x16(pix, ref_picture + (y * s->linesize) + x, s->linesize);

  587. 	    if (d < dminy || (d == dminy && (abs(x - xx) + abs(y - yy)) < (abs(mx - xx) + abs(my - yy)))) {

  588. 		dminy = d;

  589. 		my = y;

  590. 	    }

  591. 	}

  592. 

  593. 	range = range >> 1;

  594. 

  595. 	x = mx;

  596. 	y = my;

  597. 	x1 = mx - range;

  598. 	if (x1 < xmin)

  599. 	    x1 = xmin;

  600. 

  601. 	x2 = mx + range;

  602. 	if (x2 > xmax)

  603. 	    x2 = xmax;

  604. 

  605. 	y1 = my - range;

  606. 	if (y1 < ymin)

  607. 	    y1 = ymin;

  608. 

  609. 	y2 = my + range;

  610. 	if (y2 > ymax)

  611. 	    y2 = ymax;

  612. 

  613.     } while (range >= 1);

  614. 

  615. #ifdef DEBUG

  616.     fprintf(stderr, "phods     - MX: %d\tMY: %d\n", mx, my);

  617. #endif

  618. 

  619.     /* half pixel search */

  620.     *mx_ptr = mx;

  621.     *my_ptr = my;

  622.     return dminy;

  623. }

  624. 

  625. 

  626. #define Z_THRESHOLD 256

  627. 

  628. #define CHECK_SAD_HALF_MV(suffix, x, y) \

  629. {\

  630.     d= pix_abs_ ## suffix(pix, ptr+((x)>>1), s->linesize);\

  631.     d += (mv_penalty[pen_x + x] + mv_penalty[pen_y + y])*penalty_factor;\

  632.     COPY3_IF_LT(dminh, d, dx, x, dy, y)\

  633. }

  634. 

  635. static inline int sad_hpel_motion_search(MpegEncContext * s,

  636. 				  int *mx_ptr, int *my_ptr, int dmin,

  637. 				  int xmin, int ymin, int xmax, int ymax,

  638.                                   int pred_x, int pred_y, Picture *picture,

  639.                                   int n, int size, uint16_t * const mv_penalty)

  640. {

  641.     uint8_t *ref_picture= picture->data[0];

  642.     uint32_t *score_map= s->me.score_map;

  643.     const int penalty_factor= s->me.sub_penalty_factor;

  644.     int mx, my, xx, yy, dminh;

  645.     UINT8 *pix, *ptr;

  646.     op_pixels_abs_func pix_abs_x2;

  647.     op_pixels_abs_func pix_abs_y2;

  648.     op_pixels_abs_func pix_abs_xy2;

  649.     

  650.     if(size==0){

  651.         pix_abs_x2 = s->dsp.pix_abs16x16_x2;

  652.         pix_abs_y2 = s->dsp.pix_abs16x16_y2;

  653.         pix_abs_xy2= s->dsp.pix_abs16x16_xy2;

  654.     }else{

  655.         pix_abs_x2 = s->dsp.pix_abs8x8_x2;

  656.         pix_abs_y2 = s->dsp.pix_abs8x8_y2;

  657.         pix_abs_xy2= s->dsp.pix_abs8x8_xy2;

  658.     }

  659. 

  660.     if(s->me.skip){

  661. //    printf("S");

  662.         *mx_ptr = 0;

  663.         *my_ptr = 0;

  664.         return dmin;

  665.     }

  666. //    printf("N");

  667.         

  668.     xx = 16 * s->mb_x + 8*(n&1);

  669.     yy = 16 * s->mb_y + 8*(n>>1);

  670.     pix =  s->new_picture.data[0] + (yy * s->linesize) + xx;

  671. 

  672.     mx = *mx_ptr;

  673.     my = *my_ptr;

  674.     ptr = ref_picture + ((yy + my) * s->linesize) + (xx + mx);

  675.     

  676.     dminh = dmin;

  677. 

  678.     if (mx > xmin && mx < xmax && 

  679.         my > ymin && my < ymax) {

  680.         int dx=0, dy=0;

  681.         int d, pen_x, pen_y; 

  682.         const int index= (my<<ME_MAP_SHIFT) + mx;

  683.         const int t= score_map[(index-(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];

  684.         const int l= score_map[(index- 1               )&(ME_MAP_SIZE-1)];

  685.         const int r= score_map[(index+ 1               )&(ME_MAP_SIZE-1)];

  686.         const int b= score_map[(index+(1<<ME_MAP_SHIFT))&(ME_MAP_SIZE-1)];

  687.         mx<<=1;

  688.         my<<=1;

  689. 

  690.         

  691.         pen_x= pred_x + mx;

  692.         pen_y= pred_y + my;

  693. 

  694.         ptr-= s->linesize;

  695.         if(t<=b){

  696.             CHECK_SAD_HALF_MV(y2 , 0, -1)

  697.             if(l<=r){

  698.                 CHECK_SAD_HALF_MV(xy2, -1, -1)

  699.                 if(t+r<=b+l){

  700.                     CHECK_SAD_HALF_MV(xy2, +1, -1)

  701.                     ptr+= s->linesize;

  702.                 }else{

  703.                     ptr+= s->linesize;

  704.                     CHECK_SAD_HALF_MV(xy2, -1, +1)

  705.                 }

  706.                 CHECK_SAD_HALF_MV(x2 , -1,  0)

  707.             }else{

  708.                 CHECK_SAD_HALF_MV(xy2, +1, -1)

  709.                 if(t+l<=b+r){

  710.                     CHECK_SAD_HALF_MV(xy2, -1, -1)

  711.                     ptr+= s->linesize;

  712.                 }else{

  713.                     ptr+= s->linesize;

  714.                     CHECK_SAD_HALF_MV(xy2, +1, +1)

  715.                 }

  716.                 CHECK_SAD_HALF_MV(x2 , +1,  0)

  717.             }

  718.         }else{

  719.             if(l<=r){

  720.                 if(t+l<=b+r){

  721.                     CHECK_SAD_HALF_MV(xy2, -1, -1)

  722.                     ptr+= s->linesize;

  723.                 }else{

  724.                     ptr+= s->linesize;

  725.                     CHECK_SAD_HALF_MV(xy2, +1, +1)

  726.                 }

  727.                 CHECK_SAD_HALF_MV(x2 , -1,  0)

  728.                 CHECK_SAD_HALF_MV(xy2, -1, +1)

  729.             }else{

  730.                 if(t+r<=b+l){

  731.                     CHECK_SAD_HALF_MV(xy2, +1, -1)

  732.                     ptr+= s->linesize;

  733.                 }else{

  734.                     ptr+= s->linesize;

  735.                     CHECK_SAD_HALF_MV(xy2, -1, +1)

  736.                 }

  737.                 CHECK_SAD_HALF_MV(x2 , +1,  0)

  738.                 CHECK_SAD_HALF_MV(xy2, +1, +1)

  739.             }

  740.             CHECK_SAD_HALF_MV(y2 ,  0, +1)

  741.         }

  742.         mx+=dx;

  743.         my+=dy;

  744. 

  745.     }else{

  746.         mx<<=1;

  747.         my<<=1;

  748.     }

  749. 

  750.     *mx_ptr = mx;

  751.     *my_ptr = my;

  752.     return dminh;

  753. }

  754. 

  755. static inline void set_p_mv_tables(MpegEncContext * s, int mx, int my, int mv4)

  756. {

  757.     const int xy= s->mb_x + 1 + (s->mb_y + 1)*(s->mb_width + 2);

  758.     

  759.     s->p_mv_table[xy][0] = mx;

  760.     s->p_mv_table[xy][1] = my;

  761. 

  762.     /* has allready been set to the 4 MV if 4MV is done */

  763.     if(mv4){

  764.         int mot_xy= s->block_index[0];

  765. 

  766.         s->motion_val[mot_xy  ][0]= mx;

  767.         s->motion_val[mot_xy  ][1]= my;

  768.         s->motion_val[mot_xy+1][0]= mx;

  769.         s->motion_val[mot_xy+1][1]= my;

  770. 

  771.         mot_xy += s->block_wrap[0];

  772.         s->motion_val[mot_xy  ][0]= mx;

  773.         s->motion_val[mot_xy  ][1]= my;

  774.         s->motion_val[mot_xy+1][0]= mx;

  775.         s->motion_val[mot_xy+1][1]= my;

  776.     }

  777. }

  778. 

  779. static inline void get_limits(MpegEncContext *s, int *range, int *xmin, int *ymin, int *xmax, int *ymax, int f_code)

  780. {

  781.     *range = 8 * (1 << (f_code - 1));

  782.     /* XXX: temporary kludge to avoid overflow for msmpeg4 */

  783.     if (s->out_format == FMT_H263 && !s->h263_msmpeg4)

  784. 	*range *= 2;

  785. 

  786.     if (s->unrestricted_mv) {

  787.         *xmin = -16;

  788.         *ymin = -16;

  789.         if (s->h263_plus)

  790.             *range *= 2;

  791.         if(s->avctx->codec->id!=CODEC_ID_MPEG4){

  792.             *xmax = s->mb_width*16;

  793.             *ymax = s->mb_height*16;

  794.         }else {

  795.             *xmax = s->width;

  796.             *ymax = s->height;

  797.         }

  798.     } else {

  799.         *xmin = 0;

  800.         *ymin = 0;

  801.         *xmax = s->mb_width*16 - 16;

  802.         *ymax = s->mb_height*16 - 16;

  803.     }

  804. }

  805. 

  806. static inline int h263_mv4_search(MpegEncContext *s, int xmin, int ymin, int xmax, int ymax, int mx, int my, int shift)

  807. {

  808.     int block;

  809.     int P[10][2];

  810.     int dmin_sum=0, mx4_sum=0, my4_sum=0;

  811.     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;

  812. 

  813.     for(block=0; block<4; block++){

  814.         int mx4, my4;

  815.         int pred_x4, pred_y4;

  816.         int dmin4;

  817.         static const int off[4]= {2, 1, 1, -1};

  818.         const int mot_stride = s->block_wrap[0];

  819.         const int mot_xy = s->block_index[block];

  820. //        const int block_x= (block&1);

  821. //        const int block_y= (block>>1);

  822. #if 1 // this saves us a bit of cliping work and shouldnt affect compression in a negative way

  823.         const int rel_xmin4= xmin;

  824.         const int rel_xmax4= xmax;

  825.         const int rel_ymin4= ymin;

  826.         const int rel_ymax4= ymax;

  827. #else

  828.         const int rel_xmin4= xmin - block_x*8;

  829.         const int rel_xmax4= xmax - block_x*8 + 8;

  830.         const int rel_ymin4= ymin - block_y*8;

  831.         const int rel_ymax4= ymax - block_y*8 + 8;

  832. #endif

  833.         P_LEFT[0] = s->motion_val[mot_xy - 1][0];

  834.         P_LEFT[1] = s->motion_val[mot_xy - 1][1];

  835. 

  836.         if(P_LEFT[0]       > (rel_xmax4<<shift)) P_LEFT[0]       = (rel_xmax4<<shift);

  837. 

  838.         /* special case for first line */

  839.         if (s->mb_y == 0 && block<2) {

  840.             pred_x4= P_LEFT[0];

  841.             pred_y4= P_LEFT[1];

  842.         } else {

  843.             P_TOP[0]      = s->motion_val[mot_xy - mot_stride             ][0];

  844.             P_TOP[1]      = s->motion_val[mot_xy - mot_stride             ][1];

  845.             P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + off[block]][0];

  846.             P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + off[block]][1];

  847.             if(P_TOP[1]      > (rel_ymax4<<shift)) P_TOP[1]     = (rel_ymax4<<shift);

  848.             if(P_TOPRIGHT[0] < (rel_xmin4<<shift)) P_TOPRIGHT[0]= (rel_xmin4<<shift);

  849.             if(P_TOPRIGHT[0] > (rel_xmax4<<shift)) P_TOPRIGHT[0]= (rel_xmax4<<shift);

  850.             if(P_TOPRIGHT[1] > (rel_ymax4<<shift)) P_TOPRIGHT[1]= (rel_ymax4<<shift);

  851.     

  852.             P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);

  853.             P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);

  854. 

  855. //            if(s->out_format == FMT_H263){

  856.                 pred_x4 = P_MEDIAN[0];

  857.                 pred_y4 = P_MEDIAN[1];

  858. #if 0

  859.             }else { /* mpeg1 at least */

  860.                 pred_x4= P_LEFT[0];

  861.                 pred_y4= P_LEFT[1];

  862.             }

  863. #endif

  864.         }

  865.         P_MV1[0]= mx;

  866.         P_MV1[1]= my;

  867. 

  868.         dmin4 = s->me.motion_search[1](s, block, &mx4, &my4, P, pred_x4, pred_y4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, 

  869.                                        &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);

  870. 

  871.         dmin4= s->me.sub_motion_search(s, &mx4, &my4, dmin4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, 

  872. 					  pred_x4, pred_y4, &s->last_picture, block, 1, mv_penalty);

  873.  

  874.         if(s->dsp.me_sub_cmp != s->dsp.mb_cmp){

  875.             int dxy;

  876.             const int offset= ((block&1) + (block>>1)*s->linesize)*8;

  877.             uint8_t *dest_y = s->me.scratchpad + offset;

  878. 

  879.             if(s->quarter_sample){

  880.                 uint8_t *ref= s->last_picture.data[0] + (s->mb_x*16 + (mx4>>2)) + (s->mb_y*16 + (my4>>2))*s->linesize + offset;

  881.                 dxy = ((my4 & 3) << 2) | (mx4 & 3);

  882. 

  883.                 if(s->no_rounding)

  884.                     s->dsp.put_no_rnd_qpel_pixels_tab[0][dxy](dest_y   , ref    , s->linesize);

  885.                 else

  886.                     s->dsp.put_qpel_pixels_tab       [0][dxy](dest_y   , ref    , s->linesize);

  887.             }else{

  888.                 uint8_t *ref= s->last_picture.data[0] + (s->mb_x*16 + (mx4>>1)) + (s->mb_y*16 + (my4>>1))*s->linesize + offset;

  889.                 dxy = ((my4 & 1) << 1) | (mx4 & 1);

  890. 

  891.                 if(s->no_rounding)

  892.                     s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y    , ref    , s->linesize, 16);

  893.                 else

  894.                     s->dsp.put_pixels_tab       [0][dxy](dest_y    , ref    , s->linesize, 16);

  895.             }

  896.             dmin_sum+= (mv_penalty[mx4-pred_x4] + mv_penalty[my4-pred_y4])*s->me.mb_penalty_factor;

  897.         }else

  898.             dmin_sum+= dmin4;

  899. 

  900.         if(s->quarter_sample){

  901.             mx4_sum+= mx4/2;

  902.             my4_sum+= my4/2;

  903.         }else{

  904.             mx4_sum+= mx4;

  905.             my4_sum+= my4;

  906.         }

  907.             

  908.         s->motion_val[ s->block_index[block] ][0]= mx4;

  909.         s->motion_val[ s->block_index[block] ][1]= my4;

  910.     }

  911.     

  912.     if(s->dsp.me_sub_cmp != s->dsp.mb_cmp){

  913.         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);

  914.     }

  915.     

  916.     if(s->avctx->mb_cmp&FF_CMP_CHROMA){

  917.         int dxy;

  918.         int mx, my;

  919.         int offset;

  920. 

  921.         mx= ff_h263_round_chroma(mx4_sum);

  922.         my= ff_h263_round_chroma(my4_sum);

  923.         dxy = ((my & 1) << 1) | (mx & 1);

  924.         

  925.         offset= (s->mb_x*8 + (mx>>1)) + (s->mb_y*8 + (my>>1))*s->uvlinesize;

  926.        

  927.         if(s->no_rounding){

  928.             s->dsp.put_no_rnd_pixels_tab[1][dxy](s->me.scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);

  929.             s->dsp.put_no_rnd_pixels_tab[1][dxy](s->me.scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);

  930.         }else{

  931.             s->dsp.put_pixels_tab       [1][dxy](s->me.scratchpad    , s->last_picture.data[1] + offset, s->uvlinesize, 8);

  932.             s->dsp.put_pixels_tab       [1][dxy](s->me.scratchpad+8  , s->last_picture.data[2] + offset, s->uvlinesize, 8);

  933.         }

  934. 

  935.         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);

  936.         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);

  937.     }

  938. 

  939.     switch(s->avctx->mb_cmp&0xFF){

  940.     /*case FF_CMP_SSE:

  941.         return dmin_sum+ 32*s->qscale*s->qscale;*/

  942.     case FF_CMP_RD:

  943.         return dmin_sum;

  944.     default:

  945.         return dmin_sum+ 11*s->me.mb_penalty_factor;

  946.     }

  947. }

  948. 

  949. void ff_estimate_p_frame_motion(MpegEncContext * s,

  950.                                 int mb_x, int mb_y)

  951. {

  952.     UINT8 *pix, *ppix;

  953.     int sum, varc, vard, mx, my, range, dmin, xx, yy;

  954.     int xmin, ymin, xmax, ymax;

  955.     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;

  956.     int pred_x=0, pred_y=0;

  957.     int P[10][2];

  958.     const int shift= 1+s->quarter_sample;

  959.     int mb_type=0;

  960.     uint8_t *ref_picture= s->last_picture.data[0];

  961.     Picture * const pic= &s->current_picture;

  962.     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;

  963.     

  964.     assert(s->quarter_sample==0 || s->quarter_sample==1);

  965. 

  966.     s->me.penalty_factor    = get_penalty_factor(s, s->avctx->me_cmp);

  967.     s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);

  968.     s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);

  969. 

  970.     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, s->f_code);

  971.     rel_xmin= xmin - mb_x*16;

  972.     rel_xmax= xmax - mb_x*16;

  973.     rel_ymin= ymin - mb_y*16;

  974.     rel_ymax= ymax - mb_y*16;

  975.     s->me.skip=0;

  976. 

  977.     switch(s->me_method) {

  978.     case ME_ZERO:

  979.     default:

  980. 	no_motion_search(s, &mx, &my);

  981.         mx-= mb_x*16;

  982.         my-= mb_y*16;

  983.         dmin = 0;

  984.         break;

  985.     case ME_FULL:

  986. 	dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);

  987.         mx-= mb_x*16;

  988.         my-= mb_y*16;

  989.         break;

  990.     case ME_LOG:

  991. 	dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);

  992.         mx-= mb_x*16;

  993.         my-= mb_y*16;

  994.         break;

  995.     case ME_PHODS:

  996. 	dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);

  997.         mx-= mb_x*16;

  998.         my-= mb_y*16;

  999.         break;

  1000.     case ME_X1:

  1001.     case ME_EPZS:

  1002.        {

  1003.             const int mot_stride = s->block_wrap[0];

  1004.             const int mot_xy = s->block_index[0];

  1005. 

  1006.             P_LEFT[0]       = s->motion_val[mot_xy - 1][0];

  1007.             P_LEFT[1]       = s->motion_val[mot_xy - 1][1];

  1008. 

  1009.             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);

  1010. 

  1011.             if(mb_y) {

  1012.                 P_TOP[0]      = s->motion_val[mot_xy - mot_stride    ][0];

  1013.                 P_TOP[1]      = s->motion_val[mot_xy - mot_stride    ][1];

  1014.                 P_TOPRIGHT[0] = s->motion_val[mot_xy - mot_stride + 2][0];

  1015.                 P_TOPRIGHT[1] = s->motion_val[mot_xy - mot_stride + 2][1];

  1016.                 if(P_TOP[1]      > (rel_ymax<<shift)) P_TOP[1]     = (rel_ymax<<shift);

  1017.                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);

  1018.                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);

  1019.         

  1020.                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);

  1021.                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);

  1022. 

  1023.                 if(s->out_format == FMT_H263){

  1024.                     pred_x = P_MEDIAN[0];

  1025.                     pred_y = P_MEDIAN[1];

  1026.                 }else { /* mpeg1 at least */

  1027.                     pred_x= P_LEFT[0];

  1028.                     pred_y= P_LEFT[1];

  1029.                 }

  1030.             }else{

  1031.                 pred_x= P_LEFT[0];

  1032.                 pred_y= P_LEFT[1];

  1033.             }

  1034. 

  1035.         }

  1036.         dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1037.                                       &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);

  1038.  

  1039.         break;

  1040.     }

  1041. 

  1042.     /* intra / predictive decision */

  1043.     xx = mb_x * 16;

  1044.     yy = mb_y * 16;

  1045. 

  1046.     pix = s->new_picture.data[0] + (yy * s->linesize) + xx;

  1047.     /* At this point (mx,my) are full-pell and the relative displacement */

  1048.     ppix = ref_picture + ((yy+my) * s->linesize) + (xx+mx);

  1049.     

  1050.     sum = s->dsp.pix_sum(pix, s->linesize);

  1051.     

  1052.     varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;

  1053.     vard = (s->dsp.sse[0](NULL, pix, ppix, s->linesize)+128)>>8;

  1054. 

  1055. //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);

  1056.     pic->mb_var   [s->mb_width * mb_y + mb_x] = varc;

  1057.     pic->mc_mb_var[s->mb_width * mb_y + mb_x] = vard;

  1058.     pic->mb_mean  [s->mb_width * mb_y + mb_x] = (sum+128)>>8;

  1059. //    pic->mb_cmp_score[s->mb_width * mb_y + mb_x] = dmin; 

  1060.     pic->mb_var_sum    += varc;

  1061.     pic->mc_mb_var_sum += vard;

  1062. //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);

  1063.     

  1064. #if 0

  1065.     printf("varc=%4d avg_var=%4d (sum=%4d) vard=%4d mx=%2d my=%2d\n",

  1066. 	   varc, s->avg_mb_var, sum, vard, mx - xx, my - yy);

  1067. #endif

  1068.     if(s->flags&CODEC_FLAG_HQ){

  1069.         if (vard <= 64 || vard < varc)

  1070.             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);

  1071.         else

  1072.             s->scene_change_score+= s->qscale;

  1073. 

  1074.         if (vard*2 + 200 > varc)

  1075.             mb_type|= MB_TYPE_INTRA;

  1076.         if (varc*2 + 200 > vard){

  1077.             mb_type|= MB_TYPE_INTER;

  1078.             s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,

  1079. 				   pred_x, pred_y, &s->last_picture, 0, 0, mv_penalty);

  1080.         }else{

  1081.             mx <<=shift;

  1082.             my <<=shift;

  1083.         }

  1084.         if((s->flags&CODEC_FLAG_4MV)

  1085.            && !s->me.skip && varc>50 && vard>10){

  1086.             h263_mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);

  1087.             mb_type|=MB_TYPE_INTER4V;

  1088. 

  1089.             set_p_mv_tables(s, mx, my, 0);

  1090.         }else

  1091.             set_p_mv_tables(s, mx, my, 1);

  1092.     }else{

  1093.         mb_type= MB_TYPE_INTER;

  1094. 

  1095.         dmin= 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.         

  1098.         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)

  1099.             dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, &s->last_picture, mv_penalty);

  1100. 

  1101.         if((s->flags&CODEC_FLAG_4MV)

  1102.            && !s->me.skip && varc>50 && vard>10){

  1103.             int dmin4= h263_mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);

  1104.             if(dmin4 < dmin){

  1105.                 mb_type= MB_TYPE_INTER4V;

  1106.                 dmin=dmin4;

  1107.             }

  1108.         }

  1109.         pic->mb_cmp_score[s->mb_width * mb_y + mb_x] = dmin; 

  1110.         set_p_mv_tables(s, mx, my, mb_type!=MB_TYPE_INTER4V);

  1111.         

  1112.         if (vard <= 64 || vard < varc) {

  1113.             s->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);

  1114.         }else{

  1115.             s->scene_change_score+= s->qscale;

  1116.         }

  1117.     }

  1118. 

  1119.     s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;

  1120. }

  1121. 

  1122. int ff_pre_estimate_p_frame_motion(MpegEncContext * s,

  1123.                                     int mb_x, int mb_y)

  1124. {

  1125.     int mx, my, range, dmin;

  1126.     int xmin, ymin, xmax, ymax;

  1127.     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;

  1128.     int pred_x=0, pred_y=0;

  1129.     int P[10][2];

  1130.     const int shift= 1+s->quarter_sample;

  1131.     uint16_t * const mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV;

  1132.     const int mv_stride= s->mb_width + 2;

  1133.     const int xy= mb_x + 1 + (mb_y + 1)*mv_stride;

  1134.     

  1135.     assert(s->quarter_sample==0 || s->quarter_sample==1);

  1136. 

  1137.     s->me.pre_penalty_factor    = get_penalty_factor(s, s->avctx->me_pre_cmp);

  1138. 

  1139.     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, s->f_code);

  1140.     rel_xmin= xmin - mb_x*16;

  1141.     rel_xmax= xmax - mb_x*16;

  1142.     rel_ymin= ymin - mb_y*16;

  1143.     rel_ymax= ymax - mb_y*16;

  1144.     s->me.skip=0;

  1145. 

  1146.     P_LEFT[0]       = s->p_mv_table[xy + 1][0];

  1147.     P_LEFT[1]       = s->p_mv_table[xy + 1][1];

  1148. 

  1149.     if(P_LEFT[0]       < (rel_xmin<<shift)) P_LEFT[0]       = (rel_xmin<<shift);

  1150. 

  1151.     /* special case for first line */

  1152.     if (mb_y == s->mb_height-1) {

  1153.         pred_x= P_LEFT[0];

  1154.         pred_y= P_LEFT[1];

  1155.         P_TOP[0]= P_TOPRIGHT[0]= P_MEDIAN[0]=

  1156.         P_TOP[1]= P_TOPRIGHT[1]= P_MEDIAN[1]= 0; //FIXME 

  1157.     } else {

  1158.         P_TOP[0]      = s->p_mv_table[xy + mv_stride    ][0];

  1159.         P_TOP[1]      = s->p_mv_table[xy + mv_stride    ][1];

  1160.         P_TOPRIGHT[0] = s->p_mv_table[xy + mv_stride - 1][0];

  1161.         P_TOPRIGHT[1] = s->p_mv_table[xy + mv_stride - 1][1];

  1162.         if(P_TOP[1]      < (rel_ymin<<shift)) P_TOP[1]     = (rel_ymin<<shift);

  1163.         if(P_TOPRIGHT[0] > (rel_xmax<<shift)) P_TOPRIGHT[0]= (rel_xmax<<shift);

  1164.         if(P_TOPRIGHT[1] < (rel_ymin<<shift)) P_TOPRIGHT[1]= (rel_ymin<<shift);

  1165.     

  1166.         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);

  1167.         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);

  1168. 

  1169.         pred_x = P_MEDIAN[0];

  1170.         pred_y = P_MEDIAN[1];

  1171.     }

  1172.     dmin = s->me.pre_motion_search(s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1173.                                    &s->last_picture, s->p_mv_table, (1<<16)>>shift, mv_penalty);

  1174. 

  1175.     s->p_mv_table[xy][0] = mx<<shift;

  1176.     s->p_mv_table[xy][1] = my<<shift;

  1177.     

  1178.     return dmin;

  1179. }

  1180. 

  1181. int ff_estimate_motion_b(MpegEncContext * s,

  1182.                        int mb_x, int mb_y, int16_t (*mv_table)[2], Picture *picture, int f_code)

  1183. {

  1184.     int mx, my, range, dmin;

  1185.     int xmin, ymin, xmax, ymax;

  1186.     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;

  1187.     int pred_x=0, pred_y=0;

  1188.     int P[10][2];

  1189.     const int shift= 1+s->quarter_sample;

  1190.     const int mot_stride = s->mb_width + 2;

  1191.     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;

  1192.     uint8_t * const ref_picture= picture->data[0];

  1193.     uint16_t * const mv_penalty= s->me.mv_penalty[f_code] + MAX_MV;

  1194.     int mv_scale;

  1195.         

  1196.     s->me.penalty_factor    = get_penalty_factor(s, s->avctx->me_cmp);

  1197.     s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);

  1198.     s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);

  1199. 

  1200.     get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, f_code);

  1201.     rel_xmin= xmin - mb_x*16;

  1202.     rel_xmax= xmax - mb_x*16;

  1203.     rel_ymin= ymin - mb_y*16;

  1204.     rel_ymax= ymax - mb_y*16;

  1205. 

  1206.     switch(s->me_method) {

  1207.     case ME_ZERO:

  1208.     default:

  1209. 	no_motion_search(s, &mx, &my);

  1210.         dmin = 0;

  1211.         mx-= mb_x*16;

  1212.         my-= mb_y*16;

  1213.         break;

  1214.     case ME_FULL:

  1215. 	dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);

  1216.         mx-= mb_x*16;

  1217.         my-= mb_y*16;

  1218.         break;

  1219.     case ME_LOG:

  1220. 	dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);

  1221.         mx-= mb_x*16;

  1222.         my-= mb_y*16;

  1223.         break;

  1224.     case ME_PHODS:

  1225. 	dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);

  1226.         mx-= mb_x*16;

  1227.         my-= mb_y*16;

  1228.         break;

  1229.     case ME_X1:

  1230.     case ME_EPZS:

  1231.        {

  1232.             P_LEFT[0]        = mv_table[mot_xy - 1][0];

  1233.             P_LEFT[1]        = mv_table[mot_xy - 1][1];

  1234. 

  1235.             if(P_LEFT[0]       > (rel_xmax<<shift)) P_LEFT[0]       = (rel_xmax<<shift);

  1236. 

  1237.             /* special case for first line */

  1238.             if (mb_y) {

  1239.                 P_TOP[0] = mv_table[mot_xy - mot_stride             ][0];

  1240.                 P_TOP[1] = mv_table[mot_xy - mot_stride             ][1];

  1241.                 P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1         ][0];

  1242.                 P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1         ][1];

  1243.                 if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1]= (rel_ymax<<shift);

  1244.                 if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);

  1245.                 if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);

  1246.         

  1247.                 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);

  1248.                 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);

  1249.             }

  1250.             pred_x= P_LEFT[0];

  1251.             pred_y= P_LEFT[1];

  1252.         }

  1253.         

  1254.         if(mv_table == s->b_forw_mv_table){

  1255.             mv_scale= (s->pb_time<<16) / (s->pp_time<<shift);

  1256.         }else{

  1257.             mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift);

  1258.         }

  1259.         

  1260.         dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1261.                                       picture, s->p_mv_table, mv_scale, mv_penalty);

  1262.  

  1263.         break;

  1264.     }

  1265.     

  1266.     dmin= s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,

  1267. 				   pred_x, pred_y, picture, 0, 0, mv_penalty);

  1268.                                    

  1269.     if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)

  1270.         dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, picture, mv_penalty);

  1271. 

  1272. //printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);

  1273. //    s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;

  1274.     mv_table[mot_xy][0]= mx;

  1275.     mv_table[mot_xy][1]= my;

  1276. 

  1277.     return dmin;

  1278. }

  1279. 

  1280. static inline int check_bidir_mv(MpegEncContext * s,

  1281.                    int mb_x, int mb_y,

  1282.                    int motion_fx, int motion_fy,

  1283.                    int motion_bx, int motion_by,

  1284.                    int pred_fx, int pred_fy,

  1285.                    int pred_bx, int pred_by)

  1286. {

  1287.     //FIXME optimize?

  1288.     //FIXME move into template?

  1289.     //FIXME better f_code prediction (max mv & distance)

  1290.     UINT16 *mv_penalty= s->me.mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame

  1291.     uint8_t *dest_y = s->me.scratchpad;

  1292.     uint8_t *ptr;

  1293.     int dxy;

  1294.     int src_x, src_y;

  1295.     int fbmin;

  1296. 

  1297.     if(s->quarter_sample){

  1298.         dxy = ((motion_fy & 3) << 2) | (motion_fx & 3);

  1299.         src_x = mb_x * 16 + (motion_fx >> 2);

  1300.         src_y = mb_y * 16 + (motion_fy >> 2);

  1301.         assert(src_x >=-16 && src_x<=s->width);

  1302.         assert(src_y >=-16 && src_y<=s->height);

  1303. 

  1304.         ptr = s->last_picture.data[0] + (src_y * s->linesize) + src_x;

  1305.         s->dsp.put_qpel_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize);

  1306. 

  1307.         dxy = ((motion_by & 3) << 2) | (motion_bx & 3);

  1308.         src_x = mb_x * 16 + (motion_bx >> 2);

  1309.         src_y = mb_y * 16 + (motion_by >> 2);

  1310.         assert(src_x >=-16 && src_x<=s->width);

  1311.         assert(src_y >=-16 && src_y<=s->height);

  1312.     

  1313.         ptr = s->next_picture.data[0] + (src_y * s->linesize) + src_x;

  1314.         s->dsp.avg_qpel_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize);

  1315.     }else{

  1316.         dxy = ((motion_fy & 1) << 1) | (motion_fx & 1);

  1317.         src_x = mb_x * 16 + (motion_fx >> 1);

  1318.         src_y = mb_y * 16 + (motion_fy >> 1);

  1319.         assert(src_x >=-16 && src_x<=s->width);

  1320.         assert(src_y >=-16 && src_y<=s->height);

  1321. 

  1322.         ptr = s->last_picture.data[0] + (src_y * s->linesize) + src_x;

  1323.         s->dsp.put_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize, 16);

  1324. 

  1325.         dxy = ((motion_by & 1) << 1) | (motion_bx & 1);

  1326.         src_x = mb_x * 16 + (motion_bx >> 1);

  1327.         src_y = mb_y * 16 + (motion_by >> 1);

  1328.         assert(src_x >=-16 && src_x<=s->width);

  1329.         assert(src_y >=-16 && src_y<=s->height);

  1330.     

  1331.         ptr = s->next_picture.data[0] + (src_y * s->linesize) + src_x;

  1332.         s->dsp.avg_pixels_tab[0][dxy](dest_y    , ptr    , s->linesize, 16);

  1333.     }

  1334. 

  1335.     fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*s->me.mb_penalty_factor

  1336.            +(mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*s->me.mb_penalty_factor

  1337.            + s->dsp.mb_cmp[0](s, s->new_picture.data[0] + mb_x*16 + mb_y*16*s->linesize, dest_y, s->linesize);

  1338.            

  1339.     if(s->avctx->mb_cmp&FF_CMP_CHROMA){

  1340.     }

  1341.     //FIXME CHROMA !!!

  1342.            

  1343.     return fbmin;

  1344. }

  1345. 

  1346. /* refine the bidir vectors in hq mode and return the score in both lq & hq mode*/

  1347. static inline int bidir_refine(MpegEncContext * s,

  1348.                                   int mb_x, int mb_y)

  1349. {

  1350.     const int mot_stride = s->mb_width + 2;

  1351.     const int xy = (mb_y + 1)*mot_stride + mb_x + 1;

  1352.     int fbmin;

  1353.     int pred_fx= s->b_bidir_forw_mv_table[xy-1][0];

  1354.     int pred_fy= s->b_bidir_forw_mv_table[xy-1][1];

  1355.     int pred_bx= s->b_bidir_back_mv_table[xy-1][0];

  1356.     int pred_by= s->b_bidir_back_mv_table[xy-1][1];

  1357.     int motion_fx= s->b_bidir_forw_mv_table[xy][0]= s->b_forw_mv_table[xy][0];

  1358.     int motion_fy= s->b_bidir_forw_mv_table[xy][1]= s->b_forw_mv_table[xy][1];

  1359.     int motion_bx= s->b_bidir_back_mv_table[xy][0]= s->b_back_mv_table[xy][0];

  1360.     int motion_by= s->b_bidir_back_mv_table[xy][1]= s->b_back_mv_table[xy][1];

  1361. 

  1362.     //FIXME do refinement and add flag

  1363.     

  1364.     fbmin= check_bidir_mv(s, mb_x, mb_y, 

  1365.                           motion_fx, motion_fy,

  1366.                           motion_bx, motion_by,

  1367.                           pred_fx, pred_fy,

  1368.                           pred_bx, pred_by);

  1369. 

  1370.    return fbmin;

  1371. }

  1372. 

  1373. static inline int direct_search(MpegEncContext * s,

  1374.                                 int mb_x, int mb_y)

  1375. {

  1376.     int P[10][2];

  1377.     const int mot_stride = s->mb_width + 2;

  1378.     const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;

  1379.     const int shift= 1+s->quarter_sample;

  1380.     int dmin, i;

  1381.     const int time_pp= s->pp_time;

  1382.     const int time_pb= s->pb_time;

  1383.     int mx, my, xmin, xmax, ymin, ymax;

  1384.     int16_t (*mv_table)[2]= s->b_direct_mv_table;

  1385.     uint16_t * const mv_penalty= s->me.mv_penalty[1] + MAX_MV;

  1386.     

  1387.     ymin= xmin=(-32)>>shift;

  1388.     ymax= xmax=   31>>shift;

  1389. 

  1390.     if(s->co_located_type_table[mb_x + mb_y*s->mb_width]==CO_LOCATED_TYPE_4MV){

  1391.         s->mv_type= MV_TYPE_8X8;

  1392.     }else{

  1393.         s->mv_type= MV_TYPE_16X16;

  1394.     }

  1395. 

  1396.     for(i=0; i<4; i++){

  1397.         int index= s->block_index[i];

  1398.         int min, max;

  1399.     

  1400.         s->me.co_located_mv[i][0]= s->motion_val[index][0];

  1401.         s->me.co_located_mv[i][1]= s->motion_val[index][1];

  1402.         s->me.direct_basis_mv[i][0]= s->me.co_located_mv[i][0]*time_pb/time_pp + ((i& 1)<<(shift+3));

  1403.         s->me.direct_basis_mv[i][1]= s->me.co_located_mv[i][1]*time_pb/time_pp + ((i>>1)<<(shift+3));

  1404. //        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);

  1405. //        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);

  1406. 

  1407.         max= FFMAX(s->me.direct_basis_mv[i][0], s->me.direct_basis_mv[i][0] - s->me.co_located_mv[i][0])>>shift;

  1408.         min= FFMIN(s->me.direct_basis_mv[i][0], s->me.direct_basis_mv[i][0] - s->me.co_located_mv[i][0])>>shift;

  1409.         max+= (2*mb_x + (i& 1))*8 - 1; // +-1 is for the simpler rounding

  1410.         min+= (2*mb_x + (i& 1))*8 + 1;

  1411.         xmax= FFMIN(xmax, s->width - max);

  1412.         xmin= FFMAX(xmin, - 16     - min);

  1413. 

  1414.         max= FFMAX(s->me.direct_basis_mv[i][1], s->me.direct_basis_mv[i][1] - s->me.co_located_mv[i][1])>>shift;

  1415.         min= FFMIN(s->me.direct_basis_mv[i][1], s->me.direct_basis_mv[i][1] - s->me.co_located_mv[i][1])>>shift;

  1416.         max+= (2*mb_y + (i>>1))*8 - 1; // +-1 is for the simpler rounding

  1417.         min+= (2*mb_y + (i>>1))*8 + 1;

  1418.         ymax= FFMIN(ymax, s->height - max);

  1419.         ymin= FFMAX(ymin, - 16      - min);

  1420.         

  1421.         if(s->mv_type == MV_TYPE_16X16) break;

  1422.     }

  1423.     

  1424.     assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);

  1425.     

  1426.     if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){

  1427.         s->b_direct_mv_table[mot_xy][0]= 0;

  1428.         s->b_direct_mv_table[mot_xy][1]= 0;

  1429. 

  1430.         return 256*256*256*64;

  1431.     }

  1432. 

  1433.     P_LEFT[0]        = clip(mv_table[mot_xy - 1][0], xmin<<shift, xmax<<shift);

  1434.     P_LEFT[1]        = clip(mv_table[mot_xy - 1][1], ymin<<shift, ymax<<shift);

  1435. 

  1436.     /* special case for first line */

  1437.     if (mb_y) {

  1438.         P_TOP[0]      = clip(mv_table[mot_xy - mot_stride             ][0], xmin<<shift, xmax<<shift);

  1439.         P_TOP[1]      = clip(mv_table[mot_xy - mot_stride             ][1], ymin<<shift, ymax<<shift);

  1440.         P_TOPRIGHT[0] = clip(mv_table[mot_xy - mot_stride + 1         ][0], xmin<<shift, xmax<<shift);

  1441.         P_TOPRIGHT[1] = clip(mv_table[mot_xy - mot_stride + 1         ][1], ymin<<shift, ymax<<shift);

  1442.     

  1443.         P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);

  1444.         P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);

  1445.     }

  1446.  

  1447.     //FIXME direct_search  ptr in context!!! (needed for chroma anyway or this will get messy)   

  1448.     if(s->flags&CODEC_FLAG_QPEL){

  1449.         dmin = simple_direct_qpel_epzs_motion_search(s, 0, &mx, &my, P, 0, 0, xmin, ymin, xmax, ymax, 

  1450.                                                      &s->last_picture, mv_table, 1<<14, mv_penalty);

  1451.         dmin = simple_direct_qpel_qpel_motion_search(s, &mx, &my, dmin, xmin, ymin, xmax, ymax,

  1452.                                                 0, 0, &s->last_picture, 0, 0, mv_penalty);

  1453.         

  1454.         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)

  1455.             dmin= simple_direct_qpel_qpel_get_mb_score(s, mx, my, 0, 0, &s->last_picture, mv_penalty);

  1456.     }else{

  1457.         dmin = simple_direct_hpel_epzs_motion_search(s, 0, &mx, &my, P, 0, 0, xmin, ymin, xmax, ymax, 

  1458.                                                      &s->last_picture, mv_table, 1<<15, mv_penalty);

  1459.         dmin = simple_direct_hpel_hpel_motion_search(s, &mx, &my, dmin, xmin, ymin, xmax, ymax,

  1460.                                                 0, 0, &s->last_picture, 0, 0, mv_penalty);

  1461. 

  1462.         if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)

  1463.             dmin= simple_direct_hpel_hpel_get_mb_score(s, mx, my, 0, 0, &s->last_picture, mv_penalty);

  1464.     }

  1465. 

  1466.     s->b_direct_mv_table[mot_xy][0]= mx;

  1467.     s->b_direct_mv_table[mot_xy][1]= my;

  1468.     return dmin;

  1469. }

  1470. 

  1471. void ff_estimate_b_frame_motion(MpegEncContext * s,

  1472.                              int mb_x, int mb_y)

  1473. {

  1474.     const int penalty_factor= s->me.mb_penalty_factor;

  1475.     int fmin, bmin, dmin, fbmin;

  1476.     int type=0;

  1477.     

  1478.     dmin= direct_search(s, mb_x, mb_y);

  1479. 

  1480.     fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, &s->last_picture, s->f_code) + 3*penalty_factor;

  1481.     bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, &s->next_picture, s->b_code) + 2*penalty_factor;

  1482. //printf(" %d %d ", s->b_forw_mv_table[xy][0], s->b_forw_mv_table[xy][1]);

  1483. 

  1484.     fbmin= bidir_refine(s, mb_x, mb_y) + penalty_factor;

  1485. //printf("%d %d %d %d\n", dmin, fmin, bmin, fbmin);

  1486.     {

  1487.         int score= dmin;

  1488.         type=MB_TYPE_DIRECT;

  1489.         

  1490.         if(fmin<score){

  1491.             score=fmin;

  1492.             type= MB_TYPE_FORWARD; 

  1493.         }

  1494.         if(bmin<score){

  1495.             score=bmin;

  1496.             type= MB_TYPE_BACKWARD; 

  1497.         }

  1498.         if(fbmin<score){

  1499.             score=fbmin;

  1500.             type= MB_TYPE_BIDIR;

  1501.         }

  1502.         

  1503.         score= ((unsigned)(score*score + 128*256))>>16;

  1504.         s->current_picture.mc_mb_var_sum += score;

  1505.         s->current_picture.mc_mb_var[mb_y*s->mb_width + mb_x] = score; //FIXME use SSE

  1506.     }

  1507. 

  1508.     if(s->flags&CODEC_FLAG_HQ){

  1509.         type= MB_TYPE_FORWARD | MB_TYPE_BACKWARD | MB_TYPE_BIDIR | MB_TYPE_DIRECT; //FIXME something smarter

  1510.         if(dmin>256*256*16) type&= ~MB_TYPE_DIRECT; //dont try direct mode if its invalid for this MB

  1511.     }

  1512. 

  1513.     s->mb_type[mb_y*s->mb_width + mb_x]= type;

  1514. }

  1515. 

  1516. /* find best f_code for ME which do unlimited searches */

  1517. int ff_get_best_fcode(MpegEncContext * s, int16_t (*mv_table)[2], int type)

  1518. {

  1519.     if(s->me_method>=ME_EPZS){

  1520.         int score[8];

  1521.         int i, y;

  1522.         UINT8 * fcode_tab= s->fcode_tab;

  1523.         int best_fcode=-1;

  1524.         int best_score=-10000000;

  1525. 

  1526.         for(i=0; i<8; i++) score[i]= s->mb_num*(8-i);

  1527. 

  1528.         for(y=0; y<s->mb_height; y++){

  1529.             int x;

  1530.             int xy= (y+1)* (s->mb_width+2) + 1;

  1531.             i= y*s->mb_width;

  1532.             for(x=0; x<s->mb_width; x++){

  1533.                 if(s->mb_type[i] & type){

  1534.                     int fcode= FFMAX(fcode_tab[mv_table[xy][0] + MAX_MV],

  1535.                                      fcode_tab[mv_table[xy][1] + MAX_MV]);

  1536.                     int j;

  1537.                     

  1538.                     for(j=0; j<fcode && j<8; j++){

  1539.                         if(s->pict_type==B_TYPE || s->current_picture.mc_mb_var[i] < s->current_picture.mb_var[i])

  1540.                             score[j]-= 170;

  1541.                     }

  1542.                 }

  1543.                 i++;

  1544.                 xy++;

  1545.             }

  1546.         }

  1547.         

  1548.         for(i=1; i<8; i++){

  1549.             if(score[i] > best_score){

  1550.                 best_score= score[i];

  1551.                 best_fcode= i;

  1552.             }

  1553. //            printf("%d %d\n", i, score[i]);

  1554.         }

  1555. 

  1556. //    printf("fcode: %d type: %d\n", i, s->pict_type);

  1557.         return best_fcode;

  1558. /*        for(i=0; i<=MAX_FCODE; i++){

  1559.             printf("%d ", mv_num[i]);

  1560.         }

  1561.         printf("\n");*/

  1562.     }else{

  1563.         return 1;

  1564.     }

  1565. }

  1566. 

  1567. void ff_fix_long_p_mvs(MpegEncContext * s)

  1568. {

  1569.     const int f_code= s->f_code;

  1570.     int y;

  1571.     UINT8 * fcode_tab= s->fcode_tab;

  1572. //int clip=0;

  1573. //int noclip=0;

  1574.     /* clip / convert to intra 16x16 type MVs */

  1575.     for(y=0; y<s->mb_height; y++){

  1576.         int x;

  1577.         int xy= (y+1)* (s->mb_width+2)+1;

  1578.         int i= y*s->mb_width;

  1579.         for(x=0; x<s->mb_width; x++){

  1580.             if(s->mb_type[i]&MB_TYPE_INTER){

  1581.                 if(   fcode_tab[s->p_mv_table[xy][0] + MAX_MV] > f_code

  1582.                    || fcode_tab[s->p_mv_table[xy][0] + MAX_MV] == 0

  1583.                    || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] > f_code

  1584.                    || fcode_tab[s->p_mv_table[xy][1] + MAX_MV] == 0 ){

  1585.                     s->mb_type[i] &= ~MB_TYPE_INTER;

  1586.                     s->mb_type[i] |= MB_TYPE_INTRA;

  1587.                     s->p_mv_table[xy][0] = 0;

  1588.                     s->p_mv_table[xy][1] = 0;

  1589. //clip++;

  1590.                 }

  1591. //else

  1592. //  noclip++;

  1593.             }

  1594.             xy++;

  1595.             i++;

  1596.         }

  1597.     }

  1598. //printf("%d no:%d %d//\n", clip, noclip, f_code);

  1599.     if(s->flags&CODEC_FLAG_4MV){

  1600.         const int wrap= 2+ s->mb_width*2;

  1601. 

  1602.         /* clip / convert to intra 8x8 type MVs */

  1603.         for(y=0; y<s->mb_height; y++){

  1604.             int xy= (y*2 + 1)*wrap + 1;

  1605.             int i= y*s->mb_width;

  1606.             int x;

  1607. 

  1608.             for(x=0; x<s->mb_width; x++){

  1609.                 if(s->mb_type[i]&MB_TYPE_INTER4V){

  1610.                     int block;

  1611.                     for(block=0; block<4; block++){

  1612.                         int off= (block& 1) + (block>>1)*wrap;

  1613.                         int mx= s->motion_val[ xy + off ][0];

  1614.                         int my= s->motion_val[ xy + off ][1];

  1615. 

  1616.                         if(   fcode_tab[mx + MAX_MV] > f_code

  1617.                            || fcode_tab[mx + MAX_MV] == 0

  1618.                            || fcode_tab[my + MAX_MV] > f_code

  1619.                            || fcode_tab[my + MAX_MV] == 0 ){

  1620.                             s->mb_type[i] &= ~MB_TYPE_INTER4V;

  1621.                             s->mb_type[i] |= MB_TYPE_INTRA;

  1622.                         }

  1623.                     }

  1624.                 }

  1625.                 xy+=2;

  1626.                 i++;

  1627.             }

  1628.         }

  1629.     }

  1630. }

  1631. 

  1632. void ff_fix_long_b_mvs(MpegEncContext * s, int16_t (*mv_table)[2], int f_code, int type)

  1633. {

  1634.     int y;

  1635.     UINT8 * fcode_tab= s->fcode_tab;

  1636. 

  1637.     /* clip / convert to intra 16x16 type MVs */

  1638.     for(y=0; y<s->mb_height; y++){

  1639.         int x;

  1640.         int xy= (y+1)* (s->mb_width+2)+1;

  1641.         int i= y*s->mb_width;

  1642.         for(x=0; x<s->mb_width; x++){

  1643.             if(   fcode_tab[mv_table[xy][0] + MAX_MV] > f_code

  1644.                || fcode_tab[mv_table[xy][0] + MAX_MV] == 0){

  1645.                 if(mv_table[xy][0]>0) mv_table[xy][0]=  (16<<f_code)-1;

  1646.                 else                  mv_table[xy][0]= -(16<<f_code);

  1647.             }

  1648.             if(   fcode_tab[mv_table[xy][1] + MAX_MV] > f_code

  1649.                || fcode_tab[mv_table[xy][1] + MAX_MV] == 0){

  1650.                 if(mv_table[xy][1]>0) mv_table[xy][1]=  (16<<f_code)-1;

  1651.                 else                  mv_table[xy][1]= -(16<<f_code);

  1652.             }

  1653.             xy++;

  1654.             i++;

  1655.         }

  1656.     }

  1657. }