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.
1018 Commits
32 Branches
596MB
Tree: a10678da8a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a10678da8a'
${ noResults }
FFmpeg/libavcodec/motion_est.c

1755 lines
56KB
Raw Blame History 

  1. /*

  2.  * Motion estimation 

  3.  * Copyright (c) 2000,2001 Fabrice Bellard.

  4.  * Copyright (c) 2002 Michael Niedermayer

  5.  * 

  6.  *

  7.  * This library is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2 of the License, or (at your option) any later version.

  11.  *

  12.  * This library is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with this library; if not, write to the Free Software

  19.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  20.  *

  21.  * new Motion Estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at>

  22.  */

  23. #include <stdlib.h>

  24. #include <stdio.h>

  25. #include "avcodec.h"

  26. #include "dsputil.h"

  27. #include "mpegvideo.h"

  28. 

  29. #define SQ(a) ((a)*(a))

  30. #define INTER_BIAS	257

  31. 

  32. #define P_LAST P[0]

  33. #define P_LEFT P[1]

  34. #define P_TOP P[2]

  35. #define P_TOPRIGHT P[3]

  36. #define P_MEDIAN P[4]

  37. #define P_LAST_LEFT P[5]

  38. #define P_LAST_RIGHT P[6]

  39. #define P_LAST_TOP P[7]

  40. #define P_LAST_BOTTOM P[8]

  41. #define P_MV1 P[9]

  42. 

  43. 

  44. static int pix_sum(UINT8 * pix, int line_size)

  45. {

  46.     int s, i, j;

  47. 

  48.     s = 0;

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

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

  51. 	    s += pix[0];

  52. 	    s += pix[1];

  53. 	    s += pix[2];

  54. 	    s += pix[3];

  55. 	    s += pix[4];

  56. 	    s += pix[5];

  57. 	    s += pix[6];

  58. 	    s += pix[7];

  59. 	    pix += 8;

  60. 	}

  61. 	pix += line_size - 16;

  62.     }

  63.     return s;

  64. }

  65. 

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

  67. {

  68.     int s, i, j;

  69. 

  70.     s = 0;

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

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

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

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

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

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

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

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

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

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

  81. 	    pix += 8;

  82. 	}

  83. 	pix += line_size - 16;

  84.     }

  85.     return s;

  86. }

  87. 

  88. static int pix_norm1(UINT8 * pix, int line_size)

  89. {

  90.     int s, i, j;

  91.     UINT32 *sq = squareTbl + 256;

  92. 

  93.     s = 0;

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

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

  96. 	    s += sq[pix[0]];

  97. 	    s += sq[pix[1]];

  98. 	    s += sq[pix[2]];

  99. 	    s += sq[pix[3]];

  100. 	    s += sq[pix[4]];

  101. 	    s += sq[pix[5]];

  102. 	    s += sq[pix[6]];

  103. 	    s += sq[pix[7]];

  104. 	    pix += 8;

  105. 	}

  106. 	pix += line_size - 16;

  107.     }

  108.     return s;

  109. }

  110. 

  111. static int pix_norm(UINT8 * pix1, UINT8 * pix2, int line_size)

  112. {

  113.     int s, i, j;

  114.     UINT32 *sq = squareTbl + 256;

  115. 

  116.     s = 0;

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

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

  119. 	    s += sq[pix1[0] - pix2[0]];

  120. 	    s += sq[pix1[1] - pix2[1]];

  121. 	    s += sq[pix1[2] - pix2[2]];

  122. 	    s += sq[pix1[3] - pix2[3]];

  123. 	    s += sq[pix1[4] - pix2[4]];

  124. 	    s += sq[pix1[5] - pix2[5]];

  125. 	    s += sq[pix1[6] - pix2[6]];

  126. 	    s += sq[pix1[7] - pix2[7]];

  127. 	    pix1 += 8;

  128. 	    pix2 += 8;

  129. 	}

  130. 	pix1 += line_size - 16;

  131. 	pix2 += line_size - 16;

  132.     }

  133.     return s;

  134. }

  135. 

  136. static void no_motion_search(MpegEncContext * s,

  137. 			     int *mx_ptr, int *my_ptr)

  138. {

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

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

  141. }

  142. 

  143. static int full_motion_search(MpegEncContext * s,

  144.                               int *mx_ptr, int *my_ptr, int range,

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

  146. {

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

  148.     int mx, my, dmin, d;

  149.     UINT8 *pix;

  150. 

  151.     xx = 16 * s->mb_x;

  152.     yy = 16 * s->mb_y;

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

  154.     if (x1 < xmin)

  155. 	x1 = xmin;

  156.     x2 = xx + range - 1;

  157.     if (x2 > xmax)

  158. 	x2 = xmax;

  159.     y1 = yy - range + 1;

  160.     if (y1 < ymin)

  161. 	y1 = ymin;

  162.     y2 = yy + range - 1;

  163.     if (y2 > ymax)

  164. 	y2 = ymax;

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

  166.     dmin = 0x7fffffff;

  167.     mx = 0;

  168.     my = 0;

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

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

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

  172. 			     s->linesize);

  173. 	    if (d < dmin ||

  174. 		(d == dmin &&

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

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

  177. 		dmin = d;

  178. 		mx = x;

  179. 		my = y;

  180. 	    }

  181. 	}

  182.     }

  183. 

  184.     *mx_ptr = mx;

  185.     *my_ptr = my;

  186. 

  187. #if 0

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

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

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

  191.     }

  192. #endif

  193.     return dmin;

  194. }

  195. 

  196. 

  197. static int log_motion_search(MpegEncContext * s,

  198.                              int *mx_ptr, int *my_ptr, int range,

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

  200. {

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

  202.     int mx, my, dmin, d;

  203.     UINT8 *pix;

  204. 

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

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

  207. 

  208.     /* Left limit */

  209.     x1 = xx - range;

  210.     if (x1 < xmin)

  211. 	x1 = xmin;

  212. 

  213.     /* Right limit */

  214.     x2 = xx + range;

  215.     if (x2 > xmax)

  216. 	x2 = xmax;

  217. 

  218.     /* Upper limit */

  219.     y1 = yy - range;

  220.     if (y1 < ymin)

  221. 	y1 = ymin;

  222. 

  223.     /* Lower limit */

  224.     y2 = yy + range;

  225.     if (y2 > ymax)

  226. 	y2 = ymax;

  227. 

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

  229.     dmin = 0x7fffffff;

  230.     mx = 0;

  231.     my = 0;

  232. 

  233.     do {

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

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

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

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

  238. 		    dmin = d;

  239. 		    mx = x;

  240. 		    my = y;

  241. 		}

  242. 	    }

  243. 	}

  244. 

  245. 	range = range >> 1;

  246. 

  247. 	x1 = mx - range;

  248. 	if (x1 < xmin)

  249. 	    x1 = xmin;

  250. 

  251. 	x2 = mx + range;

  252. 	if (x2 > xmax)

  253. 	    x2 = xmax;

  254. 

  255. 	y1 = my - range;

  256. 	if (y1 < ymin)

  257. 	    y1 = ymin;

  258. 

  259. 	y2 = my + range;

  260. 	if (y2 > ymax)

  261. 	    y2 = ymax;

  262. 

  263.     } while (range >= 1);

  264. 

  265. #ifdef DEBUG

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

  267. #endif

  268.     *mx_ptr = mx;

  269.     *my_ptr = my;

  270.     return dmin;

  271. }

  272. 

  273. static int phods_motion_search(MpegEncContext * s,

  274.                                int *mx_ptr, int *my_ptr, int range,

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

  276. {

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

  278.     int mx, my, dminx, dminy;

  279.     UINT8 *pix;

  280. 

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

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

  283. 

  284.     /* Left limit */

  285.     x1 = xx - range;

  286.     if (x1 < xmin)

  287. 	x1 = xmin;

  288. 

  289.     /* Right limit */

  290.     x2 = xx + range;

  291.     if (x2 > xmax)

  292. 	x2 = xmax;

  293. 

  294.     /* Upper limit */

  295.     y1 = yy - range;

  296.     if (y1 < ymin)

  297. 	y1 = ymin;

  298. 

  299.     /* Lower limit */

  300.     y2 = yy + range;

  301.     if (y2 > ymax)

  302. 	y2 = ymax;

  303. 

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

  305.     mx = 0;

  306.     my = 0;

  307. 

  308.     x = xx;

  309.     y = yy;

  310.     do {

  311.         dminx = 0x7fffffff;

  312.         dminy = 0x7fffffff;

  313. 

  314. 	lastx = x;

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

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

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

  318. 		dminx = d;

  319. 		mx = x;

  320. 	    }

  321. 	}

  322. 

  323. 	x = lastx;

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

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

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

  327. 		dminy = d;

  328. 		my = y;

  329. 	    }

  330. 	}

  331. 

  332. 	range = range >> 1;

  333. 

  334. 	x = mx;

  335. 	y = my;

  336. 	x1 = mx - range;

  337. 	if (x1 < xmin)

  338. 	    x1 = xmin;

  339. 

  340. 	x2 = mx + range;

  341. 	if (x2 > xmax)

  342. 	    x2 = xmax;

  343. 

  344. 	y1 = my - range;

  345. 	if (y1 < ymin)

  346. 	    y1 = ymin;

  347. 

  348. 	y2 = my + range;

  349. 	if (y2 > ymax)

  350. 	    y2 = ymax;

  351. 

  352.     } while (range >= 1);

  353. 

  354. #ifdef DEBUG

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

  356. #endif

  357. 

  358.     /* half pixel search */

  359.     *mx_ptr = mx;

  360.     *my_ptr = my;

  361.     return dminy;

  362. }

  363. 

  364. 

  365. #define Z_THRESHOLD 256

  366. 

  367. #define CHECK_MV(x,y)\

  368. {\

  369.     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

  370.     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\

  371.     if(map[index]!=key){\

  372.         d = pix_abs16x16(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\

  373.         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\

  374.         COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\

  375.         map[index]= key;\

  376.         score_map[index]= d;\

  377.     }\

  378. }

  379. 

  380. #define CHECK_MV_DIR(x,y,new_dir)\

  381. {\

  382.     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

  383.     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\

  384.     if(map[index]!=key){\

  385.         d = pix_abs(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\

  386.         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\

  387.         if(d<dmin){\

  388.             best[0]=x;\

  389.             best[1]=y;\

  390.             dmin=d;\

  391.             next_dir= new_dir;\

  392.         }\

  393.         map[index]= key;\

  394.         score_map[index]= d;\

  395.     }\

  396. }

  397. 

  398. #define CHECK_MV4(x,y)\

  399. {\

  400.     const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;\

  401.     const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);\

  402.     if(map[index]!=key){\

  403.         d = pix_abs8x8(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);\

  404.         d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;\

  405.         COPY3_IF_LT(dmin, d, best[0], x, best[1], y)\

  406.         map[index]= key;\

  407.         score_map[index]= d;\

  408.     }\

  409. }

  410. 

  411. #define check(x,y,S,v)\

  412. if( (x)<(xmin<<(S)) ) printf("%d %d %d %d %d xmin" #v, xmin, (x), (y), s->mb_x, s->mb_y);\

  413. if( (x)>(xmax<<(S)) ) printf("%d %d %d %d %d xmax" #v, xmax, (x), (y), s->mb_x, s->mb_y);\

  414. if( (y)<(ymin<<(S)) ) printf("%d %d %d %d %d ymin" #v, ymin, (x), (y), s->mb_x, s->mb_y);\

  415. if( (y)>(ymax<<(S)) ) printf("%d %d %d %d %d ymax" #v, ymax, (x), (y), s->mb_x, s->mb_y);\

  416. 

  417. 

  418. static inline int small_diamond_search(MpegEncContext * s, int *best, int dmin,

  419.                                        UINT8 *new_pic, UINT8 *old_pic, int pic_stride,

  420.                                        int pred_x, int pred_y, UINT16 *mv_penalty, int quant,

  421.                                        int xmin, int ymin, int xmax, int ymax, int shift,

  422.                                        uint32_t *map, uint16_t *score_map, int map_generation,

  423.                                        op_pixels_abs_func pix_abs)

  424. {

  425.     int next_dir=-1;

  426. 

  427.     for(;;){

  428.         int d;

  429.         const int dir= next_dir;

  430.         const int x= best[0];

  431.         const int y= best[1];

  432.         next_dir=-1;

  433. 

  434. //printf("%d", dir);

  435.         if(dir!=2 && x>xmin) CHECK_MV_DIR(x-1, y  , 0)

  436.         if(dir!=3 && y>ymin) CHECK_MV_DIR(x  , y-1, 1)

  437.         if(dir!=0 && x<xmax) CHECK_MV_DIR(x+1, y  , 2)

  438.         if(dir!=1 && y<ymax) CHECK_MV_DIR(x  , y+1, 3)

  439. 

  440.         if(next_dir==-1){

  441.             return dmin;

  442.         }

  443.     }

  444. 

  445. /*    for(;;){

  446.         int d;

  447.         const int x= best[0];

  448.         const int y= best[1];

  449.         const int last_min=dmin;

  450.         if(x>xmin) CHECK_MV(x-1, y  )

  451.         if(y>xmin) CHECK_MV(x  , y-1)

  452.         if(x<xmax) CHECK_MV(x+1, y  )

  453.         if(y<xmax) CHECK_MV(x  , y+1)

  454.         if(x>xmin && y>ymin) CHECK_MV(x-1, y-1)

  455.         if(x>xmin && y<ymax) CHECK_MV(x-1, y+1)

  456.         if(x<xmax && y>ymin) CHECK_MV(x+1, y-1)

  457.         if(x<xmax && y<ymax) CHECK_MV(x+1, y+1)

  458.         if(x-1>xmin) CHECK_MV(x-2, y  )

  459.         if(y-1>xmin) CHECK_MV(x  , y-2)

  460.         if(x+1<xmax) CHECK_MV(x+2, y  )

  461.         if(y+1<xmax) CHECK_MV(x  , y+2)

  462.         if(x-1>xmin && y-1>ymin) CHECK_MV(x-2, y-2)

  463.         if(x-1>xmin && y+1<ymax) CHECK_MV(x-2, y+2)

  464.         if(x+1<xmax && y-1>ymin) CHECK_MV(x+2, y-2)

  465.         if(x+1<xmax && y+1<ymax) CHECK_MV(x+2, y+2)

  466.         if(dmin==last_min) return dmin;

  467.     }

  468.     */

  469. }

  470. 

  471. #if 1

  472. #define SNAKE_1 3

  473. #define SNAKE_2 2

  474. #else

  475. #define SNAKE_1 7

  476. #define SNAKE_2 3

  477. #endif

  478. static inline int snake_search(MpegEncContext * s, int *best, int dmin,

  479.                                        UINT8 *new_pic, UINT8 *old_pic, int pic_stride,

  480.                                        int pred_x, int pred_y, UINT16 *mv_penalty, int quant,

  481.                                        int xmin, int ymin, int xmax, int ymax, int shift,

  482.                                        uint32_t *map, uint16_t *score_map,int map_generation,

  483.                                        op_pixels_abs_func pix_abs)

  484. {

  485.     int dir=0;

  486.     int c=1;

  487.     static int x_dir[8]= {1,1,0,-1,-1,-1, 0, 1};

  488.     static int y_dir[8]= {0,1,1, 1, 0,-1,-1,-1};

  489.     int fails=0;

  490.     int last_d[2]={dmin, dmin};

  491. 

  492. /*static int good=0;

  493. static int bad=0;

  494. static int point=0;

  495. 

  496. point++;

  497. if(256*256*256*64%point==0)

  498. {

  499.     printf("%d %d %d\n", good, bad, point);

  500. }*/

  501. 

  502.     for(;;){

  503.         int x= best[0];

  504.         int y= best[1];

  505.         int d;

  506.         x+=x_dir[dir];

  507.         y+=y_dir[dir];

  508.         if(x>=xmin && x<=xmax && y>=ymin && y<=ymax){

  509.             const int key= ((y)<<ME_MAP_MV_BITS) + (x) + map_generation;

  510.             const int index= (((y)<<ME_MAP_SHIFT) + (x))&(ME_MAP_SIZE-1);

  511.             if(map[index]!=key){

  512.                 d = pix_abs(new_pic, old_pic + (x) + (y)*pic_stride, pic_stride);

  513.                 d += (mv_penalty[((x)<<shift)-pred_x] + mv_penalty[((y)<<shift)-pred_y])*quant;

  514.                 map[index]=key;

  515.                 score_map[index]=d;

  516.             }else

  517.                 d= dmin+1;

  518.         }else{

  519.             d = dmin + 10000; //FIXME smarter boundary handling

  520.         }

  521.         if(d<dmin){

  522.             best[0]=x;

  523.             best[1]=y;

  524.             dmin=d;

  525. 

  526.             if(last_d[1] - last_d[0] > last_d[0] - d) c= -c;

  527.             dir+=c;

  528. 

  529.             fails=0;

  530. //good++;

  531.             last_d[1]=last_d[0];

  532.             last_d[0]=d;

  533.         }else{

  534. //bad++;

  535.             if(fails){

  536.                 if(fails>=SNAKE_1+1) return dmin;

  537.             }else{

  538.                 if(dir&1) dir-= c*3;

  539.                 else      c= -c;

  540. //                c= -c;

  541.             }

  542.             dir+=c*SNAKE_2;

  543.             fails++;

  544.         }

  545.         dir&=7;

  546.     }

  547. }

  548. 

  549. static inline int cross_search(MpegEncContext * s, int *best, int dmin,

  550.                                        UINT8 *new_pic, UINT8 *old_pic, int pic_stride,

  551.                                        int pred_x, int pred_y, UINT16 *mv_penalty, int quant,

  552.                                        int xmin, int ymin, int xmax, int ymax, int shift,

  553.                                        uint32_t *map, uint16_t *score_map,int map_generation,

  554.                                        op_pixels_abs_func pix_abs)

  555. {

  556.     static int x_dir[4]= {-1, 0, 1, 0};

  557.     static int y_dir[4]= { 0,-1, 0, 1};

  558.     int improvement[2]={100000, 100000};

  559.     int dirs[2]={2, 3};

  560.     int dir;

  561.     int last_dir= -1;

  562.     

  563.     for(;;){

  564.         dir= dirs[ improvement[0] > improvement[1] ? 0 : 1 ];

  565.         if(improvement[dir&1]==-1) return dmin;

  566.         

  567.         {

  568.             const int x= best[0] + x_dir[dir];

  569.             const int y= best[1] + y_dir[dir];

  570.             const int key= (y<<ME_MAP_MV_BITS) + x + map_generation;

  571.             const int index= ((y<<ME_MAP_SHIFT) + x)&(ME_MAP_SIZE-1);

  572.             int d;

  573.             if(x>=xmin && x<=xmax && y>=ymin && y<=ymax){

  574.                 if(map[index]!=key){

  575.                     d = pix_abs(new_pic, old_pic + x + y*pic_stride, pic_stride);

  576.                     d += (mv_penalty[(x<<shift)-pred_x] + mv_penalty[(y<<shift)-pred_y])*quant;

  577.                     map[index]=key;

  578.                     score_map[index]=d;

  579.                     if(d<dmin){

  580.                         improvement[dir&1]= dmin-d;

  581.                         improvement[(dir&1)^1]++;

  582.                         dmin=d;

  583.                         best[0]= x;

  584.                         best[1]= y;

  585.                         last_dir=dir;

  586.                         continue;

  587.                     }

  588.                 }else{

  589.                     d= score_map[index];

  590.                 }

  591.             }else{

  592.                 d= dmin + 1000; //FIXME is this a good idea?

  593.             }

  594.             /* evaluated point was cached or checked and worse */

  595. 

  596.             if(last_dir==dir){

  597.                 improvement[dir&1]= -1;

  598.             }else{

  599.                 improvement[dir&1]= d-dmin;

  600.                 last_dir= dirs[dir&1]= dir^2;

  601.             }

  602.         }

  603.     }

  604. }

  605. 

  606. static inline int update_map_generation(MpegEncContext * s)

  607. {

  608.     s->me_map_generation+= 1<<(ME_MAP_MV_BITS*2);

  609.     if(s->me_map_generation==0){

  610.         s->me_map_generation= 1<<(ME_MAP_MV_BITS*2);

  611.         memset(s->me_map, 0, sizeof(uint32_t)*ME_MAP_SIZE);

  612.     }

  613.     return s->me_map_generation;

  614. }

  615. 

  616. static int epzs_motion_search(MpegEncContext * s,

  617.                              int *mx_ptr, int *my_ptr,

  618.                              int P[10][2], int pred_x, int pred_y,

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

  620. {

  621.     int best[2]={0, 0};

  622.     int d, dmin; 

  623.     UINT8 *new_pic, *old_pic;

  624.     const int pic_stride= s->linesize;

  625.     const int pic_xy= (s->mb_y*pic_stride + s->mb_x)*16;

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

  627.     int quant= s->qscale; // qscale of the prev frame

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

  629.     uint32_t *map= s->me_map;

  630.     uint16_t *score_map= s->me_score_map;

  631.     int map_generation;

  632. 

  633.     new_pic = s->new_picture[0] + pic_xy;

  634.     old_pic = ref_picture + pic_xy;

  635.     

  636.     map_generation= update_map_generation(s);

  637. 

  638.     dmin = pix_abs16x16(new_pic, old_pic, pic_stride);

  639.     map[0]= map_generation;

  640.     score_map[0]= dmin;

  641. 

  642.     /* first line */

  643.     if ((s->mb_y == 0 || s->first_slice_line)) {

  644.         CHECK_MV(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  645.         CHECK_MV(P_LAST[0]>>shift, P_LAST[1]>>shift)

  646.     }else{

  647.         if(dmin<256 && ( P_LEFT[0]    |P_LEFT[1]

  648.                         |P_TOP[0]     |P_TOP[1]

  649.                         |P_TOPRIGHT[0]|P_TOPRIGHT[1])==0){

  650.             *mx_ptr= 0;

  651.             *my_ptr= 0;

  652.             s->skip_me=1;

  653.             return dmin;

  654.         }

  655.         CHECK_MV(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)

  656.         if(dmin>256*2){

  657.             CHECK_MV(P_LAST[0]    >>shift, P_LAST[1]    >>shift)

  658.             CHECK_MV(P_LEFT[0]    >>shift, P_LEFT[1]    >>shift)

  659.             CHECK_MV(P_TOP[0]     >>shift, P_TOP[1]     >>shift)

  660.             CHECK_MV(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)

  661.         }

  662.     }

  663.     if(dmin>256*4){

  664.         CHECK_MV(P_LAST_RIGHT[0] >>shift, P_LAST_RIGHT[1] >>shift)

  665.         CHECK_MV(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift)

  666.     }

  667. #if 0 //doest only slow things down

  668.     if(dmin>512*3){

  669.         int step;

  670.         dmin= score_map[0];

  671.         best[0]= best[1]=0;

  672.         for(step=128; step>0; step>>=1){

  673.             const int step2= step;

  674.             int y;

  675.             for(y=-step2+best[1]; y<=step2+best[1]; y+=step){

  676.                 int x;

  677.                 if(y<ymin || y>ymax) continue;

  678. 

  679.                 for(x=-step2+best[0]; x<=step2+best[0]; x+=step){

  680.                     if(x<xmin || x>xmax) continue;

  681.                     if(x==best[0] && y==best[1]) continue;

  682.                     CHECK_MV(x,y)

  683.                 }

  684.             }

  685.         }

  686.     }

  687. #endif

  688. //check(best[0],best[1],0, b0)

  689.     if(s->me_method==ME_EPZS)

  690.         dmin= small_diamond_search(s, best, dmin, new_pic, old_pic, pic_stride, 

  691.                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 

  692.                                    shift, map, score_map, map_generation, pix_abs16x16);

  693.     else

  694.         dmin=         cross_search(s, best, dmin, new_pic, old_pic, pic_stride, 

  695.                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 

  696.                                    shift, map, score_map, map_generation, pix_abs16x16);

  697. //check(best[0],best[1],0, b1)

  698.     *mx_ptr= best[0];

  699.     *my_ptr= best[1];    

  700. 

  701. //    printf("%d %d %d \n", best[0], best[1], dmin);

  702.     return dmin;

  703. }

  704. 

  705. static int epzs_motion_search4(MpegEncContext * s, int block,

  706.                              int *mx_ptr, int *my_ptr,

  707.                              int P[10][2], int pred_x, int pred_y,

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

  709. {

  710.     int best[2]={0, 0};

  711.     int d, dmin; 

  712.     UINT8 *new_pic, *old_pic;

  713.     const int pic_stride= s->linesize;

  714.     const int pic_xy= ((s->mb_y*2 + (block>>1))*pic_stride + s->mb_x*2 + (block&1))*8;

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

  716.     int quant= s->qscale; // qscale of the prev frame

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

  718.     uint32_t *map= s->me_map;

  719.     uint16_t *score_map= s->me_score_map;

  720.     int map_generation;

  721. 

  722.     new_pic = s->new_picture[0] + pic_xy;

  723.     old_pic = ref_picture + pic_xy;

  724. 

  725.     map_generation= update_map_generation(s);

  726. 

  727.     dmin = 1000000;

  728. //printf("%d %d %d %d //",xmin, ymin, xmax, ymax); 

  729.     /* first line */

  730.     if ((s->mb_y == 0 || s->first_slice_line) && block<2) {

  731.         CHECK_MV4(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  732.         CHECK_MV4(P_LAST[0]>>shift, P_LAST[1]>>shift)

  733.         CHECK_MV4(P_MV1[0]>>shift, P_MV1[1]>>shift)

  734.     }else{

  735.         CHECK_MV4(P_MV1[0]>>shift, P_MV1[1]>>shift)

  736.         //FIXME try some early stop

  737.         if(dmin>64*2){

  738.             CHECK_MV4(P_MEDIAN[0]>>shift, P_MEDIAN[1]>>shift)

  739.             CHECK_MV4(P_LEFT[0]>>shift, P_LEFT[1]>>shift)

  740.             CHECK_MV4(P_TOP[0]>>shift, P_TOP[1]>>shift)

  741.             CHECK_MV4(P_TOPRIGHT[0]>>shift, P_TOPRIGHT[1]>>shift)

  742.             CHECK_MV4(P_LAST[0]>>shift, P_LAST[1]>>shift)

  743.         }

  744.     }

  745.     if(dmin>64*4){

  746.         CHECK_MV4(P_LAST_RIGHT[0]>>shift, P_LAST_RIGHT[1]>>shift)

  747.         CHECK_MV4(P_LAST_BOTTOM[0]>>shift, P_LAST_BOTTOM[1]>>shift)

  748.     }

  749. 

  750.     if(s->me_method==ME_EPZS)

  751.         dmin= small_diamond_search(s, best, dmin, new_pic, old_pic, pic_stride, 

  752.                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 

  753.                                    shift, map, score_map, map_generation, pix_abs8x8);

  754.     else

  755.         dmin=         cross_search(s, best, dmin, new_pic, old_pic, pic_stride, 

  756.                                    pred_x, pred_y, mv_penalty, quant, xmin, ymin, xmax, ymax, 

  757.                                    shift, map, score_map, map_generation, pix_abs8x8);

  758. 

  759.     *mx_ptr= best[0];

  760.     *my_ptr= best[1];    

  761. 

  762. //    printf("%d %d %d \n", best[0], best[1], dmin);

  763.     return dmin;

  764. }

  765. 

  766. #define CHECK_HALF_MV(suffix, x, y) \

  767. {\

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

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

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

  771. }

  772. 

  773.     

  774. /* The idea would be to make half pel ME after Inter/Intra decision to 

  775.    save time. */

  776. static inline int halfpel_motion_search(MpegEncContext * s,

  777. 				  int *mx_ptr, int *my_ptr, int dmin,

  778. 				  int xmin, int ymin, int xmax, int ymax,

  779.                                   int pred_x, int pred_y, uint8_t *ref_picture,

  780.                                   op_pixels_abs_func pix_abs_x2, 

  781.                                   op_pixels_abs_func pix_abs_y2, op_pixels_abs_func pix_abs_xy2, int n)

  782. {

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

  784.     const int quant= s->qscale;

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

  786.     UINT8 *pix, *ptr;

  787. 

  788.     if(s->skip_me){

  789.         *mx_ptr = 0;

  790.         *my_ptr = 0;

  791.         return dmin;

  792.     }else

  793. 

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

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

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

  797. 

  798.     mx = *mx_ptr;

  799.     my = *my_ptr;

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

  801.     

  802.     dminh = dmin;

  803. 

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

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

  806.         int dx=0, dy=0;

  807.         int d, pen_x, pen_y; 

  808. 

  809.         mx<<=1;

  810.         my<<=1;

  811.         

  812.         pen_x= pred_x + mx;

  813.         pen_y= pred_y + my;

  814. 

  815.         ptr-= s->linesize;

  816.         CHECK_HALF_MV(xy2, -1, -1)

  817.         CHECK_HALF_MV(y2 ,  0, -1)

  818.         CHECK_HALF_MV(xy2, +1, -1)

  819.         

  820.         ptr+= s->linesize;

  821.         CHECK_HALF_MV(x2 , -1,  0)

  822.         CHECK_HALF_MV(x2 , +1,  0)

  823.         CHECK_HALF_MV(xy2, -1, +1)

  824.         CHECK_HALF_MV(y2 ,  0, +1)

  825.         CHECK_HALF_MV(xy2, +1, +1)

  826. 

  827.         mx+=dx;

  828.         my+=dy;

  829.     }else{

  830.         mx<<=1;

  831.         my<<=1;

  832.     }

  833. 

  834.     *mx_ptr = mx;

  835.     *my_ptr = my;

  836.     return dminh;

  837. }

  838. 

  839. static inline int fast_halfpel_motion_search(MpegEncContext * s,

  840. 				  int *mx_ptr, int *my_ptr, int dmin,

  841. 				  int xmin, int ymin, int xmax, int ymax,

  842.                                   int pred_x, int pred_y, uint8_t *ref_picture,

  843.                                   op_pixels_abs_func pix_abs_x2, 

  844.                                   op_pixels_abs_func pix_abs_y2, op_pixels_abs_func pix_abs_xy2, int n)

  845. {

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

  847.     uint16_t *score_map= s->me_score_map;

  848.     const int quant= s->qscale;

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

  850.     UINT8 *pix, *ptr;

  851. 

  852.     if(s->skip_me){

  853. //    printf("S");

  854.         *mx_ptr = 0;

  855.         *my_ptr = 0;

  856.         return dmin;

  857.     }

  858. //    printf("N");

  859.         

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

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

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

  863. 

  864.     mx = *mx_ptr;

  865.     my = *my_ptr;

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

  867.     

  868.     dminh = dmin;

  869. 

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

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

  872.         int dx=0, dy=0;

  873.         int d, pen_x, pen_y; 

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

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

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

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

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

  879.         mx<<=1;

  880.         my<<=1;

  881. 

  882.         

  883.         pen_x= pred_x + mx;

  884.         pen_y= pred_y + my;

  885. 

  886.         ptr-= s->linesize;

  887.         if(t<=b){

  888.             CHECK_HALF_MV(y2 ,  0, -1)

  889.             if(l<=r){

  890.                 CHECK_HALF_MV(xy2, -1, -1)

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

  892.                     CHECK_HALF_MV(xy2, +1, -1)

  893.                     ptr+= s->linesize;

  894.                 }else{

  895.                     ptr+= s->linesize;

  896.                     CHECK_HALF_MV(xy2, -1, +1)

  897.                 }

  898.                 CHECK_HALF_MV(x2 , -1,  0)

  899.             }else{

  900.                 CHECK_HALF_MV(xy2, +1, -1)

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

  902.                     CHECK_HALF_MV(xy2, -1, -1)

  903.                     ptr+= s->linesize;

  904.                 }else{

  905.                     ptr+= s->linesize;

  906.                     CHECK_HALF_MV(xy2, +1, +1)

  907.                 }

  908.                 CHECK_HALF_MV(x2 , +1,  0)

  909.             }

  910.         }else{

  911.             if(l<=r){

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

  913.                     CHECK_HALF_MV(xy2, -1, -1)

  914.                     ptr+= s->linesize;

  915.                 }else{

  916.                     ptr+= s->linesize;

  917.                     CHECK_HALF_MV(xy2, +1, +1)

  918.                 }

  919.                 CHECK_HALF_MV(x2 , -1,  0)

  920.                 CHECK_HALF_MV(xy2, -1, +1)

  921.             }else{

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

  923.                     CHECK_HALF_MV(xy2, +1, -1)

  924.                     ptr+= s->linesize;

  925.                 }else{

  926.                     ptr+= s->linesize;

  927.                     CHECK_HALF_MV(xy2, -1, +1)

  928.                 }

  929.                 CHECK_HALF_MV(x2 , +1,  0)

  930.                 CHECK_HALF_MV(xy2, +1, +1)

  931.             }

  932.             CHECK_HALF_MV(y2 ,  0, +1)

  933.         }

  934.         mx+=dx;

  935.         my+=dy;

  936. 

  937.     }else{

  938.         mx<<=1;

  939.         my<<=1;

  940.     }

  941. 

  942.     *mx_ptr = mx;

  943.     *my_ptr = my;

  944.     return dminh;

  945. }

  946. 

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

  948. {

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

  950.     

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

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

  953. 

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

  955.     if(mv4){

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

  957. 

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

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

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

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

  962. 

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

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

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

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

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

  968.     }

  969. }

  970. 

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

  972. {

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

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

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

  976. 	*range *= 2;

  977. 

  978.     if (s->unrestricted_mv) {

  979.         *xmin = -16;

  980.         *ymin = -16;

  981.         if (s->h263_plus)

  982.             *range *= 2;

  983.         if(s->avctx==NULL || s->avctx->codec->id!=CODEC_ID_MPEG4){

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

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

  986.         }else {

  987.             /* XXX: dunno if this is correct but ffmpeg4 decoder wont like it otherwise 

  988. 	            (cuz the drawn edge isnt large enough))*/

  989.             *xmax = s->width;

  990.             *ymax = s->height;

  991.         }

  992.     } else {

  993.         *xmin = 0;

  994.         *ymin = 0;

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

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

  997.     }

  998. }

  999. 

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

  1001. {

  1002.     int block;

  1003.     int P[10][2];

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

  1005.     int dmin_sum=0;

  1006. 

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

  1008.         int mx4, my4;

  1009.         int pred_x4, pred_y4;

  1010.         int dmin4;

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

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

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

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

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

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

  1017.         const int rel_xmin4= xmin;

  1018.         const int rel_xmax4= xmax;

  1019.         const int rel_ymin4= ymin;

  1020.         const int rel_ymax4= ymax;

  1021. #else

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

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

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

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

  1026. #endif

  1027.         P_LAST[0] = s->motion_val[mot_xy    ][0];

  1028.         P_LAST[1] = s->motion_val[mot_xy    ][1];

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

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

  1031.         P_LAST_RIGHT[0] = s->motion_val[mot_xy + 1][0];

  1032.         P_LAST_RIGHT[1] = s->motion_val[mot_xy + 1][1];

  1033.         P_LAST_BOTTOM[0]= s->motion_val[mot_xy + 1*mot_stride][0];

  1034.         P_LAST_BOTTOM[1]= s->motion_val[mot_xy + 1*mot_stride][1];

  1035. 

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

  1037.         if(P_LAST_RIGHT[0] < (rel_xmin4<<shift)) P_LAST_RIGHT[0] = (rel_xmin4<<shift);

  1038.         if(P_LAST_BOTTOM[1]< (rel_ymin4<<shift)) P_LAST_BOTTOM[1]= (rel_ymin4<<shift);

  1039. 

  1040.         /* special case for first line */

  1041.         if ((s->mb_y == 0 || s->first_slice_line) && block<2) {

  1042.             pred_x4= P_LEFT[0];

  1043.             pred_y4= P_LEFT[1];

  1044.         } else {

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

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

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

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

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

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

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

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

  1053.     

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

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

  1056. 

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

  1058.                 pred_x4 = P_MEDIAN[0];

  1059.                 pred_y4 = P_MEDIAN[1];

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

  1061.                 pred_x4= P_LEFT[0];

  1062.                 pred_y4= P_LEFT[1];

  1063.             }

  1064.         }

  1065.         P_MV1[0]= mx;

  1066.         P_MV1[1]= my;

  1067. 

  1068.         dmin4 = epzs_motion_search4(s, block, &mx4, &my4, P, pred_x4, pred_y4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, ref_picture);

  1069. 

  1070.         dmin4= fast_halfpel_motion_search(s, &mx4, &my4, dmin4, rel_xmin4, rel_ymin4, rel_xmax4, rel_ymax4, 

  1071.                                    pred_x4, pred_y4, ref_picture, pix_abs8x8_x2, 

  1072.                                    pix_abs8x8_y2, pix_abs8x8_xy2, block);

  1073.  

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

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

  1076.         dmin_sum+= dmin4;

  1077.     }

  1078.     return dmin_sum;

  1079. }

  1080. 

  1081. void ff_estimate_p_frame_motion(MpegEncContext * s,

  1082.                                 int mb_x, int mb_y)

  1083. {

  1084.     UINT8 *pix, *ppix;

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

  1086.     int xmin, ymin, xmax, ymax;

  1087.     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;

  1088.     int pred_x=0, pred_y=0;

  1089.     int P[10][2];

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

  1091.     int mb_type=0;

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

  1093. 

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

  1095.     rel_xmin= xmin - mb_x*16;

  1096.     rel_xmax= xmax - mb_x*16;

  1097.     rel_ymin= ymin - mb_y*16;

  1098.     rel_ymax= ymax - mb_y*16;

  1099.     s->skip_me=0;

  1100. 

  1101.     switch(s->me_method) {

  1102.     case ME_ZERO:

  1103.     default:

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

  1105.         mx-= mb_x*16;

  1106.         my-= mb_y*16;

  1107.         dmin = 0;

  1108.         break;

  1109.     case ME_FULL:

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

  1111.         mx-= mb_x*16;

  1112.         my-= mb_y*16;

  1113.         break;

  1114.     case ME_LOG:

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

  1116.         mx-= mb_x*16;

  1117.         my-= mb_y*16;

  1118.         break;

  1119.     case ME_PHODS:

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

  1121.         mx-= mb_x*16;

  1122.         my-= mb_y*16;

  1123.         break;

  1124.     case ME_X1:

  1125.     case ME_EPZS:

  1126.        {

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

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

  1129. 

  1130.             P_LAST[0]       = s->motion_val[mot_xy    ][0];

  1131.             P_LAST[1]       = s->motion_val[mot_xy    ][1];

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

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

  1134.             P_LAST_RIGHT[0] = s->motion_val[mot_xy + 2][0];

  1135.             P_LAST_RIGHT[1] = s->motion_val[mot_xy + 2][1];

  1136.             P_LAST_BOTTOM[0]= s->motion_val[mot_xy + 2*mot_stride][0];

  1137.             P_LAST_BOTTOM[1]= s->motion_val[mot_xy + 2*mot_stride][1];

  1138. 

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

  1140.             if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);

  1141.             if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);

  1142. 

  1143.             /* special case for first line */

  1144.             if ((mb_y == 0 || s->first_slice_line)) {

  1145.                 pred_x= P_LEFT[0];

  1146.                 pred_y= P_LEFT[1];

  1147.             } else {

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

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

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

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

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

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

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

  1155.         

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

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

  1158. 

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

  1160.                     pred_x = P_MEDIAN[0];

  1161.                     pred_y = P_MEDIAN[1];

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

  1163.                     pred_x= P_LEFT[0];

  1164.                     pred_y= P_LEFT[1];

  1165.                 }

  1166.             }

  1167.         }

  1168.         dmin = epzs_motion_search(s, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, ref_picture);

  1169.  

  1170.         break;

  1171.     }

  1172. 

  1173.     /* intra / predictive decision */

  1174.     xx = mb_x * 16;

  1175.     yy = mb_y * 16;

  1176. 

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

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

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

  1180.     

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

  1182.     

  1183.     sum= (sum+8)>>4;

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

  1185.     vard = (pix_norm(pix, ppix, s->linesize)+128)>>8;

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

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

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

  1189.     s->mb_var_sum    += varc;

  1190.     s->mc_mb_var_sum += vard;

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

  1192.     

  1193. #if 0

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

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

  1196. #endif

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

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

  1199.             mb_type|= MB_TYPE_INTRA;

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

  1201.             mb_type|= MB_TYPE_INTER;

  1202.             if(s->me_method >= ME_EPZS)

  1203.                 fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1204.                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 

  1205.                                            pix_abs16x16_xy2, 0);

  1206.             else

  1207.                 halfpel_motion_search(     s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1208.                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 

  1209.                                            pix_abs16x16_xy2, 0);                                           

  1210.         }else{

  1211.             mx <<=1;

  1212.             my <<=1;

  1213.         }

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

  1215.            && !s->skip_me && varc>50 && vard>10){

  1216.             mv4_search(s, rel_xmin, rel_ymin, rel_xmax, rel_ymax, mx, my, shift);

  1217.             mb_type|=MB_TYPE_INTER4V;

  1218. 

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

  1220.         }else

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

  1222.     }else{

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

  1224.             mb_type|= MB_TYPE_INTER;

  1225.             if (s->me_method != ME_ZERO) {

  1226.                 if(s->me_method >= ME_EPZS)

  1227.                     dmin= fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1228.                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 

  1229.                                            pix_abs16x16_xy2, 0);

  1230.                 else

  1231.                     dmin= halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1232.                                            pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 

  1233.                                            pix_abs16x16_xy2, 0);

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

  1235.                    && !s->skip_me && varc>50 && vard>10){

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

  1237.                     if(dmin4 + 128 <dmin)

  1238.                         mb_type= MB_TYPE_INTER4V;

  1239.                 }

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

  1241. 

  1242.             } else {

  1243.                 mx <<=1;

  1244.                 my <<=1;

  1245.             }

  1246. #if 0

  1247.             if (vard < 10) {

  1248.                 skip++;

  1249.                 fprintf(stderr,"\nEarly skip: %d vard: %2d varc: %5d dmin: %d", 

  1250.                                 skip, vard, varc, dmin);

  1251.             }

  1252. #endif

  1253.         }else{

  1254.             mb_type|= MB_TYPE_INTRA;

  1255.             mx = 0;

  1256.             my = 0;

  1257.         }

  1258.     }

  1259. 

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

  1261. }

  1262. 

  1263. int ff_estimate_motion_b(MpegEncContext * s,

  1264.                        int mb_x, int mb_y, int16_t (*mv_table)[2], uint8_t *ref_picture, int f_code)

  1265. {

  1266.     int mx, my, range, dmin;

  1267.     int xmin, ymin, xmax, ymax;

  1268.     int rel_xmin, rel_ymin, rel_xmax, rel_ymax;

  1269.     int pred_x=0, pred_y=0;

  1270.     int P[10][2];

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

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

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

  1274.     

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

  1276.     rel_xmin= xmin - mb_x*16;

  1277.     rel_xmax= xmax - mb_x*16;

  1278.     rel_ymin= ymin - mb_y*16;

  1279.     rel_ymax= ymax - mb_y*16;

  1280. 

  1281.     switch(s->me_method) {

  1282.     case ME_ZERO:

  1283.     default:

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

  1285.         dmin = 0;

  1286.         mx-= mb_x*16;

  1287.         my-= mb_y*16;

  1288.         break;

  1289.     case ME_FULL:

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

  1291.         mx-= mb_x*16;

  1292.         my-= mb_y*16;

  1293.         break;

  1294.     case ME_LOG:

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

  1296.         mx-= mb_x*16;

  1297.         my-= mb_y*16;

  1298.         break;

  1299.     case ME_PHODS:

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

  1301.         mx-= mb_x*16;

  1302.         my-= mb_y*16;

  1303.         break;

  1304.     case ME_X1:

  1305.     case ME_EPZS:

  1306.        {

  1307. 

  1308.             P_LAST[0]        = mv_table[mot_xy    ][0];

  1309.             P_LAST[1]        = mv_table[mot_xy    ][1];

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

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

  1312.             P_LAST_RIGHT[0]  = mv_table[mot_xy + 1][0];

  1313.             P_LAST_RIGHT[1]  = mv_table[mot_xy + 1][1];

  1314.             P_LAST_BOTTOM[0] = mv_table[mot_xy + mot_stride][0];

  1315.             P_LAST_BOTTOM[1] = mv_table[mot_xy + mot_stride][1];

  1316. 

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

  1318.             if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);

  1319.             if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);

  1320. 

  1321.             /* special case for first line */

  1322.             if ((mb_y == 0 || s->first_slice_line)) {

  1323.             } else {

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

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

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

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

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

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

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

  1331.         

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

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

  1334.             }

  1335.             pred_x= P_LEFT[0];

  1336.             pred_y= P_LEFT[1];

  1337.         }

  1338.         dmin = epzs_motion_search(s, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax, ref_picture);

  1339.  

  1340.         break;

  1341.     }

  1342.     

  1343.     dmin= fast_halfpel_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax, 

  1344.                                 pred_x, pred_y, ref_picture, pix_abs16x16_x2, pix_abs16x16_y2, 

  1345.                                 pix_abs16x16_xy2, 0);

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

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

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

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

  1350.     return dmin;

  1351. }

  1352. 

  1353. 

  1354. static inline int check_bidir_mv(MpegEncContext * s,

  1355.                    int mb_x, int mb_y,

  1356.                    int motion_fx, int motion_fy,

  1357.                    int motion_bx, int motion_by,

  1358.                    int pred_fx, int pred_fy,

  1359.                    int pred_bx, int pred_by)

  1360. {

  1361.     //FIXME optimize?

  1362.     //FIXME direct mode penalty

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

  1364.     uint8_t *dest_y = s->me_scratchpad;

  1365.     uint8_t *ptr;

  1366.     int dxy;

  1367.     int src_x, src_y;

  1368.     int fbmin;

  1369. 

  1370.     fbmin = (mv_penalty[motion_fx-pred_fx] + mv_penalty[motion_fy-pred_fy])*s->qscale;

  1371. 

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

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

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

  1375.             

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

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

  1378.     put_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);

  1379.     

  1380.     fbmin += (mv_penalty[motion_bx-pred_bx] + mv_penalty[motion_by-pred_by])*s->qscale;

  1381. 

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

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

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

  1385.             

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

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

  1388.     avg_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);

  1389.     

  1390.     fbmin += pix_abs16x16(s->new_picture[0] + mb_x*16 + mb_y*16*s->linesize, dest_y, s->linesize);

  1391.     return fbmin;

  1392. }

  1393. 

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

  1395. static inline int bidir_refine(MpegEncContext * s,

  1396.                                   int mb_x, int mb_y)

  1397. {

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

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

  1400.     int fbmin;

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

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

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

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

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

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

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

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

  1409. 

  1410.     //FIXME do refinement and add flag

  1411.     

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

  1413.                           motion_fx, motion_fy,

  1414.                           motion_bx, motion_by,

  1415.                           pred_fx, pred_fy,

  1416.                           pred_bx, pred_by);

  1417. 

  1418.    return fbmin;

  1419. }

  1420. 

  1421. static inline int direct_search(MpegEncContext * s,

  1422.                                 int mb_x, int mb_y)

  1423. {

  1424.     int P[10][2];

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

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

  1427.     int dmin, dmin2;

  1428.     int motion_fx, motion_fy, motion_bx, motion_by, motion_bx0, motion_by0;

  1429.     int motion_dx, motion_dy;

  1430.     const int motion_px= s->p_mv_table[mot_xy][0];

  1431.     const int motion_py= s->p_mv_table[mot_xy][1];

  1432.     const int time_pp= s->pp_time;

  1433.     const int time_bp= s->bp_time;

  1434.     const int time_pb= time_pp - time_bp;

  1435.     int bx, by;

  1436.     int mx, my, mx2, my2;

  1437.     uint8_t *ref_picture= s->me_scratchpad - (mb_x - 1 + (mb_y - 1)*s->linesize)*16;

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

  1439.     uint16_t *mv_penalty= s->mv_penalty[s->f_code] + MAX_MV; // f_code of the prev frame

  1440. 

  1441.     /* thanks to iso-mpeg the rounding is different for the zero vector, so we need to handle that ... */

  1442.     motion_fx= (motion_px*time_pb)/time_pp;

  1443.     motion_fy= (motion_py*time_pb)/time_pp;

  1444.     motion_bx0= (-motion_px*time_bp)/time_pp;

  1445.     motion_by0= (-motion_py*time_bp)/time_pp;

  1446.     motion_dx= motion_dy=0;

  1447.     dmin2= check_bidir_mv(s, mb_x, mb_y, 

  1448.                           motion_fx, motion_fy,

  1449.                           motion_bx0, motion_by0,

  1450.                           motion_fx, motion_fy,

  1451.                           motion_bx0, motion_by0) - s->qscale;

  1452. 

  1453.     motion_bx= motion_fx - motion_px;

  1454.     motion_by= motion_fy - motion_py;

  1455.     for(by=-1; by<2; by++){

  1456.         for(bx=-1; bx<2; bx++){

  1457.             uint8_t *dest_y = s->me_scratchpad + (by+1)*s->linesize*16 + (bx+1)*16;

  1458.             uint8_t *ptr;

  1459.             int dxy;

  1460.             int src_x, src_y;

  1461.             const int width= s->width;

  1462.             const int height= s->height;

  1463. 

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

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

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

  1467.             src_x = clip(src_x, -16, width);

  1468.             if (src_x == width) dxy &= ~1;

  1469.             src_y = clip(src_y, -16, height);

  1470.             if (src_y == height) dxy &= ~2;

  1471. 

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

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

  1474.             put_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);

  1475. 

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

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

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

  1479.             src_x = clip(src_x, -16, width);

  1480.             if (src_x == width) dxy &= ~1;

  1481.             src_y = clip(src_y, -16, height);

  1482.             if (src_y == height) dxy &= ~2;

  1483. 

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

  1485.             avg_pixels_tab[dxy](dest_y + 8, ptr + 8, s->linesize, 16);

  1486.         }

  1487.     }

  1488. 

  1489.     P_LAST[0]        = mv_table[mot_xy    ][0];

  1490.     P_LAST[1]        = mv_table[mot_xy    ][1];

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

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

  1493.     P_LAST_RIGHT[0]  = mv_table[mot_xy + 1][0];

  1494.     P_LAST_RIGHT[1]  = mv_table[mot_xy + 1][1];

  1495.     P_LAST_BOTTOM[0] = mv_table[mot_xy + mot_stride][0];

  1496.     P_LAST_BOTTOM[1] = mv_table[mot_xy + mot_stride][1];

  1497. /*

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

  1499.     if(P_LAST_RIGHT[0] < (rel_xmin<<shift)) P_LAST_RIGHT[0] = (rel_xmin<<shift);

  1500.     if(P_LAST_BOTTOM[1]< (rel_ymin<<shift)) P_LAST_BOTTOM[1]= (rel_ymin<<shift);

  1501. */

  1502.     /* special case for first line */

  1503.     if ((mb_y == 0 || s->first_slice_line)) {

  1504.     } else {

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

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

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

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

  1509.     

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

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

  1512.     }

  1513.     dmin = epzs_motion_search(s, &mx, &my, P, 0, 0, -16, -16, 15, 15, ref_picture);

  1514.     if(mx==0 && my==0) dmin=99999999; // not representable, due to rounding stuff

  1515.     if(dmin2<dmin){ 

  1516.         dmin= dmin2;

  1517.         mx=0;

  1518.         my=0;

  1519.     }

  1520. #if 1

  1521.     mx2= mx= mx*2; 

  1522.     my2= my= my*2;

  1523.     for(by=-1; by<2; by++){

  1524.         if(my2+by < -32) continue;

  1525.         for(bx=-1; bx<2; bx++){

  1526.             if(bx==0 && by==0) continue;

  1527.             if(mx2+bx < -32) continue;

  1528.             dmin2= check_bidir_mv(s, mb_x, mb_y, 

  1529.                           mx2+bx+motion_fx, my2+by+motion_fy,

  1530.                           mx2+bx+motion_bx, my2+by+motion_by,

  1531.                           mx2+bx+motion_fx, my2+by+motion_fy,

  1532.                           motion_bx, motion_by) - s->qscale;

  1533.             

  1534.             if(dmin2<dmin){

  1535.                 dmin=dmin2;

  1536.                 mx= mx2 + bx;

  1537.                 my= my2 + by;

  1538.             }

  1539.         }

  1540.     }

  1541. #else

  1542.     mx*=2; my*=2;

  1543. #endif

  1544.     if(mx==0 && my==0){

  1545.         motion_bx= motion_bx0;

  1546.         motion_by= motion_by0;

  1547.     }

  1548. 

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

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

  1551.     s->b_direct_forw_mv_table[mot_xy][0]= motion_fx + mx;

  1552.     s->b_direct_forw_mv_table[mot_xy][1]= motion_fy + my;

  1553.     s->b_direct_back_mv_table[mot_xy][0]= motion_bx + mx;

  1554.     s->b_direct_back_mv_table[mot_xy][1]= motion_by + my;

  1555.     return dmin;

  1556. }

  1557. 

  1558. void ff_estimate_b_frame_motion(MpegEncContext * s,

  1559.                              int mb_x, int mb_y)

  1560. {

  1561.     const int quant= s->qscale;

  1562.     int fmin, bmin, dmin, fbmin;

  1563.     int type=0;

  1564.     

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

  1566. 

  1567.     fmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_forw_mv_table, s->last_picture[0], s->f_code);

  1568.     bmin= ff_estimate_motion_b(s, mb_x, mb_y, s->b_back_mv_table, s->next_picture[0], s->b_code) - quant;

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

  1570. 

  1571.     fbmin= bidir_refine(s, mb_x, mb_y);

  1572. 

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

  1574.         type= MB_TYPE_FORWARD | MB_TYPE_BACKWARD | MB_TYPE_BIDIR | MB_TYPE_DIRECT;

  1575.     }else{

  1576.         int score= dmin;

  1577.         type=MB_TYPE_DIRECT;

  1578.         

  1579.         if(fmin<score){

  1580.             score=fmin;

  1581.             type= MB_TYPE_FORWARD; 

  1582.         }

  1583.         if(bmin<score){

  1584.             score=bmin;

  1585.             type= MB_TYPE_BACKWARD; 

  1586.         }

  1587.         if(fbmin<score){

  1588.             score=fbmin;

  1589.             type= MB_TYPE_BIDIR;

  1590.         }

  1591.         s->mc_mb_var_sum += score;

  1592.         s->mc_mb_var[mb_y*s->mb_width + mb_x] = score;

  1593.     }

  1594. /*

  1595. {

  1596. static int count=0;

  1597. static int sum=0;

  1598. if(type==MB_TYPE_DIRECT){

  1599.   int diff= ABS(s->b_forw_mv_table)

  1600. }

  1601. }*/

  1602. 

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

  1604. /*    if(mb_y==0 && mb_x==0) printf("\n");

  1605.     if(mb_x==0) printf("\n");

  1606.     printf("%d", av_log2(type));

  1607. */

  1608. }

  1609. 

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

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

  1612. {

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

  1614.         int score[8];

  1615.         int i, y;

  1616.         UINT8 * fcode_tab= s->fcode_tab;

  1617.         int best_fcode=-1;

  1618.         int best_score=-10000000;

  1619. 

  1620.         for(i=0; i<8; i++) score[i]= s->mb_num*(8-i); //FIXME *2 and all other too so its the same but nicer

  1621. 

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

  1623.             int x;

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

  1625.             i= y*s->mb_width;

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

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

  1628.                     int fcode= MAX(fcode_tab[mv_table[xy][0] + MAX_MV],

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

  1630.                     int j;

  1631.                     

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

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

  1634.                             score[j]-= 170;

  1635.                     }

  1636.                 }

  1637.                 i++;

  1638.                 xy++;

  1639.             }

  1640.         }

  1641.         

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

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

  1644.                 best_score= score[i];

  1645.                 best_fcode= i;

  1646.             }

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

  1648.         }

  1649. 

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

  1651.         return best_fcode;

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

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

  1654.         }

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

  1656.     }else{

  1657.         return 1;

  1658.     }

  1659. }

  1660. 

  1661. void ff_fix_long_p_mvs(MpegEncContext * s)

  1662. {

  1663.     const int f_code= s->f_code;

  1664.     int y;

  1665.     UINT8 * fcode_tab= s->fcode_tab;

  1666. //int clip=0;

  1667. //int noclip=0;

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

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

  1670.         int x;

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

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

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

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

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

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

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

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

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

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

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

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

  1683. //clip++;

  1684.                 }

  1685. //else

  1686. //  noclip++;

  1687.             }

  1688.             xy++;

  1689.             i++;

  1690.         }

  1691.     }

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

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

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

  1695. 

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

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

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

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

  1700.             int x;

  1701. 

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

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

  1704.                     int block;

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

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

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

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

  1709. 

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

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

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

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

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

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

  1716.                         }

  1717.                     }

  1718.                 }

  1719.                 xy+=2;

  1720.                 i++;

  1721.             }

  1722.         }

  1723.     }

  1724. }

  1725. 

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

  1727. {

  1728.     int y;

  1729.     UINT8 * fcode_tab= s->fcode_tab;

  1730. 

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

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

  1733.         int x;

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

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

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

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

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

  1739.                    || fcode_tab[mv_table[xy][0] + MAX_MV] == 0

  1740.                    || fcode_tab[mv_table[xy][1] + MAX_MV] > f_code

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

  1742.                     if(s->mb_type[i]&(~type)) s->mb_type[i] &= ~type;

  1743.                     else{

  1744.                         mv_table[xy][0] = 0;

  1745.                         mv_table[xy][1] = 0;

  1746.                         //this is certainly bad FIXME            

  1747.                     }

  1748.                 }

  1749.             }

  1750.             xy++;

  1751.             i++;

  1752.         }

  1753.     }

  1754. }