Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * VVC motion vector decoder | ||
3 | * | ||
4 | * Copyright (C) 2023 Nuo Mi | ||
5 | * Copyright (C) 2022 Xu Mu | ||
6 | * This file is part of FFmpeg. | ||
7 | * | ||
8 | * FFmpeg is free software; you can redistribute it and/or | ||
9 | * modify it under the terms of the GNU Lesser General Public | ||
10 | * License as published by the Free Software Foundation; either | ||
11 | * version 2.1 of the License, or (at your option) any later version. | ||
12 | * | ||
13 | * FFmpeg is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * Lesser General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU Lesser General Public | ||
19 | * License along with FFmpeg; if not, write to the Free Software | ||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
21 | */ | ||
22 | |||
23 | #include "ctu.h" | ||
24 | #include "data.h" | ||
25 | #include "refs.h" | ||
26 | #include "mvs.h" | ||
27 | |||
28 | #define IS_SAME_MV(a, b) (AV_RN64A(a) == AV_RN64A(b)) | ||
29 | |||
30 | //check if the two luma locations belong to the same motion estimation region | ||
31 | 612088 | static av_always_inline int is_same_mer(const VVCFrameContext *fc, const int xN, const int yN, const int xP, const int yP) | |
32 | { | ||
33 | 612088 | const uint8_t plevel = fc->ps.sps->log2_parallel_merge_level; | |
34 | |||
35 |
2/2✓ Branch 0 taken 32794 times.
✓ Branch 1 taken 579294 times.
|
644882 | return xN >> plevel == xP >> plevel && |
36 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32794 times.
|
32794 | yN >> plevel == yP >> plevel; |
37 | } | ||
38 | |||
39 | //return true if we have same mvs and ref_idxs | ||
40 | 1974717 | static av_always_inline int compare_mv_ref_idx(const MvField *n, const MvField *o) | |
41 | { | ||
42 |
4/4✓ Branch 0 taken 1667738 times.
✓ Branch 1 taken 306979 times.
✓ Branch 2 taken 512195 times.
✓ Branch 3 taken 1155543 times.
|
1974717 | if (!o || n->pred_flag != o->pred_flag) |
43 | 819174 | return 0; | |
44 |
2/2✓ Branch 0 taken 1450205 times.
✓ Branch 1 taken 246139 times.
|
1696344 | for (int i = 0; i < 2; i++) { |
45 | 1450205 | PredFlag mask = i + 1; | |
46 |
2/2✓ Branch 0 taken 1313950 times.
✓ Branch 1 taken 136255 times.
|
1450205 | if (n->pred_flag & mask) { |
47 | 1313950 | const int same_ref_idx = n->ref_idx[i] == o->ref_idx[i]; | |
48 | 1313950 | const int same_mv = IS_SAME_MV(n->mv + i, o->mv + i); | |
49 |
4/4✓ Branch 0 taken 1197537 times.
✓ Branch 1 taken 116413 times.
✓ Branch 2 taken 792991 times.
✓ Branch 3 taken 404546 times.
|
1313950 | if (!same_ref_idx || !same_mv) |
50 | 909404 | return 0; | |
51 | } | ||
52 | } | ||
53 | 246139 | return 1; | |
54 | } | ||
55 | |||
56 | // 8.5.2.15 Temporal motion buffer compression process for collocated motion vectors | ||
57 | 1912301 | static av_always_inline void mv_compression(Mv *motion) | |
58 | { | ||
59 | 1912301 | int mv[2] = {motion->x, motion->y}; | |
60 |
2/2✓ Branch 0 taken 3824602 times.
✓ Branch 1 taken 1912301 times.
|
5736903 | for (int i = 0; i < 2; i++) { |
61 | 3824602 | const int s = mv[i] >> 17; | |
62 | 3824602 | const int f = av_log2((mv[i] ^ s) | 31) - 4; | |
63 | 3824602 | const int mask = (-1 * (1 << f)) >> 1; | |
64 | 3824602 | const int round = (1 << f) >> 2; | |
65 | 3824602 | mv[i] = (mv[i] + round) & mask; | |
66 | } | ||
67 | 1912301 | motion->x = mv[0]; | |
68 | 1912301 | motion->y = mv[1]; | |
69 | 1912301 | } | |
70 | |||
71 | 1520757 | void ff_vvc_mv_scale(Mv *dst, const Mv *src, int td, int tb) | |
72 | { | ||
73 | int tx, scale_factor; | ||
74 | |||
75 | 1520757 | td = av_clip_int8(td); | |
76 | 1520757 | tb = av_clip_int8(tb); | |
77 | 1520757 | tx = (0x4000 + (abs(td) >> 1)) / td; | |
78 | 1520757 | scale_factor = av_clip_intp2((tb * tx + 32) >> 6, 12); | |
79 | 1520757 | dst->x = av_clip_intp2((scale_factor * src->x + 127 + | |
80 | 1520757 | (scale_factor * src->x < 0)) >> 8, 17); | |
81 | 1520757 | dst->y = av_clip_intp2((scale_factor * src->y + 127 + | |
82 | 1520757 | (scale_factor * src->y < 0)) >> 8, 17); | |
83 | 1520757 | } | |
84 | |||
85 | //part of 8.5.2.12 Derivation process for collocated motion vectors | ||
86 | 1912301 | static int check_mvset(Mv *mvLXCol, Mv *mvCol, | |
87 | int colPic, int poc, | ||
88 | const RefPicList *refPicList, int X, int refIdxLx, | ||
89 | const RefPicList *refPicList_col, int listCol, int refidxCol) | ||
90 | { | ||
91 | 1912301 | int cur_lt = refPicList[X].refs[refIdxLx].is_lt; | |
92 | 1912301 | int col_lt = refPicList_col[listCol].refs[refidxCol].is_lt; | |
93 | int col_poc_diff, cur_poc_diff; | ||
94 | |||
95 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1912301 times.
|
1912301 | if (cur_lt != col_lt) { |
96 | ✗ | mvLXCol->x = 0; | |
97 | ✗ | mvLXCol->y = 0; | |
98 | ✗ | return 0; | |
99 | } | ||
100 | |||
101 | 1912301 | col_poc_diff = colPic - refPicList_col[listCol].refs[refidxCol].poc; | |
102 | 1912301 | cur_poc_diff = poc - refPicList[X].refs[refIdxLx].poc; | |
103 | |||
104 | 1912301 | mv_compression(mvCol); | |
105 |
3/4✓ Branch 0 taken 1912301 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 406549 times.
✓ Branch 3 taken 1505752 times.
|
1912301 | if (cur_lt || col_poc_diff == cur_poc_diff) { |
106 | 406549 | mvLXCol->x = av_clip_intp2(mvCol->x, 17); | |
107 | 406549 | mvLXCol->y = av_clip_intp2(mvCol->y, 17); | |
108 | } else { | ||
109 | 1505752 | ff_vvc_mv_scale(mvLXCol, mvCol, col_poc_diff, cur_poc_diff); | |
110 | } | ||
111 | 1912301 | return 1; | |
112 | } | ||
113 | |||
114 | #define CHECK_MVSET(l) \ | ||
115 | check_mvset(mvLXCol, temp_col.mv + l, \ | ||
116 | colPic, fc->ps.ph.poc, \ | ||
117 | refPicList, X, refIdxLx, \ | ||
118 | refPicList_col, L ## l, temp_col.ref_idx[l]) | ||
119 | |||
120 | //derive NoBackwardPredFlag | ||
121 | 448486 | int ff_vvc_no_backward_pred_flag(const VVCLocalContext *lc) | |
122 | { | ||
123 | 448486 | int check_diffpicount = 0; | |
124 | int i, j; | ||
125 | 448486 | const RefPicList *rpl = lc->sc->rpl; | |
126 | |||
127 |
2/2✓ Branch 0 taken 896972 times.
✓ Branch 1 taken 448486 times.
|
1345458 | for (j = 0; j < 2; j++) { |
128 |
2/2✓ Branch 0 taken 1391254 times.
✓ Branch 1 taken 406710 times.
|
1797964 | for (i = 0; i < lc->sc->sh.r->num_ref_idx_active[j]; i++) { |
129 |
2/2✓ Branch 0 taken 490262 times.
✓ Branch 1 taken 900992 times.
|
1391254 | if (rpl[j].refs[i].poc > lc->fc->ps.ph.poc) { |
130 | 490262 | check_diffpicount++; | |
131 | 490262 | break; | |
132 | } | ||
133 | } | ||
134 | } | ||
135 | 448486 | return !check_diffpicount; | |
136 | } | ||
137 | |||
138 | //8.5.2.12 Derivation process for collocated motion vectors | ||
139 | 2309470 | static int derive_temporal_colocated_mvs(const VVCLocalContext *lc, MvField temp_col, | |
140 | int refIdxLx, Mv *mvLXCol, int X, | ||
141 | int colPic, const RefPicList *refPicList_col, int sb_flag) | ||
142 | { | ||
143 | 2309470 | const VVCFrameContext *fc = lc->fc; | |
144 | 2309470 | const SliceContext *sc = lc->sc; | |
145 | 2309470 | RefPicList* refPicList = sc->rpl; | |
146 | |||
147 |
2/2✓ Branch 0 taken 68726 times.
✓ Branch 1 taken 2240744 times.
|
2309470 | if (temp_col.pred_flag == PF_INTRA) |
148 | 68726 | return 0; | |
149 | |||
150 |
2/2✓ Branch 0 taken 2139046 times.
✓ Branch 1 taken 101698 times.
|
2240744 | if (sb_flag){ |
151 |
2/2✓ Branch 0 taken 1240840 times.
✓ Branch 1 taken 898206 times.
|
2139046 | if (X == 0) { |
152 |
2/2✓ Branch 0 taken 1124178 times.
✓ Branch 1 taken 116662 times.
|
1240840 | if (temp_col.pred_flag & PF_L0) |
153 | 1124178 | return CHECK_MVSET(0); | |
154 |
3/4✓ Branch 1 taken 1874 times.
✓ Branch 2 taken 114788 times.
✓ Branch 3 taken 1874 times.
✗ Branch 4 not taken.
|
116662 | else if (ff_vvc_no_backward_pred_flag(lc) && (temp_col.pred_flag & PF_L1)) |
155 | 1874 | return CHECK_MVSET(1); | |
156 | } else { | ||
157 |
2/2✓ Branch 0 taken 622529 times.
✓ Branch 1 taken 275677 times.
|
898206 | if (temp_col.pred_flag & PF_L1) |
158 | 622529 | return CHECK_MVSET(1); | |
159 |
3/4✓ Branch 1 taken 62022 times.
✓ Branch 2 taken 213655 times.
✓ Branch 3 taken 62022 times.
✗ Branch 4 not taken.
|
275677 | else if (ff_vvc_no_backward_pred_flag(lc) && (temp_col.pred_flag & PF_L0)) |
160 | 62022 | return CHECK_MVSET(0); | |
161 | } | ||
162 | } else { | ||
163 |
2/2✓ Branch 0 taken 11710 times.
✓ Branch 1 taken 89988 times.
|
101698 | if (!(temp_col.pred_flag & PF_L0)) |
164 | 11710 | return CHECK_MVSET(1); | |
165 |
2/2✓ Branch 0 taken 44919 times.
✓ Branch 1 taken 45069 times.
|
89988 | else if (temp_col.pred_flag == PF_L0) |
166 | 44919 | return CHECK_MVSET(0); | |
167 |
1/2✓ Branch 0 taken 45069 times.
✗ Branch 1 not taken.
|
45069 | else if (temp_col.pred_flag == PF_BI) { |
168 |
2/2✓ Branch 1 taken 8672 times.
✓ Branch 2 taken 36397 times.
|
45069 | if (ff_vvc_no_backward_pred_flag(lc)) { |
169 |
2/2✓ Branch 0 taken 4464 times.
✓ Branch 1 taken 4208 times.
|
8672 | if (X == 0) |
170 | 4464 | return CHECK_MVSET(0); | |
171 | else | ||
172 | 4208 | return CHECK_MVSET(1); | |
173 | } else { | ||
174 |
2/2✓ Branch 0 taken 21698 times.
✓ Branch 1 taken 14699 times.
|
36397 | if (!lc->sc->sh.r->sh_collocated_from_l0_flag) |
175 | 21698 | return CHECK_MVSET(0); | |
176 | else | ||
177 | 14699 | return CHECK_MVSET(1); | |
178 | } | ||
179 | } | ||
180 | } | ||
181 | 328443 | return 0; | |
182 | } | ||
183 | |||
184 | #define TAB_MVF(x, y) \ | ||
185 | tab_mvf[((y) >> MIN_PU_LOG2) * min_pu_width + ((x) >> MIN_PU_LOG2)] | ||
186 | |||
187 | #define TAB_MVF_PU(v) \ | ||
188 | TAB_MVF(x ## v, y ## v) | ||
189 | |||
190 | #define TAB_CP_MV(lx, x, y) \ | ||
191 | fc->tab.cp_mv[lx][((((y) >> min_cb_log2_size) * min_cb_width + ((x) >> min_cb_log2_size)) ) * MAX_CONTROL_POINTS] | ||
192 | |||
193 | |||
194 | #define DERIVE_TEMPORAL_COLOCATED_MVS(sb_flag) \ | ||
195 | derive_temporal_colocated_mvs(lc, temp_col, \ | ||
196 | refIdxLx, mvLXCol, X, colPic, \ | ||
197 | ff_vvc_get_ref_list(fc, ref, x, y), sb_flag) | ||
198 | |||
199 | //8.5.2.11 Derivation process for temporal luma motion vector prediction | ||
200 | 127499 | static int temporal_luma_motion_vector(const VVCLocalContext *lc, | |
201 | const int refIdxLx, Mv *mvLXCol, const int X, int check_center, int sb_flag) | ||
202 | { | ||
203 | 127499 | const VVCFrameContext *fc = lc->fc; | |
204 | 127499 | const VVCSPS *sps = fc->ps.sps; | |
205 | 127499 | const VVCPPS *pps = fc->ps.pps; | |
206 | 127499 | const CodingUnit *cu = lc->cu; | |
207 | 127499 | const int subpic_idx = lc->sc->sh.r->curr_subpic_idx; | |
208 | 127499 | int x, y, x_end, y_end, colPic, availableFlagLXCol = 0; | |
209 | 127499 | int min_pu_width = fc->ps.pps->min_pu_width; | |
210 | 127499 | VVCFrame *ref = fc->ref->collocated_ref; | |
211 | MvField *tab_mvf; | ||
212 | MvField temp_col; | ||
213 | |||
214 |
2/2✓ Branch 0 taken 66 times.
✓ Branch 1 taken 127433 times.
|
127499 | if (!ref) { |
215 | 66 | memset(mvLXCol, 0, sizeof(*mvLXCol)); | |
216 | 66 | return 0; | |
217 | } | ||
218 | |||
219 |
3/4✓ Branch 0 taken 127433 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1672 times.
✓ Branch 3 taken 125761 times.
|
127433 | if (!fc->ps.ph.r->ph_temporal_mvp_enabled_flag || (cu->cb_width * cu->cb_height <= 32)) |
220 | 1672 | return 0; | |
221 | |||
222 | 125761 | tab_mvf = ref->tab_dmvr_mvf; | |
223 | 125761 | colPic = ref->poc; | |
224 | |||
225 | //bottom right collocated motion vector | ||
226 | 125761 | x = cu->x0 + cu->cb_width; | |
227 | 125761 | y = cu->y0 + cu->cb_height; | |
228 | |||
229 | 125761 | x_end = pps->subpic_x[subpic_idx] + pps->subpic_width[subpic_idx]; | |
230 | 125761 | y_end = pps->subpic_y[subpic_idx] + pps->subpic_height[subpic_idx]; | |
231 | |||
232 |
1/2✓ Branch 0 taken 125761 times.
✗ Branch 1 not taken.
|
125761 | if (tab_mvf && |
233 |
4/4✓ Branch 0 taken 105767 times.
✓ Branch 1 taken 19994 times.
✓ Branch 2 taken 103875 times.
✓ Branch 3 taken 1892 times.
|
125761 | (cu->y0 >> sps->ctb_log2_size_y) == (y >> sps->ctb_log2_size_y) && |
234 |
2/2✓ Branch 0 taken 100239 times.
✓ Branch 1 taken 3636 times.
|
103875 | x < x_end && y < y_end) { |
235 | 100239 | x &= ~7; | |
236 | 100239 | y &= ~7; | |
237 | 100239 | temp_col = TAB_MVF(x, y); | |
238 | 100239 | availableFlagLXCol = DERIVE_TEMPORAL_COLOCATED_MVS(sb_flag); | |
239 | } | ||
240 |
2/2✓ Branch 0 taken 112537 times.
✓ Branch 1 taken 13224 times.
|
125761 | if (check_center) { |
241 | // derive center collocated motion vector | ||
242 |
3/4✓ Branch 0 taken 112537 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 44591 times.
✓ Branch 3 taken 67946 times.
|
112537 | if (tab_mvf && !availableFlagLXCol) { |
243 | 44591 | x = cu->x0 + (cu->cb_width >> 1); | |
244 | 44591 | y = cu->y0 + (cu->cb_height >> 1); | |
245 | 44591 | x &= ~7; | |
246 | 44591 | y &= ~7; | |
247 | 44591 | temp_col = TAB_MVF(x, y); | |
248 | 44591 | availableFlagLXCol = DERIVE_TEMPORAL_COLOCATED_MVS(sb_flag); | |
249 | } | ||
250 | } | ||
251 | 125761 | return availableFlagLXCol; | |
252 | } | ||
253 | |||
254 | 5201248 | void ff_vvc_set_mvf(const VVCLocalContext *lc, const int x0, const int y0, const int w, const int h, const MvField *mvf) | |
255 | { | ||
256 | 5201248 | const VVCFrameContext *fc = lc->fc; | |
257 | 5201248 | MvField *tab_mvf = fc->tab.mvf; | |
258 | 5201248 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
259 | 5201248 | const int min_pu_size = 1 << MIN_PU_LOG2; | |
260 |
2/2✓ Branch 0 taken 8168425 times.
✓ Branch 1 taken 5201248 times.
|
13369673 | for (int dy = 0; dy < h; dy += min_pu_size) { |
261 |
2/2✓ Branch 0 taken 36651288 times.
✓ Branch 1 taken 8168425 times.
|
44819713 | for (int dx = 0; dx < w; dx += min_pu_size) { |
262 | 36651288 | const int x = x0 + dx; | |
263 | 36651288 | const int y = y0 + dy; | |
264 | 36651288 | TAB_MVF(x, y) = *mvf; | |
265 | } | ||
266 | } | ||
267 | 5201248 | } | |
268 | |||
269 | 531134 | void ff_vvc_set_intra_mvf(const VVCLocalContext *lc, const int dmvr) | |
270 | { | ||
271 | 531134 | const VVCFrameContext *fc = lc->fc; | |
272 | 531134 | const CodingUnit *cu = lc->cu; | |
273 |
2/2✓ Branch 0 taken 1582 times.
✓ Branch 1 taken 529552 times.
|
531134 | MvField *tab_mvf = dmvr ? fc->ref->tab_dmvr_mvf : fc->tab.mvf; |
274 | 531134 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
275 | 531134 | const int min_pu_size = 1 << MIN_PU_LOG2; | |
276 |
2/2✓ Branch 0 taken 1409302 times.
✓ Branch 1 taken 531134 times.
|
1940436 | for (int dy = 0; dy < cu->cb_height; dy += min_pu_size) { |
277 |
2/2✓ Branch 0 taken 6206156 times.
✓ Branch 1 taken 1409302 times.
|
7615458 | for (int dx = 0; dx < cu->cb_width; dx += min_pu_size) { |
278 | 6206156 | const int x = cu->x0 + dx; | |
279 | 6206156 | const int y = cu->y0 + dy; | |
280 | 6206156 | TAB_MVF(x, y).pred_flag = PF_INTRA; | |
281 | } | ||
282 | } | ||
283 | 531134 | } | |
284 | |||
285 | //cbProfFlagLX from 8.5.5.9 Derivation process for motion vector arrays from affine control point motion vectors | ||
286 | 41015 | static int derive_cb_prof_flag_lx(const VVCLocalContext *lc, const PredictionUnit* pu, int lx, int is_fallback) | |
287 | { | ||
288 | 41015 | const MotionInfo* mi = &pu->mi; | |
289 | 41015 | const Mv* cp_mv = &mi->mv[lx][0]; | |
290 |
3/4✓ Branch 0 taken 41015 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 237 times.
✓ Branch 3 taken 40778 times.
|
41015 | if (lc->fc->ps.ph.r->ph_prof_disabled_flag || is_fallback) |
291 | 237 | return 0; | |
292 |
2/2✓ Branch 0 taken 15544 times.
✓ Branch 1 taken 25234 times.
|
40778 | if (mi->motion_model_idc == MOTION_4_PARAMS_AFFINE) { |
293 |
2/2✓ Branch 0 taken 2447 times.
✓ Branch 1 taken 13097 times.
|
15544 | if (IS_SAME_MV(cp_mv, cp_mv + 1)) |
294 | 2447 | return 0; | |
295 | } | ||
296 |
2/2✓ Branch 0 taken 25234 times.
✓ Branch 1 taken 13097 times.
|
38331 | if (mi->motion_model_idc == MOTION_6_PARAMS_AFFINE) { |
297 |
4/4✓ Branch 0 taken 4239 times.
✓ Branch 1 taken 20995 times.
✓ Branch 2 taken 891 times.
✓ Branch 3 taken 3348 times.
|
25234 | if (IS_SAME_MV(cp_mv, cp_mv + 1) && IS_SAME_MV(cp_mv, cp_mv + 2)) |
298 | 891 | return 0; | |
299 | } | ||
300 |
2/2✓ Branch 0 taken 137 times.
✓ Branch 1 taken 37303 times.
|
37440 | if (lc->sc->rpl[lx].refs[mi->ref_idx[lx]].is_scaled) |
301 | 137 | return 0; | |
302 | 37303 | return 1; | |
303 | } | ||
304 | |||
305 | typedef struct SubblockParams { | ||
306 | int d_hor_x; | ||
307 | int d_ver_x; | ||
308 | int d_hor_y; | ||
309 | int d_ver_y; | ||
310 | int mv_scale_hor; | ||
311 | int mv_scale_ver; | ||
312 | int is_fallback; | ||
313 | |||
314 | int cb_width; | ||
315 | int cb_height; | ||
316 | } SubblockParams; | ||
317 | |||
318 | 41015 | static int is_fallback_mode(const SubblockParams *sp, const PredFlag pred_flag) | |
319 | { | ||
320 | 41015 | const int a = 4 * (2048 + sp->d_hor_x); | |
321 | 41015 | const int b = 4 * sp->d_hor_y; | |
322 | 41015 | const int c = 4 * (2048 + sp->d_ver_y); | |
323 | 41015 | const int d = 4 * sp->d_ver_x; | |
324 |
2/2✓ Branch 0 taken 17092 times.
✓ Branch 1 taken 23923 times.
|
41015 | if (pred_flag == PF_BI) { |
325 |
2/2✓ Branch 0 taken 17079 times.
✓ Branch 1 taken 13 times.
|
17092 | const int max_w4 = FFMAX(0, FFMAX(a, FFMAX(b, a + b))); |
326 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 17079 times.
|
17092 | const int min_w4 = FFMIN(0, FFMIN(a, FFMIN(b, a + b))); |
327 |
2/2✓ Branch 0 taken 17086 times.
✓ Branch 1 taken 6 times.
|
17092 | const int max_h4 = FFMAX(0, FFMAX(c, FFMAX(d, c + d))); |
328 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 17086 times.
|
17092 | const int min_h4 = FFMIN(0, FFMIN(c, FFMIN(d, c + d))); |
329 | 17092 | const int bx_wx4 = ((max_w4 - min_w4) >> 11) + 9; | |
330 | 17092 | const int bx_hx4 = ((max_h4 - min_h4) >> 11) + 9; | |
331 | 17092 | return bx_wx4 * bx_hx4 > 225; | |
332 | } else { | ||
333 | 23923 | const int bx_wxh = (FFABS(a) >> 11) + 9; | |
334 | 23923 | const int bx_hxh = (FFABS(d) >> 11) + 9; | |
335 | 23923 | const int bx_wxv = (FFABS(b) >> 11) + 9; | |
336 | 23923 | const int bx_hxv = (FFABS(c) >> 11) + 9; | |
337 |
4/4✓ Branch 0 taken 23839 times.
✓ Branch 1 taken 84 times.
✓ Branch 2 taken 23749 times.
✓ Branch 3 taken 90 times.
|
23923 | if (bx_wxh * bx_hxh <= 165 && bx_wxv * bx_hxv <= 165) |
338 | 23749 | return 0; | |
339 | } | ||
340 | 174 | return 1; | |
341 | } | ||
342 | |||
343 | 41015 | static void init_subblock_params(SubblockParams *sp, const MotionInfo* mi, | |
344 | const int cb_width, const int cb_height, const int lx) | ||
345 | { | ||
346 | 41015 | const int log2_cbw = av_log2(cb_width); | |
347 | 41015 | const int log2_cbh = av_log2(cb_height); | |
348 | 41015 | const Mv* cp_mv = mi->mv[lx]; | |
349 | 41015 | const int num_cp_mv = mi->motion_model_idc + 1; | |
350 | 41015 | sp->d_hor_x = (cp_mv[1].x - cp_mv[0].x) * (1 << (MAX_CU_DEPTH - log2_cbw)); | |
351 | 41015 | sp->d_ver_x = (cp_mv[1].y - cp_mv[0].y) * (1 << (MAX_CU_DEPTH - log2_cbw)); | |
352 |
2/2✓ Branch 0 taken 25459 times.
✓ Branch 1 taken 15556 times.
|
41015 | if (num_cp_mv == 3) { |
353 | 25459 | sp->d_hor_y = (cp_mv[2].x - cp_mv[0].x) * (1 << (MAX_CU_DEPTH - log2_cbh)); | |
354 | 25459 | sp->d_ver_y = (cp_mv[2].y - cp_mv[0].y) * (1 << (MAX_CU_DEPTH - log2_cbh)); | |
355 | } else { | ||
356 | 15556 | sp->d_hor_y = -sp->d_ver_x; | |
357 | 15556 | sp->d_ver_y = sp->d_hor_x; | |
358 | } | ||
359 | 41015 | sp->mv_scale_hor = (cp_mv[0].x) * (1 << MAX_CU_DEPTH); | |
360 | 41015 | sp->mv_scale_ver = (cp_mv[0].y) * (1 << MAX_CU_DEPTH); | |
361 | 41015 | sp->cb_width = cb_width; | |
362 | 41015 | sp->cb_height = cb_height; | |
363 | 41015 | sp->is_fallback = is_fallback_mode(sp, mi->pred_flag); | |
364 | 41015 | } | |
365 | |||
366 | 41015 | static void derive_subblock_diff_mvs(const VVCLocalContext *lc, PredictionUnit* pu, const SubblockParams* sp, const int lx) | |
367 | { | ||
368 | 41015 | pu->cb_prof_flag[lx] = derive_cb_prof_flag_lx(lc, pu, lx, sp->is_fallback); | |
369 |
2/2✓ Branch 0 taken 37303 times.
✓ Branch 1 taken 3712 times.
|
41015 | if (pu->cb_prof_flag[lx]) { |
370 | 37303 | const int dmv_limit = 1 << 5; | |
371 | 37303 | const int pos_offset_x = 6 * (sp->d_hor_x + sp->d_hor_y); | |
372 | 37303 | const int pos_offset_y = 6 * (sp->d_ver_x + sp->d_ver_y); | |
373 |
2/2✓ Branch 0 taken 149212 times.
✓ Branch 1 taken 37303 times.
|
186515 | for (int x = 0; x < AFFINE_MIN_BLOCK_SIZE; x++) { |
374 |
2/2✓ Branch 0 taken 596848 times.
✓ Branch 1 taken 149212 times.
|
746060 | for (int y = 0; y < AFFINE_MIN_BLOCK_SIZE; y++) { |
375 | 596848 | LOCAL_ALIGNED_8(Mv, diff, [1]); | |
376 | 596848 | diff->x = x * (sp->d_hor_x * (1 << 2)) + y * (sp->d_hor_y * (1 << 2)) - pos_offset_x; | |
377 | 596848 | diff->y = x * (sp->d_ver_x * (1 << 2)) + y * (sp->d_ver_y * (1 << 2)) - pos_offset_y; | |
378 | 596848 | ff_vvc_round_mv(diff, 0, 8); | |
379 | 596848 | pu->diff_mv_x[lx][AFFINE_MIN_BLOCK_SIZE * y + x] = av_clip(diff->x, -dmv_limit + 1, dmv_limit - 1); | |
380 | 596848 | pu->diff_mv_y[lx][AFFINE_MIN_BLOCK_SIZE * y + x] = av_clip(diff->y, -dmv_limit + 1, dmv_limit - 1); | |
381 | } | ||
382 | } | ||
383 | } | ||
384 | 41015 | } | |
385 | |||
386 | 41015 | static void store_cp_mv(const VVCLocalContext *lc, const MotionInfo *mi, const int lx) | |
387 | { | ||
388 | 41015 | VVCFrameContext *fc = lc->fc; | |
389 | 41015 | const CodingUnit *cu = lc->cu; | |
390 | 41015 | const int log2_min_cb_size = fc->ps.sps->min_cb_log2_size_y; | |
391 | 41015 | const int min_cb_size = fc->ps.sps->min_cb_size_y; | |
392 | 41015 | const int min_cb_width = fc->ps.pps->min_cb_width; | |
393 | 41015 | const int num_cp_mv = mi->motion_model_idc + 1; | |
394 | |||
395 |
2/2✓ Branch 0 taken 324896 times.
✓ Branch 1 taken 41015 times.
|
365911 | for (int dy = 0; dy < cu->cb_height; dy += min_cb_size) { |
396 |
2/2✓ Branch 0 taken 4035176 times.
✓ Branch 1 taken 324896 times.
|
4360072 | for (int dx = 0; dx < cu->cb_width; dx += min_cb_size) { |
397 | 4035176 | const int x_cb = (cu->x0 + dx) >> log2_min_cb_size; | |
398 | 4035176 | const int y_cb = (cu->y0 + dy) >> log2_min_cb_size; | |
399 | 4035176 | const int offset = (y_cb * min_cb_width + x_cb) * MAX_CONTROL_POINTS; | |
400 | |||
401 | 4035176 | memcpy(&fc->tab.cp_mv[lx][offset], mi->mv[lx], sizeof(Mv) * num_cp_mv); | |
402 | } | ||
403 | } | ||
404 | 41015 | } | |
405 | |||
406 | //8.5.5.9 Derivation process for motion vector arrays from affine control point motion vectors | ||
407 | 32469 | void ff_vvc_store_sb_mvs(const VVCLocalContext *lc, PredictionUnit *pu) | |
408 | { | ||
409 | 32469 | const CodingUnit *cu = lc->cu; | |
410 | 32469 | const MotionInfo *mi = &pu->mi; | |
411 | 32469 | const int sbw = cu->cb_width / mi->num_sb_x; | |
412 | 32469 | const int sbh = cu->cb_height / mi->num_sb_y; | |
413 | SubblockParams params[2]; | ||
414 | 32469 | MvField mvf = {0}; | |
415 | |||
416 | 32469 | mvf.pred_flag = mi->pred_flag; | |
417 | 32469 | mvf.bcw_idx = mi->bcw_idx; | |
418 | 32469 | mvf.hpel_if_idx = mi->hpel_if_idx; | |
419 |
2/2✓ Branch 0 taken 64938 times.
✓ Branch 1 taken 32469 times.
|
97407 | for (int i = 0; i < 2; i++) { |
420 | 64938 | const PredFlag mask = i + 1; | |
421 |
2/2✓ Branch 0 taken 41015 times.
✓ Branch 1 taken 23923 times.
|
64938 | if (mi->pred_flag & mask) { |
422 | 41015 | store_cp_mv(lc, mi, i); | |
423 | 41015 | init_subblock_params(params + i, mi, cu->cb_width, cu->cb_height, i); | |
424 | 41015 | derive_subblock_diff_mvs(lc, pu, params + i, i); | |
425 | 41015 | mvf.ref_idx[i] = mi->ref_idx[i]; | |
426 | } | ||
427 | } | ||
428 | |||
429 |
2/2✓ Branch 0 taken 257776 times.
✓ Branch 1 taken 32469 times.
|
290245 | for (int sby = 0; sby < mi->num_sb_y; sby++) { |
430 |
2/2✓ Branch 0 taken 3167824 times.
✓ Branch 1 taken 257776 times.
|
3425600 | for (int sbx = 0; sbx < mi->num_sb_x; sbx++) { |
431 | 3167824 | const int x0 = cu->x0 + sbx * sbw; | |
432 | 3167824 | const int y0 = cu->y0 + sby * sbh; | |
433 |
2/2✓ Branch 0 taken 6335648 times.
✓ Branch 1 taken 3167824 times.
|
9503472 | for (int i = 0; i < 2; i++) { |
434 | 6335648 | const PredFlag mask = i + 1; | |
435 |
2/2✓ Branch 0 taken 4035176 times.
✓ Branch 1 taken 2300472 times.
|
6335648 | if (mi->pred_flag & mask) { |
436 | 4035176 | const SubblockParams* sp = params + i; | |
437 |
2/2✓ Branch 0 taken 7652 times.
✓ Branch 1 taken 4027524 times.
|
4035176 | const int x_pos_cb = sp->is_fallback ? (cu->cb_width >> 1) : (2 + (sbx << MIN_CU_LOG2)); |
438 |
2/2✓ Branch 0 taken 7652 times.
✓ Branch 1 taken 4027524 times.
|
4035176 | const int y_pos_cb = sp->is_fallback ? (cu->cb_height >> 1) : (2 + (sby << MIN_CU_LOG2)); |
439 | 4035176 | Mv *mv = mvf.mv + i; | |
440 | |||
441 | 4035176 | mv->x = sp->mv_scale_hor + sp->d_hor_x * x_pos_cb + sp->d_hor_y * y_pos_cb; | |
442 | 4035176 | mv->y = sp->mv_scale_ver + sp->d_ver_x * x_pos_cb + sp->d_ver_y * y_pos_cb; | |
443 | 4035176 | ff_vvc_round_mv(mv, 0, MAX_CU_DEPTH); | |
444 | 4035176 | ff_vvc_clip_mv(mv); | |
445 | } | ||
446 | } | ||
447 | 3167824 | ff_vvc_set_mvf(lc, x0, y0, sbw, sbh, &mvf); | |
448 | } | ||
449 | } | ||
450 | 32469 | } | |
451 | |||
452 | 24737 | void ff_vvc_store_gpm_mvf(const VVCLocalContext *lc, const PredictionUnit *pu) | |
453 | { | ||
454 | 24737 | const CodingUnit *cu = lc->cu; | |
455 | 24737 | const int angle_idx = ff_vvc_gpm_angle_idx[pu->gpm_partition_idx]; | |
456 | 24737 | const int distance_idx = ff_vvc_gpm_distance_idx[pu->gpm_partition_idx]; | |
457 | 24737 | const int displacement_x = ff_vvc_gpm_distance_lut[angle_idx]; | |
458 | 24737 | const int displacement_y = ff_vvc_gpm_distance_lut[(angle_idx + 8) % 32]; | |
459 |
4/4✓ Branch 0 taken 12982 times.
✓ Branch 1 taken 11755 times.
✓ Branch 2 taken 10424 times.
✓ Branch 3 taken 2558 times.
|
24737 | const int is_flip = angle_idx >= 13 &&angle_idx <= 27; |
460 |
6/6✓ Branch 0 taken 23196 times.
✓ Branch 1 taken 1541 times.
✓ Branch 2 taken 20487 times.
✓ Branch 3 taken 2709 times.
✓ Branch 4 taken 4918 times.
✓ Branch 5 taken 15569 times.
|
24737 | const int shift_hor = (angle_idx % 16 == 8 || (angle_idx % 16 && cu->cb_height >= cu->cb_width)) ? 0 : 1; |
461 |
2/2✓ Branch 0 taken 14571 times.
✓ Branch 1 taken 10166 times.
|
24737 | const int sign = angle_idx < 16 ? 1 : -1; |
462 | 24737 | const int block_size = 4; | |
463 | 24737 | int offset_x = (-cu->cb_width) >> 1; | |
464 | 24737 | int offset_y = (-cu->cb_height) >> 1; | |
465 | |||
466 |
2/2✓ Branch 0 taken 17110 times.
✓ Branch 1 taken 7627 times.
|
24737 | if (!shift_hor) |
467 | 17110 | offset_y += sign * ((distance_idx * cu->cb_height) >> 3); | |
468 | else | ||
469 | 7627 | offset_x += sign * ((distance_idx * cu->cb_width) >> 3); | |
470 | |||
471 |
2/2✓ Branch 0 taken 111242 times.
✓ Branch 1 taken 24737 times.
|
135979 | for (int y = 0; y < cu->cb_height; y += block_size) { |
472 |
2/2✓ Branch 0 taken 511556 times.
✓ Branch 1 taken 111242 times.
|
622798 | for (int x = 0; x < cu->cb_width; x += block_size) { |
473 | 511556 | const int motion_idx = (((x + offset_x) * (1 << 1)) + 5) * displacement_x + | |
474 | 511556 | (((y + offset_y) * (1 << 1)) + 5) * displacement_y; | |
475 |
6/6✓ Branch 0 taken 256690 times.
✓ Branch 1 taken 254866 times.
✓ Branch 2 taken 154995 times.
✓ Branch 3 taken 101695 times.
✓ Branch 4 taken 254866 times.
✓ Branch 5 taken 154995 times.
|
511556 | const int s_type = FFABS(motion_idx) < 32 ? 2 : (motion_idx <= 0 ? (1 - is_flip) : is_flip); |
476 | 511556 | const int pred_flag = pu->gpm_mv[0].pred_flag | pu->gpm_mv[1].pred_flag; | |
477 | 511556 | const int x0 = cu->x0 + x; | |
478 | 511556 | const int y0 = cu->y0 + y; | |
479 | |||
480 |
2/2✓ Branch 0 taken 199134 times.
✓ Branch 1 taken 312422 times.
|
511556 | if (!s_type) |
481 | 199134 | ff_vvc_set_mvf(lc, x0, y0, block_size, block_size, pu->gpm_mv + 0); | |
482 |
5/6✓ Branch 0 taken 101695 times.
✓ Branch 1 taken 210727 times.
✓ Branch 2 taken 101695 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 54610 times.
✓ Branch 5 taken 47085 times.
|
312422 | else if (s_type == 1 || (s_type == 2 && pred_flag != PF_BI)) |
483 | 265337 | ff_vvc_set_mvf(lc, x0, y0, block_size, block_size, pu->gpm_mv + 1); | |
484 | else { | ||
485 | 47085 | MvField mvf = pu->gpm_mv[0]; | |
486 | 47085 | const MvField *mv1 = &pu->gpm_mv[1]; | |
487 | 47085 | const int lx = mv1->pred_flag - PF_L0; | |
488 | 47085 | mvf.pred_flag = PF_BI; | |
489 | 47085 | mvf.ref_idx[lx] = mv1->ref_idx[lx]; | |
490 | 47085 | mvf.mv[lx] = mv1->mv[lx]; | |
491 | 47085 | ff_vvc_set_mvf(lc, x0, y0, block_size, block_size, &mvf); | |
492 | } | ||
493 | } | ||
494 | } | ||
495 | 24737 | } | |
496 | |||
497 | 265675 | void ff_vvc_store_mvf(const VVCLocalContext *lc, const MvField *mvf) | |
498 | { | ||
499 | 265675 | const CodingUnit *cu = lc->cu; | |
500 | 265675 | ff_vvc_set_mvf(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height, mvf); | |
501 | 265675 | } | |
502 | |||
503 | 50265 | void ff_vvc_store_mv(const VVCLocalContext *lc, const MotionInfo *mi) | |
504 | { | ||
505 | 50265 | const CodingUnit *cu = lc->cu; | |
506 | 50265 | MvField mvf = {0}; | |
507 | |||
508 | 50265 | mvf.hpel_if_idx = mi->hpel_if_idx; | |
509 | 50265 | mvf.bcw_idx = mi->bcw_idx; | |
510 | 50265 | mvf.pred_flag = mi->pred_flag; | |
511 | |||
512 |
2/2✓ Branch 0 taken 100530 times.
✓ Branch 1 taken 50265 times.
|
150795 | for (int i = 0; i < 2; i++) { |
513 | 100530 | const PredFlag mask = i + 1; | |
514 |
2/2✓ Branch 0 taken 65293 times.
✓ Branch 1 taken 35237 times.
|
100530 | if (mvf.pred_flag & mask) { |
515 | 65293 | mvf.mv[i] = mi->mv[i][0]; | |
516 | 65293 | mvf.ref_idx[i] = mi->ref_idx[i]; | |
517 | } | ||
518 | } | ||
519 | 50265 | ff_vvc_set_mvf(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height, &mvf); | |
520 | 50265 | } | |
521 | |||
522 | typedef enum NeighbourIdx { | ||
523 | A0, | ||
524 | A1, | ||
525 | A2, | ||
526 | B0, | ||
527 | B1, | ||
528 | B2, | ||
529 | B3, | ||
530 | NUM_NBS, | ||
531 | NB_IDX_NONE = NUM_NBS, | ||
532 | } NeighbourIdx; | ||
533 | |||
534 | typedef struct Neighbour { | ||
535 | int x; | ||
536 | int y; | ||
537 | |||
538 | int checked; | ||
539 | int available; | ||
540 | } Neighbour; | ||
541 | |||
542 | typedef struct NeighbourContext { | ||
543 | Neighbour neighbours[NUM_NBS]; | ||
544 | const VVCLocalContext *lc; | ||
545 | } NeighbourContext; | ||
546 | |||
547 | 1159407 | static int is_available(const VVCFrameContext *fc, const int x0, const int y0) | |
548 | { | ||
549 | 1159407 | const VVCSPS *sps = fc->ps.sps; | |
550 | 1159407 | const int x = x0 >> sps->min_cb_log2_size_y; | |
551 | 1159407 | const int y = y0 >> sps->min_cb_log2_size_y; | |
552 | 1159407 | const int min_cb_width = fc->ps.pps->min_cb_width; | |
553 | |||
554 | 1159407 | return SAMPLE_CTB(fc->tab.cb_width[0], x, y) != 0; | |
555 | } | ||
556 | |||
557 | 415373 | static int is_a0_available(const VVCLocalContext *lc, const CodingUnit *cu) | |
558 | { | ||
559 | 415373 | const VVCFrameContext *fc = lc->fc; | |
560 | 415373 | const VVCSPS *sps = fc->ps.sps; | |
561 | 415373 | const int x0b = av_zero_extend(cu->x0, sps->ctb_log2_size_y); | |
562 | int cand_bottom_left; | ||
563 | |||
564 |
4/4✓ Branch 0 taken 93145 times.
✓ Branch 1 taken 322228 times.
✓ Branch 2 taken 12165 times.
✓ Branch 3 taken 80980 times.
|
415373 | if (!x0b && !lc->ctb_left_flag) { |
565 | 12165 | cand_bottom_left = 0; | |
566 | } else { | ||
567 | 403208 | const int max_y = FFMIN(fc->ps.pps->height, ((cu->y0 >> sps->ctb_log2_size_y) + 1) << sps->ctb_log2_size_y); | |
568 |
2/2✓ Branch 0 taken 87544 times.
✓ Branch 1 taken 315664 times.
|
403208 | if (cu->y0 + cu->cb_height >= max_y) |
569 | 87544 | cand_bottom_left = 0; | |
570 | else | ||
571 | 315664 | cand_bottom_left = is_available(fc, cu->x0 - 1, cu->y0 + cu->cb_height); | |
572 | } | ||
573 | 415373 | return cand_bottom_left; | |
574 | } | ||
575 | |||
576 | 415373 | static void init_neighbour_context(NeighbourContext *ctx, const VVCLocalContext *lc) | |
577 | { | ||
578 | 415373 | const CodingUnit *cu = lc->cu; | |
579 | 415373 | const NeighbourAvailable *na = &lc->na; | |
580 | 415373 | const int x0 = cu->x0; | |
581 | 415373 | const int y0 = cu->y0; | |
582 | 415373 | const int cb_width = cu->cb_width; | |
583 | 415373 | const int cb_height = cu->cb_height; | |
584 | 415373 | const int a0_available = is_a0_available(lc, cu); | |
585 | |||
586 | 415373 | Neighbour neighbours[NUM_NBS] = { | |
587 | 415373 | { x0 - 1, y0 + cb_height, !a0_available }, //A0 | |
588 | 415373 | { x0 - 1, y0 + cb_height - 1, !na->cand_left }, //A1 | |
589 | 415373 | { x0 - 1, y0, !na->cand_left }, //A2 | |
590 | 415373 | { x0 + cb_width, y0 - 1, !na->cand_up_right }, //B0 | |
591 | 415373 | { x0 + cb_width - 1, y0 - 1, !na->cand_up }, //B1 | |
592 | 415373 | { x0 - 1, y0 - 1, !na->cand_up_left }, //B2 | |
593 | 415373 | { x0, y0 - 1, !na->cand_up }, //B3 | |
594 | }; | ||
595 | |||
596 | 415373 | memcpy(ctx->neighbours, neighbours, sizeof(neighbours)); | |
597 | 415373 | ctx->lc = lc; | |
598 | 415373 | } | |
599 | |||
600 | 804588 | static av_always_inline PredMode pred_flag_to_mode(PredFlag pred) | |
601 | { | ||
602 |
2/2✓ Branch 0 taken 803272 times.
✓ Branch 1 taken 1316 times.
|
804588 | return pred == PF_IBC ? MODE_IBC : (pred == PF_INTRA ? MODE_INTRA : MODE_INTER); |
603 | } | ||
604 | |||
605 | 1091731 | static int check_available(Neighbour *n, const VVCLocalContext *lc, const int check_mer) | |
606 | { | ||
607 | 1091731 | const VVCFrameContext *fc = lc->fc; | |
608 | 1091731 | const VVCSPS *sps = fc->ps.sps; | |
609 | 1091731 | const CodingUnit *cu = lc->cu; | |
610 | 1091731 | const MvField *tab_mvf = fc->tab.mvf; | |
611 | 1091731 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
612 | |||
613 |
2/2✓ Branch 0 taken 843943 times.
✓ Branch 1 taken 247788 times.
|
1091731 | if (!n->checked) { |
614 | 843943 | n->checked = 1; | |
615 |
4/4✓ Branch 0 taken 87906 times.
✓ Branch 1 taken 756037 times.
✓ Branch 2 taken 87706 times.
✓ Branch 3 taken 200 times.
|
843943 | n->available = !sps->r->sps_entropy_coding_sync_enabled_flag || ((n->x >> sps->ctb_log2_size_y) <= (cu->x0 >> sps->ctb_log2_size_y)); |
616 |
6/6✓ Branch 0 taken 843743 times.
✓ Branch 1 taken 200 times.
✓ Branch 3 taken 804588 times.
✓ Branch 4 taken 39155 times.
✓ Branch 6 taken 749733 times.
✓ Branch 7 taken 54855 times.
|
843943 | n->available = n->available && is_available(fc, n->x, n->y) && cu->pred_mode == pred_flag_to_mode(TAB_MVF(n->x, n->y).pred_flag); |
617 |
2/2✓ Branch 0 taken 673046 times.
✓ Branch 1 taken 170897 times.
|
843943 | if (check_mer) |
618 |
3/4✓ Branch 0 taken 612088 times.
✓ Branch 1 taken 60958 times.
✓ Branch 3 taken 612088 times.
✗ Branch 4 not taken.
|
673046 | n->available = n->available && !is_same_mer(fc, n->x, n->y, cu->x0, cu->y0); |
619 | } | ||
620 | 1091731 | return n->available; | |
621 | } | ||
622 | |||
623 | 515551 | static const MvField *mv_merge_candidate(const VVCLocalContext *lc, const int x_cand, const int y_cand) | |
624 | { | ||
625 | 515551 | const VVCFrameContext *fc = lc->fc; | |
626 | 515551 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
627 | 515551 | const MvField* tab_mvf = fc->tab.mvf; | |
628 | 515551 | const MvField *mvf = &TAB_MVF(x_cand, y_cand); | |
629 | |||
630 | 515551 | return mvf; | |
631 | } | ||
632 | |||
633 | 643523 | static const MvField* mv_merge_from_nb(NeighbourContext *ctx, const NeighbourIdx nb) | |
634 | { | ||
635 | 643523 | const VVCLocalContext *lc = ctx->lc; | |
636 | 643523 | Neighbour *n = &ctx->neighbours[nb]; | |
637 | |||
638 |
2/2✓ Branch 1 taken 515551 times.
✓ Branch 2 taken 127972 times.
|
643523 | if (check_available(n, lc, 1)) |
639 | 515551 | return mv_merge_candidate(lc, n->x, n->y); | |
640 | 127972 | return 0; | |
641 | } | ||
642 | #define MV_MERGE_FROM_NB(nb) mv_merge_from_nb(&nctx, nb) | ||
643 | |||
644 | //8.5.2.3 Derivation process for spatial merging candidates | ||
645 | 290412 | static int mv_merge_spatial_candidates(const VVCLocalContext *lc, const int merge_idx, | |
646 | const MvField **nb_list, MvField *cand_list, int *nb_merge_cand) | ||
647 | { | ||
648 | const MvField *cand; | ||
649 | 290412 | int num_cands = 0; | |
650 | NeighbourContext nctx; | ||
651 | |||
652 | static NeighbourIdx nbs[][2] = { | ||
653 | {B1, NB_IDX_NONE }, | ||
654 | {A1, B1 }, | ||
655 | {B0, B1 }, | ||
656 | {A0, A1 }, | ||
657 | }; | ||
658 | |||
659 | 290412 | init_neighbour_context(&nctx, lc); | |
660 |
2/2✓ Branch 0 taken 582661 times.
✓ Branch 1 taken 61505 times.
|
644166 | for (int i = 0; i < FF_ARRAY_ELEMS(nbs); i++) { |
661 | 582661 | NeighbourIdx nb = nbs[i][0]; | |
662 | 582661 | NeighbourIdx old = nbs[i][1]; | |
663 | 582661 | cand = nb_list[nb] = MV_MERGE_FROM_NB(nb); | |
664 |
4/4✓ Branch 0 taken 465934 times.
✓ Branch 1 taken 116727 times.
✓ Branch 3 taken 420454 times.
✓ Branch 4 taken 45480 times.
|
582661 | if (cand && !compare_mv_ref_idx(cand, nb_list[old])) { |
665 | 420454 | cand_list[num_cands] = *cand; | |
666 |
2/2✓ Branch 0 taken 228907 times.
✓ Branch 1 taken 191547 times.
|
420454 | if (merge_idx == num_cands) |
667 | 228907 | return 1; | |
668 | 191547 | num_cands++; | |
669 | } | ||
670 | } | ||
671 |
2/2✓ Branch 0 taken 60862 times.
✓ Branch 1 taken 643 times.
|
61505 | if (num_cands != 4) { |
672 | 60862 | cand = MV_MERGE_FROM_NB(B2); | |
673 |
4/4✓ Branch 0 taken 49617 times.
✓ Branch 1 taken 11245 times.
✓ Branch 3 taken 29928 times.
✓ Branch 4 taken 19689 times.
|
60862 | if (cand && !compare_mv_ref_idx(cand, nb_list[A1]) |
674 |
2/2✓ Branch 1 taken 21230 times.
✓ Branch 2 taken 8698 times.
|
29928 | && !compare_mv_ref_idx(cand, nb_list[B1])) { |
675 | 21230 | cand_list[num_cands] = *cand; | |
676 |
2/2✓ Branch 0 taken 9565 times.
✓ Branch 1 taken 11665 times.
|
21230 | if (merge_idx == num_cands) |
677 | 9565 | return 1; | |
678 | 11665 | num_cands++; | |
679 | } | ||
680 | } | ||
681 | 51940 | *nb_merge_cand = num_cands; | |
682 | 51940 | return 0; | |
683 | } | ||
684 | |||
685 | 51940 | static int mv_merge_temporal_candidate(const VVCLocalContext *lc, MvField *cand) | |
686 | { | ||
687 | 51940 | const VVCFrameContext *fc = lc->fc; | |
688 | 51940 | const CodingUnit *cu = lc->cu; | |
689 | |||
690 | 51940 | memset(cand, 0, sizeof(*cand)); | |
691 |
4/4✓ Branch 0 taken 51793 times.
✓ Branch 1 taken 147 times.
✓ Branch 2 taken 48972 times.
✓ Branch 3 taken 2821 times.
|
51940 | if (fc->ps.ph.r->ph_temporal_mvp_enabled_flag && (cu->cb_width * cu->cb_height > 32)) { |
692 | 48972 | int available_l0 = temporal_luma_motion_vector(lc, 0, cand->mv + 0, 0, 1, 0); | |
693 | 97944 | int available_l1 = IS_B(lc->sc->sh.r) ? | |
694 |
2/2✓ Branch 0 taken 46574 times.
✓ Branch 1 taken 2398 times.
|
48972 | temporal_luma_motion_vector(lc, 0, cand->mv + 1, 1, 1, 0) : 0; |
695 | 48972 | cand->pred_flag = available_l0 + (available_l1 << 1); | |
696 | } | ||
697 | 51940 | return cand->pred_flag; | |
698 | } | ||
699 | |||
700 | //8.5.2.6 Derivation process for history-based merging candidates | ||
701 | 32164 | static int mv_merge_history_candidates(const VVCLocalContext *lc, const int merge_idx, | |
702 | const MvField **nb_list, MvField *cand_list, int *num_cands) | ||
703 | { | ||
704 | 32164 | const VVCSPS *sps = lc->fc->ps.sps; | |
705 | 32164 | const EntryPoint* ep = lc->ep; | |
706 |
4/4✓ Branch 0 taken 84273 times.
✓ Branch 1 taken 1605 times.
✓ Branch 2 taken 76001 times.
✓ Branch 3 taken 8272 times.
|
85878 | for (int i = 1; i <= ep->num_hmvp && (*num_cands < sps->max_num_merge_cand - 1); i++) { |
707 | 76001 | const MvField *h = &ep->hmvp[ep->num_hmvp - i]; | |
708 |
6/6✓ Branch 0 taken 55830 times.
✓ Branch 1 taken 20171 times.
✓ Branch 3 taken 37540 times.
✓ Branch 4 taken 18290 times.
✓ Branch 6 taken 9954 times.
✓ Branch 7 taken 27586 times.
|
76001 | const int same_motion = i <= 2 && (compare_mv_ref_idx(h, nb_list[A1]) || compare_mv_ref_idx(h, nb_list[B1])); |
709 |
2/2✓ Branch 0 taken 47757 times.
✓ Branch 1 taken 28244 times.
|
76001 | if (!same_motion) { |
710 | 47757 | cand_list[*num_cands] = *h; | |
711 |
2/2✓ Branch 0 taken 22287 times.
✓ Branch 1 taken 25470 times.
|
47757 | if (merge_idx == *num_cands) |
712 | 22287 | return 1; | |
713 | 25470 | (*num_cands)++; | |
714 | } | ||
715 | } | ||
716 | 9877 | return 0; | |
717 | } | ||
718 | |||
719 | //8.5.2.4 Derivation process for pairwise average merging candidate | ||
720 | 9877 | static int mv_merge_pairwise_candidate(MvField *cand_list, const int num_cands, const int is_b) | |
721 | { | ||
722 |
2/2✓ Branch 0 taken 9629 times.
✓ Branch 1 taken 248 times.
|
9877 | if (num_cands > 1) { |
723 |
2/2✓ Branch 0 taken 9185 times.
✓ Branch 1 taken 444 times.
|
9629 | const int num_ref_rists = is_b ? 2 : 1; |
724 | 9629 | const MvField* p0 = cand_list + 0; | |
725 | 9629 | const MvField* p1 = cand_list + 1; | |
726 | 9629 | MvField* cand = cand_list + num_cands; | |
727 | |||
728 | 9629 | cand->pred_flag = 0; | |
729 |
2/2✓ Branch 0 taken 18814 times.
✓ Branch 1 taken 9629 times.
|
28443 | for (int i = 0; i < num_ref_rists; i++) { |
730 | 18814 | PredFlag mask = i + 1; | |
731 |
2/2✓ Branch 0 taken 15567 times.
✓ Branch 1 taken 3247 times.
|
18814 | if (p0->pred_flag & mask) { |
732 | 15567 | cand->pred_flag |= mask; | |
733 | 15567 | cand->ref_idx[i] = p0->ref_idx[i]; | |
734 |
2/2✓ Branch 0 taken 13928 times.
✓ Branch 1 taken 1639 times.
|
15567 | if (p1->pred_flag & mask) { |
735 | 13928 | Mv *mv = cand->mv + i; | |
736 | 13928 | mv->x = p0->mv[i].x + p1->mv[i].x; | |
737 | 13928 | mv->y = p0->mv[i].y + p1->mv[i].y; | |
738 | 13928 | ff_vvc_round_mv(mv, 0, 1); | |
739 | } else { | ||
740 | 1639 | cand->mv[i] = p0->mv[i]; | |
741 | } | ||
742 |
2/2✓ Branch 0 taken 1901 times.
✓ Branch 1 taken 1346 times.
|
3247 | } else if (p1->pred_flag & mask) { |
743 | 1901 | cand->pred_flag |= mask; | |
744 | 1901 | cand->mv[i] = p1->mv[i]; | |
745 | 1901 | cand->ref_idx[i] = p1->ref_idx[i]; | |
746 | } | ||
747 | } | ||
748 |
1/2✓ Branch 0 taken 9629 times.
✗ Branch 1 not taken.
|
9629 | if (cand->pred_flag) { |
749 |
2/2✓ Branch 0 taken 9038 times.
✓ Branch 1 taken 591 times.
|
9629 | cand->hpel_if_idx = p0->hpel_if_idx == p1->hpel_if_idx ? p0->hpel_if_idx : 0; |
750 | 9629 | cand->bcw_idx = 0; | |
751 | 9629 | cand->ciip_flag = 0; | |
752 | 9629 | return 1; | |
753 | } | ||
754 | } | ||
755 | 248 | return 0; | |
756 | } | ||
757 | |||
758 | //8.5.2.5 Derivation process for zero motion vector merging candidates | ||
759 | 496 | static void mv_merge_zero_motion_candidate(const VVCLocalContext *lc, const int merge_idx, | |
760 | MvField *cand_list, int num_cands) | ||
761 | { | ||
762 | 496 | const VVCSPS *sps = lc->fc->ps.sps; | |
763 | 496 | const H266RawSliceHeader *rsh = lc->sc->sh.r; | |
764 | 992 | const int num_ref_idx = IS_P(rsh) ? | |
765 |
2/2✓ Branch 0 taken 34 times.
✓ Branch 1 taken 462 times.
|
496 | rsh->num_ref_idx_active[L0] : FFMIN(rsh->num_ref_idx_active[L0], rsh->num_ref_idx_active[L1]); |
766 | 496 | int zero_idx = 0; | |
767 | |||
768 |
1/2✓ Branch 0 taken 654 times.
✗ Branch 1 not taken.
|
654 | while (num_cands < sps->max_num_merge_cand) { |
769 | 654 | MvField *cand = cand_list + num_cands; | |
770 | |||
771 |
2/2✓ Branch 0 taken 592 times.
✓ Branch 1 taken 62 times.
|
654 | cand->pred_flag = PF_L0 + (IS_B(rsh) << 1); |
772 | 654 | AV_ZERO64(cand->mv + 0); | |
773 | 654 | AV_ZERO64(cand->mv + 1); | |
774 |
2/2✓ Branch 0 taken 629 times.
✓ Branch 1 taken 25 times.
|
654 | cand->ref_idx[0] = zero_idx < num_ref_idx ? zero_idx : 0; |
775 |
2/2✓ Branch 0 taken 629 times.
✓ Branch 1 taken 25 times.
|
654 | cand->ref_idx[1] = zero_idx < num_ref_idx ? zero_idx : 0; |
776 | 654 | cand->bcw_idx = 0; | |
777 | 654 | cand->hpel_if_idx = 0; | |
778 |
2/2✓ Branch 0 taken 496 times.
✓ Branch 1 taken 158 times.
|
654 | if (merge_idx == num_cands) |
779 | 496 | return; | |
780 | 158 | num_cands++; | |
781 | 158 | zero_idx++; | |
782 | } | ||
783 | } | ||
784 | |||
785 | 290412 | static void mv_merge_mode(const VVCLocalContext *lc, const int merge_idx, MvField *cand_list) | |
786 | { | ||
787 | 290412 | int num_cands = 0; | |
788 | 290412 | const MvField *nb_list[NUM_NBS + 1] = { NULL }; | |
789 | |||
790 |
2/2✓ Branch 1 taken 238472 times.
✓ Branch 2 taken 51940 times.
|
290412 | if (mv_merge_spatial_candidates(lc, merge_idx, nb_list, cand_list, &num_cands)) |
791 | 289916 | return; | |
792 | |||
793 |
2/2✓ Branch 1 taken 40673 times.
✓ Branch 2 taken 11267 times.
|
51940 | if (mv_merge_temporal_candidate(lc, &cand_list[num_cands])) { |
794 |
2/2✓ Branch 0 taken 19776 times.
✓ Branch 1 taken 20897 times.
|
40673 | if (merge_idx == num_cands) |
795 | 19776 | return; | |
796 | 20897 | num_cands++; | |
797 | } | ||
798 | |||
799 |
2/2✓ Branch 1 taken 22287 times.
✓ Branch 2 taken 9877 times.
|
32164 | if (mv_merge_history_candidates(lc, merge_idx, nb_list, cand_list, &num_cands)) |
800 | 22287 | return; | |
801 | |||
802 |
2/2✓ Branch 1 taken 9629 times.
✓ Branch 2 taken 248 times.
|
9877 | if (mv_merge_pairwise_candidate(cand_list, num_cands, IS_B(lc->sc->sh.r))) { |
803 |
2/2✓ Branch 0 taken 9381 times.
✓ Branch 1 taken 248 times.
|
9629 | if (merge_idx == num_cands) |
804 | 9381 | return; | |
805 | 248 | num_cands++; | |
806 | } | ||
807 | |||
808 | 496 | mv_merge_zero_motion_candidate(lc, merge_idx, cand_list, num_cands); | |
809 | } | ||
810 | |||
811 | //8.5.2.2 Derivation process for luma motion vectors for merge mode | ||
812 | 265675 | void ff_vvc_luma_mv_merge_mode(VVCLocalContext *lc, const int merge_idx, const int ciip_flag, MvField *mv) | |
813 | { | ||
814 | 265675 | const CodingUnit *cu = lc->cu; | |
815 | MvField cand_list[MRG_MAX_NUM_CANDS]; | ||
816 | |||
817 | 265675 | ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height); | |
818 | 265675 | mv_merge_mode(lc, merge_idx, cand_list); | |
819 | 265675 | *mv = cand_list[merge_idx]; | |
820 | //ciip flag in not inhritable | ||
821 | 265675 | mv->ciip_flag = ciip_flag; | |
822 | 265675 | } | |
823 | |||
824 | //8.5.4.2 Derivation process for luma motion vectors for geometric partitioning merge mode | ||
825 | 24737 | void ff_vvc_luma_mv_merge_gpm(VVCLocalContext *lc, const int merge_gpm_idx[2], MvField *mv) | |
826 | { | ||
827 | 24737 | const CodingUnit *cu = lc->cu; | |
828 | MvField cand_list[MRG_MAX_NUM_CANDS]; | ||
829 | |||
830 | 24737 | const int idx[] = { merge_gpm_idx[0], merge_gpm_idx[1] + (merge_gpm_idx[1] >= merge_gpm_idx[0]) }; | |
831 | |||
832 | 24737 | ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height); | |
833 | 24737 | mv_merge_mode(lc, FFMAX(idx[0], idx[1]), cand_list); | |
834 | 24737 | memset(mv, 0, 2 * sizeof(*mv)); | |
835 |
2/2✓ Branch 0 taken 49474 times.
✓ Branch 1 taken 24737 times.
|
74211 | for (int i = 0; i < 2; i++) { |
836 | 49474 | int lx = idx[i] & 1; | |
837 | 49474 | int mask = lx + PF_L0; | |
838 | 49474 | MvField *cand = cand_list + idx[i]; | |
839 |
2/2✓ Branch 0 taken 13529 times.
✓ Branch 1 taken 35945 times.
|
49474 | if (!(cand->pred_flag & mask)) { |
840 | 13529 | lx = !lx; | |
841 | 13529 | mask = lx + PF_L0; | |
842 | } | ||
843 | 49474 | mv[i].pred_flag = mask; | |
844 | 49474 | mv[i].ref_idx[lx] = cand->ref_idx[lx]; | |
845 | 49474 | mv[i].mv[lx] = cand->mv[lx]; | |
846 | } | ||
847 | |||
848 | 24737 | } | |
849 | |||
850 | //8.5.5.5 Derivation process for luma affine control point motion vectors from a neighbouring block | ||
851 | 28522 | static void affine_cps_from_nb(const VVCLocalContext *lc, | |
852 | const int x_nb, int y_nb, const int nbw, const int nbh, const int lx, | ||
853 | Mv *cps, int num_cps) | ||
854 | { | ||
855 | 28522 | const VVCFrameContext *fc = lc->fc; | |
856 | 28522 | const CodingUnit *cu = lc->cu; | |
857 | 28522 | const int x0 = cu->x0; | |
858 | 28522 | const int y0 = cu->y0; | |
859 | 28522 | const int cb_width = cu->cb_width; | |
860 | 28522 | const int cb_height = cu->cb_height; | |
861 | 28522 | const MvField* tab_mvf = fc->tab.mvf; | |
862 | 28522 | const int min_cb_log2_size = fc->ps.sps->min_cb_log2_size_y; | |
863 | 28522 | const int min_cb_width = fc->ps.pps->min_cb_width; | |
864 | |||
865 | 28522 | const int log2_nbw = ff_log2(nbw); | |
866 | 28522 | const int log2_nbh = ff_log2(nbh); | |
867 |
4/4✓ Branch 0 taken 8526 times.
✓ Branch 1 taken 19996 times.
✓ Branch 2 taken 3317 times.
✓ Branch 3 taken 5209 times.
|
28522 | const int is_ctb_boundary = !((y_nb + nbh) % fc->ps.sps->ctb_size_y) && (y_nb + nbh == y0); |
868 | const Mv *l, *r; | ||
869 | int mv_scale_hor, mv_scale_ver, d_hor_x, d_ver_x, d_hor_y, d_ver_y, motion_model_idc_nb; | ||
870 |
2/2✓ Branch 0 taken 3317 times.
✓ Branch 1 taken 25205 times.
|
28522 | if (is_ctb_boundary) { |
871 | 3317 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
872 | 3317 | l = &TAB_MVF(x_nb, y_nb + nbh - 1).mv[lx]; | |
873 | 3317 | r = &TAB_MVF(x_nb + nbw - 1, y_nb + nbh - 1).mv[lx]; | |
874 | } else { | ||
875 | 25205 | const int x = x_nb >> min_cb_log2_size; | |
876 | 25205 | const int y = y_nb >> min_cb_log2_size; | |
877 | 25205 | motion_model_idc_nb = SAMPLE_CTB(fc->tab.mmi, x, y); | |
878 | |||
879 | 25205 | l = &TAB_CP_MV(lx, x_nb, y_nb); | |
880 | 25205 | r = &TAB_CP_MV(lx, x_nb + nbw - 1, y_nb) + 1; | |
881 | } | ||
882 | 28522 | mv_scale_hor = l->x * (1 << 7); | |
883 | 28522 | mv_scale_ver = l->y * (1 << 7); | |
884 | 28522 | d_hor_x = (r->x - l->x) * (1 << (7 - log2_nbw)); | |
885 | 28522 | d_ver_x = (r->y - l->y) * (1 << (7 - log2_nbw)); | |
886 |
4/4✓ Branch 0 taken 25205 times.
✓ Branch 1 taken 3317 times.
✓ Branch 2 taken 14598 times.
✓ Branch 3 taken 10607 times.
|
28522 | if (!is_ctb_boundary && motion_model_idc_nb == MOTION_6_PARAMS_AFFINE) { |
887 | 14598 | const Mv* lb = &TAB_CP_MV(lx, x_nb, y_nb + nbh - 1) + 2; | |
888 | 14598 | d_hor_y = (lb->x - l->x) * (1 << (7 - log2_nbh)); | |
889 | 14598 | d_ver_y = (lb->y - l->y) * (1 << (7 - log2_nbh)); | |
890 | } else { | ||
891 | 13924 | d_hor_y = -d_ver_x; | |
892 | 13924 | d_ver_y = d_hor_x; | |
893 | } | ||
894 | |||
895 |
2/2✓ Branch 0 taken 3317 times.
✓ Branch 1 taken 25205 times.
|
28522 | if (is_ctb_boundary) { |
896 | 3317 | y_nb = y0; | |
897 | } | ||
898 | 28522 | cps[0].x = mv_scale_hor + d_hor_x * (x0 - x_nb) + d_hor_y * (y0 - y_nb); | |
899 | 28522 | cps[0].y = mv_scale_ver + d_ver_x * (x0 - x_nb) + d_ver_y * (y0 - y_nb); | |
900 | 28522 | cps[1].x = mv_scale_hor + d_hor_x * (x0 + cb_width - x_nb) + d_hor_y * (y0 - y_nb); | |
901 | 28522 | cps[1].y = mv_scale_ver + d_ver_x * (x0 + cb_width - x_nb) + d_ver_y * (y0 - y_nb); | |
902 |
2/2✓ Branch 0 taken 16137 times.
✓ Branch 1 taken 12385 times.
|
28522 | if (num_cps == 3) { |
903 | 16137 | cps[2].x = mv_scale_hor + d_hor_x * (x0 - x_nb) + d_hor_y * (y0 + cb_height - y_nb); | |
904 | 16137 | cps[2].y = mv_scale_ver + d_ver_x * (x0 - x_nb) + d_ver_y * (y0 + cb_height - y_nb); | |
905 | } | ||
906 |
2/2✓ Branch 0 taken 73181 times.
✓ Branch 1 taken 28522 times.
|
101703 | for (int i = 0; i < num_cps; i++) { |
907 | 73181 | ff_vvc_round_mv(cps + i, 0, 7); | |
908 | 73181 | ff_vvc_clip_mv(cps + i); | |
909 | } | ||
910 | 28522 | } | |
911 | |||
912 | //derive affine neighbour's postion, width and height, | ||
913 | 89409 | static int affine_neighbour_cb(const VVCFrameContext *fc, const int x_nb, const int y_nb, int *x_cb, int *y_cb, int *cbw, int *cbh) | |
914 | { | ||
915 | 89409 | const int log2_min_cb_size = fc->ps.sps->min_cb_log2_size_y; | |
916 | 89409 | const int min_cb_width = fc->ps.pps->min_cb_width; | |
917 | 89409 | const int x = x_nb >> log2_min_cb_size; | |
918 | 89409 | const int y = y_nb >> log2_min_cb_size; | |
919 | 89409 | const int motion_model_idc = SAMPLE_CTB(fc->tab.mmi, x, y); | |
920 |
2/2✓ Branch 0 taken 25563 times.
✓ Branch 1 taken 63846 times.
|
89409 | if (motion_model_idc) { |
921 | 25563 | *x_cb = SAMPLE_CTB(fc->tab.cb_pos_x[0], x, y); | |
922 | 25563 | *y_cb = SAMPLE_CTB(fc->tab.cb_pos_y[0], x, y); | |
923 | 25563 | *cbw = SAMPLE_CTB(fc->tab.cb_width[0], x, y); | |
924 | 25563 | *cbh = SAMPLE_CTB(fc->tab.cb_height[0], x, y); | |
925 | } | ||
926 | 89409 | return motion_model_idc; | |
927 | } | ||
928 | |||
929 | //part of 8.5.5.2 Derivation process for motion vectors and reference indices in subblock merge mode | ||
930 | 61468 | static int affine_merge_candidate(const VVCLocalContext *lc, const int x_cand, const int y_cand, MotionInfo* mi) | |
931 | { | ||
932 | 61468 | const VVCFrameContext *fc = lc->fc; | |
933 | int x, y, w, h, motion_model_idc; | ||
934 | |||
935 | 61468 | motion_model_idc = affine_neighbour_cb(fc, x_cand, y_cand, &x, &y, &w, &h); | |
936 |
2/2✓ Branch 0 taken 18523 times.
✓ Branch 1 taken 42945 times.
|
61468 | if (motion_model_idc) { |
937 | 18523 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
938 | 18523 | const MvField* tab_mvf = fc->tab.mvf; | |
939 | 18523 | const MvField *mvf = &TAB_MVF(x, y); | |
940 | |||
941 | 18523 | mi->bcw_idx = mvf->bcw_idx; | |
942 | 18523 | mi->pred_flag = mvf->pred_flag; | |
943 |
2/2✓ Branch 0 taken 37046 times.
✓ Branch 1 taken 18523 times.
|
55569 | for (int i = 0; i < 2; i++) { |
944 | 37046 | PredFlag mask = i + 1; | |
945 |
2/2✓ Branch 0 taken 22827 times.
✓ Branch 1 taken 14219 times.
|
37046 | if (mi->pred_flag & mask) { |
946 | 22827 | affine_cps_from_nb(lc, x, y, w, h, i, &mi->mv[i][0], motion_model_idc + 1); | |
947 | } | ||
948 | 37046 | mi->ref_idx[i] = mvf->ref_idx[i]; | |
949 | } | ||
950 | 18523 | mi->motion_model_idc = motion_model_idc; | |
951 | } | ||
952 | 61468 | return motion_model_idc; | |
953 | } | ||
954 | |||
955 | 41431 | static int affine_merge_from_nbs(NeighbourContext *ctx, const NeighbourIdx *nbs, const int num_nbs, MotionInfo* cand) | |
956 | { | ||
957 | 41431 | const VVCLocalContext *lc = ctx->lc; | |
958 |
2/2✓ Branch 0 taken 86429 times.
✓ Branch 1 taken 22908 times.
|
109337 | for (int i = 0; i < num_nbs; i++) { |
959 | 86429 | Neighbour *n = &ctx->neighbours[nbs[i]]; | |
960 |
4/4✓ Branch 1 taken 61468 times.
✓ Branch 2 taken 24961 times.
✓ Branch 4 taken 18523 times.
✓ Branch 5 taken 42945 times.
|
86429 | if (check_available(n, lc, 1) && affine_merge_candidate(lc, n->x, n->y, cand)) |
961 | 18523 | return 1; | |
962 | } | ||
963 | 22908 | return 0; | |
964 | } | ||
965 | #define AFFINE_MERGE_FROM_NBS(nbs) affine_merge_from_nbs(&nctx, nbs, FF_ARRAY_ELEMS(nbs), mi) | ||
966 | |||
967 | |||
968 | 90100 | static const MvField* derive_corner_mvf(NeighbourContext *ctx, const NeighbourIdx *neighbour, const int num_neighbour) | |
969 | { | ||
970 | 90100 | const VVCFrameContext *fc = ctx->lc->fc; | |
971 | 90100 | const MvField *tab_mvf = fc->tab.mvf; | |
972 | 90100 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
973 |
2/2✓ Branch 0 taken 93100 times.
✓ Branch 1 taken 3777 times.
|
96877 | for (int i = 0; i < num_neighbour; i++) { |
974 | 93100 | Neighbour *n = &ctx->neighbours[neighbour[i]]; | |
975 |
2/2✓ Branch 1 taken 86323 times.
✓ Branch 2 taken 6777 times.
|
93100 | if (check_available(n, ctx->lc, 1)) { |
976 | 86323 | return &TAB_MVF(n->x, n->y); | |
977 | } | ||
978 | } | ||
979 | 3777 | return NULL; | |
980 | } | ||
981 | |||
982 | #define DERIVE_CORNER_MV(nbs) derive_corner_mvf(nctx, nbs, FF_ARRAY_ELEMS(nbs)) | ||
983 | |||
984 | // check if the mv's and refidx are the same between A and B | ||
985 | 50286 | static av_always_inline int compare_pf_ref_idx(const MvField *A, const struct MvField *B, const struct MvField *C, const int lx) | |
986 | { | ||
987 | |||
988 | 50286 | const PredFlag mask = (lx + 1) & A->pred_flag; | |
989 |
2/2✓ Branch 0 taken 17918 times.
✓ Branch 1 taken 32368 times.
|
50286 | if (!(B->pred_flag & mask)) |
990 | 17918 | return 0; | |
991 |
2/2✓ Branch 0 taken 1445 times.
✓ Branch 1 taken 30923 times.
|
32368 | if (A->ref_idx[lx] != B->ref_idx[lx]) |
992 | 1445 | return 0; | |
993 |
2/2✓ Branch 0 taken 26102 times.
✓ Branch 1 taken 4821 times.
|
30923 | if (C) { |
994 |
2/2✓ Branch 0 taken 888 times.
✓ Branch 1 taken 25214 times.
|
26102 | if (!(C->pred_flag & mask)) |
995 | 888 | return 0; | |
996 |
2/2✓ Branch 0 taken 1006 times.
✓ Branch 1 taken 24208 times.
|
25214 | if (A->ref_idx[lx] != C->ref_idx[lx]) |
997 | 1006 | return 0; | |
998 | } | ||
999 | 29029 | return 1; | |
1000 | } | ||
1001 | |||
1002 | 1254562 | static av_always_inline void sb_clip_location(const VVCLocalContext *lc, | |
1003 | const int x_ctb, const int y_ctb, const Mv* temp_mv, int *x, int *y) | ||
1004 | { | ||
1005 | 1254562 | const VVCFrameContext *fc = lc->fc; | |
1006 | 1254562 | const VVCPPS *pps = fc->ps.pps; | |
1007 | 1254562 | const int ctb_log2_size = fc->ps.sps->ctb_log2_size_y; | |
1008 | 1254562 | const int subpic_idx = lc->sc->sh.r->curr_subpic_idx; | |
1009 | 1254562 | const int x_end = pps->subpic_x[subpic_idx] + pps->subpic_width[subpic_idx]; | |
1010 | 1254562 | const int y_end = pps->subpic_y[subpic_idx] + pps->subpic_height[subpic_idx]; | |
1011 | |||
1012 | 1254562 | *x = av_clip(*x + temp_mv->x, x_ctb, FFMIN(x_end - 1, x_ctb + (1 << ctb_log2_size) + 3)) & ~7; | |
1013 |
2/2✓ Branch 0 taken 1108050 times.
✓ Branch 1 taken 146512 times.
|
1254562 | *y = av_clip(*y + temp_mv->y, y_ctb, FFMIN(y_end - 1, y_ctb + (1 << ctb_log2_size) - 1)) & ~7; |
1014 | 1254562 | } | |
1015 | |||
1016 | 1254562 | static void sb_temproal_luma_motion(const VVCLocalContext *lc, | |
1017 | const int x_ctb, const int y_ctb, const Mv *temp_mv, | ||
1018 | int x, int y, uint8_t *pred_flag, Mv *mv) | ||
1019 | { | ||
1020 | MvField temp_col; | ||
1021 | Mv* mvLXCol; | ||
1022 | 1254562 | const int refIdxLx = 0; | |
1023 | 1254562 | const VVCFrameContext *fc = lc->fc; | |
1024 | 1254562 | const VVCSH *sh = &lc->sc->sh; | |
1025 | 1254562 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
1026 | 1254562 | VVCFrame *ref = fc->ref->collocated_ref; | |
1027 | 1254562 | MvField *tab_mvf = ref->tab_dmvr_mvf; | |
1028 | 1254562 | int colPic = ref->poc; | |
1029 | 1254562 | int X = 0; | |
1030 | |||
1031 | 1254562 | sb_clip_location(lc, x_ctb, y_ctb, temp_mv, &x, &y); | |
1032 | |||
1033 | 1254562 | temp_col = TAB_MVF(x, y); | |
1034 | 1254562 | mvLXCol = mv + 0; | |
1035 | 1254562 | *pred_flag = DERIVE_TEMPORAL_COLOCATED_MVS(1); | |
1036 |
2/2✓ Branch 0 taken 910078 times.
✓ Branch 1 taken 344484 times.
|
1254562 | if (IS_B(sh->r)) { |
1037 | 910078 | X = 1; | |
1038 | 910078 | mvLXCol = mv + 1; | |
1039 | 910078 | *pred_flag |= (DERIVE_TEMPORAL_COLOCATED_MVS(1)) << 1; | |
1040 | } | ||
1041 | 1254562 | } | |
1042 | |||
1043 | //8.5.5.4 Derivation process for subblock-based temporal merging base motion data | ||
1044 | 48634 | static int sb_temporal_luma_motion_data(const VVCLocalContext *lc, const MvField *a1, | |
1045 | const int x_ctb, const int y_ctb, MvField *ctr_mvf, Mv *temp_mv) | ||
1046 | { | ||
1047 | 48634 | const VVCFrameContext *fc = lc->fc; | |
1048 | 48634 | const RefPicList *rpl = lc->sc->rpl; | |
1049 | 48634 | const CodingUnit *cu = lc->cu; | |
1050 | 48634 | const int x = cu->x0 + cu->cb_width / 2; | |
1051 | 48634 | const int y = cu->y0 + cu->cb_height / 2; | |
1052 | 48634 | const VVCFrame *ref = fc->ref->collocated_ref; | |
1053 | |||
1054 | int colPic; | ||
1055 | |||
1056 | 48634 | memset(temp_mv, 0, sizeof(*temp_mv)); | |
1057 | |||
1058 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 48634 times.
|
48634 | if (!ref) { |
1059 | ✗ | memset(ctr_mvf, 0, sizeof(*ctr_mvf)); | |
1060 | ✗ | return 0; | |
1061 | } | ||
1062 | |||
1063 | 48634 | colPic = ref->poc; | |
1064 | |||
1065 |
2/2✓ Branch 0 taken 46174 times.
✓ Branch 1 taken 2460 times.
|
48634 | if (a1) { |
1066 |
4/4✓ Branch 0 taken 42315 times.
✓ Branch 1 taken 3859 times.
✓ Branch 2 taken 29006 times.
✓ Branch 3 taken 13309 times.
|
46174 | if ((a1->pred_flag & PF_L0) && colPic == rpl[L0].refs[a1->ref_idx[L0]].poc) |
1067 | 29006 | *temp_mv = a1->mv[0]; | |
1068 |
4/4✓ Branch 0 taken 11915 times.
✓ Branch 1 taken 5253 times.
✓ Branch 2 taken 9756 times.
✓ Branch 3 taken 2159 times.
|
17168 | else if ((a1->pred_flag & PF_L1) && colPic == rpl[L1].refs[a1->ref_idx[L1]].poc) |
1069 | 9756 | *temp_mv = a1->mv[1]; | |
1070 | 46174 | ff_vvc_round_mv(temp_mv, 0, 4); | |
1071 | } | ||
1072 | 48634 | sb_temproal_luma_motion(lc, x_ctb, y_ctb, temp_mv, x, y, &ctr_mvf->pred_flag , ctr_mvf->mv); | |
1073 | |||
1074 | 48634 | return ctr_mvf->pred_flag; | |
1075 | } | ||
1076 | |||
1077 | |||
1078 | //8.5.5.3 Derivation process for subblock-based temporal merging candidates | ||
1079 | 48721 | static int sb_temporal_merge_candidate(const VVCLocalContext* lc, NeighbourContext *nctx, PredictionUnit *pu) | |
1080 | { | ||
1081 | 48721 | const VVCFrameContext *fc = lc->fc; | |
1082 | 48721 | const CodingUnit *cu = lc->cu; | |
1083 | 48721 | const VVCSPS *sps = fc->ps.sps; | |
1084 | 48721 | const VVCPH *ph = &fc->ps.ph; | |
1085 | 48721 | MotionInfo *mi = &pu->mi; | |
1086 | 48721 | const int ctb_log2_size = sps->ctb_log2_size_y; | |
1087 | 48721 | const int x0 = cu->x0; | |
1088 | 48721 | const int y0 = cu->y0; | |
1089 | 48721 | const NeighbourIdx n = A1; | |
1090 | const MvField *a1; | ||
1091 | MvField ctr_mvf; | ||
1092 | 48721 | LOCAL_ALIGNED_8(Mv, temp_mv, [1]); | |
1093 | 48721 | const int x_ctb = (x0 >> ctb_log2_size) << ctb_log2_size; | |
1094 | 48721 | const int y_ctb = (y0 >> ctb_log2_size) << ctb_log2_size; | |
1095 | |||
1096 | |||
1097 |
2/2✓ Branch 0 taken 48634 times.
✓ Branch 1 taken 87 times.
|
48721 | if (!ph->r->ph_temporal_mvp_enabled_flag || |
1098 |
1/2✓ Branch 0 taken 48634 times.
✗ Branch 1 not taken.
|
48634 | !sps->r->sps_sbtmvp_enabled_flag || |
1099 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 48634 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
48634 | (cu->cb_width < 8 && cu->cb_height < 8)) |
1100 | 87 | return 0; | |
1101 | |||
1102 | 48634 | mi->num_sb_x = cu->cb_width >> 3; | |
1103 | 48634 | mi->num_sb_y = cu->cb_height >> 3; | |
1104 | |||
1105 | 48634 | a1 = derive_corner_mvf(nctx, &n, 1); | |
1106 |
2/2✓ Branch 1 taken 41506 times.
✓ Branch 2 taken 7128 times.
|
48634 | if (sb_temporal_luma_motion_data(lc, a1, x_ctb, y_ctb, &ctr_mvf, temp_mv)) { |
1107 | 41506 | const int sbw = cu->cb_width / mi->num_sb_x; | |
1108 | 41506 | const int sbh = cu->cb_height / mi->num_sb_y; | |
1109 | 41506 | MvField mvf = {0}; | |
1110 |
2/2✓ Branch 0 taken 171844 times.
✓ Branch 1 taken 41506 times.
|
213350 | for (int sby = 0; sby < mi->num_sb_y; sby++) { |
1111 |
2/2✓ Branch 0 taken 1205928 times.
✓ Branch 1 taken 171844 times.
|
1377772 | for (int sbx = 0; sbx < mi->num_sb_x; sbx++) { |
1112 | 1205928 | int x = x0 + sbx * sbw; | |
1113 | 1205928 | int y = y0 + sby * sbh; | |
1114 | 1205928 | sb_temproal_luma_motion(lc, x_ctb, y_ctb, temp_mv, x + sbw / 2, y + sbh / 2, &mvf.pred_flag, mvf.mv); | |
1115 |
2/2✓ Branch 0 taken 6594 times.
✓ Branch 1 taken 1199334 times.
|
1205928 | if (!mvf.pred_flag) { |
1116 | 6594 | mvf.pred_flag = ctr_mvf.pred_flag; | |
1117 | 6594 | memcpy(mvf.mv, ctr_mvf.mv, sizeof(mvf.mv)); | |
1118 | } | ||
1119 | 1205928 | ff_vvc_set_mvf(lc, x, y, sbw, sbh, &mvf); | |
1120 | } | ||
1121 | } | ||
1122 | 41506 | return 1; | |
1123 | } | ||
1124 | 7128 | return 0; | |
1125 | } | ||
1126 | |||
1127 | 13822 | static int affine_merge_const1(const MvField *c0, const MvField *c1, const MvField *c2, MotionInfo *mi) | |
1128 | { | ||
1129 |
6/6✓ Branch 0 taken 13757 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 13133 times.
✓ Branch 3 taken 624 times.
✓ Branch 4 taken 12632 times.
✓ Branch 5 taken 501 times.
|
13822 | if (c0 && c1 && c2) { |
1130 | 12632 | mi->pred_flag = 0; | |
1131 |
2/2✓ Branch 0 taken 25264 times.
✓ Branch 1 taken 12632 times.
|
37896 | for (int i = 0; i < 2; i++) { |
1132 | 25264 | PredFlag mask = i + 1; | |
1133 |
2/2✓ Branch 1 taken 14831 times.
✓ Branch 2 taken 10433 times.
|
25264 | if (compare_pf_ref_idx(c0, c1, c2, i)) { |
1134 | 14831 | mi->pred_flag |= mask; | |
1135 | 14831 | mi->ref_idx[i] = c0->ref_idx[i]; | |
1136 | 14831 | mi->mv[i][0] = c0->mv[i]; | |
1137 | 14831 | mi->mv[i][1] = c1->mv[i]; | |
1138 | 14831 | mi->mv[i][2] = c2->mv[i]; | |
1139 | } | ||
1140 | } | ||
1141 |
2/2✓ Branch 0 taken 11695 times.
✓ Branch 1 taken 937 times.
|
12632 | if (mi->pred_flag) { |
1142 |
2/2✓ Branch 0 taken 3136 times.
✓ Branch 1 taken 8559 times.
|
11695 | if (mi->pred_flag == PF_BI) |
1143 | 3136 | mi->bcw_idx = c0->bcw_idx; | |
1144 | 11695 | mi->motion_model_idc = MOTION_6_PARAMS_AFFINE; | |
1145 | 11695 | return 1; | |
1146 | } | ||
1147 | } | ||
1148 | 2127 | return 0; | |
1149 | } | ||
1150 | |||
1151 | 7350 | static int affine_merge_const2(const MvField *c0, const MvField *c1, const MvField *c3, MotionInfo *mi) | |
1152 | { | ||
1153 |
6/6✓ Branch 0 taken 7285 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 6661 times.
✓ Branch 3 taken 624 times.
✓ Branch 4 taken 4507 times.
✓ Branch 5 taken 2154 times.
|
7350 | if (c0 && c1 && c3) { |
1154 | 4507 | mi->pred_flag = 0; | |
1155 |
2/2✓ Branch 0 taken 9014 times.
✓ Branch 1 taken 4507 times.
|
13521 | for (int i = 0; i < 2; i++) { |
1156 | 9014 | PredFlag mask = i + 1; | |
1157 |
2/2✓ Branch 1 taken 5295 times.
✓ Branch 2 taken 3719 times.
|
9014 | if (compare_pf_ref_idx(c0, c1, c3, i)) { |
1158 | 5295 | mi->pred_flag |= mask; | |
1159 | 5295 | mi->ref_idx[i] = c0->ref_idx[i]; | |
1160 | 5295 | mi->mv[i][0] = c0->mv[i]; | |
1161 | 5295 | mi->mv[i][1] = c1->mv[i]; | |
1162 | 5295 | mi->mv[i][2].x = c3->mv[i].x + c0->mv[i].x - c1->mv[i].x; | |
1163 | 5295 | mi->mv[i][2].y = c3->mv[i].y + c0->mv[i].y - c1->mv[i].y; | |
1164 | 5295 | ff_vvc_clip_mv(&mi->mv[i][2]); | |
1165 | } | ||
1166 | } | ||
1167 |
2/2✓ Branch 0 taken 3942 times.
✓ Branch 1 taken 565 times.
|
4507 | if (mi->pred_flag) { |
1168 |
2/2✓ Branch 0 taken 1353 times.
✓ Branch 1 taken 2589 times.
|
3942 | mi->bcw_idx = mi->pred_flag == PF_BI ? c0->bcw_idx : 0; |
1169 | 3942 | mi->motion_model_idc = MOTION_6_PARAMS_AFFINE; | |
1170 | 3942 | return 1; | |
1171 | } | ||
1172 | } | ||
1173 | 3408 | return 0; | |
1174 | } | ||
1175 | |||
1176 | 5287 | static int affine_merge_const3(const MvField *c0, const MvField *c2, const MvField *c3, MotionInfo *mi) | |
1177 | { | ||
1178 |
6/6✓ Branch 0 taken 5222 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 4904 times.
✓ Branch 3 taken 318 times.
✓ Branch 4 taken 2766 times.
✓ Branch 5 taken 2138 times.
|
5287 | if (c0 && c2 && c3) { |
1179 | 2766 | mi->pred_flag = 0; | |
1180 |
2/2✓ Branch 0 taken 5532 times.
✓ Branch 1 taken 2766 times.
|
8298 | for (int i = 0; i < 2; i++) { |
1181 | 5532 | PredFlag mask = i + 1; | |
1182 |
2/2✓ Branch 1 taken 3172 times.
✓ Branch 2 taken 2360 times.
|
5532 | if (compare_pf_ref_idx(c0, c2, c3, i)) { |
1183 | 3172 | mi->pred_flag |= mask; | |
1184 | 3172 | mi->ref_idx[i] = c0->ref_idx[i]; | |
1185 | 3172 | mi->mv[i][0] = c0->mv[i]; | |
1186 | 3172 | mi->mv[i][1].x = c3->mv[i].x + c0->mv[i].x - c2->mv[i].x; | |
1187 | 3172 | mi->mv[i][1].y = c3->mv[i].y + c0->mv[i].y - c2->mv[i].y; | |
1188 | 3172 | ff_vvc_clip_mv(&mi->mv[i][1]); | |
1189 | 3172 | mi->mv[i][2] = c2->mv[i]; | |
1190 | } | ||
1191 | } | ||
1192 |
2/2✓ Branch 0 taken 2347 times.
✓ Branch 1 taken 419 times.
|
2766 | if (mi->pred_flag) { |
1193 |
2/2✓ Branch 0 taken 825 times.
✓ Branch 1 taken 1522 times.
|
2347 | mi->bcw_idx = mi->pred_flag == PF_BI ? c0->bcw_idx : 0; |
1194 | 2347 | mi->motion_model_idc = MOTION_6_PARAMS_AFFINE; | |
1195 | 2347 | return 1; | |
1196 | } | ||
1197 | } | ||
1198 | 2940 | return 0; | |
1199 | } | ||
1200 | |||
1201 | 3700 | static int affine_merge_const4(const MvField *c1, const MvField *c2, const MvField *c3, MotionInfo *mi) | |
1202 | { | ||
1203 |
6/6✓ Branch 0 taken 3305 times.
✓ Branch 1 taken 395 times.
✓ Branch 2 taken 2993 times.
✓ Branch 3 taken 312 times.
✓ Branch 4 taken 1060 times.
✓ Branch 5 taken 1933 times.
|
3700 | if (c1 && c2 && c3) { |
1204 | 1060 | mi->pred_flag = 0; | |
1205 |
2/2✓ Branch 0 taken 2120 times.
✓ Branch 1 taken 1060 times.
|
3180 | for (int i = 0; i < 2; i++) { |
1206 | 2120 | PredFlag mask = i + 1; | |
1207 |
2/2✓ Branch 1 taken 910 times.
✓ Branch 2 taken 1210 times.
|
2120 | if (compare_pf_ref_idx(c1, c2, c3, i)) { |
1208 | 910 | mi->pred_flag |= mask; | |
1209 | 910 | mi->ref_idx[i] = c1->ref_idx[i]; | |
1210 | 910 | mi->mv[i][0].x = c1->mv[i].x + c2->mv[i].x - c3->mv[i].x; | |
1211 | 910 | mi->mv[i][0].y = c1->mv[i].y + c2->mv[i].y - c3->mv[i].y; | |
1212 | 910 | ff_vvc_clip_mv(&mi->mv[i][0]); | |
1213 | 910 | mi->mv[i][1] = c1->mv[i]; | |
1214 | 910 | mi->mv[i][2] = c2->mv[i]; | |
1215 | } | ||
1216 | } | ||
1217 |
2/2✓ Branch 0 taken 669 times.
✓ Branch 1 taken 391 times.
|
1060 | if (mi->pred_flag) { |
1218 |
2/2✓ Branch 0 taken 241 times.
✓ Branch 1 taken 428 times.
|
669 | mi->bcw_idx = mi->pred_flag == PF_BI ? c1->bcw_idx : 0; |
1219 | 669 | mi->motion_model_idc = MOTION_6_PARAMS_AFFINE; | |
1220 | 669 | return 1; | |
1221 | } | ||
1222 | } | ||
1223 | 3031 | return 0; | |
1224 | } | ||
1225 | |||
1226 | 3076 | static int affine_merge_const5(const MvField *c0, const MvField *c1, MotionInfo *mi) | |
1227 | { | ||
1228 |
4/4✓ Branch 0 taken 3011 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 2673 times.
✓ Branch 3 taken 338 times.
|
3076 | if (c0 && c1) { |
1229 | 2673 | mi->pred_flag = 0; | |
1230 |
2/2✓ Branch 0 taken 5346 times.
✓ Branch 1 taken 2673 times.
|
8019 | for (int i = 0; i < 2; i++) { |
1231 | 5346 | PredFlag mask = i + 1; | |
1232 |
2/2✓ Branch 1 taken 3029 times.
✓ Branch 2 taken 2317 times.
|
5346 | if (compare_pf_ref_idx(c0, c1, NULL, i)) { |
1233 | 3029 | mi->pred_flag |= mask; | |
1234 | 3029 | mi->ref_idx[i] = c0->ref_idx[i]; | |
1235 | 3029 | mi->mv[i][0] = c0->mv[i]; | |
1236 | 3029 | mi->mv[i][1] = c1->mv[i]; | |
1237 | } | ||
1238 | } | ||
1239 |
2/2✓ Branch 0 taken 2400 times.
✓ Branch 1 taken 273 times.
|
2673 | if (mi->pred_flag) { |
1240 |
2/2✓ Branch 0 taken 629 times.
✓ Branch 1 taken 1771 times.
|
2400 | if (mi->pred_flag == PF_BI) |
1241 | 629 | mi->bcw_idx = c0->bcw_idx; | |
1242 | 2400 | mi->motion_model_idc = MOTION_4_PARAMS_AFFINE; | |
1243 | 2400 | return 1; | |
1244 | } | ||
1245 | } | ||
1246 | 676 | return 0; | |
1247 | } | ||
1248 | |||
1249 | 1651 | static int affine_merge_const6(const MvField* c0, const MvField* c2, const int cb_width, const int cb_height, MotionInfo *mi) | |
1250 | { | ||
1251 |
4/4✓ Branch 0 taken 1586 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 1505 times.
✓ Branch 3 taken 81 times.
|
1651 | if (c0 && c2) { |
1252 | 1505 | const int shift = 7 + av_log2(cb_width) - av_log2(cb_height); | |
1253 | 1505 | mi->pred_flag = 0; | |
1254 |
2/2✓ Branch 0 taken 3010 times.
✓ Branch 1 taken 1505 times.
|
4515 | for (int i = 0; i < 2; i++) { |
1255 | 3010 | PredFlag mask = i + 1; | |
1256 |
2/2✓ Branch 1 taken 1792 times.
✓ Branch 2 taken 1218 times.
|
3010 | if (compare_pf_ref_idx(c0, c2, NULL, i)) { |
1257 | 1792 | mi->pred_flag |= mask; | |
1258 | 1792 | mi->ref_idx[i] = c0->ref_idx[i]; | |
1259 | 1792 | mi->mv[i][0] = c0->mv[i]; | |
1260 | 1792 | mi->mv[i][1].x = (c0->mv[i].x * (1 << 7)) + ((c2->mv[i].y - c0->mv[i].y) * (1 << shift)); | |
1261 | 1792 | mi->mv[i][1].y = (c0->mv[i].y * (1 << 7)) - ((c2->mv[i].x - c0->mv[i].x) * (1 << shift)); | |
1262 | 1792 | ff_vvc_round_mv(&mi->mv[i][1], 0, 7); | |
1263 | 1792 | ff_vvc_clip_mv(&mi->mv[i][1]); | |
1264 | } | ||
1265 | } | ||
1266 |
2/2✓ Branch 0 taken 1411 times.
✓ Branch 1 taken 94 times.
|
1505 | if (mi->pred_flag) { |
1267 |
2/2✓ Branch 0 taken 381 times.
✓ Branch 1 taken 1030 times.
|
1411 | if (mi->pred_flag == PF_BI) |
1268 | 381 | mi->bcw_idx = c0->bcw_idx; | |
1269 | 1411 | mi->motion_model_idc = MOTION_4_PARAMS_AFFINE; | |
1270 | 1411 | return 1; | |
1271 | } | ||
1272 | } | ||
1273 | 240 | return 0; | |
1274 | } | ||
1275 | |||
1276 | 540 | static void affine_merge_zero_motion(const VVCLocalContext *lc, MotionInfo *mi) | |
1277 | { | ||
1278 | 540 | const CodingUnit *cu = lc->cu; | |
1279 | |||
1280 | 540 | memset(mi, 0, sizeof(*mi)); | |
1281 |
2/2✓ Branch 0 taken 418 times.
✓ Branch 1 taken 122 times.
|
540 | mi->pred_flag = PF_L0 + (IS_B(lc->sc->sh.r) << 1); |
1282 | 540 | mi->motion_model_idc = MOTION_4_PARAMS_AFFINE; | |
1283 | 540 | mi->num_sb_x = cu->cb_width >> MIN_PU_LOG2; | |
1284 | 540 | mi->num_sb_y = cu->cb_height >> MIN_PU_LOG2; | |
1285 | 540 | } | |
1286 | |||
1287 | //8.5.5.6 Derivation process for constructed affine control point motion vector merging candidates | ||
1288 | 13822 | static int affine_merge_const_candidates(const VVCLocalContext *lc, MotionInfo *mi, | |
1289 | NeighbourContext *nctx, const int merge_subblock_idx, int num_cands) | ||
1290 | { | ||
1291 | 13822 | const VVCFrameContext *fc = lc->fc; | |
1292 | 13822 | const CodingUnit *cu = lc->cu; | |
1293 | 13822 | const NeighbourIdx tl[] = { B2, B3, A2 }; | |
1294 | 13822 | const NeighbourIdx tr[] = { B1, B0}; | |
1295 | 13822 | const NeighbourIdx bl[] = { A1, A0}; | |
1296 | const MvField *c0, *c1, *c2; | ||
1297 | |||
1298 | 13822 | c0 = DERIVE_CORNER_MV(tl); | |
1299 | 13822 | c1 = DERIVE_CORNER_MV(tr); | |
1300 | 13822 | c2 = DERIVE_CORNER_MV(bl); | |
1301 | |||
1302 |
1/2✓ Branch 0 taken 13822 times.
✗ Branch 1 not taken.
|
13822 | if (fc->ps.sps->r->sps_6param_affine_enabled_flag) { |
1303 | 13822 | MvField corner3, *c3 = NULL; | |
1304 | //Const1 | ||
1305 |
2/2✓ Branch 1 taken 11695 times.
✓ Branch 2 taken 2127 times.
|
13822 | if (affine_merge_const1(c0, c1, c2, mi)) { |
1306 |
2/2✓ Branch 0 taken 6472 times.
✓ Branch 1 taken 5223 times.
|
11695 | if (merge_subblock_idx == num_cands) |
1307 | 10746 | return 1; | |
1308 | 5223 | num_cands++; | |
1309 | } | ||
1310 | |||
1311 | 7350 | memset(&corner3, 0, sizeof(corner3)); | |
1312 |
2/2✓ Branch 0 taken 7324 times.
✓ Branch 1 taken 26 times.
|
7350 | if (fc->ps.ph.r->ph_temporal_mvp_enabled_flag){ |
1313 | 7324 | const int available_l0 = temporal_luma_motion_vector(lc, 0, corner3.mv + 0, 0, 0, 0); | |
1314 | 14648 | const int available_l1 = (lc->sc->sh.r->sh_slice_type == VVC_SLICE_TYPE_B) ? | |
1315 |
2/2✓ Branch 0 taken 5900 times.
✓ Branch 1 taken 1424 times.
|
7324 | temporal_luma_motion_vector(lc, 0, corner3.mv + 1, 1, 0, 0) : 0; |
1316 | |||
1317 | 7324 | corner3.pred_flag = available_l0 + (available_l1 << 1); | |
1318 |
2/2✓ Branch 0 taken 4941 times.
✓ Branch 1 taken 2383 times.
|
7324 | if (corner3.pred_flag) |
1319 | 4941 | c3 = &corner3; | |
1320 | } | ||
1321 | |||
1322 | //Const2 | ||
1323 |
2/2✓ Branch 1 taken 3942 times.
✓ Branch 2 taken 3408 times.
|
7350 | if (affine_merge_const2(c0, c1, c3, mi)) { |
1324 |
2/2✓ Branch 0 taken 2063 times.
✓ Branch 1 taken 1879 times.
|
3942 | if (merge_subblock_idx == num_cands) |
1325 | 2063 | return 1; | |
1326 | 1879 | num_cands++; | |
1327 | } | ||
1328 | |||
1329 | //Const3 | ||
1330 |
2/2✓ Branch 1 taken 2347 times.
✓ Branch 2 taken 2940 times.
|
5287 | if (affine_merge_const3(c0, c2, c3, mi)) { |
1331 |
2/2✓ Branch 0 taken 1587 times.
✓ Branch 1 taken 760 times.
|
2347 | if (merge_subblock_idx == num_cands) |
1332 | 1587 | return 1; | |
1333 | 760 | num_cands++; | |
1334 | } | ||
1335 | |||
1336 | //Const4 | ||
1337 |
2/2✓ Branch 1 taken 669 times.
✓ Branch 2 taken 3031 times.
|
3700 | if (affine_merge_const4(c1, c2, c3, mi)) { |
1338 |
2/2✓ Branch 0 taken 624 times.
✓ Branch 1 taken 45 times.
|
669 | if (merge_subblock_idx == num_cands) |
1339 | 624 | return 1; | |
1340 | 45 | num_cands++; | |
1341 | } | ||
1342 | } | ||
1343 | |||
1344 | //Const5 | ||
1345 |
2/2✓ Branch 1 taken 2400 times.
✓ Branch 2 taken 676 times.
|
3076 | if (affine_merge_const5(c0, c1, mi)) { |
1346 |
2/2✓ Branch 0 taken 1425 times.
✓ Branch 1 taken 975 times.
|
2400 | if (merge_subblock_idx == num_cands) |
1347 | 1425 | return 1; | |
1348 | 975 | num_cands++; | |
1349 | } | ||
1350 | |||
1351 |
2/2✓ Branch 1 taken 1411 times.
✓ Branch 2 taken 240 times.
|
1651 | if (affine_merge_const6(c0, c2, cu->cb_width, cu->cb_height, mi)) { |
1352 |
2/2✓ Branch 0 taken 1111 times.
✓ Branch 1 taken 300 times.
|
1411 | if (merge_subblock_idx == num_cands) |
1353 | 1111 | return 1; | |
1354 | } | ||
1355 | 540 | return 0; | |
1356 | } | ||
1357 | |||
1358 | //8.5.5.2 Derivation process for motion vectors and reference indices in subblock merge mode | ||
1359 | //return 1 if candidate is SbCol | ||
1360 | 48721 | static int sb_mv_merge_mode(const VVCLocalContext *lc, const int merge_subblock_idx, PredictionUnit *pu) | |
1361 | { | ||
1362 | 48721 | const VVCSPS *sps = lc->fc->ps.sps; | |
1363 | 48721 | const CodingUnit *cu = lc->cu; | |
1364 | 48721 | MotionInfo *mi = &pu->mi; | |
1365 | 48721 | int num_cands = 0; | |
1366 | NeighbourContext nctx; | ||
1367 | |||
1368 | 48721 | init_neighbour_context(&nctx, lc); | |
1369 | |||
1370 | //SbCol | ||
1371 |
2/2✓ Branch 1 taken 41506 times.
✓ Branch 2 taken 7215 times.
|
48721 | if (sb_temporal_merge_candidate(lc, &nctx, pu)) { |
1372 |
2/2✓ Branch 0 taken 25354 times.
✓ Branch 1 taken 16152 times.
|
41506 | if (merge_subblock_idx == num_cands) |
1373 | 25354 | return 1; | |
1374 | 16152 | num_cands++; | |
1375 | } | ||
1376 | |||
1377 | 23367 | pu->inter_affine_flag = 1; | |
1378 | 23367 | mi->num_sb_x = cu->cb_width >> MIN_PU_LOG2; | |
1379 | 23367 | mi->num_sb_y = cu->cb_height >> MIN_PU_LOG2; | |
1380 | |||
1381 |
1/2✓ Branch 0 taken 23367 times.
✗ Branch 1 not taken.
|
23367 | if (sps->r->sps_affine_enabled_flag) { |
1382 | 23367 | const NeighbourIdx ak[] = { A0, A1 }; | |
1383 | 23367 | const NeighbourIdx bk[] = { B0, B1, B2 }; | |
1384 | //A | ||
1385 |
2/2✓ Branch 1 taken 9624 times.
✓ Branch 2 taken 13743 times.
|
23367 | if (AFFINE_MERGE_FROM_NBS(ak)) { |
1386 |
2/2✓ Branch 0 taken 5303 times.
✓ Branch 1 taken 4321 times.
|
9624 | if (merge_subblock_idx == num_cands) |
1387 | 22827 | return 0; | |
1388 | 4321 | num_cands++; | |
1389 | } | ||
1390 | |||
1391 | //B | ||
1392 |
2/2✓ Branch 1 taken 8899 times.
✓ Branch 2 taken 9165 times.
|
18064 | if (AFFINE_MERGE_FROM_NBS(bk)) { |
1393 |
2/2✓ Branch 0 taken 4242 times.
✓ Branch 1 taken 4657 times.
|
8899 | if (merge_subblock_idx == num_cands) |
1394 | 4242 | return 0; | |
1395 | 4657 | num_cands++; | |
1396 | } | ||
1397 | |||
1398 | //Const1 to Const6 | ||
1399 |
2/2✓ Branch 1 taken 13282 times.
✓ Branch 2 taken 540 times.
|
13822 | if (affine_merge_const_candidates(lc, mi, &nctx, merge_subblock_idx, num_cands)) |
1400 | 13282 | return 0; | |
1401 | } | ||
1402 | //Zero | ||
1403 | 540 | affine_merge_zero_motion(lc, mi); | |
1404 | 540 | return 0; | |
1405 | } | ||
1406 | |||
1407 | 48721 | void ff_vvc_sb_mv_merge_mode(VVCLocalContext *lc, const int merge_subblock_idx, PredictionUnit *pu) | |
1408 | { | ||
1409 | 48721 | const CodingUnit *cu = lc->cu; | |
1410 | 48721 | ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height); | |
1411 |
2/2✓ Branch 1 taken 23367 times.
✓ Branch 2 taken 25354 times.
|
48721 | if (!sb_mv_merge_mode(lc, merge_subblock_idx, pu)) { |
1412 | 23367 | ff_vvc_store_sb_mvs(lc, pu); | |
1413 | } | ||
1414 | 48721 | } | |
1415 | |||
1416 | 105141 | static int mvp_candidate(const VVCLocalContext *lc, const int x_cand, const int y_cand, | |
1417 | const int lx, const int8_t *ref_idx, Mv *mv) | ||
1418 | { | ||
1419 | 105141 | const VVCFrameContext *fc = lc->fc; | |
1420 | 105141 | const RefPicList *rpl = lc->sc->rpl; | |
1421 | 105141 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
1422 | 105141 | const MvField* tab_mvf = fc->tab.mvf; | |
1423 | 105141 | const MvField *mvf = &TAB_MVF(x_cand, y_cand); | |
1424 | 105141 | const PredFlag maskx = lx + 1; | |
1425 | 105141 | const int poc = rpl[lx].refs[ref_idx[lx]].poc; | |
1426 | 105141 | int available = 0; | |
1427 | |||
1428 |
4/4✓ Branch 0 taken 81718 times.
✓ Branch 1 taken 23423 times.
✓ Branch 2 taken 60674 times.
✓ Branch 3 taken 21044 times.
|
105141 | if ((mvf->pred_flag & maskx) && rpl[lx].refs[mvf->ref_idx[lx]].poc == poc) { |
1429 | 60674 | available = 1; | |
1430 | 60674 | *mv = mvf->mv[lx]; | |
1431 | } else { | ||
1432 | 44467 | const int ly = !lx; | |
1433 | 44467 | const PredFlag masky = ly + 1; | |
1434 |
4/4✓ Branch 0 taken 32791 times.
✓ Branch 1 taken 11676 times.
✓ Branch 2 taken 7026 times.
✓ Branch 3 taken 25765 times.
|
44467 | if ((mvf->pred_flag & masky) && rpl[ly].refs[mvf->ref_idx[ly]].poc == poc) { |
1435 | 7026 | available = 1; | |
1436 | 7026 | *mv = mvf->mv[ly]; | |
1437 | } | ||
1438 | } | ||
1439 | |||
1440 | 105141 | return available; | |
1441 | } | ||
1442 | |||
1443 | 27941 | static int affine_mvp_candidate(const VVCLocalContext *lc, | |
1444 | const int x_cand, const int y_cand, const int lx, const int8_t *ref_idx, | ||
1445 | Mv *cps, const int num_cp) | ||
1446 | { | ||
1447 | 27941 | const VVCFrameContext *fc = lc->fc; | |
1448 | 27941 | int x_nb, y_nb, nbw, nbh, motion_model_idc, available = 0; | |
1449 | |||
1450 | 27941 | motion_model_idc = affine_neighbour_cb(fc, x_cand, y_cand, &x_nb, &y_nb, &nbw, &nbh); | |
1451 |
2/2✓ Branch 0 taken 7040 times.
✓ Branch 1 taken 20901 times.
|
27941 | if (motion_model_idc) { |
1452 | 7040 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
1453 | 7040 | const MvField* tab_mvf = fc->tab.mvf; | |
1454 | 7040 | const MvField *mvf = &TAB_MVF(x_nb, y_nb); | |
1455 | 7040 | RefPicList* rpl = lc->sc->rpl; | |
1456 | 7040 | const PredFlag maskx = lx + 1; | |
1457 | 7040 | const int poc = rpl[lx].refs[ref_idx[lx]].poc; | |
1458 | |||
1459 |
4/4✓ Branch 0 taken 5961 times.
✓ Branch 1 taken 1079 times.
✓ Branch 2 taken 5010 times.
✓ Branch 3 taken 951 times.
|
7040 | if ((mvf->pred_flag & maskx) && rpl[lx].refs[mvf->ref_idx[lx]].poc == poc) { |
1460 | 5010 | available = 1; | |
1461 | 5010 | affine_cps_from_nb(lc, x_nb, y_nb, nbw, nbh, lx, cps, num_cp); | |
1462 | } else { | ||
1463 | 2030 | const int ly = !lx; | |
1464 | 2030 | const PredFlag masky = ly + 1; | |
1465 |
4/4✓ Branch 0 taken 1311 times.
✓ Branch 1 taken 719 times.
✓ Branch 2 taken 685 times.
✓ Branch 3 taken 626 times.
|
2030 | if ((mvf->pred_flag & masky) && rpl[ly].refs[mvf->ref_idx[ly]].poc == poc) { |
1466 | 685 | available = 1; | |
1467 | 685 | affine_cps_from_nb(lc, x_nb, y_nb, nbw, nbh, ly, cps, num_cp); | |
1468 | } | ||
1469 | } | ||
1470 | |||
1471 | } | ||
1472 | 27941 | return available; | |
1473 | } | ||
1474 | |||
1475 | 121746 | static int mvp_from_nbs(NeighbourContext *ctx, | |
1476 | const NeighbourIdx *nbs, const int num_nbs, const int lx, const int8_t *ref_idx, const int amvr_shift, | ||
1477 | Mv *cps, const int num_cps) | ||
1478 | { | ||
1479 | 121746 | const VVCLocalContext *lc = ctx->lc; | |
1480 | 121746 | int available = 0; | |
1481 | |||
1482 |
2/2✓ Branch 0 taken 234816 times.
✓ Branch 1 taken 48351 times.
|
283167 | for (int i = 0; i < num_nbs; i++) { |
1483 | 234816 | Neighbour *n = &ctx->neighbours[nbs[i]]; | |
1484 |
2/2✓ Branch 1 taken 133082 times.
✓ Branch 2 taken 101734 times.
|
234816 | if (check_available(n, lc, 0)) { |
1485 |
2/2✓ Branch 0 taken 27941 times.
✓ Branch 1 taken 105141 times.
|
133082 | if (num_cps > 1) |
1486 | 27941 | available = affine_mvp_candidate(lc, n->x, n->y, lx, ref_idx, cps, num_cps); | |
1487 | else | ||
1488 | 105141 | available = mvp_candidate(lc, n->x, n->y, lx, ref_idx, cps); | |
1489 |
2/2✓ Branch 0 taken 73395 times.
✓ Branch 1 taken 59687 times.
|
133082 | if (available) { |
1490 |
2/2✓ Branch 0 taken 82002 times.
✓ Branch 1 taken 73395 times.
|
155397 | for (int c = 0; c < num_cps; c++) |
1491 | 82002 | ff_vvc_round_mv(cps + c, amvr_shift, amvr_shift); | |
1492 | 73395 | return 1; | |
1493 | } | ||
1494 | } | ||
1495 | } | ||
1496 | 48351 | return 0; | |
1497 | } | ||
1498 | |||
1499 | //get mvp from neighbours | ||
1500 | #define AFFINE_MVP_FROM_NBS(nbs) \ | ||
1501 | mvp_from_nbs(&nctx, nbs, FF_ARRAY_ELEMS(nbs), lx, ref_idx, amvr_shift, cps, num_cp) \ | ||
1502 | |||
1503 | #define MVP_FROM_NBS(nbs) \ | ||
1504 | mvp_from_nbs(&nctx, nbs, FF_ARRAY_ELEMS(nbs), lx, ref_idx, amvr_shift, mv, 1) \ | ||
1505 | |||
1506 | 63711 | static int mvp_spatial_candidates(const VVCLocalContext *lc, | |
1507 | const int mvp_lx_flag, const int lx, const int8_t* ref_idx, const int amvr_shift, | ||
1508 | Mv* mv, int *nb_merge_cand) | ||
1509 | { | ||
1510 | 63711 | const NeighbourIdx ak[] = { A0, A1 }; | |
1511 | 63711 | const NeighbourIdx bk[] = { B0, B1, B2 }; | |
1512 | NeighbourContext nctx; | ||
1513 | 63711 | int available_a, num_cands = 0; | |
1514 | 63711 | LOCAL_ALIGNED_8(Mv, mv_a, [1]); | |
1515 | |||
1516 | 63711 | init_neighbour_context(&nctx, lc); | |
1517 | |||
1518 | 63711 | available_a = MVP_FROM_NBS(ak); | |
1519 |
2/2✓ Branch 0 taken 42223 times.
✓ Branch 1 taken 21488 times.
|
63711 | if (available_a) { |
1520 |
2/2✓ Branch 0 taken 26040 times.
✓ Branch 1 taken 16183 times.
|
42223 | if (mvp_lx_flag == num_cands) |
1521 | 26040 | return 1; | |
1522 | 16183 | num_cands++; | |
1523 | 16183 | *mv_a = *mv; | |
1524 | } | ||
1525 |
2/2✓ Branch 1 taken 25477 times.
✓ Branch 2 taken 12194 times.
|
37671 | if (MVP_FROM_NBS(bk)) { |
1526 |
4/4✓ Branch 0 taken 14364 times.
✓ Branch 1 taken 11113 times.
✓ Branch 2 taken 12203 times.
✓ Branch 3 taken 2161 times.
|
25477 | if (!available_a || !IS_SAME_MV(mv_a, mv)) { |
1527 |
2/2✓ Branch 0 taken 20012 times.
✓ Branch 1 taken 3304 times.
|
23316 | if (mvp_lx_flag == num_cands) |
1528 | 20012 | return 1; | |
1529 | 3304 | num_cands++; | |
1530 | } | ||
1531 | } | ||
1532 | 17659 | *nb_merge_cand = num_cands; | |
1533 | 17659 | return 0; | |
1534 | } | ||
1535 | |||
1536 | 17659 | static int mvp_temporal_candidates(const VVCLocalContext* lc, | |
1537 | const int mvp_lx_flag, const int lx, const int8_t *ref_idx, const int amvr_shift, | ||
1538 | Mv* mv, int *num_cands) | ||
1539 | { | ||
1540 |
2/2✓ Branch 1 taken 12848 times.
✓ Branch 2 taken 4811 times.
|
17659 | if (temporal_luma_motion_vector(lc, ref_idx[lx], mv, lx, 1, 0)) { |
1541 |
2/2✓ Branch 0 taken 11075 times.
✓ Branch 1 taken 1773 times.
|
12848 | if (mvp_lx_flag == *num_cands) { |
1542 | 11075 | ff_vvc_round_mv(mv, amvr_shift, amvr_shift); | |
1543 | 11075 | return 1; | |
1544 | } | ||
1545 | 1773 | (*num_cands)++; | |
1546 | } | ||
1547 | 6584 | return 0; | |
1548 | |||
1549 | } | ||
1550 | |||
1551 | 6584 | static int mvp_history_candidates(const VVCLocalContext *lc, | |
1552 | const int mvp_lx_flag, const int lx, const int8_t ref_idx, const int amvr_shift, | ||
1553 | Mv *mv, int num_cands) | ||
1554 | { | ||
1555 | 6584 | const EntryPoint* ep = lc->ep; | |
1556 | 6584 | const RefPicList* rpl = lc->sc->rpl; | |
1557 | 6584 | const int poc = rpl[lx].refs[ref_idx].poc; | |
1558 | |||
1559 |
2/2✓ Branch 0 taken 272 times.
✓ Branch 1 taken 6312 times.
|
6584 | if (ep->num_hmvp == 0) |
1560 | 272 | return 0; | |
1561 |
2/2✓ Branch 0 taken 13062 times.
✓ Branch 1 taken 1503 times.
|
14565 | for (int i = 1; i <= FFMIN(4, ep->num_hmvp); i++) { |
1562 | 13062 | const MvField* h = &ep->hmvp[i - 1]; | |
1563 |
2/2✓ Branch 0 taken 21733 times.
✓ Branch 1 taken 8253 times.
|
29986 | for (int j = 0; j < 2; j++) { |
1564 |
2/2✓ Branch 0 taken 8671 times.
✓ Branch 1 taken 13062 times.
|
21733 | const int ly = (j ? !lx : lx); |
1565 | 21733 | PredFlag mask = PF_L0 + ly; | |
1566 |
4/4✓ Branch 0 taken 15185 times.
✓ Branch 1 taken 6548 times.
✓ Branch 2 taken 5533 times.
✓ Branch 3 taken 9652 times.
|
21733 | if ((h->pred_flag & mask) && poc == rpl[ly].refs[h->ref_idx[ly]].poc) { |
1567 |
2/2✓ Branch 0 taken 4809 times.
✓ Branch 1 taken 724 times.
|
5533 | if (mvp_lx_flag == num_cands) { |
1568 | 4809 | *mv = h->mv[ly]; | |
1569 | 4809 | ff_vvc_round_mv(mv, amvr_shift, amvr_shift); | |
1570 | 4809 | return 1; | |
1571 | } | ||
1572 | 724 | num_cands++; | |
1573 | } | ||
1574 | } | ||
1575 | } | ||
1576 | 1503 | return 0; | |
1577 | } | ||
1578 | |||
1579 | //8.5.2.8 Derivation process for luma motion vector prediction | ||
1580 | 63711 | static void mvp(const VVCLocalContext *lc, const int mvp_lx_flag, const int lx, | |
1581 | const int8_t *ref_idx, const int amvr_shift, Mv *mv) | ||
1582 | { | ||
1583 | int num_cands; | ||
1584 | |||
1585 |
2/2✓ Branch 1 taken 46052 times.
✓ Branch 2 taken 17659 times.
|
63711 | if (mvp_spatial_candidates(lc, mvp_lx_flag, lx, ref_idx, amvr_shift, mv, &num_cands)) |
1586 | 61936 | return; | |
1587 | |||
1588 |
2/2✓ Branch 1 taken 11075 times.
✓ Branch 2 taken 6584 times.
|
17659 | if (mvp_temporal_candidates(lc, mvp_lx_flag, lx, ref_idx, amvr_shift, mv, &num_cands)) |
1589 | 11075 | return; | |
1590 | |||
1591 |
2/2✓ Branch 1 taken 4809 times.
✓ Branch 2 taken 1775 times.
|
6584 | if (mvp_history_candidates(lc, mvp_lx_flag, lx, ref_idx[lx], amvr_shift, mv, num_cands)) |
1592 | 4809 | return; | |
1593 | |||
1594 | 1775 | memset(mv, 0, sizeof(*mv)); | |
1595 | } | ||
1596 | |||
1597 | 48683 | void ff_vvc_mvp(VVCLocalContext *lc, const int *mvp_lx_flag, const int amvr_shift, MotionInfo *mi) | |
1598 | { | ||
1599 | 48683 | const CodingUnit *cu = lc->cu; | |
1600 | 48683 | mi->num_sb_x = 1; | |
1601 | 48683 | mi->num_sb_y = 1; | |
1602 | |||
1603 | 48683 | ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height); | |
1604 |
2/2✓ Branch 0 taken 41673 times.
✓ Branch 1 taken 7010 times.
|
48683 | if (mi->pred_flag != PF_L1) |
1605 | 41673 | mvp(lc, mvp_lx_flag[L0], L0, mi->ref_idx, amvr_shift, &mi->mv[L0][0]); | |
1606 |
2/2✓ Branch 0 taken 22038 times.
✓ Branch 1 taken 26645 times.
|
48683 | if (mi->pred_flag != PF_L0) |
1607 | 22038 | mvp(lc, mvp_lx_flag[L1], L1, mi->ref_idx, amvr_shift, &mi->mv[L1][0]); | |
1608 | 48683 | } | |
1609 | |||
1610 | 1582 | static int ibc_spatial_candidates(const VVCLocalContext *lc, const int merge_idx, Mv *const cand_list, int *nb_merge_cand) | |
1611 | { | ||
1612 | 1582 | const CodingUnit *cu = lc->cu; | |
1613 | 1582 | const VVCFrameContext *fc = lc->fc; | |
1614 | 1582 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
1615 | 1582 | const MvField *tab_mvf = fc->tab.mvf; | |
1616 | 1582 | const int is_gt4by4 = (cu->cb_width * cu->cb_height) > 16; | |
1617 | 1582 | int num_cands = 0; | |
1618 | |||
1619 | NeighbourContext nctx; | ||
1620 | 1582 | Neighbour *a1 = &nctx.neighbours[A1]; | |
1621 | 1582 | Neighbour *b1 = &nctx.neighbours[B1]; | |
1622 | |||
1623 |
2/2✓ Branch 0 taken 202 times.
✓ Branch 1 taken 1380 times.
|
1582 | if (!is_gt4by4) { |
1624 | 202 | *nb_merge_cand = 0; | |
1625 | 202 | return 0; | |
1626 | } | ||
1627 | |||
1628 | 1380 | init_neighbour_context(&nctx, lc); | |
1629 | |||
1630 |
2/2✓ Branch 1 taken 1070 times.
✓ Branch 2 taken 310 times.
|
1380 | if (check_available(a1, lc, 1)) { |
1631 | 1070 | cand_list[num_cands++] = TAB_MVF(a1->x, a1->y).mv[L0]; | |
1632 |
1/2✓ Branch 0 taken 1070 times.
✗ Branch 1 not taken.
|
1070 | if (num_cands > merge_idx) |
1633 | 1070 | return 1; | |
1634 | } | ||
1635 |
2/2✓ Branch 1 taken 179 times.
✓ Branch 2 taken 131 times.
|
310 | if (check_available(b1, lc, 1)) { |
1636 | 179 | const MvField *mvf = &TAB_MVF(b1->x, b1->y); | |
1637 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 179 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
179 | if (!num_cands || !IS_SAME_MV(&cand_list[0], mvf->mv)) { |
1638 | 179 | cand_list[num_cands++] = mvf->mv[L0]; | |
1639 |
1/2✓ Branch 0 taken 179 times.
✗ Branch 1 not taken.
|
179 | if (num_cands > merge_idx) |
1640 | 179 | return 1; | |
1641 | } | ||
1642 | } | ||
1643 | |||
1644 | 131 | *nb_merge_cand = num_cands; | |
1645 | 131 | return 0; | |
1646 | } | ||
1647 | |||
1648 | 333 | static int ibc_history_candidates(const VVCLocalContext *lc, | |
1649 | const int merge_idx, Mv *cand_list, int *nb_merge_cand) | ||
1650 | { | ||
1651 | 333 | const CodingUnit *cu = lc->cu; | |
1652 | 333 | const EntryPoint *ep = lc->ep; | |
1653 | 333 | const int is_gt4by4 = (cu->cb_width * cu->cb_height) > 16; | |
1654 | 333 | int num_cands = *nb_merge_cand; | |
1655 | |||
1656 |
2/2✓ Branch 0 taken 319 times.
✓ Branch 1 taken 14 times.
|
333 | for (int i = 1; i <= ep->num_hmvp_ibc; i++) { |
1657 | 319 | int same_motion = 0; | |
1658 | 319 | const MvField *mvf = &ep->hmvp_ibc[ep->num_hmvp_ibc - i]; | |
1659 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 319 times.
|
319 | for (int j = 0; j < *nb_merge_cand; j++) { |
1660 | ✗ | same_motion = is_gt4by4 && i == 1 && IS_SAME_MV(&mvf->mv[L0], &cand_list[j]); | |
1661 | ✗ | if (same_motion) | |
1662 | ✗ | break; | |
1663 | } | ||
1664 |
1/2✓ Branch 0 taken 319 times.
✗ Branch 1 not taken.
|
319 | if (!same_motion) { |
1665 | 319 | cand_list[num_cands++] = mvf->mv[L0]; | |
1666 |
1/2✓ Branch 0 taken 319 times.
✗ Branch 1 not taken.
|
319 | if (num_cands > merge_idx) |
1667 | 319 | return 1; | |
1668 | } | ||
1669 | } | ||
1670 | |||
1671 | 14 | *nb_merge_cand = num_cands; | |
1672 | 14 | return 0; | |
1673 | } | ||
1674 | |||
1675 | #define MV_BITS 18 | ||
1676 | #define IBC_SHIFT(v) ((v) >= (1 << (MV_BITS - 1)) ? ((v) - (1 << MV_BITS)) : (v)) | ||
1677 | |||
1678 | 1342 | static inline void ibc_add_mvp(Mv *mv, Mv *mvp, const int amvr_shift) | |
1679 | { | ||
1680 | 1342 | ff_vvc_round_mv(mv, amvr_shift, 0); | |
1681 | 1342 | ff_vvc_round_mv(mvp, amvr_shift, amvr_shift); | |
1682 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1342 times.
|
1342 | mv->x = IBC_SHIFT(mv->x + mvp->x); |
1683 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1342 times.
|
1342 | mv->y = IBC_SHIFT(mv->y + mvp->y); |
1684 | 1342 | } | |
1685 | |||
1686 | 1582 | static void ibc_merge_candidates(VVCLocalContext *lc, const int merge_idx, Mv *mv) | |
1687 | { | ||
1688 | 1582 | const CodingUnit *cu = lc->cu; | |
1689 | 1582 | LOCAL_ALIGNED_8(Mv, cand_list, [MRG_MAX_NUM_CANDS]); | |
1690 | int nb_cands; | ||
1691 | |||
1692 | 1582 | ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height); | |
1693 |
4/4✓ Branch 1 taken 333 times.
✓ Branch 2 taken 1249 times.
✓ Branch 3 taken 319 times.
✓ Branch 4 taken 14 times.
|
1915 | if (ibc_spatial_candidates(lc, merge_idx, cand_list, &nb_cands) || |
1694 | 333 | ibc_history_candidates(lc, merge_idx, cand_list, &nb_cands)) { | |
1695 | 1568 | *mv = cand_list[merge_idx]; | |
1696 | 1568 | return; | |
1697 | } | ||
1698 | |||
1699 | //zero mv | ||
1700 | 14 | memset(mv, 0, sizeof(*mv)); | |
1701 | } | ||
1702 | |||
1703 | 1582 | static int ibc_check_mv(VVCLocalContext *lc, Mv *mv) | |
1704 | { | ||
1705 | 1582 | const VVCFrameContext *fc = lc->fc; | |
1706 | 1582 | const VVCSPS *sps = lc->fc->ps.sps; | |
1707 | 1582 | const CodingUnit *cu = lc->cu; | |
1708 | 1582 | const Mv *bv = &cu->pu.mi.mv[L0][0]; | |
1709 | |||
1710 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1582 times.
|
1582 | if (sps->ctb_size_y < ((cu->y0 + (bv->y >> 4)) & (sps->ctb_size_y - 1)) + cu->cb_height) { |
1711 | ✗ | av_log(fc->log_ctx, AV_LOG_ERROR, "IBC region spans multiple CTBs.\n"); | |
1712 | ✗ | return AVERROR_INVALIDDATA; | |
1713 | } | ||
1714 | |||
1715 | 1582 | return 0; | |
1716 | } | ||
1717 | |||
1718 | 1342 | int ff_vvc_mvp_ibc(VVCLocalContext *lc, const int mvp_l0_flag, const int amvr_shift, Mv *mv) | |
1719 | { | ||
1720 | 1342 | LOCAL_ALIGNED_8(Mv, mvp, [1]); | |
1721 | |||
1722 | 1342 | ibc_merge_candidates(lc, mvp_l0_flag, mvp); | |
1723 | 1342 | ibc_add_mvp(mv, mvp, amvr_shift); | |
1724 | 1342 | return ibc_check_mv(lc, mv); | |
1725 | } | ||
1726 | |||
1727 | 240 | int ff_vvc_luma_mv_merge_ibc(VVCLocalContext *lc, const int merge_idx, Mv *mv) | |
1728 | { | ||
1729 | 240 | ibc_merge_candidates(lc, merge_idx, mv); | |
1730 | 240 | return ibc_check_mv(lc, mv); | |
1731 | } | ||
1732 | |||
1733 | 21471 | static int affine_mvp_constructed_cp(NeighbourContext *ctx, | |
1734 | const NeighbourIdx *neighbour, const int num_neighbour, | ||
1735 | const int lx, const int8_t ref_idx, const int amvr_shift, Mv *cp) | ||
1736 | { | ||
1737 | 21471 | const VVCLocalContext *lc = ctx->lc; | |
1738 | 21471 | const VVCFrameContext *fc = lc->fc; | |
1739 | 21471 | const MvField *tab_mvf = fc->tab.mvf; | |
1740 | 21471 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
1741 | 21471 | const RefPicList* rpl = lc->sc->rpl; | |
1742 | 21471 | int available = 0; | |
1743 | |||
1744 |
2/2✓ Branch 0 taken 32173 times.
✓ Branch 1 taken 6277 times.
|
38450 | for (int i = 0; i < num_neighbour; i++) { |
1745 | 32173 | Neighbour *n = &ctx->neighbours[neighbour[i]]; | |
1746 |
2/2✓ Branch 1 taken 21561 times.
✓ Branch 2 taken 10612 times.
|
32173 | if (check_available(n, ctx->lc, 0)) { |
1747 | 21561 | const PredFlag maskx = lx + 1; | |
1748 | 21561 | const MvField* mvf = &TAB_MVF(n->x, n->y); | |
1749 | 21561 | const int poc = rpl[lx].refs[ref_idx].poc; | |
1750 |
4/4✓ Branch 0 taken 17756 times.
✓ Branch 1 taken 3805 times.
✓ Branch 2 taken 13586 times.
✓ Branch 3 taken 4170 times.
|
21561 | if ((mvf->pred_flag & maskx) && rpl[lx].refs[mvf->ref_idx[lx]].poc == poc) { |
1751 | 13586 | available = 1; | |
1752 | 13586 | *cp = mvf->mv[lx]; | |
1753 | } else { | ||
1754 | 7975 | const int ly = !lx; | |
1755 | 7975 | const PredFlag masky = ly + 1; | |
1756 |
4/4✓ Branch 0 taken 5471 times.
✓ Branch 1 taken 2504 times.
✓ Branch 2 taken 1608 times.
✓ Branch 3 taken 3863 times.
|
7975 | if ((mvf->pred_flag & masky) && rpl[ly].refs[mvf->ref_idx[ly]].poc == poc) { |
1757 | 1608 | available = 1; | |
1758 | 1608 | *cp = mvf->mv[ly]; | |
1759 | } | ||
1760 | } | ||
1761 |
2/2✓ Branch 0 taken 15194 times.
✓ Branch 1 taken 6367 times.
|
21561 | if (available) { |
1762 | 15194 | ff_vvc_round_mv(cp, amvr_shift, amvr_shift); | |
1763 | 15194 | return 1; | |
1764 | } | ||
1765 | } | ||
1766 | } | ||
1767 | 6277 | return 0; | |
1768 | } | ||
1769 | |||
1770 | #define AFFINE_MVP_CONSTRUCTED_CP(cands, cp) \ | ||
1771 | affine_mvp_constructed_cp(nctx, cands, FF_ARRAY_ELEMS(cands), lx, ref_idx, \ | ||
1772 | amvr_shift, cp) | ||
1773 | |||
1774 | //8.5.5.8 Derivation process for constructed affine control point motion vector prediction candidates | ||
1775 | 7157 | static int affine_mvp_const1(NeighbourContext* nctx, | |
1776 | const int lx, const int8_t ref_idx, const int amvr_shift, | ||
1777 | Mv *cps, int *available) | ||
1778 | { | ||
1779 | 7157 | const NeighbourIdx tl[] = { B2, B3, A2 }; | |
1780 | 7157 | const NeighbourIdx tr[] = { B1, B0 }; | |
1781 | 7157 | const NeighbourIdx bl[] = { A1, A0 }; | |
1782 | |||
1783 | 7157 | available[0] = AFFINE_MVP_CONSTRUCTED_CP(tl, cps + 0); | |
1784 | 7157 | available[1] = AFFINE_MVP_CONSTRUCTED_CP(tr, cps + 1); | |
1785 | 7157 | available[2] = AFFINE_MVP_CONSTRUCTED_CP(bl, cps + 2); | |
1786 |
4/4✓ Branch 0 taken 5844 times.
✓ Branch 1 taken 1313 times.
✓ Branch 2 taken 4527 times.
✓ Branch 3 taken 1317 times.
|
7157 | return available[0] && available[1]; |
1787 | } | ||
1788 | |||
1789 | //8.5.5.7 item 7 | ||
1790 | 3314 | static void affine_mvp_const2(const int idx, Mv *cps, const int num_cp) | |
1791 | { | ||
1792 | 3314 | const Mv mv = cps[idx]; | |
1793 |
2/2✓ Branch 0 taken 8350 times.
✓ Branch 1 taken 3314 times.
|
11664 | for (int j = 0; j < num_cp; j++) |
1794 | 8350 | cps[j] = mv; | |
1795 | 3314 | } | |
1796 | |||
1797 | //8.5.5.7 Derivation process for luma affine control point motion vector predictors | ||
1798 | 11149 | static void affine_mvp(const VVCLocalContext *lc, | |
1799 | const int mvp_lx_flag, const int lx, const int8_t *ref_idx, const int amvr_shift, | ||
1800 | MotionModelIdc motion_model_idc, Mv *cps) | ||
1801 | { | ||
1802 | 11149 | const NeighbourIdx ak[] = { A0, A1 }; | |
1803 | 11149 | const NeighbourIdx bk[] = { B0, B1, B2 }; | |
1804 | 11149 | const int num_cp = motion_model_idc + 1; | |
1805 | NeighbourContext nctx; | ||
1806 | int available[MAX_CONTROL_POINTS]; | ||
1807 | 11149 | int num_cands = 0; | |
1808 | |||
1809 | 11149 | init_neighbour_context(&nctx, lc); | |
1810 | //Ak | ||
1811 |
2/2✓ Branch 1 taken 2879 times.
✓ Branch 2 taken 8270 times.
|
11149 | if (AFFINE_MVP_FROM_NBS(ak)) { |
1812 |
2/2✓ Branch 0 taken 1934 times.
✓ Branch 1 taken 945 times.
|
2879 | if (mvp_lx_flag == num_cands) |
1813 | 10820 | return; | |
1814 | 945 | num_cands++; | |
1815 | } | ||
1816 | //Bk | ||
1817 |
2/2✓ Branch 1 taken 2816 times.
✓ Branch 2 taken 6399 times.
|
9215 | if (AFFINE_MVP_FROM_NBS(bk)) { |
1818 |
2/2✓ Branch 0 taken 2058 times.
✓ Branch 1 taken 758 times.
|
2816 | if (mvp_lx_flag == num_cands) |
1819 | 2058 | return; | |
1820 | 758 | num_cands++; | |
1821 | } | ||
1822 | |||
1823 | //Const1 | ||
1824 |
2/2✓ Branch 1 taken 4527 times.
✓ Branch 2 taken 2630 times.
|
7157 | if (affine_mvp_const1(&nctx, lx, ref_idx[lx], amvr_shift, cps, available)) { |
1825 |
4/4✓ Branch 0 taken 1151 times.
✓ Branch 1 taken 3376 times.
✓ Branch 2 taken 604 times.
✓ Branch 3 taken 547 times.
|
4527 | if (available[2] || motion_model_idc == MOTION_4_PARAMS_AFFINE) { |
1826 |
2/2✓ Branch 0 taken 2773 times.
✓ Branch 1 taken 1207 times.
|
3980 | if (mvp_lx_flag == num_cands) |
1827 | 2773 | return; | |
1828 | 1207 | num_cands++; | |
1829 | } | ||
1830 | } | ||
1831 | |||
1832 | //Const2 | ||
1833 |
2/2✓ Branch 0 taken 8314 times.
✓ Branch 1 taken 1070 times.
|
9384 | for (int i = 2; i >= 0; i--) { |
1834 |
2/2✓ Branch 0 taken 3764 times.
✓ Branch 1 taken 4550 times.
|
8314 | if (available[i]) { |
1835 |
2/2✓ Branch 0 taken 3314 times.
✓ Branch 1 taken 450 times.
|
3764 | if (mvp_lx_flag == num_cands) { |
1836 | 3314 | affine_mvp_const2(i, cps, num_cp); | |
1837 | 3314 | return; | |
1838 | } | ||
1839 | 450 | num_cands++; | |
1840 | } | ||
1841 | } | ||
1842 |
2/2✓ Branch 1 taken 848 times.
✓ Branch 2 taken 222 times.
|
1070 | if (temporal_luma_motion_vector(lc, ref_idx[lx], cps, lx, 1, 0)) { |
1843 |
2/2✓ Branch 0 taken 741 times.
✓ Branch 1 taken 107 times.
|
848 | if (mvp_lx_flag == num_cands) { |
1844 | 741 | ff_vvc_round_mv(cps, amvr_shift, amvr_shift); | |
1845 |
2/2✓ Branch 0 taken 1022 times.
✓ Branch 1 taken 741 times.
|
1763 | for (int i = 1; i < num_cp; i++) |
1846 | 1022 | cps[i] = cps[0]; | |
1847 | 741 | return; | |
1848 | } | ||
1849 | 107 | num_cands++; | |
1850 | } | ||
1851 | |||
1852 | //Zero Mv | ||
1853 | 329 | memset(cps, 0, num_cp * sizeof(Mv)); | |
1854 | } | ||
1855 | |||
1856 | 9102 | void ff_vvc_affine_mvp(VVCLocalContext *lc, const int *mvp_lx_flag, const int amvr_shift, MotionInfo *mi) | |
1857 | { | ||
1858 | 9102 | const CodingUnit *cu = lc->cu; | |
1859 | |||
1860 | 9102 | mi->num_sb_x = cu->cb_width >> MIN_PU_LOG2; | |
1861 | 9102 | mi->num_sb_y = cu->cb_height >> MIN_PU_LOG2; | |
1862 | |||
1863 | 9102 | ff_vvc_set_neighbour_available(lc, cu->x0, cu->y0, cu->cb_width, cu->cb_height); | |
1864 |
2/2✓ Branch 0 taken 8132 times.
✓ Branch 1 taken 970 times.
|
9102 | if (mi->pred_flag != PF_L1) |
1865 | 8132 | affine_mvp(lc, mvp_lx_flag[L0], L0, mi->ref_idx, amvr_shift, mi->motion_model_idc, &mi->mv[L0][0]); | |
1866 |
2/2✓ Branch 0 taken 3017 times.
✓ Branch 1 taken 6085 times.
|
9102 | if (mi->pred_flag != PF_L0) |
1867 | 3017 | affine_mvp(lc, mvp_lx_flag[L1], L1, mi->ref_idx, amvr_shift, mi->motion_model_idc, &mi->mv[L1][0]); | |
1868 | 9102 | } | |
1869 | |||
1870 | //8.5.2.14 Rounding process for motion vectors | ||
1871 | 7157092 | void ff_vvc_round_mv(Mv *mv, const int lshift, const int rshift) | |
1872 | { | ||
1873 |
2/2✓ Branch 0 taken 7154534 times.
✓ Branch 1 taken 2558 times.
|
7157092 | if (rshift) { |
1874 | 7154534 | const int offset = 1 << (rshift - 1); | |
1875 | 7154534 | mv->x = ((mv->x + offset - (mv->x >= 0)) >> rshift) * (1 << lshift); | |
1876 | 7154534 | mv->y = ((mv->y + offset - (mv->y >= 0)) >> rshift) * (1 << lshift); | |
1877 | } else { | ||
1878 | 2558 | mv->x = mv->x * (1 << lshift); | |
1879 | 2558 | mv->y = mv->y * (1 << lshift); | |
1880 | } | ||
1881 | 7157092 | } | |
1882 | |||
1883 | 5019378 | void ff_vvc_clip_mv(Mv *mv) | |
1884 | { | ||
1885 | 5019378 | mv->x = av_clip(mv->x, -(1 << 17), (1 << 17) - 1); | |
1886 | 5019378 | mv->y = av_clip(mv->y, -(1 << 17), (1 << 17) - 1); | |
1887 | 5019378 | } | |
1888 | |||
1889 | //8.5.2.1 Derivation process for motion vector components and reference indices | ||
1890 | 314358 | static av_always_inline int is_greater_mer(const VVCFrameContext *fc, const int x0, const int y0, const int x0_br, const int y0_br) | |
1891 | { | ||
1892 | 314358 | const uint8_t plevel = fc->ps.sps->log2_parallel_merge_level; | |
1893 | |||
1894 |
1/2✓ Branch 0 taken 314358 times.
✗ Branch 1 not taken.
|
628716 | return x0_br >> plevel > x0 >> plevel && |
1895 |
1/2✓ Branch 0 taken 314358 times.
✗ Branch 1 not taken.
|
314358 | y0_br >> plevel > y0 >> plevel; |
1896 | } | ||
1897 | |||
1898 | 315738 | static void update_hmvp(MvField *hmvp, int *num_hmvp, const MvField *mvf, | |
1899 | int (*compare)(const MvField *n, const MvField *o)) | ||
1900 | { | ||
1901 | int i; | ||
1902 |
2/2✓ Branch 0 taken 1342123 times.
✓ Branch 1 taken 171314 times.
|
1513437 | for (i = 0; i < *num_hmvp; i++) { |
1903 |
2/2✓ Branch 1 taken 144424 times.
✓ Branch 2 taken 1197699 times.
|
1342123 | if (compare(mvf, hmvp + i)) { |
1904 | 144424 | (*num_hmvp)--; | |
1905 | 144424 | break; | |
1906 | } | ||
1907 | } | ||
1908 |
2/2✓ Branch 0 taken 153346 times.
✓ Branch 1 taken 162392 times.
|
315738 | if (i == MAX_NUM_HMVP_CANDS) { |
1909 | 153346 | (*num_hmvp)--; | |
1910 | 153346 | i = 0; | |
1911 | } | ||
1912 | |||
1913 | 315738 | memmove(hmvp + i, hmvp + i + 1, (*num_hmvp - i) * sizeof(MvField)); | |
1914 | 315738 | hmvp[(*num_hmvp)++] = *mvf; | |
1915 | 315738 | } | |
1916 | |||
1917 | 6255 | static int compare_l0_mv(const MvField *n, const MvField *o) | |
1918 | { | ||
1919 | 6255 | return IS_SAME_MV(&n->mv[L0], &o->mv[L0]); | |
1920 | } | ||
1921 | |||
1922 | //8.6.2.4 Derivation process for IBC history-based block vector candidates | ||
1923 | //8.5.2.16 Updating process for the history-based motion vector predictor candidate list | ||
1924 | 315940 | void ff_vvc_update_hmvp(VVCLocalContext *lc, const MotionInfo *mi) | |
1925 | { | ||
1926 | 315940 | const VVCFrameContext *fc = lc->fc; | |
1927 | 315940 | const CodingUnit *cu = lc->cu; | |
1928 | 315940 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
1929 | 315940 | const MvField *tab_mvf = fc->tab.mvf; | |
1930 | 315940 | EntryPoint *ep = lc->ep; | |
1931 | |||
1932 |
2/2✓ Branch 0 taken 1582 times.
✓ Branch 1 taken 314358 times.
|
315940 | if (cu->pred_mode == MODE_IBC) { |
1933 |
2/2✓ Branch 0 taken 202 times.
✓ Branch 1 taken 1380 times.
|
1582 | if (cu->cb_width * cu->cb_height <= 16) |
1934 | 202 | return; | |
1935 | 1380 | update_hmvp(ep->hmvp_ibc, &ep->num_hmvp_ibc, &TAB_MVF(cu->x0, cu->y0), compare_l0_mv); | |
1936 | } else { | ||
1937 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 314358 times.
|
314358 | if (!is_greater_mer(fc, cu->x0, cu->y0, cu->x0 + cu->cb_width, cu->y0 + cu->cb_height)) |
1938 | ✗ | return; | |
1939 | 314358 | update_hmvp(ep->hmvp, &ep->num_hmvp, &TAB_MVF(cu->x0, cu->y0), compare_mv_ref_idx); | |
1940 | } | ||
1941 | } | ||
1942 | |||
1943 | 11731276 | MvField* ff_vvc_get_mvf(const VVCFrameContext *fc, const int x0, const int y0) | |
1944 | { | ||
1945 | 11731276 | const int min_pu_width = fc->ps.pps->min_pu_width; | |
1946 | 11731276 | MvField* tab_mvf = fc->tab.mvf; | |
1947 | |||
1948 | 11731276 | return &TAB_MVF(x0, y0); | |
1949 | } | ||
1950 |