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