diff --git a/libavcodec/hevc/cabac.c b/libavcodec/hevc/cabac.c index 5b53815630..fa4c7ebf86 100644 --- a/libavcodec/hevc/cabac.c +++ b/libavcodec/hevc/cabac.c @@ -429,17 +429,17 @@ static int cabac_reinit(HEVCLocalContext *lc) static void cabac_init_state(HEVCLocalContext *lc, const HEVCContext *s) { - int init_type = 2 - s->sh.slice_type; + int init_type = 2 - lc->sh->slice_type; int i; - if (s->sh.cabac_init_flag && s->sh.slice_type != HEVC_SLICE_I) + if (lc->sh->cabac_init_flag && lc->sh->slice_type != HEVC_SLICE_I) 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(s->sh.slice_qp, 0, 51)) >> 4) + n) - 127; + int pre = 2 * (((m * av_clip(lc->sh->slice_qp, 0, 51)) >> 4) + n) - 127; pre ^= pre >> 31; if (pre > 124) @@ -476,24 +476,24 @@ int ff_hevc_cabac_init(HEVCLocalContext *lc, const HEVCPPS *pps, const HEVCSPS *const sps = pps->sps; HEVCSubstream *const sub = &lc->sub; - if (ctb_addr_ts == pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]) { + if (ctb_addr_ts == pps->ctb_addr_rs_to_ts[lc->sh->slice_ctb_addr_rs]) { /* First CTB of a slice segment. For a dependent slice segment the * data still belongs to the new segment. */ int ret = ff_init_cabac_decoder(&sub->cc, sub->data, sub->size); if (ret < 0) return ret; sub->opened = 1; - if (s->sh.dependent_slice_segment_flag == 0 || + if (lc->sh->dependent_slice_segment_flag == 0 || (pps->tiles_enabled_flag && pps->tile_id[ctb_addr_ts] != pps->tile_id[ctb_addr_ts - 1])) cabac_init_state(lc, s); - if (!s->sh.first_slice_in_pic_flag && + if (!lc->sh->first_slice_in_pic_flag && pps->entropy_coding_sync_enabled_flag) { if (ctb_addr_ts % sps->ctb_width == 0) { if (sps->ctb_width == 1) cabac_init_state(lc, s); - else if (s->sh.dependent_slice_segment_flag == 1) + else if (lc->sh->dependent_slice_segment_flag == 1) load_states(lc, sps); } } @@ -752,7 +752,7 @@ int ff_hevc_merge_idx_decode(HEVCLocalContext *lc) int i = GET_CABAC(MERGE_IDX_OFFSET); if (i != 0) { - while (i < lc->parent->sh.max_num_merge_cand-1 && get_cabac_bypass(&lc->sub.cc)) + while (i < lc->sh->max_num_merge_cand-1 && get_cabac_bypass(&lc->sub.cc)) i++; } return i; @@ -1146,10 +1146,10 @@ void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, const HEVCPPS *pps, int qp_i, offset; if (c_idx == 1) - offset = pps->cb_qp_offset + s->sh.slice_cb_qp_offset + + offset = pps->cb_qp_offset + lc->sh->slice_cb_qp_offset + lc->sub.cu_qp_offset_cb; else - offset = pps->cr_qp_offset + s->sh.slice_cr_qp_offset + + offset = pps->cr_qp_offset + lc->sh->slice_cr_qp_offset + lc->sub.cu_qp_offset_cr; qp_i = av_clip(qp_y + offset, - sps->qp_bd_offset, 57); diff --git a/libavcodec/hevc/filter.c b/libavcodec/hevc/filter.c index 1769014602..2042a583b1 100644 --- a/libavcodec/hevc/filter.c +++ b/libavcodec/hevc/filter.c @@ -96,7 +96,7 @@ static int get_qPy_pred(HEVCLocalContext *lc, const HEVCContext *s, // qPy_pred if (lc->sub.first_qp_group || (!xQgBase && !yQgBase)) { lc->sub.first_qp_group = !lc->tu.is_cu_qp_delta_coded; - qPy_pred = s->sh.slice_qp; + qPy_pred = lc->sh->slice_qp; } else { qPy_pred = lc->sub.qPy_pred; } @@ -693,13 +693,16 @@ static av_always_inline int mvf_run_equal(const MvField *a, const MvField *b, in } } -static int boundary_strength(const HEVCContext *s, const MvField *curr, const MvField *neigh, +/* rpl is the reference list of the slice curr belongs to, neigh_refPicList + * the one of the neighbour. */ +static int boundary_strength(const RefPicList *rpl, + const MvField *curr, const MvField *neigh, const RefPicList *neigh_refPicList) { if (curr->pred_flag == PF_BI && neigh->pred_flag == PF_BI) { // same L0 and L1 - if (s->cur_frame->refPicList[0].list[curr->ref_idx[0]] == neigh_refPicList[0].list[neigh->ref_idx[0]] && - s->cur_frame->refPicList[0].list[curr->ref_idx[0]] == s->cur_frame->refPicList[1].list[curr->ref_idx[1]] && + if (rpl[0].list[curr->ref_idx[0]] == neigh_refPicList[0].list[neigh->ref_idx[0]] && + rpl[0].list[curr->ref_idx[0]] == rpl[1].list[curr->ref_idx[1]] && neigh_refPicList[0].list[neigh->ref_idx[0]] == neigh_refPicList[1].list[neigh->ref_idx[1]]) { if ((FFABS(neigh->mv[0].x - curr->mv[0].x) >= 4 || FFABS(neigh->mv[0].y - curr->mv[0].y) >= 4 || FFABS(neigh->mv[1].x - curr->mv[1].x) >= 4 || FFABS(neigh->mv[1].y - curr->mv[1].y) >= 4) && @@ -708,15 +711,15 @@ static int boundary_strength(const HEVCContext *s, const MvField *curr, const Mv return 1; else return 0; - } else if (neigh_refPicList[0].list[neigh->ref_idx[0]] == s->cur_frame->refPicList[0].list[curr->ref_idx[0]] && - neigh_refPicList[1].list[neigh->ref_idx[1]] == s->cur_frame->refPicList[1].list[curr->ref_idx[1]]) { + } else if (neigh_refPicList[0].list[neigh->ref_idx[0]] == rpl[0].list[curr->ref_idx[0]] && + neigh_refPicList[1].list[neigh->ref_idx[1]] == rpl[1].list[curr->ref_idx[1]]) { if (FFABS(neigh->mv[0].x - curr->mv[0].x) >= 4 || FFABS(neigh->mv[0].y - curr->mv[0].y) >= 4 || FFABS(neigh->mv[1].x - curr->mv[1].x) >= 4 || FFABS(neigh->mv[1].y - curr->mv[1].y) >= 4) return 1; else return 0; - } else if (neigh_refPicList[1].list[neigh->ref_idx[1]] == s->cur_frame->refPicList[0].list[curr->ref_idx[0]] && - neigh_refPicList[0].list[neigh->ref_idx[0]] == s->cur_frame->refPicList[1].list[curr->ref_idx[1]]) { + } else if (neigh_refPicList[1].list[neigh->ref_idx[1]] == rpl[0].list[curr->ref_idx[0]] && + neigh_refPicList[0].list[neigh->ref_idx[0]] == rpl[1].list[curr->ref_idx[1]]) { if (FFABS(neigh->mv[1].x - curr->mv[0].x) >= 4 || FFABS(neigh->mv[1].y - curr->mv[0].y) >= 4 || FFABS(neigh->mv[0].x - curr->mv[1].x) >= 4 || FFABS(neigh->mv[0].y - curr->mv[1].y) >= 4) return 1; @@ -731,10 +734,10 @@ static int boundary_strength(const HEVCContext *s, const MvField *curr, const Mv if (curr->pred_flag & 1) { A = curr->mv[0]; - ref_A = s->cur_frame->refPicList[0].list[curr->ref_idx[0]]; + ref_A = rpl[0].list[curr->ref_idx[0]]; } else { A = curr->mv[1]; - ref_A = s->cur_frame->refPicList[1].list[curr->ref_idx[1]]; + ref_A = rpl[1].list[curr->ref_idx[1]]; } if (neigh->pred_flag & 1) { @@ -775,7 +778,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer boundary_upper = y0 > 0 && !(y0 & 7); if (boundary_upper && - ((!s->sh.slice_loop_filter_across_slices_enabled_flag && + ((!lc->sh->slice_loop_filter_across_slices_enabled_flag && lc->boundary_flags & BOUNDARY_UPPER_SLICE && (y0 % (1 << sps->log2_ctb_size)) == 0) || ((!pps->loop_filter_across_tiles_enabled_flag || lc->tile_bs_defer) && @@ -786,8 +789,8 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer if (boundary_upper) { const RefPicList *rpl_top = (lc->boundary_flags & BOUNDARY_UPPER_SLICE) ? ff_hevc_get_ref_list(s->cur_frame, x0, y0 - 1) : - s->cur_frame->refPicList; - int same_rpl = rpl_top == s->cur_frame->refPicList; + lc->rpl; + int same_rpl = rpl_top == lc->rpl; int yp_pu = (y0 - 1) >> log2_min_pu_size; int yq_pu = y0 >> log2_min_pu_size; int yp_tu = (y0 - 1) >> log2_min_tu_size; @@ -808,7 +811,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer else if (same_rpl && mvf_equal(curr, top)) bs = 0; else - bs = boundary_strength(s, curr, top, rpl_top); + bs = boundary_strength(lc->rpl, curr, top, rpl_top); l->horizontal_bs[((x0 + i) + y0 * l->bs_width) >> 2] = bs; } } @@ -816,7 +819,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer // bs for vertical TU boundaries boundary_left = x0 > 0 && !(x0 & 7); if (boundary_left && - ((!s->sh.slice_loop_filter_across_slices_enabled_flag && + ((!lc->sh->slice_loop_filter_across_slices_enabled_flag && lc->boundary_flags & BOUNDARY_LEFT_SLICE && (x0 % (1 << sps->log2_ctb_size)) == 0) || ((!pps->loop_filter_across_tiles_enabled_flag || lc->tile_bs_defer) && @@ -827,8 +830,8 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer if (boundary_left) { const RefPicList *rpl_left = (lc->boundary_flags & BOUNDARY_LEFT_SLICE) ? ff_hevc_get_ref_list(s->cur_frame, x0 - 1, y0) : - s->cur_frame->refPicList; - int same_rpl = rpl_left == s->cur_frame->refPicList; + lc->rpl; + int same_rpl = rpl_left == lc->rpl; int xp_pu = (x0 - 1) >> log2_min_pu_size; int xq_pu = x0 >> log2_min_pu_size; int xp_tu = (x0 - 1) >> log2_min_tu_size; @@ -849,13 +852,13 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer else if (same_rpl && mvf_equal(curr, left)) bs = 0; else - bs = boundary_strength(s, curr, left, rpl_left); + bs = boundary_strength(lc->rpl, curr, left, rpl_left); l->vertical_bs[(x0 + (y0 + i) * l->bs_width) >> 2] = bs; } } if (log2_trafo_size > log2_min_pu_size && !is_intra) { - const RefPicList *rpl = s->cur_frame->refPicList; + const RefPicList *rpl = lc->rpl; // whole edge lines can be tested at once when there is one MvField entry per 4px segment if (log2_min_pu_size == 2 && log2_trafo_size >= 4 && log2_trafo_size <= 6) { @@ -873,7 +876,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer memset(bs_h, 0, n); } else { for (i = 0; i < n; i++) - bs_h[i] = mvf_equal(&curr[i], &top[i]) ? 0 : boundary_strength(s, &curr[i], &top[i], rpl); + bs_h[i] = mvf_equal(&curr[i], &top[i]) ? 0 : boundary_strength(rpl, &curr[i], &top[i], rpl); } } @@ -889,7 +892,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer bs_v[i] = 0; } else { for (i = 2; i < n; i += 2) - bs_v[i] = mvf_equal(&row[i], &row[i - 1]) ? 0 : boundary_strength(s, &row[i], &row[i - 1], rpl); + bs_v[i] = mvf_equal(&row[i], &row[i - 1]) ? 0 : boundary_strength(rpl, &row[i], &row[i - 1], rpl); } } return; @@ -905,7 +908,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer const MvField *top = &tab_mvf[yp_pu * min_pu_width + x_pu]; const MvField *curr = &tab_mvf[yq_pu * min_pu_width + x_pu]; - bs = mvf_equal(curr, top) ? 0 : boundary_strength(s, curr, top, rpl); + bs = mvf_equal(curr, top) ? 0 : boundary_strength(rpl, curr, top, rpl); l->horizontal_bs[((x0 + i) + (y0 + j) * l->bs_width) >> 2] = bs; } } @@ -920,7 +923,7 @@ void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayer const MvField *left = &tab_mvf[y_pu * min_pu_width + xp_pu]; const MvField *curr = &tab_mvf[y_pu * min_pu_width + xq_pu]; - bs = mvf_equal(curr, left) ? 0 : boundary_strength(s, curr, left, rpl); + bs = mvf_equal(curr, left) ? 0 : boundary_strength(rpl, curr, left, rpl); l->vertical_bs[((x0 + i) + (y0 + j) * l->bs_width) >> 2] = bs; } } @@ -943,7 +946,7 @@ void ff_hevc_tile_boundary_bs(HEVCLocalContext *lc, const HEVCLayerContext *l, if ((lc->boundary_flags & BOUNDARY_UPPER_TILE) && y0 > 0) { const RefPicList *rpl_top = (lc->boundary_flags & BOUNDARY_UPPER_SLICE) ? ff_hevc_get_ref_list(s->cur_frame, x0, y0 - 1) : - s->cur_frame->refPicList; + lc->rpl; int yp_pu = (y0 - 1) >> log2_min_pu_size, yq_pu = y0 >> log2_min_pu_size; int yp_tu = (y0 - 1) >> log2_min_tu_size, yq_tu = y0 >> log2_min_tu_size; int len = FFMIN(ctb_size, sps->width - x0); @@ -959,7 +962,7 @@ void ff_hevc_tile_boundary_bs(HEVCLocalContext *lc, const HEVCLayerContext *l, else if (curr_cbf || top_cbf) bs = 1; else - bs = boundary_strength(s, curr, top, rpl_top); + bs = boundary_strength(lc->rpl, curr, top, rpl_top); l->horizontal_bs[((x0 + i) + y0 * l->bs_width) >> 2] = bs; } } @@ -967,7 +970,7 @@ void ff_hevc_tile_boundary_bs(HEVCLocalContext *lc, const HEVCLayerContext *l, if ((lc->boundary_flags & BOUNDARY_LEFT_TILE) && x0 > 0) { const RefPicList *rpl_left = (lc->boundary_flags & BOUNDARY_LEFT_SLICE) ? ff_hevc_get_ref_list(s->cur_frame, x0 - 1, y0) : - s->cur_frame->refPicList; + lc->rpl; int xp_pu = (x0 - 1) >> log2_min_pu_size, xq_pu = x0 >> log2_min_pu_size; int xp_tu = (x0 - 1) >> log2_min_tu_size, xq_tu = x0 >> log2_min_tu_size; int len = FFMIN(ctb_size, sps->height - y0); @@ -983,7 +986,7 @@ void ff_hevc_tile_boundary_bs(HEVCLocalContext *lc, const HEVCLayerContext *l, else if (curr_cbf || left_cbf) bs = 1; else - bs = boundary_strength(s, curr, left, rpl_left); + bs = boundary_strength(lc->rpl, curr, left, rpl_left); l->vertical_bs[(x0 + (y0 + i) * l->bs_width) >> 2] = bs; } } @@ -1004,9 +1007,9 @@ void ff_hevc_hls_filter(HEVCLocalContext *lc, const HEVCLayerContext *l, if (s->avctx->skip_loop_filter >= AVDISCARD_ALL || (s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && !IS_IDR(s)) || (s->avctx->skip_loop_filter >= AVDISCARD_NONINTRA && - s->sh.slice_type != HEVC_SLICE_I) || + lc->sh->slice_type != HEVC_SLICE_I) || (s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && - s->sh.slice_type == HEVC_SLICE_B) || + lc->sh->slice_type == HEVC_SLICE_B) || (s->avctx->skip_loop_filter >= AVDISCARD_NONREF && ff_hevc_nal_is_nonref(s->nal_unit_type))) skip = 1; diff --git a/libavcodec/hevc/hevcdec.c b/libavcodec/hevc/hevcdec.c index 7680cd4154..90c903d0c6 100644 --- a/libavcodec/hevc/hevcdec.c +++ b/libavcodec/hevc/hevcdec.c @@ -1239,14 +1239,13 @@ static void hls_sao_param(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int rx, int ry) { - const HEVCContext *const s = lc->parent; int sao_merge_left_flag = 0; int sao_merge_up_flag = 0; SAOParams *sao = &CTB(l->sao, rx, ry); int c_idx, i; - if (s->sh.slice_sample_adaptive_offset_flag[0] || - s->sh.slice_sample_adaptive_offset_flag[1]) { + if (lc->sh->slice_sample_adaptive_offset_flag[0] || + lc->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(lc); @@ -1261,7 +1260,7 @@ static void hls_sao_param(HEVCLocalContext *lc, const HEVCLayerContext *l, int log2_sao_offset_scale = c_idx == 0 ? pps->log2_sao_offset_scale_luma : pps->log2_sao_offset_scale_chroma; - if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) { + if (!lc->sh->slice_sample_adaptive_offset_flag[c_idx]) { sao->type_idx[c_idx] = SAO_NOT_APPLIED; continue; } @@ -1375,7 +1374,7 @@ static int hls_transform_unit(HEVCLocalContext *lc, ff_hevc_set_qPy(lc, l, pps, cb_xBase, cb_yBase, log2_cb_size); } - if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma && + if (lc->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(lc); if (cu_chroma_qp_offset_flag) { @@ -1564,7 +1563,6 @@ static int hls_transform_tree(HEVCLocalContext *lc, int trafo_depth, int blk_idx, const int *base_cbf_cb, const int *base_cbf_cr) { - const HEVCContext *const s = lc->parent; uint8_t split_transform_flag; int cbf_cb[2]; int cbf_cr[2]; @@ -1673,7 +1671,7 @@ do { l->cbf_luma[y_tu * min_tu_width + x_tu] = 1; } } - if (!s->sh.disable_deblocking_filter_flag) { + if (!lc->sh->disable_deblocking_filter_flag) { ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_trafo_size); if (pps->transquant_bypass_enable_flag && lc->cu.cu_transquant_bypass_flag) @@ -1700,7 +1698,7 @@ static int hls_pcm_sample(HEVCLocalContext *lc, const HEVCLayerContext *l, const uint8_t *pcm = skip_bytes(&lc->sub.cc, (length + 7) >> 3); int ret; - if (!s->sh.disable_deblocking_filter_flag) + if (!lc->sh->disable_deblocking_filter_flag) ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_cb_size); ret = init_get_bits(&gb, pcm, length); @@ -1756,8 +1754,8 @@ static void luma_mc_uni(HEVCLocalContext *lc, int pic_height = sps->height; int mx = mv->x & 3; int my = mv->y & 3; - int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || - (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); + int weight_flag = (lc->sh->slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || + (lc->sh->slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); int idx = hevc_pel_weight[block_w]; x_off += mv->x >> 2; @@ -1787,7 +1785,7 @@ static void luma_mc_uni(HEVCLocalContext *lc, block_h, mx, my, block_w); else s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride, - block_h, s->sh.luma_log2_weight_denom, + block_h, lc->sh->luma_log2_weight_denom, luma_weight, luma_offset, mx, my, block_w); } @@ -1823,8 +1821,8 @@ static void luma_mc_bi(HEVCLocalContext *lc, int my0 = mv0->y & 3; int mx1 = mv1->x & 3; int my1 = mv1->y & 3; - int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || - (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); + int weight_flag = (lc->sh->slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || + (lc->sh->slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); int x_off0 = x_off + (mv0->x >> 2); int y_off0 = y_off + (mv0->y >> 2); int x_off1 = x_off + (mv1->x >> 2); @@ -1875,11 +1873,11 @@ static void luma_mc_bi(HEVCLocalContext *lc, block_h, mx1, my1, block_w); else s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp, - block_h, s->sh.luma_log2_weight_denom, - s->sh.luma_weight_l0[current_mv->ref_idx[0]], - s->sh.luma_weight_l1[current_mv->ref_idx[1]], - s->sh.luma_offset_l0[current_mv->ref_idx[0]] + - s->sh.luma_offset_l1[current_mv->ref_idx[1]], + block_h, lc->sh->luma_log2_weight_denom, + lc->sh->luma_weight_l0[current_mv->ref_idx[0]], + lc->sh->luma_weight_l1[current_mv->ref_idx[1]], + lc->sh->luma_offset_l0[current_mv->ref_idx[0]] + + lc->sh->luma_offset_l1[current_mv->ref_idx[1]], mx1, my1, block_w); } @@ -1912,8 +1910,8 @@ static void chroma_mc_uni(HEVCLocalContext *lc, int pic_width = sps->width >> sps->hshift[1]; int pic_height = sps->height >> sps->vshift[1]; const Mv *mv = ¤t_mv->mv[reflist]; - int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || - (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); + int weight_flag = (lc->sh->slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || + (lc->sh->slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); int idx = hevc_pel_weight[block_w]; int hshift = sps->hshift[1]; int vshift = sps->vshift[1]; @@ -1950,7 +1948,7 @@ static void chroma_mc_uni(HEVCLocalContext *lc, block_h, _mx, _my, block_w); else s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride, - block_h, s->sh.chroma_log2_weight_denom, + block_h, lc->sh->chroma_log2_weight_denom, chroma_weight, chroma_offset, _mx, _my, block_w); } @@ -1982,8 +1980,8 @@ static void chroma_mc_bi(HEVCLocalContext *lc, const uint8_t *src2 = ref1->data[cidx+1]; ptrdiff_t src1stride = ref0->linesize[cidx+1]; ptrdiff_t src2stride = ref1->linesize[cidx+1]; - int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || - (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); + int weight_flag = (lc->sh->slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) || + (lc->sh->slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag); int pic_width = sps->width >> sps->hshift[1]; int pic_height = sps->height >> sps->vshift[1]; const Mv *const mv0 = ¤t_mv->mv[0]; @@ -2056,11 +2054,11 @@ static void chroma_mc_bi(HEVCLocalContext *lc, s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->cur_frame->f->linesize[cidx+1], src2, src2stride, lc->tmp, block_h, - s->sh.chroma_log2_weight_denom, - s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx], - s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx], - s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx] + - s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx], + lc->sh->chroma_log2_weight_denom, + lc->sh->chroma_weight_l0[current_mv->ref_idx[0]][cidx], + lc->sh->chroma_weight_l1[current_mv->ref_idx[1]][cidx], + lc->sh->chroma_offset_l0[current_mv->ref_idx[0]][cidx] + + lc->sh->chroma_offset_l1[current_mv->ref_idx[1]][cidx], _mx1, _my1, block_w); } @@ -2080,18 +2078,17 @@ static void hevc_luma_mv_mvp_mode(HEVCLocalContext *lc, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv) { - const HEVCContext *const s = lc->parent; enum InterPredIdc inter_pred_idc = PRED_L0; int mvp_flag; ff_hevc_set_neighbour_available(lc, x0, y0, nPbW, nPbH, sps->log2_ctb_size); mv->pred_flag = 0; - if (s->sh.slice_type == HEVC_SLICE_B) + if (lc->sh->slice_type == HEVC_SLICE_B) 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(lc, s->sh.nb_refs[L0]); + if (lc->sh->nb_refs[L0]) + mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(lc, lc->sh->nb_refs[L0]); mv->pred_flag = PF_L0; ff_hevc_hls_mvd_coding(lc, x0, y0, 0); @@ -2103,10 +2100,10 @@ static void hevc_luma_mv_mvp_mode(HEVCLocalContext *lc, } if (inter_pred_idc != PRED_L0) { - if (s->sh.nb_refs[L1]) - mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(lc, s->sh.nb_refs[L1]); + if (lc->sh->nb_refs[L1]) + mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(lc, lc->sh->nb_refs[L1]); - if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) { + if (lc->sh->mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) { AV_ZERO32(&lc->pu.mvd); } else { ff_hevc_hls_mvd_coding(lc, x0, y0, 1); @@ -2138,7 +2135,7 @@ static void hls_prediction_unit(HEVCLocalContext *lc, int min_pu_width = sps->min_pu_width; MvField *tab_mvf = s->cur_frame->tab_mvf; - const RefPicList *refPicList = s->cur_frame->refPicList; + const RefPicList *refPicList = lc->rpl; const HEVCFrame *ref0 = NULL, *ref1 = NULL; const int *linesize = s->cur_frame->f->linesize; uint8_t *dst0 = s->cur_frame->f->data[0] + y0 * linesize[0] + (x0 << sps->pixel_shift); @@ -2157,7 +2154,7 @@ static void hls_prediction_unit(HEVCLocalContext *lc, 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) + if (lc->sh->max_num_merge_cand > 1) merge_idx = ff_hevc_merge_idx_decode(lc); else merge_idx = 0; @@ -2197,16 +2194,16 @@ static void hls_prediction_unit(HEVCLocalContext *lc, luma_mc_uni(lc, pps, sps, dst0, linesize[0], ref0->f, ¤t_mv.mv[0], x0, y0, nPbW, nPbH, - s->sh.luma_weight_l0[current_mv.ref_idx[0]], - s->sh.luma_offset_l0[current_mv.ref_idx[0]]); + lc->sh->luma_weight_l0[current_mv.ref_idx[0]], + lc->sh->luma_offset_l0[current_mv.ref_idx[0]]); if (sps->chroma_format_idc) { chroma_mc_uni(lc, pps, sps, dst1, linesize[1], ref0->f->data[1], ref0->f->linesize[1], 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, - s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]); + lc->sh->chroma_weight_l0[current_mv.ref_idx[0]][0], lc->sh->chroma_offset_l0[current_mv.ref_idx[0]][0]); chroma_mc_uni(lc, pps, sps, dst2, linesize[2], ref0->f->data[2], ref0->f->linesize[2], 0, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, - s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]); + lc->sh->chroma_weight_l0[current_mv.ref_idx[0]][1], lc->sh->chroma_offset_l0[current_mv.ref_idx[0]][1]); } } else if (current_mv.pred_flag == PF_L1) { int x0_c = x0 >> sps->hshift[1]; @@ -2216,17 +2213,17 @@ static void hls_prediction_unit(HEVCLocalContext *lc, luma_mc_uni(lc, pps, sps, dst0, linesize[0], ref1->f, ¤t_mv.mv[1], x0, y0, nPbW, nPbH, - s->sh.luma_weight_l1[current_mv.ref_idx[1]], - s->sh.luma_offset_l1[current_mv.ref_idx[1]]); + lc->sh->luma_weight_l1[current_mv.ref_idx[1]], + lc->sh->luma_offset_l1[current_mv.ref_idx[1]]); if (sps->chroma_format_idc) { chroma_mc_uni(lc, pps, sps, dst1, linesize[1], ref1->f->data[1], ref1->f->linesize[1], 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, - s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]); + lc->sh->chroma_weight_l1[current_mv.ref_idx[1]][0], lc->sh->chroma_offset_l1[current_mv.ref_idx[1]][0]); chroma_mc_uni(lc, pps, sps, dst2, linesize[2], ref1->f->data[2], ref1->f->linesize[2], 1, x0_c, y0_c, nPbW_c, nPbH_c, ¤t_mv, - s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]); + lc->sh->chroma_weight_l1[current_mv.ref_idx[1]][1], lc->sh->chroma_offset_l1[current_mv.ref_idx[1]][1]); } } else if (current_mv.pred_flag == PF_BI) { int x0_c = x0 >> sps->hshift[1]; @@ -2477,7 +2474,7 @@ static int hls_coding_unit(HEVCLocalContext *lc, const HEVCContext *s, } else lc->cu.cu_transquant_bypass_flag = 0; - if (s->sh.slice_type != HEVC_SLICE_I) { + if (lc->sh->slice_type != HEVC_SLICE_I) { const int x0b = av_zero_extend(x0, sps->log2_ctb_size); const int y0b = av_zero_extend(y0, sps->log2_ctb_size); uint8_t skip_flag = ff_hevc_skip_flag_decode(lc, l->skip_flag, @@ -2503,12 +2500,12 @@ static int hls_coding_unit(HEVCLocalContext *lc, const HEVCContext *s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx); intra_prediction_unit_default_value(lc, l, sps, x0, y0, log2_cb_size); - if (!s->sh.disable_deblocking_filter_flag) + if (!lc->sh->disable_deblocking_filter_flag) ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_cb_size); } else { int pcm_flag = 0; - if (s->sh.slice_type != HEVC_SLICE_I) + if (lc->sh->slice_type != HEVC_SLICE_I) lc->cu.pred_mode = ff_hevc_pred_mode_decode(lc); if (lc->cu.pred_mode != MODE_INTRA || log2_cb_size == sps->log2_min_cb_size) { @@ -2608,7 +2605,7 @@ static int hls_coding_unit(HEVCLocalContext *lc, const HEVCContext *s, if (ret < 0) return ret; } else { - if (!s->sh.disable_deblocking_filter_flag) + if (!lc->sh->disable_deblocking_filter_flag) ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_cb_size); } } @@ -2659,7 +2656,7 @@ static int hls_coding_quadtree(HEVCLocalContext *lc, lc->tu.cu_qp_delta = 0; } - if (s->sh.cu_chroma_qp_offset_enabled_flag && + if (lc->sh->cu_chroma_qp_offset_enabled_flag && log2_cb_size >= sps->log2_ctb_size - pps->diff_cu_chroma_qp_offset_depth) { lc->tu.is_cu_chroma_qp_offset_coded = 0; } @@ -2731,14 +2728,13 @@ static void hls_decode_neighbour(HEVCLocalContext *lc, const HEVCPPS *pps, const HEVCSPS *sps, int x_ctb, int y_ctb, int ctb_addr_ts) { - const HEVCContext *const s = lc->parent; int ctb_size = 1 << sps->log2_ctb_size; int ctb_addr_rs = pps->ctb_addr_ts_to_rs[ctb_addr_ts]; - int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr; + int ctb_addr_in_slice = ctb_addr_rs - lc->sh->slice_addr; /* the tile-parallel path pre-fills this serially, workers only read it */ if (!lc->tile_bs_defer) - l->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr; + l->tab_slice_address[ctb_addr_rs] = lc->sh->slice_addr; if (pps->entropy_coding_sync_enabled_flag) { if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0) @@ -2789,13 +2785,13 @@ static int hls_decode_entry(HEVCContext *s, GetBitContext *gb) int more_data = 1; int x_ctb = 0; int y_ctb = 0; - int ctb_addr_ts = pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs]; + int ctb_addr_ts = pps->ctb_addr_rs_to_ts[lc->sh->slice_ctb_addr_rs]; int ret; /* The slice segment is one buffer, so CABAC stays open across tile and * WPP row boundaries. */ - lc->sub.data = gb->buffer + s->sh.data_offset; - lc->sub.size = get_bits_bytesize(gb, 1) - s->sh.data_offset; + lc->sub.data = gb->buffer + lc->sh->data_offset; + lc->sub.size = get_bits_bytesize(gb, 1) - lc->sh->data_offset; lc->sub.opened = 0; while (more_data && ctb_addr_ts < sps->ctb_size) { @@ -2814,9 +2810,9 @@ static int hls_decode_entry(HEVCContext *s, GetBitContext *gb) hls_sao_param(lc, l, pps, sps, x_ctb >> sps->log2_ctb_size, y_ctb >> sps->log2_ctb_size); - l->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset; - l->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset; - l->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag; + l->deblock[ctb_addr_rs].beta_offset = lc->sh->beta_offset; + l->deblock[ctb_addr_rs].tc_offset = lc->sh->tc_offset; + l->filter_slice_edges[ctb_addr_rs] = lc->sh->slice_loop_filter_across_slices_enabled_flag; more_data = hls_coding_quadtree(lc, l, pps, sps, x_ctb, y_ctb, sps->log2_ctb_size, 0); if (more_data < 0) { @@ -2837,6 +2833,22 @@ static int hls_decode_entry(HEVCContext *s, GetBitContext *gb) return ctb_addr_ts; } +/* Bind lc to a slice without touching HEVCContext, so that tiles of + * different slices can be decoded interleaved. */ +static void bind_slice_ctx(HEVCLocalContext *lc, const SliceHeader *sh, + const RefPicList *rpl, const HEVCFrame *collocated_ref) +{ + lc->sh = sh; + lc->rpl = rpl; + lc->collocated_ref = collocated_ref; +} + +static void bind_current_slice(HEVCContext *s, HEVCLocalContext *lc) +{ + bind_slice_ctx(lc, &s->sh, s->cur_frame ? s->cur_frame->refPicList : NULL, + s->collocated_ref); +} + static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist, int job, int thread) { @@ -2848,7 +2860,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist, int ctb_size = 1 << sps->log2_ctb_size; int more_data = 1; int ctb_row = job; - int ctb_addr_rs = s->sh.slice_ctb_addr_rs + ctb_row * ((sps->width + ctb_size - 1) >> sps->log2_ctb_size); + int ctb_addr_rs = lc->sh->slice_ctb_addr_rs + ctb_row * ((sps->width + ctb_size - 1) >> sps->log2_ctb_size); int ctb_addr_ts = pps->ctb_addr_rs_to_ts[ctb_addr_rs]; int progress = 0; @@ -2856,8 +2868,8 @@ static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist, int ret; /* Substream of this row, opened at its first CTB */ - lc->sub.data = s->data + s->sh.offset[ctb_row]; - lc->sub.size = s->sh.size[ctb_row]; + lc->sub.data = s->data + lc->sh->offset[ctb_row]; + lc->sub.size = lc->sh->size[ctb_row]; lc->sub.opened = 0; /* Slices starting mid-row skip the initialization below */ @@ -2888,9 +2900,9 @@ static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist, hls_sao_param(lc, l, pps, sps, x_ctb >> sps->log2_ctb_size, y_ctb >> sps->log2_ctb_size); - l->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset; - l->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset; - l->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag; + l->deblock[ctb_addr_rs].beta_offset = lc->sh->beta_offset; + l->deblock[ctb_addr_rs].tc_offset = lc->sh->tc_offset; + l->filter_slice_edges[ctb_addr_rs] = lc->sh->slice_loop_filter_across_slices_enabled_flag; more_data = hls_coding_quadtree(lc, l, pps, sps, x_ctb, y_ctb, sps->log2_ctb_size, 0); @@ -2905,7 +2917,7 @@ static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist, ff_thread_progress_report(&s->wpp_progress[ctb_row], ++progress); ff_hevc_hls_filters(lc, l, pps, x_ctb, y_ctb, ctb_size); - if (!more_data && (x_ctb+ctb_size) < sps->width && ctb_row != s->sh.num_entry_point_offsets) { + if (!more_data && (x_ctb+ctb_size) < sps->width && ctb_row != lc->sh->num_entry_point_offsets) { /* Casting const away here is safe, because it is an atomic operation. */ atomic_store((atomic_int*)&s->wpp_err, 1); ff_thread_progress_report(&s->wpp_progress[ctb_row], INT_MAX); @@ -3061,6 +3073,7 @@ static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal) for (unsigned i = 1; i < s->nb_local_ctx; i++) { s->local_ctx[i].sub.first_qp_group = 1; s->local_ctx[i].sub.qp_y = s->local_ctx[0].sub.qp_y; + bind_current_slice(s, &s->local_ctx[i]); } atomic_store(&s->wpp_err, 0); @@ -3096,8 +3109,8 @@ static int hls_decode_entry_tile(AVCodecContext *avctx, void *hevc_lclist, int more_data = 1, ret; /* Substream of this tile, opened at its first CTB */ - lc->sub.data = s->data + s->sh.offset[job]; - lc->sub.size = s->sh.size[job]; + lc->sub.data = s->data + lc->sh->offset[job]; + lc->sub.size = lc->sh->size[job]; lc->sub.opened = 0; lc->tile_bs_defer = 1; @@ -3121,9 +3134,9 @@ static int hls_decode_entry_tile(AVCodecContext *avctx, void *hevc_lclist, hls_sao_param(lc, l, pps, sps, x_ctb >> sps->log2_ctb_size, y_ctb >> sps->log2_ctb_size); - l->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset; - l->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset; - l->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag; + l->deblock[ctb_addr_rs].beta_offset = lc->sh->beta_offset; + l->deblock[ctb_addr_rs].tc_offset = lc->sh->tc_offset; + l->filter_slice_edges[ctb_addr_rs] = lc->sh->slice_loop_filter_across_slices_enabled_flag; more_data = hls_coding_quadtree(lc, l, pps, sps, x_ctb, y_ctb, sps->log2_ctb_size, 0); if (more_data < 0) @@ -3155,6 +3168,7 @@ static int hls_slice_data_tiles(HEVCContext *s, const H2645NAL *nal) for (unsigned i = 1; i < s->nb_local_ctx; i++) { s->local_ctx[i].sub.first_qp_group = 1; s->local_ctx[i].sub.qp_y = s->local_ctx[0].sub.qp_y; + bind_current_slice(s, &s->local_ctx[i]); } for (ctb_addr_ts = start_ts; ctb_addr_ts < sps->ctb_size; ctb_addr_ts++) @@ -3241,6 +3255,9 @@ static int decode_slice_data(HEVCContext *s, const HEVCLayerContext *l, } } + /* All decoding paths below read the slice state from lc */ + bind_current_slice(s, &s->local_ctx[0]); + s->local_ctx[0].sub.first_qp_group = !s->sh.dependent_slice_segment_flag; if (!pps->cu_qp_delta_enabled_flag) diff --git a/libavcodec/hevc/hevcdec.h b/libavcodec/hevc/hevcdec.h index b6116e74a3..27efa4d012 100644 --- a/libavcodec/hevc/hevcdec.h +++ b/libavcodec/hevc/hevcdec.h @@ -411,6 +411,12 @@ typedef struct HEVCLocalContext { void *logctx; const struct HEVCContext *parent; + /* Slice being decoded, read instead of HEVCContext so that tiles of + * different slices can be decoded interleaved. */ + const SliceHeader *sh; + const RefPicList *rpl; ///< reference lists of that slice, NULL for I slices + const HEVCFrame *collocated_ref; ///< picture read by the temporal MVP, NULL if none + /** * This is a pointer to the common CABAC state. * In case entropy_coding_sync_enabled_flag is set, diff --git a/libavcodec/hevc/mvs.c b/libavcodec/hevc/mvs.c index 937c7cf753..b22b3e7ac6 100644 --- a/libavcodec/hevc/mvs.c +++ b/libavcodec/hevc/mvs.c @@ -161,11 +161,12 @@ static int check_mvset(Mv *mvLXCol, const Mv *mvCol, refPicList_col, L ## l, temp_col.ref_idx[l]) // derive the motion vectors section 8.5.3.1.8 -static int derive_temporal_colocated_mvs(const HEVCContext *s, MvField temp_col, +static int derive_temporal_colocated_mvs(const HEVCContext *s, + const HEVCLocalContext *lc, MvField temp_col, int refIdxLx, Mv *mvLXCol, int X, int colPic, const RefPicList *refPicList_col) { - const RefPicList *refPicList = s->cur_frame->refPicList; + const RefPicList *refPicList = lc->rpl; if (temp_col.pred_flag == PF_INTRA) return 0; @@ -191,7 +192,7 @@ static int derive_temporal_colocated_mvs(const HEVCContext *s, MvField temp_col, else return CHECK_MVSET(1); } else { - if (s->sh.collocated_list == L1) + if (lc->sh->collocated_list == L1) return CHECK_MVSET(0); else return CHECK_MVSET(1); @@ -209,14 +210,16 @@ static int derive_temporal_colocated_mvs(const HEVCContext *s, MvField temp_col, ((y ## v) >> sps->log2_min_pu_size)) #define DERIVE_TEMPORAL_COLOCATED_MVS \ - derive_temporal_colocated_mvs(s, temp_col, \ + derive_temporal_colocated_mvs(s, lc, temp_col, \ refIdxLx, mvLXCol, X, colPic, \ ff_hevc_get_ref_list(ref, x, y)) /* * 8.5.3.1.7 temporal luma motion vector prediction */ -static int temporal_luma_motion_vector(const HEVCContext *s, const HEVCSPS *sps, +static int temporal_luma_motion_vector(const HEVCContext *s, + const HEVCLocalContext *lc, + const HEVCSPS *sps, int x0, int y0, int nPbW, int nPbH, int refIdxLx, Mv *mvLXCol, int X) @@ -228,7 +231,7 @@ static int temporal_luma_motion_vector(const HEVCContext *s, const HEVCSPS *sps, int availableFlagLXCol = 0; int colPic; - const HEVCFrame *ref = s->collocated_ref; + const HEVCFrame *ref = lc->collocated_ref; if (!ref) { memset(mvLXCol, 0, sizeof(*mvLXCol)); @@ -293,7 +296,7 @@ static void derive_spatial_merge_candidates(HEVCLocalContext *lc, const HEVCCont int merge_idx, struct MvField mergecandlist[]) { - const RefPicList *refPicList = s->cur_frame->refPicList; + const RefPicList *refPicList = lc->rpl; const MvField *tab_mvf = s->cur_frame->tab_mvf; const int min_pu_width = sps->min_pu_width; @@ -319,8 +322,8 @@ static void derive_spatial_merge_candidates(HEVCLocalContext *lc, const HEVCCont const int xB2 = x0 - 1; const int yB2 = y0 - 1; - const int nb_refs = (s->sh.slice_type == HEVC_SLICE_P) ? - s->sh.nb_refs[0] : FFMIN(s->sh.nb_refs[0], s->sh.nb_refs[1]); + const int nb_refs = (lc->sh->slice_type == HEVC_SLICE_P) ? + lc->sh->nb_refs[0] : FFMIN(lc->sh->nb_refs[0], lc->sh->nb_refs[1]); int zero_idx = 0; @@ -410,13 +413,13 @@ static void derive_spatial_merge_candidates(HEVCLocalContext *lc, const HEVCCont } // temporal motion vector candidate - if (s->sh.slice_temporal_mvp_enabled_flag && - nb_merge_cand < s->sh.max_num_merge_cand) { + if (lc->sh->slice_temporal_mvp_enabled_flag && + nb_merge_cand < lc->sh->max_num_merge_cand) { Mv mv_l0_col = { 0 }, mv_l1_col = { 0 }; - int available_l0 = temporal_luma_motion_vector(s, sps, x0, y0, nPbW, nPbH, + int available_l0 = temporal_luma_motion_vector(s, lc, sps, x0, y0, nPbW, nPbH, 0, &mv_l0_col, 0); - int available_l1 = (s->sh.slice_type == HEVC_SLICE_B) ? - temporal_luma_motion_vector(s, sps, x0, y0, nPbW, nPbH, + int available_l1 = (lc->sh->slice_type == HEVC_SLICE_B) ? + temporal_luma_motion_vector(s, lc, sps, x0, y0, nPbW, nPbH, 0, &mv_l1_col, 1) : 0; if (available_l0 || available_l1) { @@ -434,11 +437,11 @@ static void derive_spatial_merge_candidates(HEVCLocalContext *lc, const HEVCCont nb_orig_merge_cand = nb_merge_cand; // combined bi-predictive merge candidates (applies for B slices) - if (s->sh.slice_type == HEVC_SLICE_B && nb_orig_merge_cand > 1 && - nb_orig_merge_cand < s->sh.max_num_merge_cand) { + if (lc->sh->slice_type == HEVC_SLICE_B && nb_orig_merge_cand > 1 && + nb_orig_merge_cand < lc->sh->max_num_merge_cand) { int comb_idx = 0; - for (comb_idx = 0; nb_merge_cand < s->sh.max_num_merge_cand && + for (comb_idx = 0; nb_merge_cand < lc->sh->max_num_merge_cand && comb_idx < nb_orig_merge_cand * (nb_orig_merge_cand - 1); comb_idx++) { int l0_cand_idx = l0_l1_cand_idx[comb_idx][0]; int l1_cand_idx = l0_l1_cand_idx[comb_idx][1]; @@ -462,8 +465,8 @@ static void derive_spatial_merge_candidates(HEVCLocalContext *lc, const HEVCCont } // append Zero motion vector candidates - while (nb_merge_cand < s->sh.max_num_merge_cand) { - mergecandlist[nb_merge_cand].pred_flag = PF_L0 + ((s->sh.slice_type == HEVC_SLICE_B) << 1); + while (nb_merge_cand < lc->sh->max_num_merge_cand) { + mergecandlist[nb_merge_cand].pred_flag = PF_L0 + ((lc->sh->slice_type == HEVC_SLICE_B) << 1); AV_ZERO32(mergecandlist[nb_merge_cand].mv + 0); AV_ZERO32(mergecandlist[nb_merge_cand].mv + 1); mergecandlist[nb_merge_cand].ref_idx[0] = zero_idx < nb_refs ? zero_idx : 0; @@ -514,11 +517,11 @@ void ff_hevc_luma_mv_merge_mode(HEVCLocalContext *lc, const HEVCPPS *pps, *mv = mergecand_list[merge_idx]; } -static av_always_inline void dist_scale(const HEVCContext *s, Mv *mv, +static av_always_inline void dist_scale(const HEVCContext *s, + const RefPicList *refPicList, Mv *mv, int min_pu_width, int x, int y, int elist, int ref_idx_curr, int ref_idx) { - const RefPicList *refPicList = s->cur_frame->refPicList; const MvField *tab_mvf = s->cur_frame->tab_mvf; int ref_pic_elist = refPicList[elist].list[TAB_MVF(x, y).ref_idx[elist]]; int ref_pic_curr = refPicList[ref_idx_curr].list[ref_idx]; @@ -531,15 +534,14 @@ static av_always_inline void dist_scale(const HEVCContext *s, Mv *mv, } } -static int mv_mp_mode_mx(const HEVCContext *s, const HEVCSPS *sps, +static int mv_mp_mode_mx(const HEVCContext *s, const RefPicList *refPicList, + const HEVCSPS *sps, int x, int y, int pred_flag_index, Mv *mv, int ref_idx_curr, int ref_idx) { const MvField *tab_mvf = s->cur_frame->tab_mvf; int min_pu_width = sps->min_pu_width; - const RefPicList *refPicList = s->cur_frame->refPicList; - if (((TAB_MVF(x, y).pred_flag) & (1 << pred_flag_index)) && refPicList[pred_flag_index].list[TAB_MVF(x, y).ref_idx[pred_flag_index]] == refPicList[ref_idx_curr].list[ref_idx]) { *mv = TAB_MVF(x, y).mv[pred_flag_index]; @@ -548,15 +550,14 @@ static int mv_mp_mode_mx(const HEVCContext *s, const HEVCSPS *sps, return 0; } -static int mv_mp_mode_mx_lt(const HEVCContext *s, const HEVCSPS *sps, +static int mv_mp_mode_mx_lt(const HEVCContext *s, const RefPicList *refPicList, + const HEVCSPS *sps, int x, int y, int pred_flag_index, Mv *mv, int ref_idx_curr, int ref_idx) { const MvField *tab_mvf = s->cur_frame->tab_mvf; int min_pu_width = sps->min_pu_width; - const RefPicList *refPicList = s->cur_frame->refPicList; - if ((TAB_MVF(x, y).pred_flag) & (1 << pred_flag_index)) { int currIsLongTerm = refPicList[ref_idx_curr].isLongTerm[ref_idx]; @@ -566,7 +567,7 @@ static int mv_mp_mode_mx_lt(const HEVCContext *s, const HEVCSPS *sps, if (colIsLongTerm == currIsLongTerm) { *mv = TAB_MVF(x, y).mv[pred_flag_index]; if (!currIsLongTerm) - dist_scale(s, mv, min_pu_width, x, y, + dist_scale(s, refPicList, mv, min_pu_width, x, y, pred_flag_index, ref_idx_curr, ref_idx); return 1; } @@ -575,13 +576,13 @@ static int mv_mp_mode_mx_lt(const HEVCContext *s, const HEVCSPS *sps, } #define MP_MX(v, pred, mx) \ - mv_mp_mode_mx(s, sps, \ + mv_mp_mode_mx(s, lc->rpl, sps, \ (x ## v) >> sps->log2_min_pu_size, \ (y ## v) >> sps->log2_min_pu_size, \ pred, &mx, ref_idx_curr, ref_idx) #define MP_MX_LT(v, pred, mx) \ - mv_mp_mode_mx_lt(s, sps, \ + mv_mp_mode_mx_lt(s, lc->rpl, sps, \ (x ## v) >> sps->log2_min_pu_size, \ (y ## v) >> sps->log2_min_pu_size, \ pred, &mx, ref_idx_curr, ref_idx) @@ -769,10 +770,10 @@ scalef: mvpcand_list[numMVPCandLX++] = mxB; //temporal motion vector prediction candidate - if (numMVPCandLX < 2 && s->sh.slice_temporal_mvp_enabled_flag && + if (numMVPCandLX < 2 && lc->sh->slice_temporal_mvp_enabled_flag && mvp_lx_flag == numMVPCandLX) { Mv mv_col; - int available_col = temporal_luma_motion_vector(s, sps, x0, y0, nPbW, + int available_col = temporal_luma_motion_vector(s, lc, sps, x0, y0, nPbW, nPbH, ref_idx, &mv_col, LX); if (available_col)