The HEVC decoder has both HEVCContext and HEVCLocalContext
structures. The latter is supposed to be the structure
containing the per-slicethread state.
Yet that is not how it is handled in practice: Each HEVCLocalContext
has a unique HEVCContext allocated for it and each of these
coincides except in exactly one field: The corresponding
HEVCLocalContext. This makes it possible to pass the HEVCContext
everywhere where logically a HEVCLocalContext should be used.
This commit stops doing this for lavc/hevc_cabac.c; it also constifies
everything that is possible in order to ensure that no slice thread
accidentally modifies the main HEVCContext state.
Signed-off-by: Andreas Rheinhardt <andreas.rheinha...@outlook.com>
---
libavcodec/hevc_cabac.c | 310 +++++++++++++++++++++-------------------
libavcodec/hevcdec.c | 102 ++++++-------
libavcodec/hevcdec.h | 72 +++++-----
3 files changed, 246 insertions(+), 238 deletions(-)
diff --git a/libavcodec/hevc_cabac.c b/libavcodec/hevc_cabac.c
index 985c97ef2a..f8f349dc4c 100644
--- a/libavcodec/hevc_cabac.c
+++ b/libavcodec/hevc_cabac.c
@@ -447,24 +447,26 @@ static const uint8_t diag_scan8x8_inv[8][8] = {
{ 28, 36, 43, 49, 54, 58, 61, 63, },
};
-void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
+void ff_hevc_save_states(HEVCLocalContext *lc, int ctb_addr_ts)
{
+ const HEVCContext *const s = lc->parent;
+
if (s->ps.pps->entropy_coding_sync_enabled_flag &&
(ctb_addr_ts % s->ps.sps->ctb_width == 2 ||
(s->ps.sps->ctb_width == 2 &&
ctb_addr_ts % s->ps.sps->ctb_width == 0))) {
- memcpy(s->cabac->state, s->HEVClc->cabac_state, HEVC_CONTEXTS);
+ memcpy(s->cabac->state, lc->cabac_state, HEVC_CONTEXTS);
if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
- memcpy(s->cabac->stat_coeff, s->HEVClc->stat_coeff,
HEVC_STAT_COEFFS);
+ memcpy(s->cabac->stat_coeff, lc->stat_coeff, HEVC_STAT_COEFFS);
}
}
}
-static void load_states(HEVCContext *s)
+static void load_states(HEVCLocalContext *lc, const HEVCContext *s)
{
- memcpy(s->HEVClc->cabac_state, s->cabac->state, HEVC_CONTEXTS);
+ memcpy(lc->cabac_state, s->cabac->state, HEVC_CONTEXTS);
if (s->ps.sps->persistent_rice_adaptation_enabled_flag) {
- memcpy(s->HEVClc->stat_coeff, s->cabac->stat_coeff, HEVC_STAT_COEFFS);
+ memcpy(lc->stat_coeff, s->cabac->stat_coeff, HEVC_STAT_COEFFS);
}
}
@@ -473,17 +475,17 @@ static int cabac_reinit(HEVCLocalContext *lc)
return skip_bytes(&lc->cc, 0) == NULL ? AVERROR_INVALIDDATA : 0;
}
-static int cabac_init_decoder(HEVCContext *s)
+static int cabac_init_decoder(HEVCLocalContext *lc)
{
- GetBitContext *gb = &s->HEVClc->gb;
+ GetBitContext *gb = &lc->gb;
skip_bits(gb, 1);
align_get_bits(gb);
- return ff_init_cabac_decoder(&s->HEVClc->cc,
+ return ff_init_cabac_decoder(&lc->cc,
gb->buffer + get_bits_count(gb) / 8,
(get_bits_left(gb) + 7) / 8);
}
-static void cabac_init_state(HEVCContext *s)
+static void cabac_init_state(HEVCLocalContext *lc, const HEVCContext *s)
{
int init_type = 2 - s->sh.slice_type;
int i;
@@ -500,31 +502,33 @@ static void cabac_init_state(HEVCContext *s)
pre ^= pre >> 31;
if (pre > 124)
pre = 124 + (pre & 1);
- s->HEVClc->cabac_state[i] = pre;
+ lc->cabac_state[i] = pre;
}
for (i = 0; i < 4; i++)
- s->HEVClc->stat_coeff[i] = 0;
+ lc->stat_coeff[i] = 0;
}
-int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
+int ff_hevc_cabac_init(HEVCLocalContext *lc, int ctb_addr_ts)
{
+ const HEVCContext *const s = lc->parent;
+
if (ctb_addr_ts == s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) {
- int ret = cabac_init_decoder(s);
+ int ret = cabac_init_decoder(lc);
if (ret < 0)
return ret;
if (s->sh.dependent_slice_segment_flag == 0 ||
(s->ps.pps->tiles_enabled_flag &&
s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts
- 1]))
- cabac_init_state(s);
+ cabac_init_state(lc, s);
if (!s->sh.first_slice_in_pic_flag &&
s->ps.pps->entropy_coding_sync_enabled_flag) {
if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
if (s->ps.sps->ctb_width == 1)
- cabac_init_state(s);
+ cabac_init_state(lc, s);
else if (s->sh.dependent_slice_segment_flag == 1)
- load_states(s);
+ load_states(lc, s);
}
}
} else {
@@ -532,111 +536,112 @@ int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts
- 1]) {
int ret;
if (s->threads_number == 1)
- ret = cabac_reinit(s->HEVClc);
+ ret = cabac_reinit(lc);
else {
- ret = cabac_init_decoder(s);
+ ret = cabac_init_decoder(lc);
}
if (ret < 0)
return ret;
- cabac_init_state(s);
+ cabac_init_state(lc, s);
}
if (s->ps.pps->entropy_coding_sync_enabled_flag) {
if (ctb_addr_ts % s->ps.sps->ctb_width == 0) {
int ret;
- get_cabac_terminate(&s->HEVClc->cc);
+ get_cabac_terminate(&lc->cc);
if (s->threads_number == 1)
- ret = cabac_reinit(s->HEVClc);
+ ret = cabac_reinit(lc);
else {
- ret = cabac_init_decoder(s);
+ ret = cabac_init_decoder(lc);
}
if (ret < 0)
return ret;
if (s->ps.sps->ctb_width == 1)
- cabac_init_state(s);
+ cabac_init_state(lc, s);
else
- load_states(s);
+ load_states(lc, s);
}
}
}
return 0;
}
-#define GET_CABAC(ctx) get_cabac(&s->HEVClc->cc, &s->HEVClc->cabac_state[ctx])
+#define GET_CABAC(ctx) get_cabac(&lc->cc, &lc->cabac_state[ctx])
-int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
+int ff_hevc_sao_merge_flag_decode(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[SAO_MERGE_FLAG]);
}
-int ff_hevc_sao_type_idx_decode(HEVCContext *s)
+int ff_hevc_sao_type_idx_decode(HEVCLocalContext *lc)
{
if (!GET_CABAC(elem_offset[SAO_TYPE_IDX]))
return 0;
- if (!get_cabac_bypass(&s->HEVClc->cc))
+ if (!get_cabac_bypass(&lc->cc))
return SAO_BAND;
return SAO_EDGE;
}
-int ff_hevc_sao_band_position_decode(HEVCContext *s)
+int ff_hevc_sao_band_position_decode(HEVCLocalContext *lc)
{
int i;
- int value = get_cabac_bypass(&s->HEVClc->cc);
+ int value = get_cabac_bypass(&lc->cc);
for (i = 0; i < 4; i++)
- value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
+ value = (value << 1) | get_cabac_bypass(&lc->cc);
return value;
}
-int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
+int ff_hevc_sao_offset_abs_decode(HEVCLocalContext *lc)
{
int i = 0;
- int length = (1 << (FFMIN(s->ps.sps->bit_depth, 10) - 5)) - 1;
+ int length = (1 << (FFMIN(lc->parent->ps.sps->bit_depth, 10) - 5)) - 1;
- while (i < length && get_cabac_bypass(&s->HEVClc->cc))
+ while (i < length && get_cabac_bypass(&lc->cc))
i++;
return i;
}
-int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
+int ff_hevc_sao_offset_sign_decode(HEVCLocalContext *lc)
{
- return get_cabac_bypass(&s->HEVClc->cc);
+ return get_cabac_bypass(&lc->cc);
}
-int ff_hevc_sao_eo_class_decode(HEVCContext *s)
+int ff_hevc_sao_eo_class_decode(HEVCLocalContext *lc)
{
- int ret = get_cabac_bypass(&s->HEVClc->cc) << 1;
- ret |= get_cabac_bypass(&s->HEVClc->cc);
+ int ret = get_cabac_bypass(&lc->cc) << 1;
+ ret |= get_cabac_bypass(&lc->cc);
return ret;
}
-int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
+int ff_hevc_end_of_slice_flag_decode(HEVCLocalContext *lc)
{
- return get_cabac_terminate(&s->HEVClc->cc);
+ return get_cabac_terminate(&lc->cc);
}
-int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
+int ff_hevc_cu_transquant_bypass_flag_decode(HEVCLocalContext *lc)
{
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 ff_hevc_skip_flag_decode(HEVCLocalContext *lc, int x0, int y0, int x_cb,
int y_cb)
{
+ const HEVCContext *const s = lc->parent;
int min_cb_width = s->ps.sps->min_cb_width;
int inc = 0;
int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
- if (s->HEVClc->ctb_left_flag || x0b)
+ if (lc->ctb_left_flag || x0b)
inc = !!SAMPLE_CTB(s->skip_flag, x_cb - 1, y_cb);
- if (s->HEVClc->ctb_up_flag || y0b)
+ if (lc->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 ff_hevc_cu_qp_delta_abs(HEVCLocalContext *lc)
{
int prefix_val = 0;
int suffix_val = 0;
@@ -648,34 +653,34 @@ int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
}
if (prefix_val >= 5) {
int k = 0;
- while (k < 7 && get_cabac_bypass(&s->HEVClc->cc)) {
+ while (k < 7 && get_cabac_bypass(&lc->cc)) {
suffix_val += 1 << k;
k++;
}
if (k == 7) {
- av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
+ av_log(lc->logctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
return AVERROR_INVALIDDATA;
}
while (k--)
- suffix_val += get_cabac_bypass(&s->HEVClc->cc) << k;
+ suffix_val += get_cabac_bypass(&lc->cc) << k;
}
return prefix_val + suffix_val;
}
-int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
+int ff_hevc_cu_qp_delta_sign_flag(HEVCLocalContext *lc)
{
- return get_cabac_bypass(&s->HEVClc->cc);
+ return get_cabac_bypass(&lc->cc);
}
-int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
+int ff_hevc_cu_chroma_qp_offset_flag(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_FLAG]);
}
-int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
+int ff_hevc_cu_chroma_qp_offset_idx(HEVCLocalContext *lc)
{
- int c_max= FFMAX(5, s->ps.pps->chroma_qp_offset_list_len_minus1);
+ int c_max= FFMAX(5, lc->parent->ps.pps->chroma_qp_offset_list_len_minus1);
int i = 0;
while (i < c_max && GET_CABAC(elem_offset[CU_CHROMA_QP_OFFSET_IDX]))
@@ -684,23 +689,25 @@ int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
return i;
}
-int ff_hevc_pred_mode_decode(HEVCContext *s)
+int ff_hevc_pred_mode_decode(HEVCLocalContext *lc)
{
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 ff_hevc_split_coding_unit_flag_decode(HEVCLocalContext *lc, int ct_depth,
int x0, int y0)
{
+ const HEVCContext *const s = lc->parent;
+ const HEVCSPS *const sps = s->ps.sps;
int inc = 0, depth_left = 0, depth_top = 0;
- int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
- int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
- int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
- int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
+ int x0b = av_mod_uintp2(x0, sps->log2_ctb_size);
+ int y0b = av_mod_uintp2(y0, sps->log2_ctb_size);
+ int x_cb = x0 >> sps->log2_min_cb_size;
+ int y_cb = y0 >> sps->log2_min_cb_size;
- if (s->HEVClc->ctb_left_flag || x0b)
- depth_left = s->tab_ct_depth[(y_cb) * s->ps.sps->min_cb_width + x_cb -
1];
- if (s->HEVClc->ctb_up_flag || y0b)
- depth_top = s->tab_ct_depth[(y_cb - 1) * s->ps.sps->min_cb_width +
x_cb];
+ if (lc->ctb_left_flag || x0b)
+ depth_left = s->tab_ct_depth[(y_cb) * sps->min_cb_width + x_cb -
1];
+ if (lc->ctb_up_flag || y0b)
+ depth_top = s->tab_ct_depth[(y_cb - 1) * sps->min_cb_width + x_cb];
inc += (depth_left > ct_depth);
inc += (depth_top > ct_depth);
@@ -708,12 +715,12 @@ int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s,
int ct_depth, int x0,
return GET_CABAC(elem_offset[SPLIT_CODING_UNIT_FLAG] + inc);
}
-int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
+int ff_hevc_part_mode_decode(HEVCLocalContext *lc, int log2_cb_size)
{
if (GET_CABAC(elem_offset[PART_MODE])) // 1
return PART_2Nx2N;
- if (log2_cb_size == s->ps.sps->log2_min_cb_size) {
- if (s->HEVClc->cu.pred_mode == MODE_INTRA) // 0
+ if (log2_cb_size == lc->parent->ps.sps->log2_min_cb_size) {
+ if (lc->cu.pred_mode == MODE_INTRA) // 0
return PART_NxN;
if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
return PART_2NxN;
@@ -724,7 +731,7 @@ int ff_hevc_part_mode_decode(HEVCContext *s, int
log2_cb_size)
return PART_NxN; // 000
}
- if (!s->ps.sps->amp_enabled_flag) {
+ if (!lc->parent->ps.sps->amp_enabled_flag) {
if (GET_CABAC(elem_offset[PART_MODE] + 1)) // 01
return PART_2NxN;
return PART_Nx2N;
@@ -733,84 +740,84 @@ int ff_hevc_part_mode_decode(HEVCContext *s, int
log2_cb_size)
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
+ if (get_cabac_bypass(&lc->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
+ if (get_cabac_bypass(&lc->cc)) // 0001
return PART_nRx2N;
return PART_nLx2N; // 0000
}
-int ff_hevc_pcm_flag_decode(HEVCContext *s)
+int ff_hevc_pcm_flag_decode(HEVCLocalContext *lc)
{
- return get_cabac_terminate(&s->HEVClc->cc);
+ return get_cabac_terminate(&lc->cc);
}
-int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
+int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[PREV_INTRA_LUMA_PRED_FLAG]);
}
-int ff_hevc_mpm_idx_decode(HEVCContext *s)
+int ff_hevc_mpm_idx_decode(HEVCLocalContext *lc)
{
int i = 0;
- while (i < 2 && get_cabac_bypass(&s->HEVClc->cc))
+ while (i < 2 && get_cabac_bypass(&lc->cc))
i++;
return i;
}
-int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
+int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCLocalContext *lc)
{
int i;
- int value = get_cabac_bypass(&s->HEVClc->cc);
+ int value = get_cabac_bypass(&lc->cc);
for (i = 0; i < 4; i++)
- value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
+ value = (value << 1) | get_cabac_bypass(&lc->cc);
return value;
}
-int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
+int ff_hevc_intra_chroma_pred_mode_decode(HEVCLocalContext *lc)
{
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);
+ ret = get_cabac_bypass(&lc->cc) << 1;
+ ret |= get_cabac_bypass(&lc->cc);
return ret;
}
-int ff_hevc_merge_idx_decode(HEVCContext *s)
+int ff_hevc_merge_idx_decode(HEVCLocalContext *lc)
{
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))
+ while (i < lc->parent->sh.max_num_merge_cand-1 &&
get_cabac_bypass(&lc->cc))
i++;
}
return i;
}
-int ff_hevc_merge_flag_decode(HEVCContext *s)
+int ff_hevc_merge_flag_decode(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[MERGE_FLAG]);
}
-int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
+int ff_hevc_inter_pred_idc_decode(HEVCLocalContext *lc, 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))
+ if (GET_CABAC(elem_offset[INTER_PRED_IDC] + lc->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 ff_hevc_ref_idx_lx_decode(HEVCLocalContext *lc, int num_ref_idx_lx)
{
int i = 0;
int max = num_ref_idx_lx - 1;
@@ -819,87 +826,88 @@ int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int
num_ref_idx_lx)
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))
+ while (i < max && get_cabac_bypass(&lc->cc))
i++;
}
return i;
}
-int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
+int ff_hevc_mvp_lx_flag_decode(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[MVP_LX_FLAG]);
}
-int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
+int ff_hevc_no_residual_syntax_flag_decode(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[NO_RESIDUAL_DATA_FLAG]);
}
-static av_always_inline int abs_mvd_greater0_flag_decode(HEVCContext *s)
+static av_always_inline int abs_mvd_greater0_flag_decode(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[ABS_MVD_GREATER0_FLAG]);
}
-static av_always_inline int abs_mvd_greater1_flag_decode(HEVCContext *s)
+static av_always_inline int abs_mvd_greater1_flag_decode(HEVCLocalContext *lc)
{
return GET_CABAC(elem_offset[ABS_MVD_GREATER1_FLAG] + 1);
}
-static av_always_inline int mvd_decode(HEVCContext *s)
+static av_always_inline int mvd_decode(HEVCLocalContext *lc)
{
int ret = 2;
int k = 1;
- while (k < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc)) {
+ while (k < CABAC_MAX_BIN && get_cabac_bypass(&lc->cc)) {
ret += 1U << k;
k++;
}
if (k == CABAC_MAX_BIN) {
- av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
+ av_log(lc->logctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", k);
return 0;
}
while (k--)
- ret += get_cabac_bypass(&s->HEVClc->cc) << k;
- return get_cabac_bypass_sign(&s->HEVClc->cc, -ret);
+ ret += get_cabac_bypass(&lc->cc) << k;
+ return get_cabac_bypass_sign(&lc->cc, -ret);
}
-static av_always_inline int mvd_sign_flag_decode(HEVCContext *s)
+static av_always_inline int mvd_sign_flag_decode(HEVCLocalContext *lc)
{
- return get_cabac_bypass_sign(&s->HEVClc->cc, -1);
+ return get_cabac_bypass_sign(&lc->cc, -1);
}
-int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
+int ff_hevc_split_transform_flag_decode(HEVCLocalContext *lc, 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)
+int ff_hevc_cbf_cb_cr_decode(HEVCLocalContext *lc, int trafo_depth)
{
return GET_CABAC(elem_offset[CBF_CB_CR] + trafo_depth);
}
-int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
+int ff_hevc_cbf_luma_decode(HEVCLocalContext *lc, int trafo_depth)
{
return GET_CABAC(elem_offset[CBF_LUMA] + !trafo_depth);
}
-static int hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
+static int hevc_transform_skip_flag_decode(HEVCLocalContext *lc, int c_idx)
{
return GET_CABAC(elem_offset[TRANSFORM_SKIP_FLAG] + !!c_idx);
}
-static int explicit_rdpcm_flag_decode(HEVCContext *s, int c_idx)
+static int explicit_rdpcm_flag_decode(HEVCLocalContext *lc, int c_idx)
{
return GET_CABAC(elem_offset[EXPLICIT_RDPCM_FLAG] + !!c_idx);
}
-static int explicit_rdpcm_dir_flag_decode(HEVCContext *s, int c_idx)
+static int explicit_rdpcm_dir_flag_decode(HEVCLocalContext *lc, int c_idx)
{
return GET_CABAC(elem_offset[EXPLICIT_RDPCM_DIR_FLAG] + !!c_idx);
}
-int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
+int ff_hevc_log2_res_scale_abs(HEVCLocalContext *lc, int idx)
+{
int i =0;
while (i < 4 && GET_CABAC(elem_offset[LOG2_RES_SCALE_ABS] + 4 * idx + i))
@@ -908,11 +916,12 @@ int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx) {
return i;
}
-int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx) {
+int ff_hevc_res_scale_sign_flag(HEVCLocalContext *lc, int idx)
+{
return GET_CABAC(elem_offset[RES_SCALE_SIGN_FLAG] + idx);
}
-static av_always_inline void
last_significant_coeff_xy_prefix_decode(HEVCContext *s, int c_idx,
+static av_always_inline void
last_significant_coeff_xy_prefix_decode(HEVCLocalContext *lc, int c_idx,
int log2_size, int
*last_scx_prefix, int *last_scy_prefix)
{
int i = 0;
@@ -938,19 +947,19 @@ static av_always_inline void
last_significant_coeff_xy_prefix_decode(HEVCContext
*last_scy_prefix = i;
}
-static av_always_inline int last_significant_coeff_suffix_decode(HEVCContext
*s,
+static av_always_inline int
last_significant_coeff_suffix_decode(HEVCLocalContext *lc,
int
last_significant_coeff_prefix)
{
int i;
int length = (last_significant_coeff_prefix >> 1) - 1;
- int value = get_cabac_bypass(&s->HEVClc->cc);
+ int value = get_cabac_bypass(&lc->cc);
for (i = 1; i < length; i++)
- value = (value << 1) | get_cabac_bypass(&s->HEVClc->cc);
+ value = (value << 1) | get_cabac_bypass(&lc->cc);
return value;
}
-static av_always_inline int significant_coeff_group_flag_decode(HEVCContext
*s, int c_idx, int ctx_cg)
+static av_always_inline int
significant_coeff_group_flag_decode(HEVCLocalContext *lc, int c_idx, int ctx_cg)
{
int inc;
@@ -958,19 +967,19 @@ static av_always_inline int
significant_coeff_group_flag_decode(HEVCContext *s,
return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_GROUP_FLAG] + inc);
}
-static av_always_inline int significant_coeff_flag_decode(HEVCContext *s, int
x_c, int y_c,
+static av_always_inline int significant_coeff_flag_decode(HEVCLocalContext
*lc, int x_c, int y_c,
int offset, const uint8_t
*ctx_idx_map)
{
int inc = ctx_idx_map[(y_c << 2) + x_c] + offset;
return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + inc);
}
-static av_always_inline int significant_coeff_flag_decode_0(HEVCContext *s,
int c_idx, int offset)
+static av_always_inline int significant_coeff_flag_decode_0(HEVCLocalContext
*lc, int c_idx, int offset)
{
return GET_CABAC(elem_offset[SIGNIFICANT_COEFF_FLAG] + offset);
}
-static av_always_inline int coeff_abs_level_greater1_flag_decode(HEVCContext
*s, int c_idx, int inc)
+static av_always_inline int
coeff_abs_level_greater1_flag_decode(HEVCLocalContext *lc, int c_idx, int inc)
{
if (c_idx > 0)
@@ -979,7 +988,7 @@ static av_always_inline int
coeff_abs_level_greater1_flag_decode(HEVCContext *s,
return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER1_FLAG] + inc);
}
-static av_always_inline int coeff_abs_level_greater2_flag_decode(HEVCContext
*s, int c_idx, int inc)
+static av_always_inline int
coeff_abs_level_greater2_flag_decode(HEVCLocalContext *lc, int c_idx, int inc)
{
if (c_idx > 0)
inc += 4;
@@ -987,47 +996,47 @@ static av_always_inline int
coeff_abs_level_greater2_flag_decode(HEVCContext *s,
return GET_CABAC(elem_offset[COEFF_ABS_LEVEL_GREATER2_FLAG] + inc);
}
-static av_always_inline int coeff_abs_level_remaining_decode(HEVCContext *s,
int rc_rice_param)
+static av_always_inline int coeff_abs_level_remaining_decode(HEVCLocalContext
*lc, int rc_rice_param)
{
int prefix = 0;
int suffix = 0;
int last_coeff_abs_level_remaining;
int i;
- while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&s->HEVClc->cc))
+ while (prefix < CABAC_MAX_BIN && get_cabac_bypass(&lc->cc))
prefix++;
if (prefix < 3) {
for (i = 0; i < rc_rice_param; i++)
- suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
+ suffix = (suffix << 1) | get_cabac_bypass(&lc->cc);
last_coeff_abs_level_remaining = (prefix << rc_rice_param) + suffix;
} else {
int prefix_minus3 = prefix - 3;
if (prefix == CABAC_MAX_BIN || prefix_minus3 + rc_rice_param > 16 + 6)
{
- av_log(s->avctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
+ av_log(lc->logctx, AV_LOG_ERROR, "CABAC_MAX_BIN : %d\n", prefix);
return 0;
}
for (i = 0; i < prefix_minus3 + rc_rice_param; i++)
- suffix = (suffix << 1) | get_cabac_bypass(&s->HEVClc->cc);
+ suffix = (suffix << 1) | get_cabac_bypass(&lc->cc);
last_coeff_abs_level_remaining = (((1 << prefix_minus3) + 3 - 1)
<< rc_rice_param) + suffix;
}
return last_coeff_abs_level_remaining;
}
-static av_always_inline int coeff_sign_flag_decode(HEVCContext *s, uint8_t nb)
+static av_always_inline int coeff_sign_flag_decode(HEVCLocalContext *lc,
uint8_t nb)
{
int i;
int ret = 0;
for (i = 0; i < nb; i++)
- ret = (ret << 1) | get_cabac_bypass(&s->HEVClc->cc);
+ ret = (ret << 1) | get_cabac_bypass(&lc->cc);
return ret;
}
-void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
+void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0,
int log2_trafo_size, enum ScanType scan_idx,
int c_idx)
{
@@ -1036,7 +1045,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
x_c = (x_cg << 2) + scan_x_off[n]; \
y_c = (y_cg << 2) + scan_y_off[n]; \
} while (0)
- HEVCLocalContext *lc = s->HEVClc;
+ const HEVCContext *const s = lc->parent;
int transform_skip_flag = 0;
int last_significant_coeff_x, last_significant_coeff_y;
@@ -1091,7 +1100,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
if (s->ps.pps->transform_skip_enabled_flag &&
log2_trafo_size <= s->ps.pps->log2_max_transform_skip_block_size) {
- transform_skip_flag = hevc_transform_skip_flag_decode(s, c_idx);
+ transform_skip_flag = hevc_transform_skip_flag_decode(lc, c_idx);
}
if (c_idx == 0) {
@@ -1150,24 +1159,24 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int
x0, int y0,
if (lc->cu.pred_mode == MODE_INTER &&
s->ps.sps->explicit_rdpcm_enabled_flag &&
(transform_skip_flag || lc->cu.cu_transquant_bypass_flag)) {
- explicit_rdpcm_flag = explicit_rdpcm_flag_decode(s, c_idx);
+ explicit_rdpcm_flag = explicit_rdpcm_flag_decode(lc, c_idx);
if (explicit_rdpcm_flag) {
- explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(s, c_idx);
+ explicit_rdpcm_dir_flag = explicit_rdpcm_dir_flag_decode(lc,
c_idx);
}
}
- last_significant_coeff_xy_prefix_decode(s, c_idx, log2_trafo_size,
+ last_significant_coeff_xy_prefix_decode(lc, c_idx, log2_trafo_size,
&last_significant_coeff_x,
&last_significant_coeff_y);
if (last_significant_coeff_x > 3) {
- int suffix = last_significant_coeff_suffix_decode(s,
last_significant_coeff_x);
+ int suffix = last_significant_coeff_suffix_decode(lc,
last_significant_coeff_x);
last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) -
1)) *
(2 + (last_significant_coeff_x & 1)) +
suffix;
}
if (last_significant_coeff_y > 3) {
- int suffix = last_significant_coeff_suffix_decode(s,
last_significant_coeff_y);
+ int suffix = last_significant_coeff_suffix_decode(lc,
last_significant_coeff_y);
last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) -
1)) *
(2 + (last_significant_coeff_y & 1)) +
suffix;
@@ -1246,7 +1255,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
significant_coeff_group_flag[x_cg][y_cg] =
- significant_coeff_group_flag_decode(s, c_idx, ctx_cg);
+ significant_coeff_group_flag_decode(lc, c_idx, ctx_cg);
implicit_non_zero_coeff = 1;
} else {
significant_coeff_group_flag[x_cg][y_cg] =
@@ -1313,7 +1322,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
for (n = n_end; n > 0; n--) {
x_c = scan_x_off[n];
y_c = scan_y_off[n];
- if (significant_coeff_flag_decode(s, x_c, y_c, scf_offset,
ctx_idx_map_p)) {
+ if (significant_coeff_flag_decode(lc, x_c, y_c, scf_offset,
ctx_idx_map_p)) {
significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
nb_significant_coeff_flag++;
implicit_non_zero_coeff = 0;
@@ -1337,7 +1346,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
scf_offset = 2 + scf_offset;
}
}
- if (significant_coeff_flag_decode_0(s, c_idx, scf_offset) ==
1) {
+ if (significant_coeff_flag_decode_0(lc, c_idx, scf_offset) ==
1) {
significant_coeff_flag_idx[nb_significant_coeff_flag] = 0;
nb_significant_coeff_flag++;
}
@@ -1381,7 +1390,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
int inc = (ctx_set << 2) + greater1_ctx;
coeff_abs_level_greater1_flag[m] =
- coeff_abs_level_greater1_flag_decode(s, c_idx, inc);
+ coeff_abs_level_greater1_flag_decode(lc, c_idx, inc);
if (coeff_abs_level_greater1_flag[m]) {
greater1_ctx = 0;
if (first_greater1_coeff_idx == -1)
@@ -1402,12 +1411,12 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int
x0, int y0,
sign_hidden = (last_nz_pos_in_cg - first_nz_pos_in_cg >= 4);
if (first_greater1_coeff_idx != -1) {
- coeff_abs_level_greater1_flag[first_greater1_coeff_idx] +=
coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
+ coeff_abs_level_greater1_flag[first_greater1_coeff_idx] +=
coeff_abs_level_greater2_flag_decode(lc, c_idx, ctx_set);
}
if (!s->ps.pps->sign_data_hiding_flag || !sign_hidden ) {
- coeff_sign_flag = coeff_sign_flag_decode(s,
nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
+ coeff_sign_flag = coeff_sign_flag_decode(lc,
nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
} else {
- coeff_sign_flag = coeff_sign_flag_decode(s,
nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
+ coeff_sign_flag = coeff_sign_flag_decode(lc,
nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
}
for (m = 0; m < n_end; m++) {
@@ -1416,7 +1425,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
if (m < 8) {
trans_coeff_level = 1 + coeff_abs_level_greater1_flag[m];
if (trans_coeff_level == ((m == first_greater1_coeff_idx)
? 3 : 2)) {
- int last_coeff_abs_level_remaining =
coeff_abs_level_remaining_decode(s, c_rice_param);
+ int last_coeff_abs_level_remaining =
coeff_abs_level_remaining_decode(lc, c_rice_param);
trans_coeff_level += last_coeff_abs_level_remaining;
if (trans_coeff_level > (3 << c_rice_param))
@@ -1432,7 +1441,7 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int x0,
int y0,
}
}
} else {
- int last_coeff_abs_level_remaining =
coeff_abs_level_remaining_decode(s, c_rice_param);
+ int last_coeff_abs_level_remaining =
coeff_abs_level_remaining_decode(lc, c_rice_param);
trans_coeff_level = 1 + last_coeff_abs_level_remaining;
if (trans_coeff_level > (3 << c_rice_param))
@@ -1537,26 +1546,25 @@ void ff_hevc_hls_residual_coding(HEVCContext *s, int
x0, int y0,
s->hevcdsp.add_residual[log2_trafo_size-2](dst, coeffs, stride);
}
-void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
+void ff_hevc_hls_mvd_coding(HEVCLocalContext *lc, int x0, int y0, int
log2_cb_size)
{
- HEVCLocalContext *lc = s->HEVClc;
- int x = abs_mvd_greater0_flag_decode(s);
- int y = abs_mvd_greater0_flag_decode(s);
+ int x = abs_mvd_greater0_flag_decode(lc);
+ int y = abs_mvd_greater0_flag_decode(lc);
if (x)
- x += abs_mvd_greater1_flag_decode(s);
+ x += abs_mvd_greater1_flag_decode(lc);
if (y)
- y += abs_mvd_greater1_flag_decode(s);
+ y += abs_mvd_greater1_flag_decode(lc);
switch (x) {
- case 2: lc->pu.mvd.x = mvd_decode(s); break;
- case 1: lc->pu.mvd.x = mvd_sign_flag_decode(s); break;
+ case 2: lc->pu.mvd.x = mvd_decode(lc); break;
+ case 1: lc->pu.mvd.x = mvd_sign_flag_decode(lc); break;
case 0: lc->pu.mvd.x = 0; break;
}
switch (y) {
- case 2: lc->pu.mvd.y = mvd_decode(s); break;
- case 1: lc->pu.mvd.y = mvd_sign_flag_decode(s); break;
+ case 2: lc->pu.mvd.y = mvd_decode(lc); break;
+ case 1: lc->pu.mvd.y = mvd_sign_flag_decode(lc); break;
case 0: lc->pu.mvd.y = 0; break;
}
}
diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c
index 7d4de414cd..b3965932e9 100644
--- a/libavcodec/hevcdec.c
+++ b/libavcodec/hevcdec.c
@@ -1017,11 +1017,11 @@ static void hls_sao_param(HEVCContext *s, int rx, int
ry)
s->sh.slice_sample_adaptive_offset_flag[1]) {
if (rx > 0) {
if (lc->ctb_left_flag)
- sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
+ sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(lc);
}
if (ry > 0 && !sao_merge_left_flag) {
if (lc->ctb_up_flag)
- sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
+ sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(lc);
}
}
@@ -1038,27 +1038,27 @@ static void hls_sao_param(HEVCContext *s, int rx, int
ry)
sao->type_idx[2] = sao->type_idx[1];
sao->eo_class[2] = sao->eo_class[1];
} else {
- SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
+ SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(lc));
}
if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
continue;
for (i = 0; i < 4; i++)
- SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
+ SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(lc));
if (sao->type_idx[c_idx] == SAO_BAND) {
for (i = 0; i < 4; i++) {
if (sao->offset_abs[c_idx][i]) {
SET_SAO(offset_sign[c_idx][i],
- ff_hevc_sao_offset_sign_decode(s));
+ ff_hevc_sao_offset_sign_decode(lc));
} else {
sao->offset_sign[c_idx][i] = 0;
}
}
- SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
+ SET_SAO(band_position[c_idx],
ff_hevc_sao_band_position_decode(lc));
} else if (c_idx != 2) {
- SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
+ SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(lc));
}
// Inferred parameters
@@ -1081,10 +1081,10 @@ static void hls_sao_param(HEVCContext *s, int rx, int
ry)
static int hls_cross_component_pred(HEVCContext *s, int idx) {
HEVCLocalContext *lc = s->HEVClc;
- int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
+ int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(lc, idx);
if (log2_res_scale_abs_plus1 != 0) {
- int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
+ int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(lc, idx);
lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
(1 - 2 * res_scale_sign_flag);
} else {
@@ -1120,9 +1120,9 @@ static int hls_transform_unit(HEVCContext *s, int x0, int
y0,
(cbf_cb[1] || cbf_cr[1]));
if (s->ps.pps->cu_qp_delta_enabled_flag &&
!lc->tu.is_cu_qp_delta_coded) {
- lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(s);
+ lc->tu.cu_qp_delta = ff_hevc_cu_qp_delta_abs(lc);
if (lc->tu.cu_qp_delta != 0)
- if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
+ if (ff_hevc_cu_qp_delta_sign_flag(lc) == 1)
lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
lc->tu.is_cu_qp_delta_coded = 1;
@@ -1142,11 +1142,11 @@ static int hls_transform_unit(HEVCContext *s, int x0,
int y0,
if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
!lc->cu.cu_transquant_bypass_flag &&
!lc->tu.is_cu_chroma_qp_offset_coded) {
- int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
+ int cu_chroma_qp_offset_flag =
ff_hevc_cu_chroma_qp_offset_flag(lc);
if (cu_chroma_qp_offset_flag) {
int cu_chroma_qp_offset_idx = 0;
if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
- cu_chroma_qp_offset_idx =
ff_hevc_cu_chroma_qp_offset_idx(s);
+ cu_chroma_qp_offset_idx =
ff_hevc_cu_chroma_qp_offset_idx(lc);
av_log(s->avctx, AV_LOG_ERROR,
"cu_chroma_qp_offset_idx not yet tested.\n");
}
@@ -1180,7 +1180,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int
y0,
lc->tu.cross_pf = 0;
if (cbf_luma)
- ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx,
0);
+ ff_hevc_hls_residual_coding(lc, x0, y0, log2_trafo_size, scan_idx,
0);
if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
@@ -1197,7 +1197,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int
y0,
s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i <<
log2_trafo_size_c), 1);
}
if (cbf_cb[i])
- ff_hevc_hls_residual_coding(s, x0, y0 + (i <<
log2_trafo_size_c),
+ ff_hevc_hls_residual_coding(lc, x0, y0 + (i <<
log2_trafo_size_c),
log2_trafo_size_c, scan_idx_c,
1);
else
if (lc->tu.cross_pf) {
@@ -1227,7 +1227,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int
y0,
s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i <<
log2_trafo_size_c), 2);
}
if (cbf_cr[i])
- ff_hevc_hls_residual_coding(s, x0, y0 + (i <<
log2_trafo_size_c),
+ ff_hevc_hls_residual_coding(lc, x0, y0 + (i <<
log2_trafo_size_c),
log2_trafo_size_c, scan_idx_c,
2);
else
if (lc->tu.cross_pf) {
@@ -1256,7 +1256,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int
y0,
s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase +
(i << log2_trafo_size), 1);
}
if (cbf_cb[i])
- ff_hevc_hls_residual_coding(s, xBase, yBase + (i <<
log2_trafo_size),
+ ff_hevc_hls_residual_coding(lc, xBase, yBase + (i <<
log2_trafo_size),
log2_trafo_size, scan_idx_c,
1);
}
for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
@@ -1266,7 +1266,7 @@ static int hls_transform_unit(HEVCContext *s, int x0, int
y0,
s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase +
(i << log2_trafo_size), 2);
}
if (cbf_cr[i])
- ff_hevc_hls_residual_coding(s, xBase, yBase + (i <<
log2_trafo_size),
+ ff_hevc_hls_residual_coding(lc, xBase, yBase + (i <<
log2_trafo_size),
log2_trafo_size, scan_idx_c,
2);
}
}
@@ -1355,7 +1355,7 @@ static int hls_transform_tree(HEVCContext *s, int x0, int
y0,
log2_trafo_size > s->ps.sps->log2_min_tb_size &&
trafo_depth < lc->cu.max_trafo_depth &&
!(lc->cu.intra_split_flag && trafo_depth == 0)) {
- split_transform_flag = ff_hevc_split_transform_flag_decode(s,
log2_trafo_size);
+ split_transform_flag = ff_hevc_split_transform_flag_decode(lc,
log2_trafo_size);
} else {
int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0
&&
lc->cu.pred_mode == MODE_INTER &&
@@ -1369,16 +1369,16 @@ static int hls_transform_tree(HEVCContext *s, int x0,
int y0,
if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 ||
s->ps.sps->chroma_format_idc == 3)) {
if (trafo_depth == 0 || cbf_cb[0]) {
- cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
+ cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag ||
log2_trafo_size == 3)) {
- cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
+ cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
}
}
if (trafo_depth == 0 || cbf_cr[0]) {
- cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
+ cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag ||
log2_trafo_size == 3)) {
- cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
+ cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
}
}
}
@@ -1412,7 +1412,7 @@ do {
if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
cbf_cb[0] || cbf_cr[0] ||
(s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
- cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
+ cbf_luma = ff_hevc_cbf_luma_decode(lc, trafo_depth);
}
ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
@@ -1825,15 +1825,15 @@ static void hevc_luma_mv_mvp_mode(HEVCContext *s, int
x0, int y0, int nPbW,
ff_hevc_set_neighbour_available(lc, x0, y0, nPbW, nPbH);
mv->pred_flag = 0;
if (s->sh.slice_type == HEVC_SLICE_B)
- inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
+ inter_pred_idc = ff_hevc_inter_pred_idc_decode(lc, nPbW, nPbH);
if (inter_pred_idc != PRED_L1) {
if (s->sh.nb_refs[L0])
- mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
+ mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(lc, s->sh.nb_refs[L0]);
mv->pred_flag = PF_L0;
- ff_hevc_hls_mvd_coding(s, x0, y0, 0);
- mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
+ ff_hevc_hls_mvd_coding(lc, x0, y0, 0);
+ mvp_flag = ff_hevc_mvp_lx_flag_decode(lc);
ff_hevc_luma_mv_mvp_mode(lc, x0, y0, nPbW, nPbH, log2_cb_size,
part_idx, merge_idx, mv, mvp_flag, 0);
mv->mv[0].x += lc->pu.mvd.x;
@@ -1842,16 +1842,16 @@ static void hevc_luma_mv_mvp_mode(HEVCContext *s, int
x0, int y0, int nPbW,
if (inter_pred_idc != PRED_L0) {
if (s->sh.nb_refs[L1])
- mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
+ mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(lc, s->sh.nb_refs[L1]);
if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
AV_ZERO32(&lc->pu.mvd);
} else {
- ff_hevc_hls_mvd_coding(s, x0, y0, 1);
+ ff_hevc_hls_mvd_coding(lc, x0, y0, 1);
}
mv->pred_flag += PF_L1;
- mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
+ mvp_flag = ff_hevc_mvp_lx_flag_decode(lc);
ff_hevc_luma_mv_mvp_mode(lc, x0, y0, nPbW, nPbH, log2_cb_size,
part_idx, merge_idx, mv, mvp_flag, 1);
mv->mv[1].x += lc->pu.mvd.x;
@@ -1888,11 +1888,11 @@ static void hls_prediction_unit(HEVCContext *s, int x0,
int y0,
int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
if (!skip_flag)
- lc->pu.merge_flag = ff_hevc_merge_flag_decode(s);
+ lc->pu.merge_flag = ff_hevc_merge_flag_decode(lc);
if (skip_flag || lc->pu.merge_flag) {
if (s->sh.max_num_merge_cand > 1)
- merge_idx = ff_hevc_merge_idx_decode(s);
+ merge_idx = ff_hevc_merge_idx_decode(lc);
else
merge_idx = 0;
@@ -2096,14 +2096,14 @@ static void intra_prediction_unit(HEVCContext *s, int
x0, int y0,
for (i = 0; i < side; i++)
for (j = 0; j < side; j++)
- prev_intra_luma_pred_flag[2 * i + j] =
ff_hevc_prev_intra_luma_pred_flag_decode(s);
+ prev_intra_luma_pred_flag[2 * i + j] =
ff_hevc_prev_intra_luma_pred_flag_decode(lc);
for (i = 0; i < side; i++) {
for (j = 0; j < side; j++) {
if (prev_intra_luma_pred_flag[2 * i + j])
- lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(s);
+ lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(lc);
else
- lc->pu.rem_intra_luma_pred_mode =
ff_hevc_rem_intra_luma_pred_mode_decode(s);
+ lc->pu.rem_intra_luma_pred_mode =
ff_hevc_rem_intra_luma_pred_mode_decode(lc);
lc->pu.intra_pred_mode[2 * i + j] =
luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i,
pb_size,
@@ -2114,7 +2114,7 @@ static void intra_prediction_unit(HEVCContext *s, int x0,
int y0,
if (s->ps.sps->chroma_format_idc == 3) {
for (i = 0; i < side; i++) {
for (j = 0; j < side; j++) {
- lc->pu.chroma_mode_c[2 * i + j] = chroma_mode =
ff_hevc_intra_chroma_pred_mode_decode(s);
+ lc->pu.chroma_mode_c[2 * i + j] = chroma_mode =
ff_hevc_intra_chroma_pred_mode_decode(lc);
if (chroma_mode != 4) {
if (lc->pu.intra_pred_mode[2 * i + j] ==
intra_chroma_table[chroma_mode])
lc->pu.intra_pred_mode_c[2 * i + j] = 34;
@@ -2127,7 +2127,7 @@ static void intra_prediction_unit(HEVCContext *s, int x0,
int y0,
}
} else if (s->ps.sps->chroma_format_idc == 2) {
int mode_idx;
- lc->pu.chroma_mode_c[0] = chroma_mode =
ff_hevc_intra_chroma_pred_mode_decode(s);
+ lc->pu.chroma_mode_c[0] = chroma_mode =
ff_hevc_intra_chroma_pred_mode_decode(lc);
if (chroma_mode != 4) {
if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
mode_idx = 34;
@@ -2138,7 +2138,7 @@ static void intra_prediction_unit(HEVCContext *s, int x0,
int y0,
}
lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
} else if (s->ps.sps->chroma_format_idc != 0) {
- chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
+ chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(lc);
if (chroma_mode != 4) {
if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
lc->pu.intra_pred_mode_c[0] = 34;
@@ -2196,14 +2196,14 @@ static int hls_coding_unit(HEVCContext *s, int x0, int
y0, int log2_cb_size)
for (x = 0; x < 4; x++)
lc->pu.intra_pred_mode[x] = 1;
if (s->ps.pps->transquant_bypass_enable_flag) {
- lc->cu.cu_transquant_bypass_flag =
ff_hevc_cu_transquant_bypass_flag_decode(s);
+ lc->cu.cu_transquant_bypass_flag =
ff_hevc_cu_transquant_bypass_flag_decode(lc);
if (lc->cu.cu_transquant_bypass_flag)
set_deblocking_bypass(s, x0, y0, log2_cb_size);
} else
lc->cu.cu_transquant_bypass_flag = 0;
if (s->sh.slice_type != HEVC_SLICE_I) {
- uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
+ uint8_t skip_flag = ff_hevc_skip_flag_decode(lc, x0, y0, x_cb, y_cb);
x = y_cb * min_cb_width + x_cb;
for (y = 0; y < length; y++) {
@@ -2229,10 +2229,10 @@ static int hls_coding_unit(HEVCContext *s, int x0, int
y0, int log2_cb_size)
int pcm_flag = 0;
if (s->sh.slice_type != HEVC_SLICE_I)
- lc->cu.pred_mode = ff_hevc_pred_mode_decode(s);
+ lc->cu.pred_mode = ff_hevc_pred_mode_decode(lc);
if (lc->cu.pred_mode != MODE_INTRA ||
log2_cb_size == s->ps.sps->log2_min_cb_size) {
- lc->cu.part_mode = ff_hevc_part_mode_decode(s,
log2_cb_size);
+ lc->cu.part_mode = ff_hevc_part_mode_decode(lc,
log2_cb_size);
lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
lc->cu.pred_mode == MODE_INTRA;
}
@@ -2241,7 +2241,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int
y0, int log2_cb_size)
if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag
&&
log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
- pcm_flag = ff_hevc_pcm_flag_decode(s);
+ pcm_flag = ff_hevc_pcm_flag_decode(lc);
}
if (pcm_flag) {
intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
@@ -2298,7 +2298,7 @@ static int hls_coding_unit(HEVCContext *s, int x0, int
y0, int log2_cb_size)
if (lc->cu.pred_mode != MODE_INTRA &&
!(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
- rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
+ rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(lc);
}
if (rqt_root_cbf) {
const static int cbf[2] = { 0 };
@@ -2348,7 +2348,7 @@ static int hls_coding_quadtree(HEVCContext *s, int x0,
int y0,
if (x0 + cb_size <= s->ps.sps->width &&
y0 + cb_size <= s->ps.sps->height &&
log2_cb_size > s->ps.sps->log2_min_cb_size) {
- split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
+ split_cu = ff_hevc_split_coding_unit_flag_decode(lc, cb_depth, x0, y0);
} else {
split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
}
@@ -2411,7 +2411,7 @@ static int hls_coding_quadtree(HEVCContext *s, int x0,
int y0,
(!((y0 + cb_size) %
(1 << (s->ps.sps->log2_ctb_size))) ||
(y0 + cb_size >= s->ps.sps->height))) {
- int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
+ int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(lc);
return !end_of_slice_flag;
} else {
return 1;
@@ -2501,7 +2501,7 @@ static int hls_decode_entry(AVCodecContext *avctxt, void
*isFilterThread)
y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >>
s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
- ret = ff_hevc_cabac_init(s, ctb_addr_ts);
+ ret = ff_hevc_cabac_init(lc, ctb_addr_ts);
if (ret < 0) {
s->tab_slice_address[ctb_addr_rs] = -1;
return ret;
@@ -2521,7 +2521,7 @@ static int hls_decode_entry(AVCodecContext *avctxt, void
*isFilterThread)
ctb_addr_ts++;
- ff_hevc_save_states(s, ctb_addr_ts);
+ ff_hevc_save_states(lc, ctb_addr_ts);
ff_hevc_hls_filters(lc, x_ctb, y_ctb, ctb_size);
}
@@ -2579,7 +2579,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt,
void *input_ctb_row, int
return 0;
}
- ret = ff_hevc_cabac_init(s, ctb_addr_ts);
+ ret = ff_hevc_cabac_init(lc, ctb_addr_ts);
if (ret < 0)
goto error;
hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >>
s->ps.sps->log2_ctb_size);
@@ -2592,7 +2592,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctxt,
void *input_ctb_row, int
ctb_addr_ts++;
- ff_hevc_save_states(s, ctb_addr_ts);
+ ff_hevc_save_states(lc, ctb_addr_ts);
ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
ff_hevc_hls_filters(lc, x_ctb, y_ctb, ctb_size);
diff --git a/libavcodec/hevcdec.h b/libavcodec/hevcdec.h
index b97b7d1354..b33e8ae0f6 100644
--- a/libavcodec/hevcdec.h
+++ b/libavcodec/hevcdec.h
@@ -604,38 +604,38 @@ int ff_hevc_frame_rps(HEVCContext *s);
*/
int ff_hevc_slice_rpl(HEVCContext *s);
-void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts);
-int ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts);
-int ff_hevc_sao_merge_flag_decode(HEVCContext *s);
-int ff_hevc_sao_type_idx_decode(HEVCContext *s);
-int ff_hevc_sao_band_position_decode(HEVCContext *s);
-int ff_hevc_sao_offset_abs_decode(HEVCContext *s);
-int ff_hevc_sao_offset_sign_decode(HEVCContext *s);
-int ff_hevc_sao_eo_class_decode(HEVCContext *s);
-int ff_hevc_end_of_slice_flag_decode(HEVCContext *s);
-int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s);
-int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0,
+void ff_hevc_save_states(HEVCLocalContext *lc, int ctb_addr_ts);
+int ff_hevc_cabac_init(HEVCLocalContext *lc, int ctb_addr_ts);
+int ff_hevc_sao_merge_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_sao_type_idx_decode(HEVCLocalContext *lc);
+int ff_hevc_sao_band_position_decode(HEVCLocalContext *lc);
+int ff_hevc_sao_offset_abs_decode(HEVCLocalContext *lc);
+int ff_hevc_sao_offset_sign_decode(HEVCLocalContext *lc);
+int ff_hevc_sao_eo_class_decode(HEVCLocalContext *lc);
+int ff_hevc_end_of_slice_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_cu_transquant_bypass_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_skip_flag_decode(HEVCLocalContext *lc, int x0, int y0,
int x_cb, int y_cb);
-int ff_hevc_pred_mode_decode(HEVCContext *s);
-int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth,
+int ff_hevc_pred_mode_decode(HEVCLocalContext *lc);
+int ff_hevc_split_coding_unit_flag_decode(HEVCLocalContext *lc, int ct_depth,
int x0, int y0);
-int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size);
-int ff_hevc_pcm_flag_decode(HEVCContext *s);
-int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s);
-int ff_hevc_mpm_idx_decode(HEVCContext *s);
-int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s);
-int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s);
-int ff_hevc_merge_idx_decode(HEVCContext *s);
-int ff_hevc_merge_flag_decode(HEVCContext *s);
-int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH);
-int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx);
-int ff_hevc_mvp_lx_flag_decode(HEVCContext *s);
-int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s);
-int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size);
-int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth);
-int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth);
-int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx);
-int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx);
+int ff_hevc_part_mode_decode(HEVCLocalContext *lc, int log2_cb_size);
+int ff_hevc_pcm_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_mpm_idx_decode(HEVCLocalContext *lc);
+int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCLocalContext *lc);
+int ff_hevc_intra_chroma_pred_mode_decode(HEVCLocalContext *lc);
+int ff_hevc_merge_idx_decode(HEVCLocalContext *lc);
+int ff_hevc_merge_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_inter_pred_idc_decode(HEVCLocalContext *lc, int nPbW, int nPbH);
+int ff_hevc_ref_idx_lx_decode(HEVCLocalContext *lc, int num_ref_idx_lx);
+int ff_hevc_mvp_lx_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_no_residual_syntax_flag_decode(HEVCLocalContext *lc);
+int ff_hevc_split_transform_flag_decode(HEVCLocalContext *lc, int
log2_trafo_size);
+int ff_hevc_cbf_cb_cr_decode(HEVCLocalContext *lc, int trafo_depth);
+int ff_hevc_cbf_luma_decode(HEVCLocalContext *lc, int trafo_depth);
+int ff_hevc_log2_res_scale_abs(HEVCLocalContext *lc, int idx);
+int ff_hevc_res_scale_sign_flag(HEVCLocalContext *lc, int idx);
/**
* Get the number of candidate references for the current frame.
@@ -686,15 +686,15 @@ void ff_hevc_set_qPy(HEVCLocalContext *lc, int xBase, int
yBase,
int log2_cb_size);
void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, int x0, int
y0,
int log2_trafo_size);
-int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s);
-int ff_hevc_cu_qp_delta_abs(HEVCContext *s);
-int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s);
-int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s);
-void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0,
+int ff_hevc_cu_qp_delta_sign_flag(HEVCLocalContext *lc);
+int ff_hevc_cu_qp_delta_abs(HEVCLocalContext *lc);
+int ff_hevc_cu_chroma_qp_offset_flag(HEVCLocalContext *lc);
+int ff_hevc_cu_chroma_qp_offset_idx(HEVCLocalContext *lc);
+void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, int x0, int y0,
int log2_trafo_size, enum ScanType scan_idx,
int c_idx);
-void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size);
+void ff_hevc_hls_mvd_coding(HEVCLocalContext *lc, int x0, int y0, int
log2_cb_size);
extern const uint8_t ff_hevc_qpel_extra_before[4];
extern const uint8_t ff_hevc_qpel_extra_after[4];
--
2.34.1
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
To unsubscribe, visit link above, or email
ffmpeg-devel-requ...@ffmpeg.org with subject "unsubscribe".
