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"
31 #define CABAC_MAX_BIN 31
34 * number of bin by SyntaxElement.
36 static const int8_t num_bins_in_se[] = {
40 0, // sao_band_position
43 0, // end_of_slice_flag
44 3, // split_coding_unit_flag
45 1, // cu_transquant_bypass_flag
51 1, // prev_intra_luma_pred_mode
53 0, // rem_intra_luma_pred_mode
54 2, // intra_chroma_pred_mode
60 2, // abs_mvd_greater0_flag
61 2, // abs_mvd_greater1_flag
65 1, // no_residual_data_flag
66 3, // split_transform_flag
69 2, // transform_skip_flag[][]
70 18, // last_significant_coeff_x_prefix
71 18, // last_significant_coeff_y_prefix
72 0, // last_significant_coeff_x_suffix
73 0, // last_significant_coeff_y_suffix
74 4, // significant_coeff_group_flag
75 42, // significant_coeff_flag
76 24, // coeff_abs_level_greater1_flag
77 6, // coeff_abs_level_greater2_flag
78 0, // coeff_abs_level_remaining
83 * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement.
85 static const int elem_offset[sizeof(num_bins_in_se)] = {
133 * Indexed by init_type
135 static const uint8_t init_values[3][HEVC_CONTEXTS] = {
140 // split_coding_unit_flag
142 // cu_transquant_bypass_flag
152 // prev_intra_luma_pred_mode
154 // intra_chroma_pred_mode
161 CNU, CNU, CNU, CNU, CNU,
166 // abs_mvd_greater1_flag
168 // abs_mvd_greater1_flag
172 // no_residual_data_flag
174 // split_transform_flag
180 // transform_skip_flag
182 // last_significant_coeff_x_prefix
183 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
185 // last_significant_coeff_y_prefix
186 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111,
188 // significant_coeff_group_flag
190 // significant_coeff_flag
191 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153,
192 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140,
193 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111,
194 // coeff_abs_level_greater1_flag
195 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107,
196 122, 152, 140, 179, 166, 182, 140, 227, 122, 197,
197 // coeff_abs_level_greater2_flag
198 138, 153, 136, 167, 152, 152, },
203 // split_coding_unit_flag
205 // cu_transquant_bypass_flag
215 // prev_intra_luma_pred_mode
217 // intra_chroma_pred_mode
229 // abs_mvd_greater1_flag
231 // abs_mvd_greater1_flag
235 // no_residual_data_flag
237 // split_transform_flag
243 // transform_skip_flag
245 // last_significant_coeff_x_prefix
246 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
248 // last_significant_coeff_y_prefix
249 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95,
251 // significant_coeff_group_flag
253 // significant_coeff_flag
254 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153,
255 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
256 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140,
257 // coeff_abs_level_greater1_flag
258 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
259 136, 137, 169, 194, 166, 167, 154, 167, 137, 182,
260 // coeff_abs_level_greater2_flag
261 107, 167, 91, 122, 107, 167, },
266 // split_coding_unit_flag
268 // cu_transquant_bypass_flag
278 // prev_intra_luma_pred_mode
280 // intra_chroma_pred_mode
292 // abs_mvd_greater1_flag
294 // abs_mvd_greater1_flag
298 // no_residual_data_flag
300 // split_transform_flag
306 // transform_skip_flag
308 // last_significant_coeff_x_prefix
309 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
311 // last_significant_coeff_y_prefix
312 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111,
314 // significant_coeff_group_flag
316 // significant_coeff_flag
317 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153,
318 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170,
319 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140,
320 // coeff_abs_level_greater1_flag
321 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121,
322 136, 122, 169, 208, 166, 167, 154, 152, 167, 182,
323 // coeff_abs_level_greater2_flag
324 107, 167, 91, 107, 107, 167, },
327 void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
329 if (s->ps.pps->entropy_coding_sync_enabled_flag &&
330 (ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
331 (s->ps.sps->ctb_width == 2 &&
332 ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
333 memcpy(s->cabac_state, s->HEVClc.cabac_state, HEVC_CONTEXTS);
337 static void load_states(HEVCContext *s)
339 memcpy(s->HEVClc.cabac_state, s->cabac_state, HEVC_CONTEXTS);
342 static void cabac_reinit(HEVCLocalContext *lc)
344 skip_bytes(&lc->cc, 0);
347 static void cabac_init_decoder(HEVCContext *s)
349 GetBitContext *gb = &s->HEVClc.gb;
352 ff_init_cabac_decoder(&s->HEVClc.cc,
353 gb->buffer + get_bits_count(gb) / 8,
354 (get_bits_left(gb) + 7) / 8);
357 static void cabac_init_state(HEVCContext *s)
359 int init_type = 2 - s->sh.slice_type;
362 if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I)
365 for (i = 0; i < HEVC_CONTEXTS; i++) {
366 int init_value = init_values[init_type][i];
367 int m = (init_value >> 4) * 5 - 45;
368 int n = ((init_value & 15) << 3) - 16;
369 int pre = 2 * (((m * av_clip(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127;
373 pre = 124 + (pre & 1);
374 s->HEVClc.cabac_state[i] = pre;
378 void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
380 if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
381 cabac_init_decoder(s);
382 if (s->sh.dependent_slice_segment_flag == 0 ||
383 (s->ps.pps->tiles_enabled_flag &&
384 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]))
387 if (!s->sh.first_slice_in_pic_flag &&
388 s->ps.pps->entropy_coding_sync_enabled_flag) {
389 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
390 if (s->ps.sps->ctb_width == 1)
392 else if (s->sh.dependent_slice_segment_flag == 1)
397 if (s->ps.pps->tiles_enabled_flag &&
398 s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
399 cabac_reinit(&s->HEVClc);
402 if (s->ps.pps->entropy_coding_sync_enabled_flag) {
403 if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
404 get_cabac_terminate(&s->HEVClc.cc);
405 cabac_reinit(&s->HEVClc);
407 if (s->ps.sps->ctb_width == 1)
416 #define GET_CABAC(ctx) get_cabac(&s->HEVClc.cc, &s->HEVClc.cabac_state[ctx])
418 int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
420 return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
423 int ff_hevc_sao_type_idx_decode(HEVCContext *s)
425 if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
428 if (!get_cabac_bypass(&s->HEVClc.cc))
433 int ff_hevc_sao_band_position_decode(HEVCContext *s)
436 int value = get_cabac_bypass(&s->HEVClc.cc);
438 for (i = 0; i < 4; i++)
439 value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
443 int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
446 int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
448 while (i < length && get_cabac_bypass(&s->HEVClc.cc))
453 int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
455 return get_cabac_bypass(&s->HEVClc.cc);
458 int ff_hevc_sao_eo_class_decode(HEVCContext *s)
460 int ret = get_cabac_bypass(&s->HEVClc.cc) << 1;
461 ret |= get_cabac_bypass(&s->HEVClc.cc);
465 int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
467 return get_cabac_terminate(&s->HEVClc.cc);
470 int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
472 return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]);
475 int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
477 int min_cb_width = s->ps.sps->min_cb_width;
479 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
480 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
482 if (s->HEVClc.ctb_left_flag || x0b)
483 inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
484 if (s->HEVClc.ctb_up_flag || y0b)
485 inc += !!SAMPLE_CTB(s->skip_flag, x_cb, y_cb - 1);
487 return GET_CABAC(elem_offset[SKIP_FLAG] + inc);
490 int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
496 while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) {
500 if (prefix_val >= 5) {
502 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
503 suffix_val += 1 << k;
506 if (k == CABAC_MAX_BIN)
507 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
510 suffix_val += get_cabac_bypass(&s->HEVClc.cc) << k;
512 return prefix_val + suffix_val;
515 int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
517 return get_cabac_bypass(&s->HEVClc.cc);
520 int ff_hevc_pred_mode_decode(HEVCContext *s)
522 return GET_CABAC(elem_offset[PRED_MODE_FLAG]);
525 int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
527 int inc = 0, depth_left = 0, depth_top = 0;
528 int x0b = x0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
529 int y0b = y0 & ((1 << s->ps.sps->log2_ctb_size) - 1);
530 int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
531 int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
533 if (s->HEVClc.ctb_left_flag || x0b)
534 depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb - 1];
535 if (s->HEVClc.ctb_up_flag || y0b)
536 depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width + x_cb];
538 inc += (depth_left > ct_depth);
539 inc += (depth_top > ct_depth);
541 return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
544 int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
546 if (GET_CABAC(elem_offset[PART_MODE])) // 1
548 if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
549 if (s->HEVClc.cu.pred_mode == MODE_INTRA) // 0
551 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
553 if (log2_cb_size == 3) // 00
555 if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001
557 return PART_NxN; // 000
560 if (!s->ps.sps->amp_enabled_flag) {
561 if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
566 if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX
567 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011
569 if (get_cabac_bypass(&s->HEVClc.cc)) // 0101
571 return PART_2NxnU; // 0100
574 if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001
576 if (get_cabac_bypass(&s->HEVClc.cc)) // 0001
578 return PART_nLx2N; // 0000
581 int ff_hevc_pcm_flag_decode(HEVCContext *s)
583 return get_cabac_terminate(&s->HEVClc.cc);
586 int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
588 return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
591 int ff_hevc_mpm_idx_decode(HEVCContext *s)
594 while (i < 2 && get_cabac_bypass(&s->HEVClc.cc))
599 int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
602 int value = get_cabac_bypass(&s->HEVClc.cc);
604 for (i = 0; i < 4; i++)
605 value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
609 int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
612 if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE]))
615 ret = get_cabac_bypass(&s->HEVClc.cc) << 1;
616 ret |= get_cabac_bypass(&s->HEVClc.cc);
620 int ff_hevc_merge_idx_decode(HEVCContext *s)
622 int i = GET_CABAC(elem_offset[MERGE_IDX]);
625 while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc.cc))
631 int ff_hevc_merge_flag_decode(HEVCContext *s)
633 return GET_CABAC(elem_offset[MERGE_FLAG]);
636 int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
638 if (nPbW + nPbH == 12)
639 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
640 if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc.ct.depth))
643 return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4);
646 int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
649 int max = num_ref_idx_lx - 1;
650 int max_ctx = FFMIN(max, 2);
652 while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i))
655 while (i < max && get_cabac_bypass(&s->HEVClc.cc))
662 int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
664 return GET_CABAC(elem_offset[MVP_LX_FLAG]);
667 int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
669 return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
672 int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s)
674 return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
677 int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s)
679 return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
682 int ff_hevc_mvd_decode(HEVCContext *s)
687 while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) {
691 if (k == CABAC_MAX_BIN)
692 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
694 ret += get_cabac_bypass(&s->HEVClc.cc) << k;
695 return get_cabac_bypass_sign(&s->HEVClc.cc, -ret);
698 int ff_hevc_mvd_sign_flag_decode(HEVCContext *s)
700 return get_cabac_bypass_sign(&s->HEVClc.cc, -1);
703 int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
705 return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size);
708 int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
710 return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
713 int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
715 return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
718 int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
720 return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
723 #define LAST_SIG_COEFF(elem) \
725 int max = (log2_size << 1) - 1; \
726 int ctx_offset, ctx_shift; \
729 ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2); \
730 ctx_shift = (log2_size + 1) >> 2; \
733 ctx_shift = log2_size - 2; \
736 GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset)) \
740 int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx,
743 LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_X_PREFIX)
746 int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx,
749 LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_Y_PREFIX)
752 int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s,
753 int last_significant_coeff_prefix)
756 int length = (last_significant_coeff_prefix >> 1) - 1;
757 int value = get_cabac_bypass(&s->HEVClc.cc);
759 for (i = 1; i < length; i++)
760 value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc);
764 int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
768 inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0);
770 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
773 int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c,
774 int log2_trafo_size, int scan_idx, int prev_sig)
776 static const uint8_t ctx_idx_map[] = {
777 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8
783 if (x_c + y_c == 0) {
785 } else if (log2_trafo_size == 2) {
786 sig_ctx = ctx_idx_map[(y_c << 2) + x_c];
792 sig_ctx = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0;
796 sig_ctx = 2 - FFMIN(y_c & 3, 2);
799 sig_ctx = 2 - FFMIN(x_c & 3, 2);
805 if (c_idx == 0 && (x_cg > 0 || y_cg > 0))
808 if (log2_trafo_size == 3) {
809 sig_ctx += (scan_idx == SCAN_DIAG) ? 9 : 15;
811 sig_ctx += c_idx ? 12 : 21;
820 return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
823 int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int inc)
829 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
832 int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
837 return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
840 int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param)
844 int last_coeff_abs_level_remaining;
847 while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc))
849 if (prefix == CABAC_MAX_BIN)
850 av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
852 for (i = 0; i < rc_rice_param; i++)
853 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
854 last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
856 int prefix_minus3 = prefix - 3;
857 for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
858 suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc);
859 last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
860 << rc_rice_param) + suffix;
862 return last_coeff_abs_level_remaining;
865 int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb)
870 for (i = 0; i < nb; i++)
871 ret = (ret << 1) | get_cabac_bypass(&s->HEVClc.cc);