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     do
 732     {
 733         int i_prefix, ctx;
 734         i_coeff--;
 735
 736         /* write coeff_abs - 1 */
 737         i_prefix = X264_MIN( i_coeff_abs_m1[i_coeff], 14 );
 738         ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
 739
 740         if( i_prefix )
 741         {
 742             x264_cabac_encode_decision( cb, ctx, 1 );
 743             ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
 744 #ifdef RDO_SKIP_BS
 745             cb->f8_bits_encoded += cabac_prefix_size[i_prefix][cb->state[ctx]];
 746             cb->state[ctx] = cabac_prefix_transition[i_prefix][cb->state[ctx]];
 747 #else
 748             for( j = 0; j < i_prefix - 1; j++ )
 749                 x264_cabac_encode_decision( cb, ctx, 1 );
 750             if( i_prefix < 14 )
 751                 x264_cabac_encode_decision( cb, ctx, 0 );
 752 #endif
 753             if( i_prefix >= 14 )
 754                 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i_coeff] - 14 );
 755
 756             node_ctx = coeff_abs_level_transition[1][node_ctx];
 757         }
 758         else
 759         {
 760             x264_cabac_encode_decision( cb, ctx, 0 );
 761             node_ctx = coeff_abs_level_transition[0][node_ctx];
 762 #ifdef RDO_SKIP_BS
 763             x264_cabac_encode_bypass( cb, 0 ); // sign
 764 #endif
 765         }
 766
 767 #ifndef RDO_SKIP_BS
 768         x264_cabac_encode_bypass( cb, i_coeff_sign[i_coeff] );
 769 #endif
 770     } while( i_coeff > 0 );
 771 }
 772
 773
 774
 775 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
 776 {
 777     const int i_mb_type = h->mb.i_type;
 778     int i_list;
 779     int i;
 780
 781 #ifndef RDO_SKIP_BS
 782     const int i_mb_pos_start = x264_cabac_pos( cb );
 783     int       i_mb_pos_tex;
 784 #endif
 785
 786     /* Write the MB type */
 787     x264_cabac_mb_type( h, cb );
 788
 789 #ifndef RDO_SKIP_BS
 790     if( i_mb_type == I_PCM )
 791     {
 792         i_mb_pos_tex = x264_cabac_pos( cb );
 793         h->stat.frame.i_hdr_bits += i_mb_pos_tex - i_mb_pos_start;
 794
 795         memcpy( cb->p, h->mb.pic.p_fenc[0], 256 );
 796         cb->p += 256;
 797         for( i = 0; i < 8; i++ )
 798             memcpy( cb->p + i*8, h->mb.pic.p_fenc[1] + i*FENC_STRIDE, 8 );
 799         cb->p += 64;
 800         for( i = 0; i < 8; i++ )
 801             memcpy( cb->p + i*8, h->mb.pic.p_fenc[2] + i*FENC_STRIDE, 8 );
 802         cb->p += 64;
 803
 804         cb->i_low   = 0;
 805         cb->i_range = 0x01FE;
 806         cb->i_queue = -1;
 807         cb->i_bytes_outstanding = 0;
 808
 809         /* if PCM is chosen, we need to store reconstructed frame data */
 810         h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc[0], FENC_STRIDE, 16 );
 811         h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE, 8 );
 812         h->mc.copy[PIXEL_8x8]  ( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE, 8 );
 813
 814         h->stat.frame.i_itex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
 815         return;
 816     }
 817 #endif
 818
 819     if( IS_INTRA( i_mb_type ) )
 820     {
 821         if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
 822             x264_cabac_mb_transform_size( h, cb );
 823
 824         if( i_mb_type != I_16x16 )
 825         {
 826             int di = (i_mb_type == I_8x8) ? 4 : 1;
 827             for( i = 0; i < 16; i += di )
 828             {
 829                 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
 830                 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
 831                 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
 832             }
 833         }
 834
 835         x264_cabac_mb_intra_chroma_pred_mode( h, cb );
 836     }
 837     else if( i_mb_type == P_L0 )
 838     {
 839         if( h->mb.i_partition == D_16x16 )
 840         {
 841             if( h->mb.pic.i_fref[0] > 1 )
 842             {
 843                 x264_cabac_mb_ref( h, cb, 0, 0 );
 844             }
 845             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
 846         }
 847         else if( h->mb.i_partition == D_16x8 )
 848         {
 849             if( h->mb.pic.i_fref[0] > 1 )
 850             {
 851                 x264_cabac_mb_ref( h, cb, 0, 0 );
 852                 x264_cabac_mb_ref( h, cb, 0, 8 );
 853             }
 854             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
 855             x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
 856         }
 857         else if( h->mb.i_partition == D_8x16 )
 858         {
 859             if( h->mb.pic.i_fref[0] > 1 )
 860             {
 861                 x264_cabac_mb_ref( h, cb, 0, 0 );
 862                 x264_cabac_mb_ref( h, cb, 0, 4 );
 863             }
 864             x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
 865             x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
 866         }
 867     }
 868     else if( i_mb_type == P_8x8 )
 869     {
 870         /* sub mb type */
 871         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[0] );
 872         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[1] );
 873         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[2] );
 874         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[3] );
 875
 876         /* ref 0 */
 877         if( h->mb.pic.i_fref[0] > 1 )
 878         {
 879             x264_cabac_mb_ref( h, cb, 0, 0 );
 880             x264_cabac_mb_ref( h, cb, 0, 4 );
 881             x264_cabac_mb_ref( h, cb, 0, 8 );
 882             x264_cabac_mb_ref( h, cb, 0, 12 );
 883         }
 884
 885         for( i = 0; i < 4; i++ )
 886             x264_cabac_mb8x8_mvd( h, cb, 0, i );
 887     }
 888     else if( i_mb_type == B_8x8 )
 889     {
 890         /* sub mb type */
 891         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[0] );
 892         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[1] );
 893         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[2] );
 894         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[3] );
 895
 896         /* ref */
 897         for( i_list = 0; i_list < 2; i_list++ )
 898         {
 899             if( ( i_list ? h->mb.pic.i_fref[1] : h->mb.pic.i_fref[0] ) == 1 )
 900                 continue;
 901             for( i = 0; i < 4; i++ )
 902                 if( x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
 903                     x264_cabac_mb_ref( h, cb, i_list, 4*i );
 904         }
 905
 906         for( i = 0; i < 4; i++ )
 907             x264_cabac_mb8x8_mvd( h, cb, 0, i );
 908         for( i = 0; i < 4; i++ )
 909             x264_cabac_mb8x8_mvd( h, cb, 1, i );
 910     }
 911     else if( i_mb_type != B_DIRECT )
 912     {
 913         /* All B mode */
 914         int b_list[2][2];
 915
 916         /* init ref list utilisations */
 917         for( i = 0; i < 2; i++ )
 918         {
 919             b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
 920             b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
 921         }
 922
 923         for( i_list = 0; i_list < 2; i_list++ )
 924         {
 925             const int i_ref_max = i_list == 0 ? h->mb.pic.i_fref[0] : h->mb.pic.i_fref[1];
 926
 927             if( i_ref_max > 1 )
 928             {
 929                 if( h->mb.i_partition == D_16x16 )
 930                 {
 931                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
 932                 }
 933                 else if( h->mb.i_partition == D_16x8 )
 934                 {
 935                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
 936                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 8 );
 937                 }
 938                 else if( h->mb.i_partition == D_8x16 )
 939                 {
 940                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
 941                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 4 );
 942                 }
 943             }
 944         }
 945         for( i_list = 0; i_list < 2; i_list++ )
 946         {
 947             if( h->mb.i_partition == D_16x16 )
 948             {
 949                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
 950             }
 951             else if( h->mb.i_partition == D_16x8 )
 952             {
 953                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
 954                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
 955             }
 956             else if( h->mb.i_partition == D_8x16 )
 957             {
 958                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
 959                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
 960             }
 961         }
 962     }
 963
 964 #ifndef RDO_SKIP_BS
 965     i_mb_pos_tex = x264_cabac_pos( cb );
 966     h->stat.frame.i_hdr_bits += i_mb_pos_tex - i_mb_pos_start;
 967 #endif
 968
 969     if( i_mb_type != I_16x16 )
 970     {
 971         x264_cabac_mb_cbp_luma( h, cb );
 972         x264_cabac_mb_cbp_chroma( h, cb );
 973     }
 974
 975     if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
 976     {
 977         x264_cabac_mb_transform_size( h, cb );
 978     }
 979
 980     if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
 981     {
 982         x264_cabac_mb_qp_delta( h, cb );
 983
 984         /* write residual */
 985         if( i_mb_type == I_16x16 )
 986         {
 987             /* DC Luma */
 988             block_residual_write_cabac( h, cb, DCT_LUMA_DC, 0, h->dct.luma16x16_dc, 16 );
 989
 990             /* AC Luma */
 991             if( h->mb.i_cbp_luma != 0 )
 992                 for( i = 0; i < 16; i++ )
 993                     block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 15 );
 994         }
 995         else if( h->mb.b_transform_8x8 )
 996         {
 997             for( i = 0; i < 4; i++ )
 998                 if( h->mb.i_cbp_luma & ( 1 << i ) )
 999                     block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i, h->dct.luma8x8[i], 64 );
1000         }
1001         else
1002         {
1003             for( i = 0; i < 16; i++ )
1004                 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
1005                     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], 16 );
1006         }
1007
1008         if( h->mb.i_cbp_chroma &0x03 )    /* Chroma DC residual present */
1009         {
1010             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
1011             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
1012         }
1013         if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
1014         {
1015             for( i = 16; i < 24; i++ )
1016                 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
1017         }
1018     }
1019
1020 #ifndef RDO_SKIP_BS
1021     if( IS_INTRA( i_mb_type ) )
1022         h->stat.frame.i_itex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1023     else
1024         h->stat.frame.i_ptex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1025 #endif
1026 }
1027
1028 #ifdef RDO_SKIP_BS
1029 /*****************************************************************************
1030  * RD only; doesn't generate a valid bitstream
1031  * doesn't write cbp or chroma dc (I don't know how much this matters)
1032  * works on all partition sizes except 16x16
1033  * for sub8x8, call once per 8x8 block
1034  *****************************************************************************/
1035 void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
1036 {
1037     const int i_mb_type = h->mb.i_type;
1038     int j;
1039
1040     if( i_mb_type == P_8x8 )
1041     {
1042         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
1043         if( h->mb.pic.i_fref[0] > 1 )
1044             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1045         x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1046     }
1047     else if( i_mb_type == P_L0 )
1048     {
1049         if( h->mb.pic.i_fref[0] > 1 )
1050             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1051         if( h->mb.i_partition == D_16x8 )
1052             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4, 2 );
1053         else //8x16
1054             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 4 );
1055     }
1056     else if( i_mb_type == B_8x8 )
1057     {
1058         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i8] );
1059
1060         if( h->mb.pic.i_fref[0] > 1
1061             && x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1062             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1063         if( h->mb.pic.i_fref[1] > 1
1064             && x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1065             x264_cabac_mb_ref( h, cb, 1, 4*i8 );
1066
1067         x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1068         x264_cabac_mb8x8_mvd( h, cb, 1, i8 );
1069     }
1070     else
1071     {
1072         x264_log(h, X264_LOG_ERROR, "invalid/unhandled mb_type\n" );
1073         return;
1074     }
1075
1076     for( j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1077     {
1078         if( h->mb.i_cbp_luma & (1 << i8) )
1079         {
1080             if( h->mb.b_transform_8x8 )
1081                 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i8, h->dct.luma8x8[i8], 64 );
1082             else
1083             {
1084                 int i4;
1085                 for( i4 = 0; i4 < 4; i4++ )
1086                     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 16 );
1087             }
1088         }
1089
1090         block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 15 );
1091         block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 15 );
1092
1093         i8 += x264_pixel_size[i_pixel].h >> 3;
1094     }
1095 }
1096
1097 static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1098 {
1099     const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1100     const int nnz = array_non_zero(h->dct.luma8x8[i8]);
1101     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1102     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1103     if( nnz )
1104     {
1105         block_residual_write_cabac( h, cb, DCT_LUMA_8x8, 4*i8, h->dct.luma8x8[i8], 64 );
1106         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4]] = 0x0101;
1107         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4+2]] = 0x0101;
1108     }
1109     else
1110     {
1111         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4]] = 0;
1112         *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4+2]] = 0;
1113     }
1114 }
1115
1116 static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1117 {
1118     const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1119     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1120     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1121     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 16 );
1122     h->mb.cache.non_zero_count[x264_scan8[i4]] = array_non_zero( h->dct.luma4x4[i4] );
1123 }
1124
1125 static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
1126 {
1127     x264_cabac_mb_intra_chroma_pred_mode( h, cb );
1128     x264_cabac_mb_cbp_chroma( h, cb );
1129     if( h->mb.i_cbp_chroma > 0 )
1130     {
1131         block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
1132         block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
1133
1134         if( h->mb.i_cbp_chroma == 2 )
1135         {
1136             int i;
1137             for( i = 16; i < 24; i++ )
1138                 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
1139         }
1140     }
1141 }
1142 #endif