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

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

VC书籍

开发平台：

Visual C++

text_bits.c：源码内容
  1. #include "momusys.h"
  2. #include "text_defs.h"
  3. #include "bitstream.h"
  4. #include "text_bits.h"
  5. #include "putvlc.h"
  6. #include "zigzag.h"   
  7. #include "max_level.h"   
  8. Int   IntraDC_dpcm (Int val, Int lum, Image *bitstream);
  9. Int   CodeCoeff (Int j_start, Int Mode, Int qcoeff[],
  10. Int block, Int ncoeffs, Image *bitstream);
  11. Int   CodeCoeff_RVLC (Int j_start, Int Mode, Int qcoeff[],
  12. Int block, Int ncoeffs, Image *bitstream);
  13. Void MB_CodeCoeff(Bits* bits, Int *qcoeff,
  14. Int Mode, Int CBP, Int ncoeffs,
  15. Int intra_dcpred_disable,
  16. Image *DCbitstream,
  17. Image *bitstream,
  18. Int transp_pattern[], Int direction[],
  19. Int error_res_disable,
  20. Int reverse_vlc,
  21. Int switched,
  22. Int alternate_scan)
  23. {
  24. Int i, m, coeff[64];
  25. Int *zz = alternate_scan ? zigzag_v : zigzag;
  26. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  27. {
  28. if (intra_dcpred_disable == 0)
  29. {
  30. for (i = 0; i < 6; i++)
  31. {
  32. {
  33. if (!alternate_scan)
  34. {
  35. switch (direction[i])
  36. {
  37. case 1: zz = zigzag_v; break;
  38. case 2: zz = zigzag_h; break;
  39. case 0: break;
  40. default: fprintf(stderr, "MB_CodeCoeff(): Error in zigzag directionn");
  41. exit(-1);
  42. }
  43. }
  45. for (m = 0; m < 64; m++)
  46. {
  47. *(coeff + zz[m]) = qcoeff[i*ncoeffs+m];
  48. }
  49. if (switched==0)
  50. {
  51. if (error_res_disable)
  52. {
  53. if (i < 4)
  54. bits->Y += IntraDC_dpcm(coeff[0],1,bitstream);
  55. else
  56. bits->C += IntraDC_dpcm(coeff[0],0,bitstream);
  57. }
  58. else
  59. {
  60. if (i < 4)
  61. bits->Y += IntraDC_dpcm(coeff[0],1,DCbitstream);
  62. else
  63. bits->C += IntraDC_dpcm(coeff[0],0,DCbitstream);
  64. }
  65. }
  67. if ((i==0 && CBP&32) ||
  68. (i==1 && CBP&16) ||
  69. (i==2 && CBP&8)  ||
  70. (i==3 && CBP&4)  ||
  71. (i==4 && CBP&2)  ||
  72. (i==5 && CBP&1))
  73. {
  74. if (error_res_disable || ((!error_res_disable) && (!reverse_vlc)))
  75. {
  76. if (i < 4)
  77. bits->Y += CodeCoeff(1-switched,Mode, coeff,i,ncoeffs,bitstream);
  78. else
  79. bits->C += CodeCoeff(1-switched,Mode, coeff,i,ncoeffs,
  80. bitstream);
  81. }
  82. else
  83. {
  84. if (i < 4)
  85. bits->Y += CodeCoeff_RVLC(1-switched,Mode, coeff, i,
  86. ncoeffs, bitstream);
  87. else
  88. bits->C += CodeCoeff_RVLC(1-switched,Mode, coeff, i,
  89. ncoeffs, bitstream);
  90. }
  91. }
  92. }
  93. }
  94. }
  95. else   
  96. {
  97. for (i = 0; i < 6; i++)
  98. {
  99. {
  101. for (m = 0; m < 64; m++)
  102. *(coeff + zz[m]) = qcoeff[i*ncoeffs+m];
  103. if (switched==0)
  104. {
  105. if (error_res_disable)
  106. {
  107. if (coeff[0] != 128)
  108. BitstreamPutBits(bitstream,(long)(coeff[0]),8L);
  109. else
  110. BitstreamPutBits(bitstream, 255L, 8L);
  111. }
  112. else
  113. {
  114. if (coeff[0] != 128)
  115. BitstreamPutBits(DCbitstream,(long)(coeff[0]),8L);
  116. else
  117. BitstreamPutBits(DCbitstream,255L, 8L);
  118. }
  119. if (i < 4)
  120. bits->Y += 8;
  121. else
  122. bits->C += 8;
  123. }
  124. if ((i==0 && CBP&32) || (i==1 && CBP&16) ||
  125. (i==2 && CBP&8) || (i==3 && CBP&4) ||
  126. (i==4 && CBP&2) || (i==5 && CBP&1))
  127. {
  129. if (error_res_disable || ((!error_res_disable) && (!reverse_vlc)))
  130. {
  131. if (i < 4)
  132. bits->Y += CodeCoeff(1-switched,Mode, coeff,i,ncoeffs,
  133. bitstream);
  134. else
  135. bits->C += CodeCoeff(1-switched,Mode, coeff,i,ncoeffs,
  136. bitstream);
  137. }
  138. else
  139. {
  140. if (i < 4)
  141. bits->Y += CodeCoeff_RVLC(1-switched,Mode, coeff, i,
  142. ncoeffs, bitstream);
  143. else
  144. bits->C += CodeCoeff_RVLC(1-switched,Mode, coeff, i,
  145. ncoeffs, bitstream);
  146. }
  147. }
  148. }
  149. }
  150. }
  151. }
  152. else   
  153. {
  154. for (i = 0; i < 6; i++)
  155. {
  157. for (m = 0; m < 64; m++)
  158. *(coeff + zz[m]) = qcoeff[i*ncoeffs+m];
  159. if ((i==0 && CBP&32) ||
  160. (i==1 && CBP&16) ||
  161. (i==2 && CBP&8) ||
  162. (i==3 && CBP&4) ||
  163. (i==4 && CBP&2) ||
  164. (i==5 && CBP&1))
  165. {
  166. if (error_res_disable || ((!error_res_disable) && (!reverse_vlc)))
  167. {
  168. if (i < 4)
  169. bits->Y += CodeCoeff(0,Mode, coeff, i, ncoeffs, bitstream);
  170. else
  171. bits->C += CodeCoeff(0,Mode, coeff, i, ncoeffs, bitstream);
  172. }
  173. else
  174. {
  175. if (i < 4)
  176. bits->Y += CodeCoeff_RVLC(0,Mode, coeff, i, ncoeffs,
  177. bitstream);
  178. else
  179. bits->C += CodeCoeff_RVLC(0,Mode, coeff, i, ncoeffs,
  180. bitstream);
  181. }
  182. }
  183. }
  184. }
  185. }
  186. Int
  187. IntraDC_dpcm(Int val, Int lum, Image *bitstream)
  188. {
  189. Int n_bits;
  190. Int absval, size = 0;
  191. absval = ( val <0)?-val:val;   
  193. size = 0;
  194. while(absval)
  195. {
  196. absval>>=1;
  197. size++;
  198. }
  199. if (lum)
  200. {   
  201. n_bits = PutDCsize_lum (size, bitstream);
  202. }
  203. else
  204. {   
  205. n_bits = PutDCsize_chrom (size, bitstream);
  206. }
  207. if ( size != 0 )
  208. {
  209. if (val>=0)
  210. {
  211. ;
  212. }
  213. else
  214. {
  215. absval = -val;   
  216. val = (absval ^( (int)pow(2.0,(double)size)-1) );
  217. }
  218. BitstreamPutBits(bitstream, (long)(val), (long)(size));
  219. n_bits += size;
  220. if (size > 8)
  221. BitstreamPutBits(bitstream, (long)1, (long)1);
  222. }
  223. return n_bits;   
  224. }
  225. Int CodeCoeff(Int j_start, Int Mode, Int qcoeff[], Int block, Int ncoeffs, Image *bitstream)
  226. {
  227. Int j, bits;
  228. Int prev_run, run, prev_level, level, first;
  229. Int prev_ind, ind, prev_s, s, length;
  230. run = bits = 0;
  231. first = 1;
  232. prev_run = prev_level = prev_ind = level = s = prev_s = ind = 0;
  233. for (j = j_start; j< ncoeffs; j++)
  234. {
  236. {
  239. s = 0;
  241. if ((level = qcoeff[j]) == 0)
  242. {
  243. run++;
  244. }
  245. else
  246. {
  248. if (level < 0)
  249. {
  250. s = 1;
  251. level = -level;
  252. }
  253. ind = level | run<<4;
  254. ind = ind | 0<<12;   
  255. if (!first)
  256. {
  258. if ((prev_run < 64) &&
  259. (((prev_level < 13) && (Mode != MODE_INTRA &&
  260. Mode != MODE_INTRA_Q))
  261. || ((prev_level < 28) && (Mode == MODE_INTRA ||
  262. Mode == MODE_INTRA_Q))))
  263. {
  265. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  266. {
  267. length = PutCoeff_Intra(prev_run, prev_level,
  268. 0, bitstream);
  269. }
  270. else
  271. {
  272. length = PutCoeff_Inter(prev_run, prev_level,
  273. 0, bitstream);
  274. }
  275. }
  276. else
  277. length = 0;
  279. if (length == 0)
  280. {
  281. if ( prev_run < 64 )
  282. {
  284. int level_minus_max;
  285. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  286. level_minus_max = prev_level -
  287. intra_max_level[0][prev_run];
  288. else
  289. level_minus_max = prev_level -
  290. inter_max_level[0][prev_run];
  291. if (  ( (level_minus_max < 13) && (Mode != MODE_INTRA && Mode != MODE_INTRA_Q) ) ||
  292. ( (level_minus_max < 28) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) ) )
  293. {
  295. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  296. {
  297. length = PutLevelCoeff_Intra(prev_run, level_minus_max, 0, bitstream);
  298. }
  299. else
  300. {
  301. length = PutLevelCoeff_Inter(prev_run, level_minus_max, 0, bitstream);
  302. }
  303. } else
  304. length = 0;
  305. }
  306. else length = 0;
  307. }
  309. if (length == 0)
  310. {
  311. if ( ((prev_level < 13) && (Mode != MODE_INTRA && Mode != MODE_INTRA_Q)) ||
  312. ((prev_level < 28) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)) )
  313. {
  315. int run_minus_max;
  316. if (prev_level == 0)
  317. {
  318. fprintf (stdout, "ERROR(CodeCoeff-second esc): level is %dn", prev_level);
  319. exit(-1);
  320. }
  321. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  322. run_minus_max = prev_run - (intra_max_run0[prev_level]+1);
  323. else
  324. run_minus_max = prev_run - (inter_max_run0[prev_level]+1);
  325.   
  326. if (run_minus_max < 64)
  327. {
  329. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  330. {
  331. length = PutRunCoeff_Intra(run_minus_max, prev_level, 0, bitstream);
  332. }
  333. else
  334. {
  335. length = PutRunCoeff_Inter(run_minus_max, prev_level, 0, bitstream);
  336. }
  337. } else
  338. length = 0;
  339. }
  340. else length = 0;
  341. }
  343. if (length == 0)
  344. {   
  345. if (prev_s == 1)
  346. {
  349. prev_level = (prev_level^0xfff)+1;
  350. }
  351. BitstreamPutBits(bitstream, 3L, 7L);
  352.   
  353. BitstreamPutBits(bitstream, 3L, 2L);
  354.   
  355. BitstreamPutBits(bitstream, 0L, 1L);
  356.   
  357. BitstreamPutBits(bitstream, (long)(prev_run), 6L);
  359. BitstreamPutBits(bitstream, MARKER_BIT, 1);
  363.   
  364. BitstreamPutBits(bitstream, (long)(prev_level), 12L);
  366. BitstreamPutBits(bitstream, MARKER_BIT, 1);
  368. bits += 30;
  369. }
  370. else
  371. {
  372. BitstreamPutBits(bitstream, (long)(prev_s), 1L);
  373. bits += length + 1;
  374. }
  375. }
  376. prev_run = run; prev_s = s;
  377. prev_level = level; prev_ind = ind;
  378. run = first = 0;
  379. }
  380. }
  381. }
  383. if (!first)
  384. {
  385. prev_ind = prev_ind | 1<<12;   
  386. if ((prev_run < 64) &&
  387. (((prev_level < 4) && (Mode != MODE_INTRA &&
  388. Mode != MODE_INTRA_Q))
  389. || ((prev_level < 9) && ((Mode == MODE_INTRA) ||
  390. (Mode == MODE_INTRA_Q)))))
  391. {
  393. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  394. {
  395. length = PutCoeff_Intra(prev_run, prev_level, 1,
  396. bitstream);
  397. }
  398. else
  399. {
  400. length = PutCoeff_Inter(prev_run, prev_level, 1,
  401. bitstream);
  402. }
  403. }
  404. else
  405. length = 0;
  407. if (length == 0)
  408. {
  409. if ( prev_run < 64 )
  410. {
  412. int level_minus_max;
  413. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  414. level_minus_max = prev_level - intra_max_level[1][prev_run];
  415. else
  416. level_minus_max = prev_level - inter_max_level[1][prev_run];
  417. if (  ( (level_minus_max < 4) && (Mode != MODE_INTRA && Mode != MODE_INTRA_Q) ) ||
  418. ( (level_minus_max < 9) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q) ) )
  419. {
  421. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  422. {
  423. length = PutLevelCoeff_Intra(prev_run, level_minus_max, 1, bitstream);
  424. }
  425. else
  426. {
  427. length = PutLevelCoeff_Inter(prev_run, level_minus_max, 1, bitstream);
  428. }
  429. } else
  430. length = 0;
  431. }
  432. else length = 0;
  433. }
  435. if (length == 0)
  436. {
  437. if (((prev_level < 4) && (Mode != MODE_INTRA && Mode != MODE_INTRA_Q))||
  438. ((prev_level < 9) && (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)) )
  439. {
  441. int run_minus_max;
  442. if (prev_level == 0)
  443. {
  444. fprintf (stdout, "ERROR(CodeCoeff-second esc): level is %dn", prev_level);
  445. exit(-1);
  446. }
  447. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  448. run_minus_max = prev_run - (intra_max_run1[prev_level]+1);
  449. else
  450. run_minus_max = prev_run - (inter_max_run1[prev_level]+1);
  451. if (run_minus_max < 64)   
  452. {
  454. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  455. {
  456. length = PutRunCoeff_Intra(run_minus_max, prev_level, 1, bitstream);
  457. }
  458. else
  459. {
  460. length = PutRunCoeff_Inter(run_minus_max, prev_level, 1, bitstream);
  461. }
  462. } else
  463. length = 0;
  464. }
  465. else length = 0;
  466. }
  468. if (length == 0)
  469. {   
  470. if (prev_s == 1)
  471. {
  474. prev_level = (prev_level^0xfff)+1;
  475. }
  476. BitstreamPutBits(bitstream, 3L, 7L);
  477. BitstreamPutBits(bitstream, 3L, 2L);  
  478. BitstreamPutBits(bitstream, 1L, 1L);  
  479. BitstreamPutBits(bitstream, (long)(prev_run), 6L);
  481. BitstreamPutBits(bitstream, MARKER_BIT, 1);
  485.   
  486. BitstreamPutBits(bitstream, (long)(prev_level), 12L);
  488. BitstreamPutBits(bitstream, MARKER_BIT, 1);
  490. bits += 30;
  491. }
  492. else
  493. {
  494. BitstreamPutBits(bitstream, (long)(prev_s), 1L);
  495. bits += length + 1;
  496. }
  497. }
  498. return bits;
  499. }
  500. Int CodeCoeff_RVLC(Int j_start, Int Mode, Int qcoeff[], Int block, Int ncoeffs, Image *bitstream)
  501. {
  502. Int j, bits;
  503. Int prev_run, run, prev_level, level, first;
  504. Int prev_ind, ind, prev_s, s, length;
  505. run = bits = 0;
  506. first = 1;
  507. prev_run = prev_level = prev_ind = level = s = prev_s = ind = 0;
  508. for (j = j_start; j< ncoeffs; j++)
  509. {
  511. {
  514. s = 0;
  516. if ((level = qcoeff[j]) == 0)
  517. {
  518. run++;
  519. }
  520. else
  521. {
  523. if (level < 0)
  524. {
  525. s = 1;
  526. level = -level;
  527. }
  528. ind = level | run<<4;
  529. ind = ind | 0<<12;   
  530. if (!first)
  531. {
  533. if (prev_level  < 28 && prev_run < 39)
  535. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  536. {
  537. length = PutCoeff_Intra_RVLC(prev_run, prev_level, 0,
  538. bitstream);
  539. }
  540. else
  541. {
  542. length = PutCoeff_Inter_RVLC(prev_run, prev_level, 0,
  543. bitstream);
  544. }
  545. else
  546. length = 0;
  547. if (length == 0)
  548. {   
  549.   
  550. BitstreamPutBits(bitstream, 1L, 5L);
  551.   
  552. BitstreamPutBits(bitstream, 0L, 1L);
  553. BitstreamPutBits(bitstream,
  554. (long)(prev_run), 6L);
  559. BitstreamPutBits( bitstream, MARKER_BIT, 1 );
  560.   
  561. BitstreamPutBits( bitstream, (long)(prev_level), 11L);
  562. BitstreamPutBits( bitstream, MARKER_BIT, 1 );
  563.   
  564. BitstreamPutBits(bitstream, 0L, 4L);
  565.   
  566. BitstreamPutBits(bitstream,
  567. (long)(prev_s),1L);
  568. bits += 5 + 1 + 6 + 1 + 11 + 1 + 4 + 1;
  570. }
  571. else
  572. {
  573. BitstreamPutBits(bitstream,
  574. (long)(prev_s), 1L);
  575. bits += length + 1;
  576. }
  577. }
  578. prev_run = run; prev_s = s;
  579. prev_level = level; prev_ind = ind;
  580. run = first = 0;
  581. }
  582. }
  583. }
  585. if (!first)
  586. {
  587. prev_ind = prev_ind | 1<<12;   
  588. if (prev_level  < 5 && prev_run < 45)
  590. if (Mode == MODE_INTRA || Mode == MODE_INTRA_Q)
  591. {
  592. length = PutCoeff_Intra_RVLC(prev_run, prev_level, 1,
  593. bitstream);
  594. }
  595. else
  596. {
  597. length = PutCoeff_Inter_RVLC(prev_run, prev_level, 1,
  598. bitstream);
  599. }
  600. else
  601. length = 0;
  602. if (length == 0)
  603. {   
  604. BitstreamPutBits(bitstream, 1L, 5L);  
  605. BitstreamPutBits(bitstream, 1L, 1L);  
  606.   
  607. BitstreamPutBits(bitstream, (long)(prev_run), 6L);
  611. BitstreamPutBits( bitstream, MARKER_BIT, 1 );
  612.   
  613. BitstreamPutBits( bitstream, (long)(prev_level), 11L);
  614. BitstreamPutBits( bitstream, MARKER_BIT, 1 );
  615. BitstreamPutBits(bitstream, 0L, 4L);  
  616.   
  617. BitstreamPutBits(bitstream, (long)(prev_s), 1L);
  618. bits += 24;
  619. }
  620. else
  621. {
  622. BitstreamPutBits(bitstream, (long)(prev_s), 1L);
  623. bits += length + 1;
  624. }
  625. }
  626. return bits;
  627. }
  628. void
  629. Bits_Reset (Bits *bits)
  630. {
  631. memset(bits, 0, sizeof(Bits));
  632. }