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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
mbcoding.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：12k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mbcoding.c：源码内容
  1. #include <stdlib.h>
  2. #include "../portab.h"
  3. #include "bitstream.h"
  4. #include "zigzag.h"
  5. #include "vlc_codes.h"
  6. #include "mbcoding.h"
  8. #include "../utils/mbfunctions.h"
  10. #define ABS(X) (((X)>0)?(X):-(X))
  11. #define CLIP(X,A) (X > A) ? (A) : (X)
  13. VLC intra_table[65536]; 
  14. VLC inter_table[65536];
  16. VLC DCT3Dintra[4096];
  17. VLC DCT3Dinter[4096];
  19. static int16_t clip_table[4096];
  21. void init_vlc_tables(void)
  22. {
  24. int32_t k, l, i, intra, last;
  25. VLC *vlc[2];
  26. VLC **coeff_ptr;
  27. VLC *vlc1, *vlc2;
  29. vlc1 = DCT3Dintra;
  30. vlc2 = DCT3Dinter;
  32. vlc[0] = intra_table;
  33. vlc[1] = inter_table;
  35. // initialize the clipping table
  36. for(i = -2048; i < 2048; i++) {
  37. clip_table[i + 2048] = i;
  38. if(i < -255)
  39. clip_table[i + 2048] = -255;
  40. if(i > 255)
  41. clip_table[i + 2048] = 255;
  42. }
  44. // generate encoding vlc lookup tables
  45. for(i = 0; i < 4; i++) {
  46. intra = i % 2;
  47. last = i / 2;
  49. coeff_ptr = coeff_vlc[last + 2 * intra];
  51. for(k = -255; k < 256; k++) { // level
  52. int8_t *max_level_ptr = max_level[last + 2 * intra];
  53. int8_t *max_run_ptr = max_run[last + 2 * intra];
  55. for(l = 0; l < 64; l++) { // run
  56. int32_t level = k;
  57. uint32_t run = l;
  59. if((abs(level) <= max_level_ptr[run]) &&
  60.    (run <= max_run_ptr[abs(level)])) { // level < max_level and run < max_run
  61.    
  62. vlc[intra]->code = 0;
  63. vlc[intra]->len = 0;
  64. goto loop_end;
  65. }
  66. else {
  67. if(level > 0)      // correct level
  68. level -= max_level_ptr[run];
  69. else
  70. level += max_level_ptr[run];
  72. if((abs(level) <= max_level_ptr[run]) &&
  73.    (run <= max_run_ptr[abs(level)])) {
  75. vlc[intra]->code = 0x06;
  76. vlc[intra]->len = 8;
  77. goto loop_end;
  78. }
  80. if(level > 0)     // still here?
  81. level += max_level_ptr[run];    // restore level
  82. else
  83. level -= max_level_ptr[run];
  85. run -= max_run_ptr[abs(level)] + 1; // and change run
  87. if((abs(level) <= max_level_ptr[run]) &&
  88.    (run <= max_run_ptr[abs(level)])) {
  90. vlc[intra]->code = 0x0e;
  91. vlc[intra]->len = 9;
  92. goto loop_end;
  93. }
  94. run += max_run_ptr[abs(level)] + 1;
  95. }
  97. vlc[intra]->code = (uint32_t) ((l << 14) | (0x1e + last) << 20) |
  98.   (1 << 13) | ((k & 0xfff) << 1) | 1;
  100. vlc[intra]->len = 30;
  101. vlc[intra]++;
  102. continue;
  104. loop_end:
  105. if(level != 0) {
  106. vlc[intra]->code = (vlc[intra]->code << (coeff_ptr[run][abs(level) - 1].len + 1)) |
  107.    (coeff_ptr[run][abs(level) - 1].code << 1);
  108. vlc[intra]->len = (coeff_ptr[run][abs(level) - 1].len + 1) + vlc[intra]->len;
  110. if(level < 0)
  111. vlc[intra]->code += 1;
  112. }
  114. vlc[intra]++;
  115. }
  116. }
  117. }
  119. for(i = 0; i < 4096; i++) {
  120. if(i >= 512) {
  121. *vlc1 = DCT3Dtab3[(i >> 5) - 16];
  122. *vlc2 = DCT3Dtab0[(i >> 5) - 16];
  123. }
  124. else if(i >= 128) {
  125. *vlc1 = DCT3Dtab4[(i >> 2) - 32];
  126. *vlc2 = DCT3Dtab1[(i >> 2) - 32];
  127. }
  128. else if(i >= 8) {
  129. *vlc1 = DCT3Dtab5[i - 8];
  130. *vlc2 = DCT3Dtab2[i - 8];
  131. }
  132. else {
  133. *vlc1 = ERRtab[i];
  134. *vlc2 = ERRtab[i];
  135. }
  137. vlc1++;
  138. vlc2++;
  139. }
  140. DCT3D[0] = DCT3Dinter;
  141. DCT3D[1] = DCT3Dintra;
  143. }
  145. static __inline void CodeVector(Bitstream *bs,
  146. int16_t value,
  147. int16_t f_code,
  148. Statistics *pStat)
  149. {
  151. const int scale_factor = 1 << (f_code - 1);
  152. const int cmp = scale_factor << 5;
  154. if(value < (-1 * cmp))
  155. value += 64 * scale_factor;
  157. if(value > (cmp - 1))
  158. value -= 64 * scale_factor;
  160. pStat->iMvSum += value * value;
  161. pStat->iMvCount++;
  163. if (value == 0) {
  164. BitstreamPutBits(bs, mb_motion_table[32].code, mb_motion_table[32].len);
  165. } else {
  166. uint16_t length, code, mv_res, sign;
  168. length = 16 << f_code;
  169. f_code--;
  171. sign = (value < 0);
  173. if(value >= length)
  174. value -= 2 * length;
  175. else if(value < -length)
  176. value += 2 * length;
  178. if(sign)
  179. value = -value;
  181. value--;
  182. mv_res = value & ((1 << f_code) - 1);
  183. code = ((value - mv_res) >> f_code) + 1;
  185. if(sign)
  186. code = -code;
  188. code += 32;
  189. BitstreamPutBits(bs, mb_motion_table[code].code, mb_motion_table[code].len);
  191. if(f_code)
  192. BitstreamPutBits(bs, mv_res, f_code);
  193. }
  195. }
  198. static __inline void CodeCoeff(Bitstream *bs,
  199.        int16_t qcoeff[64],
  200.        VLC *table,
  201.        const uint16_t *zigzag,
  202.        uint16_t intra)
  203. {
  205. uint32_t j, last;
  206. short v;
  207. VLC *vlc;
  209. j = intra;
  210. last = intra;
  212. while((v = qcoeff[zigzag[j]]) == 0) j++;
  213.     
  214. do {
  215. // count zeroes
  216. vlc = table + 64*255 + (clip_table[2048+v] << 6) + j - last;
  217. last = ++j;
  218. while(j < 64 && (v = qcoeff[zigzag[j]]) == 0) j++;
  220. // write code
  221. if(j != 64) {
  222. BitstreamPutBits(bs, vlc->code, vlc->len);
  223. } else {
  224. vlc += 64*511;
  225. BitstreamPutBits(bs, vlc->code, vlc->len);
  226. break;
  227. }
  228. } while(1);
  230. }
  233. static void CodeBlockIntra(const MBParam * pParam,
  234.    const MACROBLOCK *pMB,
  235.    int16_t qcoeff[6*64],
  236.    Bitstream * bs,
  237.    Statistics * pStat)
  238. {
  240. uint32_t i, mcbpc, cbpy, bits;
  242. cbpy = pMB->cbp >> 2;
  244. // write mcbpc
  245. if(pParam->coding_type == I_VOP) {
  246. mcbpc = ((pMB->mode >> 1) & 3) | ((pMB->cbp & 3) << 2);
  247. BitstreamPutBits(bs, mcbpc_intra_tab[mcbpc].code, mcbpc_intra_tab[mcbpc].len);
  248. }
  249. else {
  250. mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
  251. BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code, mcbpc_inter_tab[mcbpc].len);
  252. }
  254. // ac prediction flag
  255. if(pMB->acpred_directions[0])
  256. BitstreamPutBits(bs, 1, 1);
  257. else
  258. BitstreamPutBits(bs, 0, 1);
  260. // write cbpy
  261. BitstreamPutBits (bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
  263. // write dquant
  264. if(pMB->mode == MODE_INTRA_Q)
  265. BitstreamPutBits(bs, pMB->dquant, 2);
  267. // write interlacing
  268. if (pParam->global_flags & XVID_INTERLACING)
  269. {
  270. BitstreamPutBit(bs, pMB->field_dct);
  271. }
  273. // code block coeffs
  274. for(i = 0; i < 6; i++)
  275. {
  276. if(i < 4)
  277. BitstreamPutBits(bs,
  278.  dcy_tab[qcoeff[i*64 + 0] + 255].code,
  279.  dcy_tab[qcoeff[i*64 + 0] + 255].len);
  280. else
  281. BitstreamPutBits(bs,
  282.  dcc_tab[qcoeff[i*64 + 0] + 255].code,
  283.                  dcc_tab[qcoeff[i*64 + 0] + 255].len);
  285. if(pMB->cbp & (1 << (5 - i)))
  286. {
  287. bits = BitstreamPos(bs);
  289. CodeCoeff(bs,
  290.   &qcoeff[i*64],
  291.   intra_table,
  292.   scan_tables[pMB->acpred_directions[i]],
  293.   1);
  295. bits = BitstreamPos(bs) - bits;
  296. pStat->iTextBits += bits;
  297. }
  298. }
  300. }
  303. static void CodeBlockInter(const MBParam * pParam,
  304.    const MACROBLOCK *pMB,
  305.    int16_t qcoeff[6*64],
  306.    Bitstream * bs,
  307.    Statistics * pStat)
  308. {
  310. int32_t i;
  311. uint32_t bits, mcbpc, cbpy;
  313. mcbpc = (pMB->mode & 7) | ((pMB->cbp & 3) << 3);
  314. cbpy = 15 - (pMB->cbp >> 2);
  316. // write mcbpc
  317. BitstreamPutBits(bs, mcbpc_inter_tab[mcbpc].code, mcbpc_inter_tab[mcbpc].len);
  319. // write cbpy
  320. BitstreamPutBits(bs, cbpy_tab[cbpy].code, cbpy_tab[cbpy].len);
  322. // write dquant
  323. if(pMB->mode == MODE_INTER_Q)
  324. BitstreamPutBits(bs, pMB->dquant, 2);
  325.     
  326. // interlacing
  327. if (pParam->global_flags & XVID_INTERLACING)
  328. {
  329. BitstreamPutBit(bs, pMB->field_dct);
  330. DEBUG1("codep: field_dct: ", pMB->field_dct);
  332. // if inter block, write field ME flag
  333. if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)
  334. {
  335. BitstreamPutBit(bs, pMB->field_pred);
  336. DEBUG1("codep: field_pred: ", pMB->field_pred);
  338. // write field prediction references
  339. if (pMB->field_pred)
  340. {
  341. BitstreamPutBit(bs, pMB->field_for_top);
  342. BitstreamPutBit(bs, pMB->field_for_bot);
  343. }
  344. }
  345. }
  347. // code motion vector(s)
  348. for(i = 0; i < (pMB->mode == MODE_INTER4V ? 4 : 1); i++)
  349. {
  350. CodeVector(bs, pMB->pmvs[i].x, pParam->fixed_code, pStat);
  351. CodeVector(bs, pMB->pmvs[i].y, pParam->fixed_code, pStat);
  352. }
  354. bits = BitstreamPos(bs);
  356. // code block coeffs
  357. for(i = 0; i < 6; i++)
  358. if(pMB->cbp & (1 << (5 - i)))
  359. CodeCoeff(bs, &qcoeff[i*64], inter_table, scan_tables[0], 0);
  361. bits = BitstreamPos(bs) - bits;
  362. pStat->iTextBits += bits;
  364. }
  367. void MBCoding(const MBParam * pParam,
  368.       MACROBLOCK *pMB,
  369.       int16_t qcoeff[6*64], 
  370.       Bitstream * bs,
  371.       Statistics * pStat)
  372. {
  374. int intra = (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q);
  376. if(pParam->coding_type == P_VOP) {
  377. if(pMB->cbp == 0 && pMB->mode == MODE_INTER &&
  378.    pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0)
  379. {
  380. BitstreamPutBit(bs, 1); // not_coded
  381. return;
  382. }
  383. else
  384. BitstreamPutBit(bs, 0); // coded
  385. }
  387. if(intra)
  388. CodeBlockIntra(pParam, pMB, qcoeff, bs, pStat);
  389. else
  390. CodeBlockInter(pParam, pMB, qcoeff, bs, pStat);
  392. }
  395. /***************************************************************
  396.  * decoding stuff starts here                                  *
  397.  ***************************************************************/
  399. int get_mcbpc_intra(Bitstream * bs)
  400. {
  402. uint32_t index;
  404. while((index = BitstreamShowBits(bs, 9)) == 1)
  405. BitstreamSkip(bs, 9);
  407. index >>= 3;
  409. BitstreamSkip(bs, mcbpc_intra_table[index].len);
  411. return mcbpc_intra_table[index].code;
  413. }
  415. int get_mcbpc_inter(Bitstream * bs)
  416. {
  418. uint32_t index;
  420. while((index = CLIP(BitstreamShowBits(bs, 9), 256)) == 1)
  421. BitstreamSkip(bs, 9);
  423. BitstreamSkip(bs,  mcbpc_inter_table[index].len);
  425. return mcbpc_inter_table[index].code;
  427. }
  429. int get_cbpy(Bitstream * bs, int intra)
  430. {
  432. int cbpy;
  433. uint32_t index = BitstreamShowBits(bs, 6);
  435. BitstreamSkip(bs, cbpy_table[index].len);
  436. cbpy = cbpy_table[index].code;
  438. if(!intra)
  439. cbpy = 15 - cbpy;
  441. return cbpy;
  443. }
  445. int get_mv_data(Bitstream * bs)
  446. {
  448. uint32_t index;
  450. if(BitstreamGetBit(bs))
  451. return 0;
  453. index = BitstreamShowBits(bs, 12);
  455. if(index >= 512)
  456. {
  457. index = (index >> 8) - 2;
  458. BitstreamSkip(bs, TMNMVtab0[index].len);
  459. return TMNMVtab0[index].code;
  460. }
  462. if(index >= 128)
  463. {
  464. index = (index >> 2) - 32;
  465. BitstreamSkip(bs, TMNMVtab1[index].len);
  466. return TMNMVtab1[index].code;
  467. }
  469. index -= 4; 
  471. BitstreamSkip(bs, TMNMVtab2[index].len);
  472. return TMNMVtab2[index].code;
  474. }
  476. int get_mv(Bitstream * bs, int fcode)
  477. {
  479. int data;
  480. int res;
  481. int mv;
  482. int scale_fac = 1 << (fcode - 1);
  484. data = get_mv_data(bs);
  486. if(scale_fac == 1 || data == 0)
  487. return data;
  489. res = BitstreamGetBits(bs, fcode - 1);
  490. mv = ((ABS(data) - 1) * scale_fac) + res + 1;
  492. return data < 0 ? -mv : mv;
  494. }
  496. int get_dc_dif(Bitstream * bs, uint32_t dc_size)
  497. {
  499. int code = BitstreamGetBits(bs, dc_size);
  500. int msb = code >> (dc_size - 1);
  502. if(msb == 0)
  503. return (-1 * (code^((1 << dc_size) - 1)));
  505. return code;
  507. }
  509. int get_dc_size_lum(Bitstream * bs)
  510. {
  512. int code, i;
  513. code = BitstreamShowBits(bs, 11);
  515. for(i = 11; i > 3; i--) {
  516. if(code == 1) {
  517. BitstreamSkip(bs, i);
  518. return i + 1;
  519. }
  520. code >>= 1;
  521. }
  523. BitstreamSkip(bs, dc_lum_tab[code].len);
  524. return dc_lum_tab[code].code;
  526. }
  529. int get_dc_size_chrom(Bitstream * bs)
  530. {
  532. uint32_t code, i;
  533. code = BitstreamShowBits(bs, 12);
  535. for(i = 12; i > 2; i--) {
  536. if(code == 1) {
  537. BitstreamSkip(bs, i);
  538. return i;
  539. }
  540. code >>= 1;
  541. }
  543. return 3 - BitstreamGetBits(bs, 2);
  545. }
  547. void get_intra_block(Bitstream * bs, int16_t * block, int direction, int coeff) 
  548. {
  550. const uint16_t * scan = scan_tables[ direction ];
  551. int level;
  552. int run;
  553. int last;
  555. do
  556. {
  557. level = get_coeff(bs, &run, &last, 1, 0);
  558. if (run == -1)
  559. {
  560. DEBUG("fatal: invalid run");
  561. break;
  562. }
  563. coeff += run;
  564. block[ scan[coeff] ] = level;
  565. if (level < -127 || level > 127)
  566. {
  567. DEBUG1("warning: intra_overflow", level);
  568. }
  569. coeff++;
  570. } while (!last);
  572. }
  574. void get_inter_block(Bitstream * bs, int16_t * block) 
  575. {
  577. const uint16_t * scan = scan_tables[0];
  578. int p;
  579. int level;
  580. int run;
  581. int last;
  583. p = 0;
  584. do
  585. {
  586. level = get_coeff(bs, &run, &last, 0, 0);
  587. if (run == -1)
  588. {
  589. DEBUG("fatal: invalid run");
  590. break;
  591. }
  592. p += run;
  593. block[ scan[p] ] = level;
  594. if (level < -127 || level > 127)
  595. {
  596. DEBUG1("warning: inter_overflow", level);
  597. }
  598. p++;
  599. } while (!last);
  601. }