Use floats instead of int64 in log messages, since win32 (incl. mingw) doesn't unders...
[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 <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "common/common.h"
29 #include "macroblock.h"
30
31 static const uint8_t block_idx_x[16] =
32 {
33     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
34 };
35 static const uint8_t block_idx_y[16] =
36 {
37     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
38 };
39 static const uint8_t block_idx_xy[4][4] =
40 {
41     { 0, 2, 8,  10},
42     { 1, 3, 9,  11},
43     { 4, 6, 12, 14},
44     { 5, 7, 13, 15}
45 };
46
47 static void x264_cabac_mb_type( x264_t *h )
48 {
49     const int i_mb_type = h->mb.i_type;
50
51     if( h->sh.i_type == SLICE_TYPE_I )
52     {
53         int ctx = 0;
54         if( h->mb.i_mb_x > 0 && h->mb.type[h->mb.i_mb_xy - 1] != I_4x4 )
55         {
56             ctx++;
57         }
58         if( h->mb.i_mb_y > 0 && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride] != I_4x4 )
59         {
60             ctx++;
61         }
62
63         if( i_mb_type == I_4x4 )
64         {
65             x264_cabac_encode_decision( &h->cabac, 3 + ctx, 0 );
66         }
67         else if( i_mb_type == I_PCM )
68         {
69             x264_cabac_encode_decision( &h->cabac, 3 + ctx, 1 );
70             x264_cabac_encode_terminal( &h->cabac, 1 );
71         }
72         else    /* I_16x16 */
73         {
74             x264_cabac_encode_decision( &h->cabac, 3 + ctx, 1 );
75             x264_cabac_encode_terminal( &h->cabac, 0 );
76
77             x264_cabac_encode_decision( &h->cabac, 3 + 3, ( h->mb.i_cbp_luma == 0 ? 0 : 1 ));
78             if( h->mb.i_cbp_chroma == 0 )
79             {
80                 x264_cabac_encode_decision( &h->cabac, 3 + 4, 0 );
81             }
82             else
83             {
84                 x264_cabac_encode_decision( &h->cabac, 3 + 4, 1 );
85                 x264_cabac_encode_decision( &h->cabac, 3 + 5, ( h->mb.i_cbp_chroma == 1 ? 0 : 1 ) );
86             }
87             x264_cabac_encode_decision( &h->cabac, 3 + 6, ( (h->mb.i_intra16x16_pred_mode / 2) ? 1 : 0 ));
88             x264_cabac_encode_decision( &h->cabac, 3 + 7, ( (h->mb.i_intra16x16_pred_mode % 2) ? 1 : 0 ));
89         }
90     }
91     else if( h->sh.i_type == SLICE_TYPE_P )
92     {
93         /* prefix: 14, suffix: 17 */
94         if( i_mb_type == P_L0 )
95         {
96             if( h->mb.i_partition == D_16x16 )
97             {
98                 x264_cabac_encode_decision( &h->cabac, 14, 0 );
99                 x264_cabac_encode_decision( &h->cabac, 15, 0 );
100                 x264_cabac_encode_decision( &h->cabac, 16, 0 );
101             }
102             else if( h->mb.i_partition == D_16x8 )
103             {
104                 x264_cabac_encode_decision( &h->cabac, 14, 0 );
105                 x264_cabac_encode_decision( &h->cabac, 15, 1 );
106                 x264_cabac_encode_decision( &h->cabac, 17, 1 );
107             }
108             else if( h->mb.i_partition == D_8x16 )
109             {
110                 x264_cabac_encode_decision( &h->cabac, 14, 0 );
111                 x264_cabac_encode_decision( &h->cabac, 15, 1 );
112                 x264_cabac_encode_decision( &h->cabac, 17, 0 );
113             }
114         }
115         else if( i_mb_type == P_8x8 )
116         {
117             x264_cabac_encode_decision( &h->cabac, 14, 0 );
118             x264_cabac_encode_decision( &h->cabac, 15, 0 );
119             x264_cabac_encode_decision( &h->cabac, 16, 1 );
120         }
121         else if( i_mb_type == I_4x4 )
122         {
123             /* prefix */
124             x264_cabac_encode_decision( &h->cabac, 14, 1 );
125
126             x264_cabac_encode_decision( &h->cabac, 17, 0 );
127         }
128         else if( i_mb_type == I_PCM )
129         {
130             /* prefix */
131             x264_cabac_encode_decision( &h->cabac, 14, 1 );
132
133             x264_cabac_encode_decision( &h->cabac, 17, 1 );
134             x264_cabac_encode_terminal( &h->cabac, 1 ); /*ctxIdx == 276 */
135         }
136         else /* intra 16x16 */
137         {
138             /* prefix */
139             x264_cabac_encode_decision( &h->cabac, 14, 1 );
140
141             /* suffix */
142             x264_cabac_encode_decision( &h->cabac, 17, 1 );
143             x264_cabac_encode_terminal( &h->cabac, 0 ); /*ctxIdx == 276 */
144
145             x264_cabac_encode_decision( &h->cabac, 17+1, ( h->mb.i_cbp_luma == 0 ? 0 : 1 ));
146             if( h->mb.i_cbp_chroma == 0 )
147             {
148                 x264_cabac_encode_decision( &h->cabac, 17+2, 0 );
149             }
150             else
151             {
152                 x264_cabac_encode_decision( &h->cabac, 17+2, 1 );
153                 x264_cabac_encode_decision( &h->cabac, 17+2, ( h->mb.i_cbp_chroma == 1 ? 0 : 1 ) );
154             }
155             x264_cabac_encode_decision( &h->cabac, 17+3, ( (h->mb.i_intra16x16_pred_mode / 2) ? 1 : 0 ));
156             x264_cabac_encode_decision( &h->cabac, 17+3, ( (h->mb.i_intra16x16_pred_mode % 2) ? 1 : 0 ));
157         }
158     }
159     else if( h->sh.i_type == SLICE_TYPE_B )
160     {
161         int ctx = 0;
162         if( h->mb.i_mb_x > 0 && h->mb.type[h->mb.i_mb_xy - 1] != B_SKIP && h->mb.type[h->mb.i_mb_xy - 1] != B_DIRECT )
163         {
164             ctx++;
165         }
166         if( h->mb.i_mb_y > 0 && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride] != B_SKIP && h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride] != B_DIRECT )
167         {
168             ctx++;
169         }
170
171         if( i_mb_type == B_DIRECT )
172         {
173             x264_cabac_encode_decision( &h->cabac, 27+ctx, 0 );
174         }
175         else if( i_mb_type == B_8x8 )
176         {
177             x264_cabac_encode_decision( &h->cabac, 27+ctx, 1 );
178             x264_cabac_encode_decision( &h->cabac, 27+3,   1 );
179             x264_cabac_encode_decision( &h->cabac, 27+4,   1 );
180
181             x264_cabac_encode_decision( &h->cabac, 27+5,   1 );
182             x264_cabac_encode_decision( &h->cabac, 27+5,   1 );
183             x264_cabac_encode_decision( &h->cabac, 27+5,   1 );
184         }
185         else if( IS_INTRA( i_mb_type ) )
186         {
187             /* prefix */
188             x264_cabac_encode_decision( &h->cabac, 27+ctx, 1 );
189             x264_cabac_encode_decision( &h->cabac, 27+3,   1 );
190             x264_cabac_encode_decision( &h->cabac, 27+4,   1 );
191
192             x264_cabac_encode_decision( &h->cabac, 27+5,   1 );
193             x264_cabac_encode_decision( &h->cabac, 27+5,   0 );
194             x264_cabac_encode_decision( &h->cabac, 27+5,   1 );
195
196             /* Suffix */
197             if( i_mb_type == I_4x4 )
198             {
199                 x264_cabac_encode_decision( &h->cabac, 32, 0 );
200             }
201             else if( i_mb_type == I_PCM )
202             {
203                 x264_cabac_encode_decision( &h->cabac, 32, 1 );
204                 x264_cabac_encode_terminal( &h->cabac,     1 );
205             }
206             else
207             {
208                 x264_cabac_encode_decision( &h->cabac, 32, 1 );
209                 x264_cabac_encode_terminal( &h->cabac,     0 );
210
211                 /* TODO */
212                 x264_cabac_encode_decision( &h->cabac, 32+1, ( h->mb.i_cbp_luma == 0 ? 0 : 1 ));
213                 if( h->mb.i_cbp_chroma == 0 )
214                 {
215                     x264_cabac_encode_decision( &h->cabac, 32+2, 0 );
216                 }
217                 else
218                 {
219                     x264_cabac_encode_decision( &h->cabac, 32+2, 1 );
220                     x264_cabac_encode_decision( &h->cabac, 32+2, ( h->mb.i_cbp_chroma == 1 ? 0 : 1 ) );
221                 }
222                 x264_cabac_encode_decision( &h->cabac, 32+3, ( (h->mb.i_intra16x16_pred_mode / 2) ? 1 : 0 ));
223                 x264_cabac_encode_decision( &h->cabac, 32+3, ( (h->mb.i_intra16x16_pred_mode % 2) ? 1 : 0 ));
224             }
225         }
226         else
227         {
228             static const int i_mb_len[21] =
229             {
230                 3, 6, 6,    /* L0 L0 */
231                 3, 6, 6,    /* L1 L1 */
232                 6, 7, 7,    /* BI BI */
233
234                 6, 6,       /* L0 L1 */
235                 6, 6,       /* L1 L0 */
236                 7, 7,       /* L0 BI */
237                 7, 7,       /* L1 BI */
238                 7, 7,       /* BI L0 */
239                 7, 7,       /* BI L1 */
240             };
241             static const int i_mb_bits[21][7] =
242             {
243                 { 1, 0, 0, },            { 1, 1, 0, 0, 0, 1, },    { 1, 1, 0, 0, 1, 0, },   /* L0 L0 */
244                 { 1, 0, 1, },            { 1, 1, 0, 0, 1, 1, },    { 1, 1, 0, 1, 0, 0, },   /* L1 L1 */
245                 { 1, 1, 0, 0, 0, 0 ,},   { 1, 1, 1, 1, 0, 0 , 0 }, { 1, 1, 1, 1, 0, 0 , 1 },/* BI BI */
246
247                 { 1, 1, 0, 1, 0, 1, },   { 1, 1, 0, 1, 1, 0, },     /* L0 L1 */
248                 { 1, 1, 0, 1, 1, 1, },   { 1, 1, 1, 1, 1, 0, },     /* L1 L0 */
249                 { 1, 1, 1, 0, 0, 0, 0 }, { 1, 1, 1, 0, 0, 0, 1 },   /* L0 BI */
250                 { 1, 1, 1, 0, 0, 1, 0 }, { 1, 1, 1, 0, 0, 1, 1 },   /* L1 BI */
251                 { 1, 1, 1, 0, 1, 0, 0 }, { 1, 1, 1, 0, 1, 0, 1 },   /* BI L0 */
252                 { 1, 1, 1, 0, 1, 1, 0 }, { 1, 1, 1, 0, 1, 1, 1 }    /* BI L1 */
253             };
254
255             const int i_partition = h->mb.i_partition;
256             int idx = 0;
257             int i;
258             switch( i_mb_type )
259             {
260                 /* D_16x16, D_16x8, D_8x16 */
261                 case B_BI_BI: idx += 3;
262                 case B_L1_L1: idx += 3;
263                 case B_L0_L0:
264                     if( i_partition == D_16x8 )
265                         idx += 1;
266                     else if( i_partition == D_8x16 )
267                         idx += 2;
268                     break;
269
270                 /* D_16x8, D_8x16 */
271                 case B_BI_L1: idx += 2;
272                 case B_BI_L0: idx += 2;
273                 case B_L1_BI: idx += 2;
274                 case B_L0_BI: idx += 2;
275                 case B_L1_L0: idx += 2;
276                 case B_L0_L1:
277                     idx += 3*3;
278                     if( i_partition == D_8x16 )
279                         idx++;
280                     break;
281                 default:
282                     x264_log(h, X264_LOG_ERROR, "error in B mb type\n" );
283                     return;
284             }
285
286             x264_cabac_encode_decision( &h->cabac, 27+ctx,                         i_mb_bits[idx][0] );
287             x264_cabac_encode_decision( &h->cabac, 27+3,                           i_mb_bits[idx][1] );
288             x264_cabac_encode_decision( &h->cabac, 27+(i_mb_bits[idx][1] != 0 ? 4 : 5), i_mb_bits[idx][2] );
289             for( i = 3; i < i_mb_len[idx]; i++ )
290             {
291                 x264_cabac_encode_decision( &h->cabac, 27+5,                       i_mb_bits[idx][i] );
292             }
293         }
294     }
295     else
296     {
297         x264_log(h, X264_LOG_ERROR, "unknown SLICE_TYPE unsupported in x264_macroblock_write_cabac\n" );
298     }
299 }
300
301 static void x264_cabac_mb_intra4x4_pred_mode( x264_t *h, int i_pred, int i_mode )
302 {
303     if( i_pred == i_mode )
304     {
305         /* b_prev_intra4x4_pred_mode */
306         x264_cabac_encode_decision( &h->cabac, 68, 1 );
307     }
308     else
309     {
310         /* b_prev_intra4x4_pred_mode */
311         x264_cabac_encode_decision( &h->cabac, 68, 0 );
312         if( i_mode > i_pred  )
313         {
314             i_mode--;
315         }
316         x264_cabac_encode_decision( &h->cabac, 69, (i_mode     )&0x01 );
317         x264_cabac_encode_decision( &h->cabac, 69, (i_mode >> 1)&0x01 );
318         x264_cabac_encode_decision( &h->cabac, 69, (i_mode >> 2)&0x01 );
319     }
320 }
321 static void x264_cabac_mb_intra8x8_pred_mode( x264_t *h )
322 {
323     const int i_mode  = h->mb.i_chroma_pred_mode;
324     int       ctx = 0;
325
326     /* No need to test for I4x4 or I_16x16 as cache_save handle that */
327     if( h->mb.i_mb_x > 0 && h->mb.chroma_pred_mode[h->mb.i_mb_xy - 1] != 0 )
328     {
329         ctx++;
330     }
331     if( h->mb.i_mb_y > 0 && h->mb.chroma_pred_mode[h->mb.i_mb_xy - h->mb.i_mb_stride] != 0 )
332     {
333         ctx++;
334     }
335
336     if( i_mode == 0 )
337     {
338         x264_cabac_encode_decision( &h->cabac, 64 + ctx, 0 );
339     }
340     else
341     {
342         x264_cabac_encode_decision( &h->cabac, 64 + ctx, 1 );
343         x264_cabac_encode_decision( &h->cabac, 64 + 3, ( i_mode == 1 ? 0 : 1 ) );
344         if( i_mode > 1 )
345         {
346             x264_cabac_encode_decision( &h->cabac, 64 + 3, ( i_mode == 2 ? 0 : 1 ) );
347         }
348     }
349 }
350
351 static void x264_cabac_mb_cbp_luma( x264_t *h )
352 {
353     /* TODO: clean up and optimize */
354     int i8x8;
355     for( i8x8 = 0; i8x8 < 4; i8x8++ )
356     {
357         int i_mba_xy = -1;
358         int i_mbb_xy = -1;
359         int x = block_idx_x[4*i8x8];
360         int y = block_idx_y[4*i8x8];
361         int ctx = 0;
362
363         if( x > 0 )
364             i_mba_xy = h->mb.i_mb_xy;
365         else if( h->mb.i_mb_x > 0 )
366             i_mba_xy = h->mb.i_mb_xy - 1;
367
368         if( y > 0 )
369             i_mbb_xy = h->mb.i_mb_xy;
370         else if( h->mb.i_mb_y > 0 )
371             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
372
373
374         /* No need to test for PCM and SKIP */
375         if( i_mba_xy >= 0 )
376         {
377             const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
378             if( ((h->mb.cbp[i_mba_xy] >> i8x8a)&0x01) == 0 )
379             {
380                 ctx++;
381             }
382         }
383
384         if( i_mbb_xy >= 0 )
385         {
386             const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
387             if( ((h->mb.cbp[i_mbb_xy] >> i8x8b)&0x01) == 0 )
388             {
389                 ctx += 2;
390             }
391         }
392
393         x264_cabac_encode_decision( &h->cabac, 73 + ctx, (h->mb.i_cbp_luma >> i8x8)&0x01 );
394     }
395 }
396
397 static void x264_cabac_mb_cbp_chroma( x264_t *h )
398 {
399     int cbp_a = -1;
400     int cbp_b = -1;
401     int ctx;
402
403     /* No need to test for SKIP/PCM */
404     if( h->mb.i_mb_x > 0 )
405     {
406         cbp_a = (h->mb.cbp[h->mb.i_mb_xy - 1] >> 4)&0x3;
407     }
408
409     if( h->mb.i_mb_y > 0 )
410     {
411         cbp_b = (h->mb.cbp[h->mb.i_mb_xy - h->mb.i_mb_stride] >> 4)&0x3;
412     }
413
414     ctx = 0;
415     if( cbp_a > 0 ) ctx++;
416     if( cbp_b > 0 ) ctx += 2;
417     if( h->mb.i_cbp_chroma == 0 )
418     {
419         x264_cabac_encode_decision( &h->cabac, 77 + ctx, 0 );
420     }
421     else
422     {
423         x264_cabac_encode_decision( &h->cabac, 77 + ctx, 1 );
424
425         ctx = 4;
426         if( cbp_a == 2 ) ctx++;
427         if( cbp_b == 2 ) ctx += 2;
428         x264_cabac_encode_decision( &h->cabac, 77 + ctx, h->mb.i_cbp_chroma > 1 ? 1 : 0 );
429     }
430 }
431
432 /* TODO check it with != qp per mb */
433 static void x264_cabac_mb_qp_delta( x264_t *h )
434 {
435     int i_mbn_xy = h->mb.i_mb_xy - 1;
436     int i_dqp = h->mb.qp[h->mb.i_mb_xy] - h->mb.i_last_qp;
437     int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
438     int ctx;
439
440     /* No need to test for PCM / SKIP */
441     if( i_mbn_xy >= 0 && h->mb.i_last_dqp != 0 &&
442         ( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) ) )
443         ctx = 1;
444     else
445         ctx = 0;
446
447     while( val > 0 )
448     {
449         x264_cabac_encode_decision( &h->cabac,  60 + ctx, 1 );
450         if( ctx < 2 )
451             ctx = 2;
452         else
453             ctx = 3;
454         val--;
455     }
456     x264_cabac_encode_decision( &h->cabac,  60 + ctx, 0 );
457 }
458
459 void x264_cabac_mb_skip( x264_t *h, int b_skip )
460 {
461     int ctx = 0;
462
463     if( h->mb.i_mb_x > 0 && !IS_SKIP( h->mb.type[h->mb.i_mb_xy -1]) )
464     {
465         ctx++;
466     }
467     if( h->mb.i_mb_y > 0 && !IS_SKIP( h->mb.type[h->mb.i_mb_xy -h->mb.i_mb_stride]) )
468     {
469         ctx++;
470     }
471
472     if( h->sh.i_type == SLICE_TYPE_P )
473         x264_cabac_encode_decision( &h->cabac, 11 + ctx, b_skip ? 1 : 0 );
474     else /* SLICE_TYPE_B */
475         x264_cabac_encode_decision( &h->cabac, 24 + ctx, b_skip ? 1 : 0 );
476 }
477
478 static inline void x264_cabac_mb_sub_p_partition( x264_t *h, int i_sub )
479 {
480     if( i_sub == D_L0_8x8 )
481     {
482         x264_cabac_encode_decision( &h->cabac, 21, 1 );
483     }
484     else if( i_sub == D_L0_8x4 )
485     {
486         x264_cabac_encode_decision( &h->cabac, 21, 0 );
487         x264_cabac_encode_decision( &h->cabac, 22, 0 );
488     }
489     else if( i_sub == D_L0_4x8 )
490     {
491         x264_cabac_encode_decision( &h->cabac, 21, 0 );
492         x264_cabac_encode_decision( &h->cabac, 22, 1 );
493         x264_cabac_encode_decision( &h->cabac, 23, 1 );
494     }
495     else if( i_sub == D_L0_4x4 )
496     {
497         x264_cabac_encode_decision( &h->cabac, 21, 0 );
498         x264_cabac_encode_decision( &h->cabac, 22, 1 );
499         x264_cabac_encode_decision( &h->cabac, 23, 0 );
500     }
501 }
502
503 static inline void x264_cabac_mb_sub_b_partition( x264_t *h, int i_sub )
504 {
505     if( i_sub == D_DIRECT_8x8 )
506     {
507         x264_cabac_encode_decision( &h->cabac, 36, 0 );
508     }
509     else if( i_sub == D_L0_8x8 )
510     {
511         x264_cabac_encode_decision( &h->cabac, 36, 1 );
512         x264_cabac_encode_decision( &h->cabac, 37, 0 );
513         x264_cabac_encode_decision( &h->cabac, 39, 0 );
514     }
515     else if( i_sub == D_L1_8x8 )
516     {
517         x264_cabac_encode_decision( &h->cabac, 36, 1 );
518         x264_cabac_encode_decision( &h->cabac, 37, 0 );
519         x264_cabac_encode_decision( &h->cabac, 39, 1 );
520     }
521     else if( i_sub == D_BI_8x8 )
522     {
523         x264_cabac_encode_decision( &h->cabac, 36, 1 );
524         x264_cabac_encode_decision( &h->cabac, 37, 1 );
525         x264_cabac_encode_decision( &h->cabac, 38, 0 );
526         x264_cabac_encode_decision( &h->cabac, 39, 0 );
527         x264_cabac_encode_decision( &h->cabac, 39, 0 );
528     }
529     else if( i_sub == D_L0_8x4 )
530     {
531         x264_cabac_encode_decision( &h->cabac, 36, 1 );
532         x264_cabac_encode_decision( &h->cabac, 37, 1 );
533         x264_cabac_encode_decision( &h->cabac, 38, 0 );
534         x264_cabac_encode_decision( &h->cabac, 39, 0 );
535         x264_cabac_encode_decision( &h->cabac, 39, 1 );
536     }
537     else if( i_sub == D_L0_4x8 )
538     {
539         x264_cabac_encode_decision( &h->cabac, 36, 1 );
540         x264_cabac_encode_decision( &h->cabac, 37, 1 );
541         x264_cabac_encode_decision( &h->cabac, 38, 0 );
542         x264_cabac_encode_decision( &h->cabac, 39, 1 );
543         x264_cabac_encode_decision( &h->cabac, 39, 0 );
544     }
545     else if( i_sub == D_L1_8x4 )
546     {
547         x264_cabac_encode_decision( &h->cabac, 36, 1 );
548         x264_cabac_encode_decision( &h->cabac, 37, 1 );
549         x264_cabac_encode_decision( &h->cabac, 38, 0 );
550         x264_cabac_encode_decision( &h->cabac, 39, 1 );
551         x264_cabac_encode_decision( &h->cabac, 39, 1 );
552     }
553     else if( i_sub == D_L1_4x8 )
554     {
555         x264_cabac_encode_decision( &h->cabac, 36, 1 );
556         x264_cabac_encode_decision( &h->cabac, 37, 1 );
557         x264_cabac_encode_decision( &h->cabac, 38, 1 );
558         x264_cabac_encode_decision( &h->cabac, 39, 0 );
559         x264_cabac_encode_decision( &h->cabac, 39, 0 );
560         x264_cabac_encode_decision( &h->cabac, 39, 0 );
561     }
562     else if( i_sub == D_BI_8x4 )
563     {
564         x264_cabac_encode_decision( &h->cabac, 36, 1 );
565         x264_cabac_encode_decision( &h->cabac, 37, 1 );
566         x264_cabac_encode_decision( &h->cabac, 38, 1 );
567         x264_cabac_encode_decision( &h->cabac, 39, 0 );
568         x264_cabac_encode_decision( &h->cabac, 39, 0 );
569         x264_cabac_encode_decision( &h->cabac, 39, 1 );
570     }
571     else if( i_sub == D_BI_4x8 )
572     {
573         x264_cabac_encode_decision( &h->cabac, 36, 1 );
574         x264_cabac_encode_decision( &h->cabac, 37, 1 );
575         x264_cabac_encode_decision( &h->cabac, 38, 1 );
576         x264_cabac_encode_decision( &h->cabac, 39, 0 );
577         x264_cabac_encode_decision( &h->cabac, 39, 1 );
578         x264_cabac_encode_decision( &h->cabac, 39, 0 );
579     }
580     else if( i_sub == D_L0_4x4 )
581     {
582         x264_cabac_encode_decision( &h->cabac, 36, 1 );
583         x264_cabac_encode_decision( &h->cabac, 37, 1 );
584         x264_cabac_encode_decision( &h->cabac, 38, 1 );
585         x264_cabac_encode_decision( &h->cabac, 39, 0 );
586         x264_cabac_encode_decision( &h->cabac, 39, 1 );
587         x264_cabac_encode_decision( &h->cabac, 39, 1 );
588     }
589     else if( i_sub == D_L1_4x4 )
590     {
591         x264_cabac_encode_decision( &h->cabac, 36, 1 );
592         x264_cabac_encode_decision( &h->cabac, 37, 1 );
593         x264_cabac_encode_decision( &h->cabac, 38, 1 );
594         x264_cabac_encode_decision( &h->cabac, 39, 1 );
595         x264_cabac_encode_decision( &h->cabac, 39, 0 );
596     }
597     else if( i_sub == D_BI_4x4 )
598     {
599         x264_cabac_encode_decision( &h->cabac, 36, 1 );
600         x264_cabac_encode_decision( &h->cabac, 37, 1 );
601         x264_cabac_encode_decision( &h->cabac, 38, 1 );
602         x264_cabac_encode_decision( &h->cabac, 39, 1 );
603         x264_cabac_encode_decision( &h->cabac, 39, 1 );
604     }
605 }
606
607 static inline void x264_cabac_mb_ref( x264_t *h, int i_list, int idx )
608 {
609     const int i8 = x264_scan8[idx];
610     const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
611     const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
612     int i_ref  = h->mb.cache.ref[i_list][i8];
613     int ctx  = 0;
614
615     if( i_refa > 0 && !h->mb.cache.skip[i8 - 1])
616         ctx++;
617     if( i_refb > 0 && !h->mb.cache.skip[i8 - 8])
618         ctx += 2;
619
620     while( i_ref > 0 )
621     {
622         x264_cabac_encode_decision( &h->cabac, 54 + ctx, 1 );
623         if( ctx < 4 )
624             ctx = 4;
625         else
626             ctx = 5;
627
628         i_ref--;
629     }
630     x264_cabac_encode_decision( &h->cabac, 54 + ctx, 0 );
631 }
632
633
634
635 static inline void  x264_cabac_mb_mvd_cpn( x264_t *h, int i_list, int idx, int l, int mvd )
636 {
637     const int amvd = abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 1][l] ) +
638                      abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 8][l] );
639     const int i_abs = abs( mvd );
640     const int i_prefix = X264_MIN( i_abs, 9 );
641     const int ctxbase = (l == 0 ? 40 : 47);
642     int ctx;
643     int i;
644
645
646     if( amvd < 3 )
647         ctx = 0;
648     else if( amvd > 32 )
649         ctx = 2;
650     else
651         ctx = 1;
652
653     for( i = 0; i < i_prefix; i++ )
654     {
655         x264_cabac_encode_decision( &h->cabac, ctxbase + ctx, 1 );
656         if( ctx < 3 )
657             ctx = 3;
658         else if( ctx < 6 )
659             ctx++;
660     }
661     if( i_prefix < 9 )
662     {
663         x264_cabac_encode_decision( &h->cabac, ctxbase + ctx, 0 );
664     }
665
666     if( i_prefix >= 9 )
667     {
668         int i_suffix = i_abs - 9;
669         int k = 3;
670
671         while( i_suffix >= (1<<k) )
672         {
673             x264_cabac_encode_bypass( &h->cabac, 1 );
674             i_suffix -= 1 << k;
675             k++;
676         }
677         x264_cabac_encode_bypass( &h->cabac, 0 );
678         while( k-- )
679         {
680             x264_cabac_encode_bypass( &h->cabac, (i_suffix >> k)&0x01 );
681         }
682     }
683
684     /* sign */
685     if( mvd > 0 )
686         x264_cabac_encode_bypass( &h->cabac, 0 );
687     else if( mvd < 0 )
688         x264_cabac_encode_bypass( &h->cabac, 1 );
689 }
690
691 static inline void  x264_cabac_mb_mvd( x264_t *h, int i_list, int idx, int width, int height )
692 {
693     int mvp[2];
694     int mdx, mdy;
695
696     /* Calculate mvd */
697     x264_mb_predict_mv( h, i_list, idx, width, mvp );
698     mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
699     mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
700
701     /* encode */
702     x264_cabac_mb_mvd_cpn( h, i_list, idx, 0, mdx );
703     x264_cabac_mb_mvd_cpn( h, i_list, idx, 1, mdy );
704
705     /* save value */
706     x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mdx, mdy );
707 }
708
709 static inline void x264_cabac_mb8x8_mvd( x264_t *h, int i_list )
710 {
711     int i;
712     for( i = 0; i < 4; i++ )
713     {
714         if( !x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
715         {
716             continue;
717         }
718
719         switch( h->mb.i_sub_partition[i] )
720         {
721             case D_L0_8x8:
722             case D_L1_8x8:
723             case D_BI_8x8:
724                 x264_cabac_mb_mvd( h, i_list, 4*i, 2, 2 );
725                 break;
726             case D_L0_8x4:
727             case D_L1_8x4:
728             case D_BI_8x4:
729                 x264_cabac_mb_mvd( h, i_list, 4*i+0, 2, 1 );
730                 x264_cabac_mb_mvd( h, i_list, 4*i+2, 2, 1 );
731                 break;
732             case D_L0_4x8:
733             case D_L1_4x8:
734             case D_BI_4x8:
735                 x264_cabac_mb_mvd( h, i_list, 4*i+0, 1, 2 );
736                 x264_cabac_mb_mvd( h, i_list, 4*i+1, 1, 2 );
737                 break;
738             case D_L0_4x4:
739             case D_L1_4x4:
740             case D_BI_4x4:
741                 x264_cabac_mb_mvd( h, i_list, 4*i+0, 1, 1 );
742                 x264_cabac_mb_mvd( h, i_list, 4*i+1, 1, 1 );
743                 x264_cabac_mb_mvd( h, i_list, 4*i+2, 1, 1 );
744                 x264_cabac_mb_mvd( h, i_list, 4*i+3, 1, 1 );
745                 break;
746         }
747     }
748 }
749
750 static int x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx )
751 {
752     /* TODO: clean up/optimize */
753     int i_mba_xy = -1;
754     int i_mbb_xy = -1;
755     int i_nza = -1;
756     int i_nzb = -1;
757     int ctx = 0;
758
759     if( i_cat == 0 )
760     {
761         if( h->mb.i_mb_x > 0 )
762         {
763             i_mba_xy = h->mb.i_mb_xy -1;
764             if( h->mb.type[i_mba_xy] == I_16x16 )
765             {
766                 i_nza = h->mb.cbp[i_mba_xy]&0x100;
767             }
768         }
769         if( h->mb.i_mb_y > 0 )
770         {
771             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
772             if( h->mb.type[i_mbb_xy] == I_16x16 )
773             {
774                 i_nzb = h->mb.cbp[i_mbb_xy]&0x100;
775             }
776         }
777     }
778     else if( i_cat == 1 || i_cat == 2 )
779     {
780         int x = block_idx_x[i_idx];
781         int y = block_idx_y[i_idx];
782
783         if( x > 0 )
784             i_mba_xy = h->mb.i_mb_xy;
785         else if( h->mb.i_mb_x > 0 )
786             i_mba_xy = h->mb.i_mb_xy -1;
787
788         if( y > 0 )
789             i_mbb_xy = h->mb.i_mb_xy;
790         else if( h->mb.i_mb_y > 0 )
791             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
792
793         /* no need to test for skip/pcm */
794         if( i_mba_xy >= 0 )
795         {
796             const int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
797             if( (h->mb.cbp[i_mba_xy]&0x0f)>> i8x8a )
798             {
799                 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
800             }
801         }
802         if( i_mbb_xy >= 0 )
803         {
804             const int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
805             if( (h->mb.cbp[i_mbb_xy]&0x0f)>> i8x8b )
806             {
807                 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
808             }
809         }
810     }
811     else if( i_cat == 3 )
812     {
813         /* no need to test skip/pcm */
814         if( h->mb.i_mb_x > 0 )
815         {
816             i_mba_xy = h->mb.i_mb_xy -1;
817             if( h->mb.cbp[i_mba_xy]&0x30 )
818             {
819                 i_nza = h->mb.cbp[i_mba_xy]&( 0x02 << ( 8 + i_idx) );
820             }
821         }
822         if( h->mb.i_mb_y > 0 )
823         {
824             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
825             if( h->mb.cbp[i_mbb_xy]&0x30 )
826             {
827                 i_nzb = h->mb.cbp[i_mbb_xy]&( 0x02 << ( 8 + i_idx) );
828             }
829         }
830     }
831     else if( i_cat == 4 )
832     {
833         int idxc = i_idx% 4;
834
835         if( idxc == 1 || idxc == 3 )
836             i_mba_xy = h->mb.i_mb_xy;
837         else if( h->mb.i_mb_x > 0 )
838             i_mba_xy = h->mb.i_mb_xy - 1;
839
840         if( idxc == 2 || idxc == 3 )
841             i_mbb_xy = h->mb.i_mb_xy;
842         else if( h->mb.i_mb_y > 0 )
843             i_mbb_xy = h->mb.i_mb_xy - h->mb.i_mb_stride;
844
845         /* no need to test skip/pcm */
846         if( i_mba_xy >= 0 && (h->mb.cbp[i_mba_xy]&0x30) == 0x20 )
847         {
848             i_nza = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 1];
849         }
850         if( i_mbb_xy >= 0 && (h->mb.cbp[i_mbb_xy]&0x30) == 0x20 )
851         {
852             i_nzb = h->mb.cache.non_zero_count[x264_scan8[16+i_idx] - 8];
853         }
854     }
855
856     if( ( i_mba_xy < 0  && IS_INTRA( h->mb.i_type ) ) || i_nza > 0 )
857     {
858         ctx++;
859     }
860     if( ( i_mbb_xy < 0  && IS_INTRA( h->mb.i_type ) ) || i_nzb > 0 )
861     {
862         ctx += 2;
863     }
864
865     return 4 * i_cat + ctx;
866 }
867
868
869 static void block_residual_write_cabac( x264_t *h, int i_ctxBlockCat, int i_idx, int *l, int i_count )
870 {
871     static const int significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 };
872     static const int last_significant_coeff_flag_offset[5] = { 0, 15, 29, 44, 47 };
873     static const int coeff_abs_level_m1_offset[5] = { 0, 10, 20, 30, 39 };
874
875     int i_coeff_abs_m1[16];
876     int i_coeff_sign[16];
877     int i_coeff = 0;
878     int i_last  = 0;
879
880     int i_abslevel1 = 0;
881     int i_abslevelgt1 = 0;
882
883     int i;
884
885     /* i_ctxBlockCat: 0-> DC 16x16  i_idx = 0
886      *                1-> AC 16x16  i_idx = luma4x4idx
887      *                2-> Luma4x4   i_idx = luma4x4idx
888      *                3-> DC Chroma i_idx = iCbCr
889      *                4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
890      */
891
892     //fprintf( stderr, "l[] = " );
893     for( i = 0; i < i_count; i++ )
894     {
895         //fprintf( stderr, "%d ", l[i] );
896         if( l[i] != 0 )
897         {
898             i_coeff_abs_m1[i_coeff] = abs( l[i] ) - 1;
899             i_coeff_sign[i_coeff]   = ( l[i] < 0 ? 1 : 0);
900             i_coeff++;
901
902             i_last = i;
903         }
904     }
905     //fprintf( stderr, "\n" );
906
907     if( i_coeff == 0 )
908     {
909         /* codec block flag */
910         x264_cabac_encode_decision( &h->cabac,  85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx ), 0 );
911         return;
912     }
913
914     /* block coded */
915     x264_cabac_encode_decision( &h->cabac,  85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx ), 1 );
916     for( i = 0; i < i_count - 1; i++ )
917     {
918         int i_ctxIdxInc;
919
920         i_ctxIdxInc = X264_MIN( i, i_count - 2 );
921
922         if( l[i] != 0 )
923         {
924             x264_cabac_encode_decision( &h->cabac, 105 + significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc, 1 );
925             x264_cabac_encode_decision( &h->cabac, 166 + last_significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc, i == i_last ? 1 : 0 );
926         }
927         else
928         {
929             x264_cabac_encode_decision( &h->cabac, 105 + significant_coeff_flag_offset[i_ctxBlockCat] + i_ctxIdxInc, 0 );
930         }
931         if( i == i_last )
932         {
933             break;
934         }
935     }
936
937     for( i = i_coeff - 1; i >= 0; i-- )
938     {
939         int i_prefix;
940         int i_ctxIdxInc;
941
942         /* write coeff_abs - 1 */
943
944         /* prefix */
945         i_prefix = X264_MIN( i_coeff_abs_m1[i], 14 );
946
947         i_ctxIdxInc = (i_abslevelgt1 != 0 ? 0 : X264_MIN( 4, i_abslevel1 + 1 )) + coeff_abs_level_m1_offset[i_ctxBlockCat];
948         if( i_prefix == 0 )
949         {
950             x264_cabac_encode_decision( &h->cabac,  227 + i_ctxIdxInc, 0 );
951         }
952         else
953         {
954             int j;
955             x264_cabac_encode_decision( &h->cabac,  227 + i_ctxIdxInc, 1 );
956             i_ctxIdxInc = 5 + X264_MIN( 4, i_abslevelgt1 ) + coeff_abs_level_m1_offset[i_ctxBlockCat];
957             for( j = 0; j < i_prefix - 1; j++ )
958             {
959                 x264_cabac_encode_decision( &h->cabac,  227 + i_ctxIdxInc, 1 );
960             }
961             if( i_prefix < 14 )
962             {
963                 x264_cabac_encode_decision( &h->cabac,  227 + i_ctxIdxInc, 0 );
964             }
965         }
966         /* suffix */
967         if( i_coeff_abs_m1[i] >= 14 )
968         {
969             int k = 0;
970             int i_suffix = i_coeff_abs_m1[i] - 14;
971
972             while( i_suffix >= (1<<k) )
973             {
974                 x264_cabac_encode_bypass( &h->cabac, 1 );
975                 i_suffix -= 1 << k;
976                 k++;
977             }
978             x264_cabac_encode_bypass( &h->cabac, 0 );
979             while( k-- )
980             {
981                 x264_cabac_encode_bypass( &h->cabac, (i_suffix >> k)&0x01 );
982             }
983         }
984
985         /* write sign */
986         x264_cabac_encode_bypass( &h->cabac, i_coeff_sign[i] );
987
988
989         if( i_coeff_abs_m1[i] == 0 )
990         {
991             i_abslevel1++;
992         }
993         else
994         {
995             i_abslevelgt1++;
996         }
997     }
998 }
999
1000
1001
1002 void x264_macroblock_write_cabac( x264_t *h, bs_t *s )
1003 {
1004     const int i_mb_type = h->mb.i_type;
1005     const int i_mb_pos_start = bs_pos( s );
1006     int       i_mb_pos_tex;
1007
1008     int i_list;
1009     int i;
1010
1011     /* Write the MB type */
1012     x264_cabac_mb_type( h );
1013
1014     /* PCM special block type UNTESTED */
1015     if( i_mb_type == I_PCM )
1016     {
1017         bs_align_0( s );    /* not sure */
1018         /* Luma */
1019         for( i = 0; i < 16*16; i++ )
1020         {
1021             const int x = 16 * h->mb.i_mb_x + (i % 16);
1022             const int y = 16 * h->mb.i_mb_y + (i / 16);
1023             bs_write( s, 8, h->fenc->plane[0][y*h->mb.pic.i_stride[0]+x] );
1024         }
1025         /* Cb */
1026         for( i = 0; i < 8*8; i++ )
1027         {
1028             const int x = 8 * h->mb.i_mb_x + (i % 8);
1029             const int y = 8 * h->mb.i_mb_y + (i / 8);
1030             bs_write( s, 8, h->fenc->plane[1][y*h->mb.pic.i_stride[1]+x] );
1031         }
1032         /* Cr */
1033         for( i = 0; i < 8*8; i++ )
1034         {
1035             const int x = 8 * h->mb.i_mb_x + (i % 8);
1036             const int y = 8 * h->mb.i_mb_y + (i / 8);
1037             bs_write( s, 8, h->fenc->plane[2][y*h->mb.pic.i_stride[2]+x] );
1038         }
1039         x264_cabac_encode_init( &h->cabac, s );
1040         return;
1041     }
1042
1043     if( IS_INTRA( i_mb_type ) )
1044     {
1045         /* Prediction */
1046         if( i_mb_type == I_4x4 )
1047         {
1048             for( i = 0; i < 16; i++ )
1049             {
1050                 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
1051                 const int i_mode = h->mb.cache.intra4x4_pred_mode[x264_scan8[i]];
1052                 x264_cabac_mb_intra4x4_pred_mode( h, i_pred, i_mode );
1053             }
1054         }
1055         x264_cabac_mb_intra8x8_pred_mode( h );
1056     }
1057     else if( i_mb_type == P_L0 )
1058     {
1059         if( h->mb.i_partition == D_16x16 )
1060         {
1061             if( h->sh.i_num_ref_idx_l0_active > 1 )
1062             {
1063                 x264_cabac_mb_ref( h, 0, 0 );
1064             }
1065             x264_cabac_mb_mvd( h, 0, 0, 4, 4 );
1066         }
1067         else if( h->mb.i_partition == D_16x8 )
1068         {
1069             if( h->sh.i_num_ref_idx_l0_active > 1 )
1070             {
1071                 x264_cabac_mb_ref( h, 0, 0 );
1072                 x264_cabac_mb_ref( h, 0, 8 );
1073             }
1074             x264_cabac_mb_mvd( h, 0, 0, 4, 2 );
1075             x264_cabac_mb_mvd( h, 0, 8, 4, 2 );
1076         }
1077         else if( h->mb.i_partition == D_8x16 )
1078         {
1079             if( h->sh.i_num_ref_idx_l0_active > 1 )
1080             {
1081                 x264_cabac_mb_ref( h, 0, 0 );
1082                 x264_cabac_mb_ref( h, 0, 4 );
1083             }
1084             x264_cabac_mb_mvd( h, 0, 0, 2, 4 );
1085             x264_cabac_mb_mvd( h, 0, 4, 2, 4 );
1086         }
1087     }
1088     else if( i_mb_type == P_8x8 )
1089     {
1090         /* sub mb type */
1091         x264_cabac_mb_sub_p_partition( h, h->mb.i_sub_partition[0] );
1092         x264_cabac_mb_sub_p_partition( h, h->mb.i_sub_partition[1] );
1093         x264_cabac_mb_sub_p_partition( h, h->mb.i_sub_partition[2] );
1094         x264_cabac_mb_sub_p_partition( h, h->mb.i_sub_partition[3] );
1095
1096         /* ref 0 */
1097         if( h->sh.i_num_ref_idx_l0_active > 1 )
1098         {
1099             x264_cabac_mb_ref( h, 0, 0 );
1100             x264_cabac_mb_ref( h, 0, 4 );
1101             x264_cabac_mb_ref( h, 0, 8 );
1102             x264_cabac_mb_ref( h, 0, 12 );
1103         }
1104
1105         x264_cabac_mb8x8_mvd( h, 0 );
1106     }
1107     else if( i_mb_type == B_8x8 )
1108     {
1109         /* sub mb type */
1110         x264_cabac_mb_sub_b_partition( h, h->mb.i_sub_partition[0] );
1111         x264_cabac_mb_sub_b_partition( h, h->mb.i_sub_partition[1] );
1112         x264_cabac_mb_sub_b_partition( h, h->mb.i_sub_partition[2] );
1113         x264_cabac_mb_sub_b_partition( h, h->mb.i_sub_partition[3] );
1114
1115         /* ref */
1116         for( i_list = 0; i_list < 2; i_list++ )
1117         {
1118             if( ( i_list ? h->sh.i_num_ref_idx_l1_active : h->sh.i_num_ref_idx_l0_active ) == 1 )
1119                 continue;
1120             for( i = 0; i < 4; i++ )
1121             {
1122                 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
1123                 {
1124                     x264_cabac_mb_ref( h, i_list, 4*i );
1125                 }
1126             }
1127         }
1128
1129         x264_cabac_mb8x8_mvd( h, 0 );
1130         x264_cabac_mb8x8_mvd( h, 1 );
1131     }
1132     else if( i_mb_type != B_DIRECT )
1133     {
1134         /* All B mode */
1135         int b_list[2][2];
1136
1137         /* init ref list utilisations */
1138         for( i = 0; i < 2; i++ )
1139         {
1140             b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
1141             b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
1142         }
1143
1144         for( i_list = 0; i_list < 2; i_list++ )
1145         {
1146             const int i_ref_max = i_list == 0 ? h->sh.i_num_ref_idx_l0_active : h->sh.i_num_ref_idx_l1_active;
1147
1148             if( i_ref_max > 1 )
1149             {
1150                 if( h->mb.i_partition == D_16x16 )
1151                 {
1152                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, i_list, 0 );
1153                 }
1154                 else if( h->mb.i_partition == D_16x8 )
1155                 {
1156                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, i_list, 0 );
1157                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, i_list, 8 );
1158                 }
1159                 else if( h->mb.i_partition == D_8x16 )
1160                 {
1161                     if( b_list[i_list][0] ) x264_cabac_mb_ref( h, i_list, 0 );
1162                     if( b_list[i_list][1] ) x264_cabac_mb_ref( h, i_list, 4 );
1163                 }
1164             }
1165         }
1166         for( i_list = 0; i_list < 2; i_list++ )
1167         {
1168             if( h->mb.i_partition == D_16x16 )
1169             {
1170                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, i_list, 0, 4, 4 );
1171             }
1172             else if( h->mb.i_partition == D_16x8 )
1173             {
1174                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, i_list, 0, 4, 2 );
1175                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, i_list, 8, 4, 2 );
1176             }
1177             else if( h->mb.i_partition == D_8x16 )
1178             {
1179                 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, i_list, 0, 2, 4 );
1180                 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, i_list, 4, 2, 4 );
1181             }
1182         }
1183     }
1184
1185     i_mb_pos_tex = bs_pos( s );
1186     h->stat.frame.i_hdr_bits += i_mb_pos_tex - i_mb_pos_start;
1187
1188     if( i_mb_type != I_16x16 )
1189     {
1190         x264_cabac_mb_cbp_luma( h );
1191         x264_cabac_mb_cbp_chroma( h );
1192     }
1193
1194     if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
1195     {
1196         x264_cabac_mb_qp_delta( h );
1197
1198         /* write residual */
1199         if( i_mb_type == I_16x16 )
1200         {
1201             /* DC Luma */
1202             block_residual_write_cabac( h, 0, 0, h->dct.luma16x16_dc, 16 );
1203
1204             if( h->mb.i_cbp_luma != 0 )
1205             {
1206                 /* AC Luma */
1207                 for( i = 0; i < 16; i++ )
1208                 {
1209                     block_residual_write_cabac( h, 1, i, h->dct.block[i].residual_ac, 15 );
1210                 }
1211             }
1212         }
1213         else
1214         {
1215             for( i = 0; i < 16; i++ )
1216             {
1217                 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
1218                 {
1219                     block_residual_write_cabac( h, 2, i, h->dct.block[i].luma4x4, 16 );
1220                 }
1221             }
1222         }
1223
1224         if( h->mb.i_cbp_chroma &0x03 )    /* Chroma DC residual present */
1225         {
1226             block_residual_write_cabac( h, 3, 0, h->dct.chroma_dc[0], 4 );
1227             block_residual_write_cabac( h, 3, 1, h->dct.chroma_dc[1], 4 );
1228         }
1229         if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
1230         {
1231             for( i = 0; i < 8; i++ )
1232             {
1233                 block_residual_write_cabac( h, 4, i, h->dct.block[16+i].residual_ac, 15 );
1234             }
1235         }
1236     }
1237
1238     if( IS_INTRA( i_mb_type ) )
1239         h->stat.frame.i_itex_bits += bs_pos(s) - i_mb_pos_tex;
1240     else
1241         h->stat.frame.i_ptex_bits += bs_pos(s) - i_mb_pos_tex;
1242 }
1243