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