Coverage Report

Created: 2025-06-13 07:07

/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
}