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_neighbour & MB_LEFT) && h->mb.i_mb_type_left != I_4x4 )
81 if( (h->mb.i_neighbour & MB_TOP) && 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_neighbour & MB_LEFT) && h->mb.i_mb_type_left != B_SKIP && h->mb.i_mb_type_left != B_DIRECT )
115 if( (h->mb.i_neighbour & MB_TOP) && 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] =
149 0x31, 0x29, 0x4, /* L0 L0 */
150 0x35, 0x2d, 0, /* L0 L1 */
151 0x43, 0x63, 0, /* L0 BI */
152 0x3d, 0x2f, 0, /* L1 L0 */
153 0x39, 0x25, 0x6, /* L1 L1 */
154 0x53, 0x73, 0, /* L1 BI */
155 0x4b, 0x6b, 0, /* BI L0 */
156 0x5b, 0x7b, 0, /* BI L1 */
157 0x47, 0x67, 0x21 /* BI BI */
160 const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
161 int bits = i_mb_bits[idx];
163 x264_cabac_encode_decision_noup( cb, 27+3, bits&1 );
164 x264_cabac_encode_decision( cb, 27+5-(bits&1), (bits>>1)&1 ); bits >>= 2;
167 x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
168 x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
169 x264_cabac_encode_decision( cb, 27+5, bits&1 ); bits >>= 1;
171 x264_cabac_encode_decision_noup( cb, 27+5, bits&1 );
177 static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
179 if( i_pred == i_mode )
180 x264_cabac_encode_decision( cb, 68, 1 );
183 x264_cabac_encode_decision( cb, 68, 0 );
184 if( i_mode > i_pred )
186 x264_cabac_encode_decision( cb, 69, (i_mode )&0x01 );
187 x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
188 x264_cabac_encode_decision( cb, 69, (i_mode >> 2) );
192 static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
194 const int i_mode = x264_mb_pred_mode8x8c_fix[h->mb.i_chroma_pred_mode];
197 /* No need to test for I4x4 or I_16x16 as cache_save handle that */
198 if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_left_xy] != 0 )
200 if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_top_xy] != 0 )
203 x264_cabac_encode_decision_noup( cb, 64 + ctx, i_mode > 0 );
206 x264_cabac_encode_decision( cb, 64 + 3, i_mode > 1 );
208 x264_cabac_encode_decision_noup( cb, 64 + 3, i_mode > 2 );
212 static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
214 int cbp = h->mb.i_cbp_luma;
215 int cbp_l = h->mb.cache.i_cbp_left;
216 int cbp_t = h->mb.cache.i_cbp_top;
217 x264_cabac_encode_decision ( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (cbp >> 0) & 1 );
218 x264_cabac_encode_decision ( cb, 76 - ((cbp >> 0) & 1) - ((cbp_t >> 2) & 2), (cbp >> 1) & 1 );
219 x264_cabac_encode_decision ( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp << 1) & 2), (cbp >> 2) & 1 );
220 x264_cabac_encode_decision_noup( cb, 76 - ((cbp >> 2) & 1) - ((cbp >> 0) & 2), (cbp >> 3) & 1 );
223 static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
225 int cbp_a = h->mb.cache.i_cbp_left & 0x30;
226 int cbp_b = h->mb.cache.i_cbp_top & 0x30;
229 if( cbp_a && h->mb.cache.i_cbp_left != -1 ) ctx++;
230 if( cbp_b && h->mb.cache.i_cbp_top != -1 ) ctx+=2;
231 if( h->mb.i_cbp_chroma == 0 )
232 x264_cabac_encode_decision_noup( cb, 77 + ctx, 0 );
235 x264_cabac_encode_decision_noup( cb, 77 + ctx, 1 );
238 if( cbp_a == 0x20 ) ctx++;
239 if( cbp_b == 0x20 ) ctx += 2;
240 x264_cabac_encode_decision_noup( cb, 77 + ctx, h->mb.i_cbp_chroma >> 1 );
244 static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
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 /* Since, per the above, empty-CBP I16x16 blocks never have delta quants,
259 * we don't have to check for them. */
260 ctx = h->mb.i_last_dqp && h->mb.cbp[h->mb.i_mb_prev_xy];
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_neighbour & MB_LEFT) && !IS_SKIP( h->mb.i_mb_type_left ))
281 + ((h->mb.i_neighbour & MB_TOP) && !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 ALWAYS_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 ALWAYS_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];
337 if( i_refa > 0 && !h->mb.cache.skip[i8 - 1] )
339 if( i_refb > 0 && !h->mb.cache.skip[i8 - 8] )
342 for( int i_ref = h->mb.cache.ref[i_list][i8]; i_ref > 0; i_ref-- )
344 x264_cabac_encode_decision( cb, 54 + ctx, 1 );
347 x264_cabac_encode_decision( cb, 54 + ctx, 0 );
350 static ALWAYS_INLINE int x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd, int ctx )
352 const int i_abs = abs( mvd );
353 const int ctxbase = l ? 47 : 40;
356 x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
359 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
362 for( int i = 1; i < i_abs; i++ )
363 x264_cabac_encode_decision( cb, ctxbase + i + 2, 1 );
364 x264_cabac_encode_decision( cb, ctxbase + i_abs + 2, 0 );
365 x264_cabac_encode_bypass( cb, mvd < 0 );
369 x264_cabac_encode_decision( cb, ctxbase + 3, 1 );
370 x264_cabac_encode_decision( cb, ctxbase + 4, 1 );
371 x264_cabac_encode_decision( cb, ctxbase + 5, 1 );
374 cb->f8_bits_encoded += cabac_size_unary[i_abs - 3][cb->state[ctxbase+6]];
375 cb->state[ctxbase+6] = cabac_transition_unary[i_abs - 3][cb->state[ctxbase+6]];
379 cb->f8_bits_encoded += cabac_size_5ones[cb->state[ctxbase+6]];
380 cb->state[ctxbase+6] = cabac_transition_5ones[cb->state[ctxbase+6]];
381 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
386 static const uint8_t ctxes[8] = { 3,4,5,6,6,6,6,6 };
389 x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
392 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
395 for( int i = 1; i < i_abs; i++ )
396 x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
397 x264_cabac_encode_decision( cb, ctxbase + ctxes[i_abs-1], 0 );
401 for( int i = 1; i < 9; i++ )
402 x264_cabac_encode_decision( cb, ctxbase + ctxes[i-1], 1 );
403 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
405 x264_cabac_encode_bypass( cb, mvd < 0 );
408 /* Since we don't need to keep track of MVDs larger than 33, just cap the value.
409 * This lets us store MVDs as 8-bit values instead of 16-bit. */
410 return X264_MIN( i_abs, 33 );
413 static NOINLINE uint16_t x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width )
415 ALIGNED_4( int16_t mvp[2] );
419 x264_mb_predict_mv( h, i_list, idx, width, mvp );
420 mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
421 mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
422 uint16_t amvd = x264_cabac_mvd_sum(h->mb.cache.mvd[i_list][x264_scan8[idx] - 1],
423 h->mb.cache.mvd[i_list][x264_scan8[idx] - 8]);
426 mdx = x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx, amvd&0xFF );
427 mdy = x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy, amvd>>8 );
429 return pack8to16(mdx,mdy);
432 #define x264_cabac_mb_mvd(h,cb,i_list,idx,width,height)\
435 uint16_t mvd = x264_cabac_mb_mvd(h,cb,i_list,idx,width);\
436 x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, mvd );\
439 static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i )
441 switch( h->mb.i_sub_partition[i] )
444 x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
447 x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 2, 1 );
448 x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 2, 1 );
451 x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 2 );
452 x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 2 );
455 x264_cabac_mb_mvd( h, cb, 0, 4*i+0, 1, 1 );
456 x264_cabac_mb_mvd( h, cb, 0, 4*i+1, 1, 1 );
457 x264_cabac_mb_mvd( h, cb, 0, 4*i+2, 1, 1 );
458 x264_cabac_mb_mvd( h, cb, 0, 4*i+3, 1, 1 );
465 /* i_ctxBlockCat: 0-> DC 16x16 i_idx = 0
466 * 1-> AC 16x16 i_idx = luma4x4idx
467 * 2-> Luma4x4 i_idx = luma4x4idx
468 * 3-> DC Chroma i_idx = iCbCr
469 * 4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
470 * 5-> Luma8x8 i_idx = luma8x8idx
473 static int ALWAYS_INLINE x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx, int b_intra )
483 /* no need to test for skip/pcm */
484 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
485 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
486 if( x264_constant_p(b_intra) && !b_intra )
487 return 85 + 4*i_cat + ((2*i_nzb + i_nza)&0x7f);
490 i_nza &= 0x7f + (b_intra << 7);
491 i_nzb &= 0x7f + (b_intra << 7);
492 return 85 + 4*i_cat + 2*!!i_nzb + !!i_nza;
495 i_nza = (h->mb.cache.i_cbp_left >> 8) & 1;
496 i_nzb = (h->mb.cache.i_cbp_top >> 8) & 1;
497 return 85 + 4*i_cat + 2*i_nzb + i_nza;
499 /* no need to test skip/pcm */
501 i_nza = h->mb.cache.i_cbp_left != -1 ? (h->mb.cache.i_cbp_left >> (9 + i_idx)) & 1 : b_intra;
502 i_nzb = h->mb.cache.i_cbp_top != -1 ? (h->mb.cache.i_cbp_top >> (9 + i_idx)) & 1 : b_intra;
503 return 85 + 4*i_cat + 2*i_nzb + i_nza;
510 static const uint16_t significant_coeff_flag_offset[2][6] = {
511 { 105, 120, 134, 149, 152, 402 },
512 { 277, 292, 306, 321, 324, 436 }
514 static const uint16_t last_coeff_flag_offset[2][6] = {
515 { 166, 181, 195, 210, 213, 417 },
516 { 338, 353, 367, 382, 385, 451 }
518 static const uint16_t coeff_abs_level_m1_offset[6] =
519 { 227, 237, 247, 257, 266, 426 };
520 static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
522 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
523 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
524 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
525 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
527 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
528 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
529 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
530 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
532 static const uint8_t last_coeff_flag_offset_8x8[63] = {
533 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
535 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
536 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
539 // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
540 // 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
541 /* map node ctx => cabac ctx for level=1 */
542 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
543 /* map node ctx => cabac ctx for level>1 */
544 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
545 static const uint8_t coeff_abs_level_transition[2][8] = {
546 /* update node ctx after coding a level=1 */
547 { 1, 2, 3, 3, 4, 5, 6, 7 },
548 /* update node ctx after coding a level>1 */
549 { 4, 4, 4, 4, 5, 6, 7, 7 }
551 static const uint8_t count_cat_m1[5] = {15, 14, 15, 3, 14};
554 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l )
556 const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
557 const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
558 const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
559 const uint8_t *sig_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
560 int i_coeff_abs_m1[64];
561 int i_coeff_sign[64];
567 i_last = h->quantf.coeff_last[i_ctxBlockCat](l);
569 #define WRITE_SIGMAP( l8x8 )\
574 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;\
575 i_coeff_sign[i_coeff] = l[i] < 0;\
577 x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? sig_offset[i] : i), 1 );\
580 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 1 );\
584 x264_cabac_encode_decision( cb, i_ctx_last + (l8x8 ? last_coeff_flag_offset_8x8[i] : i), 0 );\
587 x264_cabac_encode_decision( cb, i_ctx_sig + (l8x8 ? sig_offset[i] : i), 0 );\
589 if( i == i_count_m1 )\
591 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;\
592 i_coeff_sign[i_coeff] = l[i] < 0;\
598 if( i_ctxBlockCat == DCT_LUMA_8x8 )
600 const int i_count_m1 = 63;
605 const int i_count_m1 = count_cat_m1[i_ctxBlockCat];
614 /* write coeff_abs - 1 */
615 i_prefix = X264_MIN( i_coeff_abs_m1[i_coeff], 14 );
616 ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
620 x264_cabac_encode_decision( cb, ctx, 1 );
621 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
622 for( i = 0; i < i_prefix - 1; i++ )
623 x264_cabac_encode_decision( cb, ctx, 1 );
625 x264_cabac_encode_decision( cb, ctx, 0 );
627 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i_coeff] - 14 );
629 node_ctx = coeff_abs_level_transition[1][node_ctx];
633 x264_cabac_encode_decision( cb, ctx, 0 );
634 node_ctx = coeff_abs_level_transition[0][node_ctx];
637 x264_cabac_encode_bypass( cb, i_coeff_sign[i_coeff] );
638 } while( i_coeff > 0 );
640 #define block_residual_write_cabac_8x8( h, cb, l ) block_residual_write_cabac( h, cb, DCT_LUMA_8x8, l )
644 /* Faster RDO by merging sigmap and level coding. Note that for 8x8dct
645 * this is slightly incorrect because the sigmap is not reversible
646 * (contexts are repeated). However, there is nearly no quality penalty
647 * for this (~0.001db) and the speed boost (~30%) is worth it. */
648 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 )
650 const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
651 const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
652 const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
653 const uint8_t *sig_offset = significant_coeff_flag_offset_8x8[h->mb.b_interlaced];
654 int i_last, i_coeff_abs, ctx, node_ctx;
656 i_last = h->quantf.coeff_last[i_ctxBlockCat](l);
658 i_coeff_abs = abs(l[i_last]);
659 ctx = coeff_abs_level1_ctx[0] + i_ctx_level;
661 if( i_last != (b_8x8 ? 63 : count_cat_m1[i_ctxBlockCat]) )
663 x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?sig_offset[i_last]:i_last), 1 );
664 x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i_last]:i_last), 1 );
667 if( i_coeff_abs > 1 )
669 x264_cabac_encode_decision( cb, ctx, 1 );
670 ctx = coeff_abs_levelgt1_ctx[0] + i_ctx_level;
671 if( i_coeff_abs < 15 )
673 cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
674 cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
678 cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
679 cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
680 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
682 node_ctx = coeff_abs_level_transition[1][0];
686 x264_cabac_encode_decision( cb, ctx, 0 );
687 node_ctx = coeff_abs_level_transition[0][0];
688 x264_cabac_encode_bypass( cb, 0 ); // sign
691 for( int i = i_last-1 ; i >= 0; i-- )
695 i_coeff_abs = abs(l[i]);
696 x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?sig_offset[i]:i), 1 );
697 x264_cabac_encode_decision( cb, i_ctx_last + (b_8x8?last_coeff_flag_offset_8x8[i]:i), 0 );
698 ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
700 if( i_coeff_abs > 1 )
702 x264_cabac_encode_decision( cb, ctx, 1 );
703 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
704 if( i_coeff_abs < 15 )
706 cb->f8_bits_encoded += cabac_size_unary[i_coeff_abs-1][cb->state[ctx]];
707 cb->state[ctx] = cabac_transition_unary[i_coeff_abs-1][cb->state[ctx]];
711 cb->f8_bits_encoded += cabac_size_unary[14][cb->state[ctx]];
712 cb->state[ctx] = cabac_transition_unary[14][cb->state[ctx]];
713 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs - 15 );
715 node_ctx = coeff_abs_level_transition[1][node_ctx];
719 x264_cabac_encode_decision( cb, ctx, 0 );
720 node_ctx = coeff_abs_level_transition[0][node_ctx];
721 x264_cabac_encode_bypass( cb, 0 );
725 x264_cabac_encode_decision( cb, i_ctx_sig + (b_8x8?sig_offset[i]:i), 0 );
729 static void block_residual_write_cabac_8x8( x264_t *h, x264_cabac_t *cb, int16_t *l )
731 block_residual_write_cabac_internal( h, cb, DCT_LUMA_8x8, l, 1 );
733 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int16_t *l )
735 block_residual_write_cabac_internal( h, cb, i_ctxBlockCat, l, 0 );
739 #define block_residual_write_cabac_cbf( h, cb, i_ctxBlockCat, i_idx, l, b_intra )\
741 int ctxidxinc = x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx, b_intra );\
742 if( h->mb.cache.non_zero_count[x264_scan8[i_idx]] )\
744 x264_cabac_encode_decision( cb, ctxidxinc, 1 );\
745 block_residual_write_cabac( h, cb, i_ctxBlockCat, l );\
748 x264_cabac_encode_decision( cb, ctxidxinc, 0 );\
751 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
753 const int i_mb_type = h->mb.i_type;
757 const int i_mb_pos_start = x264_cabac_pos( cb );
761 /* Write the MB type */
762 x264_cabac_mb_type( h, cb );
765 if( i_mb_type == I_PCM )
767 i_mb_pos_tex = x264_cabac_pos( cb );
768 h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
770 memcpy( cb->p, h->mb.pic.p_fenc[0], 256 );
772 for( int i = 0; i < 8; i++ )
773 memcpy( cb->p + i*8, h->mb.pic.p_fenc[1] + i*FENC_STRIDE, 8 );
775 for( int i = 0; i < 8; i++ )
776 memcpy( cb->p + i*8, h->mb.pic.p_fenc[2] + i*FENC_STRIDE, 8 );
780 cb->i_range = 0x01FE;
782 cb->i_bytes_outstanding = 0;
784 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
789 if( IS_INTRA( i_mb_type ) )
791 if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
792 x264_cabac_mb_transform_size( h, cb );
794 if( i_mb_type != I_16x16 )
796 int di = h->mb.b_transform_8x8 ? 4 : 1;
797 for( int i = 0; i < 16; i += di )
799 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
800 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
801 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
805 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
807 else if( i_mb_type == P_L0 )
809 if( h->mb.i_partition == D_16x16 )
811 if( h->mb.pic.i_fref[0] > 1 )
813 x264_cabac_mb_ref( h, cb, 0, 0 );
815 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
817 else if( h->mb.i_partition == D_16x8 )
819 if( h->mb.pic.i_fref[0] > 1 )
821 x264_cabac_mb_ref( h, cb, 0, 0 );
822 x264_cabac_mb_ref( h, cb, 0, 8 );
824 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
825 x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
827 else //if( h->mb.i_partition == D_8x16 )
829 if( h->mb.pic.i_fref[0] > 1 )
831 x264_cabac_mb_ref( h, cb, 0, 0 );
832 x264_cabac_mb_ref( h, cb, 0, 4 );
834 x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
835 x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
838 else if( i_mb_type == P_8x8 )
841 for( int i = 0; i < 4; i++ )
842 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i] );
845 if( h->mb.pic.i_fref[0] > 1 )
847 x264_cabac_mb_ref( h, cb, 0, 0 );
848 x264_cabac_mb_ref( h, cb, 0, 4 );
849 x264_cabac_mb_ref( h, cb, 0, 8 );
850 x264_cabac_mb_ref( h, cb, 0, 12 );
853 for( int i = 0; i < 4; i++ )
854 x264_cabac_mb8x8_mvd( h, cb, i );
856 else if( i_mb_type == B_8x8 )
859 for( int i = 0; i < 4; i++ )
860 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i] );
863 if( h->mb.pic.i_fref[0] > 1 )
864 for( int i = 0; i < 4; i++ )
865 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
866 x264_cabac_mb_ref( h, cb, 0, 4*i );
868 if( h->mb.pic.i_fref[1] > 1 )
869 for( int i = 0; i < 4; i++ )
870 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
871 x264_cabac_mb_ref( h, cb, 1, 4*i );
873 for( int i = 0; i < 4; i++ )
874 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i] ] )
875 x264_cabac_mb_mvd( h, cb, 0, 4*i, 2, 2 );
877 for( int i = 0; i < 4; i++ )
878 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i] ] )
879 x264_cabac_mb_mvd( h, cb, 1, 4*i, 2, 2 );
881 else if( i_mb_type != B_DIRECT )
884 const uint8_t (*b_list)[2] = x264_mb_type_list_table[i_mb_type];
885 if( h->mb.pic.i_fref[0] > 1 )
888 x264_cabac_mb_ref( h, cb, 0, 0 );
889 if( b_list[0][1] && h->mb.i_partition != D_16x16 )
890 x264_cabac_mb_ref( h, cb, 0, 8 >> (h->mb.i_partition == D_8x16) );
892 if( h->mb.pic.i_fref[1] > 1 )
895 x264_cabac_mb_ref( h, cb, 1, 0 );
896 if( b_list[1][1] && h->mb.i_partition != D_16x16 )
897 x264_cabac_mb_ref( h, cb, 1, 8 >> (h->mb.i_partition == D_8x16) );
899 for( i_list = 0; i_list < 2; i_list++ )
901 if( h->mb.i_partition == D_16x16 )
903 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
905 else if( h->mb.i_partition == D_16x8 )
907 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
908 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
910 else //if( h->mb.i_partition == D_8x16 )
912 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
913 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
919 i_mb_pos_tex = x264_cabac_pos( cb );
920 h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
923 if( i_mb_type != I_16x16 )
925 x264_cabac_mb_cbp_luma( h, cb );
926 x264_cabac_mb_cbp_chroma( h, cb );
929 if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
931 x264_cabac_mb_transform_size( h, cb );
934 if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
936 const int b_intra = IS_INTRA( i_mb_type );
937 x264_cabac_mb_qp_delta( h, cb );
940 if( i_mb_type == I_16x16 )
943 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_DC, 24, h->dct.luma16x16_dc, 1 );
946 if( h->mb.i_cbp_luma != 0 )
947 for( int i = 0; i < 16; i++ )
948 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 1 );
950 else if( h->mb.b_transform_8x8 )
952 for( int i = 0; i < 4; i++ )
953 if( h->mb.i_cbp_luma & ( 1 << i ) )
954 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i] );
958 for( int i = 0; i < 16; i++ )
959 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
960 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], b_intra );
963 if( h->mb.i_cbp_chroma ) /* Chroma DC residual present */
965 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], b_intra );
966 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], b_intra );
967 if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
968 for( int i = 16; i < 24; i++ )
969 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, b_intra );
974 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
979 /*****************************************************************************
980 * RD only; doesn't generate a valid bitstream
981 * doesn't write cbp or chroma dc (I don't know how much this matters)
982 * doesn't write ref (never varies between calls, so no point in doing so)
983 * only writes subpartition for p8x8, needed for sub-8x8 mode decision RDO
984 * works on all partition sizes except 16x16
985 *****************************************************************************/
986 static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
988 const int i_mb_type = h->mb.i_type;
989 int b_8x16 = h->mb.i_partition == D_8x16;
991 if( i_mb_type == P_8x8 )
993 x264_cabac_mb8x8_mvd( h, cb, i8 );
994 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
996 else if( i_mb_type == P_L0 )
997 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4>>b_8x16, 2<<b_8x16 );
998 else if( i_mb_type > B_DIRECT && i_mb_type < B_8x8 )
1000 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 );
1001 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 );
1003 else //if( i_mb_type == B_8x8 )
1005 if( x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1006 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 2 );
1007 if( x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1008 x264_cabac_mb_mvd( h, cb, 1, 4*i8, 2, 2 );
1011 for( int j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1013 if( h->mb.i_cbp_luma & (1 << i8) )
1015 if( h->mb.b_transform_8x8 )
1016 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
1018 for( int i4 = 0; i4 < 4; i4++ )
1019 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 0 );
1022 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 0 );
1023 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 0 );
1025 i8 += x264_pixel_size[i_pixel].h >> 3;
1029 static void x264_subpartition_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_pixel )
1031 int b_8x4 = i_pixel == PIXEL_8x4;
1032 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 0 );
1033 if( i_pixel == PIXEL_4x4 )
1035 x264_cabac_mb_mvd( h, cb, 0, i4, 1, 1 );
1039 x264_cabac_mb_mvd( h, cb, 0, i4, 1+b_8x4, 2-b_8x4 );
1040 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4+2-b_8x4, h->dct.luma4x4[i4+2-b_8x4], 0 );
1044 static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1046 const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1047 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1048 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1049 x264_cabac_mb_cbp_luma( h, cb );
1050 if( h->mb.i_cbp_luma & (1 << i8) )
1051 block_residual_write_cabac_8x8( h, cb, h->dct.luma8x8[i8] );
1054 static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1056 const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1057 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1058 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1059 block_residual_write_cabac_cbf( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 1 );
1062 static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
1064 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
1065 x264_cabac_mb_cbp_chroma( h, cb );
1066 if( h->mb.i_cbp_chroma > 0 )
1068 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 25, h->dct.chroma_dc[0], 1 );
1069 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_DC, 26, h->dct.chroma_dc[1], 1 );
1071 if( h->mb.i_cbp_chroma == 2 )
1072 for( int i = 16; i < 24; i++ )
1073 block_residual_write_cabac_cbf( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 1 );