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

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