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