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

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

VC书籍

开发平台：

Visual C++

mot_est_comp.c：源码内容
  1. #include "vm_common_defs.h"
  2. #include "mom_util.h"
  3. #include "mot_util.h"
  4. #include "mot_est_mb.h"
  5. extern FILE *ftrace;
  6. static Int roundtab16[] = {0,0,0,1,1,1,1,1,1,1,1,1,1,1,2,2};
  7. Void   MotionEstCompPicture (
  8. SInt *curr,
  9. SInt *prev,
  10. SInt *prev_ipol_y,
  11. SInt *prev_ipol_u,
  12. SInt *prev_ipol_v,
  13. Int prev_x,
  14. Int prev_y,
  15. Int vop_width,
  16. Int vop_height,
  17. Int enable_8x8_mv,
  18. Int edge,
  19. Int sr_for,
  20. Int f_code,
  21. Int rounding_type,
  22. Int br_x,
  23. Int br_y,
  24. Int br_width,
  25. Int br_height,
  26. SInt *curr_comp_y,
  27. SInt *curr_comp_u,
  28. SInt *curr_comp_v,
  29. Float *mad,
  30. Float *mv16_w,
  31. Float *mv16_h,
  32. Float *mv8_w,
  33. Float *mv8_h,
  34. SInt *mode16
  35. );
  36. Void GetPred_Chroma (
  37. Int x_curr,
  38. Int y_curr,
  39. Int dx,
  40. Int dy,
  41. SInt *prev_u,
  42. SInt *prev_v,
  43. SInt *comp_u,
  44. SInt *comp_v,
  45. Int width,
  46. Int width_prev,
  47. Int prev_x_min,
  48. Int prev_y_min,
  49. Int prev_x_max,
  50. Int prev_y_max,
  51. Int rounding_control
  52. );
  53. Void
  54. MotionEstimationCompensation (
  55. Vop    *curr_vop,   
  56. Vop    *prev_rec_vop,   
  57. Int    enable_8x8_mv,   
  58. Int    edge,   
  59. Int    f_code,   
  60. Vop    *curr_comp_vop,   
  61. Float  *mad,   
  62. Image  **mot_x,   
  63. Image  **mot_y,   
  64. Image  **mode   
  65. )
  66. {
  67. Image   *pr_rec_y;   
  68. Image   *pi_y;   
  69. Image   *mode16;
  70. Image   *mv16_w;
  71. Image   *mv16_h;
  72. Image   *mv8_w;
  73. Image   *mv8_h;
  74. SInt    *prev_ipol_y,   
  75. *prev_orig_y;   
  76. Int     vop_width, vop_height;
  77. Int     br_x;
  78. Int     br_y;
  79. Int     br_height;
  80. Int     br_width;
  81. Int     mv_h, mv_w;
  83. br_y=curr_vop->ver_spat_ref;
  84. br_x=curr_vop->hor_spat_ref;
  85. br_height=curr_vop->height;
  86. br_width=curr_vop->width;
  87. mv_h=br_height/MB_SIZE;
  88. mv_w=br_width/MB_SIZE;
  90. vop_width=prev_rec_vop->width;
  91. vop_height=prev_rec_vop->height;
  93. pr_rec_y = prev_rec_vop->y_chan;
  94. prev_orig_y = (SInt*)GetImageData(pr_rec_y);
  95. pi_y = AllocImage (2*vop_width, 2*vop_height, SHORT_TYPE);
  96. InterpolateImage(pr_rec_y, pi_y, GetVopRoundingType(curr_vop));
  97. prev_ipol_y = (SInt*)GetImageData(pi_y);
  99. mode16=AllocImage (mv_w,mv_h,SHORT_TYPE);
  100. SetConstantImage (mode16,(Float)MBM_INTRA);
  102. mv16_w=AllocImage (mv_w*2,mv_h*2,FLOAT_TYPE);
  103. mv16_h=AllocImage (mv_w*2,mv_h*2,FLOAT_TYPE);
  104. mv8_w =AllocImage (mv_w*2,mv_h*2,FLOAT_TYPE);
  105. mv8_h =AllocImage (mv_w*2,mv_h*2,FLOAT_TYPE);
  106. SetConstantImage (mv16_h,+0.0);
  107. SetConstantImage (mv16_w,+0.0);
  108. SetConstantImage (mv8_h,+0.0);
  109. SetConstantImage (mv8_w,+0.0);
  110. SetConstantImage (curr_comp_vop->u_chan, 0);
  111. SetConstantImage (curr_comp_vop->v_chan, 0);
  113. MotionEstCompPicture(
  114. (SInt *)GetImageData(GetVopY(curr_vop)), 
  115. prev_orig_y,   
  116. prev_ipol_y,   
  117. (SInt*)GetImageData(prev_rec_vop->u_chan) + (vop_width/2) * (16/2) + (16/2),
  118. (SInt*)GetImageData(prev_rec_vop->v_chan) + (vop_width/2) * (16/2) + (16/2),
  119. prev_rec_vop->hor_spat_ref,
  120. prev_rec_vop->ver_spat_ref,
  121. vop_width,vop_height,
  122. enable_8x8_mv,
  123. edge,
  124. GetVopSearchRangeFor(curr_vop), 
  125. f_code,
  126. GetVopRoundingType(curr_vop),
  127. br_x,br_y,   
  128. br_width,br_height,   
  129. (SInt*)GetImageData(curr_comp_vop->y_chan),
  130. (SInt*)GetImageData(curr_comp_vop->u_chan),
  131. (SInt*)GetImageData(curr_comp_vop->v_chan),
  132. mad,
  133. (Float*)GetImageData(mv16_w),
  134. (Float*)GetImageData(mv16_h),
  135. (Float*)GetImageData(mv8_w),
  136. (Float*)GetImageData(mv8_h),
  137. (SInt*) GetImageData(mode16)
  138. );
  140. GetMotionImages(mv16_w, mv16_h, mv8_w, mv8_h, mode16, mot_x, mot_y, mode);
  142. FreeImage(mv16_w); FreeImage(mv16_h);
  143. FreeImage(mv8_w);  FreeImage(mv8_h);
  144. FreeImage(mode16);
  145. FreeImage(pi_y);
  146. }
  147. Void
  148. MotionEstCompPicture(
  149. SInt    *curr,   
  150. SInt    *prev,   
  151. SInt    *prev_ipol,   
  152. SInt    *prev_u,   
  153. SInt    *prev_v,   
  154. Int     prev_x,   
  155. Int     prev_y,   
  156. Int     vop_width,   
  157. Int     vop_height,   
  158. Int     enable_8x8_mv,   
  159. Int     edge,   
  160. Int sr_for,   
  161. Int     f_code,          /* <-- MV search range 1/2 or 1/4 pel: 1=32,2=64,...,7=2048*/
  162. Int rounding_type,   
  163. Int     br_x,   
  164. Int     br_y,   
  165. Int     br_width,   
  166. Int     br_height,   
  167. SInt *curr_comp_y,   
  168. SInt *curr_comp_u,   
  169. SInt *curr_comp_v,   
  170. Float *mad,   
  171. Float   *mv16_w,   
  172. Float   *mv16_h,   
  173. Float   *mv8_w,   
  174. Float   *mv8_h,   
  175. SInt    *mode16   
  176. )
  177. {
  178. Int i, j, k;
  179. SInt curr_mb[MB_SIZE][MB_SIZE];
  180. SInt curr_comp_mb_16[MB_SIZE][MB_SIZE];
  181. SInt curr_comp_mb_8[MB_SIZE][MB_SIZE];
  182. Int sad8 = MV_MAX_ERROR, sad16, sad;
  183. Int imas_w, imas_h, Mode;
  184. Int posmode, pos16, pos8;
  185. Int min_error16,
  186. min_error8_0, min_error8_1, min_error8_2, min_error8_3;
  188. SInt *halfpelflags;
  189. Float hint_mv_w, hint_mv_h;
  190. Int xsum,ysum,dx,dy;
  191. Int prev_x_min,prev_x_max,prev_y_min,prev_y_max;
  192. prev_x_min = 2 * prev_x + 2 * 16;
  193. prev_y_min = 2 * prev_y + 2 * 16;
  194. prev_x_max = prev_x_min + 2 * vop_width - 4 * 16;
  195. prev_y_max = prev_y_min + 2 * vop_height - 4 * 16; 
  196. imas_w=br_width/MB_SIZE;
  197. imas_h=br_height/MB_SIZE;
  199. halfpelflags=(SInt*)malloc(5*4*sizeof(SInt));
  201. sad = 0;
  202. for ( j=0; j< (br_height/MB_SIZE); j++)
  203. {
  204. hint_mv_w = hint_mv_h = 0.f;
  205. for ( i=0; i< (br_width/MB_SIZE); i++)
  206. {
  208. Int min_error;
  209. posmode =          j * imas_w +   i;
  210. pos16   = pos8 = 2*j*2*imas_w + 2*i;
  211. MBMotionEstimation(curr,
  212. prev, br_x, br_y,
  213. br_width, i, j, prev_x, prev_y,
  214. vop_width, vop_height, enable_8x8_mv, edge,
  215. f_code, sr_for, 
  216. hint_mv_w, hint_mv_h, 
  217. mv16_w, mv16_h,
  218. mv8_w, mv8_h, &min_error, halfpelflags);
  220. Mode = ChooseMode(curr, 
  221. i*MB_SIZE,j*MB_SIZE, min_error, br_width);
  222. hint_mv_w = mv16_w[pos16];
  223. hint_mv_h = mv16_h[pos16];
  224. LoadArea(curr, i*MB_SIZE, j*MB_SIZE, 16, 16, br_width, (SInt *)curr_mb);
  226. if ( Mode != 0)
  227. {
  228. FindSubPel (i*MB_SIZE,j*MB_SIZE, prev_ipol,
  229. &curr_mb[0][0], 16, 16 , 0,
  230. br_x-prev_x,br_y-prev_y,vop_width, vop_height,
  231. edge, halfpelflags, &curr_comp_mb_16[0][0],
  232. &mv16_w[pos16], &mv16_h[pos16], &min_error16);
  234. sad16 = min_error16;
  235. mode16[posmode] = MBM_INTER16;
  236. if (enable_8x8_mv)
  237. {
  238. xsum = 0; ysum = 0;
  239. FindSubPel(i*MB_SIZE, j*MB_SIZE, prev_ipol,
  240. &curr_mb[0][0], 8, 8 , 0,
  241. br_x-prev_x,br_y-prev_y, vop_width, vop_height,
  242. edge, halfpelflags, &curr_comp_mb_8[0][0],
  243. &mv8_w[pos8], &mv8_h[pos8], &min_error8_0);
  244. xsum += (Int)(2*(mv8_w[pos8]));
  245. ysum += (Int)(2*(mv8_h[pos8]));
  246. FindSubPel(i*MB_SIZE, j*MB_SIZE, prev_ipol,
  247. &curr_mb[0][8], 8, 8 , 1,
  248. br_x-prev_x,br_y-prev_y, vop_width,vop_height,
  249. edge, halfpelflags, &curr_comp_mb_8[0][8],
  250. &mv8_w[pos8+1], &mv8_h[pos8+1], &min_error8_1);
  251. xsum += (Int)(2*(mv8_w[pos8+1]));
  252. ysum += (Int)(2*(mv8_h[pos8+1]));
  253. pos8+=2*imas_w;
  254. FindSubPel(i*MB_SIZE, j*MB_SIZE, prev_ipol,
  255. &curr_mb[8][0], 8, 8 , 2,
  256. br_x-prev_x,br_y-prev_y, vop_width,vop_height,
  257. edge, halfpelflags, &curr_comp_mb_8[8][0], 
  258. &mv8_w[pos8], &mv8_h[pos8], &min_error8_2);
  259. xsum += (Int)(2*(mv8_w[pos8]));
  260. ysum += (Int)(2*(mv8_h[pos8]));
  261. FindSubPel(i*MB_SIZE, j*MB_SIZE, prev_ipol, 
  262. &curr_mb[8][8], 8, 8 , 3,
  263. br_x-prev_x,br_y-prev_y, vop_width,vop_height,
  264. edge, halfpelflags, &curr_comp_mb_8[8][8], 
  265. &mv8_w[pos8+1], &mv8_h[pos8+1], &min_error8_3);
  266. xsum += (Int)(2*(mv8_w[pos8+1]));
  267. ysum += (Int)(2*(mv8_h[pos8+1]));
  268. sad8 = min_error8_0+min_error8_1+min_error8_2+min_error8_3;
  270. if (sad8 < (sad16 -(128+1)))
  271. mode16[posmode] = MBM_INTER8;
  272. }   
  275. if ((mv16_w[pos16]==0.0) && (mv16_h[pos16]==0.0) && (mode16[posmode]==MBM_INTER16))
  276. sad16 += 128+1;
  278. if(mode16[posmode] == MBM_INTER8)
  279. {
  280. dx = SIGN (xsum) * (roundtab16[ABS (xsum) % 16] + (ABS (xsum) / 16) * 2);
  281. dy = SIGN (ysum) * (roundtab16[ABS (ysum) % 16] + (ABS (ysum) / 16) * 2);
  282. sad += sad8;
  283. }
  284. else 
  285. {
  286. dx = (Int)(2 * mv16_w[pos16]);
  287. dy = (Int)(2 * mv16_h[pos16]);
  288. dx = ( dx % 4 == 0 ? dx >> 1 : (dx>>1)|1 );
  289. dy = ( dy % 4 == 0 ? dy >> 1 : (dy>>1)|1 );
  290. sad += sad16;
  291. }
  292. GetPred_Chroma (i*MB_SIZE, j*MB_SIZE, dx, dy, 
  293. prev_u, prev_v, curr_comp_u, curr_comp_v,
  294. br_width, vop_width,
  295. prev_x_min/4,prev_y_min/4,prev_x_max/4,prev_y_max/4, rounding_type);
  296. }   
  297. else   
  298. {
  299. mode16[posmode] = MBM_INTRA;
  300. for (k = 0; k < MB_SIZE*MB_SIZE; k++) 
  301. {
  303. curr_comp_mb_16[k/MB_SIZE][k%MB_SIZE] = 0;
  305. sad += curr_mb[k/MB_SIZE][k%MB_SIZE];
  306. }
  307. }
  308. if (mode16[posmode] == MBM_INTER8)
  309. SetArea((SInt*)curr_comp_mb_8, i*MB_SIZE, j*MB_SIZE, 16, 16, br_width, curr_comp_y);
  310. else
  311. SetArea((SInt*)curr_comp_mb_16, i*MB_SIZE, j*MB_SIZE, 16, 16, br_width, curr_comp_y);
  312. }   
  313. }
  314. *mad = (float)sad/(br_width*br_height);
  315. free((Char*)halfpelflags);
  316. return;
  317. }
  318. #define unrestricted_MC_chro(x,y,npix,prev_x_min,prev_y_min,prev_x_max,prev_y_max) ((x)+(y)*(npix))
  319. Void GetPred_Chroma (
  320. Int x_curr,
  321. Int y_curr,
  322. Int dx,
  323. Int dy,
  324. SInt *prev_u,
  325. SInt *prev_v,
  326. SInt *comp_u,
  327. SInt *comp_v,
  328. Int width,
  329. Int width_prev,
  330. Int prev_x_min,
  331. Int prev_y_min,
  332. Int prev_x_max,
  333. Int prev_y_max,
  334. Int rounding_control)
  335. {
  336. Int m,n;
  337. Int x, y, ofx, ofy, lx;
  338. Int xint, yint;
  339. Int xh, yh;
  340. Int index1,index2,index3,index4;
  341. lx = width_prev/2;
  342. x = x_curr>>1;
  343. y = y_curr>>1;
  344. xint = dx>>1;
  345. xh = dx & 1;
  346. yint = dy>>1;
  347. yh = dy & 1;
  348. if (!xh && !yh)
  349. {
  350. for (n = 0; n < 8; n++)
  351. {
  352. for (m = 0; m < 8; m++)
  353. {
  354. ofx = x + xint + m;
  355. ofy = y + yint + n;
  356. index1 = unrestricted_MC_chro(ofx,ofy,lx,prev_x_min,
  357. prev_y_min,prev_x_max,prev_y_max);
  358. comp_u[(y+n)*width/2+x+m]
  359. = *(prev_u+index1);
  360. comp_v[(y+n)*width/2+x+m]
  361. = *(prev_v+index1);
  362. }
  363. }
  364. }
  365. else if (!xh && yh)
  366. {
  367. for (n = 0; n < 8; n++)
  368. {
  369. for (m = 0; m < 8; m++)
  370. {
  371. ofx = x + xint + m;
  372. ofy = y + yint + n;
  373. index1 =  unrestricted_MC_chro(ofx,ofy,lx,prev_x_min,
  374. prev_y_min,prev_x_max,prev_y_max);
  375. index2 =  unrestricted_MC_chro(ofx,ofy+yh,lx,prev_x_min,
  376. prev_y_min,prev_x_max,prev_y_max);
  377. comp_u[(y+n)*width/2+x+m]
  378. = (*(prev_u+index1) +
  379. *(prev_u+index2) + 1- rounding_control)>>1;
  380. comp_v[(y+n)*width/2+x+m]
  381. = (*(prev_v+index1) +
  382. *(prev_v+index2) + 1- rounding_control)>>1;
  383. }
  384. }
  385. }
  386. else if (xh && !yh)
  387. {
  388. for (n = 0; n < 8; n++)
  389. {
  390. for (m = 0; m < 8; m++)
  391. {
  392. ofx = x + xint + m;
  393. ofy = y + yint + n;
  394. index1 =  unrestricted_MC_chro(ofx,ofy,lx,prev_x_min,
  395. prev_y_min,prev_x_max,prev_y_max);
  396. index2 =  unrestricted_MC_chro(ofx+xh,ofy,lx,prev_x_min,
  397. prev_y_min,prev_x_max,prev_y_max);
  398. comp_u[(y+n)*width/2+x+m]
  399. = (*(prev_u+index1) +
  400. *(prev_u+index2) + 1- rounding_control)>>1;
  401. comp_v[(y+n)*width/2+x+m]
  402. = (*(prev_v+index1) +
  403. *(prev_v+index2) + 1- rounding_control)>>1;
  404. }
  405. }
  406. }
  407. else
  408. {   
  409. for (n = 0; n < 8; n++)
  410. {
  411. for (m = 0; m < 8; m++)
  412. {
  413. ofx = x + xint + m;
  414. ofy = y + yint + n;
  415. index1 =  unrestricted_MC_chro(ofx,ofy,lx,prev_x_min,
  416. prev_y_min,prev_x_max,prev_y_max);
  417. index2 =  unrestricted_MC_chro(ofx+xh,ofy,lx,prev_x_min,
  418. prev_y_min,prev_x_max,prev_y_max);
  419. index3 =  unrestricted_MC_chro(ofx,ofy+yh,lx,prev_x_min,
  420. prev_y_min,prev_x_max,prev_y_max);
  421. index4 =  unrestricted_MC_chro(ofx+xh,ofy+yh,lx,prev_x_min,
  422. prev_y_min,prev_x_max,prev_y_max);
  423. comp_u[(y+n)*width/2+x+m]
  424. = (*(prev_u+index1)+
  425. *(prev_u+index2)+
  426. *(prev_u+index3)+
  427. *(prev_u+index4)+
  428. 2- rounding_control)>>2;
  429. comp_v[(y+n)*width/2+x+m]
  430. = (*(prev_v+index1)+
  431. *(prev_v+index2)+
  432. *(prev_v+index3)+
  433. *(prev_v+index4)+
  434. 2- rounding_control)>>2;
  435. }
  436. }
  437. }
  438. return;
  439. }