diff options
author | Guillaume Martres <smarter@ubuntu.com> | 2013-10-12 11:55:48 +0200 |
---|---|---|
committer | Michael Niedermayer <michaelni@gmx.at> | 2013-10-15 22:13:02 +0200 |
commit | c8dd048ab8cff815c9f4b16a62db0b74df011f0a (patch) | |
tree | e9167d50e3b802a195b6fcfb4c042332f0d2b469 /libavcodec/hevc_cabac.c | |
parent | 2a19fcc12311f71f55eab7129b764d4cb800c934 (diff) | |
download | ffmpeg-c8dd048ab8cff815c9f4b16a62db0b74df011f0a.tar.gz |
lavc: add a HEVC decoder.
Initially written by Guillaume Martres <smarter@ubuntu.com> as a GSoC
project. Further contributions by the OpenHEVC project and other
developers, namely:
Mickaël Raulet <mraulet@insa-rennes.fr>
Seppo Tomperi <seppo.tomperi@vtt.fi>
Gildas Cocherel <gildas.cocherel@laposte.net>
Khaled Jerbi <khaled_jerbi@yahoo.fr>
Wassim Hamidouche <wassim.hamidouche@insa-rennes.fr>
Vittorio Giovara <vittorio.giovara@gmail.com>
Jan Ekström <jeebjp@gmail.com>
Anton Khirnov <anton@khirnov.net>
Martin Storsjö <martin@martin.st>
Luca Barbato <lu_zero@gentoo.org>
Yusuke Nakamura <muken.the.vfrmaniac@gmail.com>
Signed-off-by: Anton Khirnov <anton@khirnov.net>
Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
Diffstat (limited to 'libavcodec/hevc_cabac.c')
-rw-r--r-- | libavcodec/hevc_cabac.c | 928 |
1 files changed, 928 insertions, 0 deletions
diff --git a/libavcodec/hevc_cabac.c b/libavcodec/hevc_cabac.c new file mode 100644 index 0000000000..8468d560b9 --- /dev/null +++ b/libavcodec/hevc_cabac.c @@ -0,0 +1,928 @@ +/* + * HEVC CABAC decoding + * + * Copyright (C) 2012 - 2013 Guillaume Martres + * Copyright (C) 2012 - 2013 Gildas Cocherel + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "libavutil/attributes.h" +#include "libavutil/common.h" + +#include "cabac_functions.h" +#include "hevc.h" + +#define CABAC_MAX_BIN 100 + +/** + * number of bin by SyntaxElement. + */ +static const int8_t num_bins_in_se[] = { + 1, // sao_merge_flag + 1, // sao_type_idx + 0, // sao_eo_class + 0, // sao_band_position + 0, // sao_offset_abs + 0, // sao_offset_sign + 0, // end_of_slice_flag + 3, // split_coding_unit_flag + 1, // cu_transquant_bypass_flag + 3, // skip_flag + 3, // cu_qp_delta + 1, // pred_mode + 4, // part_mode + 0, // pcm_flag + 1, // prev_intra_luma_pred_mode + 0, // mpm_idx + 0, // rem_intra_luma_pred_mode + 2, // intra_chroma_pred_mode + 1, // merge_flag + 1, // merge_idx + 5, // inter_pred_idc + 2, // ref_idx_l0 + 2, // ref_idx_l1 + 2, // abs_mvd_greater0_flag + 2, // abs_mvd_greater1_flag + 0, // abs_mvd_minus2 + 0, // mvd_sign_flag + 1, // mvp_lx_flag + 1, // no_residual_data_flag + 3, // split_transform_flag + 2, // cbf_luma + 4, // cbf_cb, cbf_cr + 2, // transform_skip_flag[][] + 18, // last_significant_coeff_x_prefix + 18, // last_significant_coeff_y_prefix + 0, // last_significant_coeff_x_suffix + 0, // last_significant_coeff_y_suffix + 4, // significant_coeff_group_flag + 42, // significant_coeff_flag + 24, // coeff_abs_level_greater1_flag + 6, // coeff_abs_level_greater2_flag + 0, // coeff_abs_level_remaining + 0, // coeff_sign_flag +}; + +/** + * Offset to ctxIdx 0 in init_values and states, indexed by SyntaxElement. + */ +static const int elem_offset[sizeof(num_bins_in_se)] = { + 0, + 1, + 2, + 2, + 2, + 2, + 2, + 2, + 5, + 6, + 9, + 12, + 13, + 17, + 17, + 18, + 18, + 18, + 20, + 21, + 22, + 27, + 29, + 31, + 33, + 35, + 35, + 35, + 36, + 37, + 40, + 42, + 46, + 48, + 66, + 84, + 84, + 84, + 88, + 130, + 154, + 160, + 160, +}; + +#define CNU 154 +/** + * Indexed by init_type + */ +static const uint8_t init_values[3][HEVC_CONTEXTS] = { + { + // sao_merge_flag + 153, + // sao_type_idx + 200, + // split_coding_unit_flag + 139, 141, 157, + // cu_transquant_bypass_flag + 154, + // skip_flag + CNU, CNU, CNU, + // cu_qp_delta + 154, 154, 154, + // pred_mode + CNU, + // part_mode + 184, CNU, CNU, CNU, + // prev_intra_luma_pred_mode + 184, + // intra_chroma_pred_mode + 63, 139, + // merge_flag + CNU, + // merge_idx + CNU, + // inter_pred_idc + CNU, CNU, CNU, CNU, CNU, + // ref_idx_l0 + CNU, CNU, + // ref_idx_l1 + CNU, CNU, + // abs_mvd_greater1_flag + CNU, CNU, + // abs_mvd_greater1_flag + CNU, CNU, + // mvp_lx_flag + CNU, + // no_residual_data_flag + CNU, + // split_transform_flag + 153, 138, 138, + // cbf_luma + 111, 141, + // cbf_cb, cbf_cr + 94, 138, 182, 154, + // transform_skip_flag + 139, 139, + // last_significant_coeff_x_prefix + 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, + 79, 108, 123, 63, + // last_significant_coeff_y_prefix + 110, 110, 124, 125, 140, 153, 125, 127, 140, 109, 111, 143, 127, 111, + 79, 108, 123, 63, + // significant_coeff_group_flag + 91, 171, 134, 141, + // significant_coeff_flag + 111, 111, 125, 110, 110, 94, 124, 108, 124, 107, 125, 141, 179, 153, + 125, 107, 125, 141, 179, 153, 125, 107, 125, 141, 179, 153, 125, 140, + 139, 182, 182, 152, 136, 152, 136, 153, 136, 139, 111, 136, 139, 111, + // coeff_abs_level_greater1_flag + 140, 92, 137, 138, 140, 152, 138, 139, 153, 74, 149, 92, 139, 107, + 122, 152, 140, 179, 166, 182, 140, 227, 122, 197, + // coeff_abs_level_greater2_flag + 138, 153, 136, 167, 152, 152, + }, + { + // sao_merge_flag + 153, + // sao_type_idx + 185, + // split_coding_unit_flag + 107, 139, 126, + // cu_transquant_bypass_flag + 154, + // skip_flag + 197, 185, 201, + // cu_qp_delta + 154, 154, 154, + // pred_mode + 149, + // part_mode + 154, 139, 154, 154, + // prev_intra_luma_pred_mode + 154, + // intra_chroma_pred_mode + 152, 139, + // merge_flag + 110, + // merge_idx + 122, + // inter_pred_idc + 95, 79, 63, 31, 31, + // ref_idx_l0 + 153, 153, + // ref_idx_l1 + 153, 153, + // abs_mvd_greater1_flag + 140, 198, + // abs_mvd_greater1_flag + 140, 198, + // mvp_lx_flag + 168, + // no_residual_data_flag + 79, + // split_transform_flag + 124, 138, 94, + // cbf_luma + 153, 111, + // cbf_cb, cbf_cr + 149, 107, 167, 154, + // transform_skip_flag + 139, 139, + // last_significant_coeff_x_prefix + 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95, + 94, 108, 123, 108, + // last_significant_coeff_y_prefix + 125, 110, 94, 110, 95, 79, 125, 111, 110, 78, 110, 111, 111, 95, + 94, 108, 123, 108, + // significant_coeff_group_flag + 121, 140, 61, 154, + // significant_coeff_flag + 155, 154, 139, 153, 139, 123, 123, 63, 153, 166, 183, 140, 136, 153, + 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170, + 153, 123, 123, 107, 121, 107, 121, 167, 151, 183, 140, 151, 183, 140, + // coeff_abs_level_greater1_flag + 154, 196, 196, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121, + 136, 137, 169, 194, 166, 167, 154, 167, 137, 182, + // coeff_abs_level_greater2_flag + 107, 167, 91, 122, 107, 167, + }, + { + // sao_merge_flag + 153, + // sao_type_idx + 160, + // split_coding_unit_flag + 107, 139, 126, + // cu_transquant_bypass_flag + 154, + // skip_flag + 197, 185, 201, + // cu_qp_delta + 154, 154, 154, + // pred_mode + 134, + // part_mode + 154, 139, 154, 154, + // prev_intra_luma_pred_mode + 183, + // intra_chroma_pred_mode + 152, 139, + // merge_flag + 154, + // merge_idx + 137, + // inter_pred_idc + 95, 79, 63, 31, 31, + // ref_idx_l0 + 153, 153, + // ref_idx_l1 + 153, 153, + // abs_mvd_greater1_flag + 169, 198, + // abs_mvd_greater1_flag + 169, 198, + // mvp_lx_flag + 168, + // no_residual_data_flag + 79, + // split_transform_flag + 224, 167, 122, + // cbf_luma + 153, 111, + // cbf_cb, cbf_cr + 149, 92, 167, 154, + // transform_skip_flag + 139, 139, + // last_significant_coeff_x_prefix + 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111, + 79, 108, 123, 93, + // last_significant_coeff_y_prefix + 125, 110, 124, 110, 95, 94, 125, 111, 111, 79, 125, 126, 111, 111, + 79, 108, 123, 93, + // significant_coeff_group_flag + 121, 140, 61, 154, + // significant_coeff_flag + 170, 154, 139, 153, 139, 123, 123, 63, 124, 166, 183, 140, 136, 153, + 154, 166, 183, 140, 136, 153, 154, 166, 183, 140, 136, 153, 154, 170, + 153, 138, 138, 122, 121, 122, 121, 167, 151, 183, 140, 151, 183, 140, + // coeff_abs_level_greater1_flag + 154, 196, 167, 167, 154, 152, 167, 182, 182, 134, 149, 136, 153, 121, + 136, 122, 169, 208, 166, 167, 154, 152, 167, 182, + // coeff_abs_level_greater2_flag + 107, 167, 91, 107, 107, 167, + }, +}; + +void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts) +{ + if (s->pps->entropy_coding_sync_enabled_flag && + ((ctb_addr_ts % s->sps->ctb_width) == 2 || + (s->sps->ctb_width == 2 && + (ctb_addr_ts % s->sps->ctb_width) == 0))) { + memcpy(s->cabac_state, s->HEVClc.cabac_state, HEVC_CONTEXTS); + } +} + +static void load_states(HEVCContext *s) +{ + memcpy(s->HEVClc.cabac_state, s->cabac_state, HEVC_CONTEXTS); +} + +static void cabac_reinit(HEVCLocalContext *lc) +{ + skip_bytes(&lc->cc, 0); +} + +static void cabac_init_decoder(HEVCContext *s) +{ + GetBitContext *gb = &s->HEVClc.gb; + skip_bits(gb, 1); + align_get_bits(gb); + ff_init_cabac_decoder(&s->HEVClc.cc, + gb->buffer + get_bits_count(gb) / 8, + (get_bits_left(gb) + 7) / 8); +} + +static void cabac_init_state(HEVCContext *s) +{ + int init_type = 2 - s->sh.slice_type; + int i; + + if (s->sh.cabac_init_flag && s->sh.slice_type != I_SLICE) + init_type ^= 3; + + for (i = 0; i < HEVC_CONTEXTS; i++) { + int init_value = init_values[init_type][i]; + int m = (init_value >> 4) * 5 - 45; + int n = ((init_value & 15) << 3) - 16; + int pre = 2 * (((m * av_clip_c(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127; + + pre ^= pre >> 31; + if (pre > 124) + pre = 124 + (pre & 1); + s->HEVClc.cabac_state[i] = pre; + } +} + +void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts) +{ + if (ctb_addr_ts == s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) { + cabac_init_decoder(s); + if ((s->sh.dependent_slice_segment_flag == 0) || + (s->pps->tiles_enabled_flag && + (s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]))) + cabac_init_state(s); + + if (!s->sh.first_slice_in_pic_flag && s->pps->entropy_coding_sync_enabled_flag) { + if ((ctb_addr_ts % s->sps->ctb_width) == 0) { + if (s->sps->ctb_width == 1) + cabac_init_state(s); + else if (s->sh.dependent_slice_segment_flag == 1) + load_states(s); + } + } + } else { + if (s->pps->tiles_enabled_flag && + (s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1])) { + cabac_reinit(&s->HEVClc); + cabac_init_state(s); + } + if (s->pps->entropy_coding_sync_enabled_flag) { + if ((ctb_addr_ts % s->sps->ctb_width) == 0) { + get_cabac_terminate(&s->HEVClc.cc); + cabac_reinit(&s->HEVClc); + + if (s->sps->ctb_width == 1) + cabac_init_state(s); + else + load_states(s); + } + } + } +} + +#define GET_CABAC(ctx) get_cabac(&s->HEVClc.cc, &s->HEVClc.cabac_state[ctx]) + +int ff_hevc_sao_merge_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[SAO_MERGE_FLAG]); +} + +int ff_hevc_sao_type_idx_decode(HEVCContext *s) +{ + if (!GET_CABAC(elem_offset[SAO_TYPE_IDX])) + return 0; + + if (!get_cabac_bypass(&s->HEVClc.cc)) + return SAO_BAND; + return SAO_EDGE; +} + +int ff_hevc_sao_band_position_decode(HEVCContext *s) +{ + int i; + int value = get_cabac_bypass(&s->HEVClc.cc); + + for (i = 0; i < 4; i++) + value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc); + return value; +} + +int ff_hevc_sao_offset_abs_decode(HEVCContext *s) +{ + int i = 0; + int length = (1 << (FFMIN(s->sps->bit_depth, 10) - 5)) - 1; + + while (i < length && get_cabac_bypass(&s->HEVClc.cc)) + i++; + return i; +} + +int ff_hevc_sao_offset_sign_decode(HEVCContext *s) +{ + return get_cabac_bypass(&s->HEVClc.cc); +} + +int ff_hevc_sao_eo_class_decode(HEVCContext *s) +{ + int ret = (get_cabac_bypass(&s->HEVClc.cc) << 1); + ret |= get_cabac_bypass(&s->HEVClc.cc); + return ret; +} + +int ff_hevc_end_of_slice_flag_decode(HEVCContext *s) +{ + return get_cabac_terminate(&s->HEVClc.cc); +} + +int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[CU_TRANSQUANT_BYPASS_FLAG]); +} + +int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb) +{ + int pic_width_in_ctb = s->sps->width >> s->sps->log2_min_coding_block_size; + int inc = 0; + int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1); + int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1); + + if (s->HEVClc.ctb_left_flag || x0b) + inc = SAMPLE_CTB(s->skip_flag, x_cb-1, y_cb); + if (s->HEVClc.ctb_up_flag || y0b) + inc += SAMPLE_CTB(s->skip_flag, x_cb, y_cb-1); + + return GET_CABAC(elem_offset[SKIP_FLAG] + inc); +} + +int ff_hevc_cu_qp_delta_abs(HEVCContext *s) +{ + int prefix_val = 0; + int suffix_val = 0; + int inc = 0; + + while (prefix_val < 5 && GET_CABAC(elem_offset[CU_QP_DELTA] + inc)) { + prefix_val++; + inc = 1; + } + if (prefix_val >= 5) { + int k = 0; + while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) { + suffix_val += 1 << k; + k++; + } + if (k == CABAC_MAX_BIN) + av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); + + while (k--) + suffix_val += get_cabac_bypass(&s->HEVClc.cc) << k; + } + return prefix_val + suffix_val; +} + +int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s) +{ + return get_cabac_bypass(&s->HEVClc.cc); +} + +int ff_hevc_pred_mode_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[PRED_MODE_FLAG]); +} + +int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0) +{ + int inc = 0, depth_left = 0, depth_top = 0; + int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1); + int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1); + int x_cb = x0 >> s->sps->log2_min_coding_block_size; + int y_cb = y0 >> s->sps->log2_min_coding_block_size; + + if (s->HEVClc.ctb_left_flag || x0b) + depth_left = s->tab_ct_depth[(y_cb)*s->sps->min_cb_width + x_cb-1]; + if (s->HEVClc.ctb_up_flag || y0b) + depth_top = s->tab_ct_depth[(y_cb-1)*s->sps->min_cb_width + x_cb]; + + inc += (depth_left > ct_depth); + inc += (depth_top > ct_depth); + return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc); +} + +int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size) +{ + if (GET_CABAC(elem_offset[PART_MODE])) // 1 + return PART_2Nx2N; + if (log2_cb_size == s->sps->log2_min_coding_block_size) { + if (s->HEVClc.cu.pred_mode == MODE_INTRA) // 0 + return PART_NxN; + if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01 + return PART_2NxN; + if (log2_cb_size == 3) // 00 + return PART_Nx2N; + if (GET_CABAC(elem_offset[PART_MODE] + 2)) // 001 + return PART_Nx2N; + return PART_NxN; // 000 + } + + if (!s->sps->amp_enabled_flag) { + if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01 + return PART_2NxN; + return PART_Nx2N; + } + + if (GET_CABAC(elem_offset[PART_MODE] + 1)) { // 01X, 01XX + if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 011 + return PART_2NxN; + if (get_cabac_bypass(&s->HEVClc.cc)) // 0101 + return PART_2NxnD; + return PART_2NxnU; // 0100 + } + + if (GET_CABAC(elem_offset[PART_MODE] + 3)) // 001 + return PART_Nx2N; + if (get_cabac_bypass(&s->HEVClc.cc)) // 0001 + return PART_nRx2N; + return PART_nLx2N; // 0000 +} + +int ff_hevc_pcm_flag_decode(HEVCContext *s) +{ + return get_cabac_terminate(&s->HEVClc.cc); +} + +int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]); +} + +int ff_hevc_mpm_idx_decode(HEVCContext *s) +{ + int i = 0; + while (i < 2 && get_cabac_bypass(&s->HEVClc.cc)) + i++; + return i; +} + +int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s) +{ + int i; + int value = get_cabac_bypass(&s->HEVClc.cc); + + for (i = 0; i < 4; i++) + value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc); + return value; +} + +int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s) +{ + int ret; + if (!GET_CABAC(elem_offset[INTRA_CHROMA_PRED_MODE])) + return 4; + + ret = (get_cabac_bypass(&s->HEVClc.cc) << 1); + ret |= get_cabac_bypass(&s->HEVClc.cc); + return ret; +} + +int ff_hevc_merge_idx_decode(HEVCContext *s) +{ + int i = GET_CABAC(elem_offset[MERGE_IDX]); + + if (i != 0) { + while (i < s->sh.max_num_merge_cand-1 && get_cabac_bypass(&s->HEVClc.cc)) + i++; + } + return i; +} + +int ff_hevc_merge_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[MERGE_FLAG]); +} + +int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH) +{ + if (nPbW + nPbH == 12) + return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4); + if (GET_CABAC(elem_offset[INTER_PRED_IDC] + s->HEVClc.ct.depth)) + return PRED_BI; + + return GET_CABAC(elem_offset[INTER_PRED_IDC] + 4); +} + +int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx) +{ + int i = 0; + int max = num_ref_idx_lx - 1; + int max_ctx = FFMIN(max, 2); + + while (i < max_ctx && GET_CABAC(elem_offset[REF_IDX_L0] + i)) + i++; + if (i == 2) { + while (i < max && get_cabac_bypass(&s->HEVClc.cc)) + i++; + } + + return i; +} + +int ff_hevc_mvp_lx_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[MVP_LX_FLAG]); +} + +int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]); +} + +int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]); +} + +int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s) +{ + return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1); +} + +int ff_hevc_mvd_decode(HEVCContext *s) +{ + int ret = 2; + int k = 1; + + while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) { + ret += 1 << k; + k++; + } + if (k == CABAC_MAX_BIN) + av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k); + while (k--) + ret += get_cabac_bypass(&s->HEVClc.cc) << k; + return get_cabac_bypass_sign(&s->HEVClc.cc, -ret); +} + +int ff_hevc_mvd_sign_flag_decode(HEVCContext *s) +{ + return get_cabac_bypass_sign(&s->HEVClc.cc, -1); +} + +int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size) +{ + return GET_CABAC(elem_offset[SPLIT_TRANSFORM_FLAG] + 5 - log2_trafo_size); +} + +int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth) +{ + return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth); +} + +int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth) +{ + return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth); +} + +int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx) +{ + return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx); +} + +#define LAST_SIG_COEFF(elem) \ + int i = 0; \ + int max = (log2_size << 1) - 1; \ + int ctx_offset, ctx_shift; \ + \ + if (c_idx == 0) { \ + ctx_offset = 3 * (log2_size - 2) + ((log2_size - 1) >> 2); \ + ctx_shift = (log2_size + 1) >> 2; \ + } else { \ + ctx_offset = 15; \ + ctx_shift = log2_size - 2; \ + } \ + while (i < max && \ + GET_CABAC(elem_offset[elem] + (i >> ctx_shift) + ctx_offset)) \ + i++; \ + return i; + +int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx, + int log2_size) +{ + LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_X_PREFIX) +} + +int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx, + int log2_size) +{ + LAST_SIG_COEFF(LAST_SIGNIFICANT_COEFF_Y_PREFIX) +} + +int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s, + int last_significant_coeff_prefix) +{ + int i; + int length = (last_significant_coeff_prefix >> 1) - 1; + int value = get_cabac_bypass(&s->HEVClc.cc); + + for (i = 1; i < length; i++) + value = (value << 1) | get_cabac_bypass(&s->HEVClc.cc); + return value; +} + +int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int x_cg, + int y_cg, int log2_trafo_size) +{ + int ctx_cg = 0; + int inc; + + if (x_cg < (1 << (log2_trafo_size - 2)) - 1) + ctx_cg += s->HEVClc.rc.significant_coeff_group_flag[x_cg + 1][y_cg]; + if (y_cg < (1 << (log2_trafo_size - 2)) - 1) + ctx_cg += s->HEVClc.rc.significant_coeff_group_flag[x_cg][y_cg + 1]; + + inc = FFMIN(ctx_cg, 1) + (c_idx>0 ? 2 : 0); + + return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc); +} + +int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c, + int log2_trafo_size, int scan_idx) +{ + static const uint8_t ctx_idx_map[] = { + 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8, 8 + }; + int x_cg = x_c >> 2; + int y_cg = y_c >> 2; + int sig_ctx; + int inc; + + if (x_c + y_c == 0) { + sig_ctx = 0; + } else if (log2_trafo_size == 2) { + sig_ctx = ctx_idx_map[(y_c << 2) + x_c]; + } else { + int prev_sig = 0; + + if (x_cg < ((1 << log2_trafo_size) - 1) >> 2) + prev_sig += s->HEVClc.rc.significant_coeff_group_flag[x_cg + 1][y_cg]; + if (y_cg < ((1 << log2_trafo_size) - 1) >> 2) + prev_sig += (s->HEVClc.rc.significant_coeff_group_flag[x_cg][y_cg + 1] << 1); + + switch (prev_sig) { + case 0: { + int x_off = x_c & 3; + int y_off = y_c & 3; + sig_ctx = ((x_off + y_off) == 0) ? 2 : ((x_off + y_off) <= 2) ? 1 : 0; + } + break; + case 1: + sig_ctx = 2 - FFMIN(y_c & 3, 2); + break; + case 2: + sig_ctx = 2 - FFMIN(x_c & 3, 2); + break; + default: + sig_ctx = 2; + } + + if (c_idx == 0 && (x_cg > 0 || y_cg > 0)) + sig_ctx += 3; + + if (log2_trafo_size == 3) { + sig_ctx += (scan_idx == SCAN_DIAG) ? 9 : 15; + } else { + sig_ctx += c_idx ? 12 : 21; + } + } + + if (c_idx == 0) { + inc = sig_ctx; + } else { + inc = sig_ctx + 27; + } + + return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc); +} + +int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, + int i, int n, + int first_elem, + int first_subset) +{ + + int inc; + + if (first_elem) { + s->HEVClc.ctx_set = (i > 0 && c_idx == 0) ? 2 : 0; + + if (!first_subset && s->HEVClc.greater1_ctx == 0) + s->HEVClc.ctx_set++; + s->HEVClc.greater1_ctx = 1; + } + + inc = (s->HEVClc.ctx_set << 2) + s->HEVClc.greater1_ctx; + if (c_idx > 0) + inc += 16; + + s->HEVClc.last_coeff_abs_level_greater1_flag = + GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc); + + if (s->HEVClc.last_coeff_abs_level_greater1_flag) { + s->HEVClc.greater1_ctx = 0; + } else if (s->HEVClc.greater1_ctx > 0 && s->HEVClc.greater1_ctx < 3) { + s->HEVClc.greater1_ctx++; + } + + return s->HEVClc.last_coeff_abs_level_greater1_flag; +} + +int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, + int i, int n) +{ + int inc; + + inc = s->HEVClc.ctx_set; + if (c_idx > 0) + inc += 4; + + return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc); +} + +int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int first_elem, int base_level) +{ + int i; + HEVCLocalContext *lc = &s->HEVClc; + int prefix = 0; + int suffix = 0; + + if (first_elem) { + lc->c_rice_param = 0; + lc->last_coeff_abs_level_remaining = 0; + } + + while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc.cc)) + prefix++; + if (prefix == CABAC_MAX_BIN) + av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix); + if (prefix < 3) { + for (i = 0; i < lc->c_rice_param; i++) + suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc); + lc->last_coeff_abs_level_remaining = (prefix << lc->c_rice_param) + suffix; + } else { + for (i = 0; i < prefix - 3 + lc->c_rice_param; i++) + suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc.cc); + lc->last_coeff_abs_level_remaining = (((1 << (prefix - 3)) + 3 - 1) + << lc->c_rice_param) + suffix; + } + + lc->c_rice_param = FFMIN(lc->c_rice_param + + ((base_level + lc->last_coeff_abs_level_remaining) > + (3 * (1 << lc->c_rice_param))), 4); + + return lc->last_coeff_abs_level_remaining; +} + +int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb) +{ + int i; + int ret = 0; + + for (i = 0; i < nb; i++) + ret = (ret << 1) | get_cabac_bypass(&s->HEVClc.cc); + return ret; +} |