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

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

Audio

开发平台：

Visual C++

cabac.c：源码内容
  1. /*****************************************************************************
  2.  * cabac.c: h264 encoder library
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 Laurent Aimar
  5.  * $Id: cabac.c,v 1.1 2004/06/03 19:27:08 fenrir Exp $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. #include <stdio.h>
  25. #include <string.h>
  27. #include "common/common.h"
  28. #include "macroblock.h"
  30. static inline void x264_cabac_encode_ue_bypass( x264_cabac_t *cb, int exp_bits, int val )
  31. {
  32. #ifdef RDO_SKIP_BS
  33.     cb->f8_bits_encoded += ( bs_size_ue( val + (1<<exp_bits)-1 ) - exp_bits ) << 8;
  34. #else
  35.     int k;
  36.     for( k = exp_bits; val >= (1<<k); k++ )
  37.     {
  38.         x264_cabac_encode_bypass( cb, 1 );
  39.         val -= 1 << k;
  40.     }
  41.     x264_cabac_encode_bypass( cb, 0 );
  42.     while( k-- )
  43.         x264_cabac_encode_bypass( cb, (val >> k)&0x01 );
  44. #endif
  45. }
  47. static inline void x264_cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
  48.                     int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
  49. {
  50.     if( i_mb_type == I_4x4 || i_mb_type == I_8x8 )
  51.     {
  52.         x264_cabac_encode_decision( cb, ctx0, 0 );
  53.     }
  54.     else if( i_mb_type == I_PCM )
  55.     {
  56.         x264_cabac_encode_decision( cb, ctx0, 1 );
  57.         x264_cabac_encode_terminal( cb,       1 );
  58.         x264_cabac_encode_flush( cb );
  59.     }
  60.     else
  61.     {
  62.         int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
  64.         x264_cabac_encode_decision( cb, ctx0, 1 );
  65.         x264_cabac_encode_terminal( cb,       0 );
  67.         x264_cabac_encode_decision( cb, ctx1, ( h->mb.i_cbp_luma == 0 ? 0 : 1 ));
  68.         if( h->mb.i_cbp_chroma == 0 )
  69.         {
  70.             x264_cabac_encode_decision( cb, ctx2, 0 );
  71.         }
  72.         else
  73.         {
  74.             x264_cabac_encode_decision( cb, ctx2, 1 );
  75.             x264_cabac_encode_decision( cb, ctx3, ( h->mb.i_cbp_chroma == 1 ? 0 : 1 ) );
  76.         }
  77.         x264_cabac_encode_decision( cb, ctx4, ( (i_pred / 2) ? 1 : 0 ));
  78.         x264_cabac_encode_decision( cb, ctx5, ( (i_pred % 2) ? 1 : 0 ));
  79.     }
  80. }
  82. static void x264_cabac_mb_type( x264_t *h, x264_cabac_t *cb )
  83. {
  84.     const int i_mb_type = h->mb.i_type;
  86.     if( h->sh.i_type == SLICE_TYPE_I )
  87.     {
  88.         int ctx = 0;
  89.         if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != I_4x4 )
  90.         {
  91.             ctx++;
  92.         }
  93.         if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != I_4x4 )
  94.         {
  95.             ctx++;
  96.         }
  98.         x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
  99.     }
  100.     else if( h->sh.i_type == SLICE_TYPE_P )
  101.     {
  102.         /* prefix: 14, suffix: 17 */
  103.         if( i_mb_type == P_L0 )
  104.         {
  105.             if( h->mb.i_partition == D_16x16 )
  106.             {
  107.                 x264_cabac_encode_decision( cb, 14, 0 );
  108.                 x264_cabac_encode_decision( cb, 15, 0 );
  109.                 x264_cabac_encode_decision( cb, 16, 0 );
  110.             }
  111.             else if( h->mb.i_partition == D_16x8 )
  112.             {
  113.                 x264_cabac_encode_decision( cb, 14, 0 );
  114.                 x264_cabac_encode_decision( cb, 15, 1 );
  115.                 x264_cabac_encode_decision( cb, 17, 1 );
  116.             }
  117.             else if( h->mb.i_partition == D_8x16 )
  118.             {
  119.                 x264_cabac_encode_decision( cb, 14, 0 );
  120.                 x264_cabac_encode_decision( cb, 15, 1 );
  121.                 x264_cabac_encode_decision( cb, 17, 0 );
  122.             }
  123.         }
  124.         else if( i_mb_type == P_8x8 )
  125.         {
  126.             x264_cabac_encode_decision( cb, 14, 0 );
  127.             x264_cabac_encode_decision( cb, 15, 0 );
  128.             x264_cabac_encode_decision( cb, 16, 1 );
  129.         }
  130.         else /* intra */
  131.         {
  132.             /* prefix */
  133.             x264_cabac_encode_decision( cb, 14, 1 );
  135.             /* suffix */
  136.             x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
  137.         }
  138.     }
  139.     else if( h->sh.i_type == SLICE_TYPE_B )
  140.     {
  141.         int ctx = 0;
  142.         if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != B_SKIP && h->mb.i_mb_type_left != B_DIRECT )
  143.         {
  144.             ctx++;
  145.         }
  146.         if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
  147.         {
  148.             ctx++;
  149.         }
  151.         if( i_mb_type == B_DIRECT )
  152.         {
  153.             x264_cabac_encode_decision( cb, 27+ctx, 0 );
  154.         }
  155.         else if( i_mb_type == B_8x8 )
  156.         {
  157.             x264_cabac_encode_decision( cb, 27+ctx, 1 );
  158.             x264_cabac_encode_decision( cb, 27+3,   1 );
  159.             x264_cabac_encode_decision( cb, 27+4,   1 );
  161.             x264_cabac_encode_decision( cb, 27+5,   1 );
  162.             x264_cabac_encode_decision( cb, 27+5,   1 );
  163.             x264_cabac_encode_decision( cb, 27+5,   1 );
  164.         }
  165.         else if( IS_INTRA( i_mb_type ) )
  166.         {
  167.             /* prefix */
  168.             x264_cabac_encode_decision( cb, 27+ctx, 1 );
  169.             x264_cabac_encode_decision( cb, 27+3,   1 );
  170.             x264_cabac_encode_decision( cb, 27+4,   1 );
  172.             x264_cabac_encode_decision( cb, 27+5,   1 );
  173.             x264_cabac_encode_decision( cb, 27+5,   0 );
  174.             x264_cabac_encode_decision( cb, 27+5,   1 );
  176.             /* suffix */
  177.             x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
  178.         }
  179.         else
  180.         {
  181.             static const int i_mb_len[9*3] =
  182.             {
  183.                 6, 6, 3,    /* L0 L0 */
  184.                 6, 6, 0,    /* L0 L1 */
  185.                 7, 7, 0,    /* L0 BI */
  186.                 6, 6, 0,    /* L1 L0 */
  187.                 6, 6, 3,    /* L1 L1 */
  188.                 7, 7, 0,    /* L1 BI */
  189.                 7, 7, 0,    /* BI L0 */
  190.                 7, 7, 0,    /* BI L1 */
  191.                 7, 7, 6,    /* BI BI */
  192.             };
  193.             static const int i_mb_bits[9*3][7] =
  194.             {
  195.                 { 1,1,0,0,0,1   }, { 1,1,0,0,1,0,  }, { 1,0,0 },       /* L0 L0 */
  196.                 { 1,1,0,1,0,1   }, { 1,1,0,1,1,0   }, {0},             /* L0 L1 */
  197.                 { 1,1,1,0,0,0,0 }, { 1,1,1,0,0,0,1 }, {0},             /* L0 BI */
  198.                 { 1,1,0,1,1,1   }, { 1,1,1,1,1,0   }, {0},             /* L1 L0 */
  199.                 { 1,1,0,0,1,1   }, { 1,1,0,1,0,0   }, { 1,0,1 },       /* L1 L1 */
  200.                 { 1,1,1,0,0,1,0 }, { 1,1,1,0,0,1,1 }, {0},             /* L1 BI */
  201.                 { 1,1,1,0,1,0,0 }, { 1,1,1,0,1,0,1 }, {0},             /* BI L0 */
  202.                 { 1,1,1,0,1,1,0 }, { 1,1,1,0,1,1,1 }, {0},             /* BI L1 */
  203.                 { 1,1,1,1,0,0,0 }, { 1,1,1,1,0,0,1 }, { 1,1,0,0,0,0 }, /* BI BI */
  204.             };
  206.             const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
  207.             int i;
  209.             x264_cabac_encode_decision( cb, 27+ctx, i_mb_bits[idx][0] );
  210.             x264_cabac_encode_decision( cb, 27+3,   i_mb_bits[idx][1] );
  211.             x264_cabac_encode_decision( cb, 27+5-i_mb_bits[idx][1], i_mb_bits[idx][2] );
  212.             for( i = 3; i < i_mb_len[idx]; i++ )
  213.                 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][i] );
  214.         }
  215.     }
  216.     else
  217.     {
  218.         x264_log(h, X264_LOG_ERROR, "unknown SLICE_TYPE unsupported in x264_macroblock_write_cabacn" );
  219.     }
  220. }
  222. static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
  223. {
  224.     if( i_pred == i_mode )
  225.     {
  226.         /* b_prev_intra4x4_pred_mode */
  227.         x264_cabac_encode_decision( cb, 68, 1 );
  228.     }
  229.     else
  230.     {
  231.         /* b_prev_intra4x4_pred_mode */
  232.         x264_cabac_encode_decision( cb, 68, 0 );
  233.         if( i_mode > i_pred  )
  234.         {
  235.             i_mode--;
  236.         }
  237.         x264_cabac_encode_decision( cb, 69, (i_mode     )&0x01 );
  238.         x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
  239.         x264_cabac_encode_decision( cb, 69, (i_mode >> 2)&0x01 );
  240.     }
  241. }
  243. static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
  244. {
  245.     const int i_mode = x264_mb_pred_mode8x8c_fix[ h->mb.i_chroma_pred_mode ];
  246.     int       ctx = 0;
  248.     /* No need to test for I4x4 or I_16x16 as cache_save handle that */
  249.     if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_xy - 1] != 0 )
  250.     {
  251.         ctx++;
  252.     }
  253.     if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_xy - h->mb.i_mb_stride] != 0 )
  254.     {
  255.         ctx++;
  256.     }
  258.     if( i_mode == 0 )
  259.     {
  260.         x264_cabac_encode_decision( cb, 64 + ctx, 0 );
  261.     }
  262.     else
  263.     {
  264.         x264_cabac_encode_decision( cb, 64 + ctx, 1 );
  265.         x264_cabac_encode_decision( cb, 64 + 3, ( i_mode == 1 ? 0 : 1 ) );
  266.         if( i_mode > 1 )
  267.         {
  268.             x264_cabac_encode_decision( cb, 64 + 3, ( i_mode == 2 ? 0 : 1 ) );
  269.         }
  270.     }
  271. }
  273. static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
  274. {
  275.     /* TODO: clean up and optimize */
  276.     int i8x8;
  277.     for( i8x8 = 0; i8x8 < 4; i8x8++ )
  278.     {
  279.         int i_mba_xy = -1;
  280.         int i_mbb_xy = -1;
  281.         int x = block_idx_x[4*i8x8];
  282.         int y = block_idx_y[4*i8x8];
  283.         int ctx = 0;
  285.         if( x > 0 )
  286.             i_mba_xy = h->mb.i_mb_xy;
  287.         else if( h->mb.i_neighbour & MB_LEFT )
  288.             i_mba_xy = h->mb.i_mb_xy - 1;
  290.         if( y > 0 )
  291.             i_mbb_xy = h->mb.i_mb_xy;
  292.         else if( h->mb.i_neighbour & MB_TOP )
  293.             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
  296.         /* No need to test for PCM and SKIP */
  297.         if( i_mba_xy >= 0 )
  298.         {
  299.             const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
  300.             if( ((h->mb.cbp[i_mba_xy] >> i8x8a)&0x01) == 0 )
  301.             {
  302.                 ctx++;
  303.             }
  304.         }
  306.         if( i_mbb_xy >= 0 )
  307.         {
  308.             const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
  309.             if( ((h->mb.cbp[i_mbb_xy] >> i8x8b)&0x01) == 0 )
  310.             {
  311.                 ctx += 2;
  312.             }
  313.         }
  315.         x264_cabac_encode_decision( cb, 73 + ctx, (h->mb.i_cbp_luma >> i8x8)&0x01 );
  316.     }
  317. }
  319. static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
  320. {
  321.     int cbp_a = -1;
  322.     int cbp_b = -1;
  323.     int ctx;
  325.     /* No need to test for SKIP/PCM */
  326.     if( h->mb.i_neighbour & MB_LEFT )
  327.     {
  328.         cbp_a = (h->mb.cbp[h->mb.i_mb_xy - 1] >> 4)&0x3;
  329.     }
  331.     if( h->mb.i_neighbour & MB_TOP )
  332.     {
  333.         cbp_b = (h->mb.cbp[h->mb.i_mb_xy - h->mb.i_mb_stride] >> 4)&0x3;
  334.     }
  336.     ctx = 0;
  337.     if( cbp_a > 0 ) ctx++;
  338.     if( cbp_b > 0 ) ctx += 2;
  339.     if( h->mb.i_cbp_chroma == 0 )
  340.     {
  341.         x264_cabac_encode_decision( cb, 77 + ctx, 0 );
  342.     }
  343.     else
  344.     {
  345.         x264_cabac_encode_decision( cb, 77 + ctx, 1 );
  347.         ctx = 4;
  348.         if( cbp_a == 2 ) ctx++;
  349.         if( cbp_b == 2 ) ctx += 2;
  350.         x264_cabac_encode_decision( cb, 77 + ctx, h->mb.i_cbp_chroma > 1 ? 1 : 0 );
  351.     }
  352. }
  354. /* TODO check it with != qp per mb */
  355. static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
  356. {
  357.     int i_mbn_xy = h->mb.i_mb_xy - 1;
  358.     int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
  359.     int ctx;
  361.     /* No need to test for PCM / SKIP */
  362.     if( i_mbn_xy >= h->sh.i_first_mb && h->mb.i_last_dqp != 0 &&
  363.         ( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) ) )
  364.         ctx = 1;
  365.     else
  366.         ctx = 0;
  368.     if( i_dqp != 0 )
  369.     {
  370.         int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
  371.         /* dqp is interpreted modulo 52 */
  372.         if( val > 52 )
  373.             val = 103 - val;
  374.         while( val-- )
  375.         {
  376.             x264_cabac_encode_decision( cb, 60 + ctx, 1 );
  377.             if( ctx < 2 )
  378.                 ctx = 2;
  379.             else
  380.                 ctx = 3;
  381.         }
  382.     }
  383.     x264_cabac_encode_decision( cb, 60 + ctx, 0 );
  384. }
  386. void x264_cabac_mb_skip( x264_t *h, int b_skip )
  387. {
  388.     int ctx = 0;
  390.     if( h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ) )
  391.     {
  392.         ctx++;
  393.     }
  394.     if( h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ) )
  395.     {
  396.         ctx++;
  397.     }
  399.     if( h->sh.i_type == SLICE_TYPE_P )
  400.         x264_cabac_encode_decision( &h->cabac, 11 + ctx, b_skip ? 1 : 0 );
  401.     else /* SLICE_TYPE_B */
  402.         x264_cabac_encode_decision( &h->cabac, 24 + ctx, b_skip ? 1 : 0 );
  403. }
  405. static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
  406. {
  407.     if( i_sub == D_L0_8x8 )
  408.     {
  409.         x264_cabac_encode_decision( cb, 21, 1 );
  410.     }
  411.     else if( i_sub == D_L0_8x4 )
  412.     {
  413.         x264_cabac_encode_decision( cb, 21, 0 );
  414.         x264_cabac_encode_decision( cb, 22, 0 );
  415.     }
  416.     else if( i_sub == D_L0_4x8 )
  417.     {
  418.         x264_cabac_encode_decision( cb, 21, 0 );
  419.         x264_cabac_encode_decision( cb, 22, 1 );
  420.         x264_cabac_encode_decision( cb, 23, 1 );
  421.     }
  422.     else if( i_sub == D_L0_4x4 )
  423.     {
  424.         x264_cabac_encode_decision( cb, 21, 0 );
  425.         x264_cabac_encode_decision( cb, 22, 1 );
  426.         x264_cabac_encode_decision( cb, 23, 0 );
  427.     }
  428. }
  430. static inline void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
  431. {
  432. #define WRITE_SUB_3(a,b,c) {
  433.         x264_cabac_encode_decision( cb, 36, a );
  434.         x264_cabac_encode_decision( cb, 37, b );
  435.         x264_cabac_encode_decision( cb, 39, c );
  436.     }
  437. #define WRITE_SUB_5(a,b,c,d,e) {
  438.         x264_cabac_encode_decision( cb, 36, a );
  439.         x264_cabac_encode_decision( cb, 37, b );
  440.         x264_cabac_encode_decision( cb, 38, c );
  441.         x264_cabac_encode_decision( cb, 39, d );
  442.         x264_cabac_encode_decision( cb, 39, e );
  443.     }
  444. #define WRITE_SUB_6(a,b,c,d,e,f) {
  445.         WRITE_SUB_5(a,b,c,d,e)
  446.         x264_cabac_encode_decision( cb, 39, f );
  447.     }
  449.     switch( i_sub )
  450.     {
  451.         case D_DIRECT_8x8:
  452.             x264_cabac_encode_decision( cb, 36, 0 );
  453.             break;
  454.         case D_L0_8x8: WRITE_SUB_3(1,0,0); break;
  455.         case D_L1_8x8: WRITE_SUB_3(1,0,1); break;
  456.         case D_BI_8x8: WRITE_SUB_5(1,1,0,0,0); break;
  457.         case D_L0_8x4: WRITE_SUB_5(1,1,0,0,1); break;
  458.         case D_L0_4x8: WRITE_SUB_5(1,1,0,1,0); break;
  459.         case D_L1_8x4: WRITE_SUB_5(1,1,0,1,1); break;
  460.         case D_L1_4x8: WRITE_SUB_6(1,1,1,0,0,0); break;
  461.         case D_BI_8x4: WRITE_SUB_6(1,1,1,0,0,1); break;
  462.         case D_BI_4x8: WRITE_SUB_6(1,1,1,0,1,0); break;
  463.         case D_L0_4x4: WRITE_SUB_6(1,1,1,0,1,1); break;
  464.         case D_L1_4x4: WRITE_SUB_5(1,1,1,1,0); break;
  465.         case D_BI_4x4: WRITE_SUB_5(1,1,1,1,1); break;
  466.     }
  467. }
  469. static inline void x264_cabac_mb_transform_size( x264_t *h, x264_cabac_t *cb )
  470. {
  471.     int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
  472.     x264_cabac_encode_decision( cb, ctx, h->mb.b_transform_8x8 );
  473. }
  475. static inline void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
  476. {
  477.     const int i8 = x264_scan8[idx];
  478.     const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
  479.     const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
  480.     int i_ref  = h->mb.cache.ref[i_list][i8];
  481.     int ctx  = 0;
  483.     if( i_refa > 0 && !h->mb.cache.skip[i8 - 1])
  484.         ctx++;
  485.     if( i_refb > 0 && !h->mb.cache.skip[i8 - 8])
  486.         ctx += 2;
  488.     while( i_ref > 0 )
  489.     {
  490.         x264_cabac_encode_decision( cb, 54 + ctx, 1 );
  491.         if( ctx < 4 )
  492.             ctx = 4;
  493.         else
  494.             ctx = 5;
  496.         i_ref--;
  497.     }
  498.     x264_cabac_encode_decision( cb, 54 + ctx, 0 );
  499. }
  503. static inline void  x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd )
  504. {
  505.     const int amvd = abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 1][l] ) +
  506.                      abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 8][l] );
  507.     const int i_abs = abs( mvd );
  508.     const int i_prefix = X264_MIN( i_abs, 9 );
  509.     const int ctxbase = (l == 0 ? 40 : 47);
  510.     int ctx;
  511.     int i;
  514.     if( amvd < 3 )
  515.         ctx = 0;
  516.     else if( amvd > 32 )
  517.         ctx = 2;
  518.     else
  519.         ctx = 1;
  521.     for( i = 0; i < i_prefix; i++ )
  522.     {
  523.         x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
  524.         if( ctx < 3 )
  525.             ctx = 3;
  526.         else if( ctx < 6 )
  527.             ctx++;
  528.     }
  529.     if( i_prefix < 9 )
  530.         x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
  531.     else
  532.         x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
  534.     /* sign */
  535.     if( mvd > 0 )
  536.         x264_cabac_encode_bypass( cb, 0 );
  537.     else if( mvd < 0 )
  538.         x264_cabac_encode_bypass( cb, 1 );
  539. }
  541. static inline void x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width, int height )
  542. {
  543.     int mvp[2];
  544.     int mdx, mdy;
  546.     /* Calculate mvd */
  547.     x264_mb_predict_mv( h, i_list, idx, width, mvp );
  548.     mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
  549.     mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
  551.     /* encode */
  552.     x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx );
  553.     x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy );
  555.     /* save value */
  556.     x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mdx, mdy );
  557. }
  559. static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i_list )
  560. {
  561.     int i;
  562.     for( i = 0; i < 4; i++ )
  563.     {
  564.         if( !x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
  565.         {
  566.             continue;
  567.         }
  569.         switch( h->mb.i_sub_partition[i] )
  570.         {
  571.             case D_L0_8x8:
  572.             case D_L1_8x8:
  573.             case D_BI_8x8:
  574.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i, 2, 2 );
  575.                 break;
  576.             case D_L0_8x4:
  577.             case D_L1_8x4:
  578.             case D_BI_8x4:
  579.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 2, 1 );
  580.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 2, 1 );
  581.                 break;
  582.             case D_L0_4x8:
  583.             case D_L1_4x8:
  584.             case D_BI_4x8:
  585.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 2 );
  586.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 2 );
  587.                 break;
  588.             case D_L0_4x4:
  589.             case D_L1_4x4:
  590.             case D_BI_4x4:
  591.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 1 );
  592.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 1 );
  593.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 1, 1 );
  594.                 x264_cabac_mb_mvd( h, cb, i_list, 4*i+3, 1, 1 );
  595.                 break;
  596.         }
  597.     }
  598. }
  600. static int x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx )
  601. {
  602.     /* TODO: clean up/optimize */
  603.     int i_mba_xy = -1;
  604.     int i_mbb_xy = -1;
  605.     int i_nza = -1;
  606.     int i_nzb = -1;
  607.     int ctx = 4 * i_cat;
  609.     if( i_cat == DCT_LUMA_DC )
  610.     {
  611.         if( h->mb.i_neighbour & MB_LEFT )
  612.         {
  613.             i_mba_xy = h->mb.i_mb_xy -1;
  614.             if( h->mb.type[i_mba_xy] == I_16x16 )
  615.             {
  616.                 i_nza = h->mb.cbp[i_mba_xy]&0x100;
  617.             }
  618.         }
  619.         if( h->mb.i_neighbour & MB_TOP )
  620.         {
  621.             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
  622.             if( h->mb.type[i_mbb_xy] == I_16x16 )
  623.             {
  624.                 i_nzb = h->mb.cbp[i_mbb_xy]&0x100;
  625.             }
  626.         }
  627.     }
  628.     else if( i_cat == DCT_LUMA_AC || i_cat == DCT_LUMA_4x4 )
  629.     {
  630.         int x = block_idx_x[i_idx];
  631.         int y = block_idx_y[i_idx];
  633.         if( x > 0 )
  634.             i_mba_xy = h->mb.i_mb_xy;
  635.         else if( h->mb.i_neighbour & MB_LEFT )
  636.             i_mba_xy = h->mb.i_mb_xy -1;
  638.         if( y > 0 )
  639.             i_mbb_xy = h->mb.i_mb_xy;
  640.         else if( h->mb.i_neighbour & MB_TOP )
  641.             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
  643.         /* no need to test for skip/pcm */
  644.         if( i_mba_xy >= 0 )
  645.         {
  646.             const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
  647.             if( (h->mb.cbp[i_mba_xy]&0x0f)>> i8x8a )
  648.             {
  649.                 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
  650.             }
  651.         }
  652.         if( i_mbb_xy >= 0 )
  653.         {
  654.             const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
  655.             if( (h->mb.cbp[i_mbb_xy]&0x0f)>> i8x8b )
  656.             {
  657.                 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
  658.             }
  659.         }
  660.     }
  661.     else if( i_cat == DCT_CHROMA_DC )
  662.     {
  663.         /* no need to test skip/pcm */
  664.         if( h->mb.i_neighbour & MB_LEFT )
  665.         {
  666.             i_mba_xy = h->mb.i_mb_xy -1;
  667.             if( h->mb.cbp[i_mba_xy]&0x30 )
  668.             {
  669.                 i_nza = h->mb.cbp[i_mba_xy]&( 0x02 << ( 8 + i_idx) );
  670.             }
  671.         }
  672.         if( h->mb.i_neighbour & MB_TOP )
  673.         {
  674.             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
  675.             if( h->mb.cbp[i_mbb_xy]&0x30 )
  676.             {
  677.                 i_nzb = h->mb.cbp[i_mbb_xy]&( 0x02 << ( 8 + i_idx) );
  678.             }
  679.         }
  680.     }
  681.     else if( i_cat == DCT_CHROMA_AC )
  682.     {
  683.         if( i_idx & 1 )
  684.             i_mba_xy = h->mb.i_mb_xy;
  685.         else if( h->mb.i_neighbour & MB_LEFT )
  686.             i_mba_xy = h->mb.i_mb_xy - 1;
  688.         if( i_idx & 2 )
  689.             i_mbb_xy = h->mb.i_mb_xy;
  690.         else if( h->mb.i_neighbour & MB_TOP )
  691.             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
  693.         /* no need to test skip/pcm */
  694.         if( i_mba_xy >= 0 && (h->mb.cbp[i_mba_xy]&0x30) == 0x20 )
  695.         {
  696.             i_nza = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 1];
  697.         }
  698.         if( i_mbb_xy >= 0 && (h->mb.cbp[i_mbb_xy]&0x30) == 0x20 )
  699.         {
  700.             i_nzb = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 8];
  701.         }
  702.     }
  704.     if( ( i_mba_xy < 0  && IS_INTRA( h->mb.i_type ) ) || i_nza > 0 )
  705.     {
  706.         ctx++;
  707.     }
  708.     if( ( i_mbb_xy < 0  && IS_INTRA( h->mb.i_type ) ) || i_nzb > 0 )
  709.     {
  710.         ctx += 2;
  711.     }
  713.     return ctx;
  714. }
  717. static const int significant_coeff_flag_offset[6] = { 105, 120, 134, 149, 152, 402 };
  718. static const int last_coeff_flag_offset[6] = { 166, 181, 195, 210, 213, 417 };
  719. static const int coeff_abs_level_m1_offset[6] = { 227, 237, 247, 257, 266, 426 };
  720. static const int significant_coeff_flag_offset_8x8[63] = {
  721.     0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
  722.     4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
  723.     7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
  724.    12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
  725. };
  726. static const int last_coeff_flag_offset_8x8[63] = {
  727.     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  728.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  729.     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  730.     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
  731. };
  733. static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int i_idx, int *l, int i_count )
  734. {
  735.     const int i_ctx_sig = significant_coeff_flag_offset[i_ctxBlockCat];
  736.     const int i_ctx_last = last_coeff_flag_offset[i_ctxBlockCat];
  737.     const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
  739.     int i_coeff_abs_m1[64];
  740.     int i_coeff_sign[64];
  741.     int i_coeff = 0;
  742.     int i_last  = 0;
  743.     int i_sigmap_size;
  745.     int i_abslevel1 = 0;
  746.     int i_abslevelgt1 = 0;
  748.     int i;
  750.     /* i_ctxBlockCat: 0-> DC 16x16  i_idx = 0
  751.      *                1-> AC 16x16  i_idx = luma4x4idx
  752.      *                2-> Luma4x4   i_idx = luma4x4idx
  753.      *                3-> DC Chroma i_idx = iCbCr
  754.      *                4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
  755.      *                5-> Luma8x8   i_idx = luma8x8idx
  756.      */
  758.     for( i = 0; i < i_count; i++ )
  759.     {
  760.         if( l[i] != 0 )
  761.         {
  762.             i_coeff_abs_m1[i_coeff] = abs( l[i] ) - 1;
  763.             i_coeff_sign[i_coeff]   = ( l[i] < 0 );
  764.             i_coeff++;
  766.             i_last = i;
  767.         }
  768.     }
  770.     if( i_count != 64 )
  771.     {
  772.         /* coded block flag */
  773.         x264_cabac_encode_decision( cb, 85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx ), i_coeff != 0 );
  774.         if( i_coeff == 0 )
  775.             return;
  776.     }
  778.     i_sigmap_size = X264_MIN( i_last+1, i_count-1 );
  779.     for( i = 0; i < i_sigmap_size; i++ )
  780.     {
  781.         int i_sig_ctxIdxInc;
  782.         int i_last_ctxIdxInc;
  784.         if( i_ctxBlockCat == DCT_LUMA_8x8 )
  785.         {
  786.             i_sig_ctxIdxInc = significant_coeff_flag_offset_8x8[i];
  787.             i_last_ctxIdxInc = last_coeff_flag_offset_8x8[i];
  788.         }
  789.         else
  790.             i_sig_ctxIdxInc = i_last_ctxIdxInc = i;
  792.         x264_cabac_encode_decision( cb, i_ctx_sig + i_sig_ctxIdxInc, l[i] != 0 );
  793.         if( l[i] != 0 )
  794.             x264_cabac_encode_decision( cb, i_ctx_last + i_last_ctxIdxInc, i == i_last );
  795.     }
  797.     for( i = i_coeff - 1; i >= 0; i-- )
  798.     {
  799.         /* write coeff_abs - 1 */
  800.         const int i_prefix = X264_MIN( i_coeff_abs_m1[i], 14 );
  801.         const int i_ctxIdxInc = (i_abslevelgt1 ? 0 : X264_MIN( 4, i_abslevel1 + 1 )) + i_ctx_level;
  802.         x264_cabac_encode_decision( cb, i_ctxIdxInc, i_prefix != 0 );
  804.         if( i_prefix != 0 )
  805.         {
  806.             const int i_ctxIdxInc = 5 + X264_MIN( 4, i_abslevelgt1 ) + i_ctx_level;
  807.             int j;
  808.             for( j = 0; j < i_prefix - 1; j++ )
  809.                 x264_cabac_encode_decision( cb, i_ctxIdxInc, 1 );
  810.             if( i_prefix < 14 )
  811.                 x264_cabac_encode_decision( cb, i_ctxIdxInc, 0 );
  812.             else /* suffix */
  813.                 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i] - 14 );
  815.             i_abslevelgt1++;
  816.         }
  817.         else
  818.             i_abslevel1++;
  820.         /* write sign */
  821.         x264_cabac_encode_bypass( cb, i_coeff_sign[i] );
  822.     }
  823. }
  827. void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
  828. {
  829.     const int i_mb_type = h->mb.i_type;
  830.     int i_list;
  831.     int i;
  833. #ifndef RDO_SKIP_BS
  834.     const int i_mb_pos_start = x264_cabac_pos( cb );
  835.     int       i_mb_pos_tex;
  836. #endif
  838.     /* Write the MB type */
  839.     x264_cabac_mb_type( h, cb );
  841.     /* PCM special block type UNTESTED */
  842.     if( i_mb_type == I_PCM )
  843.     {
  844. #ifdef RDO_SKIP_BS
  845.         cb->f8_bits_encoded += (384*8) << 8;
  846. #else
  847.         bs_t *s = cb->s;
  848.         bs_align_0( s );    /* not sure */
  849.         /* Luma */
  850.         for( i = 0; i < 16*16; i++ )
  851.         {
  852.             const int x = 16 * h->mb.i_mb_x + (i % 16);
  853.             const int y = 16 * h->mb.i_mb_y + (i / 16);
  854.             bs_write( s, 8, h->fenc->plane[0][y*h->mb.pic.i_stride[0]+x] );
  855.         }
  856.         /* Cb */
  857.         for( i = 0; i < 8*8; i++ )
  858.         {
  859.             const int x = 8 * h->mb.i_mb_x + (i % 8);
  860.             const int y = 8 * h->mb.i_mb_y + (i / 8);
  861.             bs_write( s, 8, h->fenc->plane[1][y*h->mb.pic.i_stride[1]+x] );
  862.         }
  863.         /* Cr */
  864.         for( i = 0; i < 8*8; i++ )
  865.         {
  866.             const int x = 8 * h->mb.i_mb_x + (i % 8);
  867.             const int y = 8 * h->mb.i_mb_y + (i / 8);
  868.             bs_write( s, 8, h->fenc->plane[2][y*h->mb.pic.i_stride[2]+x] );
  869.         }
  870.         x264_cabac_encode_init( cb, s );
  871. #endif
  872.         return;
  873.     }
  875.     if( IS_INTRA( i_mb_type ) )
  876.     {
  877.         if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
  878.             x264_cabac_mb_transform_size( h, cb );
  880.         if( i_mb_type != I_16x16 )
  881.         {
  882.             int di = (i_mb_type == I_8x8) ? 4 : 1;
  883.             for( i = 0; i < 16; i += di )
  884.             {
  885.                 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
  886.                 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
  887.                 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
  888.             }
  889.         }
  891.         x264_cabac_mb_intra_chroma_pred_mode( h, cb );
  892.     }
  893.     else if( i_mb_type == P_L0 )
  894.     {
  895.         if( h->mb.i_partition == D_16x16 )
  896.         {
  897.             if( h->sh.i_num_ref_idx_l0_active > 1 )
  898.             {
  899.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  900.             }
  901.             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
  902.         }
  903.         else if( h->mb.i_partition == D_16x8 )
  904.         {
  905.             if( h->sh.i_num_ref_idx_l0_active > 1 )
  906.             {
  907.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  908.                 x264_cabac_mb_ref( h, cb, 0, 8 );
  909.             }
  910.             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
  911.             x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
  912.         }
  913.         else if( h->mb.i_partition == D_8x16 )
  914.         {
  915.             if( h->sh.i_num_ref_idx_l0_active > 1 )
  916.             {
  917.                 x264_cabac_mb_ref( h, cb, 0, 0 );
  918.                 x264_cabac_mb_ref( h, cb, 0, 4 );
  919.             }
  920.             x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
  921.             x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
  922.         }
  923.     }
  924.     else if( i_mb_type == P_8x8 )
  925.     {
  926.         /* sub mb type */
  927.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[0] );
  928.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[1] );
  929.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[2] );
  930.         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[3] );
  932.         /* ref 0 */
  933.         if( h->sh.i_num_ref_idx_l0_active > 1 )
  934.         {
  935.             x264_cabac_mb_ref( h, cb, 0, 0 );
  936.             x264_cabac_mb_ref( h, cb, 0, 4 );
  937.             x264_cabac_mb_ref( h, cb, 0, 8 );
  938.             x264_cabac_mb_ref( h, cb, 0, 12 );
  939.         }
  941.         x264_cabac_mb8x8_mvd( h, cb, 0 );
  942.     }
  943.     else if( i_mb_type == B_8x8 )
  944.     {
  945.         /* sub mb type */
  946.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[0] );
  947.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[1] );
  948.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[2] );
  949.         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[3] );
  951.         /* ref */
  952.         for( i_list = 0; i_list < 2; i_list++ )
  953.         {
  954.             if( ( i_list ? h->sh.i_num_ref_idx_l1_active : h->sh.i_num_ref_idx_l0_active ) == 1 )
  955.                 continue;
  956.             for( i = 0; i < 4; i++ )
  957.                 if( x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
  958.                     x264_cabac_mb_ref( h, cb, i_list, 4*i );
  959.         }
  961.         x264_cabac_mb8x8_mvd( h, cb, 0 );
  962.         x264_cabac_mb8x8_mvd( h, cb, 1 );
  963.     }
  964.     else if( i_mb_type != B_DIRECT )
  965.     {
  966.         /* All B mode */
  967.         int b_list[2][2];
  969.         /* init ref list utilisations */
  970.         for( i = 0; i < 2; i++ )
  971.         {
  972.             b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
  973.             b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
  974.         }
  976.         for( i_list = 0; i_list < 2; i_list++ )
  977.         {
  978.             const int i_ref_max = i_list == 0 ? h->sh.i_num_ref_idx_l0_active : h->sh.i_num_ref_idx_l1_active;
  980.             if( i_ref_max > 1 )
  981.             {
  982.                 if( h->mb.i_partition == D_16x16 )
  983.                 {
  984.                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
  985.                 }
  986.                 else if( h->mb.i_partition == D_16x8 )
  987.                 {
  988.                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
  989.                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 8 );
  990.                 }
  991.                 else if( h->mb.i_partition == D_8x16 )
  992.                 {
  993.                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
  994.                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 4 );
  995.                 }
  996.             }
  997.         }
  998.         for( i_list = 0; i_list < 2; i_list++ )
  999.         {
  1000.             if( h->mb.i_partition == D_16x16 )
  1001.             {
  1002.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
  1003.             }
  1004.             else if( h->mb.i_partition == D_16x8 )
  1005.             {
  1006.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
  1007.                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
  1008.             }
  1009.             else if( h->mb.i_partition == D_8x16 )
  1010.             {
  1011.                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
  1012.                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
  1013.             }
  1014.         }
  1015.     }
  1017. #ifndef RDO_SKIP_BS
  1018.     i_mb_pos_tex = x264_cabac_pos( cb );
  1019.     h->stat.frame.i_hdr_bits += i_mb_pos_tex - i_mb_pos_start;
  1020. #endif
  1022.     if( i_mb_type != I_16x16 )
  1023.     {
  1024.         x264_cabac_mb_cbp_luma( h, cb );
  1025.         x264_cabac_mb_cbp_chroma( h, cb );
  1026.     }
  1028.     if( h->mb.cache.b_transform_8x8_allowed && h->mb.i_cbp_luma && !IS_INTRA(i_mb_type) )
  1029.     {
  1030.         x264_cabac_mb_transform_size( h, cb );
  1031.     }
  1033.     if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
  1034.     {
  1035.         x264_cabac_mb_qp_delta( h, cb );
  1037.         /* write residual */
  1038.         if( i_mb_type == I_16x16 )
  1039.         {
  1040.             /* DC Luma */
  1041.             block_residual_write_cabac( h, cb, DCT_LUMA_DC, 0, h->dct.luma16x16_dc, 16 );
  1043.             /* AC Luma */
  1044.             if( h->mb.i_cbp_luma != 0 )
  1045.                 for( i = 0; i < 16; i++ )
  1046.                     block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.block[i].residual_ac, 15 );
  1047.         }
  1048.         else if( h->mb.b_transform_8x8 )
  1049.         {
  1050.             for( i = 0; i < 4; i++ )
  1051.                 if( h->mb.i_cbp_luma & ( 1 << i ) )
  1052.                     block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i, h->dct.luma8x8[i], 64 );
  1053.         }
  1054.         else
  1055.         {
  1056.             for( i = 0; i < 16; i++ )
  1057.                 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
  1058.                     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.block[i].luma4x4, 16 );
  1059.         }
  1061.         if( h->mb.i_cbp_chroma &0x03 )    /* Chroma DC residual present */
  1062.         {
  1063.             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
  1064.             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
  1065.         }
  1066.         if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
  1067.         {
  1068.             for( i = 0; i < 8; i++ )
  1069.                 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.block[16+i].residual_ac, 15 );
  1070.         }
  1071.     }
  1073. #ifndef RDO_SKIP_BS
  1074.     if( IS_INTRA( i_mb_type ) )
  1075.         h->stat.frame.i_itex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
  1076.     else
  1077.         h->stat.frame.i_ptex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
  1078. #endif
  1079. }