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

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