1 /*****************************************************************************
2 * cabac.c: h264 encoder library
3 *****************************************************************************
4 * Copyright (C) 2003-2008 x264 project
6 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7 * Loren Merritt <lorenm@u.washington.edu>
8 * Fiona Glaser <fiona@x264.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
23 *****************************************************************************/
25 #include "common/common.h"
26 #include "macroblock.h"
32 static inline void x264_cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
33 int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
35 if( i_mb_type == I_4x4 || i_mb_type == I_8x8 )
37 x264_cabac_encode_decision_noup( cb, ctx0, 0 );
40 else if( i_mb_type == I_PCM )
42 x264_cabac_encode_decision_noup( cb, ctx0, 1 );
43 x264_cabac_encode_flush( h, cb );
48 int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
50 x264_cabac_encode_decision_noup( cb, ctx0, 1 );
51 x264_cabac_encode_terminal( cb );
53 x264_cabac_encode_decision_noup( cb, ctx1, !!h->mb.i_cbp_luma );
54 if( h->mb.i_cbp_chroma == 0 )
55 x264_cabac_encode_decision_noup( cb, ctx2, 0 );
58 x264_cabac_encode_decision( cb, ctx2, 1 );
59 x264_cabac_encode_decision_noup( cb, ctx3, h->mb.i_cbp_chroma>>1 );
61 x264_cabac_encode_decision( cb, ctx4, i_pred>>1 );
62 x264_cabac_encode_decision_noup( cb, ctx5, i_pred&1 );
66 static void x264_cabac_mb_type( x264_t *h, x264_cabac_t *cb )
68 const int i_mb_type = h->mb.i_type;
71 (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
73 x264_cabac_encode_decision_noup( cb, 70 + h->mb.cache.i_neighbour_interlaced, h->mb.b_interlaced );
76 if( h->sh.i_type == SLICE_TYPE_I )
79 if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != I_4x4 )
81 if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != I_4x4 )
84 x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
86 else if( h->sh.i_type == SLICE_TYPE_P )
88 /* prefix: 14, suffix: 17 */
89 if( i_mb_type == P_L0 )
91 x264_cabac_encode_decision_noup( cb, 14, 0 );
92 x264_cabac_encode_decision_noup( cb, 15, h->mb.i_partition != D_16x16 );
93 x264_cabac_encode_decision_noup( cb, 17-(h->mb.i_partition == D_16x16), h->mb.i_partition == D_16x8 );
95 else if( i_mb_type == P_8x8 )
97 x264_cabac_encode_decision_noup( cb, 14, 0 );
98 x264_cabac_encode_decision_noup( cb, 15, 0 );
99 x264_cabac_encode_decision_noup( cb, 16, 1 );
104 x264_cabac_encode_decision_noup( cb, 14, 1 );
107 x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
110 else //if( h->sh.i_type == SLICE_TYPE_B )
113 if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != B_SKIP && h->mb.i_mb_type_left != B_DIRECT )
115 if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
118 if( i_mb_type == B_DIRECT )
120 x264_cabac_encode_decision_noup( cb, 27+ctx, 0 );
123 x264_cabac_encode_decision_noup( cb, 27+ctx, 1 );
125 if( i_mb_type == B_8x8 )
127 x264_cabac_encode_decision_noup( cb, 27+3, 1 );
128 x264_cabac_encode_decision_noup( cb, 27+4, 1 );
129 x264_cabac_encode_decision( cb, 27+5, 1 );
130 x264_cabac_encode_decision( cb, 27+5, 1 );
131 x264_cabac_encode_decision_noup( cb, 27+5, 1 );
133 else if( IS_INTRA( i_mb_type ) )
136 x264_cabac_encode_decision_noup( cb, 27+3, 1 );
137 x264_cabac_encode_decision_noup( cb, 27+4, 1 );
138 x264_cabac_encode_decision( cb, 27+5, 1 );
139 x264_cabac_encode_decision( cb, 27+5, 0 );
140 x264_cabac_encode_decision( cb, 27+5, 1 );
143 x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
147 static const uint8_t i_mb_bits[9*3][6] =
149 { 1,0,0,0,1,2 }, { 1,0,0,1,0,2 }, { 0,0,2,2,2,2 }, /* L0 L0 */
150 { 1,0,1,0,1,2 }, { 1,0,1,1,0,2 }, {0}, /* L0 L1 */
151 { 1,1,0,0,0,0 }, { 1,1,0,0,0,1 }, {0}, /* L0 BI */
152 { 1,0,1,1,1,2 }, { 1,1,1,1,0,2 }, {0}, /* L1 L0 */
153 { 1,0,0,1,1,2 }, { 1,0,1,0,0,2 }, { 0,1,2,2,2,2 }, /* L1 L1 */
154 { 1,1,0,0,1,0 }, { 1,1,0,0,1,1 }, {0}, /* L1 BI */
155 { 1,1,0,1,0,0 }, { 1,1,0,1,0,1 }, {0}, /* BI L0 */
156 { 1,1,0,1,1,0 }, { 1,1,0,1,1,1 }, {0}, /* BI L1 */
157 { 1,1,1,0,0,0 }, { 1,1,1,0,0,1 }, { 1,0,0,0,0,2 }, /* BI BI */
160 const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
162 x264_cabac_encode_decision_noup( cb, 27+3, i_mb_bits[idx][0] );
163 x264_cabac_encode_decision( cb, 27+5-i_mb_bits[idx][0], i_mb_bits[idx][1] );
164 if( i_mb_bits[idx][2] != 2 )
166 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][2] );
167 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][3] );
168 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][4] );
169 if( i_mb_bits[idx][5] != 2 )
170 x264_cabac_encode_decision_noup( cb, 27+5, i_mb_bits[idx][5] );
176 static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
178 if( i_pred == i_mode )
179 x264_cabac_encode_decision( cb, 68, 1 );
182 x264_cabac_encode_decision( cb, 68, 0 );
183 if( i_mode > i_pred )
185 x264_cabac_encode_decision( cb, 69, (i_mode )&0x01 );
186 x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
187 x264_cabac_encode_decision( cb, 69, (i_mode >> 2) );
191 static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
193 const int i_mode = x264_mb_pred_mode8x8c_fix[ h->mb.i_chroma_pred_mode ];
196 /* No need to test for I4x4 or I_16x16 as cache_save handle that */
197 if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_xy - 1] != 0 )
199 if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_top_xy] != 0 )
202 x264_cabac_encode_decision_noup( cb, 64 + ctx, i_mode > 0 );
205 x264_cabac_encode_decision( cb, 64 + 3, i_mode > 1 );
207 x264_cabac_encode_decision_noup( cb, 64 + 3, i_mode > 2 );
211 static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
213 int cbp = h->mb.i_cbp_luma;
214 int cbp_l = h->mb.cache.i_cbp_left;
215 int cbp_t = h->mb.cache.i_cbp_top;
216 x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (h->mb.i_cbp_luma >> 0) & 1 );
217 x264_cabac_encode_decision( cb, 76 - ((cbp >> 0) & 1) - ((cbp_t >> 2) & 2), (h->mb.i_cbp_luma >> 1) & 1 );
218 x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp << 1) & 2), (h->mb.i_cbp_luma >> 2) & 1 );
219 x264_cabac_encode_decision_noup( cb, 76 - ((cbp >> 2) & 1) - ((cbp >> 0) & 2), (h->mb.i_cbp_luma >> 3) & 1 );
222 static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
224 int cbp_a = h->mb.cache.i_cbp_left & 0x30;
225 int cbp_b = h->mb.cache.i_cbp_top & 0x30;
228 if( cbp_a && h->mb.cache.i_cbp_left != -1 ) ctx++;
229 if( cbp_b && h->mb.cache.i_cbp_top != -1 ) ctx+=2;
230 if( h->mb.i_cbp_chroma == 0 )
231 x264_cabac_encode_decision_noup( cb, 77 + ctx, 0 );
234 x264_cabac_encode_decision_noup( cb, 77 + ctx, 1 );
237 if( cbp_a == 0x20 ) ctx++;
238 if( cbp_b == 0x20 ) ctx += 2;
239 x264_cabac_encode_decision_noup( cb, 77 + ctx, h->mb.i_cbp_chroma > 1 );
243 static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
245 int i_mbn_xy = h->mb.i_mb_prev_xy;
246 int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
249 /* Avoid writing a delta quant if we have an empty i16x16 block, e.g. in a completely flat background area */
250 if( h->mb.i_type == I_16x16 && !h->mb.cbp[h->mb.i_mb_xy] )
253 h->mb.i_qp = h->mb.i_last_qp;
258 /* No need to test for PCM / SKIP */
259 ctx = h->mb.i_last_dqp &&
260 ( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) );
264 int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
265 /* dqp is interpreted modulo 52 */
266 if( val >= 51 && val != 52 )
270 x264_cabac_encode_decision( cb, 60 + ctx, 1 );
274 x264_cabac_encode_decision_noup( cb, 60 + ctx, 0 );
278 void x264_cabac_mb_skip( x264_t *h, int b_skip )
280 int ctx = (h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ))
281 + (h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ))
282 + (h->sh.i_type == SLICE_TYPE_P ? 11 : 24);
283 x264_cabac_encode_decision( &h->cabac, ctx, b_skip );
287 static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
289 if( i_sub == D_L0_8x8 )
291 x264_cabac_encode_decision( cb, 21, 1 );
294 x264_cabac_encode_decision( cb, 21, 0 );
295 if( i_sub == D_L0_8x4 )
296 x264_cabac_encode_decision( cb, 22, 0 );
299 x264_cabac_encode_decision( cb, 22, 1 );
300 x264_cabac_encode_decision( cb, 23, i_sub == D_L0_4x8 );
304 static inline void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
306 if( i_sub == D_DIRECT_8x8 )
308 x264_cabac_encode_decision( cb, 36, 0 );
311 x264_cabac_encode_decision( cb, 36, 1 );
312 if( i_sub == D_BI_8x8 )
314 x264_cabac_encode_decision( cb, 37, 1 );
315 x264_cabac_encode_decision( cb, 38, 0 );
316 x264_cabac_encode_decision( cb, 39, 0 );
317 x264_cabac_encode_decision( cb, 39, 0 );
320 x264_cabac_encode_decision( cb, 37, 0 );
321 x264_cabac_encode_decision( cb, 39, i_sub == D_L1_8x8 );
324 static inline void x264_cabac_mb_transform_size( x264_t *h, x264_cabac_t *cb )
326 int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
327 x264_cabac_encode_decision_noup( cb, ctx, h->mb.b_transform_8x8 );
330 static void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
332 const int i8 = x264_scan8[idx];
333 const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
334 const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
335 int i_ref = h->mb.cache.ref[i_list][i8];
338 if( i_refa > 0 && !h->mb.cache.skip[i8 - 1] )
340 if( i_refb > 0 && !h->mb.cache.skip[i8 - 8] )
345 x264_cabac_encode_decision( cb, 54 + ctx, 1 );
349 x264_cabac_encode_decision( cb, 54 + ctx, 0 );
352 static inline void x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd, int ctx )
354 const int i_abs = abs( mvd );
355 const int ctxbase = l ? 47 : 40;
359 x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
362 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
365 x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
366 x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
367 x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
368 cb->f8_bits_encoded += cabac_size_unary[i_abs - 3][cb->state[ctxbase+6]];
369 cb->state[ctxbase+6] = cabac_transition_unary[i_abs - 3][cb->state[ctxbase+6]];
373 for( i = 1; i < i_abs; i++ )
374 x264_cabac_encode_decision( cb, ctxbase + i + 2, 1 );
375 x264_cabac_encode_decision( cb, ctxbase + i_abs + 2, 0 );
376 x264_cabac_encode_bypass( cb, mvd < 0 );
381 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
382 x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
383 x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
384 x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
385 cb->f8_bits_encoded += cabac_size_5ones[cb->state[ctxbase+6]];
386 cb->state[ctxbase+6] = cabac_transition_5ones[cb->state[ctxbase+6]];
387 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
390 static const uint8_t ctxes[8] = { 3,4,5,6,6,6,6,6 };
393 x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
396 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
397 for( i = 1; i < i_abs; i++ )
398 x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
399 x264_cabac_encode_decision( cb, ctxbase + ctxes[i_abs-1], 0 );
400 x264_cabac_encode_bypass( cb, mvd < 0 );
404 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
405 for( i = 1; i < 9; i++ )
406 x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
407 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
408 x264_cabac_encode_bypass( cb, mvd < 0 );
413 static NOINLINE uint32_t x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width )
415 DECLARE_ALIGNED_4( int16_t mvp[2] );
420 x264_mb_predict_mv( h, i_list, idx, width, mvp );
421 mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
422 mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
423 amvd = x264_cabac_amvd_sum(h->mb.cache.mvd[i_list][x264_scan8[idx] - 1],
424 h->mb.cache.mvd[i_list][x264_scan8[idx] - 8]);
427 x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx, amvd&0xFFFF );
428 x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy, amvd>>16 );
430 return pack16to32_mask(mdx,mdy);
433 #define x264_cabac_mb_mvd(h,cb,i_list,idx,width,height)\
436 uint32_t mvd = x264_cabac_mb_mvd(h,cb,i_list,idx,width);\
437 x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mvd );\
440 static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i )
442 switch( h->mb.i_sub_partition[i] )
445 x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
448 x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 2, 1 );
449 x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 2, 1 );
452 x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 2 );
453 x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 2 );
456 x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 1 );
457 x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 1 );
458 x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 1, 1 );
459 x264_cabac_mb_mvd( h, cb, 0, 4*i+3, 1, 1 );
466 /* i_ctxBlockCat: 0-> DC 16x16 i_idx = 0
467 * 1-> AC 16x16 i_idx = luma4x4idx
468 * 2-> Luma4x4 i_idx = luma4x4idx
469 * 3-> DC Chroma i_idx = iCbCr
470 * 4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
471 * 5-> Luma8x8 i_idx = luma8x8idx
474 static int ALWAYS_INLINE x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx, int b_intra )
484 /* no need to test for skip/pcm */
485 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
486 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
487 if( x264_constant_p(b_intra) && !b_intra )
488 return 85 + 4*i_cat + ((2*i_nzb + i_nza)&0x7f);
491 i_nza &= 0x7f + (b_intra << 7);
492 i_nzb &= 0x7f + (b_intra << 7);
493 return 85 + 4*i_cat + 2*!!i_nzb + !!i_nza;
496 i_nza = (h->mb.cache.i_cbp_left >> 8) & 1;
497 i_nzb = (h->mb.cache.i_cbp_top >> 8) & 1;
498 return 85 + 4*i_cat + 2*i_nzb + i_nza;
500 /* no need to test skip/pcm */
502 i_nza = h->mb.cache.i_cbp_left != -1 ? (h->mb.cache.i_cbp_left >> (9 + i_idx)) & 1 : b_intra;
503 i_nzb = h->mb.cache.i_cbp_top != -1 ? (h->mb.cache.i_cbp_top >> (9 + i_idx)) & 1 : b_intra;
504 return 85 + 4*i_cat + 2*i_nzb + i_nza;
511 static const uint16_t significant_coeff_flag_offset[2][6] = {
512 { 105, 120, 134, 149, 152, 402 },
513 { 277, 292, 306, 321, 324, 436 }
515 static const uint16_t last_coeff_flag_offset[2][6] = {
516 { 166, 181, 195, 210, 213, 417 },
517 { 338, 353, 367, 382, 385, 451 }
519 static const uint16_t coeff_abs_level_m1_offset[6] =
520 { 227, 237, 247, 257, 266, 426 };
521 static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
523 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
524 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
525 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
526 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
528 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
529 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
530 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
531 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
533 static const uint8_t last_coeff_flag_offset_8x8[63] = {
534 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
536 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
537 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
540 // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
541 // 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
542 /* map node ctx => cabac ctx for level=1 */
543 static const int coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
544 /* map node ctx => cabac ctx for level>1 */
545 static const int coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
546 static const uint8_t coeff_abs_level_transition[2][8] = {
547 /* update node ctx after coding a level=1 */
548 { 1, 2, 3, 3, 4, 5, 6, 7 },
549 /* update node ctx after coding a level>1 */
550 { 4, 4, 4, 4, 5, 6, 7, 7 }
552 static const int count_cat_m1[5] = {15, 14, 15, 3, 14};
555 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l )
557 const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
558 const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
559 const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
560 const uint8_t *significant_coeff_flag_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
561 int i_coeff_abs_m1[64];
562 int i_coeff_sign[64];
568 i_last = h->quantf.coeff_last[i_ctxBlockCat](l);
570 #define WRITE_SIGMAP( l8x8 )\
575 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;\
576 i_coeff_sign[i_coeff] = l[i] < 0;\
578 x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? significant_coeff_flag_offset[i] : i), 1 );\
581 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 1 );\
585 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 0 );\
588 x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? significant_coeff_flag_offset[i] : i), 0 );\
590 if( i == i_count_m1 )\
592 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;\
593 i_coeff_sign[i_coeff] = l[i] < 0;\
599 if( i_ctxBlockCat == DCT_LUMA_8x8 )
601 const int i_count_m1 = 63;
606 const int i_count_m1 = count_cat_m1[i_ctxBlockCat];
615 /* write coeff_abs - 1 */
616 i_prefix = X264_MIN( i_coeff_abs_m1[i_coeff], 14 );
617 ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
621 x264_cabac_encode_decision( cb, ctx, 1 );
622 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
623 for( i = 0; i < i_prefix - 1; i++ )
624 x264_cabac_encode_decision( cb, ctx, 1 );
626 x264_cabac_encode_decision( cb, ctx, 0 );
628 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i_coeff] - 14 );
630 node_ctx = coeff_abs_level_transition[1][node_ctx];
634 x264_cabac_encode_decision( cb, ctx, 0 );
635 node_ctx = coeff_abs_level_transition[0][node_ctx];
638 x264_cabac_encode_bypass( cb, i_coeff_sign[i_coeff] );
639 } while( i_coeff > 0 );
641 #define block_residual_write_cabac_8x8( h, cb, l ) block_residual_write_cabac( h, cb, DCT_LUMA_8x8, l )
645 /* Faster RDO by merging sigmap and level coding. Note that for 8x8dct
646 * this is slightly incorrect because the sigmap is not reversible
647 * (contexts are repeated). However, there is nearly no quality penalty
648 * for this (~0.001db) and the speed boost (~30%) is worth it. */
649 static void ALWAYS_INLINE block_residual_write_cabac_internal( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l, int b_8x8 )
651 const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
652 const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
653 const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
654 const uint8_t *significant_coeff_flag_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
655 int i_last, i_coeff_abs, ctx, i, node_ctx;
657 i_last = h->quantf.coeff_last[i_ctxBlockCat](l);
659 i_coeff_abs = abs(l[i_last]);
660 ctx = coeff_abs_level1_ctx[0] + i_ctx_level;
662 if( i_last != (b_8x8 ? 63 : count_cat_m1[i_ctxBlockCat]) )
664 x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?significant_coeff_flag_offset[i_last]:i_last), 1 );
665 x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i_last]:i_last), 1 );
668 if( i_coeff_abs > 1 )
670 x264_cabac_encode_decision( cb, ctx, 1 );
671 ctx = coeff_abs_levelgt1_ctx[0] + i_ctx_level;
672 if( i_coeff_abs < 15 )
674 cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
675 cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
679 cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
680 cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
681 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
683 node_ctx = coeff_abs_level_transition[1][0];
687 x264_cabac_encode_decision( cb, ctx, 0 );
688 node_ctx = coeff_abs_level_transition[0][0];
689 x264_cabac_encode_bypass( cb, 0 ); // sign
692 for( i = i_last-1 ; i >= 0; i-- )
696 i_coeff_abs = abs(l[i]);
697 x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?significant_coeff_flag_offset[i]:i), 1 );
698 x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i]:i), 0 );
699 ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
701 if( i_coeff_abs > 1 )
703 x264_cabac_encode_decision( cb, ctx, 1 );
704 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
705 if( i_coeff_abs < 15 )
707 cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
708 cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
712 cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
713 cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
714 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
716 node_ctx = coeff_abs_level_transition[1][node_ctx];
720 x264_cabac_encode_decision( cb, ctx, 0 );
721 node_ctx = coeff_abs_level_transition[0][node_ctx];
722 x264_cabac_encode_bypass( cb, 0 );
726 x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?significant_coeff_flag_offset[i]:i), 0 );
730 static void block_residual_write_cabac_8x8( x264_t *h, x264_cabac_t *cb, int16_t *l )
732 block_residual_write_cabac_internal( h, cb, DCT_LUMA_8x8, l, 1 );
734 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l )
736 block_residual_write_cabac_internal( h, cb, i_ctxBlockCat, l, 0 );
740 #define block_residual_write_cabac_cbf( h, cb, i_ctxBlockCat, i_idx, l, b_intra ) \
742 int ctxidxinc = x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx, b_intra ); \
743 if( h->mb.cache.non_zero_count[x264_scan8[i_idx]] )\
745 x264_cabac_encode_decision( cb, ctxidxinc, 1 );\
746 block_residual_write_cabac( h, cb, i_ctxBlockCat, l ); \
749 x264_cabac_encode_decision( cb, ctxidxinc, 0 );\
752 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
754 const int i_mb_type = h->mb.i_type;
759 const int i_mb_pos_start = x264_cabac_pos( cb );
763 /* Write the MB type */
764 x264_cabac_mb_type( h, cb );
767 if( i_mb_type == I_PCM )
769 i_mb_pos_tex = x264_cabac_pos( cb );
770 h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
772 memcpy( cb->p, h->mb.pic.p_fenc[0], 256 );
774 for( i = 0; i < 8; i++ )
775 memcpy( cb->p + i*8, h->mb.pic.p_fenc[1] + i*FENC_STRIDE, 8 );
777 for( i = 0; i < 8; i++ )
778 memcpy( cb->p + i*8, h->mb.pic.p_fenc[2] + i*FENC_STRIDE, 8 );
782 cb->i_range = 0x01FE;
784 cb->i_bytes_outstanding = 0;
786 /* if PCM is chosen, we need to store reconstructed frame data */
787 h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc[0], FENC_STRIDE, 16 );
788 h->mc.copy[PIXEL_8x8] ( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE, 8 );
789 h->mc.copy[PIXEL_8x8] ( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE, 8 );
791 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
796 if( IS_INTRA( i_mb_type ) )
798 if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
799 x264_cabac_mb_transform_size( h, cb );
801 if( i_mb_type != I_16x16 )
803 int di = h->mb.b_transform_8x8 ? 4 : 1;
804 for( i = 0; i < 16; i += di )
806 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
807 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
808 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
812 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
814 else if( i_mb_type == P_L0 )
816 if( h->mb.i_partition == D_16x16 )
818 if( h->mb.pic.i_fref[0] > 1 )
820 x264_cabac_mb_ref( h, cb, 0, 0 );
822 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
824 else if( h->mb.i_partition == D_16x8 )
826 if( h->mb.pic.i_fref[0] > 1 )
828 x264_cabac_mb_ref( h, cb, 0, 0 );
829 x264_cabac_mb_ref( h, cb, 0, 8 );
831 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
832 x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
834 else //if( h->mb.i_partition == D_8x16 )
836 if( h->mb.pic.i_fref[0] > 1 )
838 x264_cabac_mb_ref( h, cb, 0, 0 );
839 x264_cabac_mb_ref( h, cb, 0, 4 );
841 x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
842 x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
845 else if( i_mb_type == P_8x8 )
848 for( i = 0; i < 4; i++ )
849 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i] );
852 if( h->mb.pic.i_fref[0] > 1 )
854 x264_cabac_mb_ref( h, cb, 0, 0 );
855 x264_cabac_mb_ref( h, cb, 0, 4 );
856 x264_cabac_mb_ref( h, cb, 0, 8 );
857 x264_cabac_mb_ref( h, cb, 0, 12 );
860 for( i = 0; i < 4; i++ )
861 x264_cabac_mb8x8_mvd( h, cb, i );
863 else if( i_mb_type == B_8x8 )
866 for( i = 0; i < 4; i++ )
867 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i] );
870 if( h->mb.pic.i_fref[0] > 1 )
871 for( i = 0; i < 4; i++ )
872 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
873 x264_cabac_mb_ref( h, cb, 0, 4*i );
875 if( h->mb.pic.i_fref[1] > 1 )
876 for( i = 0; i < 4; i++ )
877 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
878 x264_cabac_mb_ref( h, cb, 1, 4*i );
880 for( i = 0; i < 4; i++ )
881 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
882 x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
884 for( i = 0; i < 4; i++ )
885 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
886 x264_cabac_mb_mvd( h, cb, 1, 4*i, 2, 2 );
888 else if( i_mb_type != B_DIRECT )
891 const uint8_t (*b_list)[2] = x264_mb_type_list_table[i_mb_type];
892 if( h->mb.pic.i_fref[0] > 1 )
895 x264_cabac_mb_ref( h, cb, 0, 0 );
896 if( b_list[0][1] && h->mb.i_partition != D_16x16 )
897 x264_cabac_mb_ref( h, cb, 0, 8 >> (h->mb.i_partition == D_8x16) );
899 if( h->mb.pic.i_fref[1] > 1 )
902 x264_cabac_mb_ref( h, cb, 1, 0 );
903 if( b_list[1][1] && h->mb.i_partition != D_16x16 )
904 x264_cabac_mb_ref( h, cb, 1, 8 >> (h->mb.i_partition == D_8x16) );
906 for( i_list = 0; i_list < 2; i_list++ )
908 if( h->mb.i_partition == D_16x16 )
910 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
912 else if( h->mb.i_partition == D_16x8 )
914 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
915 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
917 else //if( h->mb.i_partition == D_8x16 )
919 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
920 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
926 i_mb_pos_tex = x264_cabac_pos( cb );
927 h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
930 if( i_mb_type != I_16x16 )
932 x264_cabac_mb_cbp_luma( h, cb );
933 x264_cabac_mb_cbp_chroma( h, cb );
936 if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
938 x264_cabac_mb_transform_size( h, cb );
941 if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
943 const int b_intra = IS_INTRA( i_mb_type );
944 x264_cabac_mb_qp_delta( h, cb );
947 if( i_mb_type == I_16x16 )
950 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_DC, 24, h->dct.luma16x16_dc, 1 );
953 if( h->mb.i_cbp_luma != 0 )
954 for( i = 0; i < 16; i++ )
955 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 1 );
957 else if( h->mb.b_transform_8x8 )
959 for( i = 0; i < 4; i++ )
960 if( h->mb.i_cbp_luma & ( 1 << i ) )
961 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i] );
965 for( i = 0; i < 16; i++ )
966 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
967 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], b_intra );
970 if( h->mb.i_cbp_chroma&0x03 ) /* Chroma DC residual present */
972 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], b_intra );
973 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], b_intra );
974 if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
975 for( i = 16; i < 24; i++ )
976 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, b_intra );
981 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
986 /*****************************************************************************
987 * RD only; doesn't generate a valid bitstream
988 * doesn't write cbp or chroma dc (I don't know how much this matters)
989 * doesn't write ref (never varies between calls, so no point in doing so)
990 * only writes subpartition for p8x8, needed for sub-8x8 mode decision RDO
991 * works on all partition sizes except 16x16
992 *****************************************************************************/
993 static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
995 const int i_mb_type = h->mb.i_type;
996 int b_8x16 = h->mb.i_partition == D_8x16;
999 if( i_mb_type == P_8x8 )
1001 x264_cabac_mb8x8_mvd( h, cb, i8 );
1002 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
1004 else if( i_mb_type == P_L0 )
1005 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
1006 else if( i_mb_type > B_DIRECT && i_mb_type < B_8x8 )
1008 if( x264_mb_type_list_table[ i_mb_type ][0][!!i8] ) x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
1009 if( x264_mb_type_list_table[ i_mb_type ][1][!!i8] ) x264_cabac_mb_mvd( h, cb, 1, 4*i8, 4>>b_8x16, 2<<b_8x16 );
1011 else //if( i_mb_type == B_8x8 )
1013 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1014 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 2 );
1015 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1016 x264_cabac_mb_mvd( h, cb, 1, 4*i8, 2, 2 );
1019 for( j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1021 if( h->mb.i_cbp_luma & (1 << i8) )
1023 if( h->mb.b_transform_8x8 )
1024 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
1028 for( i4 = 0; i4 < 4; i4++ )
1029 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 0 );
1033 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 0 );
1034 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 0 );
1036 i8 += x264_pixel_size[i_pixel].h >> 3;
1040 static void x264_subpartition_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_pixel )
1042 int b_8x4 = i_pixel == PIXEL_8x4;
1043 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 0 );
1044 if( i_pixel == PIXEL_4x4 )
1046 x264_cabac_mb_mvd( h, cb, 0, i4, 1, 1 );
1050 x264_cabac_mb_mvd( h, cb, 0, i4, 1+b_8x4, 2-b_8x4 );
1051 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+2-b_8x4, h->dct.luma4x4[i4+2-b_8x4], 0 );
1055 static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1057 const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1058 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1059 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1060 x264_cabac_mb_cbp_luma( h, cb );
1061 if( h->mb.i_cbp_luma & (1 << i8) )
1062 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
1065 static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1067 const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1068 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1069 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1070 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 1 );
1073 static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
1075 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
1076 x264_cabac_mb_cbp_chroma( h, cb );
1077 if( h->mb.i_cbp_chroma > 0 )
1079 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], 1 );
1080 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], 1 );
1082 if( h->mb.i_cbp_chroma == 2 )
1085 for( i = 16; i < 24; i++ )
1086 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 1 );