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

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