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