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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
cabac.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：38k
源码类别：

Audio

开发平台：

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.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. #include "common/common.h"
  25. #include "macroblock.h"
  27. static inline void x264_cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
  28.                     int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
  29. {
  30.     if( i_mb_type == I_4x4 || i_mb_type == I_8x8 )
  31.     {
  32.         x264_cabac_encode_decision( cb, ctx0, 0 );
  33.     }
  34.     else if( i_mb_type == I_PCM )
  35.     {
  36.         x264_cabac_encode_decision( cb, ctx0, 1 );
  37.         x264_cabac_encode_flush( h, cb );
  38.     }
  39.     else
  40.     {
  41.         int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
  43.         x264_cabac_encode_decision( cb, ctx0, 1 );
  44.         x264_cabac_encode_terminal( cb );
  46.         x264_cabac_encode_decision( cb, ctx1, !!h->mb.i_cbp_luma );
  47.         if( h->mb.i_cbp_chroma == 0 )
  48.         {
  49.             x264_cabac_encode_decision( cb, ctx2, 0 );
  50.         }
  51.         else
  52.         {
  53.             x264_cabac_encode_decision( cb, ctx2, 1 );
  54.             x264_cabac_encode_decision( cb, ctx3, h->mb.i_cbp_chroma != 1 );
  55.         }
  56.         x264_cabac_encode_decision( cb, ctx4, i_pred>>1 );
  57.         x264_cabac_encode_decision( cb, ctx5, i_pred&1 );
  58.     }
  59. }
  61. static void x264_cabac_mb_type( x264_t *h, x264_cabac_t *cb )
  62. {
  63.     const int i_mb_type = h->mb.i_type;
  65.     if( h->sh.b_mbaff &&
  66.         (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
  67.     {
  68.         x264_cabac_encode_decision( cb, 70 + h->mb.cache.i_neighbour_interlaced, h->mb.b_interlaced );
  69.     }
  71.     if( h->sh.i_type == SLICE_TYPE_I )
  72.     {
  73.         int ctx = 0;
  74.         if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != I_4x4 )
  75.         {
  76.             ctx++;
  77.         }
  78.         if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != I_4x4 )
  79.         {
  80.             ctx++;
  81.         }
  83.         x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
  84.     }
  85.     else if( h->sh.i_type == SLICE_TYPE_P )
  86.     {
  87.         /* prefix: 14, suffix: 17 */
  88.         if( i_mb_type == P_L0 )
  89.         {
  90.             if( h->mb.i_partition == D_16x16 )
  91.             {
  92.                 x264_cabac_encode_decision( cb, 14, 0 );
  93.                 x264_cabac_encode_decision( cb, 15, 0 );
  94.                 x264_cabac_encode_decision( cb, 16, 0 );
  95.             }
  96.             else if( h->mb.i_partition == D_16x8 )
  97.             {
  98.                 x264_cabac_encode_decision( cb, 14, 0 );
  99.                 x264_cabac_encode_decision( cb, 15, 1 );
  100.                 x264_cabac_encode_decision( cb, 17, 1 );
  101.             }
  102.             else if( h->mb.i_partition == D_8x16 )
  103.             {
  104.                 x264_cabac_encode_decision( cb, 14, 0 );
  105.                 x264_cabac_encode_decision( cb, 15, 1 );
  106.                 x264_cabac_encode_decision( cb, 17, 0 );
  107.             }
  108.         }
  109.         else if( i_mb_type == P_8x8 )
  110.         {
  111.             x264_cabac_encode_decision( cb, 14, 0 );
  112.             x264_cabac_encode_decision( cb, 15, 0 );
  113.             x264_cabac_encode_decision( cb, 16, 1 );
  114.         }
  115.         else /* intra */
  116.         {
  117.             /* prefix */
  118.             x264_cabac_encode_decision( cb, 14, 1 );
  120.             /* suffix */
  121.             x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
  122.         }
  123.     }
  124.     else if( h->sh.i_type == SLICE_TYPE_B )
  125.     {
  126.         int ctx = 0;
  127.         if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != B_SKIP && h->mb.i_mb_type_left != B_DIRECT )
  128.         {
  129.             ctx++;
  130.         }
  131.         if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
  132.         {
  133.             ctx++;
  134.         }
  136.         if( i_mb_type == B_DIRECT )
  137.         {
  138.             x264_cabac_encode_decision( cb, 27+ctx, 0 );
  139.         }
  140.         else if( i_mb_type == B_8x8 )
  141.         {
  142.             x264_cabac_encode_decision( cb, 27+ctx, 1 );
  143.             x264_cabac_encode_decision( cb, 27+3,   1 );
  144.             x264_cabac_encode_decision( cb, 27+4,   1 );
  146.             x264_cabac_encode_decision( cb, 27+5,   1 );
  147.             x264_cabac_encode_decision( cb, 27+5,   1 );
  148.             x264_cabac_encode_decision( cb, 27+5,   1 );
  149.         }
  150.         else if( IS_INTRA( i_mb_type ) )
  151.         {
  152.             /* prefix */
  153.             x264_cabac_encode_decision( cb, 27+ctx, 1 );
  154.             x264_cabac_encode_decision( cb, 27+3,   1 );
  155.             x264_cabac_encode_decision( cb, 27+4,   1 );
  157.             x264_cabac_encode_decision( cb, 27+5,   1 );
  158.             x264_cabac_encode_decision( cb, 27+5,   0 );
  159.             x264_cabac_encode_decision( cb, 27+5,   1 );
  161.             /* suffix */
  162.             x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
  163.         }
  164.         else
  165.         {
  166.             static const int i_mb_len[9*3] =
  167.             {
  168.                 6, 6, 3,    /* L0 L0 */
  169.                 6, 6, 0,    /* L0 L1 */
  170.                 7, 7, 0,    /* L0 BI */
  171.                 6, 6, 0,    /* L1 L0 */
  172.                 6, 6, 3,    /* L1 L1 */
  173.                 7, 7, 0,    /* L1 BI */
  174.                 7, 7, 0,    /* BI L0 */
  175.                 7, 7, 0,    /* BI L1 */
  176.                 7, 7, 6,    /* BI BI */
  177.             };
  178.             static const int i_mb_bits[9*3][7] =
  179.             {
  180.                 { 1,1,0,0,0,1   }, { 1,1,0,0,1,0,  }, { 1,0,0 },       /* L0 L0 */
  181.                 { 1,1,0,1,0,1   }, { 1,1,0,1,1,0   }, {0},             /* L0 L1 */
  182.                 { 1,1,1,0,0,0,0 }, { 1,1,1,0,0,0,1 }, {0},             /* L0 BI */
  183.                 { 1,1,0,1,1,1   }, { 1,1,1,1,1,0   }, {0},             /* L1 L0 */
  184.                 { 1,1,0,0,1,1   }, { 1,1,0,1,0,0   }, { 1,0,1 },       /* L1 L1 */
  185.                 { 1,1,1,0,0,1,0 }, { 1,1,1,0,0,1,1 }, {0},             /* L1 BI */
  186.                 { 1,1,1,0,1,0,0 }, { 1,1,1,0,1,0,1 }, {0},             /* BI L0 */
  187.                 { 1,1,1,0,1,1,0 }, { 1,1,1,0,1,1,1 }, {0},             /* BI L1 */
  188.                 { 1,1,1,1,0,0,0 }, { 1,1,1,1,0,0,1 }, { 1,1,0,0,0,0 }, /* BI BI */
  189.             };
  191.             const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
  192.             int i;
  194.             x264_cabac_encode_decision( cb, 27+ctx, i_mb_bits[idx][0] );
  195.             x264_cabac_encode_decision( cb, 27+3,   i_mb_bits[idx][1] );
  196.             x264_cabac_encode_decision( cb, 27+5-i_mb_bits[idx][1], i_mb_bits[idx][2] );
  197.             for( i = 3; i < i_mb_len[idx]; i++ )
  198.                 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][i] );
  199.         }
  200.     }
  201.     else
  202.     {
  203.         x264_log(h, X264_LOG_ERROR, "unknown SLICE_TYPE unsupported in x264_macroblock_write_cabacn" );
  204.     }
  205. }
  207. static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
  208. {
  209.     if( i_pred == i_mode )
  210.     {
  211.         /* b_prev_intra4x4_pred_mode */
  212.         x264_cabac_encode_decision( cb, 68, 1 );
  213.     }
  214.     else
  215.     {
  216.         /* b_prev_intra4x4_pred_mode */
  217.         x264_cabac_encode_decision( cb, 68, 0 );
  218.         if( i_mode > i_pred  )
  219.         {
  220.             i_mode--;
  221.         }
  222.         x264_cabac_encode_decision( cb, 69, (i_mode     )&0x01 );
  223.         x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
  224.         x264_cabac_encode_decision( cb, 69, (i_mode >> 2)&0x01 );
  225.     }
  226. }
  228. static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
  229. {
  230.     const int i_mode = x264_mb_pred_mode8x8c_fix[ h->mb.i_chroma_pred_mode ];
  231.     int       ctx = 0;
  233.     /* No need to test for I4x4 or I_16x16 as cache_save handle that */
  234.     if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_xy - 1] != 0 )
  235.     {
  236.         ctx++;
  237.     }
  238.     if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_top_xy] != 0 )
  239.     {
  240.         ctx++;
  241.     }
  243.     x264_cabac_encode_decision( cb, 64 + ctx, i_mode > 0 );
  244.     if( i_mode > 0 )
  245.     {
  246.         x264_cabac_encode_decision( cb, 64 + 3, i_mode > 1 );
  247.         if( i_mode > 1 )
  248.         {
  249.             x264_cabac_encode_decision( cb, 64 + 3, i_mode > 2 );
  250.         }
  251.     }
  252. }
  254. static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
  255. {
  256.     int cbp = h->mb.i_cbp_luma;
  257.     int cbp_l = h->mb.i_neighbour & MB_LEFT ? h->mb.cbp[h->mb.i_mb_xy - 1] : -1;
  258.     int cbp_t = h->mb.i_neighbour & MB_TOP ? h->mb.cbp[h->mb.i_mb_top_xy] : -1;
  259.     x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (h->mb.i_cbp_luma >> 0) & 1 );
  260.     x264_cabac_encode_decision( cb, 76 - ((cbp   >> 0) & 1) - ((cbp_t >> 2) & 2), (h->mb.i_cbp_luma >> 1) & 1 );
  261.     x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp   << 1) & 2), (h->mb.i_cbp_luma >> 2) & 1 );
  262.     x264_cabac_encode_decision( cb, 76 - ((cbp   >> 2) & 1) - ((cbp   >> 0) & 2), (h->mb.i_cbp_luma >> 3) & 1 );
  263. }
  265. static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
  266. {
  267.     int cbp_a = -1;
  268.     int cbp_b = -1;
  269.     int ctx;
  271.     /* No need to test for SKIP/PCM */
  272.     if( h->mb.i_neighbour & MB_LEFT )
  273.     {
  274.         cbp_a = (h->mb.cbp[h->mb.i_mb_xy - 1] >> 4)&0x3;
  275.     }
  277.     if( h->mb.i_neighbour & MB_TOP )
  278.     {
  279.         cbp_b = (h->mb.cbp[h->mb.i_mb_top_xy] >> 4)&0x3;
  280.     }
  282.     ctx = 0;
  283.     if( cbp_a > 0 ) ctx++;
  284.     if( cbp_b > 0 ) ctx += 2;
  285.     if( h->mb.i_cbp_chroma == 0 )
  286.     {
  287.         x264_cabac_encode_decision( cb, 77 + ctx, 0 );
  288.     }
  289.     else
  290.     {
  291.         x264_cabac_encode_decision( cb, 77 + ctx, 1 );
  293.         ctx = 4;
  294.         if( cbp_a == 2 ) ctx++;
  295.         if( cbp_b == 2 ) ctx += 2;
  296.         x264_cabac_encode_decision( cb, 77 + ctx, h->mb.i_cbp_chroma > 1 );
  297.     }
  298. }
  300. /* TODO check it with != qp per mb */
  301. static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
  302. {
  303.     int i_mbn_xy = h->mb.i_mb_prev_xy;
  304.     int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
  305.     int ctx;
  307.     /* Avoid writing a delta quant if we have an empty i16x16 block, e.g. in a completely flat background area */
  308.     if( h->mb.i_type == I_16x16 && !h->mb.cbp[h->mb.i_mb_xy] )
  309.     {
  310. #ifndef RDO_SKIP_BS
  311.         h->mb.i_qp = h->mb.i_last_qp;
  312. #endif
  313.         i_dqp = 0;
  314.     }
  316.     /* No need to test for PCM / SKIP */
  317.     if( h->mb.i_last_dqp &&
  318.         ( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) ) )
  319.         ctx = 1;
  320.     else
  321.         ctx = 0;
  323.     if( i_dqp != 0 )
  324.     {
  325.         int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
  326.         /* dqp is interpreted modulo 52 */
  327.         if( val >= 51 && val != 52 )
  328.             val = 103 - val;
  329.         while( val-- )
  330.         {
  331.             x264_cabac_encode_decision( cb, 60 + ctx, 1 );
  332.             if( ctx < 2 )
  333.                 ctx = 2;
  334.             else
  335.                 ctx = 3;
  336.         }
  337.     }
  338.     x264_cabac_encode_decision( cb, 60 + ctx, 0 );
  339. }
  341. #ifndef RDO_SKIP_BS
  342. void x264_cabac_mb_skip( x264_t *h, int b_skip )
  343. {
  344.     int ctx = (h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ))
  345.             + (h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ))
  346.             + (h->sh.i_type == SLICE_TYPE_P ? 11 : 24);
  347.     x264_cabac_encode_decision( &h->cabac, ctx, b_skip );
  348. }
  349. #endif
  351. static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
  352. {
  353.     if( i_sub == D_L0_8x8 )
  354.     {
  355.         x264_cabac_encode_decision( cb, 21, 1 );
  356.     }
  357.     else if( i_sub == D_L0_8x4 )
  358.     {
  359.         x264_cabac_encode_decision( cb, 21, 0 );
  360.         x264_cabac_encode_decision( cb, 22, 0 );
  361.     }
  362.     else if( i_sub == D_L0_4x8 )
  363.     {
  364.         x264_cabac_encode_decision( cb, 21, 0 );
  365.         x264_cabac_encode_decision( cb, 22, 1 );
  366.         x264_cabac_encode_decision( cb, 23, 1 );
  367.     }
  368.     else if( i_sub == D_L0_4x4 )
  369.     {
  370.         x264_cabac_encode_decision( cb, 21, 0 );
  371.         x264_cabac_encode_decision( cb, 22, 1 );
  372.         x264_cabac_encode_decision( cb, 23, 0 );
  373.     }
  374. }
  376. static NOINLINE void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
  377. {
  378.     static const uint8_t part_bits[12][7] = {
  379.         {6,1,1,1,0,1,1}, // D_L0_4x4
  380.         {5,1,1,0,0,1},   // D_L0_8x4
  381.         {5,1,1,0,1,0},   // D_L0_4x8
  382.         {3,1,0,0},       // D_L0_8x8
  383.         {5,1,1,1,1,0},   // D_L1_4x4
  384.         {5,1,1,0,1,1},   // D_L1_8x4
  385.         {6,1,1,1,0,0,0}, // D_L1_4x8
  386.         {3,1,0,1},       // D_L1_8x8
  387.         {5,1,1,1,1,1},   // D_BI_4x4
  388.         {6,1,1,1,0,0,1}, // D_BI_8x4
  389.         {6,1,1,1,0,1,0}, // D_BI_4x8
  390.         {5,1,1,0,0,0},   // D_BI_8x8
  391.     };
  392.     int len;
  393.     if( i_sub == D_DIRECT_8x8 )
  394.     {
  395.         x264_cabac_encode_decision( cb, 36, 0 );
  396.         return;
  397.     }
  398.     len = part_bits[i_sub][0];
  399.     x264_cabac_encode_decision( cb, 36, part_bits[i_sub][1] );
  400.     x264_cabac_encode_decision( cb, 37, part_bits[i_sub][2] );
  401.     if( len == 3 )
  402.         x264_cabac_encode_decision( cb, 39, part_bits[i_sub][3] );
  403.     else
  404.     {
  405.         x264_cabac_encode_decision( cb, 38, part_bits[i_sub][3] );
  406.         x264_cabac_encode_decision( cb, 39, part_bits[i_sub][4] );
  407.         x264_cabac_encode_decision( cb, 39, part_bits[i_sub][5] );
  408.         if( len == 6 )
  409.             x264_cabac_encode_decision( cb, 39, part_bits[i_sub][6] );
  410.     }
  411. }
  413. static inline void x264_cabac_mb_transform_size( x264_t *h, x264_cabac_t *cb )
  414. {
  415.     int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
  416.     x264_cabac_encode_decision( cb, ctx, h->mb.b_transform_8x8 );
  417. }
  419. static inline void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
  420. {
  421.     const int i8 = x264_scan8[idx];
  422.     const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
  423.     const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
  424.     int i_ref  = h->mb.cache.ref[i_list][i8];
  425.     int ctx  = 0;
  427.     if( i_refa > 0 && !h->mb.cache.skip[i8 - 1])
  428.         ctx++;
  429.     if( i_refb > 0 && !h->mb.cache.skip[i8 - 8])
  430.         ctx += 2;
  432.     while( i_ref > 0 )
  433.     {
  434.         x264_cabac_encode_decision( cb, 54 + ctx, 1 );
  435.         if( ctx < 4 )
  436.             ctx = 4;
  437.         else
  438.             ctx = 5;
  440.         i_ref--;
  441.     }
  442.     x264_cabac_encode_decision( cb, 54 + ctx, 0 );
  443. }
  447. static inline void x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd )
  448. {
  449.     static const uint8_t transition[7] = { 3,3,3,4,5,6,6 };
  450.     const int amvd = abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 1][l] ) +
  451.                      abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 8][l] );
  452.     const int i_abs = abs( mvd );
  453.     const int i_prefix = X264_MIN( i_abs, 9 );
  454.     const int ctxbase = l ? 47 : 40;
  455.     int ctx = (amvd>2) + (amvd>32);
  456.     int i;
  458.     for( i = 0; i < i_prefix; i++ )
  459.     {
  460.         x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
  461.         ctx = transition[ctx];
  462.     }
  463.     if( i_prefix < 9 )
  464.         x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
  465.     else
  466.         x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
  468.     /* sign */
  469.     if( mvd )
  470.         x264_cabac_encode_bypass( cb, mvd < 0 );
  471. }
  473. static inline void x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width, int height )
  474. {
  475.     DECLARE_ALIGNED_4( int16_t mvp[2] );
  476.     int mdx, mdy;
  478.     /* Calculate mvd */
  479.     x264_mb_predict_mv( h, i_list, idx, width, mvp );
  480.     mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
  481.     mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
  483.     /* encode */
  484.     x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx );
  485.     x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy );
  487.     /* save value */
  488.     x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, pack16to32_mask(mdx,mdy) );
  489. }
  491. static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int i )
  492. {
  493.     if( !x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
  494.         return;
  496.     switch( h->mb.i_sub_partition[i] )
  497.     {
  498.         case D_L0_8x8:
  499.         case D_L1_8x8:
  500.         case D_BI_8x8:
  501.             x264_cabac_mb_mvd( h, cb, i_list, 4*i, 2, 2 );
  502.             break;
  503.         case D_L0_8x4:
  504.         case D_L1_8x4:
  505.         case D_BI_8x4:
  506.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 2, 1 );
  507.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 2, 1 );
  508.             break;
  509.         case D_L0_4x8:
  510.         case D_L1_4x8:
  511.         case D_BI_4x8:
  512.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 2 );
  513.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 2 );
  514.             break;
  515.         case D_L0_4x4:
  516.         case D_L1_4x4:
  517.         case D_BI_4x4:
  518.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 1 );
  519.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 1 );
  520.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 1, 1 );
  521.             x264_cabac_mb_mvd( h, cb, i_list, 4*i+3, 1, 1 );
  522.             break;
  523.     }
  524. }
  526. static int x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx )
  527. {
  528.     /* i_ctxBlockCat: 0-> DC 16x16  i_idx = 0
  529.      *                1-> AC 16x16  i_idx = luma4x4idx
  530.      *                2-> Luma4x4   i_idx = luma4x4idx
  531.      *                3-> DC Chroma i_idx = iCbCr
  532.      *                4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
  533.      *                5-> Luma8x8   i_idx = luma8x8idx
  534.      */
  536.     int i_mba_xy = -1;
  537.     int i_mbb_xy = -1;
  538.     int i_nza = 0;
  539.     int i_nzb = 0;
  541.     if( i_cat == DCT_LUMA_DC )
  542.     {
  543.         if( h->mb.i_neighbour & MB_LEFT )
  544.         {
  545.             i_mba_xy = h->mb.i_mb_xy - 1;
  546.             i_nza = h->mb.cbp[i_mba_xy] & 0x100;
  547.         }
  548.         if( h->mb.i_neighbour & MB_TOP )
  549.         {
  550.             i_mbb_xy = h->mb.i_mb_top_xy;
  551.             i_nzb = h->mb.cbp[i_mbb_xy] & 0x100;
  552.         }
  553.     }
  554.     else if( i_cat == DCT_LUMA_AC || i_cat == DCT_LUMA_4x4 )
  555.     {
  556.         if( i_idx & ~10 ) // block_idx_x > 0
  557.             i_mba_xy = h->mb.i_mb_xy;
  558.         else if( h->mb.i_neighbour & MB_LEFT )
  559.             i_mba_xy = h->mb.i_mb_xy - 1;
  561.         if( i_idx & ~5 ) // block_idx_y > 0
  562.             i_mbb_xy = h->mb.i_mb_xy;
  563.         else if( h->mb.i_neighbour & MB_TOP )
  564.             i_mbb_xy = h->mb.i_mb_top_xy;
  566.         /* no need to test for skip/pcm */
  567.         if( i_mba_xy >= 0 )
  568.             i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
  569.         if( i_mbb_xy >= 0 )
  570.             i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
  571.     }
  572.     else if( i_cat == DCT_CHROMA_DC )
  573.     {
  574.         /* no need to test skip/pcm */
  575.         if( h->mb.i_neighbour & MB_LEFT )
  576.         {
  577.             i_mba_xy = h->mb.i_mb_xy - 1;
  578.             i_nza = h->mb.cbp[i_mba_xy] & (0x200 << i_idx);
  579.         }
  580.         if( h->mb.i_neighbour & MB_TOP )
  581.         {
  582.             i_mbb_xy = h->mb.i_mb_top_xy;
  583.             i_nzb = h->mb.cbp[i_mbb_xy] & (0x200 << i_idx);
  584.         }
  585.     }
  586.     else if( i_cat == DCT_CHROMA_AC )
  587.     {
  588.         if( i_idx & 1 )
  589.             i_mba_xy = h->mb.i_mb_xy;
  590.         else if( h->mb.i_neighbour & MB_LEFT )
  591.             i_mba_xy = h->mb.i_mb_xy - 1;
  593.         if( i_idx & 2 )
  594.             i_mbb_xy = h->mb.i_mb_xy;
  595.         else if( h->mb.i_neighbour & MB_TOP )
  596.             i_mbb_xy = h->mb.i_mb_top_xy;
  598.         /* no need to test skip/pcm */
  599.         if( i_mba_xy >= 0 )
  600.             i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
  601.         if( i_mbb_xy >= 0 )
  602.             i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
  603.     }
  605.     if( IS_INTRA( h->mb.i_type ) )
  606.     {
  607.         i_nza |= i_mba_xy < 0;
  608.         i_nzb |= i_mbb_xy < 0;
  609.     }
  611.     return 4*i_cat + 2*!!i_nzb + !!i_nza;
  612. }
  615. static const uint16_t significant_coeff_flag_offset[2][6] = {
  616.     { 105, 120, 134, 149, 152, 402 },
  617.     { 277, 292, 306, 321, 324, 436 }
  618. };
  619. static const uint16_t last_coeff_flag_offset[2][6] = {
  620.     { 166, 181, 195, 210, 213, 417 },
  621.     { 338, 353, 367, 382, 385, 451 }
  622. };
  623. static const uint16_t coeff_abs_level_m1_offset[6] =
  624.     { 227, 237, 247, 257, 266, 426 };
  625. static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
  626. {{
  627.     0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
  628.     4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
  629.     7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
  630.    12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
  631. },{
  632.     0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
  633.     6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
  634.     9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
  635.     9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
  636. }};
  637. static const uint8_t last_coeff_flag_offset_8x8[63] = {
  638.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  639.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  640.     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  641.     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
  642. };
  643. static const uint8_t identity[16] =
  644.     { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
  646. // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
  647. //           4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
  648. /* map node ctx => cabac ctx for level=1 */
  649. static const int coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
  650. /* map node ctx => cabac ctx for level>1 */
  651. static const int coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
  652. static const uint8_t coeff_abs_level_transition[2][8] = {
  653. /* update node ctx after coding a level=1 */
  654.     { 1, 2, 3, 3, 4, 5, 6, 7 },
  655. /* update node ctx after coding a level>1 */
  656.     { 4, 4, 4, 4, 5, 6, 7, 7 }
  657. };
  659. static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int i_idx, int16_t *l, int i_count )
  660. {
  661.     const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
  662.     const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
  663.     const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
  665.     int i_coeff_abs_m1[64];
  666.     int UNUSED i_coeff_sign[64];
  667.     int i_coeff = 0;
  668.     int i_last  = 0;
  669.     int i_sigmap_size;
  670.     int node_ctx = 0;
  671.     int i, j;
  673.     const uint8_t *significant_coeff_flag_offset;
  674.     const uint8_t *last_coeff_flag_offset;
  676.     /* yes this is always aligned, and l[-1] exists in the cases where it's used (ac) */
  677.     for( j = i_count - 4; j >= -1; j -= 4 )
  678.         if( *(uint64_t*)(l+j) )
  679.             break;
  681.     if( i_count != 64 )
  682.     {
  683.         /* coded block flag */
  684.         int ctx = 85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx );
  685.         if( j >= -1 )
  686.             x264_cabac_encode_decision( cb, ctx, 1 );
  687.         else
  688.         {
  689.             x264_cabac_encode_decision( cb, ctx, 0 );
  690.             return;
  691.         }
  692.     }
  694.     significant_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
  695.                                   ? significant_coeff_flag_offset_8x8[h->mb.b_interlaced]
  696.                                   : identity;
  697.     last_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
  698.                            ? last_coeff_flag_offset_8x8 : identity;
  700.     for( i = j; i < j+4; i++)
  701.         if( l[i] )
  702.             i_last = i;
  704.     i_sigmap_size = X264_MIN( i_last+1, i_count-1 );
  706.     for( i = 0; i < i_sigmap_size; i++ )
  707.     {
  708.         if( l[i] )
  709.         {
  710.             i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
  711. #ifndef RDO_SKIP_BS
  712.             i_coeff_sign[i_coeff]   = l[i] < 0;
  713. #endif
  714.             i_coeff++;
  715.             x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 1 );
  716.             x264_cabac_encode_decision( cb, i_ctx_last + last_coeff_flag_offset[i], i == i_last );
  717.         }
  718.         else
  719.             x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 0 );
  720.     }
  722.     if( i == i_last )
  723.     {
  724.         i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
  725. #ifndef RDO_SKIP_BS
  726.         i_coeff_sign[i_coeff]   = l[i] < 0;
  727. #endif
  728.         i_coeff++;
  729.     }
  731.     do
  732.     {
  733.         int i_prefix, ctx;
  734.         i_coeff--;
  736.         /* write coeff_abs - 1 */
  737.         i_prefix = X264_MIN( i_coeff_abs_m1[i_coeff], 14 );
  738.         ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
  740.         if( i_prefix )
  741.         {
  742.             x264_cabac_encode_decision( cb, ctx, 1 );
  743.             ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
  744. #ifdef RDO_SKIP_BS
  745.             cb->f8_bits_encoded += cabac_prefix_size[i_prefix][cb->state[ctx]];
  746.             cb->state[ctx] = cabac_prefix_transition[i_prefix][cb->state[ctx]];
  747. #else
  748.             for( j = 0; j < i_prefix - 1; j++ )
  749.                 x264_cabac_encode_decision( cb, ctx, 1 );
  750.             if( i_prefix < 14 )
  751.                 x264_cabac_encode_decision( cb, ctx, 0 );
  752. #endif
  753.             if( i_prefix >= 14 )
  754.                 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i_coeff] - 14 );
  756.             node_ctx = coeff_abs_level_transition[1][node_ctx];
  757.         }
  758.         else
  759.         {
  760.             x264_cabac_encode_decision( cb, ctx, 0 );
  761.             node_ctx = coeff_abs_level_transition[0][node_ctx];
  762. #ifdef RDO_SKIP_BS
  763.             x264_cabac_encode_bypass( cb, 0 ); // sign
  764. #endif
  765.         }
  767. #ifndef RDO_SKIP_BS
  768.         x264_cabac_encode_bypass( cb, i_coeff_sign[i_coeff] );
  769. #endif
  770.     } while( i_coeff > 0 );
  771. }
  775. void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
  776. {
  777.     const int i_mb_type = h->mb.i_type;
  778.     int i_list;
  779.     int i;
  781. #ifndef RDO_SKIP_BS
  782.     const int i_mb_pos_start = x264_cabac_pos( cb );
  783.     int       i_mb_pos_tex;
  784. #endif
  786.     /* Write the MB type */
  787.     x264_cabac_mb_type( h, cb );
  789. #ifndef RDO_SKIP_BS
  790.     if( i_mb_type == I_PCM )
  791.     {
  792.         i_mb_pos_tex = x264_cabac_pos( cb );
  793.         h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
  795.         memcpy( cb->p, h->mb.pic.p_fenc[0], 256 );
  796.         cb->p += 256;
  797.         for( i = 0; i < 8; i++ )
  798.             memcpy( cb->p + i*8, h->mb.pic.p_fenc[1] + i*FENC_STRIDE, 8 );
  799.         cb->p += 64;
  800.         for( i = 0; i < 8; i++ )
  801.             memcpy( cb->p + i*8, h->mb.pic.p_fenc[2] + i*FENC_STRIDE, 8 );
  802.         cb->p += 64;
  804.         cb->i_low   = 0;
  805.         cb->i_range = 0x01FE;
  806.         cb->i_queue = -1;
  807.         cb->i_bytes_outstanding = 0;
  809.         /* if PCM is chosen, we need to store reconstructed frame data */
  810.         h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc[0], FENC_STRIDE, 16 );
  811.         h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE, 8 );
  812.         h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE, 8 );
  814.         h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
  815.         return;
  816.     }
  817. #endif
  819.     if( IS_INTRA( i_mb_type ) )
  820.     {
  821.         if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
  822.             x264_cabac_mb_transform_size( h, cb );
  824.         if( i_mb_type != I_16x16 )
  825.         {
  826.             int di = (i_mb_type == I_8x8) ? 4 : 1;
  827.             for( i = 0; i < 16; i += di )
  828.             {
  829.                 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
  830.                 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
  831.                 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
  832.             }
  833.         }
  835.         x264_cabac_mb_intra_chroma_pred_mode( h, cb );
  836.     }
  837.     else if( i_mb_type == P_L0 )
  838.     {
  839.         if( h->mb.i_partition == D_16x16 )
  840.         {
  841.             if( h->mb.pic.i_fref[0] > 1 )
  842.             {
  843.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  844.             }
  845.             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
  846.         }
  847.         else if( h->mb.i_partition == D_16x8 )
  848.         {
  849.             if( h->mb.pic.i_fref[0] > 1 )
  850.             {
  851.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  852.                 x264_cabac_mb_ref( h, cb, 0, 8 );
  853.             }
  854.             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
  855.             x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
  856.         }
  857.         else if( h->mb.i_partition == D_8x16 )
  858.         {
  859.             if( h->mb.pic.i_fref[0] > 1 )
  860.             {
  861.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  862.                 x264_cabac_mb_ref( h, cb, 0, 4 );
  863.             }
  864.             x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
  865.             x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
  866.         }
  867.     }
  868.     else if( i_mb_type == P_8x8 )
  869.     {
  870.         /* sub mb type */
  871.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[0] );
  872.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[1] );
  873.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[2] );
  874.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[3] );
  876.         /* ref 0 */
  877.         if( h->mb.pic.i_fref[0] > 1 )
  878.         {
  879.             x264_cabac_mb_ref( h, cb, 0, 0 );
  880.             x264_cabac_mb_ref( h, cb, 0, 4 );
  881.             x264_cabac_mb_ref( h, cb, 0, 8 );
  882.             x264_cabac_mb_ref( h, cb, 0, 12 );
  883.         }
  885.         for( i = 0; i < 4; i++ )
  886.             x264_cabac_mb8x8_mvd( h, cb, 0, i );
  887.     }
  888.     else if( i_mb_type == B_8x8 )
  889.     {
  890.         /* sub mb type */
  891.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[0] );
  892.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[1] );
  893.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[2] );
  894.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[3] );
  896.         /* ref */
  897.         for( i_list = 0; i_list < 2; i_list++ )
  898.         {
  899.             if( ( i_list ? h->mb.pic.i_fref[1] : h->mb.pic.i_fref[0] ) == 1 )
  900.                 continue;
  901.             for( i = 0; i < 4; i++ )
  902.                 if( x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
  903.                     x264_cabac_mb_ref( h, cb, i_list, 4*i );
  904.         }
  906.         for( i = 0; i < 4; i++ )
  907.             x264_cabac_mb8x8_mvd( h, cb, 0, i );
  908.         for( i = 0; i < 4; i++ )
  909.             x264_cabac_mb8x8_mvd( h, cb, 1, i );
  910.     }
  911.     else if( i_mb_type != B_DIRECT )
  912.     {
  913.         /* All B mode */
  914.         int b_list[2][2];
  916.         /* init ref list utilisations */
  917.         for( i = 0; i < 2; i++ )
  918.         {
  919.             b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
  920.             b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
  921.         }
  923.         for( i_list = 0; i_list < 2; i_list++ )
  924.         {
  925.             const int i_ref_max = i_list == 0 ? h->mb.pic.i_fref[0] : h->mb.pic.i_fref[1];
  927.             if( i_ref_max > 1 )
  928.             {
  929.                 if( h->mb.i_partition == D_16x16 )
  930.                 {
  931.                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
  932.                 }
  933.                 else if( h->mb.i_partition == D_16x8 )
  934.                 {
  935.                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
  936.                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 8 );
  937.                 }
  938.                 else if( h->mb.i_partition == D_8x16 )
  939.                 {
  940.                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
  941.                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 4 );
  942.                 }
  943.             }
  944.         }
  945.         for( i_list = 0; i_list < 2; i_list++ )
  946.         {
  947.             if( h->mb.i_partition == D_16x16 )
  948.             {
  949.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
  950.             }
  951.             else if( h->mb.i_partition == D_16x8 )
  952.             {
  953.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
  954.                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
  955.             }
  956.             else if( h->mb.i_partition == D_8x16 )
  957.             {
  958.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
  959.                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
  960.             }
  961.         }
  962.     }
  964. #ifndef RDO_SKIP_BS
  965.     i_mb_pos_tex = x264_cabac_pos( cb );
  966.     h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
  967. #endif
  969.     if( i_mb_type != I_16x16 )
  970.     {
  971.         x264_cabac_mb_cbp_luma( h, cb );
  972.         x264_cabac_mb_cbp_chroma( h, cb );
  973.     }
  975.     if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
  976.     {
  977.         x264_cabac_mb_transform_size( h, cb );
  978.     }
  980.     if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
  981.     {
  982.         x264_cabac_mb_qp_delta( h, cb );
  984.         /* write residual */
  985.         if( i_mb_type == I_16x16 )
  986.         {
  987.             /* DC Luma */
  988.             block_residual_write_cabac( h, cb, DCT_LUMA_DC, 0, h->dct.luma16x16_dc, 16 );
  990.             /* AC Luma */
  991.             if( h->mb.i_cbp_luma != 0 )
  992.                 for( i = 0; i < 16; i++ )
  993.                     block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 15 );
  994.         }
  995.         else if( h->mb.b_transform_8x8 )
  996.         {
  997.             for( i = 0; i < 4; i++ )
  998.                 if( h->mb.i_cbp_luma & ( 1 << i ) )
  999.                     block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i, h->dct.luma8x8[i], 64 );
  1000.         }
  1001.         else
  1002.         {
  1003.             for( i = 0; i < 16; i++ )
  1004.                 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
  1005.                     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], 16 );
  1006.         }
  1008.         if( h->mb.i_cbp_chroma &0x03 )    /* Chroma DC residual present */
  1009.         {
  1010.             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
  1011.             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
  1012.         }
  1013.         if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
  1014.         {
  1015.             for( i = 16; i < 24; i++ )
  1016.                 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
  1017.         }
  1018.     }
  1020. #ifndef RDO_SKIP_BS
  1021.     h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
  1022. #endif
  1023. }
  1025. #ifdef RDO_SKIP_BS
  1026. /*****************************************************************************
  1027.  * RD only; doesn't generate a valid bitstream
  1028.  * doesn't write cbp or chroma dc (I don't know how much this matters)
  1029.  * works on all partition sizes except 16x16
  1030.  * for sub8x8, call once per 8x8 block
  1031.  *****************************************************************************/
  1032. static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
  1033. {
  1034.     const int i_mb_type = h->mb.i_type;
  1035.     int j;
  1037.     if( i_mb_type == P_8x8 )
  1038.     {
  1039.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
  1040.         if( h->mb.pic.i_fref[0] > 1 )
  1041.             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
  1042.         x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
  1043.     }
  1044.     else if( i_mb_type == P_L0 )
  1045.     {
  1046.         if( h->mb.pic.i_fref[0] > 1 )
  1047.             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
  1048.         if( h->mb.i_partition == D_16x8 )
  1049.             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4, 2 );
  1050.         else //8x16
  1051.             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 4 );
  1052.     }
  1053.     else if( i_mb_type == B_8x8 )
  1054.     {
  1055.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i8] );
  1057.         if( h->mb.pic.i_fref[0] > 1
  1058.             && x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
  1059.             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
  1060.         if( h->mb.pic.i_fref[1] > 1
  1061.             && x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
  1062.             x264_cabac_mb_ref( h, cb, 1, 4*i8 );
  1064.         x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
  1065.         x264_cabac_mb8x8_mvd( h, cb, 1, i8 );
  1066.     }
  1067.     else
  1068.     {
  1069.         x264_log(h, X264_LOG_ERROR, "invalid/unhandled mb_typen" );
  1070.         return;
  1071.     }
  1073.     for( j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
  1074.     {
  1075.         if( h->mb.i_cbp_luma & (1 << i8) )
  1076.         {
  1077.             if( h->mb.b_transform_8x8 )
  1078.                 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i8, h->dct.luma8x8[i8], 64 );
  1079.             else
  1080.             {
  1081.                 int i4;
  1082.                 for( i4 = 0; i4 < 4; i4++ )
  1083.                     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 16 );
  1084.             }
  1085.         }
  1087.         block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 15 );
  1088.         block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 15 );
  1090.         i8 += x264_pixel_size[i_pixel].h >> 3;
  1091.     }
  1092. }
  1094. static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
  1095. {
  1096.     const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
  1097.     const int nnz = array_non_zero(h->dct.luma8x8[i8]);
  1098.     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
  1099.     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
  1100.     if( nnz )
  1101.     {
  1102.         block_residual_write_cabac( h, cb, DCT_LUMA_8x8, 4*i8, h->dct.luma8x8[i8], 64 );
  1103.         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4]] = 0x0101;
  1104.         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4+2]] = 0x0101;
  1105.     }
  1106.     else
  1107.     {
  1108.         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4]] = 0;
  1109.         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4+2]] = 0;
  1110.     }
  1111. }
  1113. static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
  1114. {
  1115.     const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
  1116.     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
  1117.     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
  1118.     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 16 );
  1119.     h->mb.cache.non_zero_count[x264_scan8[i4]] = array_non_zero( h->dct.luma4x4[i4] );
  1120. }
  1122. static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
  1123. {
  1124.     x264_cabac_mb_intra_chroma_pred_mode( h, cb );
  1125.     x264_cabac_mb_cbp_chroma( h, cb );
  1126.     if( h->mb.i_cbp_chroma > 0 )
  1127.     {
  1128.         block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
  1129.         block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
  1131.         if( h->mb.i_cbp_chroma == 2 )
  1132.         {
  1133.             int i;
  1134.             for( i = 16; i < 24; i++ )
  1135.                 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
  1136.         }
  1137.     }
  1138. }
  1139. #endif