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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
cabac.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：39k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

cabac.c：源码内容
  1. /*****************************************************************************
  2.  * cabac.c: h264 encoder library
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2008 x264 project
  5.  *
  6.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  7.  *          Loren Merritt <lorenm@u.washington.edu>
  8.  *          Jason Garrett-Glaser <darkshikari@gmail.com>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. #include "common/common.h"
  26. #include "macroblock.h"
  28. #ifndef RDO_SKIP_BS
  29. #define RDO_SKIP_BS 0
  30. #endif
  32. static inline void x264_cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
  33.                     int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
  34. {
  35.     if( i_mb_type == I_4x4 || i_mb_type == I_8x8 )
  36.     {
  37.         x264_cabac_encode_decision_noup( cb, ctx0, 0 );
  38.     }
  39. #if !RDO_SKIP_BS
  40.     else if( i_mb_type == I_PCM )
  41.     {
  42.         x264_cabac_encode_decision_noup( cb, ctx0, 1 );
  43.         x264_cabac_encode_flush( h, cb );
  44.     }
  45. #endif
  46.     else
  47.     {
  48.         int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
  50.         x264_cabac_encode_decision_noup( cb, ctx0, 1 );
  51.         x264_cabac_encode_terminal( cb );
  53.         x264_cabac_encode_decision_noup( cb, ctx1, !!h->mb.i_cbp_luma );
  54.         if( h->mb.i_cbp_chroma == 0 )
  55.             x264_cabac_encode_decision_noup( cb, ctx2, 0 );
  56.         else
  57.         {
  58.             x264_cabac_encode_decision( cb, ctx2, 1 );
  59.             x264_cabac_encode_decision_noup( cb, ctx3, h->mb.i_cbp_chroma>>1 );
  60.         }
  61.         x264_cabac_encode_decision( cb, ctx4, i_pred>>1 );
  62.         x264_cabac_encode_decision_noup( cb, ctx5, i_pred&1 );
  63.     }
  64. }
  66. static void x264_cabac_mb_type( x264_t *h, x264_cabac_t *cb )
  67. {
  68.     const int i_mb_type = h->mb.i_type;
  70.     if( h->sh.b_mbaff &&
  71.         (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
  72.     {
  73.         x264_cabac_encode_decision_noup( cb, 70 + h->mb.cache.i_neighbour_interlaced, h->mb.b_interlaced );
  74.     }
  76.     if( h->sh.i_type == SLICE_TYPE_I )
  77.     {
  78.         int ctx = 0;
  79.         if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != I_4x4 )
  80.             ctx++;
  81.         if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != I_4x4 )
  82.             ctx++;
  84.         x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
  85.     }
  86.     else if( h->sh.i_type == SLICE_TYPE_P )
  87.     {
  88.         /* prefix: 14, suffix: 17 */
  89.         if( i_mb_type == P_L0 )
  90.         {
  91.             x264_cabac_encode_decision_noup( cb, 14, 0 );
  92.             x264_cabac_encode_decision_noup( cb, 15, h->mb.i_partition != D_16x16 );
  93.             x264_cabac_encode_decision_noup( cb, 17-(h->mb.i_partition == D_16x16), h->mb.i_partition == D_16x8 );
  94.         }
  95.         else if( i_mb_type == P_8x8 )
  96.         {
  97.             x264_cabac_encode_decision_noup( cb, 14, 0 );
  98.             x264_cabac_encode_decision_noup( cb, 15, 0 );
  99.             x264_cabac_encode_decision_noup( cb, 16, 1 );
  100.         }
  101.         else /* intra */
  102.         {
  103.             /* prefix */
  104.             x264_cabac_encode_decision_noup( cb, 14, 1 );
  106.             /* suffix */
  107.             x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
  108.         }
  109.     }
  110.     else //if( h->sh.i_type == SLICE_TYPE_B )
  111.     {
  112.         int ctx = 0;
  113.         if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != B_SKIP && h->mb.i_mb_type_left != B_DIRECT )
  114.             ctx++;
  115.         if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
  116.             ctx++;
  118.         if( i_mb_type == B_DIRECT )
  119.         {
  120.             x264_cabac_encode_decision_noup( cb, 27+ctx, 0 );
  121.             return;
  122.         }
  123.         x264_cabac_encode_decision_noup( cb, 27+ctx, 1 );
  125.         if( i_mb_type == B_8x8 )
  126.         {
  127.             x264_cabac_encode_decision_noup( cb, 27+3,   1 );
  128.             x264_cabac_encode_decision_noup( cb, 27+4,   1 );
  129.             x264_cabac_encode_decision( cb, 27+5,   1 );
  130.             x264_cabac_encode_decision( cb, 27+5,   1 );
  131.             x264_cabac_encode_decision_noup( cb, 27+5,   1 );
  132.         }
  133.         else if( IS_INTRA( i_mb_type ) )
  134.         {
  135.             /* prefix */
  136.             x264_cabac_encode_decision_noup( cb, 27+3,   1 );
  137.             x264_cabac_encode_decision_noup( cb, 27+4,   1 );
  138.             x264_cabac_encode_decision( cb, 27+5,   1 );
  139.             x264_cabac_encode_decision( cb, 27+5,   0 );
  140.             x264_cabac_encode_decision( cb, 27+5,   1 );
  142.             /* suffix */
  143.             x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
  144.         }
  145.         else
  146.         {
  147.             static const uint8_t i_mb_bits[9*3][6] =
  148.             {
  149.                 { 1,0,0,0,1,2 }, { 1,0,0,1,0,2 }, { 0,0,2,2,2,2 },  /* L0 L0 */
  150.                 { 1,0,1,0,1,2 }, { 1,0,1,1,0,2 }, {0},              /* L0 L1 */
  151.                 { 1,1,0,0,0,0 }, { 1,1,0,0,0,1 }, {0},              /* L0 BI */
  152.                 { 1,0,1,1,1,2 }, { 1,1,1,1,0,2 }, {0},              /* L1 L0 */
  153.                 { 1,0,0,1,1,2 }, { 1,0,1,0,0,2 }, { 0,1,2,2,2,2 },  /* L1 L1 */
  154.                 { 1,1,0,0,1,0 }, { 1,1,0,0,1,1 }, {0},              /* L1 BI */
  155.                 { 1,1,0,1,0,0 }, { 1,1,0,1,0,1 }, {0},              /* BI L0 */
  156.                 { 1,1,0,1,1,0 }, { 1,1,0,1,1,1 }, {0},              /* BI L1 */
  157.                 { 1,1,1,0,0,0 }, { 1,1,1,0,0,1 }, { 1,0,0,0,0,2 },  /* BI BI */
  158.             };
  160.             const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
  162.             x264_cabac_encode_decision_noup( cb, 27+3,   i_mb_bits[idx][0] );
  163.             x264_cabac_encode_decision( cb, 27+5-i_mb_bits[idx][0], i_mb_bits[idx][1] );
  164.             if( i_mb_bits[idx][2] != 2 )
  165.             {
  166.                 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][2] );
  167.                 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][3] );
  168.                 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][4] );
  169.                 if( i_mb_bits[idx][5] != 2 )
  170.                     x264_cabac_encode_decision_noup( cb, 27+5, i_mb_bits[idx][5] );
  171.             }
  172.         }
  173.     }
  174. }
  176. static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
  177. {
  178.     if( i_pred == i_mode )
  179.         x264_cabac_encode_decision( cb, 68, 1 );
  180.     else
  181.     {
  182.         x264_cabac_encode_decision( cb, 68, 0 );
  183.         if( i_mode > i_pred  )
  184.             i_mode--;
  185.         x264_cabac_encode_decision( cb, 69, (i_mode     )&0x01 );
  186.         x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
  187.         x264_cabac_encode_decision( cb, 69, (i_mode >> 2)      );
  188.     }
  189. }
  191. static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
  192. {
  193.     const int i_mode = x264_mb_pred_mode8x8c_fix[ h->mb.i_chroma_pred_mode ];
  194.     int       ctx = 0;
  196.     /* No need to test for I4x4 or I_16x16 as cache_save handle that */
  197.     if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_xy - 1] != 0 )
  198.         ctx++;
  199.     if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_top_xy] != 0 )
  200.         ctx++;
  202.     x264_cabac_encode_decision_noup( cb, 64 + ctx, i_mode > 0 );
  203.     if( i_mode > 0 )
  204.     {
  205.         x264_cabac_encode_decision( cb, 64 + 3, i_mode > 1 );
  206.         if( i_mode > 1 )
  207.             x264_cabac_encode_decision_noup( cb, 64 + 3, i_mode > 2 );
  208.     }
  209. }
  211. static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
  212. {
  213.     int cbp = h->mb.i_cbp_luma;
  214.     int cbp_l = h->mb.cache.i_cbp_left;
  215.     int cbp_t = h->mb.cache.i_cbp_top;
  216.     x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (h->mb.i_cbp_luma >> 0) & 1 );
  217.     x264_cabac_encode_decision( cb, 76 - ((cbp   >> 0) & 1) - ((cbp_t >> 2) & 2), (h->mb.i_cbp_luma >> 1) & 1 );
  218.     x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp   << 1) & 2), (h->mb.i_cbp_luma >> 2) & 1 );
  219.     x264_cabac_encode_decision_noup( cb, 76 - ((cbp   >> 2) & 1) - ((cbp   >> 0) & 2), (h->mb.i_cbp_luma >> 3) & 1 );
  220. }
  222. static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
  223. {
  224.     int cbp_a = h->mb.cache.i_cbp_left & 0x30;
  225.     int cbp_b = h->mb.cache.i_cbp_top  & 0x30;
  226.     int ctx = 0;
  228.     if( cbp_a && h->mb.cache.i_cbp_left != -1 ) ctx++;
  229.     if( cbp_b && h->mb.cache.i_cbp_top  != -1 ) ctx+=2;
  230.     if( h->mb.i_cbp_chroma == 0 )
  231.         x264_cabac_encode_decision_noup( cb, 77 + ctx, 0 );
  232.     else
  233.     {
  234.         x264_cabac_encode_decision_noup( cb, 77 + ctx, 1 );
  236.         ctx = 4;
  237.         if( cbp_a == 0x20 ) ctx++;
  238.         if( cbp_b == 0x20 ) ctx += 2;
  239.         x264_cabac_encode_decision_noup( cb, 77 + ctx, h->mb.i_cbp_chroma > 1 );
  240.     }
  241. }
  243. static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
  244. {
  245.     int i_mbn_xy = h->mb.i_mb_prev_xy;
  246.     int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
  247.     int ctx;
  249.     /* Avoid writing a delta quant if we have an empty i16x16 block, e.g. in a completely flat background area */
  250.     if( h->mb.i_type == I_16x16 && !h->mb.cbp[h->mb.i_mb_xy] )
  251.     {
  252. #if !RDO_SKIP_BS
  253.         h->mb.i_qp = h->mb.i_last_qp;
  254. #endif
  255.         i_dqp = 0;
  256.     }
  258.     /* No need to test for PCM / SKIP */
  259.     ctx = h->mb.i_last_dqp &&
  260.         ( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) );
  262.     if( i_dqp != 0 )
  263.     {
  264.         int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
  265.         /* dqp is interpreted modulo 52 */
  266.         if( val >= 51 && val != 52 )
  267.             val = 103 - val;
  268.         while( val-- )
  269.         {
  270.             x264_cabac_encode_decision( cb, 60 + ctx, 1 );
  271.             ctx = 2+(ctx>>1);
  272.         }
  273.     }
  274.     x264_cabac_encode_decision_noup( cb, 60 + ctx, 0 );
  275. }
  277. #if !RDO_SKIP_BS
  278. void x264_cabac_mb_skip( x264_t *h, int b_skip )
  279. {
  280.     int ctx = (h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ))
  281.             + (h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ))
  282.             + (h->sh.i_type == SLICE_TYPE_P ? 11 : 24);
  283.     x264_cabac_encode_decision( &h->cabac, ctx, b_skip );
  284. }
  285. #endif
  287. static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
  288. {
  289.     if( i_sub == D_L0_8x8 )
  290.     {
  291.         x264_cabac_encode_decision( cb, 21, 1 );
  292.         return;
  293.     }
  294.     x264_cabac_encode_decision( cb, 21, 0 );
  295.     if( i_sub == D_L0_8x4 )
  296.         x264_cabac_encode_decision( cb, 22, 0 );
  297.     else
  298.     {
  299.         x264_cabac_encode_decision( cb, 22, 1 );
  300.         x264_cabac_encode_decision( cb, 23, i_sub == D_L0_4x8 );
  301.     }
  302. }
  304. static inline void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
  305. {
  306.     if( i_sub == D_DIRECT_8x8 )
  307.     {
  308.         x264_cabac_encode_decision( cb, 36, 0 );
  309.         return;
  310.     }
  311.     x264_cabac_encode_decision( cb, 36, 1 );
  312.     if( i_sub == D_BI_8x8 )
  313.     {
  314.         x264_cabac_encode_decision( cb, 37, 1 );
  315.         x264_cabac_encode_decision( cb, 38, 0 );
  316.         x264_cabac_encode_decision( cb, 39, 0 );
  317.         x264_cabac_encode_decision( cb, 39, 0 );
  318.         return;
  319.     }
  320.     x264_cabac_encode_decision( cb, 37, 0 );
  321.     x264_cabac_encode_decision( cb, 39, i_sub == D_L1_8x8 );
  322. }
  324. static inline void x264_cabac_mb_transform_size( x264_t *h, x264_cabac_t *cb )
  325. {
  326.     int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
  327.     x264_cabac_encode_decision_noup( cb, ctx, h->mb.b_transform_8x8 );
  328. }
  330. static void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
  331. {
  332.     const int i8 = x264_scan8[idx];
  333.     const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
  334.     const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
  335.     int i_ref  = h->mb.cache.ref[i_list][i8];
  336.     int ctx  = 0;
  338.     if( i_refa > 0 && !h->mb.cache.skip[i8 - 1] )
  339.         ctx++;
  340.     if( i_refb > 0 && !h->mb.cache.skip[i8 - 8] )
  341.         ctx += 2;
  343.     while( i_ref > 0 )
  344.     {
  345.         x264_cabac_encode_decision( cb, 54 + ctx, 1 );
  346.         ctx = (ctx>>2)+4;
  347.         i_ref--;
  348.     }
  349.     x264_cabac_encode_decision( cb, 54 + ctx, 0 );
  350. }
  352. static inline void x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd, int ctx )
  353. {
  354.     const int i_abs = abs( mvd );
  355.     const int ctxbase = l ? 47 : 40;
  356.     int i;
  357. #if RDO_SKIP_BS
  358.     if( i_abs == 0 )
  359.         x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
  360.     else if( i_abs < 9 )
  361.     {
  362.         x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
  363.         if( i_abs > 4 )
  364.         {
  365.             x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
  366.             x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
  367.             x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
  368.             cb->f8_bits_encoded += cabac_size_unary[i_abs - 3][cb->state[ctxbase+6]];
  369.             cb->state[ctxbase+6] = cabac_transition_unary[i_abs - 3][cb->state[ctxbase+6]];
  370.         }
  371.         else
  372.         {
  373.             for( i = 1; i < i_abs; i++ )
  374.                 x264_cabac_encode_decision( cb, ctxbase + i + 2, 1 );
  375.             x264_cabac_encode_decision( cb, ctxbase + i_abs + 2, 0 );
  376.             x264_cabac_encode_bypass( cb, mvd < 0 );
  377.         }
  378.     }
  379.     else
  380.     {
  381.         x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
  382.         x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
  383.         x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
  384.         x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
  385.         cb->f8_bits_encoded += cabac_size_5ones[cb->state[ctxbase+6]];
  386.         cb->state[ctxbase+6] = cabac_transition_5ones[cb->state[ctxbase+6]];
  387.         x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
  388.     }
  389. #else
  390.     static const uint8_t ctxes[8] = { 3,4,5,6,6,6,6,6 };
  392.     if( i_abs == 0 )
  393.         x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
  394.     else if( i_abs < 9 )
  395.     {
  396.         x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
  397.         for( i = 1; i < i_abs; i++ )
  398.             x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
  399.         x264_cabac_encode_decision( cb, ctxbase + ctxes[i_abs-1], 0 );
  400.         x264_cabac_encode_bypass( cb, mvd < 0 );
  401.     }
  402.     else
  403.     {
  404.         x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
  405.         for( i = 1; i < 9; i++ )
  406.             x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
  407.         x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
  408.         x264_cabac_encode_bypass( cb, mvd < 0 );
  409.     }
  410. #endif
  411. }
  413. static NOINLINE uint32_t x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width )
  414. {
  415.     ALIGNED_4( int16_t mvp[2] );
  416.     uint32_t amvd;
  417.     int mdx, mdy;
  419.     /* Calculate mvd */
  420.     x264_mb_predict_mv( h, i_list, idx, width, mvp );
  421.     mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
  422.     mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
  423.     amvd = x264_cabac_amvd_sum(h->mb.cache.mvd[i_list][x264_scan8[idx] - 1],
  424.                                h->mb.cache.mvd[i_list][x264_scan8[idx] - 8]);
  426.     /* encode */
  427.     x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx, amvd&0xFFFF );
  428.     x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy, amvd>>16 );
  430.     return pack16to32_mask(mdx,mdy);
  431. }
  433. #define x264_cabac_mb_mvd(h,cb,i_list,idx,width,height)
  434. do
  435. {
  436.     uint32_t mvd = x264_cabac_mb_mvd(h,cb,i_list,idx,width);
  437.     x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mvd );
  438. } while(0)
  440. static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i )
  441. {
  442.     switch( h->mb.i_sub_partition[i] )
  443.     {
  444.         case D_L0_8x8:
  445.             x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
  446.             break;
  447.         case D_L0_8x4:
  448.             x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 2, 1 );
  449.             x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 2, 1 );
  450.             break;
  451.         case D_L0_4x8:
  452.             x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 2 );
  453.             x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 2 );
  454.             break;
  455.         case D_L0_4x4:
  456.             x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 1 );
  457.             x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 1 );
  458.             x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 1, 1 );
  459.             x264_cabac_mb_mvd( h, cb, 0, 4*i+3, 1, 1 );
  460.             break;
  461.         default:
  462.             assert(0);
  463.     }
  464. }
  466. /* i_ctxBlockCat: 0-> DC 16x16  i_idx = 0
  467.  *                1-> AC 16x16  i_idx = luma4x4idx
  468.  *                2-> Luma4x4   i_idx = luma4x4idx
  469.  *                3-> DC Chroma i_idx = iCbCr
  470.  *                4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
  471.  *                5-> Luma8x8   i_idx = luma8x8idx
  472.  */
  474. static int ALWAYS_INLINE x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx, int b_intra )
  475. {
  476.     int i_nza;
  477.     int i_nzb;
  479.     switch( i_cat )
  480.     {
  481.         case DCT_LUMA_AC:
  482.         case DCT_LUMA_4x4:
  483.         case DCT_CHROMA_AC:
  484.             /* no need to test for skip/pcm */
  485.             i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
  486.             i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
  487.             if( x264_constant_p(b_intra) && !b_intra )
  488.                 return 85 + 4*i_cat + ((2*i_nzb + i_nza)&0x7f);
  489.             else
  490.             {
  491.                 i_nza &= 0x7f + (b_intra << 7);
  492.                 i_nzb &= 0x7f + (b_intra << 7);
  493.                 return 85 + 4*i_cat + 2*!!i_nzb + !!i_nza;
  494.             }
  495.         case DCT_LUMA_DC:
  496.             i_nza = (h->mb.cache.i_cbp_left >> 8) & 1;
  497.             i_nzb = (h->mb.cache.i_cbp_top  >> 8) & 1;
  498.             return 85 + 4*i_cat + 2*i_nzb + i_nza;
  499.         case DCT_CHROMA_DC:
  500.             /* no need to test skip/pcm */
  501.             i_idx -= 25;
  502.             i_nza = h->mb.cache.i_cbp_left != -1 ? (h->mb.cache.i_cbp_left >> (9 + i_idx)) & 1 : b_intra;
  503.             i_nzb = h->mb.cache.i_cbp_top  != -1 ? (h->mb.cache.i_cbp_top  >> (9 + i_idx)) & 1 : b_intra;
  504.             return 85 + 4*i_cat + 2*i_nzb + i_nza;
  505.         default:
  506.             return 0;
  507.     }
  508. }
  511. static const uint16_t significant_coeff_flag_offset[2][6] = {
  512.     { 105, 120, 134, 149, 152, 402 },
  513.     { 277, 292, 306, 321, 324, 436 }
  514. };
  515. static const uint16_t last_coeff_flag_offset[2][6] = {
  516.     { 166, 181, 195, 210, 213, 417 },
  517.     { 338, 353, 367, 382, 385, 451 }
  518. };
  519. static const uint16_t coeff_abs_level_m1_offset[6] =
  520.     { 227, 237, 247, 257, 266, 426 };
  521. static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
  522. {{
  523.     0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
  524.     4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
  525.     7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
  526.    12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
  527. },{
  528.     0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
  529.     6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
  530.     9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
  531.     9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
  532. }};
  533. static const uint8_t last_coeff_flag_offset_8x8[63] = {
  534.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  535.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  536.     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  537.     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
  538. };
  540. // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
  541. //           4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
  542. /* map node ctx => cabac ctx for level=1 */
  543. static const int coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
  544. /* map node ctx => cabac ctx for level>1 */
  545. static const int coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
  546. static const uint8_t coeff_abs_level_transition[2][8] = {
  547. /* update node ctx after coding a level=1 */
  548.     { 1, 2, 3, 3, 4, 5, 6, 7 },
  549. /* update node ctx after coding a level>1 */
  550.     { 4, 4, 4, 4, 5, 6, 7, 7 }
  551. };
  552. static const int count_cat_m1[5] = {15, 14, 15, 3, 14};
  554. #if !RDO_SKIP_BS
  555. static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l )
  556. {
  557.     const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
  558.     const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
  559.     const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
  560.     const uint8_t *significant_coeff_flag_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
  561.     int i_coeff_abs_m1[64];
  562.     int i_coeff_sign[64];
  563.     int i_coeff = 0;
  564.     int i_last;
  565.     int node_ctx = 0;
  566.     int i = 0;
  568.     i_last = h->quantf.coeff_last[i_ctxBlockCat](l);
  570. #define WRITE_SIGMAP( l8x8 )
  571.     while(1)
  572.     {
  573.         if( l[i] )
  574.         {
  575.             i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
  576.             i_coeff_sign[i_coeff] = l[i] < 0;
  577.             i_coeff++;
  578.             x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? significant_coeff_flag_offset[i] : i), 1 );
  579.             if( i == i_last )
  580.             {
  581.                 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 1 );
  582.                 break;
  583.             }
  584.             else
  585.                 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 0 );
  586.         }
  587.         else
  588.             x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? significant_coeff_flag_offset[i] : i), 0 );
  589.         i++;
  590.         if( i == i_count_m1 )
  591.         {
  592.             i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
  593.             i_coeff_sign[i_coeff]   = l[i] < 0;
  594.             i_coeff++;
  595.             break;
  596.         }
  597.     }
  599.     if( i_ctxBlockCat == DCT_LUMA_8x8 )
  600.     {
  601.         const int i_count_m1 = 63;
  602.         WRITE_SIGMAP( 1 )
  603.     }
  604.     else
  605.     {
  606.         const int i_count_m1 = count_cat_m1[i_ctxBlockCat];
  607.         WRITE_SIGMAP( 0 )
  608.     }
  610.     do
  611.     {
  612.         int i_prefix, ctx;
  613.         i_coeff--;
  615.         /* write coeff_abs - 1 */
  616.         i_prefix = X264_MIN( i_coeff_abs_m1[i_coeff], 14 );
  617.         ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
  619.         if( i_prefix )
  620.         {
  621.             x264_cabac_encode_decision( cb, ctx, 1 );
  622.             ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
  623.             for( i = 0; i < i_prefix - 1; i++ )
  624.                 x264_cabac_encode_decision( cb, ctx, 1 );
  625.             if( i_prefix < 14 )
  626.                 x264_cabac_encode_decision( cb, ctx, 0 );
  627.             else
  628.                 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i_coeff] - 14 );
  630.             node_ctx = coeff_abs_level_transition[1][node_ctx];
  631.         }
  632.         else
  633.         {
  634.             x264_cabac_encode_decision( cb, ctx, 0 );
  635.             node_ctx = coeff_abs_level_transition[0][node_ctx];
  636.         }
  638.         x264_cabac_encode_bypass( cb, i_coeff_sign[i_coeff] );
  639.     } while( i_coeff > 0 );
  640. }
  641. #define block_residual_write_cabac_8x8( h, cb, l ) block_residual_write_cabac( h, cb, DCT_LUMA_8x8, l )
  643. #else
  645. /* Faster RDO by merging sigmap and level coding.  Note that for 8x8dct
  646.  * this is slightly incorrect because the sigmap is not reversible
  647.  * (contexts are repeated).  However, there is nearly no quality penalty
  648.  * for this (~0.001db) and the speed boost (~30%) is worth it. */
  649. static void ALWAYS_INLINE block_residual_write_cabac_internal( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l, int b_8x8 )
  650. {
  651.     const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
  652.     const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
  653.     const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
  654.     const uint8_t *significant_coeff_flag_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
  655.     int i_last, i_coeff_abs, ctx, i, node_ctx;
  657.     i_last = h->quantf.coeff_last[i_ctxBlockCat](l);
  659.     i_coeff_abs = abs(l[i_last]);
  660.     ctx = coeff_abs_level1_ctx[0] + i_ctx_level;
  662.     if( i_last != (b_8x8 ? 63 : count_cat_m1[i_ctxBlockCat]) )
  663.     {
  664.         x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?significant_coeff_flag_offset[i_last]:i_last), 1 );
  665.         x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i_last]:i_last), 1 );
  666.     }
  668.     if( i_coeff_abs > 1 )
  669.     {
  670.         x264_cabac_encode_decision( cb, ctx, 1 );
  671.         ctx = coeff_abs_levelgt1_ctx[0] + i_ctx_level;
  672.         if( i_coeff_abs < 15 )
  673.         {
  674.             cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
  675.             cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
  676.         }
  677.         else
  678.         {
  679.             cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
  680.             cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
  681.             x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
  682.         }
  683.         node_ctx = coeff_abs_level_transition[1][0];
  684.     }
  685.     else
  686.     {
  687.         x264_cabac_encode_decision( cb, ctx, 0 );
  688.         node_ctx = coeff_abs_level_transition[0][0];
  689.         x264_cabac_encode_bypass( cb, 0 ); // sign
  690.     }
  692.     for( i = i_last-1 ; i >= 0; i-- )
  693.     {
  694.         if( l[i] )
  695.         {
  696.             i_coeff_abs = abs(l[i]);
  697.             x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?significant_coeff_flag_offset[i]:i), 1 );
  698.             x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i]:i), 0 );
  699.             ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
  701.             if( i_coeff_abs > 1 )
  702.             {
  703.                 x264_cabac_encode_decision( cb, ctx, 1 );
  704.                 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
  705.                 if( i_coeff_abs < 15 )
  706.                 {
  707.                     cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
  708.                     cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
  709.                 }
  710.                 else
  711.                 {
  712.                     cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
  713.                     cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
  714.                     x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
  715.                 }
  716.                 node_ctx = coeff_abs_level_transition[1][node_ctx];
  717.             }
  718.             else
  719.             {
  720.                 x264_cabac_encode_decision( cb, ctx, 0 );
  721.                 node_ctx = coeff_abs_level_transition[0][node_ctx];
  722.                 x264_cabac_encode_bypass( cb, 0 );
  723.             }
  724.         }
  725.         else
  726.             x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?significant_coeff_flag_offset[i]:i), 0 );
  727.     }
  728. }
  730. static void block_residual_write_cabac_8x8( x264_t *h, x264_cabac_t *cb, int16_t *l )
  731. {
  732.     block_residual_write_cabac_internal( h, cb, DCT_LUMA_8x8, l, 1 );
  733. }
  734. static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l )
  735. {
  736.     block_residual_write_cabac_internal( h, cb, i_ctxBlockCat, l, 0 );
  737. }
  738. #endif
  740. #define block_residual_write_cabac_cbf( h, cb, i_ctxBlockCat, i_idx, l, b_intra ) 
  741. { 
  742.     int ctxidxinc = x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx, b_intra ); 
  743.     if( h->mb.cache.non_zero_count[x264_scan8[i_idx]] )
  744.     {
  745.         x264_cabac_encode_decision( cb, ctxidxinc, 1 );
  746.         block_residual_write_cabac( h, cb, i_ctxBlockCat, l ); 
  747.     }
  748.     else
  749.         x264_cabac_encode_decision( cb, ctxidxinc, 0 );
  750. }
  752. void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
  753. {
  754.     const int i_mb_type = h->mb.i_type;
  755.     int i_list;
  756.     int i;
  758. #if !RDO_SKIP_BS
  759.     const int i_mb_pos_start = x264_cabac_pos( cb );
  760.     int       i_mb_pos_tex;
  761. #endif
  763.     /* Write the MB type */
  764.     x264_cabac_mb_type( h, cb );
  766. #if !RDO_SKIP_BS
  767.     if( i_mb_type == I_PCM )
  768.     {
  769.         i_mb_pos_tex = x264_cabac_pos( cb );
  770.         h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
  772.         memcpy( cb->p, h->mb.pic.p_fenc[0], 256 );
  773.         cb->p += 256;
  774.         for( i = 0; i < 8; i++ )
  775.             memcpy( cb->p + i*8, h->mb.pic.p_fenc[1] + i*FENC_STRIDE, 8 );
  776.         cb->p += 64;
  777.         for( i = 0; i < 8; i++ )
  778.             memcpy( cb->p + i*8, h->mb.pic.p_fenc[2] + i*FENC_STRIDE, 8 );
  779.         cb->p += 64;
  781.         cb->i_low   = 0;
  782.         cb->i_range = 0x01FE;
  783.         cb->i_queue = -1;
  784.         cb->i_bytes_outstanding = 0;
  786.         /* if PCM is chosen, we need to store reconstructed frame data */
  787.         h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc[0], FENC_STRIDE, 16 );
  788.         h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE, 8 );
  789.         h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE, 8 );
  791.         h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
  792.         return;
  793.     }
  794. #endif
  796.     if( IS_INTRA( i_mb_type ) )
  797.     {
  798.         if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
  799.             x264_cabac_mb_transform_size( h, cb );
  801.         if( i_mb_type != I_16x16 )
  802.         {
  803.             int di = h->mb.b_transform_8x8 ? 4 : 1;
  804.             for( i = 0; i < 16; i += di )
  805.             {
  806.                 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
  807.                 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
  808.                 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
  809.             }
  810.         }
  812.         x264_cabac_mb_intra_chroma_pred_mode( h, cb );
  813.     }
  814.     else if( i_mb_type == P_L0 )
  815.     {
  816.         if( h->mb.i_partition == D_16x16 )
  817.         {
  818.             if( h->mb.pic.i_fref[0] > 1 )
  819.             {
  820.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  821.             }
  822.             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
  823.         }
  824.         else if( h->mb.i_partition == D_16x8 )
  825.         {
  826.             if( h->mb.pic.i_fref[0] > 1 )
  827.             {
  828.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  829.                 x264_cabac_mb_ref( h, cb, 0, 8 );
  830.             }
  831.             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
  832.             x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
  833.         }
  834.         else //if( h->mb.i_partition == D_8x16 )
  835.         {
  836.             if( h->mb.pic.i_fref[0] > 1 )
  837.             {
  838.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  839.                 x264_cabac_mb_ref( h, cb, 0, 4 );
  840.             }
  841.             x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
  842.             x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
  843.         }
  844.     }
  845.     else if( i_mb_type == P_8x8 )
  846.     {
  847.         /* sub mb type */
  848.         for( i = 0; i < 4; i++ )
  849.             x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i] );
  851.         /* ref 0 */
  852.         if( h->mb.pic.i_fref[0] > 1 )
  853.         {
  854.             x264_cabac_mb_ref( h, cb, 0, 0 );
  855.             x264_cabac_mb_ref( h, cb, 0, 4 );
  856.             x264_cabac_mb_ref( h, cb, 0, 8 );
  857.             x264_cabac_mb_ref( h, cb, 0, 12 );
  858.         }
  860.         for( i = 0; i < 4; i++ )
  861.             x264_cabac_mb8x8_mvd( h, cb, i );
  862.     }
  863.     else if( i_mb_type == B_8x8 )
  864.     {
  865.         /* sub mb type */
  866.         for( i = 0; i < 4; i++ )
  867.             x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i] );
  869.         /* ref */
  870.         if( h->mb.pic.i_fref[0] > 1 )
  871.             for( i = 0; i < 4; i++ )
  872.                 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
  873.                     x264_cabac_mb_ref( h, cb, 0, 4*i );
  875.         if( h->mb.pic.i_fref[1] > 1 )
  876.             for( i = 0; i < 4; i++ )
  877.                 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
  878.                     x264_cabac_mb_ref( h, cb, 1, 4*i );
  880.         for( i = 0; i < 4; i++ )
  881.             if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
  882.                 x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
  884.         for( i = 0; i < 4; i++ )
  885.             if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
  886.                 x264_cabac_mb_mvd( h, cb, 1, 4*i, 2, 2 );
  887.     }
  888.     else if( i_mb_type != B_DIRECT )
  889.     {
  890.         /* All B mode */
  891.         const uint8_t (*b_list)[2] = x264_mb_type_list_table[i_mb_type];
  892.         if( h->mb.pic.i_fref[0] > 1 )
  893.         {
  894.             if( b_list[0][0] )
  895.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  896.             if( b_list[0][1] && h->mb.i_partition != D_16x16 )
  897.                 x264_cabac_mb_ref( h, cb, 0, 8 >> (h->mb.i_partition == D_8x16) );
  898.         }
  899.         if( h->mb.pic.i_fref[1] > 1 )
  900.         {
  901.             if( b_list[1][0] )
  902.                 x264_cabac_mb_ref( h, cb, 1, 0 );
  903.             if( b_list[1][1] && h->mb.i_partition != D_16x16 )
  904.                 x264_cabac_mb_ref( h, cb, 1, 8 >> (h->mb.i_partition == D_8x16) );
  905.         }
  906.         for( i_list = 0; i_list < 2; i_list++ )
  907.         {
  908.             if( h->mb.i_partition == D_16x16 )
  909.             {
  910.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
  911.             }
  912.             else if( h->mb.i_partition == D_16x8 )
  913.             {
  914.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
  915.                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
  916.             }
  917.             else //if( h->mb.i_partition == D_8x16 )
  918.             {
  919.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
  920.                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
  921.             }
  922.         }
  923.     }
  925. #if !RDO_SKIP_BS
  926.     i_mb_pos_tex = x264_cabac_pos( cb );
  927.     h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
  928. #endif
  930.     if( i_mb_type != I_16x16 )
  931.     {
  932.         x264_cabac_mb_cbp_luma( h, cb );
  933.         x264_cabac_mb_cbp_chroma( h, cb );
  934.     }
  936.     if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
  937.     {
  938.         x264_cabac_mb_transform_size( h, cb );
  939.     }
  941.     if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
  942.     {
  943.         const int b_intra = IS_INTRA( i_mb_type );
  944.         x264_cabac_mb_qp_delta( h, cb );
  946.         /* write residual */
  947.         if( i_mb_type == I_16x16 )
  948.         {
  949.             /* DC Luma */
  950.             block_residual_write_cabac_cbf( h, cb, DCT_LUMA_DC, 24, h->dct.luma16x16_dc, 1 );
  952.             /* AC Luma */
  953.             if( h->mb.i_cbp_luma != 0 )
  954.                 for( i = 0; i < 16; i++ )
  955.                     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 1 );
  956.         }
  957.         else if( h->mb.b_transform_8x8 )
  958.         {
  959.             for( i = 0; i < 4; i++ )
  960.                 if( h->mb.i_cbp_luma & ( 1 << i ) )
  961.                     block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i] );
  962.         }
  963.         else
  964.         {
  965.             for( i = 0; i < 16; i++ )
  966.                 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
  967.                     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], b_intra );
  968.         }
  970.         if( h->mb.i_cbp_chroma&0x03 )    /* Chroma DC residual present */
  971.         {
  972.             block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], b_intra );
  973.             block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], b_intra );
  974.             if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
  975.                 for( i = 16; i < 24; i++ )
  976.                     block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, b_intra );
  977.         }
  978.     }
  980. #if !RDO_SKIP_BS
  981.     h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
  982. #endif
  983. }
  985. #if RDO_SKIP_BS
  986. /*****************************************************************************
  987.  * RD only; doesn't generate a valid bitstream
  988.  * doesn't write cbp or chroma dc (I don't know how much this matters)
  989.  * doesn't write ref (never varies between calls, so no point in doing so)
  990.  * only writes subpartition for p8x8, needed for sub-8x8 mode decision RDO
  991.  * works on all partition sizes except 16x16
  992.  *****************************************************************************/
  993. static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
  994. {
  995.     const int i_mb_type = h->mb.i_type;
  996.     int b_8x16 = h->mb.i_partition == D_8x16;
  997.     int j;
  999.     if( i_mb_type == P_8x8 )
  1000.     {
  1001.         x264_cabac_mb8x8_mvd( h, cb, i8 );
  1002.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
  1003.     }
  1004.     else if( i_mb_type == P_L0 )
  1005.         x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
  1006.     else if( i_mb_type > B_DIRECT && i_mb_type < B_8x8 )
  1007.     {
  1008.         if( x264_mb_type_list_table[ i_mb_type ][0][!!i8] ) x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
  1009.         if( x264_mb_type_list_table[ i_mb_type ][1][!!i8] ) x264_cabac_mb_mvd( h, cb, 1, 4*i8, 4>>b_8x16, 2<<b_8x16 );
  1010.     }
  1011.     else //if( i_mb_type == B_8x8 )
  1012.     {
  1013.         if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
  1014.             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 2 );
  1015.         if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
  1016.             x264_cabac_mb_mvd( h, cb, 1, 4*i8, 2, 2 );
  1017.     }
  1019.     for( j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
  1020.     {
  1021.         if( h->mb.i_cbp_luma & (1 << i8) )
  1022.         {
  1023.             if( h->mb.b_transform_8x8 )
  1024.                 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
  1025.             else
  1026.             {
  1027.                 int i4;
  1028.                 for( i4 = 0; i4 < 4; i4++ )
  1029.                     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 0 );
  1030.             }
  1031.         }
  1033.         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 0 );
  1034.         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 0 );
  1036.         i8 += x264_pixel_size[i_pixel].h >> 3;
  1037.     }
  1038. }
  1040. static void x264_subpartition_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_pixel )
  1041. {
  1042.     int b_8x4 = i_pixel == PIXEL_8x4;
  1043.     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 0 );
  1044.     if( i_pixel == PIXEL_4x4 )
  1045.     {
  1046.         x264_cabac_mb_mvd( h, cb, 0, i4, 1, 1 );
  1047.     }
  1048.     else
  1049.     {
  1050.         x264_cabac_mb_mvd( h, cb, 0, i4, 1+b_8x4, 2-b_8x4 );
  1051.         block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+2-b_8x4, h->dct.luma4x4[i4+2-b_8x4], 0 );
  1052.     }
  1053. }
  1055. static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
  1056. {
  1057.     const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
  1058.     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
  1059.     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
  1060.     x264_cabac_mb_cbp_luma( h, cb );
  1061.     if( h->mb.i_cbp_luma & (1 << i8) )
  1062.         block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
  1063. }
  1065. static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
  1066. {
  1067.     const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
  1068.     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
  1069.     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
  1070.     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 1 );
  1071. }
  1073. static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
  1074. {
  1075.     x264_cabac_mb_intra_chroma_pred_mode( h, cb );
  1076.     x264_cabac_mb_cbp_chroma( h, cb );
  1077.     if( h->mb.i_cbp_chroma > 0 )
  1078.     {
  1079.         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], 1 );
  1080.         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], 1 );
  1082.         if( h->mb.i_cbp_chroma == 2 )
  1083.         {
  1084.             int i;
  1085.             for( i = 16; i < 24; i++ )
  1086.                 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 1 );
  1087.         }
  1088.     }
  1089. }
  1090. #endif