4 * Copyright (C) 2012 - 2013 Guillaume Martres
5 * Copyright (C) 2012 - 2013 Gildas Cocherel
7 * This file is part of Libav.
9 * Libav is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * Libav 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 GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with Libav; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "libavutil/attributes.h"
25 #include "libavutil/common.h"
27 #include "cabac_functions.h"
30 #define CABAC_MAX_BIN 31
33 * number of bin by SyntaxElement.
35 av_unused static const int8_t num_bins_in_se[] = {
39 0, // sao_band_position
42 0, // end_of_slice_flag
43 3, // split_coding_unit_flag
44 1, // cu_transquant_bypass_flag
50 1, // prev_intra_luma_pred_mode
52 0, // rem_intra_luma_pred_mode
53 2, // intra_chroma_pred_mode
59 2, // abs_mvd_greater0_flag
60 2, // abs_mvd_greater1_flag
64 1, // no_residual_data_flag
65 3, // split_transform_flag
68 2, // transform_skip_flag[][]
69 18, // last_significant_coeff_x_prefix
70 18, // last_significant_coeff_y_prefix
71 0, // last_significant_coeff_x_suffix
72 0, // last_significant_coeff_y_suffix
73 4, // significant_coeff_group_flag
74 42, // significant_coeff_flag
75 24, // coeff_abs_level_greater1_flag
76 6, // coeff_abs_level_greater2_flag
77 0, // coeff_abs_level_remaining
82 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
84 static const int elem_offset[sizeof(num_bins_in_se)] = {
132 * Indexed by init_type
134 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
139 // split_coding_unit_flag
141 // cu_transquant_bypass_flag
151 // prev_intra_luma_pred_mode
153 // intra_chroma_pred_mode
160 CNU, CNU, CNU, CNU, CNU,
165 // abs_mvd_greater1_flag
167 // abs_mvd_greater1_flag
171 // no_residual_data_flag
173 // split_transform_flag
179 // transform_skip_flag
181 // last_significant_coeff_x_prefix
182 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
184 // last_significant_coeff_y_prefix
185 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
187 // significant_coeff_group_flag
189 // significant_coeff_flag
190 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153,
191 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
192 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
193 // coeff_abs_level_greater1_flag
194 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107,
195 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
196 // coeff_abs_level_greater2_flag
197 138, 153, 136, 167, 152, 152, },
202 // split_coding_unit_flag
204 // cu_transquant_bypass_flag
214 // prev_intra_luma_pred_mode
216 // intra_chroma_pred_mode
228 // abs_mvd_greater1_flag
230 // abs_mvd_greater1_flag
234 // no_residual_data_flag
236 // split_transform_flag
242 // transform_skip_flag
244 // last_significant_coeff_x_prefix
245 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
247 // last_significant_coeff_y_prefix
248 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
250 // significant_coeff_group_flag
252 // significant_coeff_flag
253 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153,
254 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
255 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
256 // coeff_abs_level_greater1_flag
257 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
258 136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
259 // coeff_abs_level_greater2_flag
260 107, 167, 91, 122, 107, 167, },
265 // split_coding_unit_flag
267 // cu_transquant_bypass_flag
277 // prev_intra_luma_pred_mode
279 // intra_chroma_pred_mode
291 // abs_mvd_greater1_flag
293 // abs_mvd_greater1_flag
297 // no_residual_data_flag
299 // split_transform_flag
305 // transform_skip_flag
307 // last_significant_coeff_x_prefix
308 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
310 // last_significant_coeff_y_prefix
311 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
313 // significant_coeff_group_flag
315 // significant_coeff_flag
316 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153,
317 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
318 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
319 // coeff_abs_level_greater1_flag
320 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
321 136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
322 // coeff_abs_level_greater2_flag
323 107, 167, 91, 107, 107, 167, },
326 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
328 if (s->ps.pps->entropy_coding_sync_enabled_flag &&
329 (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
330 (s->ps.sps->ctb_width == 2 &&
331 ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
332 memcpy(s->cabac_state, s->HEVClc.cabac_state, HEVC_CONTEXTS);
336 static void load_states(HEVCContext *s)
338 memcpy(s->HEVClc.cabac_state, s->cabac_state, HEVC_CONTEXTS);
341 static void cabac_reinit(HEVCLocalContext *lc)
343 skip_bytes(&lc->cc, 0);
346 static void cabac_init_decoder(HEVCContext *s)
348 GetBitContext *gb = &s->HEVClc.gb;
351 ff_init_cabac_decoder(&s->HEVClc.cc,
352 gb->buffer + get_bits_count(gb) / 8,
353 (get_bits_left(gb) + 7) / 8);
356 static void cabac_init_state(HEVCContext *s)
358 int init_type = 2 - s->sh.slice_type;
361 if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE)
364 for (i = 0; i < HEVC_CONTEXTS; i++) {
365 int init_value = init_values[init_type][i];
366 int m = (init_value >> 4) * 5 - 45;
367 int n = ((init_value & 15) << 3) - 16;
368 int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
372 pre = 124 + (pre & 1);
373 s->HEVClc.cabac_state[i] = pre;
377 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
379 if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
380 cabac_init_decoder(s);
381 if (s->sh.dependent_slice_segment_flag == 0 ||
382 (s->ps.pps->tiles_enabled_flag &&
383 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
386 if (!s->sh.first_slice_in_pic_flag &&
387 s->ps.pps->entropy_coding_sync_enabled_flag) {
388 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
389 if (s->ps.sps->ctb_width == 1)
391 else if (s->sh.dependent_slice_segment_flag == 1)
396 if (s->ps.pps->tiles_enabled_flag &&
397 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
398 cabac_reinit(&s->HEVClc);
401 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
402 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
403 get_cabac_terminate(&s->HEVClc.cc);
404 cabac_reinit(&s->HEVClc);
406 if (s->ps.sps->ctb_width == 1)
415 #define GET_CABAC(ctx) get_cabac(&s->HEVClc.cc, &s->HEVClc.cabac_state[ctx])
417 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
419 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
422 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
424 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
427 if (!get_cabac_bypass(&s->HEVClc.cc))
432 int ff_hevc_sao_band_position_decode(HEVCContext *s)
435 int value = get_cabac_bypass(&s->HEVClc.cc);
437 for (i = 0; i < 4; i++)
438 value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
442 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
445 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
447 while (i < length && get_cabac_bypass(&s->HEVClc.cc))
452 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
454 return get_cabac_bypass(&s->HEVClc.cc);
457 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
459 int ret = get_cabac_bypass(&s->HEVClc.cc) << 1;
460 ret |= get_cabac_bypass(&s->HEVClc.cc);
464 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
466 return get_cabac_terminate(&s->HEVClc.cc);
469 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
471 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
474 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
476 int min_cb_width = s->ps.sps->min_cb_width;
478 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
479 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
481 if (s->HEVClc.ctb_left_flag || x0b)
482 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
483 if (s->HEVClc.ctb_up_flag || y0b)
484 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
486 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
489 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
495 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
499 if (prefix_val >= 5) {
501 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
502 suffix_val += 1 << k;
505 if (k == CABAC_MAX_BIN)
506 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
509 suffix_val += get_cabac_bypass(&s->HEVClc.cc) << k;
511 return prefix_val + suffix_val;
514 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
516 return get_cabac_bypass(&s->HEVClc.cc);
519 int ff_hevc_pred_mode_decode(HEVCContext *s)
521 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
524 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
526 int inc = 0, depth_left = 0, depth_top = 0;
527 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
528 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
529 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
530 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
532 if (s->HEVClc.ctb_left_flag || x0b)
533 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
534 if (s->HEVClc.ctb_up_flag || y0b)
535 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
537 inc += (depth_left > ct_depth);
538 inc += (depth_top > ct_depth);
540 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
543 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
545 if (GET_CABAC(elem_offset[PART_MODE])) // 1
547 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
548 if (s->HEVClc.cu.pred_mode == MODE_INTRA) // 0
550 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
552 if (log2_cb_size == 3) // 00
554 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
556 return PART_NxN; // 000
559 if (!s->ps.sps->amp_enabled_flag) {
560 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
565 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
566 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
568 if (get_cabac_bypass(&s->HEVClc.cc)) // 0101
570 return PART_2NxnU; // 0100
573 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
575 if (get_cabac_bypass(&s->HEVClc.cc)) // 0001
577 return PART_nLx2N; // 0000
580 int ff_hevc_pcm_flag_decode(HEVCContext *s)
582 return get_cabac_terminate(&s->HEVClc.cc);
585 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
587 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
590 int ff_hevc_mpm_idx_decode(HEVCContext *s)
593 while (i < 2 && get_cabac_bypass(&s->HEVClc.cc))
598 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
601 int value = get_cabac_bypass(&s->HEVClc.cc);
603 for (i = 0; i < 4; i++)
604 value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
608 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
611 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
614 ret = get_cabac_bypass(&s->HEVClc.cc) << 1;
615 ret |= get_cabac_bypass(&s->HEVClc.cc);
619 int ff_hevc_merge_idx_decode(HEVCContext *s)
621 int i = GET_CABAC(elem_offset[MERGE_IDX]);
624 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc.cc))
630 int ff_hevc_merge_flag_decode(HEVCContext *s)
632 return GET_CABAC(elem_offset[MERGE_FLAG]);
635 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
637 if (nPbW + nPbH == 12)
638 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
639 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc.ct.depth))
642 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
645 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
648 int max = num_ref_idx_lx - 1;
649 int max_ctx = FFMIN(max, 2);
651 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
654 while (i < max && get_cabac_bypass(&s->HEVClc.cc))
661 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
663 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
666 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
668 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
671 int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s)
673 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
676 int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s)
678 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
681 int ff_hevc_mvd_decode(HEVCContext *s)
686 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
690 if (k == CABAC_MAX_BIN)
691 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
693 ret += get_cabac_bypass(&s->HEVClc.cc) << k;
694 return get_cabac_bypass_sign(&s->HEVClc.cc, -ret);
697 int ff_hevc_mvd_sign_flag_decode(HEVCContext *s)
699 return get_cabac_bypass_sign(&s->HEVClc.cc, -1);
702 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
704 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
707 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
709 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
712 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
714 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
717 int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
719 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
722 #define LAST_SIG_COEFF(elem) \
724 int max = (log2_size << 1) - 1; \
725 int ctx_offset, ctx_shift; \
728 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2); \
729 ctx_shift = (log2_size + 1) >> 2; \
732 ctx_shift = log2_size - 2; \
735 GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset)) \
739 int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx,
742 LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_X_PREFIX)
745 int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx,
748 LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_Y_PREFIX)
751 int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s,
752 int last_significant_coeff_prefix)
755 int length = (last_significant_coeff_prefix >> 1) - 1;
756 int value = get_cabac_bypass(&s->HEVClc.cc);
758 for (i = 1; i < length; i++)
759 value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
763 int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
767 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
769 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
772 int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c,
773 int log2_trafo_size, int scan_idx, int prev_sig)
775 static const uint8_t ctx_idx_map[] = {
776 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8
782 if (x_c + y_c == 0) {
784 } else if (log2_trafo_size == 2) {
785 sig_ctx = ctx_idx_map[(y_c << 2) + x_c];
791 sig_ctx = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0;
795 sig_ctx = 2 - FFMIN(y_c & 3, 2);
798 sig_ctx = 2 - FFMIN(x_c & 3, 2);
804 if (c_idx == 0 && (x_cg > 0 || y_cg > 0))
807 if (log2_trafo_size == 3) {
808 sig_ctx += (scan_idx == SCAN_DIAG) ? 9 : 15;
810 sig_ctx += c_idx ? 12 : 21;
819 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
822 int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
828 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
831 int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
836 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
839 int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param)
843 int last_coeff_abs_level_remaining;
846 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc))
848 if (prefix == CABAC_MAX_BIN)
849 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
851 for (i = 0; i < rc_rice_param; i++)
852 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
853 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
855 int prefix_minus3 = prefix - 3;
856 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
857 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
858 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
859 << rc_rice_param) + suffix;
861 return last_coeff_abs_level_remaining;
864 int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb)
869 for (i = 0; i < nb; i++)
870 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc.cc);