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

   1 /*****************************************************************************
   2  * cabac.c: cabac bitstream writing
   3  *****************************************************************************
   4  * Copyright (C) 2003-2011 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_SPEC+1) */
 269         if( val >= QP_MAX_SPEC && val != QP_MAX_SPEC+1 )
 270             val = 2*QP_MAX_SPEC+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 /* ctx_block_cat: 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 {
 515     { 105, 120, 134, 149, 152, 402 },
 516     { 277, 292, 306, 321, 324, 436 }
 517 };
 518 static const uint16_t last_coeff_flag_offset[2][6] =
 519 {
 520     { 166, 181, 195, 210, 213, 417 },
 521     { 338, 353, 367, 382, 385, 451 }
 522 };
 523 static const uint16_t coeff_abs_level_m1_offset[6] =
 524     { 227, 237, 247, 257, 266, 426 };
 525 static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
 526 {{
 527     0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
 528     4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
 529     7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
 530    12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
 531 },{
 532     0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
 533     6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
 534     9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
 535     9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
 536 }};
 537 static const uint8_t last_coeff_flag_offset_8x8[63] =
 538 {
 539     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 540     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 541     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 542     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
 543 };
 544
 545 // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
 546 //           4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
 547 /* map node ctx => cabac ctx for level=1 */
 548 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
 549 /* map node ctx => cabac ctx for level>1 */
 550 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
 551 static const uint8_t coeff_abs_level_transition[2][8] = {
 552 /* update node ctx after coding a level=1 */
 553     { 1, 2, 3, 3, 4, 5, 6, 7 },
 554 /* update node ctx after coding a level>1 */
 555     { 4, 4, 4, 4, 5, 6, 7, 7 }
 556 };
 557 static const uint8_t count_cat_m1[5] = {15, 14, 15, 3, 14};
 558
 559 #if !RDO_SKIP_BS
 560 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
 561 {
 562     const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][ctx_block_cat];
 563     const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][ctx_block_cat];
 564     const int i_ctx_level = coeff_abs_level_m1_offset[ctx_block_cat];
 565     const uint8_t *sig_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
 566     int i_coeff_abs_m1[64];
 567     int i_coeff_sign[64];
 568     int i_coeff = 0;
 569     int i_last;
 570     int node_ctx = 0;
 571     int i = 0;
 572
 573     i_last = h->quantf.coeff_last[ctx_block_cat](l);
 574
 575 #define WRITE_SIGMAP( l8x8 )\
 576     while(1)\
 577     {\
 578         if( l[i] )\
 579         {\
 580             i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;\
 581             i_coeff_sign[i_coeff] = l[i] < 0;\
 582             i_coeff++;\
 583             x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? sig_offset[i] : i), 1 );\
 584             if( i == i_last )\
 585             {\
 586                 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 1 );\
 587                 break;\
 588             }\
 589             else\
 590                 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 0 );\
 591         }\
 592         else\
 593             x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? sig_offset[i] : i), 0 );\
 594         i++;\
 595         if( i == i_count_m1 )\
 596         {\
 597             i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;\
 598             i_coeff_sign[i_coeff]   = l[i] < 0;\
 599             i_coeff++;\
 600             break;\
 601         }\
 602     }
 603
 604     if( ctx_block_cat == DCT_LUMA_8x8 )
 605     {
 606         const int i_count_m1 = 63;
 607         WRITE_SIGMAP( 1 )
 608     }
 609     else
 610     {
 611         const int i_count_m1 = count_cat_m1[ctx_block_cat];
 612         WRITE_SIGMAP( 0 )
 613     }
 614
 615     do
 616     {
 617         int i_prefix, ctx;
 618         i_coeff--;
 619
 620         /* write coeff_abs - 1 */
 621         i_prefix = X264_MIN( i_coeff_abs_m1[i_coeff], 14 );
 622         ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
 623
 624         if( i_prefix )
 625         {
 626             x264_cabac_encode_decision( cb, ctx, 1 );
 627             ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
 628             for( i = 0; i < i_prefix - 1; i++ )
 629                 x264_cabac_encode_decision( cb, ctx, 1 );
 630             if( i_prefix < 14 )
 631                 x264_cabac_encode_decision( cb, ctx, 0 );
 632             else
 633                 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i_coeff] - 14 );
 634
 635             node_ctx = coeff_abs_level_transition[1][node_ctx];
 636         }
 637         else
 638         {
 639             x264_cabac_encode_decision( cb, ctx, 0 );
 640             node_ctx = coeff_abs_level_transition[0][node_ctx];
 641         }
 642
 643         x264_cabac_encode_bypass( cb, i_coeff_sign[i_coeff] );
 644     } while( i_coeff > 0 );
 645 }
 646 #define block_residual_write_cabac_8x8( h, cb, l ) block_residual_write_cabac( h, cb, DCT_LUMA_8x8, l )
 647
 648 #else
 649
 650 /* Faster RDO by merging sigmap and level coding.  Note that for 8x8dct
 651  * this is slightly incorrect because the sigmap is not reversible
 652  * (contexts are repeated).  However, there is nearly no quality penalty
 653  * for this (~0.001db) and the speed boost (~30%) is worth it. */
 654 static void ALWAYS_INLINE block_residual_write_cabac_internal( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l, int b_8x8 )
 655 {
 656     const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][ctx_block_cat];
 657     const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][ctx_block_cat];
 658     const int i_ctx_level = coeff_abs_level_m1_offset[ctx_block_cat];
 659     const uint8_t *sig_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
 660     int i_last, i_coeff_abs, ctx, node_ctx;
 661
 662     i_last = h->quantf.coeff_last[ctx_block_cat](l);
 663
 664     i_coeff_abs = abs(l[i_last]);
 665     ctx = coeff_abs_level1_ctx[0] + i_ctx_level;
 666
 667     if( i_last != (b_8x8 ? 63 : count_cat_m1[ctx_block_cat]) )
 668     {
 669         x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?sig_offset[i_last]:i_last), 1 );
 670         x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i_last]:i_last), 1 );
 671     }
 672
 673     if( i_coeff_abs > 1 )
 674     {
 675         x264_cabac_encode_decision( cb, ctx, 1 );
 676         ctx = coeff_abs_levelgt1_ctx[0] + i_ctx_level;
 677         if( i_coeff_abs < 15 )
 678         {
 679             cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
 680             cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
 681         }
 682         else
 683         {
 684             cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
 685             cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
 686             x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
 687         }
 688         node_ctx = coeff_abs_level_transition[1][0];
 689     }
 690     else
 691     {
 692         x264_cabac_encode_decision( cb, ctx, 0 );
 693         node_ctx = coeff_abs_level_transition[0][0];
 694         x264_cabac_encode_bypass( cb, 0 ); // sign
 695     }
 696
 697     for( int i = i_last-1 ; i >= 0; i-- )
 698     {
 699         if( l[i] )
 700         {
 701             i_coeff_abs = abs(l[i]);
 702             x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?sig_offset[i]:i), 1 );
 703             x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i]:i), 0 );
 704             ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
 705
 706             if( i_coeff_abs > 1 )
 707             {
 708                 x264_cabac_encode_decision( cb, ctx, 1 );
 709                 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
 710                 if( i_coeff_abs < 15 )
 711                 {
 712                     cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
 713                     cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
 714                 }
 715                 else
 716                 {
 717                     cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
 718                     cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
 719                     x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
 720                 }
 721                 node_ctx = coeff_abs_level_transition[1][node_ctx];
 722             }
 723             else
 724             {
 725                 x264_cabac_encode_decision( cb, ctx, 0 );
 726                 node_ctx = coeff_abs_level_transition[0][node_ctx];
 727                 x264_cabac_encode_bypass( cb, 0 );
 728             }
 729         }
 730         else
 731             x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?sig_offset[i]:i), 0 );
 732     }
 733 }
 734
 735 static void block_residual_write_cabac_8x8( x264_t *h, x264_cabac_t *cb, dctcoef *l )
 736 {
 737     block_residual_write_cabac_internal( h, cb, DCT_LUMA_8x8, l, 1 );
 738 }
 739 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
 740 {
 741     block_residual_write_cabac_internal( h, cb, ctx_block_cat, l, 0 );
 742 }
 743 #endif
 744
 745 #define block_residual_write_cabac_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
 746 {\
 747     int ctxidxinc = x264_cabac_mb_cbf_ctxidxinc( h, ctx_block_cat, i_idx, b_intra );\
 748     if( h->mb.cache.non_zero_count[x264_scan8[i_idx]] )\
 749     {\
 750         x264_cabac_encode_decision( cb, ctxidxinc, 1 );\
 751         block_residual_write_cabac( h, cb, ctx_block_cat, l );\
 752     }\
 753     else\
 754         x264_cabac_encode_decision( cb, ctxidxinc, 0 );\
 755 }
 756
 757 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
 758 {
 759     const int i_mb_type = h->mb.i_type;
 760     int i_list;
 761
 762 #if !RDO_SKIP_BS
 763     const int i_mb_pos_start = x264_cabac_pos( cb );
 764     int       i_mb_pos_tex;
 765 #endif
 766
 767     /* Write the MB type */
 768     x264_cabac_mb_type( h, cb );
 769
 770 #if !RDO_SKIP_BS
 771     if( i_mb_type == I_PCM )
 772     {
 773         i_mb_pos_tex = x264_cabac_pos( cb );
 774         h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
 775
 776         bs_t s;
 777         bs_init( &s, cb->p, cb->p_end - cb->p );
 778
 779         for( int i = 0; i < 256; i++ )
 780             bs_write( &s, BIT_DEPTH, h->mb.pic.p_fenc[0][i] );
 781         for( int ch = 1; ch < 3; ch++ )
 782             for( int i = 0; i < 8; i++ )
 783                 for( int j = 0; j < 8; j++ )
 784                     bs_write( &s, BIT_DEPTH, h->mb.pic.p_fenc[ch][i*FENC_STRIDE+j] );
 785
 786         bs_flush( &s );
 787         cb->p = s.p;
 788         x264_cabac_encode_init_core( cb );
 789
 790         h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
 791         return;
 792     }
 793 #endif
 794
 795     if( IS_INTRA( i_mb_type ) )
 796     {
 797         if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
 798             x264_cabac_mb_transform_size( h, cb );
 799
 800         if( i_mb_type != I_16x16 )
 801         {
 802             int di = h->mb.b_transform_8x8 ? 4 : 1;
 803             for( int i = 0; i < 16; i += di )
 804             {
 805                 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
 806                 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
 807                 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
 808             }
 809         }
 810
 811         x264_cabac_mb_intra_chroma_pred_mode( h, cb );
 812     }
 813     else if( i_mb_type == P_L0 )
 814     {
 815         if( h->mb.i_partition == D_16x16 )
 816         {
 817             if( h->mb.pic.i_fref[0] > 1 )
 818             {
 819                 x264_cabac_mb_ref( h, cb, 0, 0 );
 820             }
 821             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
 822         }
 823         else if( h->mb.i_partition == D_16x8 )
 824         {
 825             if( h->mb.pic.i_fref[0] > 1 )
 826             {
 827                 x264_cabac_mb_ref( h, cb, 0, 0 );
 828                 x264_cabac_mb_ref( h, cb, 0, 8 );
 829             }
 830             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
 831             x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
 832         }
 833         else //if( h->mb.i_partition == D_8x16 )
 834         {
 835             if( h->mb.pic.i_fref[0] > 1 )
 836             {
 837                 x264_cabac_mb_ref( h, cb, 0, 0 );
 838                 x264_cabac_mb_ref( h, cb, 0, 4 );
 839             }
 840             x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
 841             x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
 842         }
 843     }
 844     else if( i_mb_type == P_8x8 )
 845     {
 846         /* sub mb type */
 847         for( int i = 0; i < 4; i++ )
 848             x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i] );
 849
 850         /* ref 0 */
 851         if( h->mb.pic.i_fref[0] > 1 )
 852         {
 853             x264_cabac_mb_ref( h, cb, 0, 0 );
 854             x264_cabac_mb_ref( h, cb, 0, 4 );
 855             x264_cabac_mb_ref( h, cb, 0, 8 );
 856             x264_cabac_mb_ref( h, cb, 0, 12 );
 857         }
 858
 859         for( int i = 0; i < 4; i++ )
 860             x264_cabac_mb8x8_mvd( h, cb, i );
 861     }
 862     else if( i_mb_type == B_8x8 )
 863     {
 864         /* sub mb type */
 865         for( int i = 0; i < 4; i++ )
 866             x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i] );
 867
 868         /* ref */
 869         if( h->mb.pic.i_fref[0] > 1 )
 870             for( int i = 0; i < 4; i++ )
 871                 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
 872                     x264_cabac_mb_ref( h, cb, 0, 4*i );
 873
 874         if( h->mb.pic.i_fref[1] > 1 )
 875             for( int i = 0; i < 4; i++ )
 876                 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
 877                     x264_cabac_mb_ref( h, cb, 1, 4*i );
 878
 879         for( int i = 0; i < 4; i++ )
 880             if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
 881                 x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
 882
 883         for( int i = 0; i < 4; i++ )
 884             if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
 885                 x264_cabac_mb_mvd( h, cb, 1, 4*i, 2, 2 );
 886     }
 887     else if( i_mb_type != B_DIRECT )
 888     {
 889         /* All B mode */
 890         const uint8_t (*b_list)[2] = x264_mb_type_list_table[i_mb_type];
 891         if( h->mb.pic.i_fref[0] > 1 )
 892         {
 893             if( b_list[0][0] )
 894                 x264_cabac_mb_ref( h, cb, 0, 0 );
 895             if( b_list[0][1] && h->mb.i_partition != D_16x16 )
 896                 x264_cabac_mb_ref( h, cb, 0, 8 >> (h->mb.i_partition == D_8x16) );
 897         }
 898         if( h->mb.pic.i_fref[1] > 1 )
 899         {
 900             if( b_list[1][0] )
 901                 x264_cabac_mb_ref( h, cb, 1, 0 );
 902             if( b_list[1][1] && h->mb.i_partition != D_16x16 )
 903                 x264_cabac_mb_ref( h, cb, 1, 8 >> (h->mb.i_partition == D_8x16) );
 904         }
 905         for( i_list = 0; i_list < 2; i_list++ )
 906         {
 907             if( h->mb.i_partition == D_16x16 )
 908             {
 909                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
 910             }
 911             else if( h->mb.i_partition == D_16x8 )
 912             {
 913                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
 914                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
 915             }
 916             else //if( h->mb.i_partition == D_8x16 )
 917             {
 918                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
 919                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
 920             }
 921         }
 922     }
 923
 924 #if !RDO_SKIP_BS
 925     i_mb_pos_tex = x264_cabac_pos( cb );
 926     h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
 927 #endif
 928
 929     if( i_mb_type != I_16x16 )
 930     {
 931         x264_cabac_mb_cbp_luma( h, cb );
 932         x264_cabac_mb_cbp_chroma( h, cb );
 933     }
 934
 935     if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
 936     {
 937         x264_cabac_mb_transform_size( h, cb );
 938     }
 939
 940     if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
 941     {
 942         const int b_intra = IS_INTRA( i_mb_type );
 943         x264_cabac_mb_qp_delta( h, cb );
 944
 945         /* write residual */
 946         if( i_mb_type == I_16x16 )
 947         {
 948             /* DC Luma */
 949             block_residual_write_cabac_cbf( h, cb, DCT_LUMA_DC, 24, h->dct.luma16x16_dc, 1 );
 950
 951             /* AC Luma */
 952             if( h->mb.i_cbp_luma != 0 )
 953                 for( int i = 0; i < 16; i++ )
 954                     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 1 );
 955         }
 956         else if( h->mb.b_transform_8x8 )
 957         {
 958             for( int i = 0; i < 4; i++ )
 959                 if( h->mb.i_cbp_luma & ( 1 << i ) )
 960                     block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i] );
 961         }
 962         else
 963         {
 964             for( int i = 0; i < 16; i++ )
 965                 if( h->mb.i_cbp_luma & ( 1 << ( i >> 2 ) ) )
 966                     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], b_intra );
 967         }
 968
 969         if( h->mb.i_cbp_chroma ) /* Chroma DC residual present */
 970         {
 971             block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], b_intra );
 972             block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], b_intra );
 973             if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
 974                 for( int i = 16; i < 24; i++ )
 975                     block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, b_intra );
 976         }
 977     }
 978
 979 #if !RDO_SKIP_BS
 980     h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
 981 #endif
 982 }
 983
 984 #if RDO_SKIP_BS
 985 /*****************************************************************************
 986  * RD only; doesn't generate a valid bitstream
 987  * doesn't write cbp or chroma dc (I don't know how much this matters)
 988  * doesn't write ref (never varies between calls, so no point in doing so)
 989  * only writes subpartition for p8x8, needed for sub-8x8 mode decision RDO
 990  * works on all partition sizes except 16x16
 991  *****************************************************************************/
 992 static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
 993 {
 994     const int i_mb_type = h->mb.i_type;
 995     int b_8x16 = h->mb.i_partition == D_8x16;
 996
 997     if( i_mb_type == P_8x8 )
 998     {
 999         x264_cabac_mb8x8_mvd( h, cb, i8 );
1000         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
1001     }
1002     else if( i_mb_type == P_L0 )
1003         x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
1004     else if( i_mb_type > B_DIRECT && i_mb_type < B_8x8 )
1005     {
1006         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 );
1007         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 );
1008     }
1009     else //if( i_mb_type == B_8x8 )
1010     {
1011         if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1012             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 2 );
1013         if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1014             x264_cabac_mb_mvd( h, cb, 1, 4*i8, 2, 2 );
1015     }
1016
1017     for( int j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1018     {
1019         if( h->mb.i_cbp_luma & (1 << i8) )
1020         {
1021             if( h->mb.b_transform_8x8 )
1022                 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
1023             else
1024                 for( int i4 = 0; i4 < 4; i4++ )
1025                     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 0 );
1026         }
1027
1028         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 0 );
1029         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 0 );
1030
1031         i8 += x264_pixel_size[i_pixel].h >> 3;
1032     }
1033 }
1034
1035 static void x264_subpartition_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_pixel )
1036 {
1037     int b_8x4 = i_pixel == PIXEL_8x4;
1038     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 0 );
1039     if( i_pixel == PIXEL_4x4 )
1040     {
1041         x264_cabac_mb_mvd( h, cb, 0, i4, 1, 1 );
1042     }
1043     else
1044     {
1045         x264_cabac_mb_mvd( h, cb, 0, i4, 1+b_8x4, 2-b_8x4 );
1046         block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+2-b_8x4, h->dct.luma4x4[i4+2-b_8x4], 0 );
1047     }
1048 }
1049
1050 static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1051 {
1052     const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1053     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1054     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1055     x264_cabac_mb_cbp_luma( h, cb );
1056     if( h->mb.i_cbp_luma & (1 << i8) )
1057         block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
1058 }
1059
1060 static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1061 {
1062     const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1063     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1064     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1065     block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 1 );
1066 }
1067
1068 static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
1069 {
1070     x264_cabac_mb_intra_chroma_pred_mode( h, cb );
1071     x264_cabac_mb_cbp_chroma( h, cb );
1072     if( h->mb.i_cbp_chroma > 0 )
1073     {
1074         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], 1 );
1075         block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], 1 );
1076
1077         if( h->mb.i_cbp_chroma == 2 )
1078             for( int i = 16; i < 24; i++ )
1079                 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 1 );
1080     }
1081 }
1082 #endif