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
420
    ref_mv_stack[idx].weight += REF_CAT_LEVEL;

clang-format's avatar
clang-format committed
421
  if (prev_frame_mvs_base && cm->show_frame && cm->last_show_frame &&
Emil Keyder's avatar
Emil Keyder committed
422
      rf[1] == NONE_FRAME) {
423
    int blk_row, blk_col;
424
    int coll_blk_count = 0;
425
426
427
428
429
#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
430
    const int mi_step = mi_size_wide[BLOCK_16X16];
431
#endif
432
433
    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) {
434
435
436
        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);
437
438
      }
    }
439
440
    if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
  } else {
441
    mode_context[ref_frame] |= (1 << ZEROMV_OFFSET);
442
  }
443

444
  // Scan the second outer area.
Deng's avatar
Deng committed
445
446
447
448
449
450
451
452
453
454
  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);
455

456
457
458
  switch (nearest_refmv_count) {
    case 0:
      mode_context[ref_frame] |= 0;
clang-format's avatar
clang-format committed
459
      if (*refmv_count >= 1) mode_context[ref_frame] |= 1;
460
461
462
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

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

488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
  // 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;
  }

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

Jingning Han's avatar
Jingning Han committed
534
535
// This function searches the neighbourhood of a given MB/SB
// to try and find candidate reference vectors.
Yaowu Xu's avatar
Yaowu Xu committed
536
static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
537
                             MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
clang-format's avatar
clang-format committed
538
539
                             int_mv *mv_ref_list, int block, int mi_row,
                             int mi_col, find_mv_refs_sync sync,
540
541
                             void *const data, int16_t *mode_context,
                             int_mv zeromv) {
Jingning Han's avatar
Jingning Han committed
542
543
  const int *ref_sign_bias = cm->ref_frame_sign_bias;
  int i, refmv_count = 0;
Yaowu Xu's avatar
Yaowu Xu committed
544
#if !CONFIG_REF_MV
Jingning Han's avatar
Jingning Han committed
545
  const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type];
Deng's avatar
Deng committed
546
#endif
Jingning Han's avatar
Jingning Han committed
547
548
  int different_ref_found = 0;
  int context_counter = 0;
clang-format's avatar
clang-format committed
549
550
551
552
  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
553
  const TileInfo *const tile = &xd->tile;
554
555
556
  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
557
#if CONFIG_REF_MV
Deng's avatar
Deng committed
558
  POSITION mv_ref_search[MVREF_NEIGHBOURS];
559
560
  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
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
  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;
579
580
581
582
583
584
585
586

#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
587
588
589
590
591
592

  // 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
593
    if (is_inside(tile, mi_col, mi_row, mv_ref)) {
clang-format's avatar
clang-format committed
594
595
      const MODE_INFO *const candidate_mi =
          xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride];
Jingning Han's avatar
Jingning Han committed
596
597
598
599
600
601
602
      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),
603
                        refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
604
605
      else if (candidate->ref_frame[1] == ref_frame)
        ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 1, mv_ref->col, block),
606
                        refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
607
608
609
610
611
612
613
614
    }
  }

  // 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
615
    if (is_inside(tile, mi_col, mi_row, mv_ref)) {
clang-format's avatar
clang-format committed
616
      const MB_MODE_INFO *const candidate =
Yaowu Xu's avatar
Yaowu Xu committed
617
618
619
          !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
620
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
621
      if (candidate == NULL) continue;
622
623
      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
624
625
        continue;
#endif
Jingning Han's avatar
Jingning Han committed
626
627
628
      different_ref_found = 1;

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

clang-format's avatar
clang-format committed
637
638
639
640
// 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
641
#if defined(_WIN32) && !HAVE_PTHREAD_H
clang-format's avatar
clang-format committed
642
643
644
  if (cm->frame_parallel_decode && sync != NULL) {
    sync(data, mi_row);
  }
Jingning Han's avatar
Jingning Han committed
645
646
647
648
649
650
651
652
653
654
#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
655
656
      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
657
    } else if (prev_frame_mvs->ref_frame[1] == ref_frame) {
clang-format's avatar
clang-format committed
658
659
      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
660
661
662
663
664
665
666
667
668
    }
  }

  // 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
669
      if (is_inside(tile, mi_col, mi_row, mv_ref)) {
clang-format's avatar
clang-format committed
670
        const MB_MODE_INFO *const candidate =
Yaowu Xu's avatar
Yaowu Xu committed
671
672
673
            !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
674
#if CONFIG_REF_MV
Yaowu Xu's avatar
Yaowu Xu committed
675
        if (candidate == NULL) continue;
676
677
        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
678
679
          continue;
#endif
Jingning Han's avatar
Jingning Han committed
680
681
682

        // 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,
683
                                 refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
684
685
686
687
688
689
690
691
692
693
694
695
696
697
      }
    }
  }

  // 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;
      }
698
      ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
699
700
701
    }

    if (prev_frame_mvs->ref_frame[1] > INTRA_FRAME &&
702
        prev_frame_mvs->ref_frame[1] != ref_frame) {
Jingning Han's avatar
Jingning Han committed
703
704
705
706
707
708
      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;
      }
709
      ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done);
Jingning Han's avatar
Jingning Han committed
710
711
712
    }
  }

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

Yue Chen's avatar
Yue Chen committed
720
721
#if CONFIG_EXT_INTER
// This function keeps a mode count for a given MB/SB
Yaowu Xu's avatar
Yaowu Xu committed
722
723
724
725
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
726
  int i, refmv_count = 0;
Yaowu Xu's avatar
Yaowu Xu committed
727
#if !CONFIG_REF_MV
Yue Chen's avatar
Yue Chen committed
728
  const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type];
729
#endif
Yue Chen's avatar
Yue Chen committed
730
731
732
733
  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
734
#if CONFIG_REF_MV
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
  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
757
758
759
760
761
762
763
764

  // 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
765
    if (is_inside(tile, mi_col, mi_row, mv_ref)) {
Yue Chen's avatar
Yue Chen committed
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
      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
783
Done:
Yue Chen's avatar
Yue Chen committed
784
785
786
787
788
789

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

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

#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
822
  zeromv[1].as_int = (rf[1] != NONE_FRAME)
823
824
825
826
827
828
829
830
                         ? 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
831
832
#if CONFIG_REF_MV
  if (ref_frame <= ALTREF_FRAME)
833
#endif  // CONFIG_REF_MV
834
835
    find_mv_refs_idx(cm, xd, mi, ref_frame, mv_ref_list, -1, mi_row, mi_col,
                     sync, data, mode_context, zeromv[0]);
836
837

#if CONFIG_REF_MV
clang-format's avatar
clang-format committed
838
839
  setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack, mv_ref_list,
                    -1, mi_row, mi_col, mode_context);
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
  /* 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
855
856
  if (*ref_mv_count >= 2) {
    for (idx = 0; idx < AOMMIN(3, *ref_mv_count); ++idx) {
857
      if (ref_mv_stack[idx].this_mv.as_int != zeromv[0].as_int) all_zero = 0;
Yaowu Xu's avatar
Yaowu Xu committed
858
      if (ref_frame > ALTREF_FRAME)
859
        if (ref_mv_stack[idx].comp_mv.as_int != zeromv[1].as_int) all_zero = 0;
Yaowu Xu's avatar
Yaowu Xu committed
860
861
862
    }
  } else if (ref_frame <= ALTREF_FRAME) {
    for (idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx)
863
      if (mv_ref_list[idx].as_int != zeromv[0].as_int) all_zero = 0;
Yaowu Xu's avatar
Yaowu Xu committed
864
  }
865

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

Yaowu Xu's avatar
Yaowu Xu committed
870
871
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
872
873
874
875
876
877
878
879
880
  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];
}

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

  assert(MAX_MV_REF_CANDIDATES == 2);

908
909
910
911
912
913
914
#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
915
  find_mv_refs_idx(cm, xd, mi, mi->mbmi.ref_frame[ref], mv_list, block, mi_row,
916
                   mi_col, NULL, NULL, NULL, zeromv);
Jingning Han's avatar
Jingning Han committed
917

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

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

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

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

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

Jingning Han's avatar
Jingning Han committed
941
942
943
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
  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
971
    default: assert(0 && "Invalid block index.");
Jingning Han's avatar
Jingning Han committed
972
973
  }
}
Yue Chen's avatar
Yue Chen committed
974
975

#if CONFIG_WARPED_MOTION
976
977
978
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
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
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
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[0];
  int up_available = xd->up_available;
  int left_available = xd->left_available;
  int i, mi_step, np = 0;
  int mvasint[100];
  int mvnumber = 0;
  int global_offset_c = mi_col * 8;
  int global_offset_r = mi_row * 8;
  int samples_per_neighbor = 4;

  // scan the above row
  if (up_available) {
    for (i = 0; i < AOMMIN(xd->n8_w, cm->mi_cols - mi_col); i += mi_step) {
      int mi_row_offset = -1;
      int mi_col_offset = i;