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>
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.
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.
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., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
22 *****************************************************************************/
24 #include "common/common.h"
25 #include "macroblock.h"
27 static inline void x264_cabac_mb_type_intra( x264_t *h, x264_cabac_t *cb, int i_mb_type,
28 int ctx0, int ctx1, int ctx2, int ctx3, int ctx4, int ctx5 )
30 if( i_mb_type == I_4x4 || i_mb_type == I_8x8 )
32 x264_cabac_encode_decision( cb, ctx0, 0 );
34 else if( i_mb_type == I_PCM )
36 x264_cabac_encode_decision( cb, ctx0, 1 );
37 x264_cabac_encode_flush( h, cb );
41 int i_pred = x264_mb_pred_mode16x16_fix[h->mb.i_intra16x16_pred_mode];
43 x264_cabac_encode_decision( cb, ctx0, 1 );
44 x264_cabac_encode_terminal( cb );
46 x264_cabac_encode_decision( cb, ctx1, !!h->mb.i_cbp_luma );
47 if( h->mb.i_cbp_chroma == 0 )
49 x264_cabac_encode_decision( cb, ctx2, 0 );
53 x264_cabac_encode_decision( cb, ctx2, 1 );
54 x264_cabac_encode_decision( cb, ctx3, h->mb.i_cbp_chroma != 1 );
56 x264_cabac_encode_decision( cb, ctx4, i_pred>>1 );
57 x264_cabac_encode_decision( cb, ctx5, i_pred&1 );
61 static void x264_cabac_mb_type( x264_t *h, x264_cabac_t *cb )
63 const int i_mb_type = h->mb.i_type;
66 (!(h->mb.i_mb_y & 1) || IS_SKIP(h->mb.type[h->mb.i_mb_xy - h->mb.i_mb_stride])) )
68 x264_cabac_encode_decision( cb, 70 + h->mb.cache.i_neighbour_interlaced, h->mb.b_interlaced );
71 if( h->sh.i_type == SLICE_TYPE_I )
74 if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != I_4x4 )
78 if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != I_4x4 )
83 x264_cabac_mb_type_intra( h, cb, i_mb_type, 3+ctx, 3+3, 3+4, 3+5, 3+6, 3+7 );
85 else if( h->sh.i_type == SLICE_TYPE_P )
87 /* prefix: 14, suffix: 17 */
88 if( i_mb_type == P_L0 )
90 if( h->mb.i_partition == D_16x16 )
92 x264_cabac_encode_decision( cb, 14, 0 );
93 x264_cabac_encode_decision( cb, 15, 0 );
94 x264_cabac_encode_decision( cb, 16, 0 );
96 else if( h->mb.i_partition == D_16x8 )
98 x264_cabac_encode_decision( cb, 14, 0 );
99 x264_cabac_encode_decision( cb, 15, 1 );
100 x264_cabac_encode_decision( cb, 17, 1 );
102 else if( h->mb.i_partition == D_8x16 )
104 x264_cabac_encode_decision( cb, 14, 0 );
105 x264_cabac_encode_decision( cb, 15, 1 );
106 x264_cabac_encode_decision( cb, 17, 0 );
109 else if( i_mb_type == P_8x8 )
111 x264_cabac_encode_decision( cb, 14, 0 );
112 x264_cabac_encode_decision( cb, 15, 0 );
113 x264_cabac_encode_decision( cb, 16, 1 );
118 x264_cabac_encode_decision( cb, 14, 1 );
121 x264_cabac_mb_type_intra( h, cb, i_mb_type, 17+0, 17+1, 17+2, 17+2, 17+3, 17+3 );
124 else if( h->sh.i_type == SLICE_TYPE_B )
127 if( h->mb.i_mb_type_left >= 0 && h->mb.i_mb_type_left != B_SKIP && h->mb.i_mb_type_left != B_DIRECT )
131 if( h->mb.i_mb_type_top >= 0 && h->mb.i_mb_type_top != B_SKIP && h->mb.i_mb_type_top != B_DIRECT )
136 if( i_mb_type == B_DIRECT )
138 x264_cabac_encode_decision( cb, 27+ctx, 0 );
140 else if( i_mb_type == B_8x8 )
142 x264_cabac_encode_decision( cb, 27+ctx, 1 );
143 x264_cabac_encode_decision( cb, 27+3, 1 );
144 x264_cabac_encode_decision( cb, 27+4, 1 );
146 x264_cabac_encode_decision( cb, 27+5, 1 );
147 x264_cabac_encode_decision( cb, 27+5, 1 );
148 x264_cabac_encode_decision( cb, 27+5, 1 );
150 else if( IS_INTRA( i_mb_type ) )
153 x264_cabac_encode_decision( cb, 27+ctx, 1 );
154 x264_cabac_encode_decision( cb, 27+3, 1 );
155 x264_cabac_encode_decision( cb, 27+4, 1 );
157 x264_cabac_encode_decision( cb, 27+5, 1 );
158 x264_cabac_encode_decision( cb, 27+5, 0 );
159 x264_cabac_encode_decision( cb, 27+5, 1 );
162 x264_cabac_mb_type_intra( h, cb, i_mb_type, 32+0, 32+1, 32+2, 32+2, 32+3, 32+3 );
166 static const int i_mb_len[9*3] =
178 static const int i_mb_bits[9*3][7] =
180 { 1,1,0,0,0,1 }, { 1,1,0,0,1,0, }, { 1,0,0 }, /* L0 L0 */
181 { 1,1,0,1,0,1 }, { 1,1,0,1,1,0 }, {0}, /* L0 L1 */
182 { 1,1,1,0,0,0,0 }, { 1,1,1,0,0,0,1 }, {0}, /* L0 BI */
183 { 1,1,0,1,1,1 }, { 1,1,1,1,1,0 }, {0}, /* L1 L0 */
184 { 1,1,0,0,1,1 }, { 1,1,0,1,0,0 }, { 1,0,1 }, /* L1 L1 */
185 { 1,1,1,0,0,1,0 }, { 1,1,1,0,0,1,1 }, {0}, /* L1 BI */
186 { 1,1,1,0,1,0,0 }, { 1,1,1,0,1,0,1 }, {0}, /* BI L0 */
187 { 1,1,1,0,1,1,0 }, { 1,1,1,0,1,1,1 }, {0}, /* BI L1 */
188 { 1,1,1,1,0,0,0 }, { 1,1,1,1,0,0,1 }, { 1,1,0,0,0,0 }, /* BI BI */
191 const int idx = (i_mb_type - B_L0_L0) * 3 + (h->mb.i_partition - D_16x8);
194 x264_cabac_encode_decision( cb, 27+ctx, i_mb_bits[idx][0] );
195 x264_cabac_encode_decision( cb, 27+3, i_mb_bits[idx][1] );
196 x264_cabac_encode_decision( cb, 27+5-i_mb_bits[idx][1], i_mb_bits[idx][2] );
197 for( i = 3; i < i_mb_len[idx]; i++ )
198 x264_cabac_encode_decision( cb, 27+5, i_mb_bits[idx][i] );
203 x264_log(h, X264_LOG_ERROR, "unknown SLICE_TYPE unsupported in x264_macroblock_write_cabac\n" );
207 static void x264_cabac_mb_intra4x4_pred_mode( x264_cabac_t *cb, int i_pred, int i_mode )
209 if( i_pred == i_mode )
211 /* b_prev_intra4x4_pred_mode */
212 x264_cabac_encode_decision( cb, 68, 1 );
216 /* b_prev_intra4x4_pred_mode */
217 x264_cabac_encode_decision( cb, 68, 0 );
218 if( i_mode > i_pred )
222 x264_cabac_encode_decision( cb, 69, (i_mode )&0x01 );
223 x264_cabac_encode_decision( cb, 69, (i_mode >> 1)&0x01 );
224 x264_cabac_encode_decision( cb, 69, (i_mode >> 2)&0x01 );
228 static void x264_cabac_mb_intra_chroma_pred_mode( x264_t *h, x264_cabac_t *cb )
230 const int i_mode = x264_mb_pred_mode8x8c_fix[ h->mb.i_chroma_pred_mode ];
233 /* No need to test for I4x4 or I_16x16 as cache_save handle that */
234 if( (h->mb.i_neighbour & MB_LEFT) && h->mb.chroma_pred_mode[h->mb.i_mb_xy - 1] != 0 )
238 if( (h->mb.i_neighbour & MB_TOP) && h->mb.chroma_pred_mode[h->mb.i_mb_top_xy] != 0 )
243 x264_cabac_encode_decision( cb, 64 + ctx, i_mode > 0 );
246 x264_cabac_encode_decision( cb, 64 + 3, i_mode > 1 );
249 x264_cabac_encode_decision( cb, 64 + 3, i_mode > 2 );
254 static void x264_cabac_mb_cbp_luma( x264_t *h, x264_cabac_t *cb )
256 int cbp = h->mb.i_cbp_luma;
257 int cbp_l = h->mb.i_neighbour & MB_LEFT ? h->mb.cbp[h->mb.i_mb_xy - 1] : -1;
258 int cbp_t = h->mb.i_neighbour & MB_TOP ? h->mb.cbp[h->mb.i_mb_top_xy] : -1;
259 x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 1) & 1) - ((cbp_t >> 1) & 2), (h->mb.i_cbp_luma >> 0) & 1 );
260 x264_cabac_encode_decision( cb, 76 - ((cbp >> 0) & 1) - ((cbp_t >> 2) & 2), (h->mb.i_cbp_luma >> 1) & 1 );
261 x264_cabac_encode_decision( cb, 76 - ((cbp_l >> 3) & 1) - ((cbp << 1) & 2), (h->mb.i_cbp_luma >> 2) & 1 );
262 x264_cabac_encode_decision( cb, 76 - ((cbp >> 2) & 1) - ((cbp >> 0) & 2), (h->mb.i_cbp_luma >> 3) & 1 );
265 static void x264_cabac_mb_cbp_chroma( x264_t *h, x264_cabac_t *cb )
271 /* No need to test for SKIP/PCM */
272 if( h->mb.i_neighbour & MB_LEFT )
274 cbp_a = (h->mb.cbp[h->mb.i_mb_xy - 1] >> 4)&0x3;
277 if( h->mb.i_neighbour & MB_TOP )
279 cbp_b = (h->mb.cbp[h->mb.i_mb_top_xy] >> 4)&0x3;
283 if( cbp_a > 0 ) ctx++;
284 if( cbp_b > 0 ) ctx += 2;
285 if( h->mb.i_cbp_chroma == 0 )
287 x264_cabac_encode_decision( cb, 77 + ctx, 0 );
291 x264_cabac_encode_decision( cb, 77 + ctx, 1 );
294 if( cbp_a == 2 ) ctx++;
295 if( cbp_b == 2 ) ctx += 2;
296 x264_cabac_encode_decision( cb, 77 + ctx, h->mb.i_cbp_chroma > 1 );
300 /* TODO check it with != qp per mb */
301 static void x264_cabac_mb_qp_delta( x264_t *h, x264_cabac_t *cb )
303 int i_mbn_xy = h->mb.i_mb_prev_xy;
304 int i_dqp = h->mb.i_qp - h->mb.i_last_qp;
307 /* Avoid writing a delta quant if we have an empty i16x16 block, e.g. in a completely flat background area */
308 if( h->mb.i_type == I_16x16 && !h->mb.cbp[h->mb.i_mb_xy] )
311 h->mb.i_qp = h->mb.i_last_qp;
316 /* No need to test for PCM / SKIP */
317 if( h->mb.i_last_dqp &&
318 ( h->mb.type[i_mbn_xy] == I_16x16 || (h->mb.cbp[i_mbn_xy]&0x3f) ) )
325 int val = i_dqp <= 0 ? (-2*i_dqp) : (2*i_dqp - 1);
326 /* dqp is interpreted modulo 52 */
327 if( val >= 51 && val != 52 )
331 x264_cabac_encode_decision( cb, 60 + ctx, 1 );
338 x264_cabac_encode_decision( cb, 60 + ctx, 0 );
342 void x264_cabac_mb_skip( x264_t *h, int b_skip )
344 int ctx = (h->mb.i_mb_type_left >= 0 && !IS_SKIP( h->mb.i_mb_type_left ))
345 + (h->mb.i_mb_type_top >= 0 && !IS_SKIP( h->mb.i_mb_type_top ))
346 + (h->sh.i_type == SLICE_TYPE_P ? 11 : 24);
347 x264_cabac_encode_decision( &h->cabac, ctx, b_skip );
351 static inline void x264_cabac_mb_sub_p_partition( x264_cabac_t *cb, int i_sub )
353 if( i_sub == D_L0_8x8 )
355 x264_cabac_encode_decision( cb, 21, 1 );
357 else if( i_sub == D_L0_8x4 )
359 x264_cabac_encode_decision( cb, 21, 0 );
360 x264_cabac_encode_decision( cb, 22, 0 );
362 else if( i_sub == D_L0_4x8 )
364 x264_cabac_encode_decision( cb, 21, 0 );
365 x264_cabac_encode_decision( cb, 22, 1 );
366 x264_cabac_encode_decision( cb, 23, 1 );
368 else if( i_sub == D_L0_4x4 )
370 x264_cabac_encode_decision( cb, 21, 0 );
371 x264_cabac_encode_decision( cb, 22, 1 );
372 x264_cabac_encode_decision( cb, 23, 0 );
376 static NOINLINE void x264_cabac_mb_sub_b_partition( x264_cabac_t *cb, int i_sub )
378 static const uint8_t part_bits[12][7] = {
379 {6,1,1,1,0,1,1}, // D_L0_4x4
380 {5,1,1,0,0,1}, // D_L0_8x4
381 {5,1,1,0,1,0}, // D_L0_4x8
382 {3,1,0,0}, // D_L0_8x8
383 {5,1,1,1,1,0}, // D_L1_4x4
384 {5,1,1,0,1,1}, // D_L1_8x4
385 {6,1,1,1,0,0,0}, // D_L1_4x8
386 {3,1,0,1}, // D_L1_8x8
387 {5,1,1,1,1,1}, // D_BI_4x4
388 {6,1,1,1,0,0,1}, // D_BI_8x4
389 {6,1,1,1,0,1,0}, // D_BI_4x8
390 {5,1,1,0,0,0}, // D_BI_8x8
393 if( i_sub == D_DIRECT_8x8 )
395 x264_cabac_encode_decision( cb, 36, 0 );
398 len = part_bits[i_sub][0];
399 x264_cabac_encode_decision( cb, 36, part_bits[i_sub][1] );
400 x264_cabac_encode_decision( cb, 37, part_bits[i_sub][2] );
402 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][3] );
405 x264_cabac_encode_decision( cb, 38, part_bits[i_sub][3] );
406 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][4] );
407 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][5] );
409 x264_cabac_encode_decision( cb, 39, part_bits[i_sub][6] );
413 static inline void x264_cabac_mb_transform_size( x264_t *h, x264_cabac_t *cb )
415 int ctx = 399 + h->mb.cache.i_neighbour_transform_size;
416 x264_cabac_encode_decision( cb, ctx, h->mb.b_transform_8x8 );
419 static inline void x264_cabac_mb_ref( x264_t *h, x264_cabac_t *cb, int i_list, int idx )
421 const int i8 = x264_scan8[idx];
422 const int i_refa = h->mb.cache.ref[i_list][i8 - 1];
423 const int i_refb = h->mb.cache.ref[i_list][i8 - 8];
424 int i_ref = h->mb.cache.ref[i_list][i8];
427 if( i_refa > 0 && !h->mb.cache.skip[i8 - 1])
429 if( i_refb > 0 && !h->mb.cache.skip[i8 - 8])
434 x264_cabac_encode_decision( cb, 54 + ctx, 1 );
442 x264_cabac_encode_decision( cb, 54 + ctx, 0 );
447 static inline void x264_cabac_mb_mvd_cpn( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int l, int mvd )
449 static const uint8_t transition[7] = { 3,3,3,4,5,6,6 };
450 const int amvd = abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 1][l] ) +
451 abs( h->mb.cache.mvd[i_list][x264_scan8[idx] - 8][l] );
452 const int i_abs = abs( mvd );
453 const int i_prefix = X264_MIN( i_abs, 9 );
454 const int ctxbase = l ? 47 : 40;
455 int ctx = (amvd>2) + (amvd>32);
458 for( i = 0; i < i_prefix; i++ )
460 x264_cabac_encode_decision( cb, ctxbase + ctx, 1 );
461 ctx = transition[ctx];
464 x264_cabac_encode_decision( cb, ctxbase + ctx, 0 );
466 x264_cabac_encode_ue_bypass( cb, 3, i_abs - 9 );
470 x264_cabac_encode_bypass( cb, mvd < 0 );
473 static inline void x264_cabac_mb_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int idx, int width, int height )
475 DECLARE_ALIGNED_4( int16_t mvp[2] );
479 x264_mb_predict_mv( h, i_list, idx, width, mvp );
480 mdx = h->mb.cache.mv[i_list][x264_scan8[idx]][0] - mvp[0];
481 mdy = h->mb.cache.mv[i_list][x264_scan8[idx]][1] - mvp[1];
484 x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 0, mdx );
485 x264_cabac_mb_mvd_cpn( h, cb, i_list, idx, 1, mdy );
488 x264_macroblock_cache_mvd( h, block_idx_x[idx], block_idx_y[idx], width, height, i_list, pack16to32_mask(mdx,mdy) );
491 static inline void x264_cabac_mb8x8_mvd( x264_t *h, x264_cabac_t *cb, int i_list, int i )
493 if( !x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
496 switch( h->mb.i_sub_partition[i] )
501 x264_cabac_mb_mvd( h, cb, i_list, 4*i, 2, 2 );
506 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 2, 1 );
507 x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 2, 1 );
512 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 2 );
513 x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 2 );
518 x264_cabac_mb_mvd( h, cb, i_list, 4*i+0, 1, 1 );
519 x264_cabac_mb_mvd( h, cb, i_list, 4*i+1, 1, 1 );
520 x264_cabac_mb_mvd( h, cb, i_list, 4*i+2, 1, 1 );
521 x264_cabac_mb_mvd( h, cb, i_list, 4*i+3, 1, 1 );
526 static int x264_cabac_mb_cbf_ctxidxinc( x264_t *h, int i_cat, int i_idx )
528 /* i_ctxBlockCat: 0-> DC 16x16 i_idx = 0
529 * 1-> AC 16x16 i_idx = luma4x4idx
530 * 2-> Luma4x4 i_idx = luma4x4idx
531 * 3-> DC Chroma i_idx = iCbCr
532 * 4-> AC Chroma i_idx = 4 * iCbCr + chroma4x4idx
533 * 5-> Luma8x8 i_idx = luma8x8idx
541 if( i_cat == DCT_LUMA_DC )
543 if( h->mb.i_neighbour & MB_LEFT )
545 i_mba_xy = h->mb.i_mb_xy - 1;
546 i_nza = h->mb.cbp[i_mba_xy] & 0x100;
548 if( h->mb.i_neighbour & MB_TOP )
550 i_mbb_xy = h->mb.i_mb_top_xy;
551 i_nzb = h->mb.cbp[i_mbb_xy] & 0x100;
554 else if( i_cat == DCT_LUMA_AC || i_cat == DCT_LUMA_4x4 )
556 if( i_idx & ~10 ) // block_idx_x > 0
557 i_mba_xy = h->mb.i_mb_xy;
558 else if( h->mb.i_neighbour & MB_LEFT )
559 i_mba_xy = h->mb.i_mb_xy - 1;
561 if( i_idx & ~5 ) // block_idx_y > 0
562 i_mbb_xy = h->mb.i_mb_xy;
563 else if( h->mb.i_neighbour & MB_TOP )
564 i_mbb_xy = h->mb.i_mb_top_xy;
566 /* no need to test for skip/pcm */
568 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
570 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
572 else if( i_cat == DCT_CHROMA_DC )
574 /* no need to test skip/pcm */
575 if( h->mb.i_neighbour & MB_LEFT )
577 i_mba_xy = h->mb.i_mb_xy - 1;
578 i_nza = h->mb.cbp[i_mba_xy] & (0x200 << i_idx);
580 if( h->mb.i_neighbour & MB_TOP )
582 i_mbb_xy = h->mb.i_mb_top_xy;
583 i_nzb = h->mb.cbp[i_mbb_xy] & (0x200 << i_idx);
586 else if( i_cat == DCT_CHROMA_AC )
589 i_mba_xy = h->mb.i_mb_xy;
590 else if( h->mb.i_neighbour & MB_LEFT )
591 i_mba_xy = h->mb.i_mb_xy - 1;
594 i_mbb_xy = h->mb.i_mb_xy;
595 else if( h->mb.i_neighbour & MB_TOP )
596 i_mbb_xy = h->mb.i_mb_top_xy;
598 /* no need to test skip/pcm */
600 i_nza = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 1];
602 i_nzb = h->mb.cache.non_zero_count[x264_scan8[i_idx] - 8];
605 if( IS_INTRA( h->mb.i_type ) )
607 i_nza |= i_mba_xy < 0;
608 i_nzb |= i_mbb_xy < 0;
611 return 4*i_cat + 2*!!i_nzb + !!i_nza;
615 static const uint16_t significant_coeff_flag_offset[2][6] = {
616 { 105, 120, 134, 149, 152, 402 },
617 { 277, 292, 306, 321, 324, 436 }
619 static const uint16_t last_coeff_flag_offset[2][6] = {
620 { 166, 181, 195, 210, 213, 417 },
621 { 338, 353, 367, 382, 385, 451 }
623 static const uint16_t coeff_abs_level_m1_offset[6] =
624 { 227, 237, 247, 257, 266, 426 };
625 static const uint8_t significant_coeff_flag_offset_8x8[2][63] =
627 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
628 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
629 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
630 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
632 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
633 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
634 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
635 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14
637 static const uint8_t last_coeff_flag_offset_8x8[63] = {
638 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
639 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
640 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
641 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
643 static const uint8_t identity[16] =
644 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
646 // node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
647 // 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
648 /* map node ctx => cabac ctx for level=1 */
649 static const int coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
650 /* map node ctx => cabac ctx for level>1 */
651 static const int coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
652 static const uint8_t coeff_abs_level_transition[2][8] = {
653 /* update node ctx after coding a level=1 */
654 { 1, 2, 3, 3, 4, 5, 6, 7 },
655 /* update node ctx after coding a level>1 */
656 { 4, 4, 4, 4, 5, 6, 7, 7 }
659 static void block_residual_write_cabac( x264_t *h, x264_cabac_t *cb, int i_ctxBlockCat, int i_idx, int16_t *l, int i_count )
661 const int i_ctx_sig = significant_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
662 const int i_ctx_last = last_coeff_flag_offset[h->mb.b_interlaced][i_ctxBlockCat];
663 const int i_ctx_level = coeff_abs_level_m1_offset[i_ctxBlockCat];
665 int i_coeff_abs_m1[64];
666 int UNUSED i_coeff_sign[64];
673 const uint8_t *significant_coeff_flag_offset;
674 const uint8_t *last_coeff_flag_offset;
676 /* yes this is always aligned, and l[-1] exists in the cases where it's used (ac) */
677 for( j = i_count - 4; j >= -1; j -= 4 )
678 if( *(uint64_t*)(l+j) )
683 /* coded block flag */
684 int ctx = 85 + x264_cabac_mb_cbf_ctxidxinc( h, i_ctxBlockCat, i_idx );
686 x264_cabac_encode_decision( cb, ctx, 1 );
689 x264_cabac_encode_decision( cb, ctx, 0 );
694 significant_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
695 ? significant_coeff_flag_offset_8x8[h->mb.b_interlaced]
697 last_coeff_flag_offset = (i_ctxBlockCat == DCT_LUMA_8x8)
698 ? last_coeff_flag_offset_8x8 : identity;
700 for( i = j; i < j+4; i++)
704 i_sigmap_size = X264_MIN( i_last+1, i_count-1 );
706 for( i = 0; i < i_sigmap_size; i++ )
710 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
712 i_coeff_sign[i_coeff] = l[i] < 0;
715 x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 1 );
716 x264_cabac_encode_decision( cb, i_ctx_last + last_coeff_flag_offset[i], i == i_last );
719 x264_cabac_encode_decision( cb, i_ctx_sig + significant_coeff_flag_offset[i], 0 );
724 i_coeff_abs_m1[i_coeff] = abs(l[i]) - 1;
726 i_coeff_sign[i_coeff] = l[i] < 0;
736 /* write coeff_abs - 1 */
737 i_prefix = X264_MIN( i_coeff_abs_m1[i_coeff], 14 );
738 ctx = coeff_abs_level1_ctx[node_ctx] + i_ctx_level;
742 x264_cabac_encode_decision( cb, ctx, 1 );
743 ctx = coeff_abs_levelgt1_ctx[node_ctx] + i_ctx_level;
745 cb->f8_bits_encoded += cabac_prefix_size[i_prefix][cb->state[ctx]];
746 cb->state[ctx] = cabac_prefix_transition[i_prefix][cb->state[ctx]];
748 for( j = 0; j < i_prefix - 1; j++ )
749 x264_cabac_encode_decision( cb, ctx, 1 );
751 x264_cabac_encode_decision( cb, ctx, 0 );
754 x264_cabac_encode_ue_bypass( cb, 0, i_coeff_abs_m1[i_coeff] - 14 );
756 node_ctx = coeff_abs_level_transition[1][node_ctx];
760 x264_cabac_encode_decision( cb, ctx, 0 );
761 node_ctx = coeff_abs_level_transition[0][node_ctx];
763 x264_cabac_encode_bypass( cb, 0 ); // sign
768 x264_cabac_encode_bypass( cb, i_coeff_sign[i_coeff] );
770 } while( i_coeff > 0 );
775 void x264_macroblock_write_cabac( x264_t *h, x264_cabac_t *cb )
777 const int i_mb_type = h->mb.i_type;
782 const int i_mb_pos_start = x264_cabac_pos( cb );
786 /* Write the MB type */
787 x264_cabac_mb_type( h, cb );
790 if( i_mb_type == I_PCM )
792 i_mb_pos_tex = x264_cabac_pos( cb );
793 h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
795 memcpy( cb->p, h->mb.pic.p_fenc[0], 256 );
797 for( i = 0; i < 8; i++ )
798 memcpy( cb->p + i*8, h->mb.pic.p_fenc[1] + i*FENC_STRIDE, 8 );
800 for( i = 0; i < 8; i++ )
801 memcpy( cb->p + i*8, h->mb.pic.p_fenc[2] + i*FENC_STRIDE, 8 );
805 cb->i_range = 0x01FE;
807 cb->i_bytes_outstanding = 0;
809 /* if PCM is chosen, we need to store reconstructed frame data */
810 h->mc.copy[PIXEL_16x16]( h->mb.pic.p_fdec[0], FDEC_STRIDE, h->mb.pic.p_fenc[0], FENC_STRIDE, 16 );
811 h->mc.copy[PIXEL_8x8] ( h->mb.pic.p_fdec[1], FDEC_STRIDE, h->mb.pic.p_fenc[1], FENC_STRIDE, 8 );
812 h->mc.copy[PIXEL_8x8] ( h->mb.pic.p_fdec[2], FDEC_STRIDE, h->mb.pic.p_fenc[2], FENC_STRIDE, 8 );
814 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
819 if( IS_INTRA( i_mb_type ) )
821 if( h->pps->b_transform_8x8_mode && i_mb_type != I_16x16 )
822 x264_cabac_mb_transform_size( h, cb );
824 if( i_mb_type != I_16x16 )
826 int di = (i_mb_type == I_8x8) ? 4 : 1;
827 for( i = 0; i < 16; i += di )
829 const int i_pred = x264_mb_predict_intra4x4_mode( h, i );
830 const int i_mode = x264_mb_pred_mode4x4_fix( h->mb.cache.intra4x4_pred_mode[x264_scan8[i]] );
831 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
835 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
837 else if( i_mb_type == P_L0 )
839 if( h->mb.i_partition == D_16x16 )
841 if( h->mb.pic.i_fref[0] > 1 )
843 x264_cabac_mb_ref( h, cb, 0, 0 );
845 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 4 );
847 else if( h->mb.i_partition == D_16x8 )
849 if( h->mb.pic.i_fref[0] > 1 )
851 x264_cabac_mb_ref( h, cb, 0, 0 );
852 x264_cabac_mb_ref( h, cb, 0, 8 );
854 x264_cabac_mb_mvd( h, cb, 0, 0, 4, 2 );
855 x264_cabac_mb_mvd( h, cb, 0, 8, 4, 2 );
857 else if( h->mb.i_partition == D_8x16 )
859 if( h->mb.pic.i_fref[0] > 1 )
861 x264_cabac_mb_ref( h, cb, 0, 0 );
862 x264_cabac_mb_ref( h, cb, 0, 4 );
864 x264_cabac_mb_mvd( h, cb, 0, 0, 2, 4 );
865 x264_cabac_mb_mvd( h, cb, 0, 4, 2, 4 );
868 else if( i_mb_type == P_8x8 )
871 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[0] );
872 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[1] );
873 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[2] );
874 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[3] );
877 if( h->mb.pic.i_fref[0] > 1 )
879 x264_cabac_mb_ref( h, cb, 0, 0 );
880 x264_cabac_mb_ref( h, cb, 0, 4 );
881 x264_cabac_mb_ref( h, cb, 0, 8 );
882 x264_cabac_mb_ref( h, cb, 0, 12 );
885 for( i = 0; i < 4; i++ )
886 x264_cabac_mb8x8_mvd( h, cb, 0, i );
888 else if( i_mb_type == B_8x8 )
891 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[0] );
892 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[1] );
893 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[2] );
894 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[3] );
897 for( i_list = 0; i_list < 2; i_list++ )
899 if( ( i_list ? h->mb.pic.i_fref[1] : h->mb.pic.i_fref[0] ) == 1 )
901 for( i = 0; i < 4; i++ )
902 if( x264_mb_partition_listX_table[i_list][ h->mb.i_sub_partition[i] ] )
903 x264_cabac_mb_ref( h, cb, i_list, 4*i );
906 for( i = 0; i < 4; i++ )
907 x264_cabac_mb8x8_mvd( h, cb, 0, i );
908 for( i = 0; i < 4; i++ )
909 x264_cabac_mb8x8_mvd( h, cb, 1, i );
911 else if( i_mb_type != B_DIRECT )
916 /* init ref list utilisations */
917 for( i = 0; i < 2; i++ )
919 b_list[0][i] = x264_mb_type_list0_table[i_mb_type][i];
920 b_list[1][i] = x264_mb_type_list1_table[i_mb_type][i];
923 for( i_list = 0; i_list < 2; i_list++ )
925 const int i_ref_max = i_list == 0 ? h->mb.pic.i_fref[0] : h->mb.pic.i_fref[1];
929 if( h->mb.i_partition == D_16x16 )
931 if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
933 else if( h->mb.i_partition == D_16x8 )
935 if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
936 if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 8 );
938 else if( h->mb.i_partition == D_8x16 )
940 if( b_list[i_list][0] ) x264_cabac_mb_ref( h, cb, i_list, 0 );
941 if( b_list[i_list][1] ) x264_cabac_mb_ref( h, cb, i_list, 4 );
945 for( i_list = 0; i_list < 2; i_list++ )
947 if( h->mb.i_partition == D_16x16 )
949 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 4 );
951 else if( h->mb.i_partition == D_16x8 )
953 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 4, 2 );
954 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 8, 4, 2 );
956 else if( h->mb.i_partition == D_8x16 )
958 if( b_list[i_list][0] ) x264_cabac_mb_mvd( h, cb, i_list, 0, 2, 4 );
959 if( b_list[i_list][1] ) x264_cabac_mb_mvd( h, cb, i_list, 4, 2, 4 );
965 i_mb_pos_tex = x264_cabac_pos( cb );
966 h->stat.frame.i_mv_bits += i_mb_pos_tex - i_mb_pos_start;
969 if( i_mb_type != I_16x16 )
971 x264_cabac_mb_cbp_luma( h, cb );
972 x264_cabac_mb_cbp_chroma( h, cb );
975 if( x264_mb_transform_8x8_allowed( h ) && h->mb.i_cbp_luma )
977 x264_cabac_mb_transform_size( h, cb );
980 if( h->mb.i_cbp_luma > 0 || h->mb.i_cbp_chroma > 0 || i_mb_type == I_16x16 )
982 x264_cabac_mb_qp_delta( h, cb );
985 if( i_mb_type == I_16x16 )
988 block_residual_write_cabac( h, cb, DCT_LUMA_DC, 0, h->dct.luma16x16_dc, 16 );
991 if( h->mb.i_cbp_luma != 0 )
992 for( i = 0; i < 16; i++ )
993 block_residual_write_cabac( h, cb, DCT_LUMA_AC, i, h->dct.luma4x4[i]+1, 15 );
995 else if( h->mb.b_transform_8x8 )
997 for( i = 0; i < 4; i++ )
998 if( h->mb.i_cbp_luma & ( 1 << i ) )
999 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i, h->dct.luma8x8[i], 64 );
1003 for( i = 0; i < 16; i++ )
1004 if( h->mb.i_cbp_luma & ( 1 << ( i / 4 ) ) )
1005 block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i, h->dct.luma4x4[i], 16 );
1008 if( h->mb.i_cbp_chroma &0x03 ) /* Chroma DC residual present */
1010 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
1011 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
1013 if( h->mb.i_cbp_chroma&0x02 ) /* Chroma AC residual present */
1015 for( i = 16; i < 24; i++ )
1016 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );
1021 h->stat.frame.i_tex_bits += x264_cabac_pos( cb ) - i_mb_pos_tex;
1026 /*****************************************************************************
1027 * RD only; doesn't generate a valid bitstream
1028 * doesn't write cbp or chroma dc (I don't know how much this matters)
1029 * works on all partition sizes except 16x16
1030 * for sub8x8, call once per 8x8 block
1031 *****************************************************************************/
1032 static void x264_partition_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_pixel )
1034 const int i_mb_type = h->mb.i_type;
1037 if( i_mb_type == P_8x8 )
1039 x264_cabac_mb_sub_p_partition( cb, h->mb.i_sub_partition[i8] );
1040 if( h->mb.pic.i_fref[0] > 1 )
1041 x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1042 x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1044 else if( i_mb_type == P_L0 )
1046 if( h->mb.pic.i_fref[0] > 1 )
1047 x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1048 if( h->mb.i_partition == D_16x8 )
1049 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 4, 2 );
1051 x264_cabac_mb_mvd( h, cb, 0, 4*i8, 2, 4 );
1053 else if( i_mb_type == B_8x8 )
1055 x264_cabac_mb_sub_b_partition( cb, h->mb.i_sub_partition[i8] );
1057 if( h->mb.pic.i_fref[0] > 1
1058 && x264_mb_partition_listX_table[0][ h->mb.i_sub_partition[i8] ] )
1059 x264_cabac_mb_ref( h, cb, 0, 4*i8 );
1060 if( h->mb.pic.i_fref[1] > 1
1061 && x264_mb_partition_listX_table[1][ h->mb.i_sub_partition[i8] ] )
1062 x264_cabac_mb_ref( h, cb, 1, 4*i8 );
1064 x264_cabac_mb8x8_mvd( h, cb, 0, i8 );
1065 x264_cabac_mb8x8_mvd( h, cb, 1, i8 );
1069 x264_log(h, X264_LOG_ERROR, "invalid/unhandled mb_type\n" );
1073 for( j = (i_pixel < PIXEL_8x8); j >= 0; j-- )
1075 if( h->mb.i_cbp_luma & (1 << i8) )
1077 if( h->mb.b_transform_8x8 )
1078 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, i8, h->dct.luma8x8[i8], 64 );
1082 for( i4 = 0; i4 < 4; i4++ )
1083 block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4+i8*4, h->dct.luma4x4[i4+i8*4], 16 );
1087 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 16+i8, h->dct.luma4x4[16+i8]+1, 15 );
1088 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, 20+i8, h->dct.luma4x4[20+i8]+1, 15 );
1090 i8 += x264_pixel_size[i_pixel].h >> 3;
1094 static void x264_partition_i8x8_size_cabac( x264_t *h, x264_cabac_t *cb, int i8, int i_mode )
1096 const int i_pred = x264_mb_predict_intra4x4_mode( h, 4*i8 );
1097 const int nnz = array_non_zero(h->dct.luma8x8[i8]);
1098 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1099 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1102 block_residual_write_cabac( h, cb, DCT_LUMA_8x8, 4*i8, h->dct.luma8x8[i8], 64 );
1103 *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4]] = 0x0101;
1104 *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4+2]] = 0x0101;
1108 *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4]] = 0;
1109 *(uint16_t*)&h->mb.cache.non_zero_count[x264_scan8[i8*4+2]] = 0;
1113 static void x264_partition_i4x4_size_cabac( x264_t *h, x264_cabac_t *cb, int i4, int i_mode )
1115 const int i_pred = x264_mb_predict_intra4x4_mode( h, i4 );
1116 i_mode = x264_mb_pred_mode4x4_fix( i_mode );
1117 x264_cabac_mb_intra4x4_pred_mode( cb, i_pred, i_mode );
1118 block_residual_write_cabac( h, cb, DCT_LUMA_4x4, i4, h->dct.luma4x4[i4], 16 );
1119 h->mb.cache.non_zero_count[x264_scan8[i4]] = array_non_zero( h->dct.luma4x4[i4] );
1122 static void x264_i8x8_chroma_size_cabac( x264_t *h, x264_cabac_t *cb )
1124 x264_cabac_mb_intra_chroma_pred_mode( h, cb );
1125 x264_cabac_mb_cbp_chroma( h, cb );
1126 if( h->mb.i_cbp_chroma > 0 )
1128 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 0, h->dct.chroma_dc[0], 4 );
1129 block_residual_write_cabac( h, cb, DCT_CHROMA_DC, 1, h->dct.chroma_dc[1], 4 );
1131 if( h->mb.i_cbp_chroma == 2 )
1134 for( i = 16; i < 24; i++ )
1135 block_residual_write_cabac( h, cb, DCT_CHROMA_AC, i, h->dct.luma4x4[i]+1, 15 );