RD subpel motion estimation (--subme 7)
[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, int i )
560 {
561     if( !x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
562         return;
563
564     switch( h->mb.i_sub_partition[i] )
565     {
566         case D_L0_8x8:
567         case D_L1_8x8:
568         case D_BI_8x8:
569             x264_cabac_mb_mvd( h, cb, i_list, 4*i, 2, 2 );
570             break;
571         case D_L0_8x4:
572         case D_L1_8x4:
573         case D_BI_8x4:
574             x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 2, 1 );
575             x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 2, 1 );
576             break;
577         case D_L0_4x8:
578         case D_L1_4x8:
579         case D_BI_4x8:
580             x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 2 );
581             x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 2 );
582             break;
583         case D_L0_4x4:
584         case D_L1_4x4:
585         case D_BI_4x4:
586             x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 1 );
587             x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 1 );
588             x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 1, 1 );
589             x264_cabac_mb_mvd( h, cb, i_list, 4*i+3, 1, 1 );
590             break;
591     }
592 }
593
594 static int x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx )
595 {
596     int i_mba_xy = -1;
597     int i_mbb_xy = -1;
598     int i_nza = 0;
599     int i_nzb = 0;
600     int ctx;
601
602     if( i_cat == DCT_LUMA_DC )
603     {
604         if( h->mb.i_neighbour & MB_LEFT )
605         {
606             i_mba_xy = h->mb.i_mb_xy - 1;
607             if( h->mb.type[i_mba_xy] == I_16x16 )
608                 i_nza = h->mb.cbp[i_mba_xy] & 0x100;
609         }
610         if( h->mb.i_neighbour & MB_TOP )
611         {
612             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
613             if( h->mb.type[i_mbb_xy] == I_16x16 )
614                 i_nzb = h->mb.cbp[i_mbb_xy] & 0x100;
615         }
616     }
617     else if( i_cat == DCT_LUMA_AC || i_cat == DCT_LUMA_4x4 )
618     {
619         if( i_idx & ~10 ) // block_idx_x > 0
620             i_mba_xy = h->mb.i_mb_xy;
621         else if( h->mb.i_neighbour & MB_LEFT )
622             i_mba_xy = h->mb.i_mb_xy - 1;
623
624         if( i_idx & ~5 ) // block_idx_y > 0
625             i_mbb_xy = h->mb.i_mb_xy;
626         else if( h->mb.i_neighbour & MB_TOP )
627             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
628
629         /* no need to test for skip/pcm */
630         if( i_mba_xy >= 0 )
631             i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
632         if( i_mbb_xy >= 0 )
633             i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
634     }
635     else if( i_cat == DCT_CHROMA_DC )
636     {
637         /* no need to test skip/pcm */
638         if( h->mb.i_neighbour & MB_LEFT )
639         {
640             i_mba_xy = h->mb.i_mb_xy - 1;
641             i_nza = h->mb.cbp[i_mba_xy] & (0x200 << i_idx);
642         }
643         if( h->mb.i_neighbour & MB_TOP )
644         {
645             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
646             i_nzb = h->mb.cbp[i_mbb_xy] & (0x200 << i_idx);
647         }
648     }
649     else if( i_cat == DCT_CHROMA_AC )
650     {
651         if( i_idx & 1 )
652             i_mba_xy = h->mb.i_mb_xy;
653         else if( h->mb.i_neighbour & MB_LEFT )
654             i_mba_xy = h->mb.i_mb_xy - 1;
655
656         if( i_idx & 2 )
657             i_mbb_xy = h->mb.i_mb_xy;
658         else if( h->mb.i_neighbour & MB_TOP )
659             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
660
661         /* no need to test skip/pcm */
662         if( i_mba_xy >= 0 )
663             i_nza = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 1];
664         if( i_mbb_xy >= 0 )
665             i_nzb = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 8];
666     }
667
668     if( IS_INTRA( h->mb.i_type ) )
669     {
670         if( i_mba_xy < 0 )
671             i_nza = 1;
672         if( i_mbb_xy < 0 )
673             i_nzb = 1;
674     }
675
676     ctx = 4 * i_cat;
677     if( i_nza )
678         ctx += 1;
679     if( i_nzb )
680         ctx += 2;
681     return ctx;
682 }
683
684
685 static const int significant_coeff_flag_offset[6] = { 105, 120, 134, 149, 152, 402 };
686 static const int last_coeff_flag_offset[6] = { 166, 181, 195, 210, 213, 417 };
687 static const int coeff_abs_level_m1_offset[6] = { 227, 237, 247, 257, 266, 426 };
688 static const int significant_coeff_flag_offset_8x8[63] = {
689     0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
690     4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
691     7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
692    12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
693 };
694 static const int last_coeff_flag_offset_8x8[63] = {
695     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
696     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
697     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
698     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
699 };
700
701 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int i_idx, int *l, int i_count )
702 {
703     const int i_ctx_sig = significant_coeff_flag_offset[i_ctxBlockCat];
704     const int i_ctx_last = last_coeff_flag_offset[i_ctxBlockCat];
705     const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
706
707     int i_coeff_abs_m1[64];
708     int i_coeff_sign[64];
709     int i_coeff = 0;
710     int i_last  = 0;
711     int i_sigmap_size;
712
713     int i_abslevel1 = 0;
714     int i_abslevelgt1 = 0;
715
716     int i;
717
718     /* i_ctxBlockCat: 0-> DC 16x16  i_idx = 0
719      *                1-> AC 16x16  i_idx = luma4x4idx
720      *                2-> Luma4x4   i_idx = luma4x4idx
721      *                3-> DC Chroma i_idx = iCbCr
722      *                4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
723      *                5-> Luma8x8   i_idx = luma8x8idx
724      */
725
726     for( i = 0; i < i_count; i++ )
727     {
728         if( l[i] != 0 )
729         {
730             i_coeff_abs_m1[i_coeff] = abs( l[i] ) - 1;
731             i_coeff_sign[i_coeff]   = ( l[i] < 0 );
732             i_coeff++;
733
734             i_last = i;
735         }
736     }
737
738     if( i_count != 64 )
739     {
740         /* coded block flag */
741         x264_cabac_encode_decision( cb, 85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx ), i_coeff != 0 );
742         if( i_coeff == 0 )
743             return;
744     }
745
746     i_sigmap_size = X264_MIN( i_last+1, i_count-1 );
747     for( i = 0; i < i_sigmap_size; i++ )
748     {
749         int i_sig_ctxIdxInc;
750         int i_last_ctxIdxInc;
751
752         if( i_ctxBlockCat == DCT_LUMA_8x8 )
753         {
754             i_sig_ctxIdxInc = significant_coeff_flag_offset_8x8[i];
755             i_last_ctxIdxInc = last_coeff_flag_offset_8x8[i];
756         }
757         else
758             i_sig_ctxIdxInc = i_last_ctxIdxInc = i;
759
760         x264_cabac_encode_decision( cb, i_ctx_sig + i_sig_ctxIdxInc, l[i] != 0 );
761         if( l[i] != 0 )
762             x264_cabac_encode_decision( cb, i_ctx_last + i_last_ctxIdxInc, i == i_last );
763     }
764
765     for( i = i_coeff - 1; i >= 0; i-- )
766     {
767         /* write coeff_abs - 1 */
768         const int i_prefix = X264_MIN( i_coeff_abs_m1[i], 14 );
769         const int i_ctxIdxInc = (i_abslevelgt1 ? 0 : X264_MIN( 4, i_abslevel1 + 1 )) + i_ctx_level;
770         x264_cabac_encode_decision( cb, i_ctxIdxInc, i_prefix != 0 );
771
772         if( i_prefix != 0 )
773         {
774             const int i_ctxIdxInc = 5 + X264_MIN( 4, i_abslevelgt1 ) + i_ctx_level;
775             int j;
776             for( j = 0; j < i_prefix - 1; j++ )
777                 x264_cabac_encode_decision( cb, i_ctxIdxInc, 1 );
778             if( i_prefix < 14 )
779                 x264_cabac_encode_decision( cb, i_ctxIdxInc, 0 );
780             else /* suffix */
781                 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i] - 14 );
782
783             i_abslevelgt1++;
784         }
785         else
786             i_abslevel1++;
787
788         /* write sign */
789         x264_cabac_encode_bypass( cb, i_coeff_sign[i] );
790     }
791 }
792
793
794
795 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
796 {
797     const int i_mb_type = h->mb.i_type;
798     int i_list;
799     int i;
800
801 #ifndef RDO_SKIP_BS
802     const int i_mb_pos_start = x264_cabac_pos( cb );
803     int       i_mb_pos_tex;
804 #endif
805
806     /* Write the MB type */
807     x264_cabac_mb_type( h, cb );
808
809     /* PCM special block type UNTESTED */
810     if( i_mb_type == I_PCM )
811     {
812 #ifdef RDO_SKIP_BS
813         cb->f8_bits_encoded += (384*8) << 8;
814 #else
815         bs_t *s = cb->s;
816         bs_align_0( s );    /* not sure */
817         /* Luma */
818         for( i = 0; i < 16*16; i++ )
819         {
820             const int x = 16 * h->mb.i_mb_x + (i % 16);
821             const int y = 16 * h->mb.i_mb_y + (i / 16);
822             bs_write( s, 8, h->fenc->plane[0][y*h->mb.pic.i_stride[0]+x] );
823         }
824         /* Cb */
825         for( i = 0; i < 8*8; i++ )
826         {
827             const int x = 8 * h->mb.i_mb_x + (i % 8);
828             const int y = 8 * h->mb.i_mb_y + (i / 8);
829             bs_write( s, 8, h->fenc->plane[1][y*h->mb.pic.i_stride[1]+x] );
830         }
831         /* Cr */
832         for( i = 0; i < 8*8; i++ )
833         {
834             const int x = 8 * h->mb.i_mb_x + (i % 8);
835             const int y = 8 * h->mb.i_mb_y + (i / 8);
836             bs_write( s, 8, h->fenc->plane[2][y*h->mb.pic.i_stride[2]+x] );
837         }
838         x264_cabac_encode_init( cb, s );
839 #endif
840         return;
841     }
842
843     if( IS_INTRA( i_mb_type ) )
844     {
845         if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
846             x264_cabac_mb_transform_size( h, cb );
847
848         if( i_mb_type != I_16x16 )
849         {
850             int di = (i_mb_type == I_8x8) ? 4 : 1;
851             for( i = 0; i < 16; i += di )
852             {
853                 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
854                 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
855                 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
856             }
857         }
858
859         x264_cabac_mb_intra_chroma_pred_mode( h, cb );
860     }
861     else if( i_mb_type == P_L0 )
862     {
863         if( h->mb.i_partition == D_16x16 )
864         {
865             if( h->sh.i_num_ref_idx_l0_active > 1 )
866             {
867                 x264_cabac_mb_ref( h, cb, 0, 0 );
868             }
869             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
870         }
871         else if( h->mb.i_partition == D_16x8 )
872         {
873             if( h->sh.i_num_ref_idx_l0_active > 1 )
874             {
875                 x264_cabac_mb_ref( h, cb, 0, 0 );
876                 x264_cabac_mb_ref( h, cb, 0, 8 );
877             }
878             x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
879             x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
880         }
881         else if( h->mb.i_partition == D_8x16 )
882         {
883             if( h->sh.i_num_ref_idx_l0_active > 1 )
884             {
885                 x264_cabac_mb_ref( h, cb, 0, 0 );
886                 x264_cabac_mb_ref( h, cb, 0, 4 );
887             }
888             x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
889             x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
890         }
891     }
892     else if( i_mb_type == P_8x8 )
893     {
894         /* sub mb type */
895         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[0] );
896         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[1] );
897         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[2] );
898         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[3] );
899
900         /* ref 0 */
901         if( h->sh.i_num_ref_idx_l0_active > 1 )
902         {
903             x264_cabac_mb_ref( h, cb, 0, 0 );
904             x264_cabac_mb_ref( h, cb, 0, 4 );
905             x264_cabac_mb_ref( h, cb, 0, 8 );
906             x264_cabac_mb_ref( h, cb, 0, 12 );
907         }
908
909         for( i = 0; i < 4; i++ )
910             x264_cabac_mb8x8_mvd( h, cb, 0, i );
911     }
912     else if( i_mb_type == B_8x8 )
913     {
914         /* sub mb type */
915         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[0] );
916         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[1] );
917         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[2] );
918         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[3] );
919
920         /* ref */
921         for( i_list = 0; i_list < 2; i_list++ )
922         {
923             if( ( i_list ? h->sh.i_num_ref_idx_l1_active : h->sh.i_num_ref_idx_l0_active ) == 1 )
924                 continue;
925             for( i = 0; i < 4; i++ )
926                 if( x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
927                     x264_cabac_mb_ref( h, cb, i_list, 4*i );
928         }
929
930         for( i = 0; i < 4; i++ )
931             x264_cabac_mb8x8_mvd( h, cb, 0, i );
932         for( i = 0; i < 4; i++ )
933             x264_cabac_mb8x8_mvd( h, cb, 1, i );
934     }
935     else if( i_mb_type != B_DIRECT )
936     {
937         /* All B mode */
938         int b_list[2][2];
939
940         /* init ref list utilisations */
941         for( i = 0; i < 2; i++ )
942         {
943             b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
944             b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
945         }
946
947         for( i_list = 0; i_list < 2; i_list++ )
948         {
949             const int i_ref_max = i_list == 0 ? h->sh.i_num_ref_idx_l0_active : h->sh.i_num_ref_idx_l1_active;
950
951             if( i_ref_max > 1 )
952             {
953                 if( h->mb.i_partition == D_16x16 )
954                 {
955                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
956                 }
957                 else if( h->mb.i_partition == D_16x8 )
958                 {
959                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
960                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 8 );
961                 }
962                 else if( h->mb.i_partition == D_8x16 )
963                 {
964                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
965                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 4 );
966                 }
967             }
968         }
969         for( i_list = 0; i_list < 2; i_list++ )
970         {
971             if( h->mb.i_partition == D_16x16 )
972             {
973                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
974             }
975             else if( h->mb.i_partition == D_16x8 )
976             {
977                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
978                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
979             }
980             else if( h->mb.i_partition == D_8x16 )
981             {
982                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
983                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
984             }
985         }
986     }
987
988 #ifndef RDO_SKIP_BS
989     i_mb_pos_tex = x264_cabac_pos( cb );
990     h->stat.frame.i_hdr_bits += i_mb_pos_tex - i_mb_pos_start;
991 #endif
992
993     if( i_mb_type != I_16x16 )
994     {
995         x264_cabac_mb_cbp_luma( h, cb );
996         x264_cabac_mb_cbp_chroma( h, cb );
997     }
998
999     if( h->mb.cache.b_transform_8x8_allowed && h->mb.i_cbp_luma && !IS_INTRA(i_mb_type) )
1000     {
1001         x264_cabac_mb_transform_size( h, cb );
1002     }
1003
1004     if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
1005     {
1006         x264_cabac_mb_qp_delta( h, cb );
1007
1008         /* write residual */
1009         if( i_mb_type == I_16x16 )
1010         {
1011             /* DC Luma */
1012             block_residual_write_cabac( h, cb, DCT_LUMA_DC, 0, h->dct.luma16x16_dc, 16 );
1013
1014             /* AC Luma */
1015             if( h->mb.i_cbp_luma != 0 )
1016                 for( i = 0; i < 16; i++ )
1017                     block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.block[i].residual_ac, 15 );
1018         }
1019         else if( h->mb.b_transform_8x8 )
1020         {
1021             for( i = 0; i < 4; i++ )
1022                 if( h->mb.i_cbp_luma & ( 1 << i ) )
1023                     block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i, h->dct.luma8x8[i], 64 );
1024         }
1025         else
1026         {
1027             for( i = 0; i < 16; i++ )
1028                 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
1029                     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.block[i].luma4x4, 16 );
1030         }
1031
1032         if( h->mb.i_cbp_chroma &0x03 )    /* Chroma DC residual present */
1033         {
1034             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
1035             block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
1036         }
1037         if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
1038         {
1039             for( i = 0; i < 8; i++ )
1040                 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.block[16+i].residual_ac, 15 );
1041         }
1042     }
1043
1044 #ifndef RDO_SKIP_BS
1045     if( IS_INTRA( i_mb_type ) )
1046         h->stat.frame.i_itex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1047     else
1048         h->stat.frame.i_ptex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1049 #endif
1050 }
1051
1052 #ifdef RDO_SKIP_BS
1053 /*****************************************************************************
1054  * RD only; doesn't generate a valid bitstream
1055  * doesn't write cbp or chroma dc (I don't know how much this matters)
1056  * works on all partition sizes except 16x16
1057  * for sub8x8, call once per 8x8 block
1058  *****************************************************************************/
1059 void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
1060 {
1061     const int i_mb_type = h->mb.i_type;
1062     int j;
1063
1064     if( i_mb_type == P_8x8 )
1065     {
1066         x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
1067         if( h->sh.i_num_ref_idx_l0_active > 1 )
1068             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1069         x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1070     }
1071     else if( i_mb_type == P_L0 )
1072     {
1073         if( h->sh.i_num_ref_idx_l0_active > 1 )
1074             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1075         if( h->mb.i_partition == D_16x8 )
1076             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4, 2 );
1077         else //8x16
1078             x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 4 );
1079     }
1080     else if( i_mb_type == B_8x8 )
1081     {
1082         x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i8] );
1083
1084         if( h->sh.i_num_ref_idx_l0_active > 1
1085             && x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1086             x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1087         if( h->sh.i_num_ref_idx_l1_active > 1
1088             && x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1089             x264_cabac_mb_ref( h, cb, 1, 4*i8 );
1090
1091         x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1092         x264_cabac_mb8x8_mvd( h, cb, 1, i8 );
1093     }
1094     else
1095     {
1096         x264_log(h, X264_LOG_ERROR, "invalid/unhandled mb_type\n" );
1097         return;
1098     }
1099
1100     for( j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1101     {
1102         if( h->mb.i_cbp_luma & (1 << i8) )
1103         {
1104             if( h->mb.b_transform_8x8 )
1105                 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i8, h->dct.luma8x8[i8], 64 );
1106             else
1107             {
1108                 int i4;
1109                 for( i4 = 0; i4 < 4; i4++ )
1110                     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.block[i4+i8*4].luma4x4, 16 );
1111             }
1112         }
1113
1114         block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i8,   h->dct.block[16+i8  ].residual_ac, 15 );
1115         block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i8+4, h->dct.block[16+i8+4].residual_ac, 15 );
1116
1117         i8 += x264_pixel_size[i_pixel].h >> 3;
1118     }
1119 }
1120
1121 static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1122 {
1123     const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1124     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1125     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1126     block_residual_write_cabac( h, cb, DCT_LUMA_8x8, 4*i8, h->dct.luma8x8[i8], 64 );
1127 }
1128
1129 static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1130 {
1131     const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1132     i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1133     x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1134     block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4, h->dct.block[i4].luma4x4, 16 );
1135 }
1136 #endif