virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-02 03:06:28 +02:00
Code Issues Releases Activity

avcodec/vvcdec: refact out VVCRefPic from RefPicList

Browse Source
This commit is contained in:
Nuo Mi 2024-05-19 21:27:38 +08:00
parent 44bbafb69f
commit 66c6bee061
8 changed files with 52 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libavcodec/vvc/ctu.c
View File

@ -1263,8 +1263,8 @@ static void derive_mmvd(const VVCLocalContext *lc, MvField *mvf, const Mv *mmvd_
const RefPicList *rpl = sc->rpl;
const int poc = lc->fc->ps.ph.poc;
const int diff[] = {
poc - rpl[0].list[mvf->ref_idx[0]],
poc - rpl[1].list[mvf->ref_idx[1]]
poc - rpl[L0].refs[mvf->ref_idx[L0]].poc,
poc - rpl[L1].refs[mvf->ref_idx[L1]].poc
};
const int sign = FFSIGN(diff[0]) != FFSIGN(diff[1]);
@ -1275,7 +1275,7 @@ static void derive_mmvd(const VVCLocalContext *lc, MvField *mvf, const Mv *mmvd_
const int i = FFABS(diff[0]) < FFABS(diff[1]);
const int o = !i;
mmvd[i] = *mmvd_offset;
if (!rpl[0].isLongTerm[mvf->ref_idx[0]] && !rpl[1].isLongTerm[mvf->ref_idx[1]]) {
if (!rpl[L0].refs[mvf->ref_idx[L0]].is_lt && !rpl[L1].refs[mvf->ref_idx[L1]].is_lt) {
ff_vvc_mv_scale(&mmvd[o], mmvd_offset, diff[i], diff[o]);
}
else {
@ -1699,8 +1699,8 @@ static void derive_dmvr_bdof_flag(const VVCLocalContext *lc, PredictionUnit *pu)
pu->bdof_flag = 0;
if (mi->pred_flag == PF_BI &&
(poc - rpl0->list[ref_idx[L0]] == rpl1->list[ref_idx[L1]] - poc) &&
!rpl0->isLongTerm[ref_idx[L0]] && !rpl1->isLongTerm[ref_idx[L1]] &&
(poc - rpl0->refs[ref_idx[L0]].poc == rpl1->refs[ref_idx[L1]].poc - poc) &&
!rpl0->refs[ref_idx[L0]].is_lt && !rpl1->refs[ref_idx[L1]].is_lt &&
!cu->ciip_flag &&
!mi->bcw_idx &&
!w->weight_flag[L0][LUMA][mi->ref_idx[L0]] && !w->weight_flag[L1][LUMA][mi->ref_idx[L1]] &&

4
libavcodec/vvc/dec.c
View File

@ -403,8 +403,8 @@ static int8_t smvd_find(const VVCFrameContext *fc, const SliceContext *sc, int l
int8_t idx = -1;
int old_diff = -1;
for (int i = 0; i < rsh->num_ref_idx_active[lx]; i++) {
if (!rpl->isLongTerm[i]) {
int diff = poc - rpl->list[i];
if (!rpl->refs[i].is_lt) {
int diff = poc - rpl->refs[i].poc;
if (find(idx, diff, old_diff)) {
idx = i;
old_diff = diff;

10
libavcodec/vvc/dec.h
View File

@ -42,10 +42,14 @@
#define L0 0
#define L1 1
typedef struct VVCRefPic {
struct VVCFrame *ref;
int poc;
int is_lt; // is long term reference
} VVCRefPic;
typedef struct RefPicList {
struct VVCFrame *ref[VVC_MAX_REF_ENTRIES];
int list[VVC_MAX_REF_ENTRIES];
int isLongTerm[VVC_MAX_REF_ENTRIES];
VVCRefPic refs[VVC_MAX_REF_ENTRIES];
int nb_refs;
} RefPicList;

22
libavcodec/vvc/filter.c
View File

@ -321,9 +321,9 @@ static int boundary_strength(const VVCLocalContext *lc, const MvField *curr, con
if (curr->pred_flag == PF_BI && neigh->pred_flag == PF_BI) {
// same L0 and L1
if (rpl[0].list[curr->ref_idx[0]] == neigh_rpl[0].list[neigh->ref_idx[0]] &&
rpl[0].list[curr->ref_idx[0]] == rpl[1].list[curr->ref_idx[1]] &&
neigh_rpl[0].list[neigh->ref_idx[0]] == neigh_rpl[1].list[neigh->ref_idx[1]]) {
if (rpl[L0].refs[curr->ref_idx[L0]].poc == neigh_rpl[L0].refs[neigh->ref_idx[L0]].poc &&
rpl[L0].refs[curr->ref_idx[L0]].poc == rpl[L1].refs[curr->ref_idx[L1]].poc &&
neigh_rpl[L0].refs[neigh->ref_idx[L0]].poc == neigh_rpl[L1].refs[neigh->ref_idx[L1]].poc) {
if ((FFABS(neigh->mv[0].x - curr->mv[0].x) >= 8 || FFABS(neigh->mv[0].y - curr->mv[0].y) >= 8 ||
FFABS(neigh->mv[1].x - curr->mv[1].x) >= 8 || FFABS(neigh->mv[1].y - curr->mv[1].y) >= 8) &&
(FFABS(neigh->mv[1].x - curr->mv[0].x) >= 8 || FFABS(neigh->mv[1].y - curr->mv[0].y) >= 8 ||
@ -331,15 +331,15 @@ static int boundary_strength(const VVCLocalContext *lc, const MvField *curr, con
return 1;
else
return 0;
} else if (neigh_rpl[0].list[neigh->ref_idx[0]] == rpl[0].list[curr->ref_idx[0]] &&
neigh_rpl[1].list[neigh->ref_idx[1]] == rpl[1].list[curr->ref_idx[1]]) {
} else if (neigh_rpl[L0].refs[neigh->ref_idx[L0]].poc == rpl[L0].refs[curr->ref_idx[L0]].poc &&
neigh_rpl[L1].refs[neigh->ref_idx[L1]].poc == rpl[L1].refs[curr->ref_idx[L1]].poc) {
if (FFABS(neigh->mv[0].x - curr->mv[0].x) >= 8 || FFABS(neigh->mv[0].y - curr->mv[0].y) >= 8 ||
FFABS(neigh->mv[1].x - curr->mv[1].x) >= 8 || FFABS(neigh->mv[1].y - curr->mv[1].y) >= 8)
return 1;
else
return 0;
} else if (neigh_rpl[1].list[neigh->ref_idx[1]] == rpl[0].list[curr->ref_idx[0]] &&
neigh_rpl[0].list[neigh->ref_idx[0]] == rpl[1].list[curr->ref_idx[1]]) {
} else if (neigh_rpl[L1].refs[neigh->ref_idx[L1]].poc == rpl[L0].refs[curr->ref_idx[L0]].poc &&
neigh_rpl[L0].refs[neigh->ref_idx[L0]].poc == rpl[L1].refs[curr->ref_idx[L1]].poc) {
if (FFABS(neigh->mv[1].x - curr->mv[0].x) >= 8 || FFABS(neigh->mv[1].y - curr->mv[0].y) >= 8 ||
FFABS(neigh->mv[0].x - curr->mv[1].x) >= 8 || FFABS(neigh->mv[0].y - curr->mv[1].y) >= 8)
return 1;
@ -354,18 +354,18 @@ static int boundary_strength(const VVCLocalContext *lc, const MvField *curr, con
if (curr->pred_flag & 1) {
A = curr->mv[0];
ref_A = rpl[0].list[curr->ref_idx[0]];
ref_A = rpl[L0].refs[curr->ref_idx[L0]].poc;
} else {
A = curr->mv[1];
ref_A = rpl[1].list[curr->ref_idx[1]];
ref_A = rpl[L1].refs[curr->ref_idx[L1]].poc;
}
if (neigh->pred_flag & 1) {
B = neigh->mv[0];
ref_B = neigh_rpl[0].list[neigh->ref_idx[0]];
ref_B = neigh_rpl[L0].refs[neigh->ref_idx[L0]].poc;
} else {
B = neigh->mv[1];
ref_B = neigh_rpl[1].list[neigh->ref_idx[1]];
ref_B = neigh_rpl[L1].refs[neigh->ref_idx[L1]].poc;
}
if (ref_A == ref_B) {

4
libavcodec/vvc/inter.c
View File

@ -394,7 +394,7 @@ static int pred_get_refs(const VVCLocalContext *lc, VVCFrame *ref[2], const MvF
for (int mask = PF_L0; mask <= PF_L1; mask++) {
if (mv->pred_flag & mask) {
const int lx = mask - PF_L0;
ref[lx] = rpl[lx].ref[mv->ref_idx[lx]];
ref[lx] = rpl[lx].refs[mv->ref_idx[lx]].ref;
if (!ref[lx])
return AVERROR_INVALIDDATA;
}
@ -450,7 +450,7 @@ static void pred_gpm_blk(VVCLocalContext *lc)
for (int i = 0; i < 2; i++) {
const MvField *mv = pu->gpm_mv + i;
const int lx = mv->pred_flag - PF_L0;
VVCFrame *ref = lc->sc->rpl[lx].ref[mv->ref_idx[lx]];
VVCFrame *ref = lc->sc->rpl[lx].refs[mv->ref_idx[lx]].ref;
if (!ref)
return;
mc(lc, tmp[i], ref->frame, mv->mv + lx, x, y, width, height, c_idx);

36
libavcodec/vvc/mvs.c
View File

@ -88,8 +88,8 @@ static int check_mvset(Mv *mvLXCol, Mv *mvCol,
const RefPicList *refPicList, int X, int refIdxLx,
const RefPicList *refPicList_col, int listCol, int refidxCol)
{
int cur_lt = refPicList[X].isLongTerm[refIdxLx];
int col_lt = refPicList_col[listCol].isLongTerm[refidxCol];
int cur_lt = refPicList[X].refs[refIdxLx].is_lt;
int col_lt = refPicList_col[listCol].refs[refidxCol].is_lt;
int col_poc_diff, cur_poc_diff;
if (cur_lt != col_lt) {
@ -98,8 +98,8 @@ static int check_mvset(Mv *mvLXCol, Mv *mvCol,
return 0;
}
col_poc_diff = colPic - refPicList_col[listCol].list[refidxCol];
cur_poc_diff = poc - refPicList[X].list[refIdxLx];
col_poc_diff = colPic - refPicList_col[listCol].refs[refidxCol].poc;
cur_poc_diff = poc - refPicList[X].refs[refIdxLx].poc;
mv_compression(mvCol);
if (cur_lt || col_poc_diff == cur_poc_diff) {
@ -126,7 +126,7 @@ int ff_vvc_no_backward_pred_flag(const VVCLocalContext *lc)
for (j = 0; j < 2; j++) {
for (i = 0; i < lc->sc->sh.r->num_ref_idx_active[j]; i++) {
if (rpl[j].list[i] > lc->fc->ps.ph.poc) {
if (rpl[j].refs[i].poc > lc->fc->ps.ph.poc) {
check_diffpicount++;
break;
}
@ -1059,9 +1059,9 @@ static int sb_temporal_luma_motion_data(const VVCLocalContext *lc, const MvField
colPic = ref->poc;
if (a1) {
if ((a1->pred_flag & PF_L0) && colPic == rpl[0].list[a1->ref_idx[0]])
if ((a1->pred_flag & PF_L0) && colPic == rpl[L0].refs[a1->ref_idx[L0]].poc)
*temp_mv = a1->mv[0];
else if ((a1->pred_flag & PF_L1) && colPic == rpl[1].list[a1->ref_idx[1]])
else if ((a1->pred_flag & PF_L1) && colPic == rpl[L1].refs[a1->ref_idx[L1]].poc)
*temp_mv = a1->mv[1];
ff_vvc_round_mv(temp_mv, 0, 4);
}
@ -1418,16 +1418,16 @@ static int mvp_candidate(const VVCLocalContext *lc, const int x_cand, const int
const MvField* tab_mvf = fc->tab.mvf;
const MvField *mvf = &TAB_MVF(x_cand, y_cand);
const PredFlag maskx = lx + 1;
const int poc = rpl[lx].list[ref_idx[lx]];
const int poc = rpl[lx].refs[ref_idx[lx]].poc;
int available = 0;
if ((mvf->pred_flag & maskx) && rpl[lx].list[mvf->ref_idx[lx]] == poc) {
if ((mvf->pred_flag & maskx) && rpl[lx].refs[mvf->ref_idx[lx]].poc == poc) {
available = 1;
*mv = mvf->mv[lx];
} else {
const int ly = !lx;
const PredFlag masky = ly + 1;
if ((mvf->pred_flag & masky) && rpl[ly].list[mvf->ref_idx[ly]] == poc) {
if ((mvf->pred_flag & masky) && rpl[ly].refs[mvf->ref_idx[ly]].poc == poc) {
available = 1;
*mv = mvf->mv[ly];
}
@ -1450,15 +1450,15 @@ static int affine_mvp_candidate(const VVCLocalContext *lc,
const MvField *mvf = &TAB_MVF(x_nb, y_nb);
RefPicList* rpl = lc->sc->rpl;
const PredFlag maskx = lx + 1;
const int poc = rpl[lx].list[ref_idx[lx]];
const int poc = rpl[lx].refs[ref_idx[lx]].poc;
if ((mvf->pred_flag & maskx) && rpl[lx].list[mvf->ref_idx[lx]] == poc) {
if ((mvf->pred_flag & maskx) && rpl[lx].refs[mvf->ref_idx[lx]].poc == poc) {
available = 1;
affine_cps_from_nb(lc, x_nb, y_nb, nbw, nbh, lx, cps, num_cp);
} else {
const int ly = !lx;
const PredFlag masky = ly + 1;
if ((mvf->pred_flag & masky) && rpl[ly].list[mvf->ref_idx[ly]] == poc) {
if ((mvf->pred_flag & masky) && rpl[ly].refs[mvf->ref_idx[ly]].poc == poc) {
available = 1;
affine_cps_from_nb(lc, x_nb, y_nb, nbw, nbh, ly, cps, num_cp);
}
@ -1550,7 +1550,7 @@ static int mvp_history_candidates(const VVCLocalContext *lc,
{
const EntryPoint* ep = lc->ep;
const RefPicList* rpl = lc->sc->rpl;
const int poc = rpl[lx].list[ref_idx];
const int poc = rpl[lx].refs[ref_idx].poc;
if (ep->num_hmvp == 0)
return 0;
@ -1559,7 +1559,7 @@ static int mvp_history_candidates(const VVCLocalContext *lc,
for (int j = 0; j < 2; j++) {
const int ly = (j ? !lx : lx);
PredFlag mask = PF_L0 + ly;
if ((h->pred_flag & mask) && poc == rpl[ly].list[h->ref_idx[ly]]) {
if ((h->pred_flag & mask) && poc == rpl[ly].refs[h->ref_idx[ly]].poc) {
if (mvp_lx_flag == num_cands) {
*mv = h->mv[ly];
ff_vvc_round_mv(mv, amvr_shift, amvr_shift);
@ -1725,14 +1725,14 @@ static int affine_mvp_constructed_cp(NeighbourContext *ctx,
if (check_available(n, ctx->lc, 0)) {
const PredFlag maskx = lx + 1;
const MvField* mvf = &TAB_MVF(n->x, n->y);
const int poc = rpl[lx].list[ref_idx];
if ((mvf->pred_flag & maskx) && rpl[lx].list[mvf->ref_idx[lx]] == poc) {
const int poc = rpl[lx].refs[ref_idx].poc;
if ((mvf->pred_flag & maskx) && rpl[lx].refs[mvf->ref_idx[lx]].poc == poc) {
available = 1;
*cp = mvf->mv[lx];
} else {
const int ly = !lx;
const PredFlag masky = ly + 1;
if ((mvf->pred_flag & masky) && rpl[ly].list[mvf->ref_idx[ly]] == poc) {
if ((mvf->pred_flag & masky) && rpl[ly].refs[mvf->ref_idx[ly]].poc == poc) {
available = 1;
*cp = mvf->mv[ly];
}

11
libavcodec/vvc/refs.c
View File

@ -352,7 +352,8 @@ static VVCFrame *generate_missing_ref(VVCContext *s, VVCFrameContext *fc, int po
static int add_candidate_ref(VVCContext *s, VVCFrameContext *fc, RefPicList *list,
int poc, int ref_flag, uint8_t use_msb)
{
VVCFrame *ref = find_ref_idx(s, fc, poc, use_msb);
VVCFrame *ref = find_ref_idx(s, fc, poc, use_msb);
VVCRefPic *refp = &list->refs[list->nb_refs];
if (ref == fc->ref || list->nb_refs >= VVC_MAX_REF_ENTRIES)
return AVERROR_INVALIDDATA;
@ -363,9 +364,9 @@ static int add_candidate_ref(VVCContext *s, VVCFrameContext *fc, RefPicList *lis
return AVERROR(ENOMEM);
}
list->list[list->nb_refs] = poc;
list->ref[list->nb_refs] = ref;
list->isLongTerm[list->nb_refs] = ref_flag & VVC_FRAME_FLAG_LONG_REF;
refp->poc = poc;
refp->ref = ref;
refp->is_lt = ref_flag & VVC_FRAME_FLAG_LONG_REF;
list->nb_refs++;
mark_ref(ref, ref_flag);
@ -463,7 +464,7 @@ int ff_vvc_slice_rpl(VVCContext *s, VVCFrameContext *fc, SliceContext *sc)
}
if ((!rsh->sh_collocated_from_l0_flag) == lx &&
rsh->sh_collocated_ref_idx < rpl->nb_refs)
fc->ref->collocated_ref = rpl->ref[rsh->sh_collocated_ref_idx];
fc->ref->collocated_ref = rpl->refs[rsh->sh_collocated_ref_idx].ref;
}
return 0;
}

2
libavcodec/vvc/thread.c
View File

@ -294,7 +294,7 @@ static void schedule_inter(VVCContext *s, VVCFrameContext *fc, const SliceContex
for (int lx = 0; lx < 2; lx++) {
for (int i = 0; i < sh->r->num_ref_idx_active[lx]; i++) {
const int y = ctu->max_y[lx][i];
VVCFrame *ref = sc->rpl[lx].ref[i];
VVCFrame *ref = sc->rpl[lx].refs[i].ref;
if (ref && y >= 0)
add_progress_listener(ref, &t->listener[lx][i], t, s, VVC_PROGRESS_PIXEL, y + LUMA_EXTRA_AFTER);
}