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