mvref_common.c 83.3 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
Yaowu Xu's avatar
Yaowu Xu committed
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
Yaowu Xu's avatar
Yaowu Xu committed
4
5
6
7
8
9
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
Jingning Han's avatar
Jingning Han committed
10
11
 */

12
#include "av1/common/mvref_common.h"
Yue Chen's avatar
Yue Chen committed
13
14
15
#if CONFIG_WARPED_MOTION
#include "av1/common/warped_motion.h"
#endif  // CONFIG_WARPED_MOTION
Jingning Han's avatar
Jingning Han committed
16

17
18
19
20
#if CONFIG_GLOBAL_MOTION
#define USE_CUR_GM_REFMV 1
#endif  // CONFIG_GLOBAL_MOTION

21
22
void av1_copy_frame_mvs(const AV1_COMMON *const cm, MODE_INFO *mi, int mi_row,
                        int mi_col, int x_mis, int y_mis) {
23
#if CONFIG_TMV || CONFIG_MFMV
24
  const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1);
25
26
  MV_REF *frame_mvs =
      cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1);
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
  x_mis = ROUND_POWER_OF_TWO(x_mis, 1);
  y_mis = ROUND_POWER_OF_TWO(y_mis, 1);
#else
  const int frame_mvs_stride = cm->mi_cols;
  MV_REF *frame_mvs = cm->cur_frame->mvs +
                      (mi_row & 0xfffe) * frame_mvs_stride + (mi_col & 0xfffe);
  x_mis = AOMMAX(x_mis, 2);
  y_mis = AOMMAX(y_mis, 2);
#endif  // CONFIG_TMV
  int w, h;

  for (h = 0; h < y_mis; h++) {
    MV_REF *const frame_mv = frame_mvs + h * frame_mvs_stride;
    for (w = 0; w < x_mis; w++) {
      MV_REF *const mv = frame_mv + w;
      mv->ref_frame[0] = mi->mbmi.ref_frame[0];
      mv->ref_frame[1] = mi->mbmi.ref_frame[1];
      mv->mv[0].as_int = mi->mbmi.mv[0].as_int;
      mv->mv[1].as_int = mi->mbmi.mv[1].as_int;
      // (TODO:yunqing) The following 2 lines won't be used and can be removed.
      mv->pred_mv[0].as_int = mi->mbmi.pred_mv[0].as_int;
      mv->pred_mv[1].as_int = mi->mbmi.pred_mv[1].as_int;
    }
  }
}

53
54
55
56
57
58
59
static uint8_t add_ref_mv_candidate(
    const MODE_INFO *const candidate_mi, const MB_MODE_INFO *const candidate,
    const MV_REFERENCE_FRAME rf[2], uint8_t *refmv_count,
    CANDIDATE_MV *ref_mv_stack, const int use_hp, int len, int block,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
    int_mv *gm_mv_candidates, const WarpedMotionParams *gm_params,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
60
    int col, int weight,
RogerZhou's avatar
RogerZhou committed
61
#if CONFIG_AMVR
Yunqing Wang's avatar
Yunqing Wang committed
62
    int is_integer,
RogerZhou's avatar
RogerZhou committed
63
#endif
Yunqing Wang's avatar
Yunqing Wang committed
64
65
    BLOCK_SIZE bsize, int mi_row, int mi_col, int subsampling_x,
    int subsampling_y) {
Jingning Han's avatar
Jingning Han committed
66
67
  int index = 0, ref;
  int newmv_count = 0;
68
  const int unify_bsize = 1;
69
  assert(weight % 2 == 0);
Yunqing Wang's avatar
Yunqing Wang committed
70
71
72
73
74
75
76
#if !CONFIG_EXT_WARPED_MOTION
  (void)bsize;
  (void)mi_row;
  (void)mi_col;
  (void)subsampling_x;
  (void)subsampling_y;
#endif  // CONFIG_EXT_WARPED_MOTION
Jingning Han's avatar
Jingning Han committed
77

Emil Keyder's avatar
Emil Keyder committed
78
  if (rf[1] == NONE_FRAME) {
Jingning Han's avatar
Jingning Han committed
79
80
81
    // single reference frame
    for (ref = 0; ref < 2; ++ref) {
      if (candidate->ref_frame[ref] == rf[0]) {
82
        int_mv this_refmv;
Yunqing Wang's avatar
Yunqing Wang committed
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#if CONFIG_EXT_WARPED_MOTION
        if (candidate->motion_mode == WARPED_CAUSAL) {
          WarpedMotionParams wm = candidate->wm_params[0];
          const int bw = block_size_wide[bsize];
          const int bh = block_size_high[bsize];
          int global_offset_c = mi_col * MI_SIZE;
          int global_offset_r = mi_row * MI_SIZE;
          int cc_offset = bw / 2 - 1;
          int cr_offset = bh / 2 - 1;
          int xc0 = cc_offset + global_offset_c;
          int yc0 = cr_offset + global_offset_r;
          int xc1 = xc0 + 1;
          int yc1 = yc0 + 1;
          int in[4] = { xc0, yc0, xc1, yc1 };
          int out[4] = { 0, 0, 0, 0 };

          assert(ref == 0);
          // For WARPED_CAUSAL, wmtype is always AFFINE.
          assert(wm.wmtype == AFFINE);
          project_points_affine(wm.wmmat, in, out, 2, 2, 2, subsampling_x,
                                subsampling_y);

          // assert(x_scale == 1024 && y_scale == 1024);
          // out[]'s precision is 1/64, adjust xc, yc accordingly.
          out[0] -= (xc0 << (3 + SCALING_FCT));
          out[1] -= (yc0 << (3 + SCALING_FCT));
          out[2] -= (xc1 << (3 + SCALING_FCT));
          out[3] -= (yc1 << (3 + SCALING_FCT));

          this_refmv.as_mv.col =
              ROUND_POWER_OF_TWO_SIGNED(out[0] + out[2], SCALING_FCT + 1);
          this_refmv.as_mv.row =
              ROUND_POWER_OF_TWO_SIGNED(out[1] + out[3], SCALING_FCT + 1);
          lower_mv_precision(&this_refmv.as_mv, use_hp);
        } else {
#endif  // CONFIG_EXT_WARPED_MOTION
119
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
120
121
122
          if (is_global_mv_block(candidate_mi, block, gm_params[rf[0]].wmtype))
            this_refmv = gm_mv_candidates[0];
          else
123
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
124
            this_refmv = get_sub_block_mv(candidate_mi, ref, col, block);
RogerZhou's avatar
RogerZhou committed
125
#if CONFIG_AMVR
Yunqing Wang's avatar
Yunqing Wang committed
126
          lower_mv_precision(&this_refmv.as_mv, use_hp, is_integer);
RogerZhou's avatar
RogerZhou committed
127
#else
128
        lower_mv_precision(&this_refmv.as_mv, use_hp);
129
#endif  // CONFIG_AMVR
Yunqing Wang's avatar
Yunqing Wang committed
130
131
132
#if CONFIG_EXT_WARPED_MOTION
        }
#endif  // CONFIG_EXT_WARPED_MOTION
133

Jingning Han's avatar
Jingning Han committed
134
        for (index = 0; index < *refmv_count; ++index)
clang-format's avatar
clang-format committed
135
          if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break;
136

137
        if (index < *refmv_count) ref_mv_stack[index].weight += weight * len;
138

Jingning Han's avatar
Jingning Han committed
139
140
141
        // Add a new item to the list.
        if (index == *refmv_count) {
          ref_mv_stack[index].this_mv = this_refmv;
142
143
          ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx(
              get_sub_block_pred_mv(candidate_mi, ref, col, block), this_refmv);
144
          ref_mv_stack[index].weight = weight * len;
Jingning Han's avatar
Jingning Han committed
145
          ++(*refmv_count);
146

147
          if (candidate->mode == NEWMV) ++newmv_count;
Jingning Han's avatar
Jingning Han committed
148
149
        }

150
151
        if (candidate_mi->mbmi.sb_type < BLOCK_8X8 && block >= 0 &&
            !unify_bsize) {
Jingning Han's avatar
Jingning Han committed
152
          int alt_block = 3 - block;
clang-format's avatar
clang-format committed
153
          this_refmv = get_sub_block_mv(candidate_mi, ref, col, alt_block);
RogerZhou's avatar
RogerZhou committed
154
155
156
#if CONFIG_AMVR
          lower_mv_precision(&this_refmv.as_mv, use_hp, is_integer);
#else
157
          lower_mv_precision(&this_refmv.as_mv, use_hp);
RogerZhou's avatar
RogerZhou committed
158
#endif
159
          for (index = 0; index < *refmv_count; ++index)
clang-format's avatar
clang-format committed
160
            if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break;
161

Yaowu Xu's avatar
Yaowu Xu committed
162
          if (index < *refmv_count) ref_mv_stack[index].weight += len;
163
164
165
166

          // Add a new item to the list.
          if (index == *refmv_count) {
            ref_mv_stack[index].this_mv = this_refmv;
167
168
169
            ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx(
                get_sub_block_pred_mv(candidate_mi, ref, col, alt_block),
                this_refmv);
Yaowu Xu's avatar
Yaowu Xu committed
170
            ref_mv_stack[index].weight = len;
171
            ++(*refmv_count);
172

173
            if (candidate->mode == NEWMV) ++newmv_count;
174
175
176
          }
        }
      }
Jingning Han's avatar
Jingning Han committed
177
178
179
    }
  } else {
    // compound reference frame
clang-format's avatar
clang-format committed
180
    if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) {
181
      int_mv this_refmv[2];
Jingning Han's avatar
Jingning Han committed
182

183
      for (ref = 0; ref < 2; ++ref) {
184
185
186
187
188
189
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
        if (is_global_mv_block(candidate_mi, block, gm_params[rf[ref]].wmtype))
          this_refmv[ref] = gm_mv_candidates[ref];
        else
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
          this_refmv[ref] = get_sub_block_mv(candidate_mi, ref, col, block);
RogerZhou's avatar
RogerZhou committed
190
191
192
#if CONFIG_AMVR
        lower_mv_precision(&this_refmv[ref].as_mv, use_hp, is_integer);
#else
193
        lower_mv_precision(&this_refmv[ref].as_mv, use_hp);
RogerZhou's avatar
RogerZhou committed
194
#endif
195
      }
196

Jingning Han's avatar
Jingning Han committed
197
198
199
200
201
      for (index = 0; index < *refmv_count; ++index)
        if ((ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int) &&
            (ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int))
          break;

202
      if (index < *refmv_count) ref_mv_stack[index].weight += weight * len;
Jingning Han's avatar
Jingning Han committed
203
204
205
206
207

      // Add a new item to the list.
      if (index == *refmv_count) {
        ref_mv_stack[index].this_mv = this_refmv[0];
        ref_mv_stack[index].comp_mv = this_refmv[1];
208
209
210
211
        ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx(
            get_sub_block_pred_mv(candidate_mi, 0, col, block), this_refmv[0]);
        ref_mv_stack[index].pred_diff[1] = av1_get_pred_diff_ctx(
            get_sub_block_pred_mv(candidate_mi, 1, col, block), this_refmv[1]);
212
        ref_mv_stack[index].weight = weight * len;
Jingning Han's avatar
Jingning Han committed
213
214
        ++(*refmv_count);

215
        if (candidate->mode == NEW_NEWMV) ++newmv_count;
Jingning Han's avatar
Jingning Han committed
216
217
      }

218
219
      if (candidate_mi->mbmi.sb_type < BLOCK_8X8 && block >= 0 &&
          !unify_bsize) {
Jingning Han's avatar
Jingning Han committed
220
221
222
223
        int alt_block = 3 - block;
        this_refmv[0] = get_sub_block_mv(candidate_mi, 0, col, alt_block);
        this_refmv[1] = get_sub_block_mv(candidate_mi, 1, col, alt_block);

RogerZhou's avatar
RogerZhou committed
224
225
226
227
        for (ref = 0; ref < 2; ++ref) {
#if CONFIG_AMVR
          lower_mv_precision(&this_refmv[ref].as_mv, use_hp, is_integer);
#else
228
          lower_mv_precision(&this_refmv[ref].as_mv, use_hp);
RogerZhou's avatar
RogerZhou committed
229
230
#endif
        }
Jingning Han's avatar
Jingning Han committed
231
232
233
234
235
        for (index = 0; index < *refmv_count; ++index)
          if (ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int &&
              ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int)
            break;

Yaowu Xu's avatar
Yaowu Xu committed
236
        if (index < *refmv_count) ref_mv_stack[index].weight += len;
Jingning Han's avatar
Jingning Han committed
237
238
239
240
241

        // Add a new item to the list.
        if (index == *refmv_count) {
          ref_mv_stack[index].this_mv = this_refmv[0];
          ref_mv_stack[index].comp_mv = this_refmv[1];
242
243
244
245
246
247
          ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx(
              get_sub_block_pred_mv(candidate_mi, 0, col, block),
              this_refmv[0]);
          ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx(
              get_sub_block_pred_mv(candidate_mi, 1, col, block),
              this_refmv[1]);
Yaowu Xu's avatar
Yaowu Xu committed
248
          ref_mv_stack[index].weight = len;
Jingning Han's avatar
Jingning Han committed
249
250
          ++(*refmv_count);

251
          if (candidate->mode == NEW_NEWMV) ++newmv_count;
Jingning Han's avatar
Jingning Han committed
252
253
254
255
256
257
258
        }
      }
    }
  }
  return newmv_count;
}

Yaowu Xu's avatar
Yaowu Xu committed
259
static uint8_t scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
Yunqing Wang's avatar
Yunqing Wang committed
260
                             int mi_row, int mi_col, int block,
clang-format's avatar
clang-format committed
261
                             const MV_REFERENCE_FRAME rf[2], int row_offset,
262
                             CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count,
263
264
265
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                             int_mv *gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
266
                             int max_row_offset, int *processed_rows) {
Yunqing Wang's avatar
Yunqing Wang committed
267
  const int end_mi = AOMMIN(xd->n8_w, cm->mi_cols - mi_col);
268
269
  const int n8_w_8 = mi_size_wide[BLOCK_8X8];
  const int n8_w_16 = mi_size_wide[BLOCK_16X16];
Jingning Han's avatar
Jingning Han committed
270
271
  int i;
  uint8_t newmv_count = 0;
272
  int col_offset = 0;
273
  const int shift = 0;
274
  // TODO(jingning): Revisit this part after cb4x4 is stable.
275
276
  if (abs(row_offset) > 1) {
    col_offset = 1;
277
    if (mi_col & 0x01 && xd->n8_w < n8_w_8) --col_offset;
278
  }
Yunqing Wang's avatar
Yunqing Wang committed
279
280
  const int use_step_16 = (xd->n8_w >= 16);
  MODE_INFO **const candidate_mi0 = xd->mi + row_offset * xd->mi_stride;
Jingning Han's avatar
Jingning Han committed
281

Yunqing Wang's avatar
Yunqing Wang committed
282
283
284
  for (i = 0; i < end_mi && *refmv_count < MAX_REF_MV_STACK_SIZE;) {
    const MODE_INFO *const candidate_mi = candidate_mi0[col_offset + i];
    const MB_MODE_INFO *const candidate = &candidate_mi->mbmi;
285
286
287
    const int candidate_bsize = candidate->sb_type;
    const int n8_w = mi_size_wide[candidate_bsize];
    int len = AOMMIN(xd->n8_w, n8_w);
Yunqing Wang's avatar
Yunqing Wang committed
288
289
290
291
    if (use_step_16)
      len = AOMMAX(n8_w_16, len);
    else if (abs(row_offset) > 1)
      len = AOMMAX(len, n8_w_8);
292
293
294
295
296
297
298
299
300
301
302

    int weight = 2;
    if (xd->n8_w >= n8_w_8 && xd->n8_w <= n8_w) {
      int inc = AOMMIN(-max_row_offset + row_offset + 1,
                       mi_size_high[candidate_bsize]);
      // Obtain range used in weight calculation.
      weight = AOMMAX(weight, (inc << shift));
      // Update processed rows.
      *processed_rows = inc - row_offset - 1;
    }

RogerZhou's avatar
RogerZhou committed
303
304
305
#if CONFIG_AMVR
    newmv_count += add_ref_mv_candidate(
        candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
306
307
308
309
        cm->allow_high_precision_mv, len, block,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
        gm_mv_candidates, cm->global_motion,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
310
311
312
        col_offset + i, weight, cm->cur_frame_mv_precision_level,
        xd->mi[0]->mbmi.sb_type, mi_row, mi_col, xd->plane[0].subsampling_x,
        xd->plane[0].subsampling_y);
RogerZhou's avatar
RogerZhou committed
313
#else
Yunqing Wang's avatar
Yunqing Wang committed
314
315
316
    newmv_count += add_ref_mv_candidate(
        candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
        cm->allow_high_precision_mv, len, block,
317
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
318
        gm_mv_candidates, cm->global_motion,
319
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
320
321
        col_offset + i, weight, xd->mi[0]->mbmi.sb_type, mi_row, mi_col,
        xd->plane[0].subsampling_x, xd->plane[0].subsampling_y);
RogerZhou's avatar
RogerZhou committed
322
#endif
323

Yunqing Wang's avatar
Yunqing Wang committed
324
    i += len;
325
  }
326
327

  return newmv_count;
328
329
}

Yaowu Xu's avatar
Yaowu Xu committed
330
static uint8_t scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
Yunqing Wang's avatar
Yunqing Wang committed
331
                             int mi_row, int mi_col, int block,
clang-format's avatar
clang-format committed
332
                             const MV_REFERENCE_FRAME rf[2], int col_offset,
333
                             CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count,
334
335
336
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                             int_mv *gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
337
                             int max_col_offset, int *processed_cols) {
Yunqing Wang's avatar
Yunqing Wang committed
338
  const int end_mi = AOMMIN(xd->n8_h, cm->mi_rows - mi_row);
339
340
  const int n8_h_8 = mi_size_high[BLOCK_8X8];
  const int n8_h_16 = mi_size_high[BLOCK_16X16];
341
  int i;
342
  uint8_t newmv_count = 0;
343
  int row_offset = 0;
344
  const int shift = 0;
345
346
  if (abs(col_offset) > 1) {
    row_offset = 1;
347
    if (mi_row & 0x01 && xd->n8_h < n8_h_8) --row_offset;
348
  }
Yunqing Wang's avatar
Yunqing Wang committed
349
  const int use_step_16 = (xd->n8_h >= 16);
350

Yunqing Wang's avatar
Yunqing Wang committed
351
352
353
354
  for (i = 0; i < end_mi && *refmv_count < MAX_REF_MV_STACK_SIZE;) {
    const MODE_INFO *const candidate_mi =
        xd->mi[(row_offset + i) * xd->mi_stride + col_offset];
    const MB_MODE_INFO *const candidate = &candidate_mi->mbmi;
355
356
357
    const int candidate_bsize = candidate->sb_type;
    const int n8_h = mi_size_high[candidate_bsize];
    int len = AOMMIN(xd->n8_h, n8_h);
Yunqing Wang's avatar
Yunqing Wang committed
358
359
360
361
    if (use_step_16)
      len = AOMMAX(n8_h_16, len);
    else if (abs(col_offset) > 1)
      len = AOMMAX(len, n8_h_8);
362
363
364
365
366
367
368
369
370
371
372

    int weight = 2;
    if (xd->n8_h >= n8_h_8 && xd->n8_h <= n8_h) {
      int inc = AOMMIN(-max_col_offset + col_offset + 1,
                       mi_size_wide[candidate_bsize]);
      // Obtain range used in weight calculation.
      weight = AOMMAX(weight, (inc << shift));
      // Update processed cols.
      *processed_cols = inc - col_offset - 1;
    }

RogerZhou's avatar
RogerZhou committed
373
374
375
#if CONFIG_AMVR
    newmv_count += add_ref_mv_candidate(
        candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
376
377
378
379
        cm->allow_high_precision_mv, len, block,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
        gm_mv_candidates, cm->global_motion,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
380
381
382
        col_offset, weight, cm->cur_frame_mv_precision_level,
        xd->mi[0]->mbmi.sb_type, mi_row, mi_col, xd->plane[0].subsampling_x,
        xd->plane[0].subsampling_y);
RogerZhou's avatar
RogerZhou committed
383
#else
Yunqing Wang's avatar
Yunqing Wang committed
384
385
386
    newmv_count += add_ref_mv_candidate(
        candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
        cm->allow_high_precision_mv, len, block,
387
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
388
        gm_mv_candidates, cm->global_motion,
389
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
390
391
        col_offset, weight, xd->mi[0]->mbmi.sb_type, mi_row, mi_col,
        xd->plane[0].subsampling_x, xd->plane[0].subsampling_y);
RogerZhou's avatar
RogerZhou committed
392
#endif
Yunqing Wang's avatar
Yunqing Wang committed
393
    i += len;
394
  }
395
396

  return newmv_count;
397
398
}

Yaowu Xu's avatar
Yaowu Xu committed
399
static uint8_t scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
400
                             const int mi_row, const int mi_col, int block,
clang-format's avatar
clang-format committed
401
402
                             const MV_REFERENCE_FRAME rf[2], int row_offset,
                             int col_offset, CANDIDATE_MV *ref_mv_stack,
403
404
405
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                             int_mv *gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
406
                             uint8_t *refmv_count) {
407
408
  const TileInfo *const tile = &xd->tile;
  POSITION mi_pos;
409
  uint8_t newmv_count = 0;
410
411
412
413

  mi_pos.row = row_offset;
  mi_pos.col = col_offset;

414
  if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos) &&
415
      *refmv_count < MAX_REF_MV_STACK_SIZE) {
416
417
418
    const MODE_INFO *const candidate_mi =
        xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col];
    const MB_MODE_INFO *const candidate = &candidate_mi->mbmi;
419
    const int len = mi_size_wide[BLOCK_8X8];
420

RogerZhou's avatar
RogerZhou committed
421
422
423
#if CONFIG_AMVR
    newmv_count += add_ref_mv_candidate(
        candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
424
425
426
427
        cm->allow_high_precision_mv, len, block,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
        gm_mv_candidates, cm->global_motion,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
428
429
430
        mi_pos.col, 2, cm->cur_frame_mv_precision_level,
        xd->mi[0]->mbmi.sb_type, mi_row, mi_col, xd->plane[0].subsampling_x,
        xd->plane[0].subsampling_y);
RogerZhou's avatar
RogerZhou committed
431
#else
Yunqing Wang's avatar
Yunqing Wang committed
432
433
434
    newmv_count += add_ref_mv_candidate(
        candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
        cm->allow_high_precision_mv, len, block,
435
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
436
        gm_mv_candidates, cm->global_motion,
437
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
438
439
        mi_pos.col, 2, xd->mi[0]->mbmi.sb_type, mi_row, mi_col,
        xd->plane[0].subsampling_x, xd->plane[0].subsampling_y);
RogerZhou's avatar
RogerZhou committed
440
#endif
441
  }  // Analyze a single 8x8 block motion information.
Yaowu Xu's avatar
Yaowu Xu committed
442

443
  return newmv_count;
444
445
}

446
447
448
449
450
static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd,
                         int mi_row, int mi_col, int bs) {
  const int sb_mi_size = mi_size_wide[cm->sb_size];
  const int mask_row = mi_row & (sb_mi_size - 1);
  const int mask_col = mi_col & (sb_mi_size - 1);
451

452
  // In a split partition all apart from the bottom right has a top right
453
  int has_tr = !((mask_row & bs) && (mask_col & bs));
454

455
456
  // bs > 0 and bs is a power of 2
  assert(bs > 0 && !(bs & (bs - 1)));
457

458
459
460
  // For each 4x4 group of blocks, when the bottom right is decoded the blocks
  // to the right have not been decoded therefore the bottom right does
  // not have a top right
461
  while (bs < sb_mi_size) {
462
463
    if (mask_col & bs) {
      if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) {
464
        has_tr = 0;
465
466
467
468
469
470
471
        break;
      }
    } else {
      break;
    }
    bs <<= 1;
  }
472

473
  // The left hand of two vertical rectangles always has a top right (as the
474
  // block above will have been decoded)
475
  if (xd->n8_w < xd->n8_h)
clang-format's avatar
clang-format committed
476
    if (!xd->is_sec_rect) has_tr = 1;
477

478
479
  // The bottom of two horizontal rectangles never has a top right (as the block
  // to the right won't have been decoded)
480
  if (xd->n8_w > xd->n8_h)
clang-format's avatar
clang-format committed
481
    if (xd->is_sec_rect) has_tr = 0;
482

483
484
485
486
#if CONFIG_EXT_PARTITION_TYPES && !CONFIG_EXT_PARTITION_TYPES_AB
  // The bottom left square of a Vertical A (in the old format) does
  // not have a top right as it is decoded before the right hand
  // rectangle of the partition
487
  if (xd->mi[0]->mbmi.partition == PARTITION_VERT_A)
488
    if ((mask_row & bs) && !(mask_col & bs)) has_tr = 0;
489
490
#endif  // CONFIG_EXT_PARTITION_TYPES

491
492
493
  return has_tr;
}

494
#if CONFIG_MFMV
495
496
497
498
499
500
501
502
503
static int check_sb_border(const AV1_COMMON *cm, const int mi_row,
                           const int mi_col, const int row_offset,
                           const int col_offset) {
  const int sb_mi_size = mi_size_wide[cm->sb_size];
  const int row = mi_row & (sb_mi_size - 1);
  const int col = mi_col & (sb_mi_size - 1);

  if (row + row_offset < 0 || row + row_offset >= sb_mi_size ||
      col + col_offset < 0 || col + col_offset >= sb_mi_size)
504
505
506
507
508
    return 0;

  return 1;
}

509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
static int add_tpl_ref_mv(const AV1_COMMON *cm,
                          const MV_REF *prev_frame_mvs_base,
                          const MACROBLOCKD *xd, int mi_row, int mi_col,
                          MV_REFERENCE_FRAME ref_frame, int blk_row,
                          int blk_col, uint8_t *refmv_count,
                          CANDIDATE_MV *ref_mv_stack, int16_t *mode_context) {
  (void)prev_frame_mvs_base;
  POSITION mi_pos;
  int idx;
  int coll_blk_count = 0;
  const int weight_unit = 1;  // mi_size_wide[BLOCK_8X8];

#if CONFIG_MV_COMPRESS
  mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1;
  mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1;
#else
  mi_pos.row = blk_row;
  mi_pos.col = blk_col;
#endif

  if (!is_inside(&xd->tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos))
    return coll_blk_count;

532
  const TPL_MV_REF *prev_frame_mvs =
Jingning Han's avatar
Jingning Han committed
533
      cm->tpl_mvs + ((mi_row + mi_pos.row) >> 1) * (cm->mi_stride >> 1) +
534
      ((mi_col + mi_pos.col) >> 1);
Jingning Han's avatar
Jingning Han committed
535

536
537
538
539
540
541
542
543
544
545
  MV_REFERENCE_FRAME rf[2];
  av1_set_ref_frame(rf, ref_frame);

  if (rf[1] == NONE_FRAME) {
    for (int i = 0; i < MFMV_STACK_SIZE; ++i) {
      if (prev_frame_mvs->mfmv[ref_frame - LAST_FRAME][i].as_int !=
          INVALID_MV) {
        int_mv this_refmv = prev_frame_mvs->mfmv[ref_frame - LAST_FRAME][i];
        lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv);

546
547
548
549
        if (blk_row == 0 && blk_col == 0)
          if (abs(this_refmv.as_mv.row) >= 16 ||
              abs(this_refmv.as_mv.col) >= 16)
            mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581

        for (idx = 0; idx < *refmv_count; ++idx)
          if (abs(this_refmv.as_mv.row - ref_mv_stack[idx].this_mv.as_mv.row) <
                  4 &&
              abs(this_refmv.as_mv.col - ref_mv_stack[idx].this_mv.as_mv.col) <
                  4)
            break;

        if (idx < *refmv_count) ref_mv_stack[idx].weight += 2 * weight_unit;

        if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
          ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
          // TODO(jingning): Hard coded context number. Need to make it better
          // sense.
          ref_mv_stack[idx].pred_diff[0] = 1;
          ref_mv_stack[idx].weight = 2 * weight_unit;
          ++(*refmv_count);
        }

        ++coll_blk_count;
      }
    }
  } else {
    // Process compound inter mode
    for (int i = 0; i < MFMV_STACK_SIZE; ++i) {
      if (prev_frame_mvs->mfmv[rf[0] - LAST_FRAME][i].as_int != INVALID_MV &&
          prev_frame_mvs->mfmv[rf[1] - LAST_FRAME][i].as_int != INVALID_MV) {
        int_mv this_refmv = prev_frame_mvs->mfmv[rf[0] - LAST_FRAME][i];
        int_mv comp_refmv = prev_frame_mvs->mfmv[rf[1] - LAST_FRAME][i];
        lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv);
        lower_mv_precision(&comp_refmv.as_mv, cm->allow_high_precision_mv);

582
583
584
585
586
587
        if (blk_row == 0 && blk_col == 0)
          if (abs(this_refmv.as_mv.row) >= 16 ||
              abs(this_refmv.as_mv.col) >= 16 ||
              abs(comp_refmv.as_mv.row) >= 16 ||
              abs(comp_refmv.as_mv.col) >= 16)
            mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620

        for (idx = 0; idx < *refmv_count; ++idx)
          if (abs(this_refmv.as_mv.row - ref_mv_stack[idx].this_mv.as_mv.row) <
                  4 &&
              abs(this_refmv.as_mv.col - ref_mv_stack[idx].this_mv.as_mv.col) <
                  4 &&
              abs(comp_refmv.as_mv.row - ref_mv_stack[idx].comp_mv.as_mv.row) <
                  4 &&
              abs(comp_refmv.as_mv.col - ref_mv_stack[idx].comp_mv.as_mv.col) <
                  4)
            break;

        if (idx < *refmv_count) ref_mv_stack[idx].weight += 2 * weight_unit;

        if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
          ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
          ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int;
          // TODO(jingning): Hard coded context number. Need to make it better
          // sense.
          ref_mv_stack[idx].pred_diff[0] = 1;
          ref_mv_stack[idx].pred_diff[1] = 1;
          ref_mv_stack[idx].weight = 2 * weight_unit;
          ++(*refmv_count);
        }

        ++coll_blk_count;
      }
    }
  }

  return coll_blk_count;
}
#else
621
622
static int add_col_ref_mv(const AV1_COMMON *cm,
                          const MV_REF *prev_frame_mvs_base,
623
624
625
                          int prev_frame_mvs_stride, const MACROBLOCKD *xd,
                          int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame,
                          int blk_row, int blk_col, uint8_t *refmv_count,
626
                          CANDIDATE_MV *ref_mv_stack, int16_t *mode_context) {
627
628
#if CONFIG_TMV
  const MV_REF *prev_frame_mvs = prev_frame_mvs_base +
Yunqing Wang's avatar
Yunqing Wang committed
629
630
                                 (blk_row >> 1) * prev_frame_mvs_stride +
                                 (blk_col >> 1);
631
#else
632
  const MV_REF *prev_frame_mvs =
633
634
      prev_frame_mvs_base + blk_row * prev_frame_mvs_stride + blk_col;
#endif
635
636
637
  POSITION mi_pos;
  int ref, idx;
  int coll_blk_count = 0;
638
  const int weight_unit = mi_size_wide[BLOCK_8X8];
639

640
641
642
643
#if CONFIG_TMV
  mi_pos.row = blk_row;
  mi_pos.col = blk_col;
#else
644
645
646
647
#if CONFIG_MV_COMPRESS
  mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1;
  mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1;
#else
648
649
  mi_pos.row = blk_row;
  mi_pos.col = blk_col;
650
#endif
651
#endif  // CONFIG_TMV
652

653
  if (!is_inside(&xd->tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos))
654
    return coll_blk_count;
655
656
657
  for (ref = 0; ref < 2; ++ref) {
    if (prev_frame_mvs->ref_frame[ref] == ref_frame) {
      int_mv this_refmv = prev_frame_mvs->mv[ref];
RogerZhou's avatar
RogerZhou committed
658
659
660
661
#if CONFIG_AMVR
      lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv,
                         cm->cur_frame_mv_precision_level);
#else
662
      lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv);
RogerZhou's avatar
RogerZhou committed
663
#endif
664
665
666
667
668
669
670
671

#if CONFIG_OPT_REF_MV
      if (blk_row == 0 && blk_col == 0)
#endif
      {
        if (abs(this_refmv.as_mv.row) >= 16 || abs(this_refmv.as_mv.col) >= 16)
          mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
      }
672
673
674
675

      for (idx = 0; idx < *refmv_count; ++idx)
        if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break;

676
      if (idx < *refmv_count) ref_mv_stack[idx].weight += 2 * weight_unit;
677
678
679

      if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
        ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
680
681
        ref_mv_stack[idx].pred_diff[0] =
            av1_get_pred_diff_ctx(prev_frame_mvs->pred_mv[ref], this_refmv);
682
        ref_mv_stack[idx].weight = 2 * weight_unit;
683
684
685
686
687
688
689
690
691
        ++(*refmv_count);
      }

      ++coll_blk_count;
    }
  }

  return coll_blk_count;
}
692
#endif
693

Yaowu Xu's avatar
Yaowu Xu committed
694
static void setup_ref_mv_list(const AV1_COMMON *cm, const MACROBLOCKD *xd,
695
                              MV_REFERENCE_FRAME ref_frame,
clang-format's avatar
clang-format committed
696
                              uint8_t *refmv_count, CANDIDATE_MV *ref_mv_stack,
697
698
699
700
701
702
                              int_mv *mv_ref_list,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                              int_mv *gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                              int block, int mi_row, int mi_col,
                              int16_t *mode_context) {
703
  int idx, nearest_refmv_count = 0;
704
  uint8_t newmv_count = 0;
705
706
707
  CANDIDATE_MV tmp_mv;
  int len, nr_len;

708
709
710
711
712
713
714
715
716
717
718
#if CONFIG_TMV
  const int prev_frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1);
  const int tmi_row = mi_row & 0xfffe;
  const int tmi_col = mi_col & 0xfffe;
  const MV_REF *const prev_frame_mvs_base =
      cm->use_prev_frame_mvs
          ? cm->prev_frame->mvs + (tmi_row >> 1) * prev_frame_mvs_stride +
                (tmi_col >> 1)
          : NULL;
#else
  const int prev_frame_mvs_stride = cm->mi_cols;
719
720
721
#if CONFIG_MV_COMPRESS
  const MV_REF *const prev_frame_mvs_base =
      cm->use_prev_frame_mvs
722
723
          ? cm->prev_frame->mvs +
                (((mi_row >> 1) << 1) + 1) * prev_frame_mvs_stride +
724
725
726
                ((mi_col >> 1) << 1) + 1
          : NULL;
#else
clang-format's avatar
clang-format committed
727
728
  const MV_REF *const prev_frame_mvs_base =
      cm->use_prev_frame_mvs
729
          ? cm->prev_frame->mvs + mi_row * prev_frame_mvs_stride + mi_col
clang-format's avatar
clang-format committed
730
          : NULL;
731
#endif
732
#endif  // CONFIG_TMV
733

734
  const int bs = AOMMAX(xd->n8_w, xd->n8_h);
735
  const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs);
Jingning Han's avatar
Jingning Han committed
736
737
  MV_REFERENCE_FRAME rf[2];

Yunqing Wang's avatar
Yunqing Wang committed
738
  const TileInfo *const tile = &xd->tile;
739
740
741
742
743
  int max_row_offset = 0, max_col_offset = 0;
  const int row_adj = (xd->n8_h < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01);
  const int col_adj = (xd->n8_w < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01);
  int processed_rows = 0;
  int processed_cols = 0;
Yunqing Wang's avatar
Yunqing Wang committed
744
745
  int row_offset, col_offset;

746
  av1_set_ref_frame(rf, ref_frame);
747
  mode_context[ref_frame] = 0;
748
  *refmv_count = 0;
749

750
751
752
  // Find valid maximum row/col offset.
  if (xd->up_available) {
    max_row_offset = -(MVREF_ROWS << 1) + row_adj;
Yunqing Wang's avatar
Yunqing Wang committed
753
754
755
    max_row_offset =
        find_valid_row_offset(tile, mi_row, cm->mi_rows, cm, max_row_offset);
  }
756
757
758

  if (xd->left_available) {
    max_col_offset = -(MVREF_COLS << 1) + col_adj;
Yunqing Wang's avatar
Yunqing Wang committed
759
760
    max_col_offset = find_valid_col_offset(tile, mi_col, max_col_offset);
  }
761

762
763
  // Scan the first above row mode info. row_offset = -1;
  if (abs(max_row_offset) >= 1)
Yunqing Wang's avatar
Yunqing Wang committed
764
765
    newmv_count += scan_row_mbmi(cm, xd, mi_row, mi_col, block, rf, -1,
                                 ref_mv_stack, refmv_count,
766
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
767
                                 gm_mv_candidates,
768
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
769
                                 max_row_offset, &processed_rows);
770
771
  // Scan the first left column mode info. col_offset = -1;
  if (abs(max_col_offset) >= 1)
Yunqing Wang's avatar
Yunqing Wang committed
772
773
    newmv_count += scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -1,
                                 ref_mv_stack, refmv_count,
774
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
775
                                 gm_mv_candidates,
776
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Yunqing Wang's avatar
Yunqing Wang committed
777
                                 max_col_offset, &processed_cols);
778
779
  // Check top-right boundary
  if (has_tr)
780
    newmv_count += scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1,
781
782
783
784
785
                                 xd->n8_w, ref_mv_stack,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                                 gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                                 refmv_count);
786

787
  nearest_refmv_count = *refmv_count;
788

789
  for (idx = 0; idx < nearest_refmv_count; ++idx)
790
    ref_mv_stack[idx].weight += REF_CAT_LEVEL;
791
792
793
794

#if CONFIG_MFMV
  int blk_row, blk_col;
  int coll_blk_count = 0;
Jingning Han's avatar
Jingning Han committed
795
796
  int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->n8_h);
  int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->n8_w);
797
798

  int tpl_sample_pos[9][2] = {
Jingning Han's avatar
Jingning Han committed
799
800
801
    { -2, hoffset }, { 0, hoffset },  { voffset, hoffset },
    { voffset, 0 },  { voffset, -2 }, { voffset, -4 },
    { -4, hoffset }, { voffset, 4 },  { 2, hoffset + 4 },
802
803
804
  };
  int i;

Jingning Han's avatar
Jingning Han committed
805
806
  for (blk_row = 0; blk_row < xd->n8_h; blk_row += mi_size_high[BLOCK_8X8]) {
    for (blk_col = 0; blk_col < xd->n8_w; blk_col += mi_size_wide[BLOCK_8X8]) {
807
808
      // (TODO: yunqing) prev_frame_mvs_base is not used here, tpl_mvs is used.
      // Can be modified the same way.
809
810
811
812
      int is_available = add_tpl_ref_mv(
          cm, prev_frame_mvs_base, xd, mi_row, mi_col, ref_frame, blk_row,
          blk_col, refmv_count, ref_mv_stack, mode_context);
      if (blk_row == 0 && blk_col == 0) coll_blk_count = is_available;
813
814
815
816
817
818
819
820
    }
  }

  if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);

  for (i = 0; i < 9; ++i) {
    blk_row = tpl_sample_pos[i][0];
    blk_col = tpl_sample_pos[i][1];
821

822
    if (!check_sb_border(cm, mi_row, mi_col, blk_row, blk_col)) continue;
823
824
    // (TODO: yunqing) prev_frame_mvs_base is not used here, tpl_mvs is used.
    // Can be modified the same way.
825
826
827
828
829
    coll_blk_count += add_tpl_ref_mv(cm, prev_frame_mvs_base, xd, mi_row,
                                     mi_col, ref_frame, blk_row, blk_col,
                                     refmv_count, ref_mv_stack, mode_context);
  }
#else
830
#if CONFIG_TEMPMV_SIGNALING
831
  if (cm->use_prev_frame_mvs && rf[1] == NONE_FRAME)
832
#else
clang-format's avatar
clang-format committed
833
  if (prev_frame_mvs_base && cm->show_frame && cm->last_show_frame &&
834
      rf[1] == NONE_FRAME)
835
#endif
836
  {
837
    int blk_row, blk_col;
838
    int coll_blk_count = 0;
839
840
841
    const int mi_step = (xd->n8_w == 1 || xd->n8_h == 1)
                            ? mi_size_wide[BLOCK_8X8]
                            : mi_size_wide[BLOCK_16X16];
842
843

#if CONFIG_TPL_MV
844
845
    // Modified sample positions to be consistent with frame_mvs
    // spatial resolution.
846
847
848
849
850
851
852
853
    int tpl_sample_pos[5][2] = { { -1, xd->n8_w },
                                 { 0, xd->n8_w },
                                 { xd->n8_h, xd->n8_w },
                                 { xd->n8_h, 0 },
                                 { xd->n8_h, -1 } };
    int i;
#endif

854
855
    for (blk_row = 0; blk_row < xd->n8_h; blk_row += mi_step) {
      for (blk_col = 0; blk_col < xd->n8_w; blk_col += mi_step) {
856
857
858
859
860
861
862
863
864
865
866
#if CONFIG_TMV
        int is_available =
            add_col_ref_mv(cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd,
                           tmi_row, tmi_col, ref_frame, blk_row, blk_col,
                           refmv_count, ref_mv_stack, mode_context);
#else
        int is_available =
            add_col_ref_mv(cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd,
                           mi_row, mi_col, ref_frame, blk_row, blk_col,
                           refmv_count, ref_mv_stack, mode_context);
#endif  // CONFIG_TMV
867
868
869
870
871
#if CONFIG_OPT_REF_MV
        if (blk_row == 0 && blk_col == 0) coll_blk_count = is_available;
#else
        coll_blk_count += is_available;
#endif
872
873
      }
    }
874
875
876
877
878

#if CONFIG_TPL_MV
    for (i = 0; i < 5; ++i) {
      blk_row = tpl_sample_pos[i][0];
      blk_col = tpl_sample_pos[i][1];
879
880
881
882
883
884
885
886
887
#if CONFIG_TMV
      coll_blk_count += add_col_ref_mv(
          cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd, tmi_row, tmi_col,
          ref_frame, blk_row, blk_col, refmv_count, ref_mv_stack, mode_context);
#else
      coll_blk_count += add_col_ref_mv(
          cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd, mi_row, mi_col,
          ref_frame, blk_row, blk_col, refmv_count, ref_mv_stack, mode_context);
#endif  // CONFIG_TMV
888
889
890
    }
#endif

891
892
    if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
  } else {
893
    mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
894
  }
895
#endif
896

897
  // Scan the second outer area.
Deng's avatar
Deng committed
898
  scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, -1, ref_mv_stack,
899
900
901
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
Deng's avatar
Deng committed
902
                refmv_count);
Yunqing Wang's avatar
Yunqing Wang committed
903
  for (idx = 2; idx <= MVREF_ROWS; ++idx) {
904
905
    row_offset = -(idx << 1) + 1 + row_adj;
    col_offset = -(idx << 1) + 1 + col_adj;
Yunqing Wang's avatar
Yunqing Wang committed
906

907
908
    if (abs(row_offset) <= abs(max_row_offset) &&
        abs(row_offset) > processed_rows)
Yunqing Wang's avatar
Yunqing Wang committed
909
      scan_row_mbmi(cm, xd, mi_row, mi_col, block, rf, row_offset, ref_mv_stack,
910
911
912
913
914
                    refmv_count,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                    gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                    max_row_offset, &processed_rows);
915
916
917

    if (abs(col_offset) <= abs(max_col_offset) &&
        abs(col_offset) > processed_cols)
Yunqing Wang's avatar
Yunqing Wang committed
918
      scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, col_offset, ref_mv_stack,
919
920
921
922
923
                    refmv_count,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                    gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                    max_col_offset, &processed_cols);
Yunqing Wang's avatar
Yunqing Wang committed
924
925
  }

926
927
928
  col_offset = -(MVREF_COLS << 1) + 1 + col_adj;
  if (abs(col_offset) <= abs(max_col_offset) &&
      abs(col_offset) > processed_cols)
Yunqing Wang's avatar
Yunqing Wang committed
929
    scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, col_offset, ref_mv_stack,
930
931
932
933
934
                  refmv_count,
#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                  gm_mv_candidates,
#endif  // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV
                  max_col_offset, &processed_cols);
935

936
  switch (nearest_refmv_count) {
937
938
    case 0: mode_context[ref_frame] |= 0;
#if !CONFIG_OPT_REF_MV
clang-format's avatar
clang-format committed
939
      if (*refmv_count >= 1) mode_context[ref_frame] |= 1;
940
941
942
943
      if (*refmv_count == 1)
        mode_context[ref_frame] |= (1 << REFMV_OFFSET);
      else if (*refmv_count >= 2)
        mode_context[ref_frame] |= (2 << REFMV_OFFSET);
944
#endif
945
      break;
946
947
948
949
    case 1: mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3;
#if CONFIG_OPT_REF_MV
      mode_context[ref_frame] |= (3 << REFMV_OFFSET);
#else
950
951
952
953
      if (*refmv_count == 1)
        mode_context[ref_frame] |= (3 << REFMV_OFFSET);
      else if (*refmv_count >= 2)
        mode_context[ref_frame] |= (4 << REFMV_OFFSET);
954
#endif
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
      break;

    case 2:
    default:
      if (newmv_count >= 2)
        mode_context[ref_frame] |= 4;
      else if (newmv_count == 1)
        mode_context[ref_frame] |= 5;
      else
        mode_context[ref_frame] |= 6;

      mode_context[ref_frame] |= (5 << REFMV_OFFSET);
      break;
  }

970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
  // Rank the likelihood and assign nearest and near mvs.
  len = nearest_refmv_count;
  while (len > 0) {
    nr_len = 0;
    for (idx = 1; idx < len; ++idx) {
      if (ref_mv_stack[idx - 1].weight < ref_mv_stack[idx].weight) {
        tmp_mv = ref_mv_stack[idx - 1];
        ref_mv_stack[idx - 1] = ref_mv_stack[idx];
        ref_mv_stack[idx] = tmp_mv;
        nr_len = idx;
      }
    }
    len = nr_len;
  }

985
  len = *refmv_count;
986
987
988
989
990
991
992
993
994
995
996
997
998
  while (len > nearest_refmv_count) {
    nr_len = nearest_refmv_count;
    for (idx = nearest_refmv_count + 1; idx < len; ++idx) {
      if (ref_mv_stack[idx - 1].weight < ref_mv_stack[idx].weight) {
        tmp_mv = ref_mv_stack[idx - 1];
        ref_mv_stack[idx - 1] = ref_mv_stack[idx];
        ref_mv_stack[idx] = tmp_mv;
        nr_len = idx;
      }
    }
    len = nr_len;
  }

Emil Keyder's avatar
Emil Keyder committed
999
  if (rf[1] > NONE_FRAME) {
1000
    for (idx = 0; idx < *refmv_count; ++idx) {