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