git.sesse.net Git - x264/blob - encoder/cabac.c

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