/src/aom/av1/common/mvref_common.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright (c) 2016, Alliance for Open Media. All rights reserved. |
3 | | * |
4 | | * This source code is subject to the terms of the BSD 2 Clause License and |
5 | | * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
6 | | * was not distributed with this source code in the LICENSE file, you can |
7 | | * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
8 | | * Media Patent License 1.0 was not distributed with this source code in the |
9 | | * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
10 | | */ |
11 | | |
12 | | #include <stdlib.h> |
13 | | |
14 | | #include "av1/common/mvref_common.h" |
15 | | #include "av1/common/warped_motion.h" |
16 | | |
17 | | // Although we assign 32 bit integers, all the values are strictly under 14 |
18 | | // bits. |
19 | | static const int div_mult[32] = { 0, 16384, 8192, 5461, 4096, 3276, 2730, |
20 | | 2340, 2048, 1820, 1638, 1489, 1365, 1260, |
21 | | 1170, 1092, 1024, 963, 910, 862, 819, |
22 | | 780, 744, 712, 682, 655, 630, 606, |
23 | | 585, 564, 546, 528 }; |
24 | | |
25 | | // TODO(jingning): Consider the use of lookup table for (num / den) |
26 | | // altogether. |
27 | 18.4M | void av1_get_mv_projection(MV *output, MV ref, int num, int den) { |
28 | 18.4M | den = AOMMIN(den, MAX_FRAME_DISTANCE); |
29 | 18.4M | num = num > 0 ? AOMMIN(num, MAX_FRAME_DISTANCE) |
30 | 18.4M | : AOMMAX(num, -MAX_FRAME_DISTANCE); |
31 | 18.4M | const int mv_row = |
32 | 18.4M | ROUND_POWER_OF_TWO_SIGNED(ref.row * num * div_mult[den], 14); |
33 | 18.4M | const int mv_col = |
34 | 18.4M | ROUND_POWER_OF_TWO_SIGNED(ref.col * num * div_mult[den], 14); |
35 | 18.4M | const int clamp_max = MV_UPP - 1; |
36 | 18.4M | const int clamp_min = MV_LOW + 1; |
37 | 18.4M | output->row = (int16_t)clamp(mv_row, clamp_min, clamp_max); |
38 | 18.4M | output->col = (int16_t)clamp(mv_col, clamp_min, clamp_max); |
39 | 18.4M | } |
40 | | |
41 | | void av1_copy_frame_mvs(const AV1_COMMON *const cm, |
42 | | const MB_MODE_INFO *const mi, int mi_row, int mi_col, |
43 | 6.25M | int x_mis, int y_mis) { |
44 | 6.25M | const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, 1); |
45 | 6.25M | MV_REF *frame_mvs = |
46 | 6.25M | cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1); |
47 | 6.25M | x_mis = ROUND_POWER_OF_TWO(x_mis, 1); |
48 | 6.25M | y_mis = ROUND_POWER_OF_TWO(y_mis, 1); |
49 | 6.25M | int w, h; |
50 | | |
51 | 19.3M | for (h = 0; h < y_mis; h++) { |
52 | 13.0M | MV_REF *mv = frame_mvs; |
53 | 72.0M | for (w = 0; w < x_mis; w++) { |
54 | 58.9M | mv->ref_frame = NONE_FRAME; |
55 | 58.9M | mv->mv.as_int = 0; |
56 | | |
57 | 176M | for (int idx = 0; idx < 2; ++idx) { |
58 | 117M | MV_REFERENCE_FRAME ref_frame = mi->ref_frame[idx]; |
59 | 117M | if (ref_frame > INTRA_FRAME) { |
60 | 75.2M | int8_t ref_idx = cm->ref_frame_side[ref_frame]; |
61 | 75.2M | if (ref_idx) continue; |
62 | 62.0M | if ((abs(mi->mv[idx].as_mv.row) > REFMVS_LIMIT) || |
63 | 62.0M | (abs(mi->mv[idx].as_mv.col) > REFMVS_LIMIT)) |
64 | 2.51M | continue; |
65 | 59.4M | mv->ref_frame = ref_frame; |
66 | 59.4M | mv->mv.as_int = mi->mv[idx].as_int; |
67 | 59.4M | } |
68 | 117M | } |
69 | 58.9M | mv++; |
70 | 58.9M | } |
71 | 13.0M | frame_mvs += frame_mvs_stride; |
72 | 13.0M | } |
73 | 6.25M | } |
74 | | |
75 | | static inline void add_ref_mv_candidate( |
76 | | const MB_MODE_INFO *const candidate, const MV_REFERENCE_FRAME rf[2], |
77 | | uint8_t *refmv_count, uint8_t *ref_match_count, uint8_t *newmv_count, |
78 | | CANDIDATE_MV *ref_mv_stack, uint16_t *ref_mv_weight, |
79 | | int_mv *gm_mv_candidates, const WarpedMotionParams *gm_params, |
80 | 29.7M | uint16_t weight) { |
81 | 29.7M | if (!is_inter_block(candidate)) return; |
82 | 25.9M | assert(weight % 2 == 0); |
83 | 25.9M | int index, ref; |
84 | | |
85 | 25.9M | if (rf[1] == NONE_FRAME) { |
86 | | // single reference frame |
87 | 68.2M | for (ref = 0; ref < 2; ++ref) { |
88 | 45.5M | if (candidate->ref_frame[ref] == rf[0]) { |
89 | 19.5M | const int is_gm_block = |
90 | 19.5M | is_global_mv_block(candidate, gm_params[rf[0]].wmtype); |
91 | 19.5M | const int_mv this_refmv = |
92 | 19.5M | is_gm_block ? gm_mv_candidates[0] : get_block_mv(candidate, ref); |
93 | 36.8M | for (index = 0; index < *refmv_count; ++index) { |
94 | 27.0M | if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) { |
95 | 9.74M | ref_mv_weight[index] += weight; |
96 | 9.74M | break; |
97 | 9.74M | } |
98 | 27.0M | } |
99 | | |
100 | | // Add a new item to the list. |
101 | 19.5M | if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { |
102 | 9.75M | ref_mv_stack[index].this_mv = this_refmv; |
103 | 9.75M | ref_mv_weight[index] = weight; |
104 | 9.75M | ++(*refmv_count); |
105 | 9.75M | } |
106 | 19.5M | if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; |
107 | 19.5M | ++*ref_match_count; |
108 | 19.5M | } |
109 | 45.5M | } |
110 | 22.7M | } else { |
111 | | // compound reference frame |
112 | 3.18M | if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) { |
113 | 1.28M | int_mv this_refmv[2]; |
114 | | |
115 | 3.85M | for (ref = 0; ref < 2; ++ref) { |
116 | 2.57M | if (is_global_mv_block(candidate, gm_params[rf[ref]].wmtype)) |
117 | 54.8k | this_refmv[ref] = gm_mv_candidates[ref]; |
118 | 2.51M | else |
119 | 2.51M | this_refmv[ref] = get_block_mv(candidate, ref); |
120 | 2.57M | } |
121 | | |
122 | 1.96M | for (index = 0; index < *refmv_count; ++index) { |
123 | 1.20M | if ((ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int) && |
124 | 1.20M | (ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int)) { |
125 | 529k | ref_mv_weight[index] += weight; |
126 | 529k | break; |
127 | 529k | } |
128 | 1.20M | } |
129 | | |
130 | | // Add a new item to the list. |
131 | 1.28M | if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { |
132 | 756k | ref_mv_stack[index].this_mv = this_refmv[0]; |
133 | 756k | ref_mv_stack[index].comp_mv = this_refmv[1]; |
134 | 756k | ref_mv_weight[index] = weight; |
135 | 756k | ++(*refmv_count); |
136 | 756k | } |
137 | 1.28M | if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; |
138 | 1.28M | ++*ref_match_count; |
139 | 1.28M | } |
140 | 3.18M | } |
141 | 25.9M | } |
142 | | |
143 | | static inline void scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
144 | | int mi_col, const MV_REFERENCE_FRAME rf[2], |
145 | | int row_offset, CANDIDATE_MV *ref_mv_stack, |
146 | | uint16_t *ref_mv_weight, uint8_t *refmv_count, |
147 | | uint8_t *ref_match_count, uint8_t *newmv_count, |
148 | | int_mv *gm_mv_candidates, int max_row_offset, |
149 | 9.84M | int *processed_rows) { |
150 | 9.84M | int end_mi = AOMMIN(xd->width, cm->mi_params.mi_cols - mi_col); |
151 | 9.84M | end_mi = AOMMIN(end_mi, mi_size_wide[BLOCK_64X64]); |
152 | 9.84M | const int width_8x8 = mi_size_wide[BLOCK_8X8]; |
153 | 9.84M | const int width_16x16 = mi_size_wide[BLOCK_16X16]; |
154 | 9.84M | int col_offset = 0; |
155 | | // TODO(jingning): Revisit this part after cb4x4 is stable. |
156 | 9.84M | if (abs(row_offset) > 1) { |
157 | 5.45M | col_offset = 1; |
158 | 5.45M | if ((mi_col & 0x01) && xd->width < width_8x8) --col_offset; |
159 | 5.45M | } |
160 | 9.84M | const int use_step_16 = (xd->width >= 16); |
161 | 9.84M | MB_MODE_INFO **const candidate_mi0 = xd->mi + row_offset * xd->mi_stride; |
162 | | |
163 | 21.3M | for (int i = 0; i < end_mi;) { |
164 | 11.4M | const MB_MODE_INFO *const candidate = candidate_mi0[col_offset + i]; |
165 | 11.4M | const int candidate_bsize = candidate->bsize; |
166 | 11.4M | const int n4_w = mi_size_wide[candidate_bsize]; |
167 | 11.4M | int len = AOMMIN(xd->width, n4_w); |
168 | 11.4M | if (use_step_16) |
169 | 437k | len = AOMMAX(width_16x16, len); |
170 | 11.0M | else if (abs(row_offset) > 1) |
171 | 6.23M | len = AOMMAX(len, width_8x8); |
172 | | |
173 | 11.4M | uint16_t weight = 2; |
174 | 11.4M | if (xd->width >= width_8x8 && xd->width <= n4_w) { |
175 | 6.16M | uint16_t inc = AOMMIN(-max_row_offset + row_offset + 1, |
176 | 6.16M | mi_size_high[candidate_bsize]); |
177 | | // Obtain range used in weight calculation. |
178 | 6.16M | weight = AOMMAX(weight, inc); |
179 | | // Update processed rows. |
180 | 6.16M | *processed_rows = inc - row_offset - 1; |
181 | 6.16M | } |
182 | | |
183 | 11.4M | add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, |
184 | 11.4M | newmv_count, ref_mv_stack, ref_mv_weight, |
185 | 11.4M | gm_mv_candidates, cm->global_motion, len * weight); |
186 | | |
187 | 11.4M | i += len; |
188 | 11.4M | } |
189 | 9.84M | } |
190 | | |
191 | | static inline void scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
192 | | int mi_row, const MV_REFERENCE_FRAME rf[2], |
193 | | int col_offset, CANDIDATE_MV *ref_mv_stack, |
194 | | uint16_t *ref_mv_weight, uint8_t *refmv_count, |
195 | | uint8_t *ref_match_count, uint8_t *newmv_count, |
196 | | int_mv *gm_mv_candidates, int max_col_offset, |
197 | 9.91M | int *processed_cols) { |
198 | 9.91M | int end_mi = AOMMIN(xd->height, cm->mi_params.mi_rows - mi_row); |
199 | 9.91M | end_mi = AOMMIN(end_mi, mi_size_high[BLOCK_64X64]); |
200 | 9.91M | const int n8_h_8 = mi_size_high[BLOCK_8X8]; |
201 | 9.91M | const int n8_h_16 = mi_size_high[BLOCK_16X16]; |
202 | 9.91M | int i; |
203 | 9.91M | int row_offset = 0; |
204 | 9.91M | if (abs(col_offset) > 1) { |
205 | 5.43M | row_offset = 1; |
206 | 5.43M | if ((mi_row & 0x01) && xd->height < n8_h_8) --row_offset; |
207 | 5.43M | } |
208 | 9.91M | const int use_step_16 = (xd->height >= 16); |
209 | | |
210 | 21.5M | for (i = 0; i < end_mi;) { |
211 | 11.6M | const MB_MODE_INFO *const candidate = |
212 | 11.6M | xd->mi[(row_offset + i) * xd->mi_stride + col_offset]; |
213 | 11.6M | const int candidate_bsize = candidate->bsize; |
214 | 11.6M | const int n4_h = mi_size_high[candidate_bsize]; |
215 | 11.6M | int len = AOMMIN(xd->height, n4_h); |
216 | 11.6M | if (use_step_16) |
217 | 472k | len = AOMMAX(n8_h_16, len); |
218 | 11.1M | else if (abs(col_offset) > 1) |
219 | 6.22M | len = AOMMAX(len, n8_h_8); |
220 | | |
221 | 11.6M | int weight = 2; |
222 | 11.6M | if (xd->height >= n8_h_8 && xd->height <= n4_h) { |
223 | 5.67M | int inc = AOMMIN(-max_col_offset + col_offset + 1, |
224 | 5.67M | mi_size_wide[candidate_bsize]); |
225 | | // Obtain range used in weight calculation. |
226 | 5.67M | weight = AOMMAX(weight, inc); |
227 | | // Update processed cols. |
228 | 5.67M | *processed_cols = inc - col_offset - 1; |
229 | 5.67M | } |
230 | | |
231 | 11.6M | add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, |
232 | 11.6M | newmv_count, ref_mv_stack, ref_mv_weight, |
233 | 11.6M | gm_mv_candidates, cm->global_motion, len * weight); |
234 | | |
235 | 11.6M | i += len; |
236 | 11.6M | } |
237 | 9.91M | } |
238 | | |
239 | | static inline void scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
240 | | const int mi_row, const int mi_col, |
241 | | const MV_REFERENCE_FRAME rf[2], int row_offset, |
242 | | int col_offset, CANDIDATE_MV *ref_mv_stack, |
243 | | uint16_t *ref_mv_weight, |
244 | | uint8_t *ref_match_count, uint8_t *newmv_count, |
245 | | int_mv *gm_mv_candidates, |
246 | 7.19M | uint8_t *refmv_count) { |
247 | 7.19M | const TileInfo *const tile = &xd->tile; |
248 | 7.19M | POSITION mi_pos; |
249 | | |
250 | 7.19M | mi_pos.row = row_offset; |
251 | 7.19M | mi_pos.col = col_offset; |
252 | | |
253 | 7.19M | if (is_inside(tile, mi_col, mi_row, &mi_pos)) { |
254 | 6.71M | const MB_MODE_INFO *const candidate = |
255 | 6.71M | xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col]; |
256 | 6.71M | const int len = mi_size_wide[BLOCK_8X8]; |
257 | | |
258 | 6.71M | add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, |
259 | 6.71M | newmv_count, ref_mv_stack, ref_mv_weight, |
260 | 6.71M | gm_mv_candidates, cm->global_motion, 2 * len); |
261 | 6.71M | } // Analyze a single 8x8 block motion information. |
262 | 7.19M | } |
263 | | |
264 | | static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
265 | 6.65M | int mi_row, int mi_col, int bs) { |
266 | 6.65M | const int sb_mi_size = mi_size_wide[cm->seq_params->sb_size]; |
267 | 6.65M | const int mask_row = mi_row & (sb_mi_size - 1); |
268 | 6.65M | const int mask_col = mi_col & (sb_mi_size - 1); |
269 | | |
270 | 6.65M | if (bs > mi_size_wide[BLOCK_64X64]) return 0; |
271 | | |
272 | | // In a split partition all apart from the bottom right has a top right |
273 | 6.41M | int has_tr = !((mask_row & bs) && (mask_col & bs)); |
274 | | |
275 | | // bs > 0 and bs is a power of 2 |
276 | 6.41M | assert(bs > 0 && !(bs & (bs - 1))); |
277 | | |
278 | | // For each 4x4 group of blocks, when the bottom right is decoded the blocks |
279 | | // to the right have not been decoded therefore the bottom right does |
280 | | // not have a top right |
281 | 9.61M | while (bs < sb_mi_size) { |
282 | 9.08M | if (mask_col & bs) { |
283 | 4.15M | if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) { |
284 | 954k | has_tr = 0; |
285 | 954k | break; |
286 | 954k | } |
287 | 4.92M | } else { |
288 | 4.92M | break; |
289 | 4.92M | } |
290 | 3.20M | bs <<= 1; |
291 | 3.20M | } |
292 | | |
293 | | // In a VERTICAL or VERTICAL_4 partition, all partition before the last one |
294 | | // always have a top right (as the block above will have been decoded). |
295 | 6.41M | if (xd->width < xd->height) { |
296 | 1.42M | if (!xd->is_last_vertical_rect) has_tr = 1; |
297 | 1.42M | } |
298 | | |
299 | | // In a HORIZONTAL or HORIZONTAL_4 partition, partitions after the first one |
300 | | // never have a top right (as the block to the right won't have been decoded). |
301 | 6.41M | if (xd->width > xd->height) { |
302 | 2.22M | if (!xd->is_first_horizontal_rect) has_tr = 0; |
303 | 2.22M | } |
304 | | |
305 | | // The bottom left square of a Vertical A (in the old format) does |
306 | | // not have a top right as it is decoded before the right hand |
307 | | // rectangle of the partition |
308 | 6.41M | if (xd->mi[0]->partition == PARTITION_VERT_A) { |
309 | 233k | if (xd->width == xd->height) |
310 | 152k | if (mask_row & bs) has_tr = 0; |
311 | 233k | } |
312 | | |
313 | 6.41M | return has_tr; |
314 | 6.41M | } |
315 | | |
316 | | static int check_sb_border(const int mi_row, const int mi_col, |
317 | 6.63M | const int row_offset, const int col_offset) { |
318 | 6.63M | const int sb_mi_size = mi_size_wide[BLOCK_64X64]; |
319 | 6.63M | const int row = mi_row & (sb_mi_size - 1); |
320 | 6.63M | const int col = mi_col & (sb_mi_size - 1); |
321 | | |
322 | 6.63M | if (row + row_offset < 0 || row + row_offset >= sb_mi_size || |
323 | 6.63M | col + col_offset < 0 || col + col_offset >= sb_mi_size) |
324 | 2.35M | return 0; |
325 | | |
326 | 4.27M | return 1; |
327 | 6.63M | } |
328 | | |
329 | | static int add_tpl_ref_mv(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
330 | | int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame, |
331 | | int blk_row, int blk_col, int_mv *gm_mv_candidates, |
332 | | uint8_t *const refmv_count, |
333 | | CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE], |
334 | | uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE], |
335 | 17.7M | int16_t *mode_context) { |
336 | 17.7M | POSITION mi_pos; |
337 | 17.7M | mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1; |
338 | 17.7M | mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1; |
339 | | |
340 | 17.7M | if (!is_inside(&xd->tile, mi_col, mi_row, &mi_pos)) return 0; |
341 | | |
342 | 17.6M | const TPL_MV_REF *prev_frame_mvs = |
343 | 17.6M | cm->tpl_mvs + |
344 | 17.6M | ((mi_row + mi_pos.row) >> 1) * (cm->mi_params.mi_stride >> 1) + |
345 | 17.6M | ((mi_col + mi_pos.col) >> 1); |
346 | 17.6M | if (prev_frame_mvs->mfmv0.as_int == INVALID_MV) return 0; |
347 | | |
348 | 1.67M | MV_REFERENCE_FRAME rf[2]; |
349 | 1.67M | av1_set_ref_frame(rf, ref_frame); |
350 | | |
351 | 1.67M | const uint16_t weight_unit = 1; // mi_size_wide[BLOCK_8X8]; |
352 | 1.67M | const int cur_frame_index = cm->cur_frame->order_hint; |
353 | 1.67M | const RefCntBuffer *const buf_0 = get_ref_frame_buf(cm, rf[0]); |
354 | 1.67M | const int frame0_index = buf_0->order_hint; |
355 | 1.67M | const int cur_offset_0 = get_relative_dist(&cm->seq_params->order_hint_info, |
356 | 1.67M | cur_frame_index, frame0_index); |
357 | 1.67M | int idx; |
358 | 1.67M | const int allow_high_precision_mv = cm->features.allow_high_precision_mv; |
359 | 1.67M | const int force_integer_mv = cm->features.cur_frame_force_integer_mv; |
360 | | |
361 | 1.67M | int_mv this_refmv; |
362 | 1.67M | av1_get_mv_projection(&this_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, |
363 | 1.67M | cur_offset_0, prev_frame_mvs->ref_frame_offset); |
364 | 1.67M | lower_mv_precision(&this_refmv.as_mv, allow_high_precision_mv, |
365 | 1.67M | force_integer_mv); |
366 | | |
367 | 1.67M | if (rf[1] == NONE_FRAME) { |
368 | 915k | if (blk_row == 0 && blk_col == 0) { |
369 | 142k | if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || |
370 | 142k | abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16) |
371 | 70.2k | mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); |
372 | 142k | } |
373 | | |
374 | 2.09M | for (idx = 0; idx < *refmv_count; ++idx) |
375 | 1.90M | if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break; |
376 | | |
377 | 915k | if (idx < *refmv_count) ref_mv_weight[idx] += 2 * weight_unit; |
378 | | |
379 | 915k | if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { |
380 | 191k | ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; |
381 | 191k | ref_mv_weight[idx] = 2 * weight_unit; |
382 | 191k | ++(*refmv_count); |
383 | 191k | } |
384 | 915k | } else { |
385 | | // Process compound inter mode |
386 | 759k | const RefCntBuffer *const buf_1 = get_ref_frame_buf(cm, rf[1]); |
387 | 759k | const int frame1_index = buf_1->order_hint; |
388 | 759k | const int cur_offset_1 = get_relative_dist(&cm->seq_params->order_hint_info, |
389 | 759k | cur_frame_index, frame1_index); |
390 | 759k | int_mv comp_refmv; |
391 | 759k | av1_get_mv_projection(&comp_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, |
392 | 759k | cur_offset_1, prev_frame_mvs->ref_frame_offset); |
393 | 759k | lower_mv_precision(&comp_refmv.as_mv, allow_high_precision_mv, |
394 | 759k | force_integer_mv); |
395 | | |
396 | 759k | if (blk_row == 0 && blk_col == 0) { |
397 | 65.6k | if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || |
398 | 65.6k | abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16 || |
399 | 65.6k | abs(comp_refmv.as_mv.row - gm_mv_candidates[1].as_mv.row) >= 16 || |
400 | 65.6k | abs(comp_refmv.as_mv.col - gm_mv_candidates[1].as_mv.col) >= 16) |
401 | 36.2k | mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); |
402 | 65.6k | } |
403 | | |
404 | 1.44M | for (idx = 0; idx < *refmv_count; ++idx) { |
405 | 1.35M | if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int && |
406 | 1.35M | comp_refmv.as_int == ref_mv_stack[idx].comp_mv.as_int) |
407 | 665k | break; |
408 | 1.35M | } |
409 | | |
410 | 759k | if (idx < *refmv_count) ref_mv_weight[idx] += 2 * weight_unit; |
411 | | |
412 | 759k | if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { |
413 | 105k | ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; |
414 | 105k | ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int; |
415 | 105k | ref_mv_weight[idx] = 2 * weight_unit; |
416 | 105k | ++(*refmv_count); |
417 | 105k | } |
418 | 759k | } |
419 | | |
420 | 1.67M | return 1; |
421 | 17.6M | } |
422 | | |
423 | | static inline void process_compound_ref_mv_candidate( |
424 | | const MB_MODE_INFO *const candidate, const AV1_COMMON *const cm, |
425 | | const MV_REFERENCE_FRAME *const rf, int_mv ref_id[2][2], |
426 | 806k | int ref_id_count[2], int_mv ref_diff[2][2], int ref_diff_count[2]) { |
427 | 2.41M | for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { |
428 | 1.61M | MV_REFERENCE_FRAME can_rf = candidate->ref_frame[rf_idx]; |
429 | | |
430 | 4.83M | for (int cmp_idx = 0; cmp_idx < 2; ++cmp_idx) { |
431 | 3.22M | if (can_rf == rf[cmp_idx] && ref_id_count[cmp_idx] < 2) { |
432 | 887k | ref_id[cmp_idx][ref_id_count[cmp_idx]] = candidate->mv[rf_idx]; |
433 | 887k | ++ref_id_count[cmp_idx]; |
434 | 2.33M | } else if (can_rf > INTRA_FRAME && ref_diff_count[cmp_idx] < 2) { |
435 | 1.21M | int_mv this_mv = candidate->mv[rf_idx]; |
436 | 1.21M | if (cm->ref_frame_sign_bias[can_rf] != |
437 | 1.21M | cm->ref_frame_sign_bias[rf[cmp_idx]]) { |
438 | 259k | this_mv.as_mv.row = -this_mv.as_mv.row; |
439 | 259k | this_mv.as_mv.col = -this_mv.as_mv.col; |
440 | 259k | } |
441 | 1.21M | ref_diff[cmp_idx][ref_diff_count[cmp_idx]] = this_mv; |
442 | 1.21M | ++ref_diff_count[cmp_idx]; |
443 | 1.21M | } |
444 | 3.22M | } |
445 | 1.61M | } |
446 | 806k | } |
447 | | |
448 | | static inline void process_single_ref_mv_candidate( |
449 | | const MB_MODE_INFO *const candidate, const AV1_COMMON *const cm, |
450 | | MV_REFERENCE_FRAME ref_frame, uint8_t *const refmv_count, |
451 | | CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE], |
452 | 2.88M | uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE]) { |
453 | 8.65M | for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { |
454 | 5.76M | if (candidate->ref_frame[rf_idx] > INTRA_FRAME) { |
455 | 2.39M | int_mv this_mv = candidate->mv[rf_idx]; |
456 | 2.39M | if (cm->ref_frame_sign_bias[candidate->ref_frame[rf_idx]] != |
457 | 2.39M | cm->ref_frame_sign_bias[ref_frame]) { |
458 | 59.1k | this_mv.as_mv.row = -this_mv.as_mv.row; |
459 | 59.1k | this_mv.as_mv.col = -this_mv.as_mv.col; |
460 | 59.1k | } |
461 | 2.39M | int stack_idx; |
462 | 2.73M | for (stack_idx = 0; stack_idx < *refmv_count; ++stack_idx) { |
463 | 2.29M | const int_mv stack_mv = ref_mv_stack[stack_idx].this_mv; |
464 | 2.29M | if (this_mv.as_int == stack_mv.as_int) break; |
465 | 2.29M | } |
466 | | |
467 | 2.39M | if (stack_idx == *refmv_count) { |
468 | 443k | ref_mv_stack[stack_idx].this_mv = this_mv; |
469 | | |
470 | | // TODO(jingning): Set an arbitrary small number here. The weight |
471 | | // doesn't matter as long as it is properly initialized. |
472 | 443k | ref_mv_weight[stack_idx] = 2; |
473 | 443k | ++(*refmv_count); |
474 | 443k | } |
475 | 2.39M | } |
476 | 5.76M | } |
477 | 2.88M | } |
478 | | |
479 | | static inline void setup_ref_mv_list( |
480 | | const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame, |
481 | | uint8_t *const refmv_count, |
482 | | CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE], |
483 | | uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE], |
484 | | int_mv mv_ref_list[MAX_MV_REF_CANDIDATES], int_mv *gm_mv_candidates, |
485 | 4.61M | int mi_row, int mi_col, int16_t *mode_context) { |
486 | 4.61M | const int bs = AOMMAX(xd->width, xd->height); |
487 | 4.61M | const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs); |
488 | 4.61M | MV_REFERENCE_FRAME rf[2]; |
489 | | |
490 | 4.61M | const TileInfo *const tile = &xd->tile; |
491 | 4.61M | int max_row_offset = 0, max_col_offset = 0; |
492 | 4.61M | const int row_adj = (xd->height < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01); |
493 | 4.61M | const int col_adj = (xd->width < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01); |
494 | 4.61M | int processed_rows = 0; |
495 | 4.61M | int processed_cols = 0; |
496 | | |
497 | 4.61M | av1_set_ref_frame(rf, ref_frame); |
498 | 4.61M | mode_context[ref_frame] = 0; |
499 | 4.61M | *refmv_count = 0; |
500 | | |
501 | | // Find valid maximum row/col offset. |
502 | 4.61M | if (xd->up_available) { |
503 | 4.39M | max_row_offset = -(MVREF_ROW_COLS << 1) + row_adj; |
504 | | |
505 | 4.39M | if (xd->height < mi_size_high[BLOCK_8X8]) |
506 | 986k | max_row_offset = -(2 << 1) + row_adj; |
507 | | |
508 | 4.39M | max_row_offset = find_valid_row_offset(tile, mi_row, max_row_offset); |
509 | 4.39M | } |
510 | | |
511 | 4.61M | if (xd->left_available) { |
512 | 4.47M | max_col_offset = -(MVREF_ROW_COLS << 1) + col_adj; |
513 | | |
514 | 4.47M | if (xd->width < mi_size_wide[BLOCK_8X8]) |
515 | 827k | max_col_offset = -(2 << 1) + col_adj; |
516 | | |
517 | 4.47M | max_col_offset = find_valid_col_offset(tile, mi_col, max_col_offset); |
518 | 4.47M | } |
519 | | |
520 | 4.61M | uint8_t col_match_count = 0; |
521 | 4.61M | uint8_t row_match_count = 0; |
522 | 4.61M | uint8_t newmv_count = 0; |
523 | | |
524 | | // Scan the first above row mode info. row_offset = -1; |
525 | 4.61M | if (abs(max_row_offset) >= 1) |
526 | 4.39M | scan_row_mbmi(cm, xd, mi_col, rf, -1, ref_mv_stack, ref_mv_weight, |
527 | 4.39M | refmv_count, &row_match_count, &newmv_count, gm_mv_candidates, |
528 | 4.39M | max_row_offset, &processed_rows); |
529 | | // Scan the first left column mode info. col_offset = -1; |
530 | 4.61M | if (abs(max_col_offset) >= 1) |
531 | 4.47M | scan_col_mbmi(cm, xd, mi_row, rf, -1, ref_mv_stack, ref_mv_weight, |
532 | 4.47M | refmv_count, &col_match_count, &newmv_count, gm_mv_candidates, |
533 | 4.47M | max_col_offset, &processed_cols); |
534 | | // Check top-right boundary |
535 | 4.61M | if (has_tr) |
536 | 2.58M | scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->width, ref_mv_stack, |
537 | 2.58M | ref_mv_weight, &row_match_count, &newmv_count, |
538 | 2.58M | gm_mv_candidates, refmv_count); |
539 | | |
540 | 4.61M | const uint8_t nearest_match = (row_match_count > 0) + (col_match_count > 0); |
541 | 4.61M | const uint8_t nearest_refmv_count = *refmv_count; |
542 | | |
543 | | // TODO(yunqing): for comp_search, do it for all 3 cases. |
544 | 11.1M | for (int idx = 0; idx < nearest_refmv_count; ++idx) |
545 | 6.50M | ref_mv_weight[idx] += REF_CAT_LEVEL; |
546 | | |
547 | 4.61M | if (cm->features.allow_ref_frame_mvs) { |
548 | 3.68M | int is_available = 0; |
549 | 3.68M | const int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->height); |
550 | 3.68M | const int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->width); |
551 | 3.68M | const int blk_row_end = AOMMIN(xd->height, mi_size_high[BLOCK_64X64]); |
552 | 3.68M | const int blk_col_end = AOMMIN(xd->width, mi_size_wide[BLOCK_64X64]); |
553 | | |
554 | 3.68M | const int tpl_sample_pos[3][2] = { |
555 | 3.68M | { voffset, -2 }, |
556 | 3.68M | { voffset, hoffset }, |
557 | 3.68M | { voffset - 2, hoffset }, |
558 | 3.68M | }; |
559 | 3.68M | const int allow_extension = (xd->height >= mi_size_high[BLOCK_8X8]) && |
560 | 3.68M | (xd->height < mi_size_high[BLOCK_64X64]) && |
561 | 3.68M | (xd->width >= mi_size_wide[BLOCK_8X8]) && |
562 | 3.68M | (xd->width < mi_size_wide[BLOCK_64X64]); |
563 | | |
564 | 3.68M | const int step_h = (xd->height >= mi_size_high[BLOCK_64X64]) |
565 | 3.68M | ? mi_size_high[BLOCK_16X16] |
566 | 3.68M | : mi_size_high[BLOCK_8X8]; |
567 | 3.68M | const int step_w = (xd->width >= mi_size_wide[BLOCK_64X64]) |
568 | 3.68M | ? mi_size_wide[BLOCK_16X16] |
569 | 3.68M | : mi_size_wide[BLOCK_8X8]; |
570 | | |
571 | 9.99M | for (int blk_row = 0; blk_row < blk_row_end; blk_row += step_h) { |
572 | 19.7M | for (int blk_col = 0; blk_col < blk_col_end; blk_col += step_w) { |
573 | 13.4M | int ret = add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, |
574 | 13.4M | blk_col, gm_mv_candidates, refmv_count, |
575 | 13.4M | ref_mv_stack, ref_mv_weight, mode_context); |
576 | 13.4M | if (blk_row == 0 && blk_col == 0) is_available = ret; |
577 | 13.4M | } |
578 | 6.31M | } |
579 | | |
580 | 3.68M | if (is_available == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); |
581 | | |
582 | 10.3M | for (int i = 0; i < 3 && allow_extension; ++i) { |
583 | 6.63M | const int blk_row = tpl_sample_pos[i][0]; |
584 | 6.63M | const int blk_col = tpl_sample_pos[i][1]; |
585 | | |
586 | 6.63M | if (!check_sb_border(mi_row, mi_col, blk_row, blk_col)) continue; |
587 | 4.27M | add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, blk_col, |
588 | 4.27M | gm_mv_candidates, refmv_count, ref_mv_stack, ref_mv_weight, |
589 | 4.27M | mode_context); |
590 | 4.27M | } |
591 | 3.68M | } |
592 | | |
593 | 4.61M | uint8_t dummy_newmv_count = 0; |
594 | | |
595 | | // Scan the second outer area. |
596 | 4.61M | scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack, ref_mv_weight, |
597 | 4.61M | &row_match_count, &dummy_newmv_count, gm_mv_candidates, |
598 | 4.61M | refmv_count); |
599 | | |
600 | 13.8M | for (int idx = 2; idx <= MVREF_ROW_COLS; ++idx) { |
601 | 9.23M | const int row_offset = -(idx << 1) + 1 + row_adj; |
602 | 9.23M | const int col_offset = -(idx << 1) + 1 + col_adj; |
603 | | |
604 | 9.23M | if (abs(row_offset) <= abs(max_row_offset) && |
605 | 9.23M | abs(row_offset) > processed_rows) |
606 | 5.45M | scan_row_mbmi(cm, xd, mi_col, rf, row_offset, ref_mv_stack, ref_mv_weight, |
607 | 5.45M | refmv_count, &row_match_count, &dummy_newmv_count, |
608 | 5.45M | gm_mv_candidates, max_row_offset, &processed_rows); |
609 | | |
610 | 9.23M | if (abs(col_offset) <= abs(max_col_offset) && |
611 | 9.23M | abs(col_offset) > processed_cols) |
612 | 5.43M | scan_col_mbmi(cm, xd, mi_row, rf, col_offset, ref_mv_stack, ref_mv_weight, |
613 | 5.43M | refmv_count, &col_match_count, &dummy_newmv_count, |
614 | 5.43M | gm_mv_candidates, max_col_offset, &processed_cols); |
615 | 9.23M | } |
616 | | |
617 | 4.61M | const uint8_t ref_match_count = (row_match_count > 0) + (col_match_count > 0); |
618 | | |
619 | 4.61M | switch (nearest_match) { |
620 | 572k | case 0: |
621 | 572k | if (ref_match_count >= 1) mode_context[ref_frame] |= 1; |
622 | 572k | if (ref_match_count == 1) |
623 | 115k | mode_context[ref_frame] |= (1 << REFMV_OFFSET); |
624 | 457k | else if (ref_match_count >= 2) |
625 | 24.1k | mode_context[ref_frame] |= (2 << REFMV_OFFSET); |
626 | 572k | break; |
627 | 1.32M | case 1: |
628 | 1.32M | mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3; |
629 | 1.32M | if (ref_match_count == 1) |
630 | 832k | mode_context[ref_frame] |= (3 << REFMV_OFFSET); |
631 | 491k | else if (ref_match_count >= 2) |
632 | 491k | mode_context[ref_frame] |= (4 << REFMV_OFFSET); |
633 | 1.32M | break; |
634 | 2.72M | case 2: |
635 | 2.72M | default: |
636 | 2.72M | if (newmv_count >= 1) |
637 | 1.61M | mode_context[ref_frame] |= 4; |
638 | 1.10M | else |
639 | 1.10M | mode_context[ref_frame] |= 5; |
640 | | |
641 | 2.72M | mode_context[ref_frame] |= (5 << REFMV_OFFSET); |
642 | 2.72M | break; |
643 | 4.61M | } |
644 | | |
645 | | // Rank the likelihood and assign nearest and near mvs. |
646 | 4.61M | int len = nearest_refmv_count; |
647 | 9.52M | while (len > 0) { |
648 | 4.90M | int nr_len = 0; |
649 | 7.76M | for (int idx = 1; idx < len; ++idx) { |
650 | 2.86M | if (ref_mv_weight[idx - 1] < ref_mv_weight[idx]) { |
651 | 1.02M | const CANDIDATE_MV tmp_mv = ref_mv_stack[idx - 1]; |
652 | 1.02M | const uint16_t tmp_ref_mv_weight = ref_mv_weight[idx - 1]; |
653 | 1.02M | ref_mv_stack[idx - 1] = ref_mv_stack[idx]; |
654 | 1.02M | ref_mv_stack[idx] = tmp_mv; |
655 | 1.02M | ref_mv_weight[idx - 1] = ref_mv_weight[idx]; |
656 | 1.02M | ref_mv_weight[idx] = tmp_ref_mv_weight; |
657 | 1.02M | nr_len = idx; |
658 | 1.02M | } |
659 | 2.86M | } |
660 | 4.90M | len = nr_len; |
661 | 4.90M | } |
662 | | |
663 | 4.61M | len = *refmv_count; |
664 | 7.54M | while (len > nearest_refmv_count) { |
665 | 2.92M | int nr_len = nearest_refmv_count; |
666 | 5.24M | for (int idx = nearest_refmv_count + 1; idx < len; ++idx) { |
667 | 2.31M | if (ref_mv_weight[idx - 1] < ref_mv_weight[idx]) { |
668 | 730k | const CANDIDATE_MV tmp_mv = ref_mv_stack[idx - 1]; |
669 | 730k | const uint16_t tmp_ref_mv_weight = ref_mv_weight[idx - 1]; |
670 | 730k | ref_mv_stack[idx - 1] = ref_mv_stack[idx]; |
671 | 730k | ref_mv_stack[idx] = tmp_mv; |
672 | 730k | ref_mv_weight[idx - 1] = ref_mv_weight[idx]; |
673 | 730k | ref_mv_weight[idx] = tmp_ref_mv_weight; |
674 | 730k | nr_len = idx; |
675 | 730k | } |
676 | 2.31M | } |
677 | 2.92M | len = nr_len; |
678 | 2.92M | } |
679 | | |
680 | 4.61M | int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->width); |
681 | 4.61M | mi_width = AOMMIN(mi_width, cm->mi_params.mi_cols - mi_col); |
682 | 4.61M | int mi_height = AOMMIN(mi_size_high[BLOCK_64X64], xd->height); |
683 | 4.61M | mi_height = AOMMIN(mi_height, cm->mi_params.mi_rows - mi_row); |
684 | 4.61M | const int mi_size = AOMMIN(mi_width, mi_height); |
685 | 4.61M | if (rf[1] > NONE_FRAME) { |
686 | | // TODO(jingning, yunqing): Refactor and consolidate the compound and |
687 | | // single reference frame modes. Reduce unnecessary redundancy. |
688 | 634k | if (*refmv_count < MAX_MV_REF_CANDIDATES) { |
689 | 426k | int_mv ref_id[2][2], ref_diff[2][2]; |
690 | 426k | int ref_id_count[2] = { 0 }, ref_diff_count[2] = { 0 }; |
691 | | |
692 | 812k | for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size;) { |
693 | 386k | const MB_MODE_INFO *const candidate = xd->mi[-xd->mi_stride + idx]; |
694 | 386k | process_compound_ref_mv_candidate( |
695 | 386k | candidate, cm, rf, ref_id, ref_id_count, ref_diff, ref_diff_count); |
696 | 386k | idx += mi_size_wide[candidate->bsize]; |
697 | 386k | } |
698 | | |
699 | 846k | for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size;) { |
700 | 420k | const MB_MODE_INFO *const candidate = xd->mi[idx * xd->mi_stride - 1]; |
701 | 420k | process_compound_ref_mv_candidate( |
702 | 420k | candidate, cm, rf, ref_id, ref_id_count, ref_diff, ref_diff_count); |
703 | 420k | idx += mi_size_high[candidate->bsize]; |
704 | 420k | } |
705 | | |
706 | | // Build up the compound mv predictor |
707 | 426k | int_mv comp_list[MAX_MV_REF_CANDIDATES][2]; |
708 | | |
709 | 1.27M | for (int idx = 0; idx < 2; ++idx) { |
710 | 851k | int comp_idx = 0; |
711 | 851k | for (int list_idx = 0; |
712 | 1.73M | list_idx < ref_id_count[idx] && comp_idx < MAX_MV_REF_CANDIDATES; |
713 | 887k | ++list_idx, ++comp_idx) |
714 | 887k | comp_list[comp_idx][idx] = ref_id[idx][list_idx]; |
715 | 851k | for (int list_idx = 0; |
716 | 1.48M | list_idx < ref_diff_count[idx] && comp_idx < MAX_MV_REF_CANDIDATES; |
717 | 851k | ++list_idx, ++comp_idx) |
718 | 631k | comp_list[comp_idx][idx] = ref_diff[idx][list_idx]; |
719 | 1.03M | for (; comp_idx < MAX_MV_REF_CANDIDATES; ++comp_idx) |
720 | 183k | comp_list[comp_idx][idx] = gm_mv_candidates[idx]; |
721 | 851k | } |
722 | | |
723 | 426k | if (*refmv_count) { |
724 | 253k | assert(*refmv_count == 1); |
725 | 253k | if (comp_list[0][0].as_int == ref_mv_stack[0].this_mv.as_int && |
726 | 253k | comp_list[0][1].as_int == ref_mv_stack[0].comp_mv.as_int) { |
727 | 197k | ref_mv_stack[*refmv_count].this_mv = comp_list[1][0]; |
728 | 197k | ref_mv_stack[*refmv_count].comp_mv = comp_list[1][1]; |
729 | 197k | } else { |
730 | 55.8k | ref_mv_stack[*refmv_count].this_mv = comp_list[0][0]; |
731 | 55.8k | ref_mv_stack[*refmv_count].comp_mv = comp_list[0][1]; |
732 | 55.8k | } |
733 | 253k | ref_mv_weight[*refmv_count] = 2; |
734 | 253k | ++*refmv_count; |
735 | 253k | } else { |
736 | 517k | for (int idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx) { |
737 | 344k | ref_mv_stack[*refmv_count].this_mv = comp_list[idx][0]; |
738 | 344k | ref_mv_stack[*refmv_count].comp_mv = comp_list[idx][1]; |
739 | 344k | ref_mv_weight[*refmv_count] = 2; |
740 | 344k | ++*refmv_count; |
741 | 344k | } |
742 | 172k | } |
743 | 426k | } |
744 | | |
745 | 634k | assert(*refmv_count >= 2); |
746 | | |
747 | 2.09M | for (int idx = 0; idx < *refmv_count; ++idx) { |
748 | 1.46M | clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->width << MI_SIZE_LOG2, |
749 | 1.46M | xd->height << MI_SIZE_LOG2, xd); |
750 | 1.46M | clamp_mv_ref(&ref_mv_stack[idx].comp_mv.as_mv, xd->width << MI_SIZE_LOG2, |
751 | 1.46M | xd->height << MI_SIZE_LOG2, xd); |
752 | 1.46M | } |
753 | 3.98M | } else { |
754 | | // Handle single reference frame extension |
755 | 5.48M | for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size && |
756 | 5.48M | *refmv_count < MAX_MV_REF_CANDIDATES;) { |
757 | 1.50M | const MB_MODE_INFO *const candidate = xd->mi[-xd->mi_stride + idx]; |
758 | 1.50M | process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count, |
759 | 1.50M | ref_mv_stack, ref_mv_weight); |
760 | 1.50M | idx += mi_size_wide[candidate->bsize]; |
761 | 1.50M | } |
762 | | |
763 | 5.36M | for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size && |
764 | 5.36M | *refmv_count < MAX_MV_REF_CANDIDATES;) { |
765 | 1.37M | const MB_MODE_INFO *const candidate = xd->mi[idx * xd->mi_stride - 1]; |
766 | 1.37M | process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count, |
767 | 1.37M | ref_mv_stack, ref_mv_weight); |
768 | 1.37M | idx += mi_size_high[candidate->bsize]; |
769 | 1.37M | } |
770 | | |
771 | 14.3M | for (int idx = 0; idx < *refmv_count; ++idx) { |
772 | 10.3M | clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->width << MI_SIZE_LOG2, |
773 | 10.3M | xd->height << MI_SIZE_LOG2, xd); |
774 | 10.3M | } |
775 | | |
776 | 3.98M | if (mv_ref_list != NULL) { |
777 | 5.30M | for (int idx = *refmv_count; idx < MAX_MV_REF_CANDIDATES; ++idx) |
778 | 1.31M | mv_ref_list[idx].as_int = gm_mv_candidates[0].as_int; |
779 | | |
780 | 10.6M | for (int idx = 0; idx < AOMMIN(MAX_MV_REF_CANDIDATES, *refmv_count); |
781 | 6.64M | ++idx) { |
782 | 6.64M | mv_ref_list[idx].as_int = ref_mv_stack[idx].this_mv.as_int; |
783 | 6.64M | } |
784 | 3.98M | } |
785 | 3.98M | } |
786 | 4.61M | } |
787 | | |
788 | | void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, |
789 | | MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, |
790 | | uint8_t ref_mv_count[MODE_CTX_REF_FRAMES], |
791 | | CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE], |
792 | | uint16_t ref_mv_weight[][MAX_REF_MV_STACK_SIZE], |
793 | | int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], |
794 | 4.61M | int_mv *global_mvs, int16_t *mode_context) { |
795 | 4.61M | const int mi_row = xd->mi_row; |
796 | 4.61M | const int mi_col = xd->mi_col; |
797 | 4.61M | int_mv gm_mv[2]; |
798 | | |
799 | 4.61M | if (ref_frame == INTRA_FRAME) { |
800 | 60.1k | gm_mv[0].as_int = gm_mv[1].as_int = 0; |
801 | 60.1k | if (global_mvs != NULL) { |
802 | 0 | global_mvs[ref_frame].as_int = INVALID_MV; |
803 | 0 | } |
804 | 4.55M | } else { |
805 | 4.55M | const BLOCK_SIZE bsize = mi->bsize; |
806 | 4.55M | const int allow_high_precision_mv = cm->features.allow_high_precision_mv; |
807 | 4.55M | const int force_integer_mv = cm->features.cur_frame_force_integer_mv; |
808 | 4.55M | if (ref_frame < REF_FRAMES) { |
809 | 3.92M | gm_mv[0] = gm_get_motion_vector(&cm->global_motion[ref_frame], |
810 | 3.92M | allow_high_precision_mv, bsize, mi_col, |
811 | 3.92M | mi_row, force_integer_mv); |
812 | 3.92M | gm_mv[1].as_int = 0; |
813 | 3.92M | if (global_mvs != NULL) global_mvs[ref_frame] = gm_mv[0]; |
814 | 3.92M | } else { |
815 | 632k | MV_REFERENCE_FRAME rf[2]; |
816 | 632k | av1_set_ref_frame(rf, ref_frame); |
817 | 632k | gm_mv[0] = gm_get_motion_vector(&cm->global_motion[rf[0]], |
818 | 632k | allow_high_precision_mv, bsize, mi_col, |
819 | 632k | mi_row, force_integer_mv); |
820 | 632k | gm_mv[1] = gm_get_motion_vector(&cm->global_motion[rf[1]], |
821 | 632k | allow_high_precision_mv, bsize, mi_col, |
822 | 632k | mi_row, force_integer_mv); |
823 | 632k | } |
824 | 4.55M | } |
825 | | |
826 | 4.61M | setup_ref_mv_list(cm, xd, ref_frame, &ref_mv_count[ref_frame], |
827 | 4.61M | ref_mv_stack[ref_frame], ref_mv_weight[ref_frame], |
828 | 4.61M | mv_ref_list ? mv_ref_list[ref_frame] : NULL, gm_mv, mi_row, |
829 | 4.61M | mi_col, mode_context); |
830 | 4.61M | } |
831 | | |
832 | | void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, |
833 | 3.18M | int_mv *near_mv, int is_integer) { |
834 | 3.18M | int i; |
835 | | // Make sure all the candidates are properly clamped etc |
836 | 9.56M | for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) { |
837 | 6.37M | lower_mv_precision(&mvlist[i].as_mv, allow_hp, is_integer); |
838 | 6.37M | } |
839 | 3.18M | *nearest_mv = mvlist[0]; |
840 | 3.18M | *near_mv = mvlist[1]; |
841 | 3.18M | } |
842 | | |
843 | 202k | void av1_setup_frame_buf_refs(AV1_COMMON *cm) { |
844 | 202k | cm->cur_frame->order_hint = cm->current_frame.order_hint; |
845 | 202k | cm->cur_frame->display_order_hint = cm->current_frame.display_order_hint; |
846 | 202k | cm->cur_frame->pyramid_level = cm->current_frame.pyramid_level; |
847 | 202k | cm->cur_frame->filter_level[0] = -1; |
848 | 202k | cm->cur_frame->filter_level[1] = -1; |
849 | 202k | MV_REFERENCE_FRAME ref_frame; |
850 | 1.62M | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
851 | 1.41M | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
852 | 1.41M | if (buf != NULL) { |
853 | 553k | cm->cur_frame->ref_order_hints[ref_frame - LAST_FRAME] = buf->order_hint; |
854 | 553k | cm->cur_frame->ref_display_order_hint[ref_frame - LAST_FRAME] = |
855 | 553k | buf->display_order_hint; |
856 | 553k | } |
857 | 1.41M | } |
858 | 202k | } |
859 | | |
860 | 202k | void av1_setup_frame_sign_bias(AV1_COMMON *cm) { |
861 | 202k | MV_REFERENCE_FRAME ref_frame; |
862 | 1.62M | for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
863 | 1.41M | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
864 | 1.41M | if (cm->seq_params->order_hint_info.enable_order_hint && buf != NULL) { |
865 | 553k | const int ref_order_hint = buf->order_hint; |
866 | 553k | cm->ref_frame_sign_bias[ref_frame] = |
867 | 553k | (get_relative_dist(&cm->seq_params->order_hint_info, ref_order_hint, |
868 | 553k | (int)cm->current_frame.order_hint) <= 0) |
869 | 553k | ? 0 |
870 | 553k | : 1; |
871 | 866k | } else { |
872 | 866k | cm->ref_frame_sign_bias[ref_frame] = 0; |
873 | 866k | } |
874 | 1.41M | } |
875 | 202k | } |
876 | | |
877 | 27.2M | #define MAX_OFFSET_WIDTH 64 |
878 | 28.4M | #define MAX_OFFSET_HEIGHT 0 |
879 | | |
880 | | static int get_block_position(AV1_COMMON *cm, int *mi_r, int *mi_c, int blk_row, |
881 | 16.0M | int blk_col, MV mv, int sign_bias) { |
882 | 16.0M | const int base_blk_row = (blk_row >> 3) << 3; |
883 | 16.0M | const int base_blk_col = (blk_col >> 3) << 3; |
884 | | |
885 | 16.0M | const int row_offset = (mv.row >= 0) ? (mv.row >> (4 + MI_SIZE_LOG2)) |
886 | 16.0M | : -((-mv.row) >> (4 + MI_SIZE_LOG2)); |
887 | | |
888 | 16.0M | const int col_offset = (mv.col >= 0) ? (mv.col >> (4 + MI_SIZE_LOG2)) |
889 | 16.0M | : -((-mv.col) >> (4 + MI_SIZE_LOG2)); |
890 | | |
891 | 16.0M | const int row = |
892 | 16.0M | (sign_bias == 1) ? blk_row - row_offset : blk_row + row_offset; |
893 | 16.0M | const int col = |
894 | 16.0M | (sign_bias == 1) ? blk_col - col_offset : blk_col + col_offset; |
895 | | |
896 | 16.0M | if (row < 0 || row >= (cm->mi_params.mi_rows >> 1) || col < 0 || |
897 | 16.0M | col >= (cm->mi_params.mi_cols >> 1)) |
898 | 1.59M | return 0; |
899 | | |
900 | 14.4M | if (row < base_blk_row - (MAX_OFFSET_HEIGHT >> 3) || |
901 | 14.4M | row >= base_blk_row + 8 + (MAX_OFFSET_HEIGHT >> 3) || |
902 | 14.4M | col < base_blk_col - (MAX_OFFSET_WIDTH >> 3) || |
903 | 14.4M | col >= base_blk_col + 8 + (MAX_OFFSET_WIDTH >> 3)) |
904 | 864k | return 0; |
905 | | |
906 | 13.5M | *mi_r = row; |
907 | 13.5M | *mi_c = col; |
908 | | |
909 | 13.5M | return 1; |
910 | 14.4M | } |
911 | | |
912 | | // Note: motion_filed_projection finds motion vectors of current frame's |
913 | | // reference frame, and projects them to current frame. To make it clear, |
914 | | // let's call current frame's reference frame as start frame. |
915 | | // Call Start frame's reference frames as reference frames. |
916 | | // Call ref_offset as frame distances between start frame and its reference |
917 | | // frames. |
918 | | static int motion_field_projection(AV1_COMMON *cm, |
919 | 45.0k | MV_REFERENCE_FRAME start_frame, int dir) { |
920 | 45.0k | TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; |
921 | 45.0k | int ref_offset[REF_FRAMES] = { 0 }; |
922 | | |
923 | 45.0k | const RefCntBuffer *const start_frame_buf = |
924 | 45.0k | get_ref_frame_buf(cm, start_frame); |
925 | 45.0k | if (start_frame_buf == NULL) return 0; |
926 | | |
927 | 45.0k | if (start_frame_buf->frame_type == KEY_FRAME || |
928 | 45.0k | start_frame_buf->frame_type == INTRA_ONLY_FRAME) |
929 | 29.0k | return 0; |
930 | | |
931 | 15.9k | if (start_frame_buf->mi_rows != cm->mi_params.mi_rows || |
932 | 15.9k | start_frame_buf->mi_cols != cm->mi_params.mi_cols) |
933 | 25 | return 0; |
934 | | |
935 | 15.9k | const int start_frame_order_hint = start_frame_buf->order_hint; |
936 | 15.9k | const unsigned int *const ref_order_hints = |
937 | 15.9k | &start_frame_buf->ref_order_hints[0]; |
938 | 15.9k | const int cur_order_hint = cm->cur_frame->order_hint; |
939 | 15.9k | int start_to_current_frame_offset = get_relative_dist( |
940 | 15.9k | &cm->seq_params->order_hint_info, start_frame_order_hint, cur_order_hint); |
941 | | |
942 | 127k | for (MV_REFERENCE_FRAME rf = LAST_FRAME; rf <= INTER_REFS_PER_FRAME; ++rf) { |
943 | 111k | ref_offset[rf] = get_relative_dist(&cm->seq_params->order_hint_info, |
944 | 111k | start_frame_order_hint, |
945 | 111k | ref_order_hints[rf - LAST_FRAME]); |
946 | 111k | } |
947 | | |
948 | 15.9k | if (dir == 2) start_to_current_frame_offset = -start_to_current_frame_offset; |
949 | | |
950 | 15.9k | MV_REF *mv_ref_base = start_frame_buf->mvs; |
951 | 15.9k | const int mvs_rows = (cm->mi_params.mi_rows + 1) >> 1; |
952 | 15.9k | const int mvs_cols = (cm->mi_params.mi_cols + 1) >> 1; |
953 | | |
954 | 484k | for (int blk_row = 0; blk_row < mvs_rows; ++blk_row) { |
955 | 26.9M | for (int blk_col = 0; blk_col < mvs_cols; ++blk_col) { |
956 | 26.4M | MV_REF *mv_ref = &mv_ref_base[blk_row * mvs_cols + blk_col]; |
957 | 26.4M | MV fwd_mv = mv_ref->mv.as_mv; |
958 | | |
959 | 26.4M | if (mv_ref->ref_frame > INTRA_FRAME) { |
960 | 19.4M | int_mv this_mv; |
961 | 19.4M | int mi_r, mi_c; |
962 | 19.4M | const int ref_frame_offset = ref_offset[mv_ref->ref_frame]; |
963 | | |
964 | 19.4M | int pos_valid = |
965 | 19.4M | abs(ref_frame_offset) <= MAX_FRAME_DISTANCE && |
966 | 19.4M | ref_frame_offset > 0 && |
967 | 19.4M | abs(start_to_current_frame_offset) <= MAX_FRAME_DISTANCE; |
968 | | |
969 | 19.4M | if (pos_valid) { |
970 | 16.0M | av1_get_mv_projection(&this_mv.as_mv, fwd_mv, |
971 | 16.0M | start_to_current_frame_offset, |
972 | 16.0M | ref_frame_offset); |
973 | 16.0M | pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, |
974 | 16.0M | this_mv.as_mv, dir >> 1); |
975 | 16.0M | } |
976 | | |
977 | 19.4M | if (pos_valid) { |
978 | 13.5M | const int mi_offset = mi_r * (cm->mi_params.mi_stride >> 1) + mi_c; |
979 | | |
980 | 13.5M | tpl_mvs_base[mi_offset].mfmv0.as_mv.row = fwd_mv.row; |
981 | 13.5M | tpl_mvs_base[mi_offset].mfmv0.as_mv.col = fwd_mv.col; |
982 | 13.5M | tpl_mvs_base[mi_offset].ref_frame_offset = ref_frame_offset; |
983 | 13.5M | } |
984 | 19.4M | } |
985 | 26.4M | } |
986 | 468k | } |
987 | | |
988 | 15.9k | return 1; |
989 | 15.9k | } |
990 | | |
991 | | // cm->ref_frame_side is calculated here, and will be used in |
992 | | // av1_copy_frame_mvs() to affect how mvs are copied. |
993 | 175k | void av1_calculate_ref_frame_side(AV1_COMMON *cm) { |
994 | 175k | const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; |
995 | | |
996 | 175k | memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side)); |
997 | 175k | if (!order_hint_info->enable_order_hint) return; |
998 | | |
999 | 125k | const int cur_order_hint = cm->cur_frame->order_hint; |
1000 | | |
1001 | 1.00M | for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { |
1002 | 875k | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
1003 | 875k | int order_hint = 0; |
1004 | | |
1005 | 875k | if (buf != NULL) order_hint = buf->order_hint; |
1006 | | |
1007 | 875k | if (get_relative_dist(order_hint_info, order_hint, cur_order_hint) > 0) |
1008 | 252k | cm->ref_frame_side[ref_frame] = 1; |
1009 | 623k | else if (order_hint == cur_order_hint) |
1010 | 194k | cm->ref_frame_side[ref_frame] = -1; |
1011 | 875k | } |
1012 | 125k | } |
1013 | | |
1014 | 15.9k | void av1_setup_motion_field(AV1_COMMON *cm) { |
1015 | 15.9k | const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; |
1016 | | |
1017 | 15.9k | if (!order_hint_info->enable_order_hint) return; |
1018 | | |
1019 | 15.9k | TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; |
1020 | 15.9k | int size = ((cm->mi_params.mi_rows + MAX_MIB_SIZE) >> 1) * |
1021 | 15.9k | (cm->mi_params.mi_stride >> 1); |
1022 | 56.6M | for (int idx = 0; idx < size; ++idx) { |
1023 | 56.6M | tpl_mvs_base[idx].mfmv0.as_int = INVALID_MV; |
1024 | 56.6M | tpl_mvs_base[idx].ref_frame_offset = 0; |
1025 | 56.6M | } |
1026 | | |
1027 | 15.9k | const int cur_order_hint = cm->cur_frame->order_hint; |
1028 | 15.9k | const RefCntBuffer *ref_buf[INTER_REFS_PER_FRAME]; |
1029 | 15.9k | int ref_order_hint[INTER_REFS_PER_FRAME]; |
1030 | | |
1031 | 127k | for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { |
1032 | 111k | const int ref_idx = ref_frame - LAST_FRAME; |
1033 | 111k | const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); |
1034 | 111k | int order_hint = 0; |
1035 | | |
1036 | 111k | if (buf != NULL) order_hint = buf->order_hint; |
1037 | | |
1038 | 111k | ref_buf[ref_idx] = buf; |
1039 | 111k | ref_order_hint[ref_idx] = order_hint; |
1040 | 111k | } |
1041 | | |
1042 | 15.9k | int ref_stamp = MFMV_STACK_SIZE - 1; |
1043 | | |
1044 | 15.9k | if (ref_buf[LAST_FRAME - LAST_FRAME] != NULL) { |
1045 | 15.9k | const int alt_of_lst_order_hint = |
1046 | 15.9k | ref_buf[LAST_FRAME - LAST_FRAME] |
1047 | 15.9k | ->ref_order_hints[ALTREF_FRAME - LAST_FRAME]; |
1048 | | |
1049 | 15.9k | const int is_lst_overlay = |
1050 | 15.9k | (alt_of_lst_order_hint == ref_order_hint[GOLDEN_FRAME - LAST_FRAME]); |
1051 | 15.9k | if (!is_lst_overlay) motion_field_projection(cm, LAST_FRAME, 2); |
1052 | 15.9k | --ref_stamp; |
1053 | 15.9k | } |
1054 | | |
1055 | 15.9k | if (get_relative_dist(order_hint_info, |
1056 | 15.9k | ref_order_hint[BWDREF_FRAME - LAST_FRAME], |
1057 | 15.9k | cur_order_hint) > 0) { |
1058 | 5.73k | if (motion_field_projection(cm, BWDREF_FRAME, 0)) --ref_stamp; |
1059 | 5.73k | } |
1060 | | |
1061 | 15.9k | if (get_relative_dist(order_hint_info, |
1062 | 15.9k | ref_order_hint[ALTREF2_FRAME - LAST_FRAME], |
1063 | 15.9k | cur_order_hint) > 0) { |
1064 | 5.56k | if (motion_field_projection(cm, ALTREF2_FRAME, 0)) --ref_stamp; |
1065 | 5.56k | } |
1066 | | |
1067 | 15.9k | if (get_relative_dist(order_hint_info, |
1068 | 15.9k | ref_order_hint[ALTREF_FRAME - LAST_FRAME], |
1069 | 15.9k | cur_order_hint) > 0 && |
1070 | 15.9k | ref_stamp >= 0) |
1071 | 6.32k | if (motion_field_projection(cm, ALTREF_FRAME, 0)) --ref_stamp; |
1072 | | |
1073 | 15.9k | if (ref_stamp >= 0) motion_field_projection(cm, LAST2_FRAME, 2); |
1074 | 15.9k | } |
1075 | | |
1076 | | static inline void record_samples(const MB_MODE_INFO *mbmi, int *pts, |
1077 | | int *pts_inref, int row_offset, int sign_r, |
1078 | 5.28M | int col_offset, int sign_c) { |
1079 | 5.28M | const int bw = block_size_wide[mbmi->bsize]; |
1080 | 5.28M | const int bh = block_size_high[mbmi->bsize]; |
1081 | 5.28M | const int x = col_offset * MI_SIZE + sign_c * bw / 2 - 1; |
1082 | 5.28M | const int y = row_offset * MI_SIZE + sign_r * bh / 2 - 1; |
1083 | | |
1084 | 5.28M | pts[0] = GET_MV_SUBPEL(x); |
1085 | 5.28M | pts[1] = GET_MV_SUBPEL(y); |
1086 | 5.28M | pts_inref[0] = pts[0] + mbmi->mv[0].as_mv.col; |
1087 | 5.28M | pts_inref[1] = pts[1] + mbmi->mv[0].as_mv.row; |
1088 | 5.28M | } |
1089 | | |
1090 | | // Select samples according to the motion vector difference. |
1091 | | uint8_t av1_selectSamples(MV *mv, int *pts, int *pts_inref, int len, |
1092 | 239k | BLOCK_SIZE bsize) { |
1093 | 239k | const int bw = block_size_wide[bsize]; |
1094 | 239k | const int bh = block_size_high[bsize]; |
1095 | 239k | const int thresh = clamp(AOMMAX(bw, bh), 16, 112); |
1096 | 239k | uint8_t ret = 0; |
1097 | 239k | assert(len <= LEAST_SQUARES_SAMPLES_MAX); |
1098 | | |
1099 | | // Only keep the samples with MV differences within threshold. |
1100 | 975k | for (int i = 0; i < len; ++i) { |
1101 | 736k | const int diff = abs(pts_inref[2 * i] - pts[2 * i] - mv->col) + |
1102 | 736k | abs(pts_inref[2 * i + 1] - pts[2 * i + 1] - mv->row); |
1103 | 736k | if (diff > thresh) continue; |
1104 | 453k | if (ret != i) { |
1105 | 76.0k | memcpy(pts + 2 * ret, pts + 2 * i, 2 * sizeof(pts[0])); |
1106 | 76.0k | memcpy(pts_inref + 2 * ret, pts_inref + 2 * i, 2 * sizeof(pts_inref[0])); |
1107 | 76.0k | } |
1108 | 453k | ++ret; |
1109 | 453k | } |
1110 | | // Keep at least 1 sample. |
1111 | 239k | return AOMMAX(ret, 1); |
1112 | 239k | } |
1113 | | |
1114 | | // Note: Samples returned are at 1/8-pel precision |
1115 | | // Sample are the neighbor block center point's coordinates relative to the |
1116 | | // left-top pixel of current block. |
1117 | | uint8_t av1_findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int *pts, |
1118 | 2.39M | int *pts_inref) { |
1119 | 2.39M | const MB_MODE_INFO *const mbmi0 = xd->mi[0]; |
1120 | 2.39M | const int ref_frame = mbmi0->ref_frame[0]; |
1121 | 2.39M | const int up_available = xd->up_available; |
1122 | 2.39M | const int left_available = xd->left_available; |
1123 | 2.39M | uint8_t np = 0; |
1124 | 2.39M | int do_tl = 1; |
1125 | 2.39M | int do_tr = 1; |
1126 | 2.39M | const int mi_stride = xd->mi_stride; |
1127 | 2.39M | const int mi_row = xd->mi_row; |
1128 | 2.39M | const int mi_col = xd->mi_col; |
1129 | | |
1130 | | // scan the nearest above rows |
1131 | 2.39M | if (up_available) { |
1132 | 2.28M | const int mi_row_offset = -1; |
1133 | 2.28M | const MB_MODE_INFO *mbmi = xd->mi[mi_row_offset * mi_stride]; |
1134 | 2.28M | uint8_t superblock_width = mi_size_wide[mbmi->bsize]; |
1135 | | |
1136 | 2.28M | if (xd->width <= superblock_width) { |
1137 | | // Handle "current block width <= above block width" case. |
1138 | 1.93M | const int col_offset = -mi_col % superblock_width; |
1139 | | |
1140 | 1.93M | if (col_offset < 0) do_tl = 0; |
1141 | 1.93M | if (col_offset + superblock_width > xd->width) do_tr = 0; |
1142 | | |
1143 | 1.93M | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
1144 | 1.27M | record_samples(mbmi, pts, pts_inref, 0, -1, col_offset, 1); |
1145 | 1.27M | pts += 2; |
1146 | 1.27M | pts_inref += 2; |
1147 | 1.27M | if (++np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; |
1148 | 1.27M | } |
1149 | 1.93M | } else { |
1150 | | // Handle "current block width > above block width" case. |
1151 | 1.22M | for (int i = 0; i < AOMMIN(xd->width, cm->mi_params.mi_cols - mi_col); |
1152 | 878k | i += superblock_width) { |
1153 | 878k | mbmi = xd->mi[i + mi_row_offset * mi_stride]; |
1154 | 878k | superblock_width = mi_size_wide[mbmi->bsize]; |
1155 | | |
1156 | 878k | if (mbmi->ref_frame[0] == ref_frame && |
1157 | 878k | mbmi->ref_frame[1] == NONE_FRAME) { |
1158 | 577k | record_samples(mbmi, pts, pts_inref, 0, -1, i, 1); |
1159 | 577k | pts += 2; |
1160 | 577k | pts_inref += 2; |
1161 | 577k | if (++np >= LEAST_SQUARES_SAMPLES_MAX) |
1162 | 1.32k | return LEAST_SQUARES_SAMPLES_MAX; |
1163 | 577k | } |
1164 | 878k | } |
1165 | 348k | } |
1166 | 2.28M | } |
1167 | 2.39M | assert(np <= LEAST_SQUARES_SAMPLES_MAX); |
1168 | | |
1169 | | // scan the nearest left columns |
1170 | 2.39M | if (left_available) { |
1171 | 2.32M | const int mi_col_offset = -1; |
1172 | 2.32M | const MB_MODE_INFO *mbmi = xd->mi[mi_col_offset]; |
1173 | 2.32M | uint8_t superblock_height = mi_size_high[mbmi->bsize]; |
1174 | | |
1175 | 2.32M | if (xd->height <= superblock_height) { |
1176 | | // Handle "current block height <= above block height" case. |
1177 | 1.94M | const int row_offset = -mi_row % superblock_height; |
1178 | | |
1179 | 1.94M | if (row_offset < 0) do_tl = 0; |
1180 | | |
1181 | 1.94M | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
1182 | 1.26M | record_samples(mbmi, pts, pts_inref, row_offset, 1, 0, -1); |
1183 | 1.26M | pts += 2; |
1184 | 1.26M | pts_inref += 2; |
1185 | 1.26M | np++; |
1186 | 1.26M | if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; |
1187 | 1.26M | } |
1188 | 1.94M | } else { |
1189 | | // Handle "current block height > above block height" case. |
1190 | 1.31M | for (int i = 0; i < AOMMIN(xd->height, cm->mi_params.mi_rows - mi_row); |
1191 | 945k | i += superblock_height) { |
1192 | 945k | mbmi = xd->mi[mi_col_offset + i * mi_stride]; |
1193 | 945k | superblock_height = mi_size_high[mbmi->bsize]; |
1194 | | |
1195 | 945k | if (mbmi->ref_frame[0] == ref_frame && |
1196 | 945k | mbmi->ref_frame[1] == NONE_FRAME) { |
1197 | 637k | record_samples(mbmi, pts, pts_inref, i, 1, 0, -1); |
1198 | 637k | pts += 2; |
1199 | 637k | pts_inref += 2; |
1200 | 637k | if (++np >= LEAST_SQUARES_SAMPLES_MAX) |
1201 | 5.17k | return LEAST_SQUARES_SAMPLES_MAX; |
1202 | 637k | } |
1203 | 945k | } |
1204 | 378k | } |
1205 | 2.32M | } |
1206 | 2.38M | assert(np <= LEAST_SQUARES_SAMPLES_MAX); |
1207 | | |
1208 | | // Top-left block |
1209 | 2.38M | if (do_tl && left_available && up_available) { |
1210 | 1.53M | const int mi_row_offset = -1; |
1211 | 1.53M | const int mi_col_offset = -1; |
1212 | 1.53M | MB_MODE_INFO *mbmi = xd->mi[mi_col_offset + mi_row_offset * mi_stride]; |
1213 | | |
1214 | 1.53M | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
1215 | 964k | record_samples(mbmi, pts, pts_inref, 0, -1, 0, -1); |
1216 | 964k | pts += 2; |
1217 | 964k | pts_inref += 2; |
1218 | 964k | if (++np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; |
1219 | 964k | } |
1220 | 1.53M | } |
1221 | 2.38M | assert(np <= LEAST_SQUARES_SAMPLES_MAX); |
1222 | | |
1223 | | // Top-right block |
1224 | 2.38M | if (do_tr && |
1225 | 2.38M | has_top_right(cm, xd, mi_row, mi_col, AOMMAX(xd->width, xd->height))) { |
1226 | 1.04M | const POSITION trb_pos = { -1, xd->width }; |
1227 | 1.04M | const TileInfo *const tile = &xd->tile; |
1228 | 1.04M | if (is_inside(tile, mi_col, mi_row, &trb_pos)) { |
1229 | 950k | const int mi_row_offset = -1; |
1230 | 950k | const int mi_col_offset = xd->width; |
1231 | 950k | const MB_MODE_INFO *mbmi = |
1232 | 950k | xd->mi[mi_col_offset + mi_row_offset * mi_stride]; |
1233 | | |
1234 | 950k | if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { |
1235 | 571k | record_samples(mbmi, pts, pts_inref, 0, -1, xd->width, 1); |
1236 | 571k | if (++np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; |
1237 | 571k | } |
1238 | 950k | } |
1239 | 1.04M | } |
1240 | 2.37M | assert(np <= LEAST_SQUARES_SAMPLES_MAX); |
1241 | | |
1242 | 2.37M | return np; |
1243 | 2.37M | } |
1244 | | |
1245 | 181k | void av1_setup_skip_mode_allowed(AV1_COMMON *cm) { |
1246 | 181k | const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; |
1247 | 181k | SkipModeInfo *const skip_mode_info = &cm->current_frame.skip_mode_info; |
1248 | | |
1249 | 181k | skip_mode_info->skip_mode_allowed = 0; |
1250 | 181k | skip_mode_info->ref_frame_idx_0 = INVALID_IDX; |
1251 | 181k | skip_mode_info->ref_frame_idx_1 = INVALID_IDX; |
1252 | | |
1253 | 181k | if (!order_hint_info->enable_order_hint || frame_is_intra_only(cm) || |
1254 | 181k | cm->current_frame.reference_mode == SINGLE_REFERENCE) |
1255 | 155k | return; |
1256 | | |
1257 | 26.2k | const int cur_order_hint = cm->current_frame.order_hint; |
1258 | 26.2k | int ref_order_hints[2] = { -1, INT_MAX }; |
1259 | 26.2k | int ref_idx[2] = { INVALID_IDX, INVALID_IDX }; |
1260 | | |
1261 | | // Identify the nearest forward and backward references. |
1262 | 209k | for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { |
1263 | 183k | const RefCntBuffer *const buf = get_ref_frame_buf(cm, LAST_FRAME + i); |
1264 | 183k | if (buf == NULL) continue; |
1265 | | |
1266 | 183k | const int ref_order_hint = buf->order_hint; |
1267 | 183k | if (get_relative_dist(order_hint_info, ref_order_hint, cur_order_hint) < |
1268 | 183k | 0) { |
1269 | | // Forward reference |
1270 | 130k | if (ref_order_hints[0] == -1 || |
1271 | 130k | get_relative_dist(order_hint_info, ref_order_hint, |
1272 | 105k | ref_order_hints[0]) > 0) { |
1273 | 44.1k | ref_order_hints[0] = ref_order_hint; |
1274 | 44.1k | ref_idx[0] = i; |
1275 | 44.1k | } |
1276 | 130k | } else if (get_relative_dist(order_hint_info, ref_order_hint, |
1277 | 52.6k | cur_order_hint) > 0) { |
1278 | | // Backward reference |
1279 | 23.2k | if (ref_order_hints[1] == INT_MAX || |
1280 | 23.2k | get_relative_dist(order_hint_info, ref_order_hint, |
1281 | 13.2k | ref_order_hints[1]) < 0) { |
1282 | 11.1k | ref_order_hints[1] = ref_order_hint; |
1283 | 11.1k | ref_idx[1] = i; |
1284 | 11.1k | } |
1285 | 23.2k | } |
1286 | 183k | } |
1287 | | |
1288 | 26.2k | if (ref_idx[0] != INVALID_IDX && ref_idx[1] != INVALID_IDX) { |
1289 | | // == Bi-directional prediction == |
1290 | 9.09k | skip_mode_info->skip_mode_allowed = 1; |
1291 | 9.09k | skip_mode_info->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]); |
1292 | 9.09k | skip_mode_info->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]); |
1293 | 17.1k | } else if (ref_idx[0] != INVALID_IDX && ref_idx[1] == INVALID_IDX) { |
1294 | | // == Forward prediction only == |
1295 | | // Identify the second nearest forward reference. |
1296 | 16.2k | ref_order_hints[1] = -1; |
1297 | 129k | for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { |
1298 | 113k | const RefCntBuffer *const buf = get_ref_frame_buf(cm, LAST_FRAME + i); |
1299 | 113k | if (buf == NULL) continue; |
1300 | | |
1301 | 113k | const int ref_order_hint = buf->order_hint; |
1302 | 113k | if ((ref_order_hints[0] != -1 && |
1303 | 113k | get_relative_dist(order_hint_info, ref_order_hint, |
1304 | 113k | ref_order_hints[0]) < 0) && |
1305 | 113k | (ref_order_hints[1] == -1 || |
1306 | 38.5k | get_relative_dist(order_hint_info, ref_order_hint, |
1307 | 24.2k | ref_order_hints[1]) > 0)) { |
1308 | | // Second closest forward reference |
1309 | 21.2k | ref_order_hints[1] = ref_order_hint; |
1310 | 21.2k | ref_idx[1] = i; |
1311 | 21.2k | } |
1312 | 113k | } |
1313 | 16.2k | if (ref_order_hints[1] != -1) { |
1314 | 14.3k | skip_mode_info->skip_mode_allowed = 1; |
1315 | 14.3k | skip_mode_info->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]); |
1316 | 14.3k | skip_mode_info->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]); |
1317 | 14.3k | } |
1318 | 16.2k | } |
1319 | 26.2k | } |
1320 | | |
1321 | | typedef struct { |
1322 | | int map_idx; // frame map index |
1323 | | RefCntBuffer *buf; // frame buffer |
1324 | | int sort_idx; // index based on the offset to be used for sorting |
1325 | | } REF_FRAME_INFO; |
1326 | | |
1327 | | // Compares the sort_idx fields. If they are equal, then compares the map_idx |
1328 | | // fields to break the tie. This ensures a stable sort. |
1329 | 383k | static int compare_ref_frame_info(const void *arg_a, const void *arg_b) { |
1330 | 383k | const REF_FRAME_INFO *info_a = (REF_FRAME_INFO *)arg_a; |
1331 | 383k | const REF_FRAME_INFO *info_b = (REF_FRAME_INFO *)arg_b; |
1332 | | |
1333 | 383k | const int sort_idx_diff = info_a->sort_idx - info_b->sort_idx; |
1334 | 383k | if (sort_idx_diff != 0) return sort_idx_diff; |
1335 | 125k | return info_a->map_idx - info_b->map_idx; |
1336 | 383k | } |
1337 | | |
1338 | | static inline void set_ref_frame_info(int *remapped_ref_idx, int frame_idx, |
1339 | 175k | REF_FRAME_INFO *ref_info) { |
1340 | 175k | assert(frame_idx >= 0 && frame_idx < INTER_REFS_PER_FRAME); |
1341 | | |
1342 | 175k | remapped_ref_idx[frame_idx] = ref_info->map_idx; |
1343 | 175k | } |
1344 | | |
1345 | | void av1_set_frame_refs(AV1_COMMON *const cm, int *remapped_ref_idx, |
1346 | 25.5k | int lst_map_idx, int gld_map_idx) { |
1347 | 25.5k | int lst_frame_sort_idx = -1; |
1348 | 25.5k | int gld_frame_sort_idx = -1; |
1349 | | |
1350 | 25.5k | assert(cm->seq_params->order_hint_info.enable_order_hint); |
1351 | 25.5k | assert(cm->seq_params->order_hint_info.order_hint_bits_minus_1 >= 0); |
1352 | 25.5k | const int cur_order_hint = (int)cm->current_frame.order_hint; |
1353 | 25.5k | const int cur_frame_sort_idx = |
1354 | 25.5k | 1 << cm->seq_params->order_hint_info.order_hint_bits_minus_1; |
1355 | | |
1356 | 25.5k | REF_FRAME_INFO ref_frame_info[REF_FRAMES]; |
1357 | 25.5k | int ref_flag_list[INTER_REFS_PER_FRAME] = { 0, 0, 0, 0, 0, 0, 0 }; |
1358 | | |
1359 | 229k | for (int i = 0; i < REF_FRAMES; ++i) { |
1360 | 204k | const int map_idx = i; |
1361 | | |
1362 | 204k | ref_frame_info[i].map_idx = map_idx; |
1363 | 204k | ref_frame_info[i].sort_idx = -1; |
1364 | | |
1365 | 204k | RefCntBuffer *const buf = cm->ref_frame_map[map_idx]; |
1366 | 204k | ref_frame_info[i].buf = buf; |
1367 | | |
1368 | 204k | if (buf == NULL) continue; |
1369 | | // If this assertion fails, there is a reference leak. |
1370 | 190k | assert(buf->ref_count > 0); |
1371 | | |
1372 | 190k | const int offset = (int)buf->order_hint; |
1373 | 190k | ref_frame_info[i].sort_idx = |
1374 | 190k | (offset == -1) ? -1 |
1375 | 190k | : cur_frame_sort_idx + |
1376 | 190k | get_relative_dist(&cm->seq_params->order_hint_info, |
1377 | 190k | offset, cur_order_hint); |
1378 | 190k | assert(ref_frame_info[i].sort_idx >= -1); |
1379 | | |
1380 | 190k | if (map_idx == lst_map_idx) lst_frame_sort_idx = ref_frame_info[i].sort_idx; |
1381 | 190k | if (map_idx == gld_map_idx) gld_frame_sort_idx = ref_frame_info[i].sort_idx; |
1382 | 190k | } |
1383 | | |
1384 | | // Confirm both LAST_FRAME and GOLDEN_FRAME are valid forward reference |
1385 | | // frames. |
1386 | 25.5k | if (lst_frame_sort_idx == -1 || lst_frame_sort_idx >= cur_frame_sort_idx) { |
1387 | 271 | aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME, |
1388 | 271 | "Inter frame requests a look-ahead frame as LAST"); |
1389 | 271 | } |
1390 | 25.5k | if (gld_frame_sort_idx == -1 || gld_frame_sort_idx >= cur_frame_sort_idx) { |
1391 | 164 | aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME, |
1392 | 164 | "Inter frame requests a look-ahead frame as GOLDEN"); |
1393 | 164 | } |
1394 | | |
1395 | | // Sort ref frames based on their frame_offset values. |
1396 | 25.5k | qsort(ref_frame_info, REF_FRAMES, sizeof(REF_FRAME_INFO), |
1397 | 25.5k | compare_ref_frame_info); |
1398 | | |
1399 | | // Identify forward and backward reference frames. |
1400 | | // Forward reference: offset < order_hint |
1401 | | // Backward reference: offset >= order_hint |
1402 | 25.5k | int fwd_start_idx = 0, fwd_end_idx = REF_FRAMES - 1; |
1403 | | |
1404 | 178k | for (int i = 0; i < REF_FRAMES; i++) { |
1405 | 173k | if (ref_frame_info[i].sort_idx == -1) { |
1406 | 13.8k | fwd_start_idx++; |
1407 | 13.8k | continue; |
1408 | 13.8k | } |
1409 | | |
1410 | 159k | if (ref_frame_info[i].sort_idx >= cur_frame_sort_idx) { |
1411 | 20.9k | fwd_end_idx = i - 1; |
1412 | 20.9k | break; |
1413 | 20.9k | } |
1414 | 159k | } |
1415 | | |
1416 | 25.5k | int bwd_start_idx = fwd_end_idx + 1; |
1417 | 25.5k | int bwd_end_idx = REF_FRAMES - 1; |
1418 | | |
1419 | | // === Backward Reference Frames === |
1420 | | |
1421 | | // == ALTREF_FRAME == |
1422 | 25.5k | if (bwd_start_idx <= bwd_end_idx) { |
1423 | 20.9k | set_ref_frame_info(remapped_ref_idx, ALTREF_FRAME - LAST_FRAME, |
1424 | 20.9k | &ref_frame_info[bwd_end_idx]); |
1425 | 20.9k | ref_flag_list[ALTREF_FRAME - LAST_FRAME] = 1; |
1426 | 20.9k | bwd_end_idx--; |
1427 | 20.9k | } |
1428 | | |
1429 | | // == BWDREF_FRAME == |
1430 | 25.5k | if (bwd_start_idx <= bwd_end_idx) { |
1431 | 13.5k | set_ref_frame_info(remapped_ref_idx, BWDREF_FRAME - LAST_FRAME, |
1432 | 13.5k | &ref_frame_info[bwd_start_idx]); |
1433 | 13.5k | ref_flag_list[BWDREF_FRAME - LAST_FRAME] = 1; |
1434 | 13.5k | bwd_start_idx++; |
1435 | 13.5k | } |
1436 | | |
1437 | | // == ALTREF2_FRAME == |
1438 | 25.5k | if (bwd_start_idx <= bwd_end_idx) { |
1439 | 7.03k | set_ref_frame_info(remapped_ref_idx, ALTREF2_FRAME - LAST_FRAME, |
1440 | 7.03k | &ref_frame_info[bwd_start_idx]); |
1441 | 7.03k | ref_flag_list[ALTREF2_FRAME - LAST_FRAME] = 1; |
1442 | 7.03k | } |
1443 | | |
1444 | | // === Forward Reference Frames === |
1445 | | |
1446 | 164k | for (int i = fwd_start_idx; i <= fwd_end_idx; ++i) { |
1447 | | // == LAST_FRAME == |
1448 | 138k | if (ref_frame_info[i].map_idx == lst_map_idx) { |
1449 | 25.1k | set_ref_frame_info(remapped_ref_idx, LAST_FRAME - LAST_FRAME, |
1450 | 25.1k | &ref_frame_info[i]); |
1451 | 25.1k | ref_flag_list[LAST_FRAME - LAST_FRAME] = 1; |
1452 | 25.1k | } |
1453 | | |
1454 | | // == GOLDEN_FRAME == |
1455 | 138k | if (ref_frame_info[i].map_idx == gld_map_idx) { |
1456 | 25.1k | set_ref_frame_info(remapped_ref_idx, GOLDEN_FRAME - LAST_FRAME, |
1457 | 25.1k | &ref_frame_info[i]); |
1458 | 25.1k | ref_flag_list[GOLDEN_FRAME - LAST_FRAME] = 1; |
1459 | 25.1k | } |
1460 | 138k | } |
1461 | | |
1462 | 25.5k | assert(ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && |
1463 | 25.5k | ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1); |
1464 | | |
1465 | | // == LAST2_FRAME == |
1466 | | // == LAST3_FRAME == |
1467 | | // == BWDREF_FRAME == |
1468 | | // == ALTREF2_FRAME == |
1469 | | // == ALTREF_FRAME == |
1470 | | |
1471 | | // Set up the reference frames in the anti-chronological order. |
1472 | 25.1k | static const MV_REFERENCE_FRAME ref_frame_list[INTER_REFS_PER_FRAME - 2] = { |
1473 | 25.1k | LAST2_FRAME, LAST3_FRAME, BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME |
1474 | 25.1k | }; |
1475 | | |
1476 | 25.1k | int ref_idx; |
1477 | 128k | for (ref_idx = 0; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { |
1478 | 109k | const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; |
1479 | | |
1480 | 109k | if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; |
1481 | | |
1482 | 104k | while (fwd_start_idx <= fwd_end_idx && |
1483 | 104k | (ref_frame_info[fwd_end_idx].map_idx == lst_map_idx || |
1484 | 97.7k | ref_frame_info[fwd_end_idx].map_idx == gld_map_idx)) { |
1485 | 25.3k | fwd_end_idx--; |
1486 | 25.3k | } |
1487 | 78.7k | if (fwd_start_idx > fwd_end_idx) break; |
1488 | | |
1489 | 72.4k | set_ref_frame_info(remapped_ref_idx, ref_frame - LAST_FRAME, |
1490 | 72.4k | &ref_frame_info[fwd_end_idx]); |
1491 | 72.4k | ref_flag_list[ref_frame - LAST_FRAME] = 1; |
1492 | | |
1493 | 72.4k | fwd_end_idx--; |
1494 | 72.4k | } |
1495 | | |
1496 | | // Assign all the remaining frame(s), if any, to the earliest reference |
1497 | | // frame. |
1498 | 47.5k | for (; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { |
1499 | 22.4k | const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; |
1500 | 22.4k | if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; |
1501 | 11.6k | set_ref_frame_info(remapped_ref_idx, ref_frame - LAST_FRAME, |
1502 | 11.6k | &ref_frame_info[fwd_start_idx]); |
1503 | 11.6k | ref_flag_list[ref_frame - LAST_FRAME] = 1; |
1504 | 11.6k | } |
1505 | | |
1506 | 200k | for (int i = 0; i < INTER_REFS_PER_FRAME; i++) { |
1507 | 175k | assert(ref_flag_list[i] == 1); |
1508 | 175k | } |
1509 | 25.1k | } |