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

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

mpeg/mp3

开发平台：

Visual C++

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. ****************************************************************************/
  24. /*****************************************************************************
  25.  * cabac.c: h264 encoder library
  26.  *****************************************************************************
  27.  * Copyright (C) 2003 Laurent Aimar
  28.  *
  29.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  30.  *
  31.  * This program is free software; you can redistribute it and/or modify
  32.  * it under the terms of the GNU General Public License as published by
  33.  * the Free Software Foundation; either version 2 of the License, or
  34.  * (at your option) any later version.
  35.  *
  36.  * This program is distributed in the hope that it will be useful,
  37.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  38.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  39.  * GNU General Public License for more details.
  40.  *
  41.  * You should have received a copy of the GNU General Public License
  42.  * along with this program; if not, write to the Free Software
  43.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  44.  *****************************************************************************/
  46. /*Note: the CABAC routine is currently referenced from x264 temporarily, with adaptation to 
  47.  *the data structure of T264. It should be modified further in the near future.
  48.  *It's can support B slice, but only with MB mode P16x16, P16x8, P8x16, Direct16x16, B_SKIP
  49.  *ie., B8x8 is not support now
  50. */
  52. #include <stdlib.h>
  53. #include <stdio.h>
  54. #include <string.h>
  55. #include <assert.h>
  56. #include "T264.h"
  57. #include "cabac_engine.h"
  58. #include "inter.h"
  59. /* From ffmpeg
  60. */
  61. #define T264_SCAN8_SIZE (6*8)
  62. #define T264_SCAN8_0 (4+1*8)
  64. static const int T264_scan8[16+2*4] =
  65. {
  66. /* Luma */
  67. VEC_LUMA + 0, VEC_LUMA + 1, VEC_LUMA + 1*8 + 0, VEC_LUMA + 1*8 + 1,
  68. VEC_LUMA + 2, VEC_LUMA + 3, VEC_LUMA + 1*8 + 2, VEC_LUMA + 1*8 + 3,
  69. VEC_LUMA + 2*8 + 0, VEC_LUMA + 2*8 + 1, VEC_LUMA + 3*8 + 0, VEC_LUMA + 3*8 + 1,
  70. VEC_LUMA + 2*8 + 2, VEC_LUMA + 2*8 + 3, VEC_LUMA + 3*8 + 2, VEC_LUMA + 3*8 + 3,
  72. /* Cb */
  73. NNZ_CHROMA0 + 0, NNZ_CHROMA0 + 1,
  74. NNZ_CHROMA0 + 1*8 + 0, NNZ_CHROMA0 + 1*8 + 1,
  76. /* Cr */
  77. NNZ_CHROMA1 + 0, NNZ_CHROMA1 + 1,
  78. NNZ_CHROMA1 + 1*8 + 0, NNZ_CHROMA1 + 1*8 + 1,
  79. };
  80. static const uint8_t block_idx_xy[4][4] =
  81. {
  82. { 0, 2, 8,  10},
  83. { 1, 3, 9,  11},
  84. { 4, 6, 12, 14},
  85. { 5, 7, 13, 15}
  86. };
  88. #define IS_INTRA(mode) (mode == I_4x4 || mode == I_16x16)
  89. #define IS_SKIP(type)  ( (type) == P_SKIP || (type) == B_SKIP )
  90. enum {
  91. INTRA_4x4           = 0,
  92. INTRA_16x16         = 1,
  93. INTRA_PCM           = 2,
  95. P_L0            = 3,
  96. P_8x81          = 4,
  97. P_SKIP1         = 5,
  99. B_DIRECT        = 6,
  100. B_L0_L0         = 7,
  101. B_L0_L1         = 8,
  102. B_L0_BI         = 9,
  103. B_L1_L0         = 10,
  104. B_L1_L1         = 11,
  105. B_L1_BI         = 12,
  106. B_BI_L0         = 13,
  107. B_BI_L1         = 14,
  108. B_BI_BI         = 15,
  109. B_8x81          = 16,
  110. B_SKIP1         = 17,
  111. };
  113. static const int T264_mb_partition_listX_table[][2] = 
  114. {
  115. {0, 0}, //B_DIRECT_8x8 = 100,
  116. {1, 0}, //B_L0_8x8,
  117. {0, 1}, //B_L1_8x8,
  118. {1, 1}, //B_Bi_8x8,
  119. {1, 0}, //B_L0_8x4,
  120. {1, 0}, //B_L0_4x8,
  121. {0, 1}, //B_L1_8x4,
  122. {0, 1}, //B_L1_4x8,
  123. {1, 1}, //B_Bi_8x4,
  124. {1, 1}, //B_Bi_4x8,
  125. {1, 0}, //B_L0_4x4,
  126. {0, 1}, //B_L1_4x4,
  127. {1, 1} //B_Bi_4x4
  128. };
  130. static const int T264_mb_type_list0_table[18][2] =
  131. {
  132. {0,0}, {0,0}, {0,0},    /* INTRA */
  133. {1,1},                  /* P_L0 */
  134. {0,0},                  /* P_8x8 */
  135. {1,1},                  /* P_SKIP */
  136. {0,0},                  /* B_DIRECT */
  137. {1,1}, {1,0}, {1,1},    /* B_L0_* */
  138. {0,1}, {0,0}, {0,1},    /* B_L1_* */
  139. {1,1}, {1,0}, {1,1},    /* B_BI_* */
  140. {0,0},                  /* B_8x8 */
  141. {0,0}                   /* B_SKIP */
  142. };
  143. static const int T264_mb_type_list1_table[18][2] =
  144. {
  145. {0,0}, {0,0}, {0,0},    /* INTRA */
  146. {0,0},                  /* P_L0 */
  147. {0,0},                  /* P_8x8 */
  148. {0,0},                  /* P_SKIP */
  149. {0,0},                  /* B_DIRECT */
  150. {0,0}, {0,1}, {0,1},    /* B_L0_* */
  151. {1,0}, {1,1}, {1,1},    /* B_L1_* */
  152. {1,0}, {1,1}, {1,1},    /* B_BI_* */
  153. {0,0},                  /* B_8x8 */
  154. {0,0}                   /* B_SKIP */
  155. };
  157. static void T264_cabac_mb_type( T264_t *t )
  158. {
  159. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  160.     int32_t mb_mode = t->mb.mb_mode;
  162.     if( t->slice_type == SLICE_I )
  163.     {
  164.         int ctx = 0;
  165.         if( t->mb.mb_x > 0 && mb_ctxs[t->mb.mb_xy-1].mb_mode != I_4x4 )
  166.         {
  167.             ctx++;
  168.         }
  169.         if( t->mb.mb_y > 0 && mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode != I_4x4 )
  170.         {
  171.             ctx++;
  172.         }
  174.         if( mb_mode == I_4x4 )
  175.         {
  176.             T264_cabac_encode_decision( &t->cabac, 3 + ctx, 0 );
  177.         }
  178.         else if(mb_mode == I_16x16)   /* I_16x16 */
  179.         {
  180.             T264_cabac_encode_decision( &t->cabac, 3 + ctx, 1 );
  181.             T264_cabac_encode_terminal( &t->cabac, 0 );
  183.             T264_cabac_encode_decision( &t->cabac, 3 + 3, ( t->mb.cbp_y == 0 ? 0 : 1 ));
  184.             if( t->mb.cbp_c == 0 )
  185.             {
  186.                 T264_cabac_encode_decision( &t->cabac, 3 + 4, 0 );
  187.             }
  188.             else
  189.             {
  190.                 T264_cabac_encode_decision( &t->cabac, 3 + 4, 1 );
  191.                 T264_cabac_encode_decision( &t->cabac, 3 + 5, ( t->mb.cbp_c == 1 ? 0 : 1 ) );
  192.             }
  193.             T264_cabac_encode_decision( &t->cabac, 3 + 6, ( (t->mb.mode_i16x16 / 2) ? 1 : 0 ));
  194.             T264_cabac_encode_decision( &t->cabac, 3 + 7, ( (t->mb.mode_i16x16 % 2) ? 1 : 0 ));
  195.         }
  196. else /* I_PCM */
  197. {
  198. T264_cabac_encode_decision( &t->cabac, 3 + ctx, 1 );
  199. T264_cabac_encode_terminal( &t->cabac, 1 );
  200. }
  201.     }
  202.     else if( t->slice_type == SLICE_P )
  203.     {
  204.         /* prefix: 14, suffix: 17 */
  205.         if( mb_mode == P_MODE )
  206.         {
  207.             if( t->mb.mb_part == MB_16x16 )
  208.             {
  209.                 T264_cabac_encode_decision( &t->cabac, 14, 0 );
  210.                 T264_cabac_encode_decision( &t->cabac, 15, 0 );
  211.                 T264_cabac_encode_decision( &t->cabac, 16, 0 );
  212.             }
  213.             else if( t->mb.mb_part == MB_16x8 )
  214.             {
  215.                 T264_cabac_encode_decision( &t->cabac, 14, 0 );
  216.                 T264_cabac_encode_decision( &t->cabac, 15, 1 );
  217.                 T264_cabac_encode_decision( &t->cabac, 17, 1 );
  218.             }
  219.             else if( t->mb.mb_part == MB_8x16 )
  220.             {
  221.                 T264_cabac_encode_decision( &t->cabac, 14, 0 );
  222.                 T264_cabac_encode_decision( &t->cabac, 15, 1 );
  223.                 T264_cabac_encode_decision( &t->cabac, 17, 0 );
  224.             }
  225. else /* P8x8 mode */
  226. {
  227. T264_cabac_encode_decision( &t->cabac, 14, 0 );
  228. T264_cabac_encode_decision( &t->cabac, 15, 0 );
  229. T264_cabac_encode_decision( &t->cabac, 16, 1 );
  230. }
  231.         }
  232.         else if( mb_mode == I_4x4 )
  233.         {
  234.             /* prefix */
  235.             T264_cabac_encode_decision( &t->cabac, 14, 1 );
  237.             T264_cabac_encode_decision( &t->cabac, 17, 0 );
  238.         }
  239.         else if(mb_mode == I_16x16) /* intra 16x16 */
  240.         {
  241.             /* prefix */
  242.             T264_cabac_encode_decision( &t->cabac, 14, 1 );
  244.             /* suffix */
  245.             T264_cabac_encode_decision( &t->cabac, 17, 1 );
  246.             T264_cabac_encode_terminal( &t->cabac, 0 ); /*ctxIdx == 276 */
  248.             T264_cabac_encode_decision( &t->cabac, 17+1, ( t->mb.cbp_y == 0 ? 0 : 1 ));
  249.             if( t->mb.cbp_c == 0 )
  250.             {
  251.                 T264_cabac_encode_decision( &t->cabac, 17+2, 0 );
  252.             }
  253.             else
  254.             {
  255.                 T264_cabac_encode_decision( &t->cabac, 17+2, 1 );
  256.                 T264_cabac_encode_decision( &t->cabac, 17+2, ( t->mb.cbp_c == 1 ? 0 : 1 ) );
  257.             }
  258.             T264_cabac_encode_decision( &t->cabac, 17+3, ( (t->mb.mode_i16x16 / 2) ? 1 : 0 ));
  259.             T264_cabac_encode_decision( &t->cabac, 17+3, ( (t->mb.mode_i16x16 % 2) ? 1 : 0 ));
  260.         }
  261. else /* I_PCM */
  262. {
  263. /* prefix */
  264. T264_cabac_encode_decision( &t->cabac, 14, 1 );
  266. T264_cabac_encode_decision( &t->cabac, 17, 1 );
  267. T264_cabac_encode_terminal( &t->cabac, 1 ); /*ctxIdx == 276 */
  268. }
  269.     }
  270.     else if( t->slice_type == SLICE_B )
  271.     {
  272. int ctx = 0;
  273. 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 )
  274. {
  275. ctx++;
  276. }
  277. 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)
  278. {
  279. ctx++;
  280. }
  281.         
  282.         if( t->mb.is_copy)
  283.         {
  284.             T264_cabac_encode_decision( &t->cabac, 27+ctx, 0 );
  285.         }
  286.         else if( t->mb.mb_part == MB_8x8 )
  287.         {
  288.             T264_cabac_encode_decision( &t->cabac, 27+ctx, 1 );
  289.             T264_cabac_encode_decision( &t->cabac, 27+3,   1 );
  290.             T264_cabac_encode_decision( &t->cabac, 27+4,   1 );
  292.             T264_cabac_encode_decision( &t->cabac, 27+5,   1 );
  293.             T264_cabac_encode_decision( &t->cabac, 27+5,   1 );
  294.             T264_cabac_encode_decision( &t->cabac, 27+5,   1 );
  295.         }
  296.         else if( IS_INTRA( mb_mode ) )
  297.         {
  298.             /* prefix */
  299.             T264_cabac_encode_decision( &t->cabac, 27+ctx, 1 );
  300.             T264_cabac_encode_decision( &t->cabac, 27+3,   1 );
  301.             T264_cabac_encode_decision( &t->cabac, 27+4,   1 );
  303.             T264_cabac_encode_decision( &t->cabac, 27+5,   1 );
  304.             T264_cabac_encode_decision( &t->cabac, 27+5,   0 );
  305.             T264_cabac_encode_decision( &t->cabac, 27+5,   1 );
  307.             /* Suffix */
  308.             if( mb_mode == I_4x4 )
  309.             {
  310.                 T264_cabac_encode_decision( &t->cabac, 32, 0 );
  311.             }
  312. else if(mb_mode == I_16x16)
  313. {
  314. T264_cabac_encode_decision( &t->cabac, 32, 1 );
  315. T264_cabac_encode_terminal( &t->cabac,     0 );
  317. /* TODO */
  318. T264_cabac_encode_decision( &t->cabac, 32+1, ( t->mb.cbp_y == 0 ? 0 : 1 ));
  319. if( t->mb.cbp_c == 0 )
  320. {
  321. T264_cabac_encode_decision( &t->cabac, 32+2, 0 );
  322. }
  323. else
  324. {
  325. T264_cabac_encode_decision( &t->cabac, 32+2, 1 );
  326. T264_cabac_encode_decision( &t->cabac, 32+2, ( t->mb.cbp_c == 1 ? 0 : 1 ) );
  327. }
  328. T264_cabac_encode_decision( &t->cabac, 32+3, ( (t->mb.mode_i16x16 / 2) ? 1 : 0 ));
  329. T264_cabac_encode_decision( &t->cabac, 32+3, ( (t->mb.mode_i16x16 % 2) ? 1 : 0 ));
  330. }
  331.             else /* I_PCM */
  332.             {
  333.                 T264_cabac_encode_decision( &t->cabac, 32, 1 );
  334.                 T264_cabac_encode_terminal( &t->cabac,     1 );
  335.             }
  336.             
  337.         }
  338.         else
  339.         {
  340.             static const int i_mb_len[21] =
  341.             {
  342.                 3, 6, 6,    /* L0 L0 */
  343.                 3, 6, 6,    /* L1 L1 */
  344.                 6, 7, 7,    /* BI BI */
  346.                 6, 6,       /* L0 L1 */
  347.                 6, 6,       /* L1 L0 */
  348.                 7, 7,       /* L0 BI */
  349.                 7, 7,       /* L1 BI */
  350.                 7, 7,       /* BI L0 */
  351.                 7, 7,       /* BI L1 */
  352.             };
  353.             static const int i_mb_bits[21][7] =
  354.             {
  355.                 { 1, 0, 0, },            { 1, 1, 0, 0, 0, 1, },    { 1, 1, 0, 0, 1, 0, },   /* L0 L0 */
  356.                 { 1, 0, 1, },            { 1, 1, 0, 0, 1, 1, },    { 1, 1, 0, 1, 0, 0, },   /* L1 L1 */
  357.                 { 1, 1, 0, 0, 0, 0 ,},   { 1, 1, 1, 1, 0, 0 , 0 }, { 1, 1, 1, 1, 0, 0 , 1 },/* BI BI */
  359.                 { 1, 1, 0, 1, 0, 1, },   { 1, 1, 0, 1, 1, 0, },     /* L0 L1 */
  360.                 { 1, 1, 0, 1, 1, 1, },   { 1, 1, 1, 1, 1, 0, },     /* L1 L0 */
  361.                 { 1, 1, 1, 0, 0, 0, 0 }, { 1, 1, 1, 0, 0, 0, 1 },   /* L0 BI */
  362.                 { 1, 1, 1, 0, 0, 1, 0 }, { 1, 1, 1, 0, 0, 1, 1 },   /* L1 BI */
  363.                 { 1, 1, 1, 0, 1, 0, 0 }, { 1, 1, 1, 0, 1, 0, 1 },   /* BI L0 */
  364.                 { 1, 1, 1, 0, 1, 1, 0 }, { 1, 1, 1, 0, 1, 1, 1 }    /* BI L1 */
  365.             };
  367.             const int i_partition = t->mb.mb_part;
  368.             int idx = 0;
  369.             int i, b_part_mode, part_mode0, part_mode1;
  370. static const int b_part_mode_map[3][3] = {
  371. { B_L0_L0, B_L0_L1, B_L0_BI },
  372. { B_L1_L0, B_L1_L1, B_L1_BI },
  373. { B_BI_L0, B_BI_L1, B_BI_BI }
  374. };
  376. switch(t->mb.mb_part)
  377. {
  378. case MB_16x16:
  379. part_mode0 = t->mb.mb_part2[0] - B_L0_16x16;
  380. b_part_mode = b_part_mode_map[part_mode0][part_mode0];
  381. break;
  382. case MB_16x8:
  383. part_mode0 = t->mb.mb_part2[0] - B_L0_16x8;
  384. part_mode1 = t->mb.mb_part2[1] - B_L0_16x8;
  385. b_part_mode = b_part_mode_map[part_mode0][part_mode1];
  386. break;
  387. case MB_8x16:
  388. part_mode0 = t->mb.mb_part2[0] - B_L0_8x16;
  389. part_mode1 = t->mb.mb_part2[1] - B_L0_8x16;
  390. b_part_mode = b_part_mode_map[part_mode0][part_mode1];
  391. break;
  392. }
  393.             switch( b_part_mode )
  394.             {
  395.                 /* D_16x16, D_16x8, D_8x16 */
  396.                 case B_BI_BI: idx += 3;
  397.                 case B_L1_L1: idx += 3;
  398.                 case B_L0_L0:
  399.                     if( i_partition == MB_16x8 )
  400.                         idx += 1;
  401.                     else if( i_partition == MB_8x16 )
  402.                         idx += 2;
  403.                     break;
  405.                 /* D_16x8, D_8x16 */
  406.                 case B_BI_L1: idx += 2;
  407.                 case B_BI_L0: idx += 2;
  408.                 case B_L1_BI: idx += 2;
  409.                 case B_L0_BI: idx += 2;
  410.                 case B_L1_L0: idx += 2;
  411.                 case B_L0_L1:
  412.                     idx += 3*3;
  413.                     if( i_partition == MB_8x16 )
  414.                         idx++;
  415.                     break;
  416.                 default:
  417. return;
  418. }
  420.             T264_cabac_encode_decision( &t->cabac, 27+ctx,                         i_mb_bits[idx][0] );
  421.             T264_cabac_encode_decision( &t->cabac, 27+3,                           i_mb_bits[idx][1] );
  422.             T264_cabac_encode_decision( &t->cabac, 27+(i_mb_bits[idx][1] != 0 ? 4 : 5), i_mb_bits[idx][2] );
  423.             for( i = 3; i < i_mb_len[idx]; i++ )
  424.             {
  425.                 T264_cabac_encode_decision( &t->cabac, 27+5,                       i_mb_bits[idx][i] );
  426.             }
  427.         }
  428.     }
  429.     else
  430.     {
  431. //dummy here
  432.     }
  433. }
  435. static void T264_cabac_mb_intra4x4_pred_mode( T264_t *t, int i_pred, int i_mode )
  436. {
  437.     if( i_pred == i_mode )
  438.     {
  439.         /* b_prev_intra4x4_pred_mode */
  440.         T264_cabac_encode_decision( &t->cabac, 68, 1 );
  441.     }
  442.     else
  443.     {
  444.         /* b_prev_intra4x4_pred_mode */
  445.         T264_cabac_encode_decision( &t->cabac, 68, 0 );
  446.         if( i_mode > i_pred  )
  447.         {
  448.             i_mode--;
  449.         }
  450.         T264_cabac_encode_decision( &t->cabac, 69, (i_mode     )&0x01 );
  451.         T264_cabac_encode_decision( &t->cabac, 69, (i_mode >> 1)&0x01 );
  452.         T264_cabac_encode_decision( &t->cabac, 69, (i_mode >> 2)&0x01 );
  453.     }
  454. }
  456. static void T264_cabac_mb_intra8x8_pred_mode( T264_t *t )
  457. {
  458.     const int i_mode  = t->mb.mb_mode_uv;
  459. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  461. int ctx = 0;
  462. if( t->mb.mb_x > 0 && mb_ctxs[t->mb.mb_xy-1].mb_mode_uv != Intra_8x8_DC)
  463. {
  464. ctx++;
  465. }
  466. if( t->mb.mb_y > 0 && mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode_uv != Intra_8x8_DC )
  467. {
  468. ctx++;
  469. }
  471.     if( i_mode == Intra_8x8_DC )
  472.     {
  473.         T264_cabac_encode_decision( &t->cabac, 64 + ctx, Intra_8x8_DC );
  474.     }
  475.     else
  476.     {
  477.         T264_cabac_encode_decision( &t->cabac, 64 + ctx, 1 );
  478.         T264_cabac_encode_decision( &t->cabac, 64 + 3, ( i_mode == 1 ? 0 : 1 ) );
  479.         if( i_mode > 1 )
  480.         {
  481.             T264_cabac_encode_decision( &t->cabac, 64 + 3, ( i_mode == 2 ? 0 : 1 ) );
  482.         }
  483.     }
  484. }
  486. static void T264_cabac_mb_cbp_luma( T264_t *t )
  487. {
  488.     /* TODO: clean up and optimize */
  489. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  490.     int i8x8;
  491.     for( i8x8 = 0; i8x8 < 4; i8x8++ )
  492.     {
  493.         int i_mba_xy = -1;
  494.         int i_mbb_xy = -1;
  495.         int x = luma_inverse_x[4*i8x8];
  496.         int y = luma_inverse_y[4*i8x8];
  497.         int ctx = 0;
  499.         if( x > 0 )
  500.             i_mba_xy = t->mb.mb_xy;
  501.         else if( t->mb.mb_x > 0 )
  502.             i_mba_xy = t->mb.mb_xy - 1;
  504.         if( y > 0 )
  505.             i_mbb_xy = t->mb.mb_xy;
  506.         else if( t->mb.mb_y > 0 )
  507.             i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  510.         /* No need to test for PCM and SKIP */
  511.         if( i_mba_xy >= 0 )
  512.         {
  513.             const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
  514.             if( ((mb_ctxs[i_mba_xy].cbp_y >> i8x8a)&0x01) == 0 )
  515.             {
  516.                 ctx++;
  517.             }
  518.         }
  520.         if( i_mbb_xy >= 0 )
  521.         {
  522.             const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
  523.             if( ((mb_ctxs[i_mbb_xy].cbp_y >> i8x8b)&0x01) == 0 )
  524.             {
  525.                 ctx += 2;
  526.             }
  527.         }
  528.    
  529.         T264_cabac_encode_decision( &t->cabac, 73 + ctx, (t->mb.cbp_y >> i8x8)&0x01 );
  530.     }
  531. }
  533. static void T264_cabac_mb_cbp_chroma( T264_t *t )
  534. {
  535.     int cbp_a = -1;
  536.     int cbp_b = -1;
  537.     int ctx;
  538. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  539.     /* No need to test for SKIP/PCM */
  540.     if( t->mb.mb_x > 0 )
  541.     {
  542.         cbp_a = (mb_ctxs[t->mb.mb_xy - 1].cbp_c)&0x3;
  543.     }
  545.     if( t->mb.mb_y > 0 )
  546.     {
  547.         cbp_b = (mb_ctxs[t->mb.mb_xy - t->mb_stride].cbp_c)&0x3;
  548.     }
  550.     ctx = 0;
  551.     if( cbp_a > 0 ) ctx++;
  552.     if( cbp_b > 0 ) ctx += 2;
  553.     if( t->mb.cbp_c == 0 )
  554.     {
  555.         T264_cabac_encode_decision( &t->cabac, 77 + ctx, 0 );
  556.     }
  557.     else
  558.     {
  559.         T264_cabac_encode_decision( &t->cabac, 77 + ctx, 1 );
  561.         ctx = 4;
  562.         if( cbp_a == 2 ) ctx++;
  563.         if( cbp_b == 2 ) ctx += 2;
  564.         T264_cabac_encode_decision( &t->cabac, 77 + ctx, t->mb.cbp_c > 1 ? 1 : 0 );
  565.     }
  566. }
  568. /* TODO check it with != qp per mb */
  569. static void T264_cabac_mb_qp_delta( T264_t *t )
  570. {
  571.     int i_mbn_xy = t->mb.mb_xy - 1;
  572.     int i_dqp = t->mb.mb_qp_delta;
  573.     int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
  574.     int ctx;
  575. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  577.     /* No need to test for PCM / SKIP */
  578.     if( i_mbn_xy >= 0 && mb_ctxs[i_mbn_xy].mb_qp_delta != 0 &&
  579.         ( mb_ctxs[i_mbn_xy].mb_mode == I_16x16 || mb_ctxs[i_mbn_xy].cbp_y || mb_ctxs[i_mbn_xy].cbp_c) )
  580.         ctx = 1;
  581.     else
  582.         ctx = 0;
  584.     while( val > 0 )
  585.     {
  586.         T264_cabac_encode_decision( &t->cabac,  60 + ctx, 1 );
  587.         if( ctx < 2 )
  588.             ctx = 2;
  589.         else
  590.             ctx = 3;
  591.         val--;
  592.     }
  593.     T264_cabac_encode_decision( &t->cabac,  60 + ctx, 0 );
  594. }
  596. void T264_cabac_mb_skip( T264_t *t, int b_skip )
  597. {
  598. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  599.     int ctx = 0;
  601.     if( t->mb.mb_x > 0 && !IS_SKIP( mb_ctxs[t->mb.mb_xy -1].mb_mode) )
  602.     {
  603.         ctx++;
  604.     }
  605.     if( t->mb.mb_y > 0 && !IS_SKIP( mb_ctxs[t->mb.mb_xy - t->mb_stride].mb_mode) )
  606.     {
  607.         ctx++;
  608.     }
  610.     if( t->slice_type == SLICE_P )
  611.         T264_cabac_encode_decision( &t->cabac, 11 + ctx, b_skip ? 1 : 0 );
  612.     else /* SLICE_TYPE_B */
  613.         T264_cabac_encode_decision( &t->cabac, 24 + ctx, b_skip ? 1 : 0 );
  614. }
  616. static __inline  void T264_cabac_mb_sub_p_partition( T264_t *t, int i_sub )
  617. {
  618.     if( i_sub == MB_8x8 )
  619.     {
  620.             T264_cabac_encode_decision( &t->cabac, 21, 1 );
  621.     }
  622.     else if( i_sub == MB_8x4 )
  623.     {
  624.             T264_cabac_encode_decision( &t->cabac, 21, 0 );
  625.             T264_cabac_encode_decision( &t->cabac, 22, 0 );
  626.     }
  627.     else if( i_sub == MB_4x8 )
  628.     {
  629.             T264_cabac_encode_decision( &t->cabac, 21, 0 );
  630.             T264_cabac_encode_decision( &t->cabac, 22, 1 );
  631.             T264_cabac_encode_decision( &t->cabac, 23, 1 );
  632.     }
  633.     else if( i_sub == MB_4x4 )
  634.     {
  635.             T264_cabac_encode_decision( &t->cabac, 21, 0 );
  636.             T264_cabac_encode_decision( &t->cabac, 22, 1 );
  637.             T264_cabac_encode_decision( &t->cabac, 23, 0 );
  638.     }
  639. }
  641. static __inline  void T264_cabac_mb_sub_b_partition( T264_t *t, int i_sub )
  642. {
  643.     if( i_sub == B_DIRECT_8x8 )
  644.     {
  645.         T264_cabac_encode_decision( &t->cabac, 36, 0 );
  646.     }
  647.     else if( i_sub == B_L0_8x8 )
  648.     {
  649.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  650.         T264_cabac_encode_decision( &t->cabac, 37, 0 );
  651.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  652.     }
  653.     else if( i_sub == B_L1_8x8 )
  654.     {
  655.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  656.         T264_cabac_encode_decision( &t->cabac, 37, 0 );
  657.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  658.     }
  659.     else if( i_sub == B_Bi_8x8 )
  660.     {
  661.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  662.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  663.         T264_cabac_encode_decision( &t->cabac, 38, 0 );
  664.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  665.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  666.     }
  667.     else if( i_sub == B_L0_8x4 )
  668.     {
  669.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  670.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  671.         T264_cabac_encode_decision( &t->cabac, 38, 0 );
  672.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  673.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  674.     }
  675.     else if( i_sub == B_L0_4x8 )
  676.     {
  677.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  678.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  679.         T264_cabac_encode_decision( &t->cabac, 38, 0 );
  680.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  681.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  682.     }
  683.     else if( i_sub == B_L1_8x4 )
  684.     {
  685.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  686.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  687.         T264_cabac_encode_decision( &t->cabac, 38, 0 );
  688.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  689.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  690.     }
  691.     else if( i_sub == B_L1_4x8 )
  692.     {
  693.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  694.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  695.         T264_cabac_encode_decision( &t->cabac, 38, 1 );
  696.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  697.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  698.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  699.     }
  700.     else if( i_sub == B_Bi_8x4 )
  701.     {
  702.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  703.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  704.         T264_cabac_encode_decision( &t->cabac, 38, 1 );
  705.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  706.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  707.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  708.     }
  709.     else if( i_sub == B_Bi_4x8 )
  710.     {
  711.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  712.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  713.         T264_cabac_encode_decision( &t->cabac, 38, 1 );
  714.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  715.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  716.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  717.     }
  718.     else if( i_sub == B_L0_4x4 )
  719.     {
  720.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  721.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  722.         T264_cabac_encode_decision( &t->cabac, 38, 1 );
  723.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  724.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  725.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  726.     }
  727.     else if( i_sub == B_L1_4x4 )
  728.     {
  729.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  730.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  731.         T264_cabac_encode_decision( &t->cabac, 38, 1 );
  732.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  733.         T264_cabac_encode_decision( &t->cabac, 39, 0 );
  734.     }
  735.     else if( i_sub == B_Bi_4x4 )
  736.     {
  737.         T264_cabac_encode_decision( &t->cabac, 36, 1 );
  738.         T264_cabac_encode_decision( &t->cabac, 37, 1 );
  739.         T264_cabac_encode_decision( &t->cabac, 38, 1 );
  740.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  741.         T264_cabac_encode_decision( &t->cabac, 39, 1 );
  742.     }
  743. }
  746. static __inline  void T264_cabac_mb_ref( T264_t *t, int i_list, int idx )
  747. {
  748. const int i8    = T264_scan8[idx];
  749. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  750. const int i_refa = t->mb.vec_ref[i8 - 1].vec[i_list].refno;
  751.     const int i_refb = t->mb.vec_ref[i8 - 8].vec[i_list].refno;
  752.     int i_ref  = t->mb.vec_ref[i8].vec[i_list].refno;
  753. int a_direct, b_direct;
  754. int ctx  = 0;
  755. int luma_idx = luma_index[idx];
  756. 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)
  757. {
  758. a_direct = 1;
  759. }
  760. else
  761. a_direct = 0;
  762. 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)
  763. {
  764. b_direct = 1;
  765. }
  766. else
  767. b_direct = 0;
  769.     if( i_refa>0 && !a_direct)
  770.         ctx++;
  771.     if( i_refb>0 && !b_direct)
  772.         ctx += 2;
  774.     while( i_ref > 0 )
  775.     {
  776.         T264_cabac_encode_decision( &t->cabac, 54 + ctx, 1 );
  777.         if( ctx < 4 )
  778.             ctx = 4;
  779.         else
  780.             ctx = 5;
  782.         i_ref--;
  783.     }
  784.     T264_cabac_encode_decision( &t->cabac, 54 + ctx, 0 );
  785. }
  788. static __inline  void  T264_cabac_mb_mvd_cpn( T264_t *t, int i_list, int i8, int l, int mvd )
  789. {
  790.     const int amvd = abs( t->mb.mvd_ref[i_list][i8 - 1][l] ) +
  791.                      abs( t->mb.mvd_ref[i_list][i8 - 8][l] );
  792.     const int i_abs = abs( mvd );
  793.     const int i_prefix = T264_MIN( i_abs, 9 );
  794.     const int ctxbase = (l == 0 ? 40 : 47);
  795.     int ctx;
  796.     int i;
  799.     if( amvd < 3 )
  800.         ctx = 0;
  801.     else if( amvd > 32 )
  802.         ctx = 2;
  803.     else
  804.         ctx = 1;
  806.     for( i = 0; i < i_prefix; i++ )
  807.     {
  808.         T264_cabac_encode_decision( &t->cabac, ctxbase + ctx, 1 );
  809.         if( ctx < 3 )
  810.             ctx = 3;
  811.         else if( ctx < 6 )
  812.             ctx++;
  813.     }
  814.     if( i_prefix < 9 )
  815.     {
  816.         T264_cabac_encode_decision( &t->cabac, ctxbase + ctx, 0 );
  817.     }
  819.     if( i_prefix >= 9 )
  820.     {
  821.         int i_suffix = i_abs - 9;
  822.         int k = 3;
  824.         while( i_suffix >= (1<<k) )
  825.         {
  826.             T264_cabac_encode_bypass( &t->cabac, 1 );
  827.             i_suffix -= 1 << k;
  828.             k++;
  829.         }
  830.         T264_cabac_encode_bypass( &t->cabac, 0 );
  831.         while( k-- )
  832.         {
  833.             T264_cabac_encode_bypass( &t->cabac, (i_suffix >> k)&0x01 );
  834.         }
  835.     }
  837.     /* sign */
  838.     if( mvd > 0 )
  839.         T264_cabac_encode_bypass( &t->cabac, 0 );
  840.     else if( mvd < 0 )
  841.         T264_cabac_encode_bypass( &t->cabac, 1 );
  842. }
  844. static __inline  void  T264_cabac_mb_mvd( T264_t *t, int i_list, int idx, int width, int height )
  845. {
  846.     T264_vector_t mvp;
  847.     int mdx, mdy;
  848. int i, j;
  849. int i8    = T264_scan8[idx];
  850. int luma_idx = luma_index[idx];
  851.     /* Calculate mvd */
  852. mvp.refno = t->mb.vec_ref[i8].vec[i_list].refno;
  853.     T264_predict_mv( t, i_list, luma_idx, width, &mvp );
  854. mdx = t->mb.vec_ref[i8].vec[i_list].x - mvp.x;
  855. mdy = t->mb.vec_ref[i8].vec[i_list].y - mvp.y;
  856.     
  857.     /* encode */
  858.     T264_cabac_mb_mvd_cpn( t, i_list, i8, 0, mdx );
  859.     T264_cabac_mb_mvd_cpn( t, i_list, i8, 1, mdy );
  860. /* save mvd value */
  861. for(j=0; j<height; j++)
  862. {
  863. for(i=0; i<width; i++)
  864. {
  865. t->mb.mvd_ref[i_list][i8+i][0] = mdx;
  866. t->mb.mvd_ref[i_list][i8+i][1] = mdy;
  867. t->mb.mvd[i_list][luma_idx+i][0] = mdx;
  868. t->mb.mvd[i_list][luma_idx+i][1] = mdy;
  869. }
  870. i8 += 8;
  871. luma_idx += 4;
  872. }
  873. }
  875. static __inline void T264_cabac_mb8x8_mvd( T264_t *t, int i_list )
  876. {
  877. int i;
  878. int sub_part;
  879. for( i = 0; i < 4; i++ )
  880. {
  881. sub_part = t->mb.submb_part[luma_index[i<<2]];
  882. if( T264_mb_partition_listX_table[sub_part-B_DIRECT_8x8][i_list] == 0 )
  883. {
  884. continue;
  885. }
  887. switch( sub_part )
  888. {
  889. case B_DIRECT_8x8:
  890. assert(0);
  891. break;
  892. case B_L0_8x8:
  893. case B_L1_8x8:
  894. case B_Bi_8x8:
  895. T264_cabac_mb_mvd( t, i_list, 4*i, 2, 2 );
  896. break;
  897. case B_L0_8x4:
  898. case B_L1_8x4:
  899. case B_Bi_8x4:
  900. T264_cabac_mb_mvd( t, i_list, 4*i+0, 2, 1 );
  901. T264_cabac_mb_mvd( t, i_list, 4*i+2, 2, 1 );
  902. break;
  903. case B_L0_4x8:
  904. case B_L1_4x8:
  905. case B_Bi_4x8:
  906. T264_cabac_mb_mvd( t, i_list, 4*i+0, 1, 2 );
  907. T264_cabac_mb_mvd( t, i_list, 4*i+1, 1, 2 );
  908. break;
  909. case B_L0_4x4:
  910. case B_L1_4x4:
  911. case B_Bi_4x4:
  912. T264_cabac_mb_mvd( t, i_list, 4*i+0, 1, 1 );
  913. T264_cabac_mb_mvd( t, i_list, 4*i+1, 1, 1 );
  914. T264_cabac_mb_mvd( t, i_list, 4*i+2, 1, 1 );
  915. T264_cabac_mb_mvd( t, i_list, 4*i+3, 1, 1 );
  916. break;
  917. }
  918. }
  919. }
  921. static int T264_cabac_mb_cbf_ctxidxinc( T264_t *t, int i_cat, int i_idx )
  922. {
  923.     /* TODO: clean up/optimize */
  924. T264_mb_context_t *mb_ctxs = &(t->rec->mb[0]);
  925. T264_mb_context_t *mb_ctx;
  926.     int i_mba_xy = -1;
  927.     int i_mbb_xy = -1;
  928.     int i_nza = -1;
  929.     int i_nzb = -1;
  930.     int ctx = 0;
  931. int cbp;
  933.     if( i_cat == 0 )
  934.     {
  935.         if( t->mb.mb_x > 0 )
  936.         {
  937.             i_mba_xy = t->mb.mb_xy -1;
  938. mb_ctx = &(mb_ctxs[i_mba_xy]);
  939.             if( mb_ctx->mb_mode == I_16x16 )
  940.             {
  941.                 i_nza = (mb_ctx->cbp & 0x100);
  942.             }
  943.         }
  944.         if( t->mb.mb_y > 0 )
  945.         {
  946.             i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  947. mb_ctx = &(mb_ctxs[i_mbb_xy]);
  948.             if( mb_ctx->mb_mode == I_16x16 )
  949.             {
  950.                 i_nzb = (mb_ctx->cbp & 0x100);
  951.             }
  952.         }
  953.     }
  954.     else if( i_cat == 1 || i_cat == 2 )
  955.     {
  956.         int x = luma_inverse_x[i_idx];
  957.         int y = luma_inverse_y[i_idx];
  958. int i8 = T264_scan8[i_idx];
  959.         if( x > 0 )
  960.             i_mba_xy = t->mb.mb_xy;
  961.         else if( t->mb.mb_x > 0 )
  962.             i_mba_xy = t->mb.mb_xy -1;
  964.         if( y > 0 )
  965.             i_mbb_xy = t->mb.mb_xy;
  966.         else if( t->mb.mb_y > 0 )
  967.             i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  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( (mb_ctxs[i_mba_xy].cbp_y&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( (mb_ctxs[i_mbb_xy].cbp_y&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.         if( t->mb.mb_x > 0 )
  991.         {
  992.             i_mba_xy = t->mb.mb_xy -1;
  993. cbp = mb_ctxs[i_mba_xy].cbp;
  994.             if( cbp&0x30 )
  995.             {
  996.                 i_nza = cbp&( 0x02 << ( 8 + i_idx) );
  997.             }
  998.         }
  999.         if( t->mb.mb_y > 0 )
  1000.         {
  1001.             i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  1002. cbp = mb_ctxs[i_mbb_xy].cbp;
  1003.             if( cbp&0x30 )
  1004.             {
  1005.                 i_nzb = cbp&( 0x02 << ( 8 + i_idx) );
  1006.             }
  1007.         }
  1008.     }
  1009.     else if( i_cat == 4 )
  1010.     {
  1011.         int idxc = i_idx% 4;
  1013.         if( idxc == 1 || idxc == 3 )
  1014.             i_mba_xy = t->mb.mb_xy;
  1015.         else if( t->mb.mb_x > 0 )
  1016.             i_mba_xy = t->mb.mb_xy - 1;
  1018.         if( idxc == 2 || idxc == 3 )
  1019.             i_mbb_xy = t->mb.mb_xy;
  1020.         else if( t->mb.mb_y > 0 )
  1021.             i_mbb_xy = t->mb.mb_xy - t->mb_stride;
  1023.         /* no need to test skip/pcm */
  1024.         if( i_mba_xy >= 0 && (mb_ctxs[i_mba_xy].cbp&0x30) == 0x20 )
  1025.         {
  1026.             i_nza = t->mb.nnz_ref[T264_scan8[16+i_idx] - 1];
  1027.         }
  1028.         if( i_mbb_xy >= 0 && (mb_ctxs[i_mbb_xy].cbp&0x30) == 0x20 )
  1029.         {
  1030.             i_nzb = t->mb.nnz_ref[T264_scan8[16+i_idx] - 8];
  1031.         }
  1032.     }
  1034.     if( ( i_mba_xy < 0  && IS_INTRA( t->mb.mb_mode ) ) || i_nza > 0 )
  1035.     {
  1036.         ctx++;
  1037.     }
  1038.     if( ( i_mbb_xy < 0  && IS_INTRA( t->mb.mb_mode ) ) || i_nzb > 0 )
  1039.     {
  1040.         ctx += 2;
  1041.     }
  1043.     return 4 * i_cat + ctx;
  1044. }
  1047. static void block_residual_write_cabac( T264_t *t, int i_ctxBlockCat, int i_idx, int16_t *l, int i_count )
  1048. {
  1049.     static const int significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 };
  1050.     static const int last_significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 };
  1051.     static const int coeff_abs_level_m1_offset[5] = { 0, 10, 20, 30, 39 };
  1053.     int i_coeff_abs_m1[16];
  1054.     int i_coeff_sign[16];
  1055.     int i_coeff = 0;
  1056.     int i_last  = 0;
  1058.     int i_abslevel1 = 0;
  1059.     int i_abslevelgt1 = 0;
  1061.     int i;
  1063.     /* i_ctxBlockCat: 0-> DC 16x16  i_idx = 0
  1064.      *                1-> AC 16x16  i_idx = luma4x4idx
  1065.      *                2-> Luma4x4   i_idx = luma4x4idx
  1066.      *                3-> DC Chroma i_idx = iCbCr
  1067.      *                4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
  1068.      */
  1070.     //fprintf( stderr, "l[] = " );
  1071.     for( i = 0; i < i_count; i++ )
  1072.     {
  1073.         //fprintf( stderr, "%d ", l[i] );
  1074.         if( l[i] != 0 )
  1075.         {
  1076.             i_coeff_abs_m1[i_coeff] = abs( l[i] ) - 1;
  1077.             i_coeff_sign[i_coeff]   = ( l[i] < 0 ? 1 : 0);
  1078.             i_coeff++;
  1080.             i_last = i;
  1081.         }
  1082.     }
  1083.     //fprintf( stderr, "n" );
  1085.     if( i_coeff == 0 )
  1086.     {
  1087.         /* codec block flag */
  1088.         T264_cabac_encode_decision( &t->cabac,  85 + T264_cabac_mb_cbf_ctxidxinc( t, i_ctxBlockCat, i_idx ), 0 );
  1089.         return;
  1090.     }
  1092.     /* block coded */
  1093.     T264_cabac_encode_decision( &t->cabac,  85 + T264_cabac_mb_cbf_ctxidxinc( t, i_ctxBlockCat, i_idx ), 1 );
  1094.     for( i = 0; i < i_count - 1; i++ )
  1095.     {
  1096.         int i_ctxIdxInc;
  1098.         i_ctxIdxInc = T264_MIN( i, i_count - 2 );
  1100.         if( l[i] != 0 )
  1101.         {
  1102.             T264_cabac_encode_decision( &t->cabac, 105 + significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc, 1 );
  1103.             T264_cabac_encode_decision( &t->cabac, 166 + last_significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc, i == i_last ? 1 : 0 );
  1104.         }
  1105.         else
  1106.         {
  1107.             T264_cabac_encode_decision( &t->cabac, 105 + significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc, 0 );
  1108.         }
  1109.         if( i == i_last )
  1110.         {
  1111.             break;
  1112.         }
  1113.     }
  1115.     for( i = i_coeff - 1; i >= 0; i-- )
  1116.     {
  1117.         int i_prefix;
  1118.         int i_ctxIdxInc;
  1120.         /* write coeff_abs - 1 */
  1122.         /* prefix */
  1123.         i_prefix = T264_MIN( i_coeff_abs_m1[i], 14 );
  1125.         i_ctxIdxInc = (i_abslevelgt1 != 0 ? 0 : T264_MIN( 4, i_abslevel1 + 1 )) + coeff_abs_level_m1_offset[i_ctxBlockCat];
  1126.         if( i_prefix == 0 )
  1127.         {
  1128.             T264_cabac_encode_decision( &t->cabac,  227 + i_ctxIdxInc, 0 );
  1129.         }
  1130.         else
  1131.         {
  1132.             int j;
  1133.             T264_cabac_encode_decision( &t->cabac,  227 + i_ctxIdxInc, 1 );
  1134.             i_ctxIdxInc = 5 + T264_MIN( 4, i_abslevelgt1 ) + coeff_abs_level_m1_offset[i_ctxBlockCat];
  1135.             for( j = 0; j < i_prefix - 1; j++ )
  1136.             {
  1137.                 T264_cabac_encode_decision( &t->cabac,  227 + i_ctxIdxInc, 1 );
  1138.             }
  1139.             if( i_prefix < 14 )
  1140.             {
  1141.                 T264_cabac_encode_decision( &t->cabac,  227 + i_ctxIdxInc, 0 );
  1142.             }
  1143.         }
  1144.         /* suffix */
  1145.         if( i_coeff_abs_m1[i] >= 14 )
  1146.         {
  1147.             int k = 0;
  1148.             int i_suffix = i_coeff_abs_m1[i] - 14;
  1150.             while( i_suffix >= (1<<k) )
  1151.             {
  1152.                 T264_cabac_encode_bypass( &t->cabac, 1 );
  1153.                 i_suffix -= 1 << k;
  1154.                 k++;
  1155.             }
  1156.             T264_cabac_encode_bypass( &t->cabac, 0 );
  1157.             while( k-- )
  1158.             {
  1159.                 T264_cabac_encode_bypass( &t->cabac, (i_suffix >> k)&0x01 );
  1160.             }
  1161.         }
  1163.         /* write sign */
  1164.         T264_cabac_encode_bypass( &t->cabac, i_coeff_sign[i] );
  1167.         if( i_coeff_abs_m1[i] == 0 )
  1168.         {
  1169.             i_abslevel1++;
  1170.         }
  1171.         else
  1172.         {
  1173.             i_abslevelgt1++;
  1174.         }
  1175.     }
  1176. }
  1179. static int8_t
  1180. T264_mb_predict_intra4x4_mode(T264_t *t, int32_t idx)
  1181. {
  1182. int32_t x, y;
  1183. int8_t nA, nB, pred_blk;
  1185. x = luma_inverse_x[idx];
  1186. y = luma_inverse_y[idx];
  1188. nA = t->mb.i4x4_pred_mode_ref[IPM_LUMA + x + y * 8 - 1];
  1189. nB = t->mb.i4x4_pred_mode_ref[IPM_LUMA + x + y * 8 - 8];
  1191. pred_blk  = T264_MIN(nA, nB);
  1193. if( pred_blk < 0 )
  1194. return Intra_4x4_DC;
  1196. return pred_blk;
  1197. }
  1199. void T264_macroblock_write_cabac( T264_t *t, bs_t *s )
  1200. {
  1201.     const int i_mb_type = t->mb.mb_mode;
  1202.     const int i_mb_pos_start = BitstreamPos( s );
  1203.     int       i_mb_pos_tex;
  1205.     int i;
  1207.     /* Write the MB type */
  1208.     T264_cabac_mb_type( t );
  1210.     /* PCM special block type UNTESTED */
  1211. /* no PCM here*/
  1213.     if( IS_INTRA( i_mb_type ) )
  1214.     {
  1215.         /* Prediction */
  1216.         if( i_mb_type == I_4x4 )
  1217.         {
  1218.             for( i = 0; i < 16; i++ )
  1219.             {
  1220.                 const int i_pred = T264_mb_predict_intra4x4_mode( t, i );
  1221.                 const int i_mode = t->mb.i4x4_pred_mode_ref[T264_scan8[i]];
  1222.                 T264_cabac_mb_intra4x4_pred_mode( t, i_pred, i_mode );
  1223.             }
  1224.         }
  1225.         T264_cabac_mb_intra8x8_pred_mode( t );
  1226.     }
  1227.     else if( i_mb_type == P_MODE )
  1228.     {
  1229.         if( t->mb.mb_part == MB_16x16 )
  1230.         {
  1231.             if( t->ps.num_ref_idx_l0_active_minus1 > 0 )
  1232.             {
  1233.                 T264_cabac_mb_ref( t, 0, 0 );
  1234.             }
  1235.             T264_cabac_mb_mvd( t, 0, 0, 4, 4 );
  1236.         }
  1237.         else if( t->mb.mb_part == MB_16x8 )
  1238.         {
  1239.             if( t->ps.num_ref_idx_l0_active_minus1 > 0 )
  1240.             {
  1241.                 T264_cabac_mb_ref( t, 0, 0 );
  1242.                 T264_cabac_mb_ref( t, 0, 8 );
  1243.             }
  1244.             T264_cabac_mb_mvd( t, 0, 0, 4, 2 );
  1245.             T264_cabac_mb_mvd( t, 0, 8, 4, 2 );
  1246.         }
  1247.         else if( t->mb.mb_part == MB_8x16 )
  1248.         {
  1249.             if( t->ps.num_ref_idx_l0_active_minus1 > 0 )
  1250.             {
  1251.                 T264_cabac_mb_ref( t, 0, 0 );
  1252.                 T264_cabac_mb_ref( t, 0, 4 );
  1253.             }
  1254.             T264_cabac_mb_mvd( t, 0, 0, 2, 4 );
  1255.             T264_cabac_mb_mvd( t, 0, 4, 2, 4 );
  1256.         }
  1257. else /* 8x8 */
  1258. {
  1259. /* sub mb type */
  1260. T264_cabac_mb_sub_p_partition( t, t->mb.submb_part[0] );
  1261. T264_cabac_mb_sub_p_partition( t, t->mb.submb_part[2] );
  1262. T264_cabac_mb_sub_p_partition( t, t->mb.submb_part[8] );
  1263. T264_cabac_mb_sub_p_partition( t, t->mb.submb_part[10] );
  1265. /* ref 0 */
  1266. if( t->ps.num_ref_idx_l0_active_minus1 > 0 )
  1267. {
  1268. T264_cabac_mb_ref( t, 0, 0 );
  1269. T264_cabac_mb_ref( t, 0, 4 );
  1270. T264_cabac_mb_ref( t, 0, 8 );
  1271. T264_cabac_mb_ref( t, 0, 12 );
  1272. }
  1274. for( i = 0; i < 4; i++ )
  1275. {
  1276. switch( t->mb.submb_part[luma_index[i<<2]] )
  1277. {
  1278. case MB_8x8:
  1279. T264_cabac_mb_mvd( t, 0, 4*i, 2, 2 );
  1280. break;
  1281. case MB_8x4:
  1282. T264_cabac_mb_mvd( t, 0, 4*i+0, 2, 1 );
  1283. T264_cabac_mb_mvd( t, 0, 4*i+2, 2, 1 );
  1284. break;
  1285. case MB_4x8:
  1286. T264_cabac_mb_mvd( t, 0, 4*i+0, 1, 2 );
  1287. T264_cabac_mb_mvd( t, 0, 4*i+1, 1, 2 );
  1288. break;
  1289. case MB_4x4:
  1290. T264_cabac_mb_mvd( t, 0, 4*i+0, 1, 1 );
  1291. T264_cabac_mb_mvd( t, 0, 4*i+1, 1, 1 );
  1292. T264_cabac_mb_mvd( t, 0, 4*i+2, 1, 1 );
  1293. T264_cabac_mb_mvd( t, 0, 4*i+3, 1, 1 );
  1294. break;
  1295. }
  1296. }
  1297. }
  1298.     }
  1299.     else if( i_mb_type == B_MODE )
  1300.     {
  1301. if((t->mb.mb_part==MB_16x16&&t->mb.is_copy!=1) || (t->mb.mb_part==MB_16x8) || (t->mb.mb_part==MB_8x16))
  1302. {
  1303. /* to be changed here*/
  1304. /* All B mode */
  1305. int i_list;
  1306. int b_list[2][2];
  1307. const int i_partition = t->mb.mb_part;
  1308. int b_part_mode, part_mode0, part_mode1;
  1309. static const int b_part_mode_map[3][3] = {
  1310. { B_L0_L0, B_L0_L1, B_L0_BI },
  1311. { B_L1_L0, B_L1_L1, B_L1_BI },
  1312. { B_BI_L0, B_BI_L1, B_BI_BI }
  1313. };
  1315. switch(t->mb.mb_part)
  1316. {
  1317. case MB_16x16:
  1318. part_mode0 = t->mb.mb_part2[0] - B_L0_16x16;
  1319. b_part_mode = b_part_mode_map[part_mode0][part_mode0];
  1320. break;
  1321. case MB_16x8:
  1322. part_mode0 = t->mb.mb_part2[0] - B_L0_16x8;
  1323. part_mode1 = t->mb.mb_part2[1] - B_L0_16x8;
  1324. b_part_mode = b_part_mode_map[part_mode0][part_mode1];
  1325. break;
  1326. case MB_8x16:
  1327. part_mode0 = t->mb.mb_part2[0] - B_L0_8x16;
  1328. part_mode1 = t->mb.mb_part2[1] - B_L0_8x16;
  1329. b_part_mode = b_part_mode_map[part_mode0][part_mode1];
  1330. break;
  1331. }
  1332. /* init ref list utilisations */
  1333. for( i = 0; i < 2; i++ )
  1334. {
  1335. b_list[0][i] = T264_mb_type_list0_table[b_part_mode][i];
  1336. b_list[1][i] = T264_mb_type_list1_table[b_part_mode][i];
  1337. }
  1338. for( i_list = 0; i_list < 2; i_list++ )
  1339. {
  1340. const int i_ref_max = i_list == 0 ? t->ps.num_ref_idx_l0_active_minus1+1 : t->ps.num_ref_idx_l1_active_minus1+1;
  1342. if( i_ref_max > 1 )
  1343. {
  1344. if( t->mb.mb_part == MB_16x16 )
  1345. {
  1346. if( b_list[i_list][0] ) T264_cabac_mb_ref( t, i_list, 0 );
  1347. }
  1348. else if( t->mb.mb_part == MB_16x8 )
  1349. {
  1350. if( b_list[i_list][0] ) T264_cabac_mb_ref( t, i_list, 0 );
  1351. if( b_list[i_list][1] ) T264_cabac_mb_ref( t, i_list, 8 );
  1352. }
  1353. else if( t->mb.mb_part == MB_8x16 )
  1354. {
  1355. if( b_list[i_list][0] ) T264_cabac_mb_ref( t, i_list, 0 );
  1356. if( b_list[i_list][1] ) T264_cabac_mb_ref( t, i_list, 4 );
  1357. }
  1358. }
  1359. }
  1360. for( i_list = 0; i_list < 2; i_list++ )
  1361. {
  1362. if( t->mb.mb_part == MB_16x16 )
  1363. {
  1364. if( b_list[i_list][0] ) T264_cabac_mb_mvd( t, i_list, 0, 4, 4 );
  1365. }
  1366. else if( t->mb.mb_part == MB_16x8 )
  1367. {
  1368. if( b_list[i_list][0] ) T264_cabac_mb_mvd( t, i_list, 0, 4, 2 );
  1369. if( b_list[i_list][1] ) T264_cabac_mb_mvd( t, i_list, 8, 4, 2 );
  1370. }
  1371. else if( t->mb.mb_part == MB_8x16 )
  1372. {
  1373. if( b_list[i_list][0] ) T264_cabac_mb_mvd( t, i_list, 0, 2, 4 );
  1374. if( b_list[i_list][1] ) T264_cabac_mb_mvd( t, i_list, 4, 2, 4 );
  1375. }
  1376. }
  1377. }
  1378. else if(t->mb.mb_part==MB_16x16 && t->mb.is_copy)
  1379. {
  1380. }
  1381. else /* B8x8 */
  1382. {
  1383. /* TODO */
  1384. int i_list;
  1385. /* sub mb type */
  1386. T264_cabac_mb_sub_b_partition( t, t->mb.submb_part[0] );
  1387. T264_cabac_mb_sub_b_partition( t, t->mb.submb_part[2] );
  1388. T264_cabac_mb_sub_b_partition( t, t->mb.submb_part[8] );
  1389. T264_cabac_mb_sub_b_partition( t, t->mb.submb_part[10] );
  1391. /* ref */
  1392. for( i_list = 0; i_list < 2; i_list++ )
  1393. {
  1394. if( ( i_list ? t->ps.num_ref_idx_l1_active_minus1 : t->ps.num_ref_idx_l0_active_minus1 ) == 0 )
  1395. continue;
  1396. for( i = 0; i < 4; i++ )
  1397. {
  1398. int sub_part = t->mb.submb_part[luma_index[i<<2]]-B_DIRECT_8x8;
  1399. if( T264_mb_partition_listX_table[sub_part][i_list] == 1 )
  1400. {
  1401. T264_cabac_mb_ref( t, i_list, 4*i );
  1402. }
  1403. }
  1404. }
  1405. T264_cabac_mb8x8_mvd( t, 0 );
  1406. T264_cabac_mb8x8_mvd( t, 1 );
  1407. }
  1408.     }
  1409.     
  1410.     i_mb_pos_tex = BitstreamPos( s );
  1411.     
  1412.     if( i_mb_type != I_16x16 )
  1413.     {
  1414.         T264_cabac_mb_cbp_luma( t );
  1415.         T264_cabac_mb_cbp_chroma( t );
  1416.     }
  1418.     if( t->mb.cbp_y > 0 || t->mb.cbp_c > 0 || i_mb_type == I_16x16 )
  1419.     {
  1420.         T264_cabac_mb_qp_delta( t );
  1422.         /* write residual */
  1423.         if( i_mb_type == I_16x16 )
  1424.         {
  1425.             /* DC Luma */
  1426.             block_residual_write_cabac( t, 0, 0, t->mb.dc4x4_z, 16 );
  1428.             if( t->mb.cbp_y != 0 )
  1429.             {
  1430.                 /* AC Luma */
  1431.                 for( i = 0; i < 16; i++ )
  1432.                 {
  1433.                     block_residual_write_cabac( t, 1, i, &(t->mb.dct_y_z[i][1]), 15 );
  1434.                 }
  1435.             }
  1436.         }
  1437.         else
  1438.         {
  1439. if(t->frame_num == 1)
  1440. t->frame_num = 1;
  1441.             for( i = 0; i < 16; i++ )
  1442.             {
  1443.                 if( t->mb.cbp_y & ( 1 << ( i / 4 ) ) )
  1444.                 {
  1445.                     block_residual_write_cabac( t, 2, i, &(t->mb.dct_y_z[i][0]), 16 );
  1446.                 }
  1447.             }
  1448.         }
  1450.         if( t->mb.cbp_c&0x03 )    /* Chroma DC residual present */
  1451.         {
  1452.             block_residual_write_cabac( t, 3, 0, &(t->mb.dc2x2_z[0][0]), 4 );
  1453.             block_residual_write_cabac( t, 3, 1, &(t->mb.dc2x2_z[1][0]), 4 );
  1454.         }
  1455.         if( t->mb.cbp_c&0x02 ) /* Chroma AC residual present */
  1456.         {
  1457.             for( i = 0; i < 8; i++ )
  1458.             {
  1459.                 block_residual_write_cabac( t, 4, i, &(t->mb.dct_uv_z[i>>2][i&0x03][1]), 15);
  1460.             }
  1461.         }
  1462.     }
  1463. /*
  1464.     if( IS_INTRA( i_mb_type ) )
  1465.         t->stat.frame.i_itex_bits += bs_pos(s) - i_mb_pos_tex;
  1466.     else
  1467.         t->stat.frame.i_ptex_bits += bs_pos(s) - i_mb_pos_tex;
  1468. */
  1469. }