mvref_common.h 18 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
 */
Yaowu Xu's avatar
Yaowu Xu committed
11
12
#ifndef AV1_COMMON_MVREF_COMMON_H_
#define AV1_COMMON_MVREF_COMMON_H_
Jingning Han's avatar
Jingning Han committed
13

14
15
#include "av1/common/onyxc_int.h"
#include "av1/common/blockd.h"
Jingning Han's avatar
Jingning Han committed
16
17
18
19
20

#ifdef __cplusplus
extern "C" {
#endif

Deng's avatar
Deng committed
21
#define MVREF_NEIGHBOURS 9
Yunqing Wang's avatar
Yunqing Wang committed
22
23
#define MVREF_ROWS 3
#define MVREF_COLS 4
Jingning Han's avatar
Jingning Han committed
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

typedef struct position {
  int row;
  int col;
} POSITION;

typedef enum {
  BOTH_ZERO = 0,
  ZERO_PLUS_PREDICTED = 1,
  BOTH_PREDICTED = 2,
  NEW_PLUS_NON_INTRA = 3,
  BOTH_NEW = 4,
  INTRA_PLUS_NON_INTRA = 5,
  BOTH_INTRA = 6,
  INVALID_CASE = 9
} motion_vector_context;

// This is used to figure out a context for the ref blocks. The code flattens
// an array that would have 3 possible counts (0, 1 & 2) for 3 choices by
// adding 9 for each intra block, 3 for each zero mv and 1 for each new
// motion vector. This single number is then converted into a context
// with a single lookup ( counter_to_context ).
46
static const int mode_2_counter[] = {
Jingning Han's avatar
Jingning Han committed
47
48
49
50
51
52
53
54
55
  9,  // DC_PRED
  9,  // V_PRED
  9,  // H_PRED
  9,  // D45_PRED
  9,  // D135_PRED
  9,  // D117_PRED
  9,  // D153_PRED
  9,  // D207_PRED
  9,  // D63_PRED
56
57
58
59
60
  9,  // SMOOTH_PRED
#if CONFIG_SMOOTH_HV
  9,    // SMOOTH_V_PRED
  9,    // SMOOTH_H_PRED
#endif  // CONFIG_SMOOTH_HV
61
62
63
64
65
  9,    // TM_PRED
  0,    // NEARESTMV
  0,    // NEARMV
  3,    // ZEROMV
  1,    // NEWMV
Yue Chen's avatar
Yue Chen committed
66
#if CONFIG_EXT_INTER
67
68
#if CONFIG_COMPOUND_SINGLEREF
  0,    // SR_NEAREST_NEARMV
69
        //  1,    // SR_NEAREST_NEWMV
70
71
72
73
  1,    // SR_NEAR_NEWMV
  3,    // SR_ZERO_NEWMV
  1,    // SR_NEW_NEWMV
#endif  // CONFIG_COMPOUND_SINGLEREF
clang-format's avatar
clang-format committed
74
75
76
77
78
79
80
81
  0,    // NEAREST_NEARESTMV
  0,    // NEAR_NEARMV
  1,    // NEAREST_NEWMV
  1,    // NEW_NEARESTMV
  1,    // NEAR_NEWMV
  1,    // NEW_NEARMV
  3,    // ZERO_ZEROMV
  1,    // NEW_NEWMV
Yue Chen's avatar
Yue Chen committed
82
#endif  // CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
83
84
85
86
87
88
};

// There are 3^3 different combinations of 3 counts that can be either 0,1 or
// 2. However the actual count can never be greater than 2 so the highest
// counter we need is 18. 9 is an invalid counter that's never used.
static const int counter_to_context[19] = {
clang-format's avatar
clang-format committed
89
90
91
92
93
94
95
96
97
  BOTH_PREDICTED,        // 0
  NEW_PLUS_NON_INTRA,    // 1
  BOTH_NEW,              // 2
  ZERO_PLUS_PREDICTED,   // 3
  NEW_PLUS_NON_INTRA,    // 4
  INVALID_CASE,          // 5
  BOTH_ZERO,             // 6
  INVALID_CASE,          // 7
  INVALID_CASE,          // 8
Jingning Han's avatar
Jingning Han committed
98
99
  INTRA_PLUS_NON_INTRA,  // 9
  INTRA_PLUS_NON_INTRA,  // 10
clang-format's avatar
clang-format committed
100
  INVALID_CASE,          // 11
Jingning Han's avatar
Jingning Han committed
101
  INTRA_PLUS_NON_INTRA,  // 12
clang-format's avatar
clang-format committed
102
103
104
105
106
107
  INVALID_CASE,          // 13
  INVALID_CASE,          // 14
  INVALID_CASE,          // 15
  INVALID_CASE,          // 16
  INVALID_CASE,          // 17
  BOTH_INTRA             // 18
Jingning Han's avatar
Jingning Han committed
108
109
110
};

static const int idx_n_column_to_subblock[4][2] = {
clang-format's avatar
clang-format committed
111
  { 1, 2 }, { 1, 3 }, { 3, 2 }, { 3, 3 }
Jingning Han's avatar
Jingning Han committed
112
113
114
};

// clamp_mv_ref
115
#if CONFIG_EXT_PARTITION
clang-format's avatar
clang-format committed
116
#define MV_BORDER (16 << 3)  // Allow 16 pels in 1/8th pel units
117
#else
clang-format's avatar
clang-format committed
118
119
#define MV_BORDER (8 << 3)  // Allow 8 pels in 1/8th pel units
#endif                      // CONFIG_EXT_PARTITION
Jingning Han's avatar
Jingning Han committed
120

121
122
static INLINE void clamp_mv_ref(MV *mv, int bw, int bh, const MACROBLOCKD *xd) {
  clamp_mv(mv, xd->mb_to_left_edge - bw * 8 - MV_BORDER,
clang-format's avatar
clang-format committed
123
124
125
           xd->mb_to_right_edge + bw * 8 + MV_BORDER,
           xd->mb_to_top_edge - bh * 8 - MV_BORDER,
           xd->mb_to_bottom_edge + bh * 8 + MV_BORDER);
Jingning Han's avatar
Jingning Han committed
126
127
128
129
130
131
}

// This function returns either the appropriate sub block or block's mv
// on whether the block_size < 8x8 and we have check_sub_blocks set.
static INLINE int_mv get_sub_block_mv(const MODE_INFO *candidate, int which_mv,
                                      int search_col, int block_idx) {
Yaowu Xu's avatar
Yaowu Xu committed
132
  (void)search_col;
133
  (void)block_idx;
Deng's avatar
Deng committed
134
  return candidate->mbmi.mv[which_mv];
Jingning Han's avatar
Jingning Han committed
135
136
}

Jingning Han's avatar
Jingning Han committed
137
static INLINE int_mv get_sub_block_pred_mv(const MODE_INFO *candidate,
clang-format's avatar
clang-format committed
138
139
                                           int which_mv, int search_col,
                                           int block_idx) {
140
141
  (void)search_col;
  (void)block_idx;
Deng's avatar
Deng committed
142
  return candidate->mbmi.mv[which_mv];
Jingning Han's avatar
Jingning Han committed
143
}
Jingning Han's avatar
Jingning Han committed
144
145
146
147
148
149
150
151
152
153
154
155
156

// Performs mv sign inversion if indicated by the reference frame combination.
static INLINE int_mv scale_mv(const MB_MODE_INFO *mbmi, int ref,
                              const MV_REFERENCE_FRAME this_ref_frame,
                              const int *ref_sign_bias) {
  int_mv mv = mbmi->mv[ref];
  if (ref_sign_bias[mbmi->ref_frame[ref]] != ref_sign_bias[this_ref_frame]) {
    mv.as_mv.row *= -1;
    mv.as_mv.col *= -1;
  }
  return mv;
}

157
158
#define CLIP_IN_ADD(mv, bw, bh, xd) clamp_mv_ref(mv, bw, bh, xd)

Jingning Han's avatar
Jingning Han committed
159
160
161
// This macro is used to add a motion vector mv_ref list if it isn't
// already in the list.  If it's the second motion vector it will also
// skip all additional processing and jump to done!
clang-format's avatar
clang-format committed
162
163
164
165
#define ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done)      \
  do {                                                                       \
    (mv_ref_list)[(refmv_count)] = (mv);                                     \
    CLIP_IN_ADD(&(mv_ref_list)[(refmv_count)].as_mv, (bw), (bh), (xd));      \
166
    if (refmv_count && (mv_ref_list)[1].as_int != (mv_ref_list)[0].as_int) { \
clang-format's avatar
clang-format committed
167
168
169
170
      (refmv_count) = 2;                                                     \
      goto Done;                                                             \
    }                                                                        \
    (refmv_count) = 1;                                                       \
Jingning Han's avatar
Jingning Han committed
171
172
173
174
175
  } while (0)

// If either reference frame is different, not INTRA, and they
// are different from each other scale and add the mv to our list.
#define IF_DIFF_REF_FRAME_ADD_MV(mbmi, ref_frame, ref_sign_bias, refmv_count, \
clang-format's avatar
clang-format committed
176
177
178
179
180
181
182
183
184
185
                                 mv_ref_list, bw, bh, xd, Done)               \
  do {                                                                        \
    if (is_inter_block(mbmi)) {                                               \
      if ((mbmi)->ref_frame[0] != ref_frame)                                  \
        ADD_MV_REF_LIST(scale_mv((mbmi), 0, ref_frame, ref_sign_bias),        \
                        refmv_count, mv_ref_list, bw, bh, xd, Done);          \
      if (has_second_ref(mbmi) && (mbmi)->ref_frame[1] != ref_frame)          \
        ADD_MV_REF_LIST(scale_mv((mbmi), 1, ref_frame, ref_sign_bias),        \
                        refmv_count, mv_ref_list, bw, bh, xd, Done);          \
    }                                                                         \
Jingning Han's avatar
Jingning Han committed
186
187
188
189
  } while (0)

// Checks that the given mi_row, mi_col and search point
// are inside the borders of the tile.
190
static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row,
191
                            int mi_rows, const AV1_COMMON *cm,
192
                            const POSITION *mi_pos) {
193
194
195
196
197
198
#if CONFIG_DEPENDENT_HORZTILES
  const int dependent_horz_tile_flag = cm->dependent_horz_tiles;
#else
  const int dependent_horz_tile_flag = 0;
  (void)cm;
#endif
199
  if (dependent_horz_tile_flag && !tile->tg_horz_boundary) {
200
201
202
203
204
205
206
207
208
209
210
    return !(mi_row + mi_pos->row < 0 ||
             mi_col + mi_pos->col < tile->mi_col_start ||
             mi_row + mi_pos->row >= mi_rows ||
             mi_col + mi_pos->col >= tile->mi_col_end);
  } else {
    return !(mi_row + mi_pos->row < tile->mi_row_start ||
             mi_col + mi_pos->col < tile->mi_col_start ||
             mi_row + mi_pos->row >= tile->mi_row_end ||
             mi_col + mi_pos->col >= tile->mi_col_end);
  }
}
Jingning Han's avatar
Jingning Han committed
211

Yunqing Wang's avatar
Yunqing Wang committed
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
static INLINE int find_valid_row_offset(const TileInfo *const tile, int mi_row,
                                        int mi_rows, const AV1_COMMON *cm,
                                        int row_offset) {
#if CONFIG_DEPENDENT_HORZTILES
  const int dependent_horz_tile_flag = cm->dependent_horz_tiles;
#else
  const int dependent_horz_tile_flag = 0;
  (void)cm;
#endif
  if (dependent_horz_tile_flag && !tile->tg_horz_boundary)
    return clamp(row_offset, -mi_row, mi_rows - mi_row - 1);
  else
    return clamp(row_offset, tile->mi_row_start - mi_row,
                 tile->mi_row_end - mi_row - 1);
}

static INLINE int find_valid_col_offset(const TileInfo *const tile, int mi_col,
                                        int col_offset) {
  return clamp(col_offset, tile->mi_col_start - mi_col,
               tile->mi_col_end - mi_col - 1);
}

RogerZhou's avatar
RogerZhou committed
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
static INLINE void lower_mv_precision(MV *mv, int allow_hp
#if CONFIG_AMVR
                                      ,
                                      int is_integer
#endif
                                      ) {
#if CONFIG_AMVR
  if (is_integer) {
    integer_mv_precision(mv);
  } else {
#endif
    if (!allow_hp) {
      if (mv->row & 1) mv->row += (mv->row > 0 ? -1 : 1);
      if (mv->col & 1) mv->col += (mv->col > 0 ? -1 : 1);
    }
#if CONFIG_AMVR
250
  }
RogerZhou's avatar
RogerZhou committed
251
#endif
252
253
}

254
255
256
257
258
259
260
261
262
static INLINE uint8_t av1_get_pred_diff_ctx(const int_mv pred_mv,
                                            const int_mv this_mv) {
  if (abs(this_mv.as_mv.row - pred_mv.as_mv.row) <= 4 &&
      abs(this_mv.as_mv.col - pred_mv.as_mv.col) <= 4)
    return 2;
  else
    return 1;
}

Yaowu Xu's avatar
Yaowu Xu committed
263
static INLINE int av1_nmv_ctx(const uint8_t ref_mv_count,
Yaowu Xu's avatar
Yaowu Xu committed
264
265
                              const CANDIDATE_MV *ref_mv_stack, int ref,
                              int ref_mv_idx) {
266
267
  if (ref_mv_stack[ref_mv_idx].weight >= REF_CAT_LEVEL && ref_mv_count > 0)
    return ref_mv_stack[ref_mv_idx].pred_diff[ref];
Yaowu Xu's avatar
Yaowu Xu committed
268

269
270
271
  return 0;
}

Zoe Liu's avatar
Zoe Liu committed
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
#if CONFIG_EXT_COMP_REFS
static INLINE int8_t av1_uni_comp_ref_idx(const MV_REFERENCE_FRAME *const rf) {
  // Single ref pred
  if (rf[1] <= INTRA_FRAME) return -1;

  // Bi-directional comp ref pred
  if ((rf[0] < BWDREF_FRAME) && (rf[1] >= BWDREF_FRAME)) return -1;

  for (int8_t ref_idx = 0; ref_idx < UNIDIR_COMP_REFS; ++ref_idx) {
    if (rf[0] == comp_ref0(ref_idx) && rf[1] == comp_ref1(ref_idx))
      return ref_idx;
  }
  return -1;
}
#endif  // CONFIG_EXT_COMP_REFS

Yaowu Xu's avatar
Yaowu Xu committed
288
static INLINE int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) {
289
  if (rf[1] > INTRA_FRAME) {
Zoe Liu's avatar
Zoe Liu committed
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
#if CONFIG_EXT_COMP_REFS
    int8_t uni_comp_ref_idx = av1_uni_comp_ref_idx(rf);
#if !USE_UNI_COMP_REFS
    // NOTE: uni-directional comp refs disabled
    assert(uni_comp_ref_idx < 0);
#endif  // !USE_UNI_COMP_REFS
    if (uni_comp_ref_idx >= 0) {
      assert((TOTAL_REFS_PER_FRAME + FWD_REFS * BWD_REFS + uni_comp_ref_idx) <
             MODE_CTX_REF_FRAMES);
      return TOTAL_REFS_PER_FRAME + FWD_REFS * BWD_REFS + uni_comp_ref_idx;
    } else {
#endif  // CONFIG_EXT_COMP_REFS
      return TOTAL_REFS_PER_FRAME + FWD_RF_OFFSET(rf[0]) +
             BWD_RF_OFFSET(rf[1]) * FWD_REFS;
#if CONFIG_EXT_COMP_REFS
    }
#endif  // CONFIG_EXT_COMP_REFS
307
  }
Jingning Han's avatar
Jingning Han committed
308
309
310
311

  return rf[0];
}

312
// clang-format off
313
static MV_REFERENCE_FRAME ref_frame_map[COMP_REFS][2] = {
314
#if CONFIG_EXT_REFS
clang-format's avatar
clang-format committed
315
316
317
  { LAST_FRAME, BWDREF_FRAME },  { LAST2_FRAME, BWDREF_FRAME },
  { LAST3_FRAME, BWDREF_FRAME }, { GOLDEN_FRAME, BWDREF_FRAME },

318
319
320
  { LAST_FRAME, ALTREF2_FRAME },  { LAST2_FRAME, ALTREF2_FRAME },
  { LAST3_FRAME, ALTREF2_FRAME }, { GOLDEN_FRAME, ALTREF2_FRAME },

clang-format's avatar
clang-format committed
321
322
  { LAST_FRAME, ALTREF_FRAME },  { LAST2_FRAME, ALTREF_FRAME },
  { LAST3_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }
Zoe Liu's avatar
Zoe Liu committed
323
324
325

  // TODO(zoeliu): Temporarily disable uni-directional comp refs
#if CONFIG_EXT_COMP_REFS
326
327
  , { LAST_FRAME, LAST2_FRAME }, { LAST_FRAME, LAST3_FRAME },
  { LAST_FRAME, GOLDEN_FRAME }, { BWDREF_FRAME, ALTREF_FRAME }
328
329
  // TODO(zoeliu): When ALTREF2 is enabled, we may add:
  //               {BWDREF_FRAME, ALTREF2_FRAME}
Zoe Liu's avatar
Zoe Liu committed
330
331
#endif  // CONFIG_EXT_COMP_REFS
#else  // !CONFIG_EXT_REFS
clang-format's avatar
clang-format committed
332
  { LAST_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }
Zoe Liu's avatar
Zoe Liu committed
333
#endif  // CONFIG_EXT_REFS
334
};
335
// clang-format on
336

Yaowu Xu's avatar
Yaowu Xu committed
337
338
static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf,
                                     int8_t ref_frame_type) {
339
340
341
  if (ref_frame_type >= TOTAL_REFS_PER_FRAME) {
    rf[0] = ref_frame_map[ref_frame_type - TOTAL_REFS_PER_FRAME][0];
    rf[1] = ref_frame_map[ref_frame_type - TOTAL_REFS_PER_FRAME][1];
Jingning Han's avatar
Jingning Han committed
342
343
  } else {
    rf[0] = ref_frame_type;
Emil Keyder's avatar
Emil Keyder committed
344
    rf[1] = NONE_FRAME;
345
346
347
348
349
350
#if CONFIG_INTRABC
    assert(ref_frame_type > NONE_FRAME);
#else
    assert(ref_frame_type > INTRA_FRAME);
#endif
    assert(ref_frame_type < TOTAL_REFS_PER_FRAME);
Jingning Han's avatar
Jingning Han committed
351
352
353
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
354
static INLINE int16_t av1_mode_context_analyzer(
Yaowu Xu's avatar
Yaowu Xu committed
355
356
    const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf,
    BLOCK_SIZE bsize, int block) {
357
  int16_t mode_ctx = 0;
Yaowu Xu's avatar
Yaowu Xu committed
358
359
  int8_t ref_frame_type = av1_ref_frame_type(rf);

360
361
  if (block >= 0) {
    mode_ctx = mode_context[rf[0]] & 0x00ff;
362
#if !CONFIG_CB4X4
363
364
    if (block > 0 && bsize < BLOCK_8X8 && bsize > BLOCK_4X4)
      mode_ctx |= (1 << SKIP_NEARESTMV_SUB8X8_OFFSET);
365
366
367
368
#else
    (void)block;
    (void)bsize;
#endif
369
370
371
372

    return mode_ctx;
  }

373
  return mode_context[ref_frame_type];
374
}
375

Yaowu Xu's avatar
Yaowu Xu committed
376
377
static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
                                  int ref_idx) {
378
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
379
380
      ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL)
    return 0;
381

382
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
Jingning Han's avatar
Jingning Han committed
383
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
384
    return 2;
385

Jingning Han's avatar
Jingning Han committed
386
  if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
387
388
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
    return 3;
389
390
391

  return 0;
}
392

393
#if CONFIG_FRAME_MARKER
394
void av1_setup_frame_buf_refs(AV1_COMMON *cm);
395
#if CONFIG_MFMV
396
void av1_setup_motion_field(AV1_COMMON *cm);
397
398
#endif  // CONFIG_MFMV
#endif  // CONFIG_FRAME_MARKER
399

Jingning Han's avatar
Jingning Han committed
400
typedef void (*find_mv_refs_sync)(void *const data, int mi_row);
Yaowu Xu's avatar
Yaowu Xu committed
401
402
403
void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
                      MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
                      uint8_t *ref_mv_count, CANDIDATE_MV *ref_mv_stack,
404
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
405
                      int16_t *compound_mode_context,
406
#endif  // CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
407
408
409
                      int_mv *mv_ref_list, int mi_row, int mi_col,
                      find_mv_refs_sync sync, void *const data,
                      int16_t *mode_context);
Jingning Han's avatar
Jingning Han committed
410
411
412
413

// check a list of motion vectors by sad score using a number rows of pixels
// above and a number cols of pixels in the left to select the one with best
// score to use as ref motion vector
RogerZhou's avatar
RogerZhou committed
414
415
416
417
#if CONFIG_AMVR
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
                           int_mv *near_mv, int is_integer);
#else
Yaowu Xu's avatar
Yaowu Xu committed
418
419
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
                           int_mv *near_mv);
RogerZhou's avatar
RogerZhou committed
420
#endif
Jingning Han's avatar
Jingning Han committed
421

422
423
void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd,
                                   int block, int ref, int mi_row, int mi_col,
Yaowu Xu's avatar
Yaowu Xu committed
424
425
                                   CANDIDATE_MV *ref_mv_stack,
                                   uint8_t *ref_mv_count,
Yue Chen's avatar
Yue Chen committed
426
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
427
                                   int_mv *mv_list,
Yue Chen's avatar
Yue Chen committed
428
#endif  // CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
429
                                   int_mv *nearest_mv, int_mv *near_mv);
Jingning Han's avatar
Jingning Han committed
430

Yue Chen's avatar
Yue Chen committed
431
432
#if CONFIG_EXT_INTER
// This function keeps a mode count for a given MB/SB
433
434
435
436
void av1_update_mv_context(const AV1_COMMON *cm, 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
437
438
#endif  // CONFIG_EXT_INTER

Yue Chen's avatar
Yue Chen committed
439
#if CONFIG_WARPED_MOTION
440
441
442
443
444
#if WARPED_MOTION_SORT_SAMPLES
int sortSamples(int *pts_mv, MV *mv, int *pts, int *pts_inref, int len);
int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
                int *pts, int *pts_inref, int *pts_mv);
#else
Yue Chen's avatar
Yue Chen committed
445
int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
446
                int *pts, int *pts_inref);
447
#endif  // WARPED_MOTION_SORT_SAMPLES
Yue Chen's avatar
Yue Chen committed
448
449
#endif  // CONFIG_WARPED_MOTION

Alex Converse's avatar
Alex Converse committed
450
451
452
453
454
455
456
457
458
459
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
488
489
490
491
492
493
494
495
496
497
498
499
500
#if CONFIG_INTRABC
static INLINE void av1_find_ref_dv(int_mv *ref_dv, int mi_row, int mi_col) {
  // TODO(aconverse@google.com): Handle tiles and such
  (void)mi_col;
  if (mi_row < MAX_MIB_SIZE) {
    ref_dv->as_mv.row = 0;
    ref_dv->as_mv.col = -MI_SIZE * MAX_MIB_SIZE;
  } else {
    ref_dv->as_mv.row = -MI_SIZE * MAX_MIB_SIZE;
    ref_dv->as_mv.col = 0;
  }
}

static INLINE int is_dv_valid(const MV dv, const TileInfo *const tile,
                              int mi_row, int mi_col, BLOCK_SIZE bsize) {
  const int bw = block_size_wide[bsize];
  const int bh = block_size_high[bsize];
  const int SCALE_PX_TO_MV = 8;
  // Disallow subpixel for now
  // SUBPEL_MASK is not the correct scale
  if ((dv.row & (SCALE_PX_TO_MV - 1) || dv.col & (SCALE_PX_TO_MV - 1)))
    return 0;
  // Is the source top-left inside the current tile?
  const int src_top_edge = mi_row * MI_SIZE * SCALE_PX_TO_MV + dv.row;
  const int tile_top_edge = tile->mi_row_start * MI_SIZE * SCALE_PX_TO_MV;
  if (src_top_edge < tile_top_edge) return 0;
  const int src_left_edge = mi_col * MI_SIZE * SCALE_PX_TO_MV + dv.col;
  const int tile_left_edge = tile->mi_col_start * MI_SIZE * SCALE_PX_TO_MV;
  if (src_left_edge < tile_left_edge) return 0;
  // Is the bottom right inside the current tile?
  const int src_bottom_edge = (mi_row * MI_SIZE + bh) * SCALE_PX_TO_MV + dv.row;
  const int tile_bottom_edge = tile->mi_row_end * MI_SIZE * SCALE_PX_TO_MV;
  if (src_bottom_edge > tile_bottom_edge) return 0;
  const int src_right_edge = (mi_col * MI_SIZE + bw) * SCALE_PX_TO_MV + dv.col;
  const int tile_right_edge = tile->mi_col_end * MI_SIZE * SCALE_PX_TO_MV;
  if (src_right_edge > tile_right_edge) return 0;
  // Is the bottom right within an already coded SB?
  const int active_sb_top_edge =
      (mi_row & ~MAX_MIB_MASK) * MI_SIZE * SCALE_PX_TO_MV;
  const int active_sb_bottom_edge =
      ((mi_row & ~MAX_MIB_MASK) + MAX_MIB_SIZE) * MI_SIZE * SCALE_PX_TO_MV;
  const int active_sb_left_edge =
      (mi_col & ~MAX_MIB_MASK) * MI_SIZE * SCALE_PX_TO_MV;
  if (src_bottom_edge > active_sb_bottom_edge) return 0;
  if (src_bottom_edge > active_sb_top_edge &&
      src_right_edge > active_sb_left_edge)
    return 0;
  return 1;
}
#endif  // CONFIG_INTRABC

Jingning Han's avatar
Jingning Han committed
501
502
503
504
#ifdef __cplusplus
}  // extern "C"
#endif

Yaowu Xu's avatar
Yaowu Xu committed
505
#endif  // AV1_COMMON_MVREF_COMMON_H_