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

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
mot_est_mb.c
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：15k
源码类别：

VC书籍

开发平台：

Visual C++

mot_est_mb.c：源码内容
  1. #include "mot_util.h"
  2. #define ABSDOUBLE(x)   (((x) > 0.0001) ? (x) : (((x) < -0.0001) ? -(x): 0.0 ))
  3. #define ARE_EQUAL(x,y) ( (ABSDOUBLE((Float)(x)-(y))>0.1)?(0):(1) )
  4. #define INDEX_BIG(x,y) ((x)+(y)*(vop_width))
  5. #define INDEX_NOR(x,y) ((x)+(y)*(MB_SIZE))
  6. static Void
  7. RangeInSearchArea(
  8. Int     i,   
  9. Int     j,   
  10. Int     block,   
  11. Int     prev_x,   
  12. Int     prev_y,   
  13. Int     vop_width,   
  14. Int     vop_height,   
  15. Int     br_x,   
  16. Int     br_y,   
  17. Int     edge,   
  18. Int     f_code,   
  19. Float   *mv_x_min,   
  20. Float   *mv_x_max,   
  21. Float   *mv_y_min,   
  22. Float   *mv_y_max,   
  23. Int     *out      
  24. )
  25. {
  26. Int   dim_curr_x_max,
  27. dim_curr_y_max,
  28. dim_curr_x_min,
  29. dim_curr_y_min;
  30. Int   dim_prev_x_max,
  31. dim_prev_y_max,
  32. dim_prev_x_min,
  33. dim_prev_y_min;
  34. Int   mb_b_size,
  35. block_x,
  36. block_y;
  37. *out=0;
  38. switch (block)
  39. {
  40. case 0:   
  41. block_x=0;   
  42. block_y=0;   
  43. mb_b_size=MB_SIZE;   
  44. break;   
  45. case 1:
  46. block_x=0;
  47. block_y=0;
  48. mb_b_size=B_SIZE;
  49. break;
  50. case 2:
  51. block_x=B_SIZE;
  52. block_y=0;
  53. mb_b_size=B_SIZE;
  54. break;
  55. case 3:
  56. block_x=0;
  57. block_y=B_SIZE;
  58. mb_b_size=B_SIZE;
  59. break;
  60. case 4:
  61. block_x=B_SIZE;
  62. block_y=B_SIZE;
  63. mb_b_size=B_SIZE;
  64. break;
  65. default:
  66. return;
  67. }
  69. dim_curr_x_min=(Int)(br_x+i*MB_SIZE+*mv_x_min+block_x);
  70. dim_curr_y_min=(Int)(br_y+j*MB_SIZE+*mv_y_min+block_y);
  71. dim_prev_x_min=prev_x;
  72. dim_prev_y_min=prev_y;
  75. dim_curr_x_max=(Int)(br_x+i*MB_SIZE+*mv_x_max+mb_b_size+block_x);
  77. dim_curr_y_max=(Int)(br_y+j*MB_SIZE+*mv_y_max+mb_b_size+block_y);
  78. dim_prev_x_max=prev_x+vop_width ;
  79. dim_prev_y_max=prev_y+vop_height;
  81. if (dim_curr_x_min > dim_prev_x_max)
  82. {
  83. *out=1;
  84. }
  85. else if(dim_curr_x_min < dim_prev_x_min)
  86. {
  87. *mv_x_min = *mv_x_min + ( dim_prev_x_min - dim_curr_x_min ) ;
  88. }
  89. if(!(*out))
  90. {
  91. if (dim_curr_y_min > dim_prev_y_max)
  92. {
  93. *out=1;
  94. }
  95. else if(dim_curr_y_min < dim_prev_y_min)
  96. {
  97. *mv_y_min = *mv_y_min + ( dim_prev_y_min - dim_curr_y_min ) ;
  98. }
  99. }
  101. if(!(*out))
  102. {
  103. if(dim_curr_x_max < dim_prev_x_min)
  104. {
  105. *out=1;
  106. }
  107. if ((!(*out))&&(dim_curr_x_max > dim_prev_x_max))
  108. {
  109. *mv_x_max = *mv_x_max - ( dim_curr_x_max - dim_prev_x_max) ;
  110. }
  111. }
  112. if(!(*out))
  113. {
  114. if(dim_curr_y_max < dim_prev_y_min)
  115. {
  116. *out=1;   
  117. }
  118. if ((!(*out))&&(dim_curr_y_max > dim_prev_y_max))
  119. {
  120. *mv_y_max = *mv_y_max - ( dim_curr_y_max - dim_prev_y_max) ;
  121. }
  122. }
  123. if(*mv_x_min>*mv_x_max)
  124. {
  125. *out=1;
  126. }
  127. if ( (!(*out)) && (*mv_y_min>*mv_y_max))
  128. {
  129. *out=1;
  130. }
  131. return;
  132. }
  133. static Int
  134. Obtain_Range(
  135. Int     f_code,   
  136. Int     sr,   
  137. Int     type,   
  138. Float   pmv_x,   
  139. Float   pmv_y,   
  140. Float   *mv_x_min,   
  141. Float   *mv_x_max,   
  142. Float   *mv_y_min,   
  143. Float   *mv_y_max,   
  144. Int     quarter_pel   
  145. )
  146. {
  147. Int    error;
  148. Float  aux_x_min, aux_y_min,
  149. aux_x_max, aux_y_max;
  150. Float  range;
  151. error=0;
  152. if ((f_code==0) && (!quarter_pel))   
  153. {
  154. *mv_x_min=0;
  155. *mv_x_max=0;
  156. *mv_y_min=0;
  157. *mv_y_max=0;
  158. }
  159. else
  160. {
  161. range = sr;
  162. *mv_x_min=-range; *mv_x_max= range - 0.5f;
  163. *mv_y_min=-range; *mv_y_max= range - 0.5f;
  164. }
  165. if (type==MBM_INTER8)
  166. {
  167. aux_x_min=pmv_x - DEFAULT_8_WIN;
  168. aux_y_min=pmv_y - DEFAULT_8_WIN;
  169. aux_x_max=pmv_x + DEFAULT_8_WIN;
  170. aux_y_max=pmv_y + DEFAULT_8_WIN;
  171. if(*mv_x_min < aux_x_min)
  172. *mv_x_min = aux_x_min;
  173. if(*mv_y_min < aux_y_min)
  174. *mv_y_min = aux_y_min;
  175. if(*mv_x_max > aux_x_max)
  176. *mv_x_max = aux_x_max;
  177. if(*mv_y_max > aux_y_max)
  178. *mv_y_max = aux_y_max;
  179. }
  180. if (error==1)
  181. return(0);
  182. else
  183. return(1);
  184. }
  185. Void
  186. MBMotionEstimation(
  187. SInt    *curr,   
  188. SInt    *prev,   
  189. Int     br_x,   
  190. Int     br_y,   
  191. Int     br_width,   
  192. Int     i,   
  193. Int     j,   
  194. Int     prev_x,   
  195. Int     prev_y,   
  196. Int     vop_width,   
  197. Int     vop_height,   
  198. Int     enable_8x8_mv,   
  199. Int     edge,   
  200. Int     f_code,   
  201. Int     sr,   
  202. Float hint_mv_w,                                
  203. Float hint_mv_h,                                
  204. Float   *mv16_w,   
  205. Float   *mv16_h,   
  206. Float   *mv8_w,   
  207. Float   *mv8_h,   
  208. Int     *min_error,   
  209. SInt    *flags
  210. )
  211. {
  212. Int     x, y;
  213. Int     sad, sad_min=MV_MAX_ERROR;
  214. Int     mv_x, mv_y;
  215. Int     block;
  216. Float   pmv_x, pmv_y;
  217. SInt act_block[MB_SIZE*MB_SIZE];
  218. Float   mv_x_min, mv_x_max,
  219. mv_y_min, mv_y_max;
  220. Int     int_mv_x_min=0, int_mv_x_max=0,
  221. int_mv_y_min=0, int_mv_y_max=0;
  222. Int     pos16, pos8;
  223. Int     mvm_width   = br_width/MB_SIZE;
  224. Int     x_curr      = i*MB_SIZE,
  225. y_curr      = j*MB_SIZE;
  226. Int     hb,vb;
  227. Int     out;
  228. Int     rel_ori_x;
  229. Int     rel_ori_y;
  230. Int     min_error16, min_error8 = 0;
  231. #ifndef _FULL_SEARCH_   
  232. typedef struct
  233. {
  234. Int x;
  235. Int y;
  236. SInt start_nmbr;
  237. } DPoint;
  238. typedef struct
  239. {
  240. DPoint point[8];
  241. } Diamond;
  242. SInt d_type=1,stop_flag=0,pt_nmbr=0,check_pts,total_check_pts=8,mot_dirn=0;
  243. Int d_centre_x=0,d_centre_y=0,check_pt_x,check_pt_y;
  244. Diamond diamond[2]=
  245. {
  246. {
  247. { {0,1,0}, {1,0,0}, {0,-1,0}, {-1,0,0} }
  248. }
  249. ,
  250. {
  251. { {0,2,6}, {1,1,0}, {2,0,0}, {1,-1,2},
  252. {0,-2,2}, {-1,-1,4}, {-2,0,4}, {-1,1,6} }
  253. }
  254. };
  255. #endif
  256. d_centre_x = (int)hint_mv_w;
  257. d_centre_y = (int)hint_mv_h;
  258. rel_ori_x=br_x-prev_x;
  259. rel_ori_y=br_y-prev_y;
  262. LoadArea(curr, x_curr,y_curr,MB_SIZE,MB_SIZE,br_width, act_block);
  265. Obtain_Range (f_code, sr, MBM_INTER16,   
  266. 0.0, 0.0, &mv_x_min, &mv_x_max,
  267.   
  268. &mv_y_min, &mv_y_max, 0);
  269. RangeInSearchArea (i,j,0, prev_x, prev_y, vop_width, vop_height,
  270. br_x, br_y, edge,f_code, &mv_x_min, &mv_x_max,
  271.   
  272. &mv_y_min, &mv_y_max,&out);
  274. if(!out)
  275. {
  276. int_mv_x_min=(int)ceil((double)mv_x_min);
  277. int_mv_y_min=(int)ceil((double)mv_y_min);
  278. int_mv_x_max=(int)floor((double)mv_x_max);
  279. int_mv_y_max=(int)floor((double)mv_y_max);
  280. flags[0]=ARE_EQUAL(int_mv_x_min,mv_x_min);
  281. flags[1]=ARE_EQUAL(int_mv_x_max,mv_x_max);
  282. flags[2]=ARE_EQUAL(int_mv_y_min,mv_y_min);
  283. flags[3]=ARE_EQUAL(int_mv_y_max,mv_y_max);
  284. sad_min=MV_MAX_ERROR;
  285. mv_x = mv_y = 2000;   
  286. #ifdef _FULL_SEARCH_   
  287. for (y=int_mv_y_min; y<=int_mv_y_max; y++)
  288. for (x=int_mv_x_min; x<=int_mv_x_max; x++)
  289. {
  290. if (x==0 && y==0)
  291. sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+rel_ori_x,
  292. y_curr+rel_ori_y), act_block, 
  293. (vop_width), MV_MAX_ERROR)
  294. - (128 + 1);
  295. else
  296. sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+x+rel_ori_x,
  297. y_curr+y+rel_ori_y), act_block, 
  298. (vop_width), sad_min);
  299. if (sad<sad_min)
  300. {
  301. sad_min=sad;
  302. mv_x=x;
  303. mv_y=y;
  304. }
  305. else if (sad==sad_min)
  306. if((ABS(x)+ABS(y)) < (ABS(mv_x)+ABS(mv_y)))
  307. {
  308. sad_min=sad;
  309. mv_x=x;
  310. mv_y=y;
  311. }
  312. }   
  313. #else   
  314. sad = SAD_Macroblock(prev+INDEX_BIG(x_curr+rel_ori_x,
  315. y_curr+rel_ori_y), act_block, (vop_width), MV_MAX_ERROR)
  316. - (128 + 1);
  317. if (sad<sad_min)
  318. {
  319. sad_min=sad;
  320. mv_x = mv_y = 0;
  321. }
  322. do
  323. {
  324. check_pts=total_check_pts;
  325. do
  326. {
  327. check_pt_x = diamond[d_type].point[pt_nmbr].x + d_centre_x;
  328. check_pt_y = diamond[d_type].point[pt_nmbr].y + d_centre_y;
  330. 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)
  331. {
  332. sad = MV_MAX_ERROR;
  333. }
  334. else
  335. {
  336. sad=SAD_Macroblock(prev+INDEX_BIG(x_curr+check_pt_x+rel_ori_x,
  337. y_curr+check_pt_y+rel_ori_y), act_block, 
  338. (vop_width), sad_min);
  339. #ifdef _SAD_EXHAUS_
  340. fprintf(stdout,"+o+ [%2d,%2d] sad16(%3d,%3d)=%4dn",i,j,x,y,sad);
  341. #endif
  342. }
  343. if (sad<sad_min)
  344. {
  345. sad_min=sad;
  346. mv_x=check_pt_x;
  347. mv_y=check_pt_y;
  348. mot_dirn=pt_nmbr;
  349. }
  350. else if (sad==sad_min)
  351. if((ABS(check_pt_x)+ABS(check_pt_y)) < (ABS(mv_x)+ABS(mv_y)))
  352. {
  353. sad_min=sad;
  354. mv_x=check_pt_x;
  355. mv_y=check_pt_y;
  356. mot_dirn=pt_nmbr;
  357. }
  358. pt_nmbr+=1;
  359. if((pt_nmbr)>= 8) pt_nmbr-=8;
  360. check_pts-=1;
  361. }
  362. while(check_pts>0);
  363. if( d_type == 0)
  364. {
  365. stop_flag = 1;
  366. }
  367. else
  368. {
  369. if( (mv_x == d_centre_x) && (mv_y == d_centre_y) )
  370. {
  371. d_type=0;
  372. pt_nmbr=0;
  373. total_check_pts = 4;
  374. }
  375. else
  376. {
  377. if((mv_x==d_centre_x) ||(mv_y==d_centre_y))
  378. total_check_pts=5;
  379. else
  380. total_check_pts=3;
  381. pt_nmbr=diamond[d_type].point[mot_dirn].start_nmbr;
  382. d_centre_x = mv_x;
  383. d_centre_y = mv_y;
  384. }
  385. }
  386. }
  387. while(stop_flag!=1);
  388. #endif
  389. flags[0]=flags[0] && (mv_x==int_mv_x_min);
  390. flags[1]=flags[1] && (mv_x==int_mv_x_max);
  391. flags[2]=flags[2] && (mv_y==int_mv_y_min);
  392. flags[3]=flags[3] && (mv_y==int_mv_y_max);
  393. }
  394. else
  395. {
  396. mv_x=mv_y=0;
  397. sad_min=MV_MAX_ERROR;
  398. }
  400. out |=((mv_x==2000)||(mv_y==2000));
  401. if(out)
  402. {
  403. mv_x=mv_y=0;
  404. sad_min=MV_MAX_ERROR;
  405. }
  406. pos16=2*j*2*mvm_width + 2*i;
  407. mv16_w[pos16]=   mv_x; mv16_h[pos16]=   mv_y;
  408. mv16_w[pos16+1]= mv_x; mv16_h[pos16+1]= mv_y;
  409. pos16+=2*mvm_width;
  410. mv16_w[pos16]=   mv_x; mv16_h[pos16]=   mv_y;
  411. mv16_w[pos16+1]= mv_x; mv16_h[pos16+1]= mv_y;
  412. min_error16 = sad_min;
  413. *min_error = min_error16;
  415. if(enable_8x8_mv==1)
  416. {
  417. if(!out)
  418. {
  419. for (block=0;block<4;block++)
  420. {
  422. if(block==0)
  423. {
  424. hb=vb=0;
  425. }
  426. else if (block==1)
  427. {
  428. hb=1;vb=0;
  429. }
  430. else if (block==2)
  431. {
  432. hb=0;vb=1;
  433. }
  434. else
  435. {
  436. hb=vb=1;
  437. }
  439. pmv_x=mv16_w[pos16]; pmv_y=mv16_h[pos16];
  440.   
  441. Obtain_Range(f_code, sr, MBM_INTER8,
  442. pmv_x, pmv_y, &mv_x_min,
  443.   
  444. &mv_x_max, &mv_y_min, &mv_y_max, 0 );
  445. RangeInSearchArea(i,j, block+1, prev_x, prev_y,
  446. vop_width, vop_height, br_x, br_y, edge,f_code,
  447.   
  448. &mv_x_min, &mv_x_max, &mv_y_min,&mv_y_max,&out);
  449. if(!out)
  450. {
  451. int_mv_x_min=(int)ceil((double)mv_x_min);
  452. int_mv_y_min=(int)ceil((double)mv_y_min);
  453. int_mv_x_max=(int)floor((double)mv_x_max);
  454. int_mv_y_max=(int)floor((double)mv_y_max);
  455. flags[4+block*4]=ARE_EQUAL(int_mv_x_min,mv_x_min);
  456. flags[4+block*4+1]=ARE_EQUAL(int_mv_x_max,mv_x_max);
  457. flags[4+block*4+2]=ARE_EQUAL(int_mv_y_min,mv_y_min);
  458. flags[4+block*4+3]=ARE_EQUAL(int_mv_y_max,mv_y_max);
  459. sad_min=MV_MAX_ERROR;
  460. mv_x = mv_y = 2000;   
  461. for (y=int_mv_y_min; y<=int_mv_y_max; y++)
  462. for (x=int_mv_x_min; x<=int_mv_x_max; x++)
  463. {
  464. sad=SAD_Block(prev+
  465. INDEX_BIG(x_curr + x + 8*(block==1||block==3)+rel_ori_x,
  466. y_curr + y + 8*(block==2||block==3)+rel_ori_y),
  467. act_block+INDEX_NOR(8*(block==1||block==3),
  468. 8*(block==2||block==3)),
  469. (vop_width ), sad_min);
  470. if (sad<sad_min)
  471. {
  472. sad_min=sad;
  473. mv_x=x;
  474. mv_y=y;
  475. }
  476. else if (sad==sad_min)
  477. if((ABS(x)+ABS(y)) < (ABS(mv_x)+ABS(mv_y)))
  478. {
  479. sad_min=sad;
  480. mv_x=x;
  481. mv_y=y;
  482. }
  483. }   
  484. flags[4+block*4]   = flags[4+block*4]   && (mv_x==int_mv_x_min);
  485. flags[4+block*4+1] = flags[4+block*4+1] && (mv_x==int_mv_x_max);
  486. flags[4+block*4+2] = flags[4+block*4+2] && (mv_y==int_mv_y_min);
  487. flags[4+block*4+3] = flags[4+block*4+3] && (mv_y==int_mv_y_max);
  488. }
  489. else
  490. {
  491. mv_x=mv_y=0;
  492. sad_min=MV_MAX_ERROR;
  494. }
  496. if(block==0)
  497. {
  498. pos8=2*j*2*mvm_width + 2*i;
  499. min_error8 += sad_min;
  500. }
  501. else if (block==1)
  502. {
  503. pos8=2*j*2*mvm_width + 2*i+1;
  504. min_error8 += sad_min;
  505. }
  506. else if (block==2)
  507. {
  508. pos8=(2*j+1)*2*mvm_width + 2*i;
  509. min_error8 += sad_min;
  510. }
  511. else
  512. {
  513. pos8=(2*j+1)*2*mvm_width + 2*i+1;
  514. min_error8 += sad_min;
  515. }
  517. mv8_w[pos8]=mv_x;
  518. mv8_h[pos8]=mv_y;
  519. }   
  520. if (min_error8 < *min_error)
  521. *min_error = min_error8;
  522. }
  523. else
  524. {   
  525. pos8=2*j*2*mvm_width + 2*i;      mv8_w[pos8]=mv8_h[pos8]=0.0;
  526. pos8=2*j*2*mvm_width + 2*i+1;    mv8_w[pos8]=mv8_h[pos8]=0.0;
  527. pos8=(2*j+1)*2*mvm_width + 2*i;  mv8_w[pos8]=mv8_h[pos8]=0.0;
  528. pos8=(2*j+1)*2*mvm_width + 2*i+1;mv8_w[pos8]=mv8_h[pos8]=0.0;
  529. min_error8 = MV_MAX_ERROR;
  530. }
  531. }   
  532. }
  533. Void
  534. FindSubPel(
  535. Int    x,   
  536. Int    y,   
  537. SInt   *prev,                                     
  538. SInt   *curr,                                      
  539. Int    bs_x,                 
  540. Int    bs_y,   
  541. Int    comp,   
  542. Int    rel_x,   
  543. Int    rel_y,   
  544. Int    pels,   
  545. Int    lines,   
  546. Int    edge,   
  547. SInt   *flags,   
  548. SInt   *curr_comp_mb,                             
  549. Float  *mvx,   
  550. Float  *mvy,   
  551. Int    *min_error   
  552. )
  553. {
  554. static PixPoint search[9] = 
  555. {
  556. {0, 0}, {-1, -1}, {0, -1}, {1, -1},
  557. {-1, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}
  558. };
  560. Int i, m, n;
  561. Int new_x, new_y,
  562. lx, size_x;   
  563. Int min_pos;
  564. Int AE, AE_min;
  565. Int flag_pos;
  566. SInt *pRef, *pComp;
  567. int flag_search[9] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
  568. Int SubDimension = 2;
  569. lx = 2*(pels );
  570. new_x = (Int)((x + *mvx + rel_x)*(SubDimension));
  571. new_y = (Int)((y + *mvy + rel_y)*(SubDimension));
  572. new_x += ((comp&1)<<3)*SubDimension;
  573. new_y += ((comp&2)<<2)*SubDimension;
  574. size_x=16;
  580. if (bs_x==8)   
  581. flag_pos=4+comp*4;
  582. else   
  583. flag_pos=0;
  584. if (((new_x/SubDimension) <= 0) || *(flags+flag_pos)) {
  585. flag_search[1] = flag_search[4] = flag_search[6] = 0;
  586. } else if  (((new_x/SubDimension) >= (pels - bs_x )) || *(flags+flag_pos+1)) {
  587. flag_search[3] = flag_search[5] = flag_search[8] = 0;
  588. };
  589. if (((new_y/SubDimension) <= 0) || *(flags+flag_pos+2)) {
  590. flag_search[1] = flag_search[2] = flag_search[3] = 0;
  591. } else if  (((new_y/SubDimension) >= (lines- bs_y )) || *(flags+flag_pos+3)) {
  592. flag_search[6] = flag_search[7] = flag_search[8] = 0;
  593. };
  594. AE_min = MV_MAX_ERROR;
  595. min_pos = 0;
  596. for (i = 0; i < 9; i++)
  597. {
  598. if (flag_search[i])
  599. {
  600. AE = 0;
  602. pRef = prev + new_x + search[i].x + (new_y + search[i].y) * lx;
  603. pComp = curr;
  604. n = bs_y;
  605. while (n--) {
  606. m = bs_x;
  607. while (m--) {
  608. AE += abs((Int)*pRef - (Int)*pComp);
  609. pRef += 2;
  610. pComp ++;
  611. }
  612. pRef += 2 * lx - 2 * bs_x;
  613. pComp += size_x - bs_x;
  614. }
  615. if (i==0 && bs_y==16 && *mvx==0 && *mvy==0)
  616. AE -= (128 + 1);
  617. if (AE < AE_min)
  618. {
  619. AE_min = AE;
  620. min_pos = i;
  621. }
  622. }
  624. }
  626. *min_error = AE_min;
  627. *mvx += ((Float)search[min_pos].x)/(Float)(SubDimension);
  628. *mvy += ((Float)search[min_pos].y)/(Float)(SubDimension);
  630. pRef = prev + new_x + search[min_pos].x + (new_y + search[min_pos].y) * lx;
  631. pComp = curr_comp_mb;
  632. n = bs_y;
  633. while (n--) {
  634. m = bs_x;
  635. while (m--) {
  636. *(pComp ++) = *pRef;
  637. pRef += 2;
  638. }
  639. pRef += 2 * lx - 2 * bs_x;
  640. pComp += 16 - bs_x;
  641. }
  642. return;
  643. }