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