CABAC: clean up and restructure
authorJason Garrett-Glaser <jason@x264.com>
Fri, 9 Sep 2011 00:27:02 +0000 (17:27 -0700)
committerJason Garrett-Glaser <jason@x264.com>
Wed, 21 Sep 2011 16:54:49 +0000 (09:54 -0700)
Somewhat faster CABAC and RD bit-counting.

common/macroblock.c
encoder/cabac.c

index a710fec..de6dfd8 100644 (file)
@@ -447,8 +447,6 @@ void x264_macroblock_slice_init( x264_t *h )
     }
     else if( h->sh.i_type == SLICE_TYPE_P )
     {
-        memset( h->mb.cache.skip, 0, sizeof( h->mb.cache.skip ) );
-
         if( h->sh.i_disable_deblocking_filter_idc != 1 && h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART )
         {
             deblock_ref_table(-2) = -2;
index 92c7790..eb2bfe8 100644 (file)
@@ -80,120 +80,7 @@ static void x264_cabac_field_decoding_flag( x264_t *h, x264_cabac_t *cb )
 }
 #endif
 
-static void x264_cabac_mb_type( x264_t *h, x264_cabac_t *cb )
-{
-    const int i_mb_type = h->mb.i_type;
-
-#if !RDO_SKIP_BS
-    if( SLICE_MBAFF &&
-        (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
-    {
-        x264_cabac_field_decoding_flag( h, cb );
-    }
-#endif
-
-    if( h->sh.i_type == SLICE_TYPE_I )
-    {
-        int ctx = 0;
-        if( (h->mb.i_neighbour & MB_LEFT) && h->mb.i_mb_type_left[0] != I_4x4 )
-            ctx++;
-        if( (h->mb.i_neighbour & MB_TOP) && h->mb.i_mb_type_top != I_4x4 )
-            ctx++;
-
-        x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
-    }
-    else if( h->sh.i_type == SLICE_TYPE_P )
-    {
-        /* prefix: 14, suffix: 17 */
-        if( i_mb_type == P_L0 )
-        {
-            x264_cabac_encode_decision_noup( cb, 14, 0 );
-            x264_cabac_encode_decision_noup( cb, 15, h->mb.i_partition != D_16x16 );
-            x264_cabac_encode_decision_noup( cb, 17-(h->mb.i_partition == D_16x16), h->mb.i_partition == D_16x8 );
-        }
-        else if( i_mb_type == P_8x8 )
-        {
-            x264_cabac_encode_decision_noup( cb, 14, 0 );
-            x264_cabac_encode_decision_noup( cb, 15, 0 );
-            x264_cabac_encode_decision_noup( cb, 16, 1 );
-        }
-        else /* intra */
-        {
-            /* prefix */
-            x264_cabac_encode_decision_noup( cb, 14, 1 );
-
-            /* suffix */
-            x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
-        }
-    }
-    else //if( h->sh.i_type == SLICE_TYPE_B )
-    {
-        int ctx = 0;
-        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 )
-            ctx++;
-        if( (h->mb.i_neighbour & MB_TOP) && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
-            ctx++;
-
-        if( i_mb_type == B_DIRECT )
-        {
-            x264_cabac_encode_decision_noup( cb, 27+ctx, 0 );
-            return;
-        }
-        x264_cabac_encode_decision_noup( cb, 27+ctx, 1 );
-
-        if( i_mb_type == B_8x8 )
-        {
-            x264_cabac_encode_decision_noup( cb, 27+3,   1 );
-            x264_cabac_encode_decision_noup( cb, 27+4,   1 );
-            x264_cabac_encode_decision( cb, 27+5,   1 );
-            x264_cabac_encode_decision( cb, 27+5,   1 );
-            x264_cabac_encode_decision_noup( cb, 27+5,   1 );
-        }
-        else if( IS_INTRA( i_mb_type ) )
-        {
-            /* prefix */
-            x264_cabac_encode_decision_noup( cb, 27+3,   1 );
-            x264_cabac_encode_decision_noup( cb, 27+4,   1 );
-            x264_cabac_encode_decision( cb, 27+5,   1 );
-            x264_cabac_encode_decision( cb, 27+5,   0 );
-            x264_cabac_encode_decision( cb, 27+5,   1 );
-
-            /* suffix */
-            x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
-        }
-        else
-        {
-            static const uint8_t i_mb_bits[9*3] =
-            {
-                0x31, 0x29, 0x4, /* L0 L0 */
-                0x35, 0x2d, 0,   /* L0 L1 */
-                0x43, 0x63, 0,   /* L0 BI */
-                0x3d, 0x2f, 0,   /* L1 L0 */
-                0x39, 0x25, 0x6, /* L1 L1 */
-                0x53, 0x73, 0,   /* L1 BI */
-                0x4b, 0x6b, 0,   /* BI L0 */
-                0x5b, 0x7b, 0,   /* BI L1 */
-                0x47, 0x67, 0x21 /* BI BI */
-            };
-
-            const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
-            int bits = i_mb_bits[idx];
-
-            x264_cabac_encode_decision_noup( cb, 27+3, bits&1 );
-            x264_cabac_encode_decision( cb, 27+5-(bits&1), (bits>>1)&1 ); bits >>= 2;
-            if( bits != 1 )
-            {
-                x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
-                x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
-                x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
-                if( bits != 1 )
-                    x264_cabac_encode_decision_noup( cb, 27+5, bits&1 );
-            }
-        }
-    }
-}
-
-static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
+static void x264_cabac_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
 {
     if( i_pred == i_mode )
         x264_cabac_encode_decision( cb, 68, 1 );
@@ -208,7 +95,7 @@ static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int
     }
 }
 
-static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
+static void x264_cabac_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
 {
     int i_mode = x264_mb_chroma_pred_mode_fix[h->mb.i_chroma_pred_mode];
     int ctx = 0;
@@ -228,7 +115,7 @@ static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
     }
 }
 
-static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
+static void x264_cabac_cbp_luma( x264_t *h, x264_cabac_t *cb )
 {
     int cbp = h->mb.i_cbp_luma;
     int cbp_l = h->mb.cache.i_cbp_left;
@@ -239,7 +126,7 @@ static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
     x264_cabac_encode_decision_noup( cb, 76 - ((cbp   >> 2) & 1) - ((cbp   >> 0) & 2), (cbp >> 3) & 1 );
 }
 
-static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
+static void x264_cabac_cbp_chroma( x264_t *h, x264_cabac_t *cb )
 {
     int cbp_a = h->mb.cache.i_cbp_left & 0x30;
     int cbp_b = h->mb.cache.i_cbp_top  & 0x30;
@@ -260,7 +147,7 @@ static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
     }
 }
 
-static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
+static void x264_cabac_qp_delta( x264_t *h, x264_cabac_t *cb )
 {
     int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
     int ctx;
@@ -303,7 +190,7 @@ void x264_cabac_mb_skip( x264_t *h, int b_skip )
 }
 #endif
 
-static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
+static inline void x264_cabac_subpartition_p( x264_cabac_t *cb, int i_sub )
 {
     if( i_sub == D_L0_8x8 )
     {
@@ -320,7 +207,7 @@ static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
     }
 }
 
-static ALWAYS_INLINE void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
+static ALWAYS_INLINE void x264_cabac_subpartition_b( x264_cabac_t *cb, int i_sub )
 {
     if( i_sub == D_DIRECT_8x8 )
     {
@@ -340,22 +227,22 @@ static ALWAYS_INLINE void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i
     x264_cabac_encode_decision( cb, 39, i_sub == D_L1_8x8 );
 }
 
-static ALWAYS_INLINE void x264_cabac_mb_transform_size( x264_t *h, x264_cabac_t *cb )
+static ALWAYS_INLINE void x264_cabac_transform_size( x264_t *h, x264_cabac_t *cb )
 {
     int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
     x264_cabac_encode_decision_noup( cb, ctx, h->mb.b_transform_8x8 );
 }
 
-static void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
+static ALWAYS_INLINE void x264_cabac_ref_internal( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int bframe )
 {
     const int i8 = x264_scan8[idx];
     const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
     const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
     int ctx = 0;
 
-    if( i_refa > 0 && !h->mb.cache.skip[i8 - 1] )
+    if( i_refa > 0 && (!bframe || !h->mb.cache.skip[i8 - 1]) )
         ctx++;
-    if( i_refb > 0 && !h->mb.cache.skip[i8 - 8] )
+    if( i_refb > 0 && (!bframe || !h->mb.cache.skip[i8 - 8]) )
         ctx += 2;
 
     for( int i_ref = h->mb.cache.ref[i_list][i8]; i_ref > 0; i_ref-- )
@@ -366,70 +253,75 @@ static void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx
     x264_cabac_encode_decision( cb, 54 + ctx, 0 );
 }
 
-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 )
+static NOINLINE void x264_cabac_ref_p( x264_t *h, x264_cabac_t *cb, int idx )
 {
-    const int i_abs = abs( mvd );
-    const int ctxbase = l ? 47 : 40;
-#if RDO_SKIP_BS
-    if( i_abs == 0 )
+    x264_cabac_ref_internal( h, cb, 0, idx, 0 );
+}
+static NOINLINE void x264_cabac_ref_b( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
+{
+    x264_cabac_ref_internal( h, cb, i_list, idx, 1 );
+}
+
+static ALWAYS_INLINE int x264_cabac_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd, int ctx )
+{
+    int ctxbase = l ? 47 : 40;
+
+    if( mvd == 0 )
+    {
         x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
+        return 0;
+    }
+
+    int i_abs = abs( mvd );
+    x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
+#if RDO_SKIP_BS
+    if( i_abs <= 3 )
+    {
+        for( int i = 1; i < i_abs; i++ )
+            x264_cabac_encode_decision( cb, ctxbase + i + 2, 1 );
+        x264_cabac_encode_decision( cb, ctxbase + i_abs + 2, 0 );
+        x264_cabac_encode_bypass( cb, mvd >> 31 );
+    }
     else
     {
-        x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
-        if( i_abs <= 3 )
+        x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
+        x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
+        x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
+        if( i_abs < 9 )
         {
-            for( int i = 1; i < i_abs; i++ )
-                x264_cabac_encode_decision( cb, ctxbase + i + 2, 1 );
-            x264_cabac_encode_decision( cb, ctxbase + i_abs + 2, 0 );
-            x264_cabac_encode_bypass( cb, mvd >> 31 );
+            cb->f8_bits_encoded += cabac_size_unary[i_abs - 3][cb->state[ctxbase+6]];
+            cb->state[ctxbase+6] = cabac_transition_unary[i_abs - 3][cb->state[ctxbase+6]];
         }
         else
         {
-            x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
-            x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
-            x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
-            if( i_abs < 9 )
-            {
-                cb->f8_bits_encoded += cabac_size_unary[i_abs - 3][cb->state[ctxbase+6]];
-                cb->state[ctxbase+6] = cabac_transition_unary[i_abs - 3][cb->state[ctxbase+6]];
-            }
-            else
-            {
-                cb->f8_bits_encoded += cabac_size_5ones[cb->state[ctxbase+6]];
-                cb->state[ctxbase+6] = cabac_transition_5ones[cb->state[ctxbase+6]];
-                x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
-            }
+            cb->f8_bits_encoded += cabac_size_5ones[cb->state[ctxbase+6]];
+            cb->state[ctxbase+6] = cabac_transition_5ones[cb->state[ctxbase+6]];
+            x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
         }
     }
 #else
     static const uint8_t ctxes[8] = { 3,4,5,6,6,6,6,6 };
 
-    if( i_abs == 0 )
-        x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
+    if( i_abs < 9 )
+    {
+        for( int i = 1; i < i_abs; i++ )
+            x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
+        x264_cabac_encode_decision( cb, ctxbase + ctxes[i_abs-1], 0 );
+    }
     else
     {
-        x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
-        if( i_abs < 9 )
-        {
-            for( int i = 1; i < i_abs; i++ )
-                x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
-            x264_cabac_encode_decision( cb, ctxbase + ctxes[i_abs-1], 0 );
-        }
-        else
-        {
-            for( int i = 1; i < 9; i++ )
-                x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
-            x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
-        }
-        x264_cabac_encode_bypass( cb, mvd >> 31 );
+        for( int i = 1; i < 9; i++ )
+            x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
+        x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
     }
+    x264_cabac_encode_bypass( cb, mvd >> 31 );
 #endif
     /* Since we don't need to keep track of MVDs larger than 66, just cap the value.
      * This lets us store MVDs as 8-bit values instead of 16-bit. */
     return X264_MIN( i_abs, 66 );
 }
 
-static NOINLINE uint16_t x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width )
+static NOINLINE uint16_t x264_cabac_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width )
 {
     ALIGNED_4( int16_t mvp[2] );
     int mdx, mdy;
@@ -442,95 +334,308 @@ static NOINLINE uint16_t x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_l
                                        h->mb.cache.mvd[i_list][x264_scan8[idx] - 8]);
 
     /* encode */
-    mdx = x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx, amvd&0xFF );
-    mdy = x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy, amvd>>8 );
+    mdx = x264_cabac_mvd_cpn( h, cb, i_list, idx, 0, mdx, amvd&0xFF );
+    mdy = x264_cabac_mvd_cpn( h, cb, i_list, idx, 1, mdy, amvd>>8 );
 
     return pack8to16(mdx,mdy);
 }
 
-#define x264_cabac_mb_mvd(h,cb,i_list,idx,width,height)\
+#define x264_cabac_mvd(h,cb,i_list,idx,width,height)\
 do\
 {\
-    uint16_t mvd = x264_cabac_mb_mvd(h,cb,i_list,idx,width);\
+    uint16_t mvd = x264_cabac_mvd(h,cb,i_list,idx,width);\
     x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mvd );\
 } while(0)
 
-static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i )
+static inline void x264_cabac_8x8_mvd( x264_t *h, x264_cabac_t *cb, int i )
 {
     switch( h->mb.i_sub_partition[i] )
     {
         case D_L0_8x8:
-            x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
+            x264_cabac_mvd( h, cb, 0, 4*i, 2, 2 );
             break;
         case D_L0_8x4:
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 2, 1 );
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 2, 1 );
+            x264_cabac_mvd( h, cb, 0, 4*i+0, 2, 1 );
+            x264_cabac_mvd( h, cb, 0, 4*i+2, 2, 1 );
             break;
         case D_L0_4x8:
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 2 );
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 2 );
+            x264_cabac_mvd( h, cb, 0, 4*i+0, 1, 2 );
+            x264_cabac_mvd( h, cb, 0, 4*i+1, 1, 2 );
             break;
         case D_L0_4x4:
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 1 );
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 1 );
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 1, 1 );
-            x264_cabac_mb_mvd( h, cb, 0, 4*i+3, 1, 1 );
+            x264_cabac_mvd( h, cb, 0, 4*i+0, 1, 1 );
+            x264_cabac_mvd( h, cb, 0, 4*i+1, 1, 1 );
+            x264_cabac_mvd( h, cb, 0, 4*i+2, 1, 1 );
+            x264_cabac_mvd( h, cb, 0, 4*i+3, 1, 1 );
             break;
         default:
             assert(0);
     }
 }
 
-/* ctx_block_cat: 0-> DC 16x16  i_idx = 0
- *                1-> AC 16x16  i_idx = luma4x4idx
- *                2-> Luma4x4   i_idx = luma4x4idx
- *                3-> DC Chroma i_idx = iCbCr
- *                4-> AC Chroma i_idx = numChroma4x4Blks * iCbCr + chroma4x4idx
- *                5-> Luma8x8   i_idx = luma8x8idx
- */
+static ALWAYS_INLINE void x264_cabac_mb_header_i( x264_t *h, x264_cabac_t *cb, int i_mb_type, int slice_type, int chroma )
+{
+    if( slice_type == SLICE_TYPE_I )
+    {
+        int ctx = 0;
+        if( (h->mb.i_neighbour & MB_LEFT) && h->mb.i_mb_type_left[0] != I_4x4 )
+            ctx++;
+        if( (h->mb.i_neighbour & MB_TOP) && h->mb.i_mb_type_top != I_4x4 )
+            ctx++;
+
+        x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
+    }
+    else if( slice_type == SLICE_TYPE_P )
+    {
+        /* prefix */
+        x264_cabac_encode_decision_noup( cb, 14, 1 );
+
+        /* suffix */
+        x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
+    }
+    else if( slice_type == SLICE_TYPE_B )
+    {
+        /* prefix */
+        x264_cabac_encode_decision_noup( cb, 27+3,   1 );
+        x264_cabac_encode_decision_noup( cb, 27+4,   1 );
+        x264_cabac_encode_decision( cb, 27+5,   1 );
+        x264_cabac_encode_decision( cb, 27+5,   0 );
+        x264_cabac_encode_decision( cb, 27+5,   1 );
+
+        /* suffix */
+        x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
+    }
+
+    if( i_mb_type == I_PCM )
+        return;
+
+    if( i_mb_type != I_16x16 )
+    {
+        if( h->pps->b_transform_8x8_mode )
+            x264_cabac_transform_size( h, cb );
+
+        int di = h->mb.b_transform_8x8 ? 4 : 1;
+        for( int i = 0; i < 16; i += di )
+        {
+            const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
+            const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
+            x264_cabac_intra4x4_pred_mode( cb, i_pred, i_mode );
+        }
+    }
+
+    if( chroma )
+        x264_cabac_intra_chroma_pred_mode( h, cb );
+}
 
-static int ALWAYS_INLINE x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx, int b_intra )
+static ALWAYS_INLINE void x264_cabac_mb_header_p( x264_t *h, x264_cabac_t *cb, int i_mb_type, int chroma )
 {
-    static const uint16_t base_ctx[14] = {85,89,93,97,101,1012,460,464,468,1016,472,476,480,1020};
-    int i_nza;
-    int i_nzb;
+    if( i_mb_type == P_L0 )
+    {
+        x264_cabac_encode_decision_noup( cb, 14, 0 );
+        if( h->mb.i_partition == D_16x16 )
+        {
+            x264_cabac_encode_decision_noup( cb, 15, 0 );
+            x264_cabac_encode_decision_noup( cb, 16, 0 );
+            if( h->mb.pic.i_fref[0] > 1 )
+                x264_cabac_ref_p( h, cb, 0 );
+            x264_cabac_mvd( h, cb, 0, 0, 4, 4 );
+        }
+        else if( h->mb.i_partition == D_16x8 )
+        {
+            x264_cabac_encode_decision_noup( cb, 15, 1 );
+            x264_cabac_encode_decision_noup( cb, 17, 1 );
+            if( h->mb.pic.i_fref[0] > 1 )
+            {
+                x264_cabac_ref_p( h, cb, 0 );
+                x264_cabac_ref_p( h, cb, 8 );
+            }
+            x264_cabac_mvd( h, cb, 0, 0, 4, 2 );
+            x264_cabac_mvd( h, cb, 0, 8, 4, 2 );
+        }
+        else //if( h->mb.i_partition == D_8x16 )
+        {
+            x264_cabac_encode_decision_noup( cb, 15, 1 );
+            x264_cabac_encode_decision_noup( cb, 17, 0 );
+            if( h->mb.pic.i_fref[0] > 1 )
+            {
+                x264_cabac_ref_p( h, cb, 0 );
+                x264_cabac_ref_p( h, cb, 4 );
+            }
+            x264_cabac_mvd( h, cb, 0, 0, 2, 4 );
+            x264_cabac_mvd( h, cb, 0, 4, 2, 4 );
+        }
+    }
+    else if( i_mb_type == P_8x8 )
+    {
+        x264_cabac_encode_decision_noup( cb, 14, 0 );
+        x264_cabac_encode_decision_noup( cb, 15, 0 );
+        x264_cabac_encode_decision_noup( cb, 16, 1 );
+
+        /* sub mb type */
+        for( int i = 0; i < 4; i++ )
+            x264_cabac_subpartition_p( cb, h->mb.i_sub_partition[i] );
+
+        /* ref 0 */
+        if( h->mb.pic.i_fref[0] > 1 )
+        {
+            x264_cabac_ref_p( h, cb,  0 );
+            x264_cabac_ref_p( h, cb,  4 );
+            x264_cabac_ref_p( h, cb,  8 );
+            x264_cabac_ref_p( h, cb, 12 );
+        }
+
+        for( int i = 0; i < 4; i++ )
+            x264_cabac_8x8_mvd( h, cb, i );
+    }
+    else /* intra */
+        x264_cabac_mb_header_i( h, cb, i_mb_type, SLICE_TYPE_P, chroma );
+}
+
+static ALWAYS_INLINE void x264_cabac_mb_header_b( x264_t *h, x264_cabac_t *cb, int i_mb_type, int chroma )
+{
+    int ctx = 0;
+    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 )
+        ctx++;
+    if( (h->mb.i_neighbour & MB_TOP) && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
+        ctx++;
 
-    switch( i_cat )
+    if( i_mb_type == B_DIRECT )
     {
-        case DCT_LUMA_8x8:
-        case DCT_CHROMAU_8x8:
-        case DCT_CHROMAV_8x8:
-        case DCT_LUMA_AC:
-        case DCT_LUMA_4x4:
-        case DCT_CHROMA_AC:
-        case DCT_CHROMAU_AC:
-        case DCT_CHROMAU_4x4:
-        case DCT_CHROMAV_AC:
-        case DCT_CHROMAV_4x4:
-            i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
-            i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
-            if( x264_constant_p(b_intra) && !b_intra )
-                return base_ctx[i_cat] + ((2*i_nzb + i_nza)&0x7f);
-            else
+        x264_cabac_encode_decision_noup( cb, 27+ctx, 0 );
+        return;
+    }
+    x264_cabac_encode_decision_noup( cb, 27+ctx, 1 );
+
+    if( i_mb_type == B_8x8 )
+    {
+        x264_cabac_encode_decision_noup( cb, 27+3,   1 );
+        x264_cabac_encode_decision_noup( cb, 27+4,   1 );
+        x264_cabac_encode_decision( cb, 27+5,   1 );
+        x264_cabac_encode_decision( cb, 27+5,   1 );
+        x264_cabac_encode_decision_noup( cb, 27+5,   1 );
+
+        /* sub mb type */
+        for( int i = 0; i < 4; i++ )
+            x264_cabac_subpartition_b( cb, h->mb.i_sub_partition[i] );
+
+        /* ref */
+        if( h->mb.pic.i_fref[0] > 1 )
+            for( int i = 0; i < 4; i++ )
+                if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
+                    x264_cabac_ref_b( h, cb, 0, 4*i );
+
+        if( h->mb.pic.i_fref[1] > 1 )
+            for( int i = 0; i < 4; i++ )
+                if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
+                    x264_cabac_ref_b( h, cb, 1, 4*i );
+
+        for( int i = 0; i < 4; i++ )
+            if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
+                x264_cabac_mvd( h, cb, 0, 4*i, 2, 2 );
+
+        for( int i = 0; i < 4; i++ )
+            if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
+                x264_cabac_mvd( h, cb, 1, 4*i, 2, 2 );
+    }
+    else if( i_mb_type >= B_L0_L0 && i_mb_type <= B_BI_BI )
+    {
+        /* All B modes */
+        static const uint8_t i_mb_bits[9*3] =
+        {
+            0x31, 0x29, 0x4, /* L0 L0 */
+            0x35, 0x2d, 0,   /* L0 L1 */
+            0x43, 0x63, 0,   /* L0 BI */
+            0x3d, 0x2f, 0,   /* L1 L0 */
+            0x39, 0x25, 0x6, /* L1 L1 */
+            0x53, 0x73, 0,   /* L1 BI */
+            0x4b, 0x6b, 0,   /* BI L0 */
+            0x5b, 0x7b, 0,   /* BI L1 */
+            0x47, 0x67, 0x21 /* BI BI */
+        };
+
+        const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
+        int bits = i_mb_bits[idx];
+
+        x264_cabac_encode_decision_noup( cb, 27+3, bits&1 );
+        x264_cabac_encode_decision( cb, 27+5-(bits&1), (bits>>1)&1 ); bits >>= 2;
+        if( bits != 1 )
+        {
+            x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
+            x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
+            x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
+            if( bits != 1 )
+                x264_cabac_encode_decision_noup( cb, 27+5, bits&1 );
+        }
+
+        const uint8_t (*b_list)[2] = x264_mb_type_list_table[i_mb_type];
+        if( h->mb.pic.i_fref[0] > 1 )
+        {
+            if( b_list[0][0] )
+                x264_cabac_ref_b( h, cb, 0, 0 );
+            if( b_list[0][1] && h->mb.i_partition != D_16x16 )
+                x264_cabac_ref_b( h, cb, 0, 8 >> (h->mb.i_partition == D_8x16) );
+        }
+        if( h->mb.pic.i_fref[1] > 1 )
+        {
+            if( b_list[1][0] )
+                x264_cabac_ref_b( h, cb, 1, 0 );
+            if( b_list[1][1] && h->mb.i_partition != D_16x16 )
+                x264_cabac_ref_b( h, cb, 1, 8 >> (h->mb.i_partition == D_8x16) );
+        }
+        for( int i_list = 0; i_list < 2; i_list++ )
+        {
+            if( h->mb.i_partition == D_16x16 )
+            {
+                if( b_list[i_list][0] ) x264_cabac_mvd( h, cb, i_list, 0, 4, 4 );
+            }
+            else if( h->mb.i_partition == D_16x8 )
             {
-                i_nza &= 0x7f + (b_intra << 7);
-                i_nzb &= 0x7f + (b_intra << 7);
-                return base_ctx[i_cat] + 2*!!i_nzb + !!i_nza;
+                if( b_list[i_list][0] ) x264_cabac_mvd( h, cb, i_list, 0, 4, 2 );
+                if( b_list[i_list][1] ) x264_cabac_mvd( h, cb, i_list, 8, 4, 2 );
             }
-        case DCT_LUMA_DC:
-        case DCT_CHROMAU_DC:
-        case DCT_CHROMAV_DC:
-            i_idx -= LUMA_DC;
-            i_nza = (h->mb.cache.i_cbp_left >> (8 + i_idx)) & 1;
-            i_nzb = (h->mb.cache.i_cbp_top  >> (8 + i_idx)) & 1;
+            else //if( h->mb.i_partition == D_8x16 )
+            {
+                if( b_list[i_list][0] ) x264_cabac_mvd( h, cb, i_list, 0, 2, 4 );
+                if( b_list[i_list][1] ) x264_cabac_mvd( h, cb, i_list, 4, 2, 4 );
+            }
+        }
+    }
+    else /* intra */
+        x264_cabac_mb_header_i( h, cb, i_mb_type, SLICE_TYPE_B, chroma );
+}
+
+static int ALWAYS_INLINE x264_cabac_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx, int b_intra, int b_dc )
+{
+    static const uint16_t base_ctx[14] = {85,89,93,97,101,1012,460,464,468,1016,472,476,480,1020};
+
+    if( b_dc )
+    {
+        i_idx -= LUMA_DC;
+        if( i_cat == DCT_CHROMA_DC )
+        {
+            int i_nza = h->mb.cache.i_cbp_left != -1 ? (h->mb.cache.i_cbp_left >> (8 + i_idx)) & 1 : b_intra;
+            int i_nzb = h->mb.cache.i_cbp_top  != -1 ? (h->mb.cache.i_cbp_top  >> (8 + i_idx)) & 1 : b_intra;
             return base_ctx[i_cat] + 2*i_nzb + i_nza;
-        case DCT_CHROMA_DC:
-            i_idx -= LUMA_DC;
-            i_nza = h->mb.cache.i_cbp_left != -1 ? (h->mb.cache.i_cbp_left >> (8 + i_idx)) & 1 : b_intra;
-            i_nzb = h->mb.cache.i_cbp_top  != -1 ? (h->mb.cache.i_cbp_top  >> (8 + i_idx)) & 1 : b_intra;
+        }
+        else
+        {
+            int i_nza = (h->mb.cache.i_cbp_left >> (8 + i_idx)) & 1;
+            int i_nzb = (h->mb.cache.i_cbp_top  >> (8 + i_idx)) & 1;
             return base_ctx[i_cat] + 2*i_nzb + i_nza;
-        default:
-            return 0;
+        }
+    }
+    else
+    {
+        int i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
+        int i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
+        if( x264_constant_p(b_intra) && !b_intra )
+            return base_ctx[i_cat] + ((2*i_nzb + i_nza)&0x7f);
+        else
+        {
+            i_nza &= 0x7f + (b_intra << 7);
+            i_nzb &= 0x7f + (b_intra << 7);
+            return base_ctx[i_cat] + 2*!!i_nzb + !!i_nza;
+        }
     }
 }
 
@@ -587,7 +692,7 @@ static const uint8_t coeff_abs_level_transition[2][8] = {
 static const uint8_t count_cat_m1[14] = {15, 14, 15, 3, 14, 63, 15, 14, 15, 63, 15, 14, 15, 63};
 
 #if !RDO_SKIP_BS
-static ALWAYS_INLINE void block_residual_write_cabac_internal( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l, int chroma422dc )
+static ALWAYS_INLINE void x264_cabac_block_residual_internal( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l, int chroma422dc )
 {
     int ctx_sig = significant_coeff_flag_offset[MB_INTERLACED][ctx_block_cat];
     int ctx_last = last_coeff_flag_offset[MB_INTERLACED][ctx_block_cat];
@@ -671,23 +776,23 @@ static ALWAYS_INLINE void block_residual_write_cabac_internal( x264_t *h, x264_c
         x264_cabac_encode_bypass( cb, coeff_sign );
     } while( --coeff_idx >= 0 );
 }
-static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
+static void x264_cabac_block_residual( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
 {
-    block_residual_write_cabac_internal( h, cb, ctx_block_cat, l, 0 );
+    x264_cabac_block_residual_internal( h, cb, ctx_block_cat, l, 0 );
 }
-static void block_residual_write_cabac_422_dc( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
+static void x264_cabac_block_residual_422_dc( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
 {
     /* Template a version specifically for chroma 4:2:2 DC in order to avoid
      * slowing down everything else due to the added complexity. */
-    block_residual_write_cabac_internal( h, cb, DCT_CHROMA_DC, l, 1 );
+    x264_cabac_block_residual_internal( h, cb, DCT_CHROMA_DC, l, 1 );
 }
-#define block_residual_write_cabac_8x8( h, cb, cat, l ) block_residual_write_cabac( h, cb, cat, l )
+#define x264_cabac_block_residual_8x8( h, cb, cat, l ) x264_cabac_block_residual( h, cb, cat, l )
 #else
 
 /* Faster RDO by merging sigmap and level coding. Note that for 8x8dct and chroma 4:2:2 dc this is
  * slightly incorrect because the sigmap is not reversible (contexts are repeated). However, there
  * is nearly no quality penalty for this (~0.001db) and the speed boost (~30%) is worth it. */
-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 )
+static void ALWAYS_INLINE x264_cabac_block_residual_internal( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l, int b_8x8, int chroma422dc )
 {
     const uint8_t *sig_offset = significant_coeff_flag_offset_8x8[MB_INTERLACED];
     int ctx_sig = significant_coeff_flag_offset[MB_INTERLACED][ctx_block_cat];
@@ -772,64 +877,73 @@ static void ALWAYS_INLINE block_residual_write_cabac_internal( x264_t *h, x264_c
     }
 }
 
-static void block_residual_write_cabac_8x8( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
+static void x264_cabac_block_residual_8x8( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
 {
-    block_residual_write_cabac_internal( h, cb, ctx_block_cat, l, 1, 0 );
+    x264_cabac_block_residual_internal( h, cb, ctx_block_cat, l, 1, 0 );
 }
-static void block_residual_write_cabac_422_dc( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
+static void x264_cabac_block_residual_422_dc( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
 {
-    block_residual_write_cabac_internal( h, cb, DCT_CHROMA_DC, l, 0, 1 );
+    x264_cabac_block_residual_internal( h, cb, DCT_CHROMA_DC, l, 0, 1 );
 }
-static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
+static void x264_cabac_block_residual( x264_t *h, x264_cabac_t *cb, int ctx_block_cat, dctcoef *l )
 {
-    block_residual_write_cabac_internal( h, cb, ctx_block_cat, l, 0, 0 );
+    x264_cabac_block_residual_internal( h, cb, ctx_block_cat, l, 0, 0 );
 }
 #endif
 
-#define block_residual_write_cabac_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, name )\
+#define x264_cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, b_dc, name )\
 do\
 {\
-    int ctxidxinc = x264_cabac_mb_cbf_ctxidxinc( h, ctx_block_cat, i_idx, b_intra );\
+    int ctxidxinc = x264_cabac_cbf_ctxidxinc( h, ctx_block_cat, i_idx, b_intra, b_dc );\
     if( h->mb.cache.non_zero_count[x264_scan8[i_idx]] )\
     {\
         x264_cabac_encode_decision( cb, ctxidxinc, 1 );\
-        block_residual_write_cabac##name( h, cb, ctx_block_cat, l );\
+        x264_cabac_block_residual##name( h, cb, ctx_block_cat, l );\
     }\
     else\
         x264_cabac_encode_decision( cb, ctxidxinc, 0 );\
 } while(0)
 
-#define block_residual_write_cabac_dc_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
-    block_residual_write_cabac_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, )
+#define x264_cabac_block_residual_dc_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
+    x264_cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, 1, )
 
-#define block_residual_write_cabac_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
-    block_residual_write_cabac_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, )
+#define x264_cabac_block_residual_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
+    x264_cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, 0, )
 
-#define block_residual_write_cabac_8x8_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
-    block_residual_write_cabac_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, _8x8 )
+#define x264_cabac_block_residual_8x8_cbf( h, cb, ctx_block_cat, i_idx, l, b_intra )\
+    x264_cabac_block_residual_cbf_internal( h, cb, ctx_block_cat, i_idx, l, b_intra, 0, _8x8 )
 
-#define block_residual_write_cabac_422_dc_cbf( h, cb, ch, b_intra )\
-    block_residual_write_cabac_cbf_internal( h, cb, DCT_CHROMA_DC, CHROMA_DC+(ch), h->dct.chroma_dc[ch], b_intra, _422_dc )
+#define x264_cabac_block_residual_422_dc_cbf( h, cb, ch, b_intra )\
+    x264_cabac_block_residual_cbf_internal( h, cb, DCT_CHROMA_DC, CHROMA_DC+(ch), h->dct.chroma_dc[ch], b_intra, 1, _422_dc )
 
 static ALWAYS_INLINE void x264_macroblock_write_cabac_internal( x264_t *h, x264_cabac_t *cb, int plane_count, int chroma )
 {
     const int i_mb_type = h->mb.i_type;
-    int i_list;
 
 #if !RDO_SKIP_BS
     const int i_mb_pos_start = x264_cabac_pos( cb );
     int       i_mb_pos_tex;
+
+    if( SLICE_MBAFF &&
+        (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
+    {
+        x264_cabac_field_decoding_flag( h, cb );
+    }
 #endif
 
-    /* Write the MB type */
-    x264_cabac_mb_type( h, cb );
+    if( h->sh.i_type == SLICE_TYPE_P )
+        x264_cabac_mb_header_p( h, cb, i_mb_type, chroma );
+    else if( h->sh.i_type == SLICE_TYPE_B )
+        x264_cabac_mb_header_b( h, cb, i_mb_type, chroma );
+    else //if( h->sh.i_type == SLICE_TYPE_I )
+        x264_cabac_mb_header_i( h, cb, i_mb_type, SLICE_TYPE_I, chroma );
 
 #if !RDO_SKIP_BS
+    i_mb_pos_tex = x264_cabac_pos( cb );
+    h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
+
     if( i_mb_type == I_PCM )
     {
-        i_mb_pos_tex = x264_cabac_pos( cb );
-        h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
-
         bs_t s;
         bs_init( &s, cb->p, cb->p_end - cb->p );
 
@@ -851,157 +965,22 @@ static ALWAYS_INLINE void x264_macroblock_write_cabac_internal( x264_t *h, x264_
     }
 #endif
 
-    if( IS_INTRA( i_mb_type ) )
-    {
-        if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
-            x264_cabac_mb_transform_size( h, cb );
-
-        if( i_mb_type != I_16x16 )
-        {
-            int di = h->mb.b_transform_8x8 ? 4 : 1;
-            for( int i = 0; i < 16; i += di )
-            {
-                const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
-                const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
-                x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
-            }
-        }
-
-        if( chroma )
-            x264_cabac_mb_intra_chroma_pred_mode( h, cb );
-    }
-    else if( i_mb_type == P_L0 )
-    {
-        if( h->mb.i_partition == D_16x16 )
-        {
-            if( h->mb.pic.i_fref[0] > 1 )
-            {
-                x264_cabac_mb_ref( h, cb, 0, 0 );
-            }
-            x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
-        }
-        else if( h->mb.i_partition == D_16x8 )
-        {
-            if( h->mb.pic.i_fref[0] > 1 )
-            {
-                x264_cabac_mb_ref( h, cb, 0, 0 );
-                x264_cabac_mb_ref( h, cb, 0, 8 );
-            }
-            x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
-            x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
-        }
-        else //if( h->mb.i_partition == D_8x16 )
-        {
-            if( h->mb.pic.i_fref[0] > 1 )
-            {
-                x264_cabac_mb_ref( h, cb, 0, 0 );
-                x264_cabac_mb_ref( h, cb, 0, 4 );
-            }
-            x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
-            x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
-        }
-    }
-    else if( i_mb_type == P_8x8 )
-    {
-        /* sub mb type */
-        for( int i = 0; i < 4; i++ )
-            x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i] );
-
-        /* ref 0 */
-        if( h->mb.pic.i_fref[0] > 1 )
-        {
-            x264_cabac_mb_ref( h, cb, 0, 0 );
-            x264_cabac_mb_ref( h, cb, 0, 4 );
-            x264_cabac_mb_ref( h, cb, 0, 8 );
-            x264_cabac_mb_ref( h, cb, 0, 12 );
-        }
-
-        for( int i = 0; i < 4; i++ )
-            x264_cabac_mb8x8_mvd( h, cb, i );
-    }
-    else if( i_mb_type == B_8x8 )
-    {
-        /* sub mb type */
-        for( int i = 0; i < 4; i++ )
-            x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i] );
-
-        /* ref */
-        if( h->mb.pic.i_fref[0] > 1 )
-            for( int i = 0; i < 4; i++ )
-                if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
-                    x264_cabac_mb_ref( h, cb, 0, 4*i );
-
-        if( h->mb.pic.i_fref[1] > 1 )
-            for( int i = 0; i < 4; i++ )
-                if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
-                    x264_cabac_mb_ref( h, cb, 1, 4*i );
-
-        for( int i = 0; i < 4; i++ )
-            if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
-                x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
-
-        for( int i = 0; i < 4; i++ )
-            if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
-                x264_cabac_mb_mvd( h, cb, 1, 4*i, 2, 2 );
-    }
-    else if( i_mb_type != B_DIRECT )
-    {
-        /* All B mode */
-        const uint8_t (*b_list)[2] = x264_mb_type_list_table[i_mb_type];
-        if( h->mb.pic.i_fref[0] > 1 )
-        {
-            if( b_list[0][0] )
-                x264_cabac_mb_ref( h, cb, 0, 0 );
-            if( b_list[0][1] && h->mb.i_partition != D_16x16 )
-                x264_cabac_mb_ref( h, cb, 0, 8 >> (h->mb.i_partition == D_8x16) );
-        }
-        if( h->mb.pic.i_fref[1] > 1 )
-        {
-            if( b_list[1][0] )
-                x264_cabac_mb_ref( h, cb, 1, 0 );
-            if( b_list[1][1] && h->mb.i_partition != D_16x16 )
-                x264_cabac_mb_ref( h, cb, 1, 8 >> (h->mb.i_partition == D_8x16) );
-        }
-        for( i_list = 0; i_list < 2; i_list++ )
-        {
-            if( h->mb.i_partition == D_16x16 )
-            {
-                if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
-            }
-            else if( h->mb.i_partition == D_16x8 )
-            {
-                if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
-                if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
-            }
-            else //if( h->mb.i_partition == D_8x16 )
-            {
-                if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
-                if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
-            }
-        }
-    }
-
-#if !RDO_SKIP_BS
-    i_mb_pos_tex = x264_cabac_pos( cb );
-    h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
-#endif
-
     if( i_mb_type != I_16x16 )
     {
-        x264_cabac_mb_cbp_luma( h, cb );
+        x264_cabac_cbp_luma( h, cb );
         if( chroma )
-            x264_cabac_mb_cbp_chroma( h, cb );
+            x264_cabac_cbp_chroma( h, cb );
     }
 
     if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
     {
-        x264_cabac_mb_transform_size( h, cb );
+        x264_cabac_transform_size( h, cb );
     }
 
     if( h->mb.i_cbp_luma || (chroma && h->mb.i_cbp_chroma) || i_mb_type == I_16x16 )
     {
         const int b_intra = IS_INTRA( i_mb_type );
-        x264_cabac_mb_qp_delta( h, cb );
+        x264_cabac_qp_delta( h, cb );
 
         /* write residual */
         if( i_mb_type == I_16x16 )
@@ -1009,12 +988,12 @@ static ALWAYS_INLINE void x264_macroblock_write_cabac_internal( x264_t *h, x264_
             /* DC Luma */
             for( int p = 0; p < plane_count; p++ )
             {
-                block_residual_write_cabac_dc_cbf( h, cb, ctx_cat_plane[DCT_LUMA_DC][p], LUMA_DC+p, h->dct.luma16x16_dc[p], 1 );
+                x264_cabac_block_residual_dc_cbf( h, cb, ctx_cat_plane[DCT_LUMA_DC][p], LUMA_DC+p, h->dct.luma16x16_dc[p], 1 );
 
                 /* AC Luma */
                 if( h->mb.i_cbp_luma )
                     for( int i = p*16; i < p*16+16; i++ )
-                        block_residual_write_cabac_cbf( h, cb, ctx_cat_plane[DCT_LUMA_AC][p], i, h->dct.luma4x4[i]+1, 1 );
+                        x264_cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_AC][p], i, h->dct.luma4x4[i]+1, 1 );
             }
         }
         else if( h->mb.b_transform_8x8 )
@@ -1063,7 +1042,7 @@ if( (h->mb.i_neighbour & MB_TOP) && !h->mb.mb_transform_size[h->mb.i_mb_top_xy]
                 for( int p = 0; p < 3; p++ )
                     for( int i = 0; i < 4; i++ )
                         if( h->mb.i_cbp_luma & ( 1 << i ) )
-                            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 );
+                            x264_cabac_block_residual_8x8_cbf( h, cb, ctx_cat_plane[DCT_LUMA_8x8][p], i*4+p*16, h->dct.luma8x8[i+p*4], b_intra );
 
                 MUNGE_8x8_NNZ( RESTORE )
             }
@@ -1071,7 +1050,7 @@ if( (h->mb.i_neighbour & MB_TOP) && !h->mb.mb_transform_size[h->mb.i_mb_top_xy]
             {
                 for( int i = 0; i < 4; i++ )
                     if( h->mb.i_cbp_luma & ( 1 << i ) )
-                        block_residual_write_cabac_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i] );
+                        x264_cabac_block_residual_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i] );
             }
         }
         else
@@ -1079,20 +1058,20 @@ if( (h->mb.i_neighbour & MB_TOP) && !h->mb.mb_transform_size[h->mb.i_mb_top_xy]
             for( int p = 0; p < plane_count; p++ )
                 for( int i = 0; i < 16; i++ )
                     if( h->mb.i_cbp_luma & ( 1 << ( i >> 2 ) ) )
-                        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 );
+                        x264_cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], i+p*16, h->dct.luma4x4[i+p*16], b_intra );
         }
 
         if( chroma && h->mb.i_cbp_chroma ) /* Chroma DC residual present */
         {
             if( CHROMA_FORMAT == CHROMA_422 )
             {
-                block_residual_write_cabac_422_dc_cbf( h, cb, 0, b_intra );
-                block_residual_write_cabac_422_dc_cbf( h, cb, 1, b_intra );
+                x264_cabac_block_residual_422_dc_cbf( h, cb, 0, b_intra );
+                x264_cabac_block_residual_422_dc_cbf( h, cb, 1, b_intra );
             }
             else
             {
-                block_residual_write_cabac_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+0, h->dct.chroma_dc[0], b_intra );
-                block_residual_write_cabac_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+1, h->dct.chroma_dc[1], b_intra );
+                x264_cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+0, h->dct.chroma_dc[0], b_intra );
+                x264_cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+1, h->dct.chroma_dc[1], b_intra );
             }
 
             if( h->mb.i_cbp_chroma == 2 ) /* Chroma AC residual present */
@@ -1100,7 +1079,7 @@ if( (h->mb.i_neighbour & MB_TOP) && !h->mb.mb_transform_size[h->mb.i_mb_top_xy]
                 int step = 8 << h->mb.chroma_v_shift;
                 for( int i = 16; i < 3*16; i += step )
                     for( int j = i; j < i+4; j++ )
-                        block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, j, h->dct.luma4x4[j]+1, b_intra );
+                        x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, j, h->dct.luma4x4[j]+1, b_intra );
             }
         }
     }
@@ -1134,22 +1113,22 @@ static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int
 
     if( i_mb_type == P_8x8 )
     {
-        x264_cabac_mb8x8_mvd( h, cb, i8 );
-        x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
+        x264_cabac_8x8_mvd( h, cb, i8 );
+        x264_cabac_subpartition_p( cb, h->mb.i_sub_partition[i8] );
     }
     else if( i_mb_type == P_L0 )
-        x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
+        x264_cabac_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
     else if( i_mb_type > B_DIRECT && i_mb_type < B_8x8 )
     {
-        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 );
-        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 );
+        if( x264_mb_type_list_table[ i_mb_type ][0][!!i8] ) x264_cabac_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
+        if( x264_mb_type_list_table[ i_mb_type ][1][!!i8] ) x264_cabac_mvd( h, cb, 1, 4*i8, 4>>b_8x16, 2<<b_8x16 );
     }
     else //if( i_mb_type == B_8x8 )
     {
         if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
-            x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 2 );
+            x264_cabac_mvd( h, cb, 0, 4*i8, 2, 2 );
         if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
-            x264_cabac_mb_mvd( h, cb, 1, 4*i8, 2, 2 );
+            x264_cabac_mvd( h, cb, 1, 4*i8, 2, 2 );
     }
 
     for( int j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
@@ -1160,14 +1139,14 @@ static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int
             {
                 if( CHROMA444 )
                     for( int p = 0; p < 3; p++ )
-                        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 );
+                        x264_cabac_block_residual_8x8_cbf( h, cb, ctx_cat_plane[DCT_LUMA_8x8][p], i8*4+p*16, h->dct.luma8x8[i8+p*4], 0 );
                 else
-                    block_residual_write_cabac_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i8] );
+                    x264_cabac_block_residual_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i8] );
             }
             else
                 for( int p = 0; p < plane_count; p++ )
                     for( int i4 = 0; i4 < 4; i4++ )
-                        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 );
+                        x264_cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], i4+i8*4+p*16, h->dct.luma4x4[i4+i8*4+p*16], 0 );
         }
 
         if( h->mb.i_cbp_chroma )
@@ -1175,15 +1154,15 @@ static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int
             if( CHROMA_FORMAT == CHROMA_422 )
             {
                 int offset = (5*i8) & 0x09;
-                block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 16+offset, h->dct.luma4x4[16+offset]+1, 0 );
-                block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 18+offset, h->dct.luma4x4[18+offset]+1, 0 );
-                block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 32+offset, h->dct.luma4x4[32+offset]+1, 0 );
-                block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 34+offset, h->dct.luma4x4[34+offset]+1, 0 );
+                x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 16+offset, h->dct.luma4x4[16+offset]+1, 0 );
+                x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 18+offset, h->dct.luma4x4[18+offset]+1, 0 );
+                x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 32+offset, h->dct.luma4x4[32+offset]+1, 0 );
+                x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 34+offset, h->dct.luma4x4[34+offset]+1, 0 );
             }
             else
             {
-                block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 0 );
-                block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 32+i8, h->dct.luma4x4[32+i8]+1, 0 );
+                x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 0 );
+                x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, 32+i8, h->dct.luma4x4[32+i8]+1, 0 );
             }
         }
 
@@ -1196,14 +1175,14 @@ static void x264_subpartition_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, i
     int b_8x4 = i_pixel == PIXEL_8x4;
     int plane_count = CHROMA444 ? 3 : 1;
     if( i_pixel == PIXEL_4x4 )
-        x264_cabac_mb_mvd( h, cb, 0, i4, 1, 1 );
+        x264_cabac_mvd( h, cb, 0, i4, 1, 1 );
     else
-        x264_cabac_mb_mvd( h, cb, 0, i4, 1+b_8x4, 2-b_8x4 );
+        x264_cabac_mvd( h, cb, 0, i4, 1+b_8x4, 2-b_8x4 );
     for( int p = 0; p < plane_count; p++ )
     {
-        block_residual_write_cabac_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], p*16+i4, h->dct.luma4x4[p*16+i4], 0 );
+        x264_cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], p*16+i4, h->dct.luma4x4[p*16+i4], 0 );
         if( i_pixel != PIXEL_4x4 )
-            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 );
+            x264_cabac_block_residual_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 );
     }
 }
 
@@ -1211,15 +1190,15 @@ static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8,
 {
     const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
-    x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
-    x264_cabac_mb_cbp_luma( h, cb );
+    x264_cabac_intra4x4_pred_mode( cb, i_pred, i_mode );
+    x264_cabac_cbp_luma( h, cb );
     if( h->mb.i_cbp_luma & (1 << i8) )
     {
         if( CHROMA444 )
             for( int p = 0; p < 3; p++ )
-                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 );
+                x264_cabac_block_residual_8x8_cbf( h, cb, ctx_cat_plane[DCT_LUMA_8x8][p], i8*4+p*16, h->dct.luma8x8[i8+p*4], 1 );
         else
-            block_residual_write_cabac_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i8] );
+            x264_cabac_block_residual_8x8( h, cb, DCT_LUMA_8x8, h->dct.luma8x8[i8] );
     }
 }
 
@@ -1228,26 +1207,26 @@ static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4,
     const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
     int plane_count = CHROMA444 ? 3 : 1;
     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
-    x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
+    x264_cabac_intra4x4_pred_mode( cb, i_pred, i_mode );
     for( int p = 0; p < plane_count; p++ )
-        block_residual_write_cabac_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], i4+p*16, h->dct.luma4x4[i4+p*16], 1 );
+        x264_cabac_block_residual_cbf( h, cb, ctx_cat_plane[DCT_LUMA_4x4][p], i4+p*16, h->dct.luma4x4[i4+p*16], 1 );
 }
 
 static void x264_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
 {
-    x264_cabac_mb_intra_chroma_pred_mode( h, cb );
-    x264_cabac_mb_cbp_chroma( h, cb );
+    x264_cabac_intra_chroma_pred_mode( h, cb );
+    x264_cabac_cbp_chroma( h, cb );
     if( h->mb.i_cbp_chroma )
     {
         if( CHROMA_FORMAT == CHROMA_422 )
         {
-            block_residual_write_cabac_422_dc_cbf( h, cb, 0, 1 );
-            block_residual_write_cabac_422_dc_cbf( h, cb, 1, 1 );
+            x264_cabac_block_residual_422_dc_cbf( h, cb, 0, 1 );
+            x264_cabac_block_residual_422_dc_cbf( h, cb, 1, 1 );
         }
         else
         {
-            block_residual_write_cabac_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+0, h->dct.chroma_dc[0], 1 );
-            block_residual_write_cabac_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+1, h->dct.chroma_dc[1], 1 );
+            x264_cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+0, h->dct.chroma_dc[0], 1 );
+            x264_cabac_block_residual_dc_cbf( h, cb, DCT_CHROMA_DC, CHROMA_DC+1, h->dct.chroma_dc[1], 1 );
         }
 
         if( h->mb.i_cbp_chroma == 2 )
@@ -1255,7 +1234,7 @@ static void x264_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
             int step = 8 << h->mb.chroma_v_shift;
             for( int i = 16; i < 3*16; i += step )
                 for( int j = i; j < i+4; j++ )
-                    block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, j, h->dct.luma4x4[j]+1, 1 );
+                    x264_cabac_block_residual_cbf( h, cb, DCT_CHROMA_AC, j, h->dct.luma4x4[j]+1, 1 );
         }
     }
 }