开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
mot_est_mb.c
资源名称：yingshiping5.rar　[点击查看]
上传用户：lq790611
上传日期：2014-03-13
资源大小：166k
文件大小：23k
源码类别：

视频捕捉/采集

开发平台：

Visual C++

mot_est_mb.c：源码内容
  2. /**************************************************************************
  3. 该文件包含了在一次扫描中对某一宏块的运动估计的处理函数
  4.  *
  5.  **************************************************************************/
  7. #include "mot_util.h"
  9. /* Obtaining if two floating point values are equal*/
  10. #define ABSDOUBLE(x)   (((x) > 0.0001) ? (x) : (((x) < -0.0001) ? -(x): 0.0 ))
  11. #define ARE_EQUAL(x,y) ( (ABSDOUBLE((Float)(x)-(y))>0.1)?(0):(1) )
  13. /* auxiliar define for indexing in MBMotionEstimation */
  14. #define INDEX_BIG(x,y) ((x)+(y)*(vop_width))
  15. #define INDEX_NOR(x,y) ((x)+(y)*(MB_SIZE))
  17. /* ------------------------------------------------------------------------- */
  19. /***********************************************************CommentBegin******
  20.  *
  21.  * -- RangeInSearchArea -- computes the range of the search area
  22.  *
  23.  * Purpose :
  24.  *      computes the range of the search area for the predicted MV's
  25.  *      INSIDE the overlapped zone between reference and current vops
  26.  *
  27.  ***********************************************************CommentEnd********/
  29. static Void
  30. RangeInSearchArea(
  31. Int     i,   /* <-- horizontal MBcoordinate in pixels               */
  32. Int     j,   /* <-- vertical MB coordinate in pixels                */
  33. Int     block,   /* <-- block position (0 16x16; 1-2-3-4 8x8)           */
  34. Int     prev_x,   /* <-- absolute horizontal position of the previous vop*/
  35. Int     prev_y,   /* <-- absolute vertical position of the previous vop  */
  36. Int     vop_width,   /* <-- horizontal vop dimension                        */
  37. Int     vop_height,   /* <-- vertical vop dimension                          */
  38. Int     br_x,   /* <-- absolute horizontal position of the current vop */
  39. Int     br_y,   /* <-- absolute vertical   position of the current vop */
  40. Int     edge,   /* <-- edge arround the reference vop                  */
  41. Int     f_code,   /* <-  MV search range 1/2 (or 1/4) pel: (0=16,) 1=32,2=64,...,7=2048 */
  42. Float   *mv_x_min,   /* <-- min horizontal range                            */
  43. Float   *mv_x_max,   /* <-- max horizontal range                            */
  44. Float   *mv_y_min,   /* <-- min vertical range                              */
  45. Float   *mv_y_max,   /* <-- max vertical range                              */
  46. Int     *out   /* --> the search area does not exist (the reference   */   /*     and current BB does not overlap)                */
  47. )
  48. {
  49. Int   dim_curr_x_max,
  50. dim_curr_y_max,
  51. dim_curr_x_min,
  52. dim_curr_y_min;
  53. Int   dim_prev_x_max,
  54. dim_prev_y_max,
  55. dim_prev_x_min,
  56. dim_prev_y_min;
  57. Int   mb_b_size,
  58. block_x,
  59. block_y;
  61. *out=0;
  63. switch (block)
  64. {
  65. case 0:   /* 8x8 or 16x16 block search */
  66. block_x=0;   /*****************************/
  67. block_y=0;   /** 1 2 ********  0  *********/
  68. mb_b_size=MB_SIZE;   /** 3 4 ********     *********/
  69. break;   /*****************************/
  70. case 1:
  71. block_x=0;
  72. block_y=0;
  73. mb_b_size=B_SIZE;
  74. break;
  75. case 2:
  76. block_x=B_SIZE;
  77. block_y=0;
  78. mb_b_size=B_SIZE;
  79. break;
  80. case 3:
  81. block_x=0;
  82. block_y=B_SIZE;
  83. mb_b_size=B_SIZE;
  84. break;
  85. case 4:
  86. block_x=B_SIZE;
  87. block_y=B_SIZE;
  88. mb_b_size=B_SIZE;
  89. break;
  90. default:
  91. return;
  92. }
  94. /* min x/y */
  95. dim_curr_x_min=(Int)(br_x+i*MB_SIZE+*mv_x_min+block_x);
  96. dim_curr_y_min=(Int)(br_y+j*MB_SIZE+*mv_y_min+block_y);
  97. dim_prev_x_min=prev_x/*-edge*/;
  98. dim_prev_y_min=prev_y/*-edge*/;
  100. /* max x/y */
  101. /*the MB right-pixels inside */
  102. dim_curr_x_max=(Int)(br_x+i*MB_SIZE+*mv_x_max+mb_b_size+block_x);
  103. /*the MB bottom-pixels inside */
  104. dim_curr_y_max=(Int)(br_y+j*MB_SIZE+*mv_y_max+mb_b_size+block_y);
  105. dim_prev_x_max=prev_x+vop_width /*+edge*/;
  106. dim_prev_y_max=prev_y+vop_height/*+edge*/;
  108. /* range x/y min */
  110. if (dim_curr_x_min > dim_prev_x_max)
  111. {
  112. *out=1;
  113. }
  114. else if(dim_curr_x_min < dim_prev_x_min)
  115. {
  116. *mv_x_min = *mv_x_min + ( dim_prev_x_min - dim_curr_x_min ) ;
  117. }
  119. if(!(*out))
  120. {
  121. if (dim_curr_y_min > dim_prev_y_max)
  122. {
  123. *out=1;
  124. }
  125. else if(dim_curr_y_min < dim_prev_y_min)
  126. {
  127. *mv_y_min = *mv_y_min + ( dim_prev_y_min - dim_curr_y_min ) ;
  128. }
  129. }
  131. /* range x/y max */
  132. if(!(*out))
  133. {
  134. if(dim_curr_x_max < dim_prev_x_min)
  135. {
  136. *out=1;
  137. }
  138. if ((!(*out))&&(dim_curr_x_max > dim_prev_x_max))
  139. {
  140. *mv_x_max = *mv_x_max - ( dim_curr_x_max - dim_prev_x_max) ;
  141. }
  142. }
  144. if(!(*out))
  145. {
  146. if(dim_curr_y_max < dim_prev_y_min)
  147. {
  148. *out=1;   /* already set */
  149. }
  150. if ((!(*out))&&(dim_curr_y_max > dim_prev_y_max))
  151. {
  152. *mv_y_max = *mv_y_max - ( dim_curr_y_max - dim_prev_y_max) ;
  153. }
  154. }
  156. if(*mv_x_min>*mv_x_max)
  157. {
  158. *out=1;
  159. }
  161. if ( (!(*out)) && (*mv_y_min>*mv_y_max))
  162. {
  163. *out=1;
  164. }
  166. return;
  167. }
  170. /***********************************************************CommentBegin******
  171.  *
  172.  * -- Obtain_Range -- computes the range of the search area
  173.  *
  174.  * Purpose :
  175.  *      computes the range of the search area for the predicted MV's
  176.  *      (it can be outside the overlapped zone between the reference
  177.  *      and current vops)
  178.  *
  179.  * Return values :
  180.  *      1 on success, 0 on error
  181.  *
  182.  ***********************************************************CommentEnd********/
  184. static Int
  185. Obtain_Range(
  186. Int     f_code,   /* <-- MV search range 1/2 (or 1/4 pel): (0=16,) 1=32,2=64,...,7=2048   */
  187. Int     sr,   /* <-- Serach range (radius)                           */
  188. Int     type,   /* <-- MBM_INTER16==16x16 search; MBM_INTER8==8x8 search */
  189. Float   pmv_x,   /* <-- predicted horizontal motion vector              */
  190. Float   pmv_y,   /* <-- predicted horizontal motion vector              */
  191. Float   *mv_x_min,   /* --> min horizontal range                            */
  192. Float   *mv_x_max,   /* --> max horizontal range                            */
  193. Float   *mv_y_min,   /* --> min vertical range                              */
  194. Float   *mv_y_max,   /* --> max vertical range                              */
  195. Int     quarter_pel   /* <-- quarter pel flag (to allow f_code==0 without sprite) */
  196. )
  197. {
  198. Int    error;
  200. Float  aux_x_min, aux_y_min,
  201. aux_x_max, aux_y_max;
  203. Float  range;
  205. error=0;
  207. if ((f_code==0) && (!quarter_pel))   /* for Low Latency Sprite */
  208. {
  209. *mv_x_min=0;
  210. *mv_x_max=0;
  211. *mv_y_min=0;
  212. *mv_y_max=0;
  213. }
  214. else
  215. {
  216. range = sr;
  218. *mv_x_min=-range; *mv_x_max= range - 0.5f;
  220. *mv_y_min=-range; *mv_y_max= range - 0.5f;
  221. }
  223. if (type==MBM_INTER8)
  224. {
  225. aux_x_min=pmv_x - DEFAULT_8_WIN;
  226. aux_y_min=pmv_y - DEFAULT_8_WIN;
  227. aux_x_max=pmv_x + DEFAULT_8_WIN;
  228. aux_y_max=pmv_y + DEFAULT_8_WIN;
  230. if(*mv_x_min < aux_x_min)
  231. *mv_x_min = aux_x_min;
  232. if(*mv_y_min < aux_y_min)
  233. *mv_y_min = aux_y_min;
  234. if(*mv_x_max > aux_x_max)
  235. *mv_x_max = aux_x_max;
  236. if(*mv_y_max > aux_y_max)
  237. *mv_y_max = aux_y_max;
  238. }
  240. if (error==1)
  241. return(0);
  242. else
  243. return(1);
  244. }
  247. /***********************************************************CommentBegin******
  248.  *
  249.  * -- MBMotionEstimation -- Computes INTEGER PRECISION MV's for a MB
  250.  *
  251.  * Purpose :
  252.  *      Computes INTEGER PRECISION MV's for a MB. Also returns
  253.  *      prediction errors. Requires the whole MVs data images to
  254.  *      obtain prediction for the current MV, which determines search
  255.  *      range
  256.  *
  257.  ***********************************************************CommentEnd********/
  259. Void
  260. MBMotionEstimation(
  261. SInt    *curr,   /* <-- Current vop pointer                          */
  262. SInt    *prev,   /* <-- extended reference picture                   */
  263. Int     br_x,   /* <-- horizontal bounding rectangle coordinate     */
  264. Int     br_y,   /* <-- vertical bounding rectangle coordinate       */
  265. Int     br_width,   /* <-- bounding rectangule width                    */
  266. Int     i,   /* <-- horizontal MBcoordinate in pixels            */
  267. Int     j,   /* <-- vertical MB coordinate in pixels             */
  268. Int     prev_x,   /* <-- absolute horiz. position of previous vop     */
  269. Int     prev_y,   /* <-- absolute verti. position of previous vop     */
  270. Int     vop_width,   /* <-- horizontal vop dimension                     */
  271. Int     vop_height,   /* <-- vertical vop dimension                       */
  272. Int     enable_8x8_mv,   /* <-- 8x8 MV (=1) or only 16x16 MV (=0)            */
  273. Int     edge,   /* <-- edge                                         */
  274. Int     f_code,   /* <-- MV search range 1/2 (or 1/4) pel: (0=16,) 1=32,2=64,...,7=2048*/
  275. Int     sr,   /* <-- search range (corresponds to f_code) UB 990215*/
  276. Float hint_mv_w,                                /* <-- hint seed for horizontal MV                  */
  277. Float hint_mv_h,                                /* <-- hint seed for vertical MV                    */
  278. Float   *mv16_w,   /* --> predicted horizontal 16x16 MV(if approp.)    */
  279. Float   *mv16_h,   /* --> predicted vertical 16x16 MV  (if approp.)    */
  280. Float   *mv8_w,   /* --> predicted horizontal 8x8 MV  (if approp.)    */
  281. Float   *mv8_h,   /* --> predicted vertical 8x8 MV    (if approp.)    */
  282. Int     *min_error,   /* --> Minimum prediction error                     */
  283. SInt    *flags
  284. )
  285. {
  286. Int     x, y;
  287. Int     sad, sad_min=MV_MAX_ERROR;
  288. Int     mv_x, mv_y;
  289. Int     block;
  290. Float   pmv_x, pmv_y;
  291. SInt act_block[MB_SIZE*MB_SIZE];
  293. Float   mv_x_min, mv_x_max,
  294. mv_y_min, mv_y_max;
  295. Int     int_mv_x_min=0, int_mv_x_max=0,
  296. int_mv_y_min=0, int_mv_y_max=0;
  298. Int     pos16, pos8;
  299. Int     mvm_width   = br_width/MB_SIZE;
  301. Int     x_curr      = i*MB_SIZE,
  302. y_curr      = j*MB_SIZE;
  303. Int     hb,vb;
  304. Int     out;
  306. Int     rel_ori_x;
  307. Int     rel_ori_y;
  309. Int     min_error16, min_error8 = 0;
  310. // SInt    *curr = (SInt *)GetImageData(GetVopY(curr_vop));
  311. #ifndef _FULL_SEARCH_   /* PIH (NTU) Fast ME 08/08/99 */
  312. typedef struct
  313. {
  314. Int x;
  315. Int y;
  316. SInt start_nmbr;
  317. } DPoint;
  319. typedef struct
  320. {
  321. DPoint point[8];
  322. } Diamond;
  324. SInt d_type=1,stop_flag=0,pt_nmbr=0,check_pts,total_check_pts=8,mot_dirn=0;
  325. Int d_centre_x=0,d_centre_y=0,check_pt_x,check_pt_y;
  326. Diamond diamond[2]=
  327. {
  328. {
  329. { {0,1,0}, {1,0,0}, {0,-1,0}, {-1,0,0} }
  330. }
  331. ,
  332. {
  333. { {0,2,6}, {1,1,0}, {2,0,0}, {1,-1,2},
  334. {0,-2,2}, {-1,-1,4}, {-2,0,4}, {-1,1,6} }
  335. }
  336. };
  337. #endif
  339. d_centre_x = (int)hint_mv_w;
  340. d_centre_y = (int)hint_mv_h;
  342. rel_ori_x=br_x-prev_x;
  343. rel_ori_y=br_y-prev_y;
  345. /* Load act_block */
  347. LoadArea(curr, x_curr,y_curr,MB_SIZE,MB_SIZE,br_width, act_block);
  349. /* Compute 16x16 integer MVs */
  351. /* Obtain range */
  353. Obtain_Range (f_code, sr, MBM_INTER16,   /* UB 990215 added search range */
  354. 0.0, 0.0, &mv_x_min, &mv_x_max,
  355.   /*UB 990215 added quarter pel support */
  356. &mv_y_min, &mv_y_max, 0/*GetVopQuarterPel(curr_vop)*/);
  358. RangeInSearchArea (i,j,0, prev_x, prev_y, vop_width, vop_height,
  359. br_x, br_y, edge,f_code, &mv_x_min, &mv_x_max,
  360.   /*UB 990215 added quarter pel support */
  361. &mv_y_min, &mv_y_max,&out);
  363. /* Compute */
  365. if(!out)
  366. {
  367. int_mv_x_min=(int)ceil((double)mv_x_min);
  368. int_mv_y_min=(int)ceil((double)mv_y_min);
  369. int_mv_x_max=(int)floor((double)mv_x_max);
  370. int_mv_y_max=(int)floor((double)mv_y_max);
  371. flags[0]=ARE_EQUAL(int_mv_x_min,mv_x_min);
  372. flags[1]=ARE_EQUAL(int_mv_x_max,mv_x_max);
  373. flags[2]=ARE_EQUAL(int_mv_y_min,mv_y_min);
  374. flags[3]=ARE_EQUAL(int_mv_y_max,mv_y_max);
  376. sad_min=MV_MAX_ERROR;
  377. mv_x = mv_y = 2000;   /* A very large MV */
  379. #ifdef _FULL_SEARCH_   /* PIH (NTU)  08/08/99 */
  380. for (y=int_mv_y_min; y<=int_mv_y_max; y++)
  381. for (x=int_mv_x_min; x<=int_mv_x_max; x++)
  382. {
  383. if (x==0 && y==0)
  384. sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+rel_ori_x,
  385. y_curr+rel_ori_y), act_block, 
  386. (vop_width/*+2*edge*/), MV_MAX_ERROR)
  387. - (128 + 1);
  388. else
  389. sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+x+rel_ori_x,
  390. y_curr+y+rel_ori_y), act_block, 
  391. (vop_width/*+2*edge*/), sad_min);
  393. if (sad<sad_min)
  394. {
  395. sad_min=sad;
  396. mv_x=x;
  397. mv_y=y;
  398. }
  399. else if (sad==sad_min)
  400. if((ABS(x)+ABS(y)) < (ABS(mv_x)+ABS(mv_y)))
  401. {
  402. sad_min=sad;
  403. mv_x=x;
  404. mv_y=y;
  405. }
  406. }   /*for*/
  407. #else   /* PIH (NTU) Fast ME 08/08/99 */
  408. sad = SAD_Macroblock(prev+INDEX_BIG(x_curr+rel_ori_x,
  409. y_curr+rel_ori_y), act_block, (vop_width/*+2*edge*/), MV_MAX_ERROR)
  410. - (128 + 1);
  411. if (sad<sad_min)
  412. {
  413. sad_min=sad;
  414. mv_x = mv_y = 0;
  415. }
  416. do
  417. {
  418. check_pts=total_check_pts;
  420. do
  421. {
  422. check_pt_x = diamond[d_type].point[pt_nmbr].x + d_centre_x;
  423. check_pt_y = diamond[d_type].point[pt_nmbr].y + d_centre_y;
  425. /* Restrict the search to the searching window ; Note: This constraint can be removed */
  426. if ( check_pt_x < int_mv_x_min || check_pt_x > int_mv_x_max || check_pt_y < int_mv_y_min || check_pt_y > int_mv_y_max)
  427. {
  428. sad = MV_MAX_ERROR;
  429. }
  430. else
  431. {
  432. sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+check_pt_x+rel_ori_x,
  433. y_curr+check_pt_y+rel_ori_y), act_block, 
  434. (vop_width/*+2*edge*/), sad_min);
  435. #ifdef _SAD_EXHAUS_
  436. fprintf(stdout,"+o+ [%2d,%2d] sad16(%3d,%3d)=%4dn",i,j,x,y,sad);
  437. #endif
  438. }
  439. if (sad<sad_min)
  440. {
  441. sad_min=sad;
  442. mv_x=check_pt_x;
  443. mv_y=check_pt_y;
  444. mot_dirn=pt_nmbr;
  445. }
  446. else if (sad==sad_min)
  447. if((ABS(check_pt_x)+ABS(check_pt_y)) < (ABS(mv_x)+ABS(mv_y)))
  448. {
  449. sad_min=sad;
  450. mv_x=check_pt_x;
  451. mv_y=check_pt_y;
  452. mot_dirn=pt_nmbr;
  453. }
  455. pt_nmbr+=1;
  456. if((pt_nmbr)>= 8) pt_nmbr-=8;
  457. check_pts-=1;
  458. }
  459. while(check_pts>0);
  461. if( d_type == 0)
  462. {
  463. stop_flag = 1;
  465. }
  466. else
  467. {
  468. if( (mv_x == d_centre_x) && (mv_y == d_centre_y) )
  469. {
  470. d_type=0;
  471. pt_nmbr=0;
  472. total_check_pts = 4;
  473. }
  474. else
  475. {
  476. if((mv_x==d_centre_x) ||(mv_y==d_centre_y))
  477. total_check_pts=5;
  478. else
  479. total_check_pts=3;
  480. pt_nmbr=diamond[d_type].point[mot_dirn].start_nmbr;
  481. d_centre_x = mv_x;
  482. d_centre_y = mv_y;
  484. }
  485. }
  486. }
  487. while(stop_flag!=1);
  488. #endif
  490. flags[0]=flags[0] && (mv_x==int_mv_x_min);
  491. flags[1]=flags[1] && (mv_x==int_mv_x_max);
  492. flags[2]=flags[2] && (mv_y==int_mv_y_min);
  493. flags[3]=flags[3] && (mv_y==int_mv_y_max);
  494. }
  495. else
  496. {
  497. mv_x=mv_y=0;
  498. sad_min=MV_MAX_ERROR;
  499. }
  501. /* Store result */
  503. out |=((mv_x==2000)||(mv_y==2000));
  504. if(out)
  505. {
  506. mv_x=mv_y=0;
  507. sad_min=MV_MAX_ERROR;
  508. }
  510. pos16=2*j*2*mvm_width + 2*i;
  511. mv16_w[pos16]=   mv_x; mv16_h[pos16]=   mv_y;
  512. mv16_w[pos16+1]= mv_x; mv16_h[pos16+1]= mv_y;
  513. pos16+=2*mvm_width;
  514. mv16_w[pos16]=   mv_x; mv16_h[pos16]=   mv_y;
  515. mv16_w[pos16+1]= mv_x; mv16_h[pos16+1]= mv_y;
  516. min_error16 = sad_min;
  518. *min_error = min_error16;
  520. /* Compute 8x8 MVs */
  522. if(enable_8x8_mv==1)
  523. {
  524. if(!out)
  525. {
  526. for (block=0;block<4;block++)
  527. {
  528. /* Obtain range */
  529. if(block==0)
  530. {
  531. hb=vb=0;
  532. }
  533. else if (block==1)
  534. {
  535. hb=1;vb=0;
  536. }
  537. else if (block==2)
  538. {
  539. hb=0;vb=1;
  540. }
  541. else
  542. {
  543. hb=vb=1;
  544. }
  546. /* VM 2.*: restrict the search range based on the current 16x16 MV
  547.  *         inside a window around it
  548.  */
  550. pmv_x=mv16_w[pos16]; pmv_y=mv16_h[pos16];
  552.   /* UB 990215 added search range */
  553. Obtain_Range(f_code, sr, MBM_INTER8,
  554. pmv_x, pmv_y, &mv_x_min,
  555.   /*UB 990215 added quarter pel support */
  556. &mv_x_max, &mv_y_min, &mv_y_max, 0 /*GetVopQuarterPel(curr_vop)*/);
  558. RangeInSearchArea(i,j, block+1, prev_x, prev_y,
  559. vop_width, vop_height, br_x, br_y, edge,f_code,
  560.   /*UB 990215 added quarter pel support */
  561. &mv_x_min, &mv_x_max, &mv_y_min,&mv_y_max,&out);
  563. if(!out)
  564. {
  565. int_mv_x_min=(int)ceil((double)mv_x_min);
  566. int_mv_y_min=(int)ceil((double)mv_y_min);
  567. int_mv_x_max=(int)floor((double)mv_x_max);
  568. int_mv_y_max=(int)floor((double)mv_y_max);
  569. flags[4+block*4]=ARE_EQUAL(int_mv_x_min,mv_x_min);
  570. flags[4+block*4+1]=ARE_EQUAL(int_mv_x_max,mv_x_max);
  571. flags[4+block*4+2]=ARE_EQUAL(int_mv_y_min,mv_y_min);
  572. flags[4+block*4+3]=ARE_EQUAL(int_mv_y_max,mv_y_max);
  574. sad_min=MV_MAX_ERROR;
  575. mv_x = mv_y = 2000;   /* A very large MV */
  577. for (y=int_mv_y_min; y<=int_mv_y_max; y++)
  578. for (x=int_mv_x_min; x<=int_mv_x_max; x++)
  579. {
  580. sad=SAD_Block(prev+
  581. INDEX_BIG(x_curr + x + 8*(block==1||block==3)+rel_ori_x,
  582. y_curr + y + 8*(block==2||block==3)+rel_ori_y),
  583. act_block+INDEX_NOR(8*(block==1||block==3),
  584. 8*(block==2||block==3)),
  585. (vop_width /*+2*edge*/), sad_min);
  587. if (sad<sad_min)
  588. {
  589. sad_min=sad;
  590. mv_x=x;
  591. mv_y=y;
  592. }
  593. else if (sad==sad_min)
  594. if((ABS(x)+ABS(y)) < (ABS(mv_x)+ABS(mv_y)))
  595. {
  596. sad_min=sad;
  597. mv_x=x;
  598. mv_y=y;
  599. }
  600. }   /*for*/
  602. flags[4+block*4]   = flags[4+block*4]   && (mv_x==int_mv_x_min);
  603. flags[4+block*4+1] = flags[4+block*4+1] && (mv_x==int_mv_x_max);
  604. flags[4+block*4+2] = flags[4+block*4+2] && (mv_y==int_mv_y_min);
  605. flags[4+block*4+3] = flags[4+block*4+3] && (mv_y==int_mv_y_max);
  606. }
  607. else
  608. {
  609. mv_x=mv_y=0;
  610. sad_min=MV_MAX_ERROR;
  611. /* punish the OUTER blocks with MV_MAX_ERROR in order to
  612.    be INTRA CODED */
  613. }
  615. /* Store result */
  617. if(block==0)
  618. {
  619. pos8=2*j*2*mvm_width + 2*i;
  620. min_error8 += sad_min;
  621. }
  622. else if (block==1)
  623. {
  624. pos8=2*j*2*mvm_width + 2*i+1;
  625. min_error8 += sad_min;
  626. }
  627. else if (block==2)
  628. {
  629. pos8=(2*j+1)*2*mvm_width + 2*i;
  630. min_error8 += sad_min;
  631. }
  632. else
  633. {
  634. pos8=(2*j+1)*2*mvm_width + 2*i+1;
  635. min_error8 += sad_min;
  636. }
  638. /* Store result: absolute coordinates (note that in restricted mode
  639.    pmv is (0,0)) */
  640. mv8_w[pos8]=mv_x;
  641. mv8_h[pos8]=mv_y;
  642. }   /*for block*/
  644. if (min_error8 < *min_error)
  645. *min_error = min_error8;
  646. }
  647. else
  648. {   /* all the four blocks are out */
  649. pos8=2*j*2*mvm_width + 2*i;      mv8_w[pos8]=mv8_h[pos8]=0.0;
  650. pos8=2*j*2*mvm_width + 2*i+1;    mv8_w[pos8]=mv8_h[pos8]=0.0;
  651. pos8=(2*j+1)*2*mvm_width + 2*i;  mv8_w[pos8]=mv8_h[pos8]=0.0;
  652. pos8=(2*j+1)*2*mvm_width + 2*i+1;mv8_w[pos8]=mv8_h[pos8]=0.0;
  653. min_error8 = MV_MAX_ERROR;
  654. }
  655. }   /* enable_8x8_mv*/
  657. }
  660. /***********************************************************CommentBegin******
  661.  *
  662.  * -- FindSubPel -- Computes MV with half-pixel accurary
  663.  *
  664.  * Purpose :
  665.  *      Computes MV with sub-pixel accurary for a 16x16 or 8x8 block
  666.  *
  667.  * Description :
  668.  *    1) The preference for the 16x16 null motion vector must be applied
  669.  *       again (now, the SAD is recomputed for the recontructed interpolated
  670.  *       reference)
  671.  *
  672.  ***********************************************************CommentEnd********/
  674. Void
  675. FindSubPel(
  676. Int    x,   /* <-- horizontal block coordinate in pixels            */
  677. Int    y,   /* <-- vertical blocl coordinate in pixels              */
  678. SInt   *prev,                                     /* <-- interpolated reference vop                       */
  679. SInt   *curr,                                   /* <-- current block                                    */   
  680. Int    bs_x,                 /* <-- hor. block size (8/16)                           */
  681. Int    bs_y,   /* <-- vert. block size (8/16)                          */
  682. Int    comp,   /* <-- block position in MB (0,1,2,3)                   */
  683. Int    rel_x,   /* <-- relative horiz. position between curr & prev vops*/
  684. Int    rel_y,   /* <-- relative verti. position between curr & prev vops*/
  685. Int    pels,   /* <-- vop width                                        */
  686. Int    lines,   /* <-- vop height                                       */
  687. Int    edge,   /* <-- edge                                             */
  688. SInt   *flags,   /* <-- flags                                            */
  689. SInt   *curr_comp_mb,                             /* <-> motion compensated current mb                    */
  690. Float  *mvx,   /* <-> horizontal motion vector                         */
  691. Float  *mvy,   /* <-> vertical motion vector                           */
  692. Int    *min_error   /* --> prediction error                                 */
  693. )
  694. {
  695. static PixPoint search[9] = 
  696. {
  697. {0, 0}, {-1, -1}, {0, -1}, {1, -1},
  698. {-1, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}
  699. };
  700. /* searching map
  701. 1 2 3
  702. 4 0 5
  703. 6 7 8
  704. */
  706. Int i, m, n;
  707. Int new_x, new_y,
  708. lx, size_x;   /* MW QPEL 07-JUL-1998 */
  709. Int min_pos;
  710. Int AE, AE_min;
  711. Int flag_pos;
  712. SInt *pRef, *pComp;
  714. int flag_search[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
  716. Int SubDimension = 2;
  718. lx = 2*(pels /*+ 2*edge*/);
  720. new_x = (Int)((x + *mvx + rel_x)*(SubDimension));
  721. new_y = (Int)((y + *mvy + rel_y)*(SubDimension));
  722. new_x += ((comp&1)<<3)*SubDimension;
  723. new_y += ((comp&2)<<2)*SubDimension;
  725. size_x=16;
  727. /** in 1-pixel search we check if we are inside the range; so don't check
  728. it again
  729. **/
  731. /* avoids trying outside the reference image */
  732. /* we also check with flags if we are inside */
  733. /* search range (1==don't make 1/x search by */
  734. /* this side                                 */
  736. if (bs_x==8)   
  737. flag_pos=4+comp*4;
  738. else   /* ==16*/
  739. flag_pos=0;
  741. if (((new_x/SubDimension) <= 0/*-edge*/) || *(flags+flag_pos)) {
  742. flag_search[1] = flag_search[4] = flag_search[6] = 0;
  743. } else if  (((new_x/SubDimension) >= (pels - bs_x /*+ edge*/)) || *(flags+flag_pos+1)) {
  744. flag_search[3] = flag_search[5] = flag_search[8] = 0;
  745. };
  747. if (((new_y/SubDimension) <= 0/*-edge*/) || *(flags+flag_pos+2)) {
  748. flag_search[1] = flag_search[2] = flag_search[3] = 0;
  749. } else if  (((new_y/SubDimension) >= (lines- bs_y /*+ edge*/)) || *(flags+flag_pos+3)) {
  750. flag_search[6] = flag_search[7] = flag_search[8] = 0;
  751. };
  753. AE_min = MV_MAX_ERROR;
  754. min_pos = 0;
  755. for (i = 0; i < 9; i++)
  756. {
  757. if (flag_search[i])
  758. {
  759. AE = 0;
  760. /* estimate on the already interpolated half-pel image */
  761. pRef = prev + new_x + search[i].x + (new_y + search[i].y) * lx;
  762. pComp = curr;
  764. n = bs_y;
  765. while (n--) {
  766. m = bs_x;
  767. while (m--) {
  768. AE += abs((Int)*pRef - (Int)*pComp);
  769. pRef += 2;
  770. pComp ++;
  771. }
  772. pRef += 2 * lx - 2 * bs_x;
  773. pComp += size_x - bs_x;
  774. }
  776. if (i==0 && bs_y==16 && *mvx==0 && *mvy==0)
  777. AE -= (128 + 1);
  779. if (AE < AE_min)
  780. {
  781. AE_min = AE;
  782. min_pos = i;
  783. }
  784. }
  785. /* else don't look outside the reference */
  786. }
  788. /* Store optimal values */
  789. *min_error = AE_min;
  790. *mvx += ((Float)search[min_pos].x)/(Float)(SubDimension);
  791. *mvy += ((Float)search[min_pos].y)/(Float)(SubDimension);
  793. // generate comp mb data for the minimum point
  794. pRef = prev + new_x + search[min_pos].x + (new_y + search[min_pos].y) * lx;
  795. pComp = curr_comp_mb;
  797. n = bs_y;
  798. while (n--) {
  799. m = bs_x;
  800. while (m--) {
  801. *(pComp ++) = *pRef;
  802. pRef += 2;
  803. }
  804. pRef += 2 * lx - 2 * bs_x;
  805. pComp += 16 - bs_x;
  806. }
  808. return;
  809. }