mvref_common.c 40.5 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
#if CONFIG_REF_MV
18

clang-format's avatar
clang-format committed
19
20
21
22
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, int col) {
Jingning Han's avatar
Jingning Han committed
23
24
  int index = 0, ref;
  int newmv_count = 0;
25
26
27
28
29
#if CONFIG_CB4X4
  const int unify_bsize = 1;
#else
  const int unify_bsize = 0;
#endif
Jingning Han's avatar
Jingning Han committed
30

Emil Keyder's avatar
Emil Keyder committed
31
  if (rf[1] == NONE_FRAME) {
Jingning Han's avatar
Jingning Han committed
32
33
34
    // single reference frame
    for (ref = 0; ref < 2; ++ref) {
      if (candidate->ref_frame[ref] == rf[0]) {
clang-format's avatar
clang-format committed
35
        int_mv this_refmv = get_sub_block_mv(candidate_mi, ref, col, block);
36
37
        lower_mv_precision(&this_refmv.as_mv, use_hp);

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

Yaowu Xu's avatar
Yaowu Xu committed
41
        if (index < *refmv_count) ref_mv_stack[index].weight += 2 * len;
42

Jingning Han's avatar
Jingning Han committed
43
44
45
        // Add a new item to the list.
        if (index == *refmv_count) {
          ref_mv_stack[index].this_mv = this_refmv;
46
47
          ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx(
              get_sub_block_pred_mv(candidate_mi, ref, col, block), this_refmv);
Yaowu Xu's avatar
Yaowu Xu committed
48
          ref_mv_stack[index].weight = 2 * len;
Jingning Han's avatar
Jingning Han committed
49
          ++(*refmv_count);
50

51
52
53
#if CONFIG_EXT_INTER
          if (candidate->mode == NEWMV || candidate->mode == NEWFROMNEARMV)
#else
Jingning Han's avatar
Jingning Han committed
54
          if (candidate->mode == NEWMV)
55
#endif  // CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
56
57
58
            ++newmv_count;
        }

59
60
        if (candidate_mi->mbmi.sb_type < BLOCK_8X8 && block >= 0 &&
            !unify_bsize) {
Jingning Han's avatar
Jingning Han committed
61
          int alt_block = 3 - block;
clang-format's avatar
clang-format committed
62
          this_refmv = get_sub_block_mv(candidate_mi, ref, col, alt_block);
63
64
          lower_mv_precision(&this_refmv.as_mv, use_hp);

65
          for (index = 0; index < *refmv_count; ++index)
clang-format's avatar
clang-format committed
66
            if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break;
67

Yaowu Xu's avatar
Yaowu Xu committed
68
          if (index < *refmv_count) ref_mv_stack[index].weight += len;
69
70
71
72

          // Add a new item to the list.
          if (index == *refmv_count) {
            ref_mv_stack[index].this_mv = this_refmv;
73
74
75
            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
76
            ref_mv_stack[index].weight = len;
77
            ++(*refmv_count);
78

79
#if CONFIG_EXT_INTER
clang-format's avatar
clang-format committed
80
            if (candidate->mode == NEWMV || candidate->mode == NEWFROMNEARMV)
81
#else
82
            if (candidate->mode == NEWMV)
83
#endif  // CONFIG_EXT_INTER
84
              ++newmv_count;
85
86
87
          }
        }
      }
Jingning Han's avatar
Jingning Han committed
88
89
90
    }
  } else {
    // compound reference frame
clang-format's avatar
clang-format committed
91
    if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) {
92
      int_mv this_refmv[2];
Jingning Han's avatar
Jingning Han committed
93

94
95
      for (ref = 0; ref < 2; ++ref) {
        this_refmv[ref] = get_sub_block_mv(candidate_mi, ref, col, block);
96
        lower_mv_precision(&this_refmv[ref].as_mv, use_hp);
97
      }
98

Jingning Han's avatar
Jingning Han committed
99
100
101
102
103
      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
104
      if (index < *refmv_count) ref_mv_stack[index].weight += 2 * len;
Jingning Han's avatar
Jingning Han committed
105
106
107
108
109

      // 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];
110
111
112
113
        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]);
Yaowu Xu's avatar
Yaowu Xu committed
114
        ref_mv_stack[index].weight = 2 * len;
Jingning Han's avatar
Jingning Han committed
115
116
        ++(*refmv_count);

117
118
119
#if CONFIG_EXT_INTER
        if (candidate->mode == NEW_NEWMV)
#else
Jingning Han's avatar
Jingning Han committed
120
        if (candidate->mode == NEWMV)
121
#endif  // CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
122
123
124
          ++newmv_count;
      }

125
126
      if (candidate_mi->mbmi.sb_type < BLOCK_8X8 && block >= 0 &&
          !unify_bsize) {
Jingning Han's avatar
Jingning Han committed
127
128
129
130
        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);

131
132
133
        for (ref = 0; ref < 2; ++ref)
          lower_mv_precision(&this_refmv[ref].as_mv, use_hp);

Jingning Han's avatar
Jingning Han committed
134
135
136
137
138
        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
139
        if (index < *refmv_count) ref_mv_stack[index].weight += len;
Jingning Han's avatar
Jingning Han committed
140
141
142
143
144

        // 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];
145
146
147
148
149
150
          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
151
          ref_mv_stack[index].weight = len;
Jingning Han's avatar
Jingning Han committed
152
153
          ++(*refmv_count);

154
155
156
#if CONFIG_EXT_INTER
          if (candidate->mode == NEW_NEWMV)
#else
Jingning Han's avatar
Jingning Han committed
157
          if (candidate->mode == NEWMV)
158
#endif  // CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
159
160
161
162
163
164
165
166
            ++newmv_count;
        }
      }
    }
  }
  return newmv_count;
}

Yaowu Xu's avatar
Yaowu Xu committed
167
static uint8_t scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
168
                             const int mi_row, const int mi_col, int block,
clang-format's avatar
clang-format committed
169
170
                             const MV_REFERENCE_FRAME rf[2], int row_offset,
                             CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count) {
Jingning Han's avatar
Jingning Han committed
171
172
173
  const TileInfo *const tile = &xd->tile;
  int i;
  uint8_t newmv_count = 0;
174
#if CONFIG_CB4X4
175
176
177
  const int bsize = xd->mi[0]->mbmi.sb_type;
  const int mi_offset =
      bsize < BLOCK_8X8 ? mi_size_wide[BLOCK_4X4] : mi_size_wide[BLOCK_8X8];
178
  // TODO(jingning): Revisit this part after cb4x4 is stable.
179
180
181
  if (bsize >= BLOCK_8X8) row_offset *= 2;
#else
  const int mi_offset = mi_size_wide[BLOCK_8X8];
182
#endif
Jingning Han's avatar
Jingning Han committed
183
184
185

  for (i = 0; i < xd->n8_w && *refmv_count < MAX_REF_MV_STACK_SIZE;) {
    POSITION mi_pos;
186
187
188
#if CONFIG_CB4X4
    const int use_step_16 = (xd->n8_w >= 16);
#else
189
    const int use_step_16 = (xd->n8_w >= 8);
190
#endif
191

Jingning Han's avatar
Jingning Han committed
192
193
    mi_pos.row = row_offset;
    mi_pos.col = i;
Geza Lore's avatar
Geza Lore committed
194
    if (is_inside(tile, mi_col, mi_row, &mi_pos)) {
Jingning Han's avatar
Jingning Han committed
195
196
197
      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;
198
      int len = AOMMIN(xd->n8_w, mi_size_wide[candidate->sb_type]);
199
      if (use_step_16) len = AOMMAX(mi_size_wide[BLOCK_16X16], len);
clang-format's avatar
clang-format committed
200
201
202
      newmv_count += add_ref_mv_candidate(
          candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
          cm->allow_high_precision_mv, len, block, mi_pos.col);
203
204
      i += len;
    } else {
205
      if (use_step_16)
206
        i += (mi_offset << 1);
207
      else
208
        i += mi_offset;
209
210
    }
  }
211
212

  return newmv_count;
213
214
}

Yaowu Xu's avatar
Yaowu Xu committed
215
static uint8_t scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
216
                             const int mi_row, const int mi_col, int block,
clang-format's avatar
clang-format committed
217
218
                             const MV_REFERENCE_FRAME rf[2], int col_offset,
                             CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count) {
219
220
  const TileInfo *const tile = &xd->tile;
  int i;
221
  uint8_t newmv_count = 0;
222
#if CONFIG_CB4X4
223
224
225
226
227
228
  const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
  const int mi_offset =
      (bsize < BLOCK_8X8) ? mi_size_high[BLOCK_4X4] : mi_size_high[BLOCK_8X8];
  if (bsize >= BLOCK_8X8) col_offset *= 2;
#else
  const int mi_offset = mi_size_wide[BLOCK_8X8];
229
#endif
230
231
232

  for (i = 0; i < xd->n8_h && *refmv_count < MAX_REF_MV_STACK_SIZE;) {
    POSITION mi_pos;
233
234
235
#if CONFIG_CB4X4
    const int use_step_16 = (xd->n8_h >= 16);
#else
236
    const int use_step_16 = (xd->n8_h >= 8);
237
#endif
238

239
240
    mi_pos.row = i;
    mi_pos.col = col_offset;
Geza Lore's avatar
Geza Lore committed
241
    if (is_inside(tile, mi_col, mi_row, &mi_pos)) {
242
243
244
      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;
245
      int len = AOMMIN(xd->n8_h, mi_size_high[candidate->sb_type]);
246
      if (use_step_16) len = AOMMAX(mi_size_high[BLOCK_16X16], len);
clang-format's avatar
clang-format committed
247
248
249
      newmv_count += add_ref_mv_candidate(
          candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
          cm->allow_high_precision_mv, len, block, mi_pos.col);
250
251
      i += len;
    } else {
252
      if (use_step_16)
253
        i += (mi_offset << 1);
254
      else
255
        i += mi_offset;
256
257
    }
  }
258
259

  return newmv_count;
260
261
}

Yaowu Xu's avatar
Yaowu Xu committed
262
static uint8_t scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
263
                             const int mi_row, const int mi_col, int block,
clang-format's avatar
clang-format committed
264
265
                             const MV_REFERENCE_FRAME rf[2], int row_offset,
                             int col_offset, CANDIDATE_MV *ref_mv_stack,
266
                             uint8_t *refmv_count) {
267
268
  const TileInfo *const tile = &xd->tile;
  POSITION mi_pos;
269
  uint8_t newmv_count = 0;
270
271
272
273

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

Geza Lore's avatar
Geza Lore committed
274
  if (is_inside(tile, mi_col, mi_row, &mi_pos) &&
275
276
277
278
      *refmv_count < MAX_REF_MV_STACK_SIZE) {
    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;
279
    const int len = mi_size_wide[BLOCK_8X8];
280

clang-format's avatar
clang-format committed
281
282
283
    newmv_count += add_ref_mv_candidate(
        candidate_mi, candidate, rf, refmv_count, ref_mv_stack,
        cm->allow_high_precision_mv, len, block, mi_pos.col);
284
  }  // Analyze a single 8x8 block motion information.
Yaowu Xu's avatar
Yaowu Xu committed
285

286
  return newmv_count;
287
288
}

clang-format's avatar
clang-format committed
289
290
static int has_top_right(const MACROBLOCKD *xd, int mi_row, int mi_col,
                         int bs) {
291
292
293
  const int mask_row = mi_row & MAX_MIB_MASK;
  const int mask_col = mi_col & MAX_MIB_MASK;

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

297
298
  // bs > 0 and bs is a power of 2
  assert(bs > 0 && !(bs & (bs - 1)));
299

300
301
302
  // 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
303
  while (bs < MAX_MIB_SIZE) {
304
305
    if (mask_col & bs) {
      if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) {
306
        has_tr = 0;
307
308
309
310
311
312
313
        break;
      }
    } else {
      break;
    }
    bs <<= 1;
  }
314

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

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

325
326
327
328
#if CONFIG_EXT_PARTITION_TYPES
  // The bottom left square of a Vertical A does not have a top right as it is
  // decoded before the right hand rectangle of the partition
  if (xd->mi[0]->mbmi.partition == PARTITION_VERT_A)
329
    if ((mask_row & bs) && !(mask_col & bs)) has_tr = 0;
330
331
#endif  // CONFIG_EXT_PARTITION_TYPES

332
333
334
  return has_tr;
}

335
336
337
338
339
340
341
342
343
344
345
static int add_col_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) {
  const MV_REF *prev_frame_mvs =
      prev_frame_mvs_base + blk_row * cm->mi_cols + blk_col;
  POSITION mi_pos;
  int ref, idx;
  int coll_blk_count = 0;
346
  const int weight_unit = mi_size_wide[BLOCK_8X8];
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363

  mi_pos.row = blk_row;
  mi_pos.col = blk_col;

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

  for (ref = 0; ref < 2; ++ref) {
    if (prev_frame_mvs->ref_frame[ref] == ref_frame) {
      int_mv this_refmv = prev_frame_mvs->mv[ref];
      lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv);

      if (abs(this_refmv.as_mv.row) >= 16 || abs(this_refmv.as_mv.col) >= 16)
        mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);

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

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

      if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
        ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
368
369
        ref_mv_stack[idx].pred_diff[0] =
            av1_get_pred_diff_ctx(prev_frame_mvs->pred_mv[ref], this_refmv);
370
        ref_mv_stack[idx].weight = 2 * weight_unit;
371
372
373
374
375
376
377
378
379
380
        ++(*refmv_count);
      }

      ++coll_blk_count;
    }
  }

  return coll_blk_count;
}

Yaowu Xu's avatar
Yaowu Xu committed
381
static void setup_ref_mv_list(const AV1_COMMON *cm, const MACROBLOCKD *xd,
382
                              MV_REFERENCE_FRAME ref_frame,
clang-format's avatar
clang-format committed
383
384
385
                              uint8_t *refmv_count, CANDIDATE_MV *ref_mv_stack,
                              int_mv *mv_ref_list, int block, int mi_row,
                              int mi_col, int16_t *mode_context) {
386
  int idx, nearest_refmv_count = 0;
387
  uint8_t newmv_count = 0;
388
389
390
  CANDIDATE_MV tmp_mv;
  int len, nr_len;

clang-format's avatar
clang-format committed
391
392
393
394
  const MV_REF *const prev_frame_mvs_base =
      cm->use_prev_frame_mvs
          ? cm->prev_frame->mvs + mi_row * cm->mi_cols + mi_col
          : NULL;
395

396
397
  const int bs = AOMMAX(xd->n8_w, xd->n8_h);
  const int has_tr = has_top_right(xd, mi_row, mi_col, bs);
Jingning Han's avatar
Jingning Han committed
398
399
  MV_REFERENCE_FRAME rf[2];

400
  av1_set_ref_frame(rf, ref_frame);
401
  mode_context[ref_frame] = 0;
402
  *refmv_count = 0;
403
404

  // Scan the first above row mode info.
405
406
  newmv_count += scan_row_mbmi(cm, xd, mi_row, mi_col, block, rf, -1,
                               ref_mv_stack, refmv_count);
407
  // Scan the first left column mode info.
clang-format's avatar
clang-format committed
408
409
  newmv_count += scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -1,
                               ref_mv_stack, refmv_count);
410

411
412
  // Check top-right boundary
  if (has_tr)
413
414
    newmv_count += scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1,
                                 xd->n8_w, ref_mv_stack, refmv_count);
415

416
  nearest_refmv_count = *refmv_count;
417

418
  for (idx = 0; idx < nearest_refmv_count; ++idx)
419
    ref_mv_stack[idx].weight += REF_CAT_LEVEL;
420
421
422
#if CONFIG_TEMPMV_SIGNALING
  if (cm->use_prev_frame_mvs && rf[1] == NONE_FRAME) {
#else
clang-format's avatar
clang-format committed
423
  if (prev_frame_mvs_base && cm->show_frame && cm->last_show_frame &&
Emil Keyder's avatar
Emil Keyder committed
424
      rf[1] == NONE_FRAME) {
425
#endif
426
    int blk_row, blk_col;
427
    int coll_blk_count = 0;
428
429
430
431
432
#if CONFIG_CB4X4
    const int mi_step = (xd->n8_w == 1 || xd->n8_h == 1)
                            ? mi_size_wide[BLOCK_8X8]
                            : mi_size_wide[BLOCK_16X16];
#else
433
    const int mi_step = mi_size_wide[BLOCK_16X16];
434
#endif
435
436
    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) {
437
438
439
        coll_blk_count += add_col_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);
440
441
      }
    }
442
443
    if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
  } else {
444
    mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
445
  }
446

447
  // Scan the second outer area.
Deng's avatar
Deng committed
448
449
450
451
452
453
454
455
456
457
  scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, -1, ref_mv_stack,
                refmv_count);
  for (idx = 2; idx <= 3; ++idx) {
    scan_row_mbmi(cm, xd, mi_row, mi_col, block, rf, -idx, ref_mv_stack,
                  refmv_count);
    scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -idx, ref_mv_stack,
                  refmv_count);
  }
  scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -4, ref_mv_stack,
                refmv_count);
458

459
460
461
  switch (nearest_refmv_count) {
    case 0:
      mode_context[ref_frame] |= 0;
clang-format's avatar
clang-format committed
462
      if (*refmv_count >= 1) mode_context[ref_frame] |= 1;
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490

      if (*refmv_count == 1)
        mode_context[ref_frame] |= (1 << REFMV_OFFSET);
      else if (*refmv_count >= 2)
        mode_context[ref_frame] |= (2 << REFMV_OFFSET);
      break;
    case 1:
      mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3;

      if (*refmv_count == 1)
        mode_context[ref_frame] |= (3 << REFMV_OFFSET);
      else if (*refmv_count >= 2)
        mode_context[ref_frame] |= (4 << REFMV_OFFSET);
      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;
  }

491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
  // 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;
  }

506
  len = *refmv_count;
507
508
509
510
511
512
513
514
515
516
517
518
519
  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
520
  if (rf[1] > NONE_FRAME) {
521
    for (idx = 0; idx < *refmv_count; ++idx) {
522
523
524
525
      clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->n8_w << MI_SIZE_LOG2,
                   xd->n8_h << MI_SIZE_LOG2, xd);
      clamp_mv_ref(&ref_mv_stack[idx].comp_mv.as_mv, xd->n8_w << MI_SIZE_LOG2,
                   xd->n8_h << MI_SIZE_LOG2, xd);
526
527
    }
  } else {
Yaowu Xu's avatar
Yaowu Xu committed
528
    for (idx = 0; idx < AOMMIN(MAX_MV_REF_CANDIDATES, *refmv_count); ++idx) {
529
      mv_ref_list[idx].as_int = ref_mv_stack[idx].this_mv.as_int;
530
531
      clamp_mv_ref(&mv_ref_list[idx].as_mv, xd->n8_w << MI_SIZE_LOG2,
                   xd->n8_h << MI_SIZE_LOG2, xd);
532
    }
533
534
535
536
  }
}
#endif

Jingning Han's avatar
Jingning Han committed
537
538
// This function searches the neighbourhood of a given MB/SB
// to try and find candidate reference vectors.
Yaowu Xu's avatar
Yaowu Xu committed
539
static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
540
                             MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
clang-format's avatar
clang-format committed
541
542
                             int_mv *mv_ref_list, int block, int mi_row,
                             int mi_col, find_mv_refs_sync sync,
543
544
                             void *const data, int16_t *mode_context,
                             int_mv zeromv) {
Jingning Han's avatar
Jingning Han committed
545
546
  const int *ref_sign_bias = cm->ref_frame_sign_bias;
  int i, refmv_count = 0;
Yaowu Xu's avatar
Yaowu Xu committed
547
#if !CONFIG_REF_MV
Jingning Han's avatar
Jingning Han committed
548
  const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type];
Deng's avatar
Deng committed
549
#endif
Jingning Han's avatar
Jingning Han committed
550
551
  int different_ref_found = 0;
  int context_counter = 0;
clang-format's avatar
clang-format committed
552
553
554
555
  const MV_REF *const prev_frame_mvs =
      cm->use_prev_frame_mvs
          ? cm->prev_frame->mvs + mi_row * cm->mi_cols + mi_col
          : NULL;
Jingning Han's avatar
Jingning Han committed
556
  const TileInfo *const tile = &xd->tile;
557
558
559
  const BLOCK_SIZE bsize = mi->mbmi.sb_type;
  const int bw = block_size_wide[AOMMAX(bsize, BLOCK_8X8)];
  const int bh = block_size_high[AOMMAX(bsize, BLOCK_8X8)];
Yaowu Xu's avatar
Yaowu Xu committed
560
#if CONFIG_REF_MV
Deng's avatar
Deng committed
561
  POSITION mv_ref_search[MVREF_NEIGHBOURS];
562
563
  const int num_8x8_blocks_wide = num_8x8_blocks_wide_lookup[bsize];
  const int num_8x8_blocks_high = num_8x8_blocks_high_lookup[bsize];
Deng's avatar
Deng committed
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
  mv_ref_search[0].row = num_8x8_blocks_high - 1;
  mv_ref_search[0].col = -1;
  mv_ref_search[1].row = -1;
  mv_ref_search[1].col = num_8x8_blocks_wide - 1;
  mv_ref_search[2].row = -1;
  mv_ref_search[2].col = (num_8x8_blocks_wide - 1) >> 1;
  mv_ref_search[3].row = (num_8x8_blocks_high - 1) >> 1;
  mv_ref_search[3].col = -1;
  mv_ref_search[4].row = -1;
  mv_ref_search[4].col = -1;
  mv_ref_search[5].row = -1;
  mv_ref_search[5].col = num_8x8_blocks_wide;
  mv_ref_search[6].row = num_8x8_blocks_high;
  mv_ref_search[6].col = -1;
  mv_ref_search[7].row = -1;
  mv_ref_search[7].col = -3;
  mv_ref_search[8].row = num_8x8_blocks_high - 1;
  mv_ref_search[8].col = -3;
582
583
584
585
586
587
588
589

#if CONFIG_CB4X4
  for (i = 0; i < MVREF_NEIGHBOURS; ++i) {
    mv_ref_search[i].row *= 2;
    mv_ref_search[i].col *= 2;
  }
#endif  // CONFIG_CB4X4
#endif  // CONFIG_REF_MV
Jingning Han's avatar
Jingning Han committed
590
591
592
593
594
595

  // The nearest 2 blocks are treated differently
  // if the size < 8x8 we get the mv from the bmi substructure,
  // and we also need to keep a mode count.
  for (i = 0; i < 2; ++i) {
    const POSITION *const mv_ref = &mv_ref_search[i];
Geza Lore's avatar
Geza Lore committed
596
    if (is_inside(tile, mi_col, mi_row, mv_ref)) {
clang-format's avatar
clang-format committed
597
598
      const MODE_INFO *const candidate_mi =
          xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride];
Jingning Han's avatar
Jingning Han committed
599
600
601
602
603
604
605
      const MB_MODE_INFO *const candidate = &candidate_mi->mbmi;
      // Keep counts for entropy encoding.
      context_counter += mode_2_counter[candidate->mode];
      different_ref_found = 1;

      if (candidate->ref_frame[0] == ref_frame)
        ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 0, mv_ref->col, block),
606
                        refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
607
608
      else if (candidate->ref_frame[1] == ref_frame)
        ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 1, mv_ref->col, block),
609
                        refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
610
611
612
613
614
615
616
617
    }
  }

  // Check the rest of the neighbors in much the same way
  // as before except we don't need to keep track of sub blocks or
  // mode counts.
  for (; i < MVREF_NEIGHBOURS; ++i) {
    const POSITION *const mv_ref = &mv_ref_search[i];
Geza Lore's avatar
Geza Lore committed
618
    if (is_inside(tile, mi_col, mi_row, mv_ref)) {
clang-format's avatar
clang-format committed
619
      const MB_MODE_INFO *const candidate =
Yaowu Xu's avatar
Yaowu Xu committed
620
621
622
          !xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]
              ? NULL
              : &xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]->mbmi;
Yaowu Xu's avatar
Yaowu Xu committed
623
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
624
      if (candidate == NULL) continue;
625
626
      if ((mi_row % MAX_MIB_SIZE) + mv_ref->row >= MAX_MIB_SIZE ||
          (mi_col % MAX_MIB_SIZE) + mv_ref->col >= MAX_MIB_SIZE)
Deng's avatar
Deng committed
627
628
        continue;
#endif
Jingning Han's avatar
Jingning Han committed
629
630
631
      different_ref_found = 1;

      if (candidate->ref_frame[0] == ref_frame)
clang-format's avatar
clang-format committed
632
633
        ADD_MV_REF_LIST(candidate->mv[0], refmv_count, mv_ref_list, bw, bh, xd,
                        Done);
Jingning Han's avatar
Jingning Han committed
634
      else if (candidate->ref_frame[1] == ref_frame)
clang-format's avatar
clang-format committed
635
636
        ADD_MV_REF_LIST(candidate->mv[1], refmv_count, mv_ref_list, bw, bh, xd,
                        Done);
Jingning Han's avatar
Jingning Han committed
637
638
639
    }
  }

clang-format's avatar
clang-format committed
640
641
642
643
// TODO(hkuang): Remove this sync after fixing pthread_cond_broadcast
// on windows platform. The sync here is unncessary if use_perv_frame_mvs
// is 0. But after removing it, there will be hang in the unit test on windows
// due to several threads waiting for a thread's signal.
Jingning Han's avatar
Jingning Han committed
644
#if defined(_WIN32) && !HAVE_PTHREAD_H
clang-format's avatar
clang-format committed
645
646
647
  if (cm->frame_parallel_decode && sync != NULL) {
    sync(data, mi_row);
  }
Jingning Han's avatar
Jingning Han committed
648
649
650
651
652
653
654
655
656
657
#endif

  // Check the last frame's mode and mv info.
  if (cm->use_prev_frame_mvs) {
    // Synchronize here for frame parallel decode if sync function is provided.
    if (cm->frame_parallel_decode && sync != NULL) {
      sync(data, mi_row);
    }

    if (prev_frame_mvs->ref_frame[0] == ref_frame) {
clang-format's avatar
clang-format committed
658
659
      ADD_MV_REF_LIST(prev_frame_mvs->mv[0], refmv_count, mv_ref_list, bw, bh,
                      xd, Done);
Jingning Han's avatar
Jingning Han committed
660
    } else if (prev_frame_mvs->ref_frame[1] == ref_frame) {
clang-format's avatar
clang-format committed
661
662
      ADD_MV_REF_LIST(prev_frame_mvs->mv[1], refmv_count, mv_ref_list, bw, bh,
                      xd, Done);
Jingning Han's avatar
Jingning Han committed
663
664
665
666
667
668
669
670
671
    }
  }

  // Since we couldn't find 2 mvs from the same reference frame
  // go back through the neighbors and find motion vectors from
  // different reference frames.
  if (different_ref_found) {
    for (i = 0; i < MVREF_NEIGHBOURS; ++i) {
      const POSITION *mv_ref = &mv_ref_search[i];
Geza Lore's avatar
Geza Lore committed
672
      if (is_inside(tile, mi_col, mi_row, mv_ref)) {
clang-format's avatar
clang-format committed
673
        const MB_MODE_INFO *const candidate =
Yaowu Xu's avatar
Yaowu Xu committed
674
675
676
            !xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]
                ? NULL
                : &xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]->mbmi;
Yaowu Xu's avatar
Yaowu Xu committed
677
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
678
        if (candidate == NULL) continue;
679
680
        if ((mi_row % MAX_MIB_SIZE) + mv_ref->row >= MAX_MIB_SIZE ||
            (mi_col % MAX_MIB_SIZE) + mv_ref->col >= MAX_MIB_SIZE)
Deng's avatar
Deng committed
681
682
          continue;
#endif
Jingning Han's avatar
Jingning Han committed
683
684
685

        // If the candidate is INTRA we don't want to consider its mv.
        IF_DIFF_REF_FRAME_ADD_MV(candidate, ref_frame, ref_sign_bias,
686
                                 refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
687
688
689
690
691
692
693
694
695
696
697
698
699
700
      }
    }
  }

  // Since we still don't have a candidate we'll try the last frame.
  if (cm->use_prev_frame_mvs) {
    if (prev_frame_mvs->ref_frame[0] != ref_frame &&
        prev_frame_mvs->ref_frame[0] > INTRA_FRAME) {
      int_mv mv = prev_frame_mvs->mv[0];
      if (ref_sign_bias[prev_frame_mvs->ref_frame[0]] !=
          ref_sign_bias[ref_frame]) {
        mv.as_mv.row *= -1;
        mv.as_mv.col *= -1;
      }
701
      ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
702
703
704
    }

    if (prev_frame_mvs->ref_frame[1] > INTRA_FRAME &&
705
        prev_frame_mvs->ref_frame[1] != ref_frame) {
Jingning Han's avatar
Jingning Han committed
706
707
708
709
710
711
      int_mv mv = prev_frame_mvs->mv[1];
      if (ref_sign_bias[prev_frame_mvs->ref_frame[1]] !=
          ref_sign_bias[ref_frame]) {
        mv.as_mv.row *= -1;
        mv.as_mv.col *= -1;
      }
712
      ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
713
714
715
    }
  }

716
717
718
Done:
  if (mode_context)
    mode_context[ref_frame] = counter_to_context[context_counter];
719
  for (i = refmv_count; i < MAX_MV_REF_CANDIDATES; ++i)
720
    mv_ref_list[i].as_int = zeromv.as_int;
Jingning Han's avatar
Jingning Han committed
721
722
}

Yue Chen's avatar
Yue Chen committed
723
724
#if CONFIG_EXT_INTER
// This function keeps a mode count for a given MB/SB
Yaowu Xu's avatar
Yaowu Xu committed
725
726
727
728
void av1_update_mv_context(const MACROBLOCKD *xd, MODE_INFO *mi,
                           MV_REFERENCE_FRAME ref_frame, int_mv *mv_ref_list,
                           int block, int mi_row, int mi_col,
                           int16_t *mode_context) {
Yue Chen's avatar
Yue Chen committed
729
  int i, refmv_count = 0;
Yaowu Xu's avatar
Yaowu Xu committed
730
#if !CONFIG_REF_MV
Yue Chen's avatar
Yue Chen committed
731
  const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type];
732
#endif
Yue Chen's avatar
Yue Chen committed
733
734
735
736
  int context_counter = 0;
  const int bw = num_8x8_blocks_wide_lookup[mi->mbmi.sb_type] << 3;
  const int bh = num_8x8_blocks_high_lookup[mi->mbmi.sb_type] << 3;
  const TileInfo *const tile = &xd->tile;
Yaowu Xu's avatar
Yaowu Xu committed
737
#if CONFIG_REF_MV
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
  POSITION mv_ref_search[MVREF_NEIGHBOURS];
  const int num_8x8_blocks_wide = bw >> 3;
  const int num_8x8_blocks_high = bh >> 3;
  mv_ref_search[0].row = num_8x8_blocks_high - 1;
  mv_ref_search[0].col = -1;
  mv_ref_search[1].row = -1;
  mv_ref_search[1].col = num_8x8_blocks_wide - 1;
  mv_ref_search[2].row = -1;
  mv_ref_search[2].col = (num_8x8_blocks_wide - 1) >> 1;
  mv_ref_search[3].row = (num_8x8_blocks_high - 1) >> 1;
  mv_ref_search[3].col = -1;
  mv_ref_search[4].row = -1;
  mv_ref_search[4].col = -1;
  mv_ref_search[5].row = -1;
  mv_ref_search[5].col = num_8x8_blocks_wide;
  mv_ref_search[6].row = num_8x8_blocks_high;
  mv_ref_search[6].col = -1;
  mv_ref_search[7].row = -1;
  mv_ref_search[7].col = -3;
  mv_ref_search[8].row = num_8x8_blocks_high - 1;
  mv_ref_search[8].col = -3;
#endif
Yue Chen's avatar
Yue Chen committed
760
761
762
763
764
765
766
767

  // Blank the reference vector list
  memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES);

  // The nearest 2 blocks are examined only.
  // If the size < 8x8, we get the mv from the bmi substructure;
  for (i = 0; i < 2; ++i) {
    const POSITION *const mv_ref = &mv_ref_search[i];
Geza Lore's avatar
Geza Lore committed
768
    if (is_inside(tile, mi_col, mi_row, mv_ref)) {
Yue Chen's avatar
Yue Chen committed
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
      const MODE_INFO *const candidate_mi =
          xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride];
      const MB_MODE_INFO *const candidate = &candidate_mi->mbmi;

      // Keep counts for entropy encoding.
      context_counter += mode_2_counter[candidate->mode];

      if (candidate->ref_frame[0] == ref_frame) {
        ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 0, mv_ref->col, block),
                        refmv_count, mv_ref_list, bw, bh, xd, Done);
      } else if (candidate->ref_frame[1] == ref_frame) {
        ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 1, mv_ref->col, block),
                        refmv_count, mv_ref_list, bw, bh, xd, Done);
      }
    }
  }

clang-format's avatar
clang-format committed
786
Done:
Yue Chen's avatar
Yue Chen committed
787
788
789
790
791
792

  if (mode_context)
    mode_context[ref_frame] = counter_to_context[context_counter];
}
#endif  // CONFIG_EXT_INTER

Yaowu Xu's avatar
Yaowu Xu committed
793
794
void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
                      MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
795
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
796
                      uint8_t *ref_mv_count, CANDIDATE_MV *ref_mv_stack,
797
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
798
                      int16_t *compound_mode_context,
799
#endif  // CONFIG_EXT_INTER
800
#endif
Yaowu Xu's avatar
Yaowu Xu committed
801
802
803
                      int_mv *mv_ref_list, int mi_row, int mi_col,
                      find_mv_refs_sync sync, void *const data,
                      int16_t *mode_context) {
804
  int_mv zeromv[2];
805
#if CONFIG_REF_MV
806
807
808
809
  int idx, all_zero = 1;
#endif
#if CONFIG_GLOBAL_MOTION
  MV_REFERENCE_FRAME rf[2];
810
#endif
Yue Chen's avatar
Yue Chen committed
811
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
812
  av1_update_mv_context(xd, mi, ref_frame, mv_ref_list, -1, mi_row, mi_col,
813
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
814
                        compound_mode_context);
815
#else
Yaowu Xu's avatar
Yaowu Xu committed
816
                        mode_context);
817
#endif  // CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
818
#endif  // CONFIG_EXT_INTER
819
820
821
822
823
824

#if CONFIG_GLOBAL_MOTION
  av1_set_ref_frame(rf, ref_frame);
  zeromv[0].as_int = gm_get_motion_vector(&cm->global_motion[rf[0]],
                                          cm->allow_high_precision_mv)
                         .as_int;
Emil Keyder's avatar
Emil Keyder committed
825
  zeromv[1].as_int = (rf[1] != NONE_FRAME)
826
827
828
829
830
831
832
833
                         ? gm_get_motion_vector(&cm->global_motion[rf[1]],
                                                cm->allow_high_precision_mv)
                               .as_int
                         : 0;
#else
  zeromv[0].as_int = zeromv[1].as_int = 0;
#endif

Yaowu Xu's avatar
Yaowu Xu committed
834
835
#if CONFIG_REF_MV
  if (ref_frame <= ALTREF_FRAME)
836
#endif  // CONFIG_REF_MV
837
838
    find_mv_refs_idx(cm, xd, mi, ref_frame, mv_ref_list, -1, mi_row, mi_col,
                     sync, data, mode_context, zeromv[0]);
839
840

#if CONFIG_REF_MV
clang-format's avatar
clang-format committed
841
842
  setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack, mv_ref_list,
                    -1, mi_row, mi_col, mode_context);
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
  /* Note: If global motion is enabled, then we want to set the ALL_ZERO flag
     iff all of the MVs we could generate with NEARMV/NEARESTMV are equivalent
     to the global motion vector.
     Note: For the following to work properly, the encoder can't throw away
     any global motion models after calling this function, even if they are
     unused. Instead we rely on the recode loop: If any non-IDENTITY model
     is unused, the whole frame will be re-encoded without it.
     The problem is that, otherwise, we can end up in the following situation:
     * Encoder has a global motion model with nonzero translational part,
       and all candidate MVs are zero. So the ALL_ZERO flag is unset.
     * Encoder throws away global motion because it is never used.
     * Decoder sees that there is no global motion and all candidate MVs are
       zero, so sets the ALL_ZERO flag.
     * This leads to an encode/decode mismatch.
  */
Yaowu Xu's avatar
Yaowu Xu committed
858
859
  if (*ref_mv_count >= 2) {
    for (idx = 0; idx < AOMMIN(3, *ref_mv_count); ++idx) {
860
      if (ref_mv_stack[idx].this_mv.as_int != zeromv[0].as_int) all_zero = 0;
Yaowu Xu's avatar
Yaowu Xu committed
861
      if (ref_frame > ALTREF_FRAME)
862
        if (ref_mv_stack[idx].comp_mv.as_int != zeromv[1].as_int) all_zero = 0;
Yaowu Xu's avatar
Yaowu Xu committed
863
864
865
    }
  } else if (ref_frame <= ALTREF_FRAME) {
    for (idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx)
866
      if (mv_ref_list[idx].as_int != zeromv[0].as_int) all_zero = 0;
Yaowu Xu's avatar
Yaowu Xu committed
867
  }
868

clang-format's avatar
clang-format committed
869
  if (all_zero) mode_context[ref_frame] |= (1 << ALL_ZERO_FLAG_OFFSET);
870
#endif
Jingning Han's avatar
Jingning Han committed
871
872
}

Yaowu Xu's avatar
Yaowu Xu committed
873
874
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
                           int_mv *near_mv) {
Jingning Han's avatar
Jingning Han committed
875
876
877
878
879
880
881
882
883
  int i;
  // Make sure all the candidates are properly clamped etc
  for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) {
    lower_mv_precision(&mvlist[i].as_mv, allow_hp);
  }
  *nearest_mv = mvlist[0];
  *near_mv = mvlist[1];
}

884
885
void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd,
                                   int block, int ref, int mi_row, int mi_col,
886
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
887
888
                                   CANDIDATE_MV *ref_mv_stack,
                                   uint8_t *ref_mv_count,
889
#endif
Yue Chen's avatar
Yue Chen committed
890
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
891
                                   int_mv *mv_list,
Yue Chen's avatar
Yue Chen committed
892
#endif  // CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
893
                                   int_mv *nearest_mv, int_mv *near_mv) {
Yue Chen's avatar
Yue Chen committed
894
#if !CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
895
  int_mv mv_list[MAX_MV_REF_CANDIDATES];
Yue Chen's avatar
Yue Chen committed
896
#endif  // !CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
897
898
899
  MODE_INFO *const mi = xd->mi[0];
  b_mode_info *bmi = mi->bmi;
  int n;
900
  int_mv zeromv;
901
902
#if CONFIG_REF_MV
  CANDIDATE_MV tmp_mv;
903
  uint8_t idx;
904
  uint8_t above_count = 0, left_count = 0;
Emil Keyder's avatar
Emil Keyder committed
905
  MV_REFERENCE_FRAME rf[2] = { mi->mbmi.ref_frame[ref], NONE_FRAME };
906
  *ref_mv_count = 0;
907
#endif
Jingning Han's avatar
Jingning Han committed
908
909
910

  assert(MAX_MV_REF_CANDIDATES == 2);

911
912
913
914
915
916
917
#if CONFIG_GLOBAL_MOTION
  zeromv.as_int =
      gm_get_motion_vector(&cm->global_motion[ref], cm->allow_high_precision_mv)
          .as_int;
#else
  zeromv.as_int = 0;
#endif
clang-format's avatar
clang-format committed
918
  find_mv_refs_idx(cm, xd, mi, mi->mbmi.ref_frame[ref], mv_list, block, mi_row,
919
                   mi_col, NULL, NULL, NULL, zeromv);
Jingning Han's avatar
Jingning Han committed
920

921
#if CONFIG_REF_MV
clang-format's avatar
clang-format committed
922
923
  scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, 0, ref_mv_stack,
                ref_mv_count);
924
  above_count = *ref_mv_count;
925

clang-format's avatar
clang-format committed
926
927
  scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, 0, -1, ref_mv_stack,
                ref_mv_count);
928
  left_count = *ref_mv_count - above_count;
929
930
931
932
933
934
935

  if (above_count > 1 && left_count > 0) {
    tmp_mv = ref_mv_stack[1];
    ref_mv_stack[1] = ref_mv_stack[above_count];
    ref_mv_stack[above_count] = tmp_mv;
  }

936
  for (idx = 0; idx < *ref_mv_count; ++idx)
937
938
    clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->n8_w << MI_SIZE_LOG2,
                 xd->n8_h << MI_SIZE_LOG2, xd);
939

Yaowu Xu's avatar
Yaowu Xu committed
940
  for (idx = 0; idx < AOMMIN(MAX_MV_REF_CANDIDATES, *ref_mv_count); ++idx)
941
    mv_list[idx].as_int = ref_mv_stack[idx].this_mv.as_int;
942
943
#endif

Jingning Han's avatar
Jingning Han committed
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
  near_mv->as_int = 0;
  switch (block) {
    case 0:
      nearest_mv->as_int = mv_list[0].as_int;
      near_mv->as_int = mv_list[1].as_int;
      break;
    case 1:
    case 2:
      nearest_mv->as_int = bmi[0].as_mv[ref].as_int;
      for (n = 0; n < MAX_MV_REF_CANDIDATES; ++n)
        if (nearest_mv->as_int != mv_list[n].as_int) {
          near_mv->as_int = mv_list[n].as_int;
          break;
        }
      break;
    case 3: {
      int_mv candidates[2 + MAX_MV_REF_CANDIDATES];
      candidates[0] = bmi[1].as_mv[ref];
      candidates[1] = bmi[0].as_mv[ref];
      candidates[2] = mv_list[0];
      candidates[3] = mv_list[1];

      nearest_mv->as_int = bmi[2].as_mv[ref].as_int;
      for (n = 0; n < 2 + MAX_MV_REF_CANDIDATES; ++n)
        if (nearest_mv->as_int != candidates[n].as_int) {
          near_mv->as_int = candidates[n].as_int;
          break;
        }
      break;
    }
clang-format's avatar
clang-format committed
974
    default: assert(0 && "Invalid block index.");
Jingning Han's avatar
Jingning Han committed
975
976
  }
}
Yue Chen's avatar
Yue Chen committed
977
978

#if CONFIG_WARPED_MOTION
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
void calc_projection_samples(MB_MODE_INFO *const mbmi,
#if CONFIG_GLOBAL_MOTION
                             MACROBLOCKD *xd,
#endif
                             int x, int y, double *pts_inref) {
  if (mbmi->motion_mode == WARPED_CAUSAL
#if CONFIG_GLOBAL_MOTION
      || (mbmi->mode == ZEROMV &&
          xd->global_motion[mbmi->ref_frame[0]].wmtype > TRANSLATION)
#endif
          ) {
    int ipts[2] = { x, y }, ipts_inref[2];
    WarpedMotionParams *wm =
#if CONFIG_GLOBAL_MOTION
        (mbmi->motion_mode != WARPED_CAUSAL)
            ? &xd->global_motion[mbmi->ref_frame[0]]
            :
#endif
            &mbmi->wm_params[0];

    project_points(wm, ipts, ipts_inref, 1, 2, 2, 0, 0);
    pts_inref[0] = (double)ipts_inref[0] / (double)WARPEDPIXEL_PREC_SHIFTS;
    pts_inref[1] = (double)ipts_inref[1] / (double)WARPEDPIXEL_PREC_SHIFTS;
  } else {
    pts_inref[0] = (double)x + (double)(mbmi->mv[0].as_mv.col) * 0.125;
    pts_inref[1] = (double)y + (double)(mbmi->mv[0].as_mv.row) * 0.125;
  }
}

Yue Chen's avatar
Yue Chen committed
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
                double *pts, double *pts_inref) {
  MB_MODE_INFO *const mbmi0 = &(xd->mi[0]->mbmi);
  int ref_frame = mbmi0->ref_frame[