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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
dec_cabac.c
资源名称：h264src.zip　[点击查看]
上传用户：sunbaby
上传日期：2013-05-31
资源大小：242k
文件大小：41k
源码类别：

mpeg/mp3

开发平台：

Visual C++

dec_cabac.c：源码内容
  1. /*****************************************************************************
  2. *
  3. *  T264 AVC CODEC
  4. *
  5. *  Copyright(C) 2004-2005 joylife <joylife_video@yahoo.com.cn>
  6. * 2004-2005 tricro <tricro@hotmail.com>
  7. *
  8. *  This program is free software ; you can redistribute it and/or modify
  9. *  it under the terms of the GNU General Public License as published by
  10. *  the Free Software Foundation ; either version 2 of the License, or
  11. *  (at your option) any later version.
  12. *
  13. *  This program is distributed in the hope that it will be useful,
  14. *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
  15. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. *  GNU General Public License for more details.
  17. *
  18. *  You should have received a copy of the GNU General Public License
  19. *  along with this program ; if not, write to the Free Software
  20. *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21. *
  22. ****************************************************************************/
  23. /*****************************************************************************
  24. * cabac.c: h264 encoder library
  25. *****************************************************************************
  26. * Copyright (C) 2003 Laurent Aimar
  27. *
  28. * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  29. *
  30. * This program is free software; you can redistribute it and/or modify
  31. * it under the terms of the GNU General Public License as published by
  32. * the Free Software Foundation; either version 2 of the License, or
  33. * (at your option) any later version.
  34. *
  35. * This program is distributed in the hope that it will be useful,
  36. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  37. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  38. * GNU General Public License for more details.
  39. *
  40. * You should have received a copy of the GNU General Public License
  41. * along with this program; if not, write to the Free Software
  42. * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  43. *****************************************************************************/
  45. /*Note: the CABAC routine is currently referenced from x264 temporarily, with adaptation to 
  46. *the data structure of T264. It should be modified further in the near future.
  47. *It's can support B slice, but now only the baseline options is tested
  48. */
  51. #include <stdlib.h>
  52. #include <stdio.h>
  53. #include <string.h>
  54. #include <assert.h>
  55. #include "T264.h"
  56. #include "cabac_engine.h"
  57. #include "inter.h"
  58. #include "utility.h"
  59. #include "inter_b.h"
  61. /* From ffmpeg
  62. */
  63. #define T264_SCAN8_SIZE (6*8)
  64. #define T264_SCAN8_0 (4+1*8)
  66. static const int T264_scan8[16+2*4] =
  67. {
  68. /* Luma */
  69. VEC_LUMA + 0, VEC_LUMA + 1, VEC_LUMA + 1*8 + 0, VEC_LUMA + 1*8 + 1,
  70. VEC_LUMA + 2, VEC_LUMA + 3, VEC_LUMA + 1*8 + 2, VEC_LUMA + 1*8 + 3,
  71. VEC_LUMA + 2*8 + 0, VEC_LUMA + 2*8 + 1, VEC_LUMA + 3*8 + 0, VEC_LUMA + 3*8 + 1,
  72. VEC_LUMA + 2*8 + 2, VEC_LUMA + 2*8 + 3, VEC_LUMA + 3*8 + 2, VEC_LUMA + 3*8 + 3,
  74. /* Cb */
  75. NNZ_CHROMA0 + 0, NNZ_CHROMA0 + 1,
  76. NNZ_CHROMA0 + 1*8 + 0, NNZ_CHROMA0 + 1*8 + 1,
  78. /* Cr */
  79. NNZ_CHROMA1 + 0, NNZ_CHROMA1 + 1,
  80. NNZ_CHROMA1 + 1*8 + 0, NNZ_CHROMA1 + 1*8 + 1,
  81. };
  82. static const uint8_t block_idx_xy[4][4] =
  83. {
  84. { 0, 2, 8,  10},
  85. { 1, 3, 9,  11},
  86. { 4, 6, 12, 14},
  87. { 5, 7, 13, 15}
  88. };
  90. #define IS_INTRA(mode) (mode == I_4x4 || mode == I_16x16)
  91. #define IS_SKIP(type)  ( (type) == P_SKIP || (type) == B_SKIP )
  92. enum {
  93. INTRA_4x4           = 0,
  94. INTRA_16x16         = 1,
  95. INTRA_PCM           = 2,
  97. P_L0            = 3,
  98. P_8x81          = 4,
  99. P_SKIP1         = 5,
  101. B_DIRECT        = 6,
  102. B_L0_L0         = 7,
  103. B_L0_L1         = 8,
  104. B_L0_BI         = 9,
  105. B_L1_L0         = 10,
  106. B_L1_L1         = 11,
  107. B_L1_BI         = 12,
  108. B_BI_L0         = 13,
  109. B_BI_L1         = 14,
  110. B_BI_BI         = 15,
  111. B_8x81          = 16,
  112. B_SKIP1         = 17,
  113. };
  115. static const int T264_mb_type_list0_table[18][2] =
  116. {
  117. {0,0}, {0,0}, {0,0},    /* INTRA */
  118. {1,1},                  /* P_L0 */
  119. {0,0},                  /* P_8x8 */
  120. {1,1},                  /* P_SKIP */
  121. {0,0},                  /* B_DIRECT */
  122. {1,1}, {1,0}, {1,1},    /* B_L0_* */
  123. {0,1}, {0,0}, {0,1},    /* B_L1_* */
  124. {1,1}, {1,0}, {1,1},    /* B_BI_* */
  125. {0,0},                  /* B_8x8 */
  126. {0,0}                   /* B_SKIP */
  127. };
  128. static const int T264_mb_type_list1_table[18][2] =
  129. {
  130. {0,0}, {0,0}, {0,0},    /* INTRA */
  131. {0,0},                  /* P_L0 */
  132. {0,0},                  /* P_8x8 */
  133. {0,0},                  /* P_SKIP */
  134. {0,0},                  /* B_DIRECT */
  135. {0,0}, {0,1}, {0,1},    /* B_L0_* */
  136. {1,0}, {1,1}, {1,1},    /* B_L1_* */
  137. {1,0}, {1,1}, {1,1},    /* B_BI_* */
  138. {0,0},                  /* B_8x8 */
  139. {0,0}                   /* B_SKIP */
  140. };
  141. static const int T264_mb_partition_listX_table[][2] = 
  142. {
  143. {0, 0}, //B_DIRECT_8x8 = 100,
  144. {1, 0}, //B_L0_8x8,
  145. {0, 1}, //B_L1_8x8,
  146. {1, 1}, //B_Bi_8x8,
  147. {1, 0}, //B_L0_8x4,
  148. {1, 0}, //B_L0_4x8,
  149. {0, 1}, //B_L1_8x4,
  150. {0, 1}, //B_L1_4x8,
  151. {1, 1}, //B_Bi_8x4,
  152. {1, 1}, //B_Bi_4x8,
  153. {1, 0}, //B_L0_4x4,
  154. {0, 1}, //B_L1_4x4,
  155. {1, 1} //B_Bi_4x4
  156. };
  158. static const int T264_map_btype_mbpart[] = 
  159. {
  160. MB_8x8, //B_DIRECT_8x8 = 100,
  161. MB_8x8, //B_L0_8x8,
  162. MB_8x8, //B_L1_8x8,
  163. MB_8x8, //B_Bi_8x8,
  164. MB_8x4, //B_L0_8x4,
  165. MB_4x8, //B_L0_4x8,
  166. MB_8x4, //B_L1_8x4,
  167. MB_4x8, //B_L1_4x8,
  168. MB_8x4, //B_Bi_8x4,
  169. MB_4x8, //B_Bi_4x8,
  170. MB_4x4, //B_L0_4x4,
  171. MB_4x4, //B_L1_4x4,
  172. MB_4x4 //B_Bi_4x4
  173. };
  175. static void T264_cabac_mb_type( T264_t *t )
  176. {
  177. int act_sym, mode_sym, sym, sym1, sym2;
  178. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  179. int32_t mb_mode;
  181. if( t->slice_type == SLICE_I )
  182. {
  183. int ctx = 0;
  184. if( t->mb.mb_x > 0 && mb_ctxs[t->mb.mb_xy-1].mb_mode != I_4x4 )
  185. {
  186. ctx++;
  187. }
  188. if( t->mb.mb_y > 0 && mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode != I_4x4 )
  189. {
  190. ctx++;
  191. }
  193. act_sym = T264_cabac_decode_decision(&t->cabac, 3+ctx);
  194. if(act_sym == 0)
  195. {
  196. mb_mode = I_4x4;
  197. }
  198. else
  199. {
  200. mode_sym = T264_cabac_decode_terminal(&t->cabac);
  201. if(mode_sym == 0) /*I_16x16*/
  202. {
  203. mb_mode = I_16x16;
  204. t->mb.cbp_y = T264_cabac_decode_decision(&t->cabac, 3+3);
  205. sym = T264_cabac_decode_decision(&t->cabac, 3+4);
  206. if(sym == 0)
  207. {
  208. t->mb.cbp_c = 0;
  209. }
  210. else
  211. {
  212. sym = T264_cabac_decode_decision(&t->cabac, 3+5);
  213. t->mb.cbp_c = (sym==0)?1:2;
  214. }
  215. sym1 = T264_cabac_decode_decision(&t->cabac, 3+6);
  216. sym2 = T264_cabac_decode_decision(&t->cabac, 3+7);
  217. t->mb.mode_i16x16 = (sym1<<1)|sym2;
  218. }
  219. else
  220. {
  221. //I_PCM
  222. }
  223. }
  224. }
  225. else if( t->slice_type == SLICE_P )
  226. {
  227. /* prefix: 14, suffix: 17 */
  228. int ctx = 0;
  229. act_sym = T264_cabac_decode_decision(&t->cabac, 14);
  230. if(act_sym == 0)
  231. {
  232. //P_MODE
  233. static int mb_part_map[] = {MB_16x16, MB_8x8, MB_8x16, MB_16x8};
  234. mb_mode = P_MODE;
  235. sym1 = T264_cabac_decode_decision(&t->cabac, 15);
  236. ctx = (sym1==0)?16:17;
  237. sym2 = T264_cabac_decode_decision(&t->cabac, ctx);
  238. sym = (sym1<<1)|sym2;
  239. t->mb.mb_part = mb_part_map[sym];
  241. }
  242. else
  243. {
  244. mode_sym = T264_cabac_decode_decision(&t->cabac, 17);
  245. if(mode_sym == 0)
  246. {
  247. mb_mode = I_4x4;
  248. }
  249. else
  250. {
  251. sym = T264_cabac_decode_terminal(&t->cabac);
  252. if(sym == 0)
  253. {
  254. //I_16x16
  255. mb_mode = I_16x16;
  256. t->mb.cbp_y = T264_cabac_decode_decision(&t->cabac, 17+1);
  257. sym1 = T264_cabac_decode_decision(&t->cabac, 17+2);
  258. if(sym1 == 0)
  259. {
  260. t->mb.cbp_c = 0;
  261. }
  262. else
  263. {
  264. sym2 = T264_cabac_decode_decision(&t->cabac, 17+2);
  265. t->mb.cbp_c = (sym2==0)?1:2;
  266. }
  267. sym1 = T264_cabac_decode_decision(&t->cabac, 17+3);
  268. sym2 = T264_cabac_decode_decision(&t->cabac, 17+3);
  269. t->mb.mode_i16x16 = (sym1<<1)|sym2;
  270. }
  271. else
  272. {
  273. //I_PCM
  274. }
  275. }
  276. }
  277. }
  278. else if( t->slice_type == SLICE_B )
  279. {
  280. int ctx = 0;
  281. int idx;
  282. if( t->mb.mb_x > 0 && mb_ctxs[t->mb.mb_xy-1].mb_mode != B_SKIP && !mb_ctxs[t->mb.mb_xy-1].is_copy )
  283. {
  284. ctx++;
  285. }
  286. if( t->mb.mb_y > 0 && mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode != B_SKIP && ! mb_ctxs[t->mb.mb_xy - t->mb_stride].is_copy)
  287. {
  288. ctx++;
  289. }
  291. sym = T264_cabac_decode_decision(&t->cabac, 27+ctx);
  292. if(sym == 0)
  293. {
  294. t->mb.is_copy = 1;
  295. t->mb.mb_part = MB_16x16;
  296. mb_mode = B_MODE;
  297. }
  298. else
  299. {
  300. t->mb.is_copy = 0;
  301. sym1 = T264_cabac_decode_decision(&t->cabac, 27+3);
  302. if(sym1 == 0)
  303. {
  304. sym2 = T264_cabac_decode_decision(&t->cabac, 27+5);
  305. mb_mode = B_MODE;
  306. t->mb.mb_part = MB_16x16;
  307. t->mb.mb_part2[0] = (sym2==0)?B_L0_16x16:B_L1_16x16;
  308. }
  309. else
  310. {
  311. sym2 = T264_cabac_decode_decision(&t->cabac, 27+4);
  312. if(sym2 == 0)
  313. {
  314. static const int mb_bits_2_part0[] = {
  315. MB_16x16, MB_16x8, MB_8x16, MB_16x8, MB_8x16,
  316. MB_16x8, MB_8x16, MB_16x8
  317. };
  318. static const int mb_bits_2_part20[][2] = {
  319. {B_Bi_16x16, B_Bi_16x16}, 
  320. {B_L0_16x8, B_L0_16x8}, {B_L0_8x16, B_L0_8x16},
  321. {B_L1_16x8, B_L1_16x8}, {B_L1_8x16, B_L1_8x16},
  322. {B_L0_16x8, B_L1_16x8}, {B_L0_8x16, B_L1_8x16},
  323. {B_L1_16x8, B_L0_16x8}
  324. };
  325. sym = T264_cabac_decode_decision(&t->cabac, 27+5);
  326. idx = sym<<2;
  327. sym = T264_cabac_decode_decision(&t->cabac, 27+5);
  328. idx |= sym<<1;
  329. sym = T264_cabac_decode_decision(&t->cabac, 27+5);
  330. idx |= sym;
  331. mb_mode = B_MODE;
  332. t->mb.mb_part = mb_bits_2_part0[idx];
  333. t->mb.mb_part2[0] = mb_bits_2_part20[idx][0];
  334. t->mb.mb_part2[1] = mb_bits_2_part20[idx][1];
  335. }
  336. else
  337. {
  338. sym = T264_cabac_decode_decision(&t->cabac, 27+5);
  339. idx = sym<<2;
  340. sym = T264_cabac_decode_decision(&t->cabac, 27+5);
  341. idx |= sym<<1;
  342. sym = T264_cabac_decode_decision(&t->cabac, 27+5);
  343. idx |= sym;
  344. if(idx == 0x07)
  345. {
  346. mb_mode = B_MODE;
  347. t->mb.mb_part = MB_8x8;
  348. }
  349. else if(idx == 0x05)
  350. {
  351. sym = T264_cabac_decode_decision(&t->cabac, 32);
  352. if(sym == 0)
  353. {
  354. //I_4x4
  355. mb_mode = I_4x4;
  356. }
  357. else
  358. {
  359. sym = T264_cabac_decode_terminal(&t->cabac);
  360. if(sym == 0)
  361. {
  362. //I_16x16
  363. mb_mode = I_16x16;
  364. t->mb.cbp_y = T264_cabac_decode_decision(&t->cabac, 32+1);
  365. sym = T264_cabac_decode_decision(&t->cabac, 32+2);
  366. if(sym == 0)
  367. {
  368. t->mb.cbp_c = 0;
  369. }
  370. else 
  371. {
  372. sym = T264_cabac_decode_decision(&t->cabac, 32+2);
  373. t->mb.cbp_c = (sym==0)?1:2;
  374. }
  375. sym1 = T264_cabac_decode_decision(&t->cabac, 32+3);
  376. sym2 = T264_cabac_decode_decision(&t->cabac, 32+3);
  377. t->mb.mode_i16x16 = (sym1<<1)|sym2;
  378. }
  379. else
  380. {
  381. //I_PCM
  382. }
  383. }
  384. }
  385. else if(idx == 0x06)
  386. {
  387. mb_mode = B_MODE;
  388. t->mb.mb_part = MB_8x16;
  389. t->mb.mb_part2[0] = B_L1_8x16;
  390. t->mb.mb_part2[1] = B_L0_8x16;
  391. }
  392. else
  393. {
  394. static const int i_mb_bits[21][7] =
  395. {
  396. { 1, 0, 0, },            { 1, 1, 0, 0, 0, 1, },    { 1, 1, 0, 0, 1, 0, },   /* L0 L0 */
  397. { 1, 0, 1, },            { 1, 1, 0, 0, 1, 1, },    { 1, 1, 0, 1, 0, 0, },   /* L1 L1 */
  398. { 1, 1, 0, 0, 0, 0 ,},   { 1, 1, 1, 1, 0, 0 , 0 }, { 1, 1, 1, 1, 0, 0 , 1 },/* BI BI */
  400. { 1, 1, 0, 1, 0, 1, },   { 1, 1, 0, 1, 1, 0, },     /* L0 L1 */
  401. { 1, 1, 0, 1, 1, 1, },   { 1, 1, 1, 1, 1, 0, },     /* L1 L0 */
  402. { 1, 1, 1, 0, 0, 0, 0 }, { 1, 1, 1, 0, 0, 0, 1 },   /* L0 BI */
  403. { 1, 1, 1, 0, 0, 1, 0 }, { 1, 1, 1, 0, 0, 1, 1 },   /* L1 BI */
  404. { 1, 1, 1, 0, 1, 0, 0 }, { 1, 1, 1, 0, 1, 0, 1 },   /* BI L0 */
  405. { 1, 1, 1, 0, 1, 1, 0 }, { 1, 1, 1, 0, 1, 1, 1 }    /* BI L1 */
  406. };
  408. static const int mb_bits_2_part1[] = {
  409. MB_16x8, MB_8x16, MB_16x8, MB_8x16, 
  410. MB_16x8, MB_8x16, MB_16x8, MB_8x16,
  411. MB_16x8, MB_8x16, MB_16x8, MB_8x16,
  412. MB_16x8, MB_8x16, MB_16x8, MB_8x16
  413. };
  414. static const int mb_bits_2_part21[][2] = {
  415. {B_L0_16x8, B_Bi_16x8}, {B_L0_8x16, B_Bi_8x16},
  416. {B_L1_16x8, B_Bi_16x8}, {B_L1_8x16, B_Bi_8x16},
  417. {B_Bi_16x8, B_L0_16x8}, {B_Bi_8x16, B_L0_8x16},
  418. {B_Bi_16x8, B_L1_16x8}, {B_Bi_8x16, B_L1_8x16},
  419. {B_Bi_16x8, B_Bi_16x8}, {B_Bi_8x16, B_Bi_8x16},
  420. {B_L0_16x8, B_L0_16x8}, {B_L0_8x16, B_L0_8x16},
  421. {B_L0_16x8, B_L0_16x8}, {B_L0_8x16, B_L0_8x16},
  422. {B_L0_16x8, B_L0_16x8}, {B_L0_8x16, B_L0_8x16}
  423. };
  424. idx <<= 1;
  425. sym = T264_cabac_decode_decision(&t->cabac, 27+5);
  426. idx |= sym;
  427. mb_mode = B_MODE;
  428. t->mb.mb_part = mb_bits_2_part1[idx];
  429. t->mb.mb_part2[0] = mb_bits_2_part21[idx][0];
  430. t->mb.mb_part2[1] = mb_bits_2_part21[idx][1];
  431. }
  432. }
  433. }
  434. }
  435. }
  436. else
  437. {
  438. //dummy here
  439. mb_mode = t->mb.mb_mode;
  440. }
  441. t->mb.mb_mode = mb_mode;
  442. }
  444. static int T264_cabac_mb_intra4x4_pred_mode( T264_t *t, int i_pred)
  445. {
  446. int i_mode, sym;
  447. sym = T264_cabac_decode_decision(&t->cabac, 68);
  448. if(sym == 1)
  449. {
  450. i_mode = i_pred;
  451. }
  452. else
  453. {
  454. i_mode = T264_cabac_decode_decision(&t->cabac, 69);
  455. sym = T264_cabac_decode_decision(&t->cabac, 69);
  456. i_mode |= (sym<<1);
  457. sym = T264_cabac_decode_decision(&t->cabac, 69);
  458. i_mode |= (sym<<2);
  459. if(i_mode >= i_pred)
  460. i_mode ++;
  461. }
  462. return i_mode;
  463. }
  465. static void T264_cabac_mb_intra8x8_pred_mode( T264_t *t )
  466. {
  467. int i_mode, sym;
  468. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  470. int ctx = 0;
  471. if( t->mb.mb_x > 0 && mb_ctxs[t->mb.mb_xy-1].mb_mode_uv != Intra_8x8_DC)
  472. {
  473. ctx++;
  474. }
  475. if( t->mb.mb_y > 0 && mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode_uv != Intra_8x8_DC )
  476. {
  477. ctx++;
  478. }
  480. sym = T264_cabac_decode_decision(&t->cabac, 64+ctx);
  481. if(sym == 0)
  482. {
  483. i_mode = Intra_8x8_DC;
  484. }
  485. else
  486. {
  487. sym = T264_cabac_decode_decision(&t->cabac, 64+3);
  488. if(sym == 0)
  489. {
  490. i_mode = 1;
  491. }
  492. else
  493. {
  494. sym = T264_cabac_decode_decision(&t->cabac, 64+3);
  495. i_mode = (sym==0)?2:3;
  496. }
  497. }
  498. t->mb.mb_mode_uv = i_mode;
  499. }
  501. static void T264_cabac_mb_cbp_luma( T264_t *t )
  502. {
  503. /* TODO: clean up and optimize */
  504. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  505. int i8x8, sym, cbp_y, cbp_ya, cbp_yb;
  506. cbp_y = 0;
  507. for( i8x8 = 0; i8x8 < 4; i8x8++ )
  508. {
  509. int i_mba_xy = -1;
  510. int i_mbb_xy = -1;
  511. int x = luma_inverse_x[4*i8x8];
  512. int y = luma_inverse_y[4*i8x8];
  513. int ctx = 0;
  515. if( x > 0 )
  516. {
  517. i_mba_xy = t->mb.mb_xy;
  518. cbp_ya = cbp_y;
  519. }
  520. else if( t->mb.mb_x > 0 )
  521. {
  522. i_mba_xy = t->mb.mb_xy - 1;
  523. cbp_ya = mb_ctxs[i_mba_xy].cbp_y;
  524. }
  526. if( y > 0 )
  527. {
  528. i_mbb_xy = t->mb.mb_xy;
  529. cbp_yb = cbp_y;
  530. }
  531. else if( t->mb.mb_y > 0 )
  532. {
  533. i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  534. cbp_yb = mb_ctxs[i_mbb_xy].cbp_y;
  535. }
  537. /* No need to test for PCM and SKIP */
  538. if( i_mba_xy >= 0 )
  539. {
  540. const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
  541. if( ((cbp_ya >> i8x8a)&0x01) == 0 )
  542. {
  543. ctx++;
  544. }
  545. }
  547. if( i_mbb_xy >= 0 )
  548. {
  549. const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
  550. if( ((cbp_yb >> i8x8b)&0x01) == 0 )
  551. {
  552. ctx += 2;
  553. }
  554. }
  555. sym = T264_cabac_decode_decision(&t->cabac, 73+ctx);
  556. cbp_y |= (sym<<i8x8);
  557. }
  558. t->mb.cbp_y = cbp_y;
  559. }
  561. static void T264_cabac_mb_cbp_chroma( T264_t *t )
  562. {
  563. int cbp_a = -1;
  564. int cbp_b = -1;
  565. int ctx, sym;
  566. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  567. /* No need to test for SKIP/PCM */
  568. if( t->mb.mb_x > 0 )
  569. {
  570. cbp_a = (mb_ctxs[t->mb.mb_xy - 1].cbp_c)&0x3;
  571. }
  573. if( t->mb.mb_y > 0 )
  574. {
  575. cbp_b = (mb_ctxs[t->mb.mb_xy - t->mb_stride].cbp_c)&0x3;
  576. }
  578. ctx = 0;
  579. if( cbp_a > 0 ) ctx++;
  580. if( cbp_b > 0 ) ctx += 2;
  581. sym = T264_cabac_decode_decision(&t->cabac, 77+ctx);
  582. if(sym == 0)
  583. {
  584. t->mb.cbp_c = 0;
  585. }
  586. else
  587. {
  588. ctx = 4;
  589. if( cbp_a == 2 ) ctx++;
  590. if( cbp_b == 2 ) ctx += 2;
  591. sym = T264_cabac_decode_decision(&t->cabac, 77+ctx);
  592. t->mb.cbp_c = (sym==0)?1:2;
  593. }
  594. }
  596. /* TODO check it with != qp per mb */
  597. static void T264_cabac_mb_qp_delta( T264_t *t )
  598. {
  599. int i_mbn_xy = t->mb.mb_xy - 1;
  600. int i_dqp = t->mb.mb_qp_delta;
  601. int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
  602. int ctx;
  603. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  605. /* No need to test for PCM / SKIP */
  606. if( i_mbn_xy >= 0 && mb_ctxs[i_mbn_xy].mb_qp_delta != 0 &&
  607. ( mb_ctxs[i_mbn_xy].mb_mode == I_16x16 || mb_ctxs[i_mbn_xy].cbp_y || mb_ctxs[i_mbn_xy].cbp_c) )
  608. ctx = 1;
  609. else
  610. ctx = 0;
  612. val = 0;
  613. while(T264_cabac_decode_decision(&t->cabac, 60+ctx) != 0)
  614. {
  615. val ++;
  616. if(ctx < 2)
  617. ctx = 2;
  618. else
  619. ctx = 3;
  620. }
  621. t->mb.mb_qp_delta = ((val&0x01)==0)?(-(val>>1)):((val+1)>>1);
  622. }
  624. int T264_cabac_dec_mb_skip( T264_t *t)
  625. {
  626. int b_skip;
  627. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  628. int ctx = 0;
  630. if( t->mb.mb_x > 0 && !IS_SKIP( mb_ctxs[t->mb.mb_xy -1].mb_mode) )
  631. {
  632. ctx++;
  633. }
  634. if( t->mb.mb_y > 0 && !IS_SKIP( mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode) )
  635. {
  636. ctx++;
  637. }
  639. if( t->slice_type == SLICE_P )
  640. b_skip = T264_cabac_decode_decision(&t->cabac, 11+ctx);
  641. else /* SLICE_TYPE_B */
  642. b_skip = T264_cabac_decode_decision(&t->cabac, 24+ctx);
  643. return b_skip;
  644. }
  646. static __inline  int T264_cabac_mb_sub_p_partition( T264_t *t)
  647. {
  648. int i_sub, sym;
  649. sym = T264_cabac_decode_decision(&t->cabac, 21);
  650. if(sym == 1)
  651. {
  652. i_sub = MB_8x8;
  653. }
  654. else
  655. {
  656. sym = T264_cabac_decode_decision(&t->cabac, 22);
  657. if(sym == 0)
  658. {
  659. i_sub = MB_8x4;
  660. }
  661. else
  662. {
  663. sym = T264_cabac_decode_decision(&t->cabac, 23);
  664. i_sub = (sym==0)?MB_4x4:MB_4x8;
  665. }
  666. }
  667. return i_sub;
  668. }
  670. static __inline  int T264_cabac_mb_sub_b_partition( T264_t *t)
  671. {
  672. int i_sub, sym, sym1;
  673. sym = T264_cabac_decode_decision(&t->cabac, 36);
  674. if(sym == 0)
  675. {
  676. i_sub = B_DIRECT_8x8;
  677. }
  678. else
  679. {
  680. sym = T264_cabac_decode_decision(&t->cabac, 37);
  681. if(sym == 0)
  682. {
  683. sym1 = T264_cabac_decode_decision(&t->cabac, 39);
  684. i_sub = (sym1==0)?B_L0_8x8:B_L1_8x8;
  685. }
  686. else
  687. {
  688. int idx;
  689. sym = T264_cabac_decode_decision(&t->cabac, 38);
  690. if(sym == 0)
  691. {
  692. static const int idx_2_sub0[] = {B_Bi_8x8, B_L0_8x4, B_L0_4x8, B_L1_8x4};
  693. sym1 = T264_cabac_decode_decision(&t->cabac, 39);
  694. idx = sym1<<1;
  695. idx |= T264_cabac_decode_decision(&t->cabac, 39);
  696. i_sub = idx_2_sub0[idx];
  697. }
  698. else
  699. {
  700. sym = T264_cabac_decode_decision(&t->cabac, 39);
  701. if(sym == 0)
  702. {
  703. static const int idx_2_sub1[] = {B_L1_4x8, B_Bi_8x4, B_Bi_4x8, B_L0_4x4};
  704. sym1 = T264_cabac_decode_decision(&t->cabac, 39);
  705. idx = sym1<<1;
  706. idx |= T264_cabac_decode_decision(&t->cabac, 39);
  707. i_sub = idx_2_sub1[idx];
  708. }
  709. else
  710. {
  711. sym1 = T264_cabac_decode_decision(&t->cabac, 39);
  712. i_sub = (sym1==0)?B_L1_4x4:B_Bi_4x4;
  713. }
  714. }
  715. }
  716. }
  717. return i_sub;
  718. }
  721. static __inline  void T264_cabac_mb_ref( T264_t *t, int i_list, int idx, int width, int height, int i_ref_max )
  722. {
  723. int i8    = T264_scan8[idx];
  725. int i_ref, i, j;
  726. int luma_idx = luma_index[idx];
  727. if( i_ref_max <= 1 )
  728. {
  729. i_ref = 0;
  730. }
  731. else
  732. {
  733. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  734. const int i_refa = t->mb.vec_ref[i8 - 1].vec[i_list].refno;
  735. const int i_refb = t->mb.vec_ref[i8 - 8].vec[i_list].refno;
  736. int a_direct, b_direct;
  737. int ctx  = 0;
  738. if( t->slice_type==SLICE_B && t->mb.mb_x > 0 && (mb_ctxs[t->mb.mb_xy-1].mb_mode == B_SKIP||mb_ctxs[t->mb.mb_xy-1].is_copy ) && (luma_idx&0x03)==0)
  739. {
  740. a_direct = 1;
  741. }
  742. else
  743. a_direct = 0;
  744. if( t->slice_type==SLICE_B && t->mb.mb_y > 0 && (mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode == B_SKIP||mb_ctxs[t->mb.mb_xy - t->mb_stride].is_copy) && luma_idx<4)
  745. {
  746. b_direct = 1;
  747. }
  748. else
  749. b_direct = 0;
  751. if( i_refa>0 && !a_direct)
  752. ctx++;
  753. if( i_refb>0 && !b_direct)
  754. ctx += 2;
  755. i_ref = 0;
  756. while(T264_cabac_decode_decision(&t->cabac, 54+ctx) != 0)
  757. {
  758. i_ref ++;
  759. if(ctx < 4)
  760. ctx = 4;
  761. else
  762. ctx = 5;
  763. }
  764. }
  765. /* save ref value */
  766. for(j=0; j<height; j++)
  767. {
  768. for(i=0; i<width; i++)
  769. {
  770. t->mb.vec_ref[i8+i].vec[i_list].refno = i_ref;
  771. t->mb.vec[i_list][luma_idx+i].refno = i_ref;
  772. }
  773. i8 += 8;
  774. luma_idx += 4;
  775. }
  776. }
  779. static __inline  int  T264_cabac_mb_mvd_cpn( T264_t *t, int i_list, int i8, int l)
  780. {
  781. int i_abs, i_prefix, i_suffix;
  782. const int amvd = abs( t->mb.mvd_ref[i_list][i8 - 1][l] ) +
  783. abs( t->mb.mvd_ref[i_list][i8 - 8][l] );
  784. const int ctxbase = (l == 0 ? 40 : 47);
  786. int ctx;
  788. if( amvd < 3 )
  789. ctx = 0;
  790. else if( amvd > 32 )
  791. ctx = 2;
  792. else
  793. ctx = 1;
  795. i_prefix = 0;
  796. while(i_prefix<9 && T264_cabac_decode_decision(&t->cabac, ctxbase+ctx)!=0)
  797. {
  798. i_prefix ++;
  799. if(ctx < 3)
  800. ctx = 3;
  801. else if(ctx < 6)
  802. ctx ++;
  803. }
  804. if(i_prefix >= 9)
  805. {
  806. int k = 3;
  807. i_suffix = 0;
  808. while(T264_cabac_decode_bypass(&t->cabac) != 0)
  809. {
  810. i_suffix += 1<<k;
  811. k++;
  812. }
  813. while(k--)
  814. {
  815. i_suffix += T264_cabac_decode_bypass(&t->cabac)<<k;
  816. }
  817. i_abs = 9 + i_suffix; 
  818. }
  819. else
  820. i_abs = i_prefix;
  822. /* sign */
  823. if(i_abs != 0)
  824. {
  825. if(T264_cabac_decode_bypass(&t->cabac) != 0)
  826. i_abs = -i_abs;
  827. }
  828. return i_abs;
  829. }
  831. static __inline  void  T264_cabac_mb_mvd( T264_t *t, int i_list, int idx, int width, int height )
  832. {
  833. T264_vector_t mvp;
  834. int mdx, mdy, mvx, mvy;
  835. int i, j;
  836. int i8    = T264_scan8[idx];
  837. int luma_idx = luma_index[idx];
  838. /* Calculate mvd */
  840. mvp.refno = t->mb.vec_ref[i8].vec[i_list].refno;
  841. T264_predict_mv( t, i_list, luma_idx, width, &mvp );
  842. /* decode */
  843. mdx = T264_cabac_mb_mvd_cpn( t, i_list, i8, 0);
  844. mdy = T264_cabac_mb_mvd_cpn( t, i_list, i8, 1);
  845. /* save mvd value */
  846. mvx = mdx + mvp.x;
  847. mvy = mdy + mvp.y;
  848. for(j=0; j<height; j++)
  849. {
  850. for(i=0; i<width; i++)
  851. {
  852. t->mb.mvd_ref[i_list][i8+i][0] = mdx;
  853. t->mb.mvd_ref[i_list][i8+i][1] = mdy;
  854. t->mb.mvd[i_list][luma_idx+i][0] = mdx;
  855. t->mb.mvd[i_list][luma_idx+i][1] = mdy;
  856. t->mb.vec_ref[i8+i].vec[i_list].x = mvx;
  857. t->mb.vec_ref[i8+i].vec[i_list].y = mvy;
  858. t->mb.vec[i_list][luma_idx+i].x = mvx;
  859. t->mb.vec[i_list][luma_idx+i].y = mvy;
  860. }
  861. i8 += 8;
  862. luma_idx += 4;
  863. }
  864. }
  865. static __inline void T264_cabac_mb8x8_mvd( T264_t *t, int i_list )
  866. {
  867. int i;
  868. int sub_part, luma_idx;
  869. for( i = 0; i < 4; i++ )
  870. {
  871. luma_idx = luma_index[i<<2];
  872. sub_part = t->mb.submb_part[luma_idx];
  873. if( T264_mb_partition_listX_table[sub_part-B_DIRECT_8x8][i_list] == 0 )
  874. {
  875. continue;
  876. }
  878. switch( sub_part )
  879. {
  880. case B_L0_8x8:
  881. case B_L1_8x8:
  882. case B_Bi_8x8:
  883. T264_cabac_mb_mvd( t, i_list, 4*i, 2, 2 );
  884. break;
  885. case B_L0_8x4:
  886. case B_L1_8x4:
  887. case B_Bi_8x4:
  888. T264_cabac_mb_mvd( t, i_list, 4*i+0, 2, 1 );
  889. T264_cabac_mb_mvd( t, i_list, 4*i+2, 2, 1 );
  890. break;
  891. case B_L0_4x8:
  892. case B_L1_4x8:
  893. case B_Bi_4x8:
  894. T264_cabac_mb_mvd( t, i_list, 4*i+0, 1, 2 );
  895. T264_cabac_mb_mvd( t, i_list, 4*i+1, 1, 2 );
  896. break;
  897. case B_L0_4x4:
  898. case B_L1_4x4:
  899. case B_Bi_4x4:
  900. T264_cabac_mb_mvd( t, i_list, 4*i+0, 1, 1 );
  901. T264_cabac_mb_mvd( t, i_list, 4*i+1, 1, 1 );
  902. T264_cabac_mb_mvd( t, i_list, 4*i+2, 1, 1 );
  903. T264_cabac_mb_mvd( t, i_list, 4*i+3, 1, 1 );
  904. break;
  905. }
  906. }
  907. }
  908. static int T264_cabac_mb_cbf_ctxidxinc( T264_t *t, int i_cat, int i_idx )
  909. {
  910. /* TODO: clean up/optimize */
  911. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  912. T264_mb_context_t *mb_ctx;
  913. int i_mba_xy = -1;
  914. int i_mbb_xy = -1;
  915. int i_nza = -1;
  916. int i_nzb = -1;
  917. int ctx = 0;
  918. int cbp;
  920. if( i_cat == 0 )
  921. {
  922. if( t->mb.mb_x > 0 )
  923. {
  924. i_mba_xy = t->mb.mb_xy -1;
  925. mb_ctx = &(mb_ctxs[i_mba_xy]);
  926. if( mb_ctx->mb_mode == I_16x16 )
  927. {
  928. i_nza = (mb_ctx->cbp & 0x100);
  929. }
  930. }
  931. if( t->mb.mb_y > 0 )
  932. {
  933. i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  934. mb_ctx = &(mb_ctxs[i_mbb_xy]);
  935. if( mb_ctx->mb_mode == I_16x16 )
  936. {
  937. i_nzb = (mb_ctx->cbp & 0x100);
  938. }
  939. }
  940. }
  941. else if( i_cat == 1 || i_cat == 2 )
  942. {
  943. int x = luma_inverse_x[i_idx];
  944. int y = luma_inverse_y[i_idx];
  945. int i8 = T264_scan8[i_idx];
  946. int cbp_ya, cbp_yb;
  947. if( x > 0 )
  948. {
  949. i_mba_xy = t->mb.mb_xy;
  950. cbp_ya = t->mb.cbp_y;
  951. }
  952. else if( t->mb.mb_x > 0 )
  953. {
  954. i_mba_xy = t->mb.mb_xy -1;
  955. cbp_ya = mb_ctxs[i_mba_xy].cbp_y;
  956. }
  958. if( y > 0 )
  959. {
  960. i_mbb_xy = t->mb.mb_xy;
  961. cbp_yb = t->mb.cbp_y;
  962. }
  963. else if( t->mb.mb_y > 0 )
  964. {
  965. i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  966. cbp_yb = mb_ctxs[i_mbb_xy].cbp_y;
  967. }
  969. /* no need to test for skip/pcm */
  970. if( i_mba_xy >= 0 )
  971. {
  972. const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
  973. if( (cbp_ya&0x0f)>> i8x8a )
  974. {
  975. i_nza = t->mb.nnz_ref[i8-1];
  976. }
  977. }
  978. if( i_mbb_xy >= 0 )
  979. {
  980. const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
  981. if( (cbp_yb&0x0f)>> i8x8b )
  982. {
  983. i_nzb = t->mb.nnz_ref[i8 - 8];
  984. }
  985. }
  986. }
  987. else if( i_cat == 3 )
  988. {
  989. /* no need to test skip/pcm */
  990. //only test other MB's cbp, so we do not care about it
  991. if( t->mb.mb_x > 0 )
  992. {
  993. i_mba_xy = t->mb.mb_xy -1;
  994. cbp = mb_ctxs[i_mba_xy].cbp;
  995. if( cbp&0x30 )
  996. {
  997. i_nza = cbp&( 0x02 << ( 8 + i_idx) );
  998. }
  999. }
  1000. if( t->mb.mb_y > 0 )
  1001. {
  1002. i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  1003. cbp = mb_ctxs[i_mbb_xy].cbp;
  1004. if( cbp&0x30 )
  1005. {
  1006. i_nzb = cbp&( 0x02 << ( 8 + i_idx) );
  1007. }
  1008. }
  1009. }
  1010. else if( i_cat == 4 )
  1011. {
  1012. int cbp_ca, cbp_cb;
  1013. int idxc = i_idx% 4;
  1015. if( idxc == 1 || idxc == 3 )
  1016. {
  1017. cbp_ca = t->mb.cbp_c;
  1018. i_mba_xy = t->mb.mb_xy;
  1019. }
  1020. else if( t->mb.mb_x > 0 )
  1021. {
  1022. i_mba_xy = t->mb.mb_xy - 1;
  1023. cbp_ca = mb_ctxs[i_mba_xy].cbp_c;
  1024. }
  1026. if( idxc == 2 || idxc == 3 )
  1027. {
  1028. i_mbb_xy = t->mb.mb_xy;
  1029. cbp_cb = t->mb.cbp_c;
  1030. }
  1031. else if( t->mb.mb_y > 0 )
  1032. {
  1033. i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  1034. cbp_cb = mb_ctxs[i_mbb_xy].cbp_c;
  1035. }
  1036. /* no need to test skip/pcm */
  1037. if( i_mba_xy >= 0 && (cbp_ca&0x03) == 0x02 )
  1038. {
  1039. i_nza = t->mb.nnz_ref[T264_scan8[16+i_idx] - 1];
  1040. }
  1041. if( i_mbb_xy >= 0 && (cbp_cb&0x03) == 0x02 )
  1042. {
  1043. i_nzb = t->mb.nnz_ref[T264_scan8[16+i_idx] - 8];
  1044. }
  1045. }
  1047. if( ( i_mba_xy < 0  && IS_INTRA( t->mb.mb_mode ) ) || i_nza > 0 )
  1048. {
  1049. ctx++;
  1050. }
  1051. if( ( i_mbb_xy < 0  && IS_INTRA( t->mb.mb_mode ) ) || i_nzb > 0 )
  1052. {
  1053. ctx += 2;
  1054. }
  1056. return 4 * i_cat + ctx;
  1057. }
  1060. static void block_residual_read_cabac( T264_t *t, int i_ctxBlockCat, int i_idx, int16_t *l, int i_count )
  1061. {
  1062. static const int significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 };
  1063. static const int last_significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 };
  1064. static const int coeff_abs_level_m1_offset[5] = { 0, 10, 20, 30, 39 };
  1066. int i_coeff_sig_map[16];
  1067. int i_coeff = 0;
  1068. int i_last  = 0;
  1070. int i_abslevel1 = 0;
  1071. int i_abslevelgt1 = 0;
  1073. int i, i1, sym, i_abs, x, y;
  1075. /* i_ctxBlockCat: 0-> DC 16x16  i_idx = 0
  1076. *                1-> AC 16x16  i_idx = luma4x4idx
  1077. *                2-> Luma4x4   i_idx = luma4x4idx
  1078. *                3-> DC Chroma i_idx = iCbCr
  1079. *                4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
  1080. */
  1082. memset(l, 0, sizeof(int16_t)*i_count);
  1083. sym = T264_cabac_decode_decision(&t->cabac, 85 + T264_cabac_mb_cbf_ctxidxinc( t, i_ctxBlockCat, i_idx ));
  1084. if(sym == 0)
  1085. {
  1086. //the block is not coded
  1087. return;
  1088. }
  1089. for(i=0; i<i_count-1; i++)
  1090. {
  1091. int i_ctxIdxInc;
  1092. i_ctxIdxInc = T264_MIN(i, i_count-2);
  1093. sym = T264_cabac_decode_decision(&t->cabac, 105+significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc);
  1094. if(sym != 0)
  1095. {
  1096. i_coeff_sig_map[i] = 1;
  1097. i_coeff ++;
  1098. //--- read last coefficient symbol ---
  1099. if(T264_cabac_decode_decision(&t->cabac, 166 + last_significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc))
  1100. {
  1101. for(i++; i<i_count; i++)
  1102. i_coeff_sig_map[i] = 0;
  1103. }
  1104. }
  1105. else
  1106. {
  1107. i_coeff_sig_map[i] = 0;
  1108. }
  1109. }
  1110. //--- last coefficient must be significant if no last symbol was received ---
  1111. if (i<i_count)
  1112. {
  1113. i_coeff_sig_map[i] = 1;
  1114. i_coeff ++;
  1115. }
  1116. i1 = i_count - 1;
  1117. for( i = i_coeff - 1; i >= 0; i-- )
  1118. {
  1119. int i_prefix;
  1120. int i_ctxIdxInc;
  1122. i_ctxIdxInc = (i_abslevelgt1 != 0 ? 0 : T264_MIN( 4, i_abslevel1 + 1 )) + coeff_abs_level_m1_offset[i_ctxBlockCat];
  1123. sym = T264_cabac_decode_decision(&t->cabac, 227+i_ctxIdxInc);
  1124. if(sym == 0)
  1125. {
  1126. i_abs = 0;
  1127. }
  1128. else
  1129. {
  1130. i_prefix = 1;
  1131. i_ctxIdxInc = 5 + T264_MIN( 4, i_abslevelgt1 ) + coeff_abs_level_m1_offset[i_ctxBlockCat];
  1132. while(i_prefix<14 && T264_cabac_decode_decision(&t->cabac, 227+i_ctxIdxInc)!=0)
  1133. {
  1134. i_prefix ++;
  1135. }
  1136. /* suffix */
  1137. if(i_prefix >= 14)
  1138. {
  1139. int k = 0;
  1140. int i_suffix = 0;
  1141. while(T264_cabac_decode_bypass(&t->cabac) != 0)
  1142. {
  1143. i_suffix += 1<<k;
  1144. k++;
  1145. }
  1146. while(k--)
  1147. {
  1148. i_suffix += T264_cabac_decode_bypass(&t->cabac)<<k;
  1149. }
  1150. i_abs = i_prefix + i_suffix;
  1151. }
  1152. else
  1153. {
  1154. i_abs = i_prefix;
  1155. }
  1156. }
  1157. /* read the sign */
  1158. sym = T264_cabac_decode_bypass(&t->cabac);
  1159. while(i_coeff_sig_map[i1]==0)
  1160. {
  1161. i1 --;
  1162. }
  1163. l[i1] = (sym==0)?(i_abs+1):(-(i_abs+1));
  1164. i1 --;
  1165. if(i_abs == 0)
  1166. {
  1167. i_abslevel1 ++;
  1168. }
  1169. else
  1170. {
  1171. i_abslevelgt1 ++;
  1172. }
  1173. }
  1175. if (i_ctxBlockCat==1 || i_ctxBlockCat==2)
  1176. {
  1177. x = luma_inverse_x[i_idx];
  1178. y = luma_inverse_y[i_idx];
  1179. t->mb.nnz[luma_index[i_idx]] = i_coeff;
  1180. t->mb.nnz_ref[NNZ_LUMA + y * 8 + x] = i_coeff;
  1181. }
  1182. else if (i_ctxBlockCat==4 && i_idx<4)
  1183. {
  1184. int idx = i_idx + 16;
  1185. t->mb.nnz[idx] = i_coeff;
  1186. x = (idx - 16) % 2;
  1187. y = (idx - 16) / 2;
  1188. t->mb.nnz_ref[NNZ_CHROMA0 + y * 8 + x] = i_coeff;
  1189. }
  1190. else if (i_ctxBlockCat==4 && i_idx<8)
  1191. {
  1192. int idx = i_idx + 16;
  1193. t->mb.nnz[idx] = i_coeff;
  1194. x = (idx - 20) % 2;
  1195. y = (idx - 20) / 2;
  1196. t->mb.nnz_ref[NNZ_CHROMA1 + y * 8 + x] = i_coeff;
  1197. }
  1198. }
  1201. static int8_t
  1202. T264_mb_predict_intra4x4_mode(T264_t *t, int32_t idx)
  1203. {
  1204. int32_t x, y;
  1205. int8_t nA, nB, pred_blk;
  1207. x = luma_inverse_x[idx];
  1208. y = luma_inverse_y[idx];
  1210. nA = t->mb.i4x4_pred_mode_ref[IPM_LUMA + x + y * 8 - 1];
  1211. nB = t->mb.i4x4_pred_mode_ref[IPM_LUMA + x + y * 8 - 8];
  1213. pred_blk  = T264_MIN(nA, nB);
  1215. if( pred_blk < 0 )
  1216. return Intra_4x4_DC;
  1218. return pred_blk;
  1219. }
  1220. static void __inline mb_get_directMB16x16_mv_cabac(T264_t* t)
  1221. {
  1222. int i, j, i8, k;
  1224. //to be revised. This has a problem
  1225. T264_get_direct_mv(t, t->mb.vec);
  1226. for(k=0; k<16; k++)
  1227. {
  1228. i8 = luma_index[k];
  1229. i = luma_inverse_x[k];
  1230. j = luma_inverse_y[k];
  1231. t->mb.vec_ref[VEC_LUMA+(j<<3)+i].vec[0] = t->mb.vec[0][k];
  1232. t->mb.vec_ref[VEC_LUMA+(j<<3)+i].vec[1] = t->mb.vec[1][k];
  1233. }
  1234. i8 = VEC_LUMA;
  1235. for(j=0; j<4; j++)
  1236. {
  1237. for(i=0; i<4; i++)
  1238. {
  1239. t->mb.mvd_ref[0][i8+i][0] = 0;
  1240. t->mb.mvd_ref[0][i8+i][1] = 0;
  1241. t->mb.mvd_ref[1][i8+i][0] = 0;
  1242. t->mb.mvd_ref[1][i8+i][1] = 0;
  1243. }
  1244. i8 += 8;
  1245. }
  1246. memset(&(t->mb.mvd[0][0][0]), 0, sizeof(t->mb.mvd));
  1247. }
  1248. void T264_macroblock_read_cabac( T264_t *t, bs_t *s )
  1249. {
  1250. int i_mb_type;
  1251. const int i_mb_pos_start = BitstreamPos( s );
  1252. int       i_mb_pos_tex;
  1254. int i, j, cbp_dc;
  1256. /* Write the MB type */
  1257. T264_cabac_mb_type( t );
  1259. /* PCM special block type UNTESTED */
  1260. /* no PCM here*/
  1261. i_mb_type = t->mb.mb_mode;
  1262. if( IS_INTRA( i_mb_type ) )
  1263. {
  1264. /* Prediction */
  1265. if( i_mb_type == I_4x4 )
  1266. {
  1267. for( i = 0; i < 16; i++ )
  1268. {
  1269. const int i_pred = T264_mb_predict_intra4x4_mode( t, i );
  1270. const int i_mode = T264_cabac_mb_intra4x4_pred_mode( t, i_pred);
  1271. t->mb.i4x4_pred_mode_ref[T264_scan8[i]] = i_mode;
  1272. t->mb.mode_i4x4[i] = i_mode;
  1273. }
  1274. }
  1275. T264_cabac_mb_intra8x8_pred_mode( t );
  1276. /* save ref */
  1277. memset(t->mb.submb_part, -1, sizeof(t->mb.submb_part));
  1278. t->mb.mb_part = -1;
  1279. #define INITINVALIDVEC(vec) vec.refno = -1; vec.x = vec.y = 0;
  1280. for(i = 0 ; i < 2 ; i ++)
  1281. {
  1282. for(j = 0 ; j < 16 ; j ++)
  1283. {
  1284. INITINVALIDVEC(t->mb.vec[i][j]);
  1285. }
  1286. }
  1287. #undef INITINVALIDVEC
  1288. }
  1289. else if( i_mb_type == P_MODE )
  1290. {
  1291. int i_ref_max = t->refl0_num;
  1292. if( t->mb.mb_part == MB_16x16 )
  1293. {
  1294. T264_cabac_mb_ref( t, 0, 0, 4, 4, i_ref_max);
  1295. T264_cabac_mb_mvd( t, 0, 0, 4, 4 );
  1296. }
  1297. else if( t->mb.mb_part == MB_16x8 )
  1298. {
  1299. T264_cabac_mb_ref( t, 0, 0, 4, 2, i_ref_max );
  1300. T264_cabac_mb_ref( t, 0, 8, 4, 2, i_ref_max );
  1302. T264_cabac_mb_mvd( t, 0, 0, 4, 2 );
  1303. T264_cabac_mb_mvd( t, 0, 8, 4, 2 );
  1304. }
  1305. else if( t->mb.mb_part == MB_8x16 )
  1306. {
  1307. T264_cabac_mb_ref( t, 0, 0, 2, 4, i_ref_max );
  1308. T264_cabac_mb_ref( t, 0, 4, 2, 4, i_ref_max );
  1310. T264_cabac_mb_mvd( t, 0, 0, 2, 4 );
  1311. T264_cabac_mb_mvd( t, 0, 4, 2, 4 );
  1312. }
  1313. else /* 8x8 */
  1314. {
  1315. /* sub mb type */
  1316. t->mb.submb_part[0] = T264_cabac_mb_sub_p_partition( t );
  1317. t->mb.submb_part[2] = T264_cabac_mb_sub_p_partition( t );
  1318. t->mb.submb_part[8] = T264_cabac_mb_sub_p_partition( t );
  1319. t->mb.submb_part[10] = T264_cabac_mb_sub_p_partition( t );
  1321. /* ref 0 */
  1322. T264_cabac_mb_ref( t, 0, 0, 2, 2, i_ref_max );
  1323. T264_cabac_mb_ref( t, 0, 4, 2, 2, i_ref_max );
  1324. T264_cabac_mb_ref( t, 0, 8, 2, 2, i_ref_max );
  1325. T264_cabac_mb_ref( t, 0, 12, 2, 2, i_ref_max);
  1327. for( i = 0; i < 4; i++ )
  1328. {
  1329. switch( t->mb.submb_part[luma_index[i<<2]] )
  1330. {
  1331. case MB_8x8:
  1332. T264_cabac_mb_mvd( t, 0, 4*i, 2, 2 );
  1333. break;
  1334. case MB_8x4:
  1335. T264_cabac_mb_mvd( t, 0, 4*i+0, 2, 1 );
  1336. T264_cabac_mb_mvd( t, 0, 4*i+2, 2, 1 );
  1337. break;
  1338. case MB_4x8:
  1339. T264_cabac_mb_mvd( t, 0, 4*i+0, 1, 2 );
  1340. T264_cabac_mb_mvd( t, 0, 4*i+1, 1, 2 );
  1341. break;
  1342. case MB_4x4:
  1343. T264_cabac_mb_mvd( t, 0, 4*i+0, 1, 1 );
  1344. T264_cabac_mb_mvd( t, 0, 4*i+1, 1, 1 );
  1345. T264_cabac_mb_mvd( t, 0, 4*i+2, 1, 1 );
  1346. T264_cabac_mb_mvd( t, 0, 4*i+3, 1, 1 );
  1347. break;
  1348. }
  1349. }
  1350. }
  1351. }
  1352. else if( i_mb_type == B_MODE )
  1353. {
  1354. if((t->mb.mb_part==MB_16x16&&t->mb.is_copy!=1) || (t->mb.mb_part==MB_16x8) || (t->mb.mb_part==MB_8x16))
  1355. {
  1356. /* to be changed here*/
  1357. /* All B mode */
  1358. int i_list;
  1359. int b_list[2][2];
  1360. const int i_partition = t->mb.mb_part;
  1361. int b_part_mode, part_mode0, part_mode1;
  1362. static const int b_part_mode_map[3][3] = {
  1363. { B_L0_L0, B_L0_L1, B_L0_BI },
  1364. { B_L1_L0, B_L1_L1, B_L1_BI },
  1365. { B_BI_L0, B_BI_L1, B_BI_BI }
  1366. };
  1368. switch(t->mb.mb_part)
  1369. {
  1370. case MB_16x16:
  1371. part_mode0 = t->mb.mb_part2[0] - B_L0_16x16;
  1372. b_part_mode = b_part_mode_map[part_mode0][part_mode0];
  1373. break;
  1374. case MB_16x8:
  1375. part_mode0 = t->mb.mb_part2[0] - B_L0_16x8;
  1376. part_mode1 = t->mb.mb_part2[1] - B_L0_16x8;
  1377. b_part_mode = b_part_mode_map[part_mode0][part_mode1];
  1378. break;
  1379. case MB_8x16:
  1380. part_mode0 = t->mb.mb_part2[0] - B_L0_8x16;
  1381. part_mode1 = t->mb.mb_part2[1] - B_L0_8x16;
  1382. b_part_mode = b_part_mode_map[part_mode0][part_mode1];
  1383. break;
  1384. }
  1385. /* init ref list utilisations */
  1386. for( i = 0; i < 2; i++ )
  1387. {
  1388. b_list[0][i] = T264_mb_type_list0_table[b_part_mode][i];
  1389. b_list[1][i] = T264_mb_type_list1_table[b_part_mode][i];
  1390. }
  1391. #define INITINVALIDVEC(vec) vec.refno = -1; vec.x = vec.y = 0;
  1392. for( i_list = 0; i_list < 2; i_list++ )
  1393. {
  1394. const int i_ref_max = i_list == 0 ? t->refl0_num:t->refl1_num;//t->ps.num_ref_idx_l0_active_minus1+1 : t->ps.num_ref_idx_l1_active_minus1+1;
  1395. if( t->mb.mb_part == MB_16x16 )
  1396. {
  1397. if( b_list[i_list][0] ) 
  1398. T264_cabac_mb_ref( t, i_list, 0, 4, 4, i_ref_max );
  1399. else
  1400. {
  1401. INITINVALIDVEC(t->mb.vec[i_list][0]);
  1402. copy_nvec(&t->mb.vec[i_list][0], &t->mb.vec[i_list][0], 4, 4, 4);
  1403. }
  1404. }
  1405. else if( t->mb.mb_part == MB_16x8 )
  1406. {
  1407. if( b_list[i_list][0] ) 
  1408. T264_cabac_mb_ref( t, i_list, 0, 4, 2, i_ref_max );
  1409. else
  1410. {
  1411. INITINVALIDVEC(t->mb.vec[i_list][0]);
  1412. copy_nvec(&t->mb.vec[i_list][0], &t->mb.vec[i_list][0], 4, 2, 4);
  1413. INITINVALIDVEC(t->mb.vec_ref[VEC_LUMA+8].vec[i_list]);
  1414. }
  1415. if( b_list[i_list][1] ) 
  1416. T264_cabac_mb_ref( t, i_list, 8, 4, 2, i_ref_max );
  1417. else
  1418. {
  1419. INITINVALIDVEC(t->mb.vec[i_list][8]);
  1420. copy_nvec(&t->mb.vec[i_list][8], &t->mb.vec[i_list][8], 4, 2, 4);
  1421. }
  1423. }
  1424. else if( t->mb.mb_part == MB_8x16 )
  1425. {
  1426. if( b_list[i_list][0] )
  1427. T264_cabac_mb_ref( t, i_list, 0, 2, 4, i_ref_max );
  1428. else
  1429. {
  1430. INITINVALIDVEC(t->mb.vec[i_list][0]);
  1431. copy_nvec(&t->mb.vec[i_list][0], &t->mb.vec[i_list][0], 2, 4, 4);
  1432. INITINVALIDVEC(t->mb.vec_ref[VEC_LUMA+1].vec[i_list]);
  1433. }
  1434. if( b_list[i_list][1] )
  1435. T264_cabac_mb_ref( t, i_list, 4, 2, 4, i_ref_max );
  1436. else
  1437. {
  1438. INITINVALIDVEC(t->mb.vec[i_list][2]);
  1439. copy_nvec(&t->mb.vec[i_list][2], &t->mb.vec[i_list][2], 2, 4, 4);
  1440. }
  1441. }
  1442. }
  1443. #undef INITINVALIDVEC
  1444. for( i_list = 0; i_list < 2; i_list++ )
  1445. {
  1446. if( t->mb.mb_part == MB_16x16 )
  1447. {
  1448. if( b_list[i_list][0] ) 
  1449. T264_cabac_mb_mvd( t, i_list, 0, 4, 4 );
  1450. }
  1451. else if( t->mb.mb_part == MB_16x8 )
  1452. {
  1453. if( b_list[i_list][0] )
  1454. T264_cabac_mb_mvd( t, i_list, 0, 4, 2 );
  1455. if( b_list[i_list][1] ) 
  1456. T264_cabac_mb_mvd( t, i_list, 8, 4, 2 );
  1457. }
  1458. else if( t->mb.mb_part == MB_8x16 )
  1459. {
  1460. if( b_list[i_list][0] ) 
  1461. T264_cabac_mb_mvd( t, i_list, 0, 2, 4 );
  1462. if( b_list[i_list][1] ) 
  1463. T264_cabac_mb_mvd( t, i_list, 4, 2, 4 );
  1464. }
  1465. }
  1466. }
  1467. else if(t->mb.mb_part==MB_16x16 && t->mb.is_copy)
  1468. {
  1469. mb_get_directMB16x16_mv_cabac(t);
  1470. }
  1471. else /* B8x8 */
  1472. {
  1473. /* TODO */
  1474. int i_list;
  1475. /* sub mb type */
  1476. t->mb.submb_part[0] = T264_cabac_mb_sub_b_partition( t );
  1477. t->mb.submb_part[2] = T264_cabac_mb_sub_b_partition( t );
  1478. t->mb.submb_part[8] = T264_cabac_mb_sub_b_partition( t );
  1479. t->mb.submb_part[10] = T264_cabac_mb_sub_b_partition( t );
  1481. /* ref */
  1482. for( i_list = 0; i_list < 2; i_list++ )
  1483. {
  1484. int i_ref_max = (i_list==0)?t->refl0_num:t->refl1_num;
  1485. for( i = 0; i < 4; i++ )
  1486. {
  1487. int luma_idx = luma_index[i<<2];
  1488. int sub_part = t->mb.submb_part[luma_idx]-B_DIRECT_8x8;
  1489. if( T264_mb_partition_listX_table[sub_part][i_list] == 1 )
  1490. {
  1491. T264_cabac_mb_ref( t, i_list, 4*i, 2, 2, i_ref_max );
  1492. }
  1493. else
  1494. {
  1495. int i8 = i / 2 * 16 + i % 2 * 2;
  1496. #define INITINVALIDVEC(vec) vec.refno = -1; vec.x = vec.y = 0;
  1497. INITINVALIDVEC(t->mb.vec[i_list][luma_idx]);
  1498. copy_nvec(&t->mb.vec[i_list][luma_idx], &t->mb.vec[i_list][luma_idx], 2, 2, 4);
  1499. t->mb.vec_ref[VEC_LUMA + i8 + 0].vec[i_list] =
  1500. t->mb.vec_ref[VEC_LUMA + i8 + 1].vec[i_list] =
  1501. t->mb.vec_ref[VEC_LUMA + i8 + 8].vec[i_list] =
  1502. t->mb.vec_ref[VEC_LUMA + i8 + 9].vec[i_list] = t->mb.vec[i_list][luma_idx];
  1503. #undef INITINVALIDVEC
  1504. }
  1505. }
  1506. }
  1507. T264_cabac_mb8x8_mvd( t, 0 );
  1508. T264_cabac_mb8x8_mvd( t, 1 );
  1509. for(i=0; i<4; i++)
  1510. {
  1511. int i_part = luma_index[i<<2];
  1512. int sub_part = t->mb.submb_part[i_part] - B_DIRECT_8x8;
  1513. t->mb.submb_part[i_part] = T264_map_btype_mbpart[sub_part];
  1514. }
  1515. }
  1516. }
  1518. i_mb_pos_tex = BitstreamPos( s );
  1520. if( i_mb_type != I_16x16 )
  1521. {
  1522. T264_cabac_mb_cbp_luma( t );
  1523. T264_cabac_mb_cbp_chroma( t );
  1524. }
  1526. cbp_dc = 0;
  1527. if( t->mb.cbp_y > 0 || t->mb.cbp_c > 0 || i_mb_type == I_16x16 )
  1528. {
  1529. T264_cabac_mb_qp_delta( t );
  1531. /* read residual */
  1532. if( i_mb_type == I_16x16 )
  1533. {
  1534. /* DC Luma */
  1535. int dc_nz;
  1536. block_residual_read_cabac( t, 0, 0, t->mb.dc4x4_z, 16 );
  1537. //for CABAC, record the DC non_zero
  1538. dc_nz = array_non_zero_count(&(t->mb.dc4x4_z[0]), 16);
  1539. if(dc_nz != 0)
  1540. {
  1541. cbp_dc = 1;
  1542. }
  1544. if( t->mb.cbp_y != 0 )
  1545. {
  1546. /* AC Luma */
  1547. for( i = 0; i < 16; i++ )
  1548. {
  1549. block_residual_read_cabac( t, 1, i, &(t->mb.dct_y_z[i][1]), 15 );
  1550. t->mb.dct_y_z[i][0] = t->mb.dc4x4_z[i];
  1551. }
  1552. }
  1553. }
  1554. else
  1555. {
  1556. if(t->frame_num == 1)
  1557. t->frame_num = 1;
  1558. for( i = 0; i < 16; i++ )
  1559. {
  1560. if( t->mb.cbp_y & ( 1 << ( i / 4 ) ) )
  1561. {
  1562. block_residual_read_cabac( t, 2, i, &(t->mb.dct_y_z[i][0]), 16 );
  1563. }
  1564. }
  1565. }
  1567. if( t->mb.cbp_c&0x03 )    /* Chroma DC residual present */
  1568. {
  1569. int dc_nz0, dc_nz1;
  1570. block_residual_read_cabac( t, 3, 0, &(t->mb.dc2x2_z[0][0]), 4 );
  1571. block_residual_read_cabac( t, 3, 1, &(t->mb.dc2x2_z[1][0]), 4 );
  1572. //for CABAC, chroma dc pattern
  1573. dc_nz0 = array_non_zero_count(t->mb.dc2x2_z[0], 4) > 0;
  1574. dc_nz1 = array_non_zero_count(t->mb.dc2x2_z[1], 4) > 0;
  1575. if(dc_nz0)
  1576. cbp_dc |= 0x02;
  1577. if(dc_nz1)
  1578. cbp_dc |= 0x04;
  1579. }
  1580. if( t->mb.cbp_c&0x02 ) /* Chroma AC residual present */
  1581. {
  1582. for( i = 0; i < 8; i++ )
  1583. {
  1584. block_residual_read_cabac( t, 4, i, &(t->mb.dct_uv_z[i>>2][i&0x03][1]), 15);
  1585. t->mb.dct_uv_z[i>>2][i&0x03][0] = t->mb.dc2x2_z[i>>2][i&0x03];
  1586. }
  1587. }
  1588. else
  1589. {
  1590. for(i = 0 ; i < 4 ; i ++)
  1591. {
  1592. t->mb.dct_uv_z[0][i][0] = t->mb.dc2x2_z[0][i];
  1593. t->mb.dct_uv_z[1][i][0] = t->mb.dc2x2_z[1][i];
  1594. }
  1595. }
  1596. }
  1597. //for CABAC, cbp
  1598. t->mb.cbp = t->mb.cbp_y | (t->mb.cbp_c<<4) | (cbp_dc << 8);
  1599. /*
  1600. if( IS_INTRA( i_mb_type ) )
  1601. t->stat.frame.i_itex_bits += bs_pos(s) - i_mb_pos_tex;
  1602. else
  1603. t->stat.frame.i_ptex_bits += bs_pos(s) - i_mb_pos_tex;
  1604. */
  1605. }
  1606. int T264dec_mb_read_cabac(T264_t *t)
  1607. {
  1608. int skip;
  1609. //for dec CABAC, set MVD to zero
  1610. memset(&(t->mb.mvd[0][0][0]), 0, sizeof(t->mb.mvd));
  1611. t->mb.cbp = t->mb.cbp_y = t->mb.cbp_c = t->mb.mb_qp_delta = 0;
  1612. if (t->slice_type != SLICE_I)
  1613. skip = T264_cabac_dec_mb_skip(t);
  1614. else
  1615. skip = 0;
  1616. if(skip)
  1617. {
  1618. /* skip mb block */
  1619. if (t->slice_type == SLICE_P)
  1620. {
  1621. T264_predict_mv_skip(t, 0, &t->mb.vec[0][0]);
  1622. copy_nvec(&t->mb.vec[0][0], &t->mb.vec[0][0], 4, 4, 4);
  1623. t->mb.mb_mode = P_MODE;     /* decode as MB_16x16 */
  1624. t->mb.mb_part = MB_16x16;
  1625. }
  1626. else if(t->slice_type == SLICE_B)
  1627. {
  1628. mb_get_directMB16x16_mv_cabac(t);
  1629.             t->mb.is_copy = 1;
  1630. t->mb.mb_mode = B_MODE;     /* decode as MB_16x16 */                
  1631. t->mb.mb_part = MB_16x16;
  1632. }
  1633. else
  1634. {
  1635. assert(0);
  1636. }
  1637. }
  1638. else
  1639. {
  1640. T264_macroblock_read_cabac(t, t->bs);
  1641. }
  1642. return skip;
  1643. }