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

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