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

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

VC书籍

开发平台：

Visual C++

mp4_block.c：源码内容
  3. #include <math.h>
  4. #include <stdlib.h>
  5. #include <assert.h>
  7. #include "mp4_vars.h"
  9. #include "getbits.h"
  10. #include "clearblock.h"
  11. #include "mp4_iquant.h"
  12. #include "mp4_predict.h"
  13. #include "mp4_vld.h"
  14. #include "debug.h"
  15. #include "mp4_block.h"
  17. /**
  18.  *
  19. **/
  21. static int getDCsizeLum();
  22. static int getDCsizeChr();
  23. static int getDCdiff();
  24. static void setDCscaler(int block_num);
  26. static int getACdir();
  28. /***/
  31. int block(int block_num, int coded)
  32. {
  33. int i;
  34. int dct_dc_size, dct_dc_diff;
  35. int intraFlag = ((mp4_state->hdr.derived_mb_type == INTRA) || 
  36. (mp4_state->hdr.derived_mb_type == INTRA_Q)) ? 1 : 0;
  37. event_t event;
  39. clearblock(ld->block); 
  41. if (intraFlag)
  42. {
  43. setDCscaler(block_num); 
  45. if (block_num < 4) {
  46. dct_dc_size = getDCsizeLum();
  47. if (dct_dc_size != 0) 
  48. dct_dc_diff = getDCdiff(dct_dc_size);
  49. else 
  50. dct_dc_diff = 0;
  51. if (dct_dc_size > 8)
  52. getbits1(); 
  53. }
  54. else {
  55. dct_dc_size = getDCsizeChr();
  56. if (dct_dc_size != 0)
  57. dct_dc_diff = getDCdiff(dct_dc_size);
  58. else 
  59. dct_dc_diff = 0;
  60. if (dct_dc_size > 8)
  61. getbits1(); 
  62. }
  64. ld->block[0] = (short) dct_dc_diff;
  66. }
  67. if (intraFlag)
  68. {
  70. dc_recon(block_num, &ld->block[0]);
  71. }
  73. if (coded) 
  74. {
  75. unsigned int * zigzag;
  77. if ((intraFlag) && (mp4_state->hdr.ac_pred_flag == 1)) {
  79. if (mp4_state->coeff_pred.predict_dir == TOP)
  80. zigzag = mp4_tables->alternate_horizontal_scan;
  81. else
  82. zigzag = mp4_tables->alternate_vertical_scan;
  83. }
  84. else {
  85. zigzag = mp4_tables->zig_zag_scan;
  86. }
  88. i = intraFlag ? 1 : 0;
  89. do 
  90. {
  91. event = vld_event(intraFlag);
  93. i+= event.run;
  94. ld->block[zigzag[i]] = (short) event.level;
  96. i++;
  97. } while (! event.last);
  98. }
  100. if (intraFlag)
  101. {
  102. ac_recon(block_num, &ld->block[0]);
  103. }
  105. #ifdef _DEBUG_B_ACDC
  106. if (intraFlag)
  107. {
  108. int i;
  109. _Print("After AcDcRecon:n");
  110. _Print("   x ");
  111. for (i = 1; i < 64; i++) {
  112. if ((i != 0) && ((i % 8) == 0))
  113. _Print("n");
  114. _Print("%4d ", ld->block[i]);
  115. }
  116. _Print("n");
  117. }
  118. #endif // _DEBUG_ACDC
  120. if (mp4_state->hdr.quant_type == 0)
  121. {
  123. iquant(ld->block, intraFlag);
  124. }
  125. else 
  126. {
  127. _Error("Error: MPEG-2 inverse quantization NOT implementedn");
  128. exit(110);
  129. }
  131. #ifdef _DEBUG_B_QUANT
  132. {
  133. int i;
  134. _Print("After IQuant:n");
  135. _Print("   x ");
  136. for (i = 1; i < 64; i++) {
  137. if ((i != 0) && ((i % 8) == 0))
  138. _Print("n");
  139. _Print("%4d ", ld->block[i]);
  140. }
  141. _Print("n");
  142. }
  143. #endif 
  145. idct(ld->block);
  147. return 1;
  148. }
  150. /***/
  152. int blockIntra(int block_num, int coded)
  153. {
  154. int i;
  155. int dct_dc_size, dct_dc_diff;
  156. event_t event;
  158. clearblock(ld->block); 
  160. setDCscaler(block_num); 
  162. if (block_num < 4) {
  163. dct_dc_size = getDCsizeLum();
  164. if (dct_dc_size != 0) 
  165. dct_dc_diff = getDCdiff(dct_dc_size);
  166. else 
  167. dct_dc_diff = 0;
  168. if (dct_dc_size > 8)
  169. getbits1(); 
  170. }
  171. else {
  172. dct_dc_size = getDCsizeChr();
  173. if (dct_dc_size != 0)
  174. dct_dc_diff = getDCdiff(dct_dc_size);
  175. else 
  176. dct_dc_diff = 0;
  177. if (dct_dc_size > 8)
  178. getbits1(); 
  179. }
  181. ld->block[0] = (short) dct_dc_diff;
  183. dc_recon(block_num, &ld->block[0]);
  185. if (coded) 
  186. {
  187. unsigned int * zigzag; 
  189. if (mp4_state->hdr.ac_pred_flag == 1) {
  191. if (mp4_state->coeff_pred.predict_dir == TOP)
  192. zigzag = mp4_tables->alternate_horizontal_scan;
  193. else
  194. zigzag = mp4_tables->alternate_vertical_scan;
  195. }
  196. else {
  197. zigzag = mp4_tables->zig_zag_scan;
  198. }
  200. i = 1;
  201. do 
  202. {
  203. event = vld_intra_dct();
  205. i+= event.run;
  206. ld->block[zigzag[i]] = (short) event.level;
  208. i++;
  209. } while (! event.last);
  210. }
  212. mp4_state->hdr.intrablock_rescaled = ac_rescaling(block_num, &ld->block[0]);
  213. if (! mp4_state->hdr.intrablock_rescaled)
  214. {
  215. ac_recon(block_num, &ld->block[0]);
  216. }
  217. ac_store(block_num, &ld->block[0]);
  219. if (mp4_state->hdr.quant_type == 0)
  220. {
  221. iquant(ld->block, 1);
  222. }
  223. else 
  224. {
  225. iquant_typefirst(ld->block);
  226. }
  228. idct(ld->block);
  230. return 1;
  231. }
  233. /***/
  235. int blockInter(int block_num, int coded)
  236. {
  237. event_t event;
  238. unsigned int * zigzag = mp4_tables->zig_zag_scan; // zigzag scan dir
  239. int i;
  241. clearblock(ld->block); 
  243. if (mp4_state->hdr.quant_type == 0) 
  244. {
  245. int q_scale = mp4_state->hdr.quantizer;
  246. int q_2scale = q_scale << 1;
  247. int q_add = (q_scale & 1) ? q_scale : (q_scale - 1);
  249. i = 0;
  250. do 
  251. {
  252. event = vld_inter_dct();
  254. i+= event.run;
  255. if (event.level > 0) {
  256. ld->block[zigzag[i]] = (q_2scale * event.level) + q_add;
  257. }
  258. else {
  259. ld->block[zigzag[i]] = (q_2scale * event.level) - q_add;
  260. }
  263. i++;
  264. } while (! event.last);
  265. }
  266. else 
  267. {
  268. int k, m = 0;
  269. i = 0;
  271. do 
  272. {
  273. event = vld_inter_dct();
  275. i+= event.run;
  277. k = (event.level > 0) ? 1 : -1;
  279. assert(ld->block[zigzag[i]] < 2047);
  280. assert(ld->block[zigzag[i]] > -2048);
  282. ld->block[zigzag[i]] = ((2 * event.level + k) * mp4_state->hdr.quantizer * 
  283. mp4_tables->nonintra_quant_matrix[zigzag[i]]) >> 4;
  285. assert(ld->block[zigzag[i]] < 2047);
  286. assert(ld->block[zigzag[i]] > -2048);
  288. m ^= ld->block[zigzag[i]];
  291. i++;
  292. } while (! event.last);
  294. if (!(m%2)) ld->block[63] ^= 1;
  295. }
  297. idct(ld->block);
  299. return 1;
  300. }
  304. static int getDCsizeLum()
  305. {
  306. int code;
  309. if (showbits(11) == 1) {
  310. flushbits(11);
  311. return 12;
  312. }
  313.   if (showbits(10) == 1) {
  314.     flushbits(10);
  315.     return 11;
  316.   }
  317.   if (showbits(9) == 1) {
  318.     flushbits(9);
  319.     return 10;
  320. }
  321. if (showbits(8) == 1) {
  322. flushbits(8);
  323. return 9;
  324. }
  325. if (showbits(7) == 1) {
  326. flushbits(7);
  327. return 8;
  328. }
  329. if (showbits(6) == 1) {
  330. flushbits(6);
  331. return 7;
  332. }  
  333. if (showbits(5) == 1) {
  334. flushbits(5);
  335. return 6;
  336. }
  337. if (showbits(4) == 1) {
  338. flushbits(4);
  339. return 5;
  340. }
  342. code = showbits(3);
  344. if (code == 1) {
  345. flushbits(3);
  346. return 4;
  347. } else if (code == 2) {
  348. flushbits(3);
  349. return 3;
  350. } else if (code == 3) {
  351. flushbits(3);
  352. return 0;
  353. }
  355.   code = showbits(2);
  357.   if (code == 2) {
  358. flushbits(2);
  359. return 2;
  360. } else if (code == 3) {
  361. flushbits(2);
  362. return 1;
  363. }     
  365. return 0;
  366. }
  368. static int getDCsizeChr()
  369. {
  371. if (showbits(12) == 1) {
  372. flushbits(12);
  373. return 12;
  374. }
  375. if (showbits(11) == 1) {
  376. flushbits(11);
  377. return 11;
  378. }
  379. if (showbits(10) == 1) {
  380. flushbits(10);
  381. return 10;
  382. }
  383. if (showbits(9) == 1) {
  384. flushbits(9);
  385. return 9;
  386. }
  387. if (showbits(8) == 1) {
  388. flushbits(8);
  389. return 8;
  390. }
  391. if (showbits(7) == 1) {
  392. flushbits(7);
  393. return 7;
  394. }
  395. if (showbits(6) == 1) {
  396. flushbits(6);
  397. return 6;
  398. }
  399. if (showbits(5) == 1) {
  400. flushbits(5);
  401. return 5;
  402. }
  403. if (showbits(4) == 1) {
  404. flushbits(4);
  405. return 4;
  406. } 
  407. if (showbits(3) == 1) {
  408. flushbits(3);
  409. return 3;
  410. } 
  412. return (3 - getbits(2));
  413. }
  417. static int getDCdiff(int dct_dc_size)
  418. {
  419. int code = getbits(dct_dc_size);
  420. int msb = code >> (dct_dc_size - 1);
  422. if (msb == 0) {
  423. return (-1 * (code^((int) pow(2.0,(double) dct_dc_size) - 1)));
  424. }
  425.   else { 
  426. return code;
  427. }
  428. }
  432. static void setDCscaler(int block_num) 
  433. {
  434. int type = (block_num < 4) ? 0 : 1;
  435. int quant = mp4_state->hdr.quantizer;
  437. if (type == 0) {
  438. if (quant > 0 && quant < 5) 
  439. mp4_state->hdr.dc_scaler = 8;
  440. else if (quant > 4 && quant < 9) 
  441. mp4_state->hdr.dc_scaler = (2 * quant);
  442. else if (quant > 8 && quant < 25) 
  443. mp4_state->hdr.dc_scaler = (quant + 8);
  444. else 
  445. mp4_state->hdr.dc_scaler = (2 * quant - 16);
  446. }
  447.   else {
  448. if (quant > 0 && quant < 5) 
  449. mp4_state->hdr.dc_scaler = 8;
  450. else if (quant > 4 && quant < 25) 
  451. mp4_state->hdr.dc_scaler = ((quant + 13) / 2);
  452. else 
  453. mp4_state->hdr.dc_scaler = (quant - 6);
  454. }
  455. }
  457. /***/