mvref_common.h 20.4 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
  9,  // SMOOTH_PRED
57
58
59
60
61
62
63
  9,  // SMOOTH_V_PRED
  9,  // SMOOTH_H_PRED
  9,  // PAETH_PRED
  0,  // NEARESTMV
  0,  // NEARMV
  3,  // GLOBALMV
  1,  // NEWMV
64
65
66
67
68
69
70
71
  0,  // NEAREST_NEARESTMV
  0,  // NEAR_NEARMV
  1,  // NEAREST_NEWMV
  1,  // NEW_NEARESTMV
  1,  // NEAR_NEWMV
  1,  // NEW_NEARMV
  3,  // GLOBAL_GLOBALMV
  1,  // NEW_NEWMV
Jingning Han's avatar
Jingning Han committed
72
73
74
75
76
77
};

// 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
78
79
80
81
82
83
84
85
86
  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
87
88
  INTRA_PLUS_NON_INTRA,  // 9
  INTRA_PLUS_NON_INTRA,  // 10
clang-format's avatar
clang-format committed
89
  INVALID_CASE,          // 11
Jingning Han's avatar
Jingning Han committed
90
  INTRA_PLUS_NON_INTRA,  // 12
clang-format's avatar
clang-format committed
91
92
93
94
95
96
  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
97
98
99
};

static const int idx_n_column_to_subblock[4][2] = {
clang-format's avatar
clang-format committed
100
  { 1, 2 }, { 1, 3 }, { 3, 2 }, { 3, 3 }
Jingning Han's avatar
Jingning Han committed
101
102
103
};

// clamp_mv_ref
104
#if CONFIG_EXT_PARTITION
clang-format's avatar
clang-format committed
105
#define MV_BORDER (16 << 3)  // Allow 16 pels in 1/8th pel units
106
#else
clang-format's avatar
clang-format committed
107
108
#define MV_BORDER (8 << 3)  // Allow 8 pels in 1/8th pel units
#endif                      // CONFIG_EXT_PARTITION
Jingning Han's avatar
Jingning Han committed
109

110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#if CONFIG_FRAME_MARKER
// Get the number of frames between the current frame and a reference frame
static INLINE int get_ref_frame_dist(const AV1_COMMON *cm,
                                     MV_REFERENCE_FRAME ref) {
  // get the offset between the key frame and the current frame
  const int cur_frame_offset = cm->frame_offset;
  // get the offset between the key frame and the reference frame
  const int ref_buf_idx = cm->frame_refs[ref - LAST_FRAME].idx;
  if (ref_buf_idx == INVALID_IDX) return INT_MAX;
  const int ref_frame_offset =
      cm->buffer_pool->frame_bufs[ref_buf_idx].cur_frame_offset;
  return cur_frame_offset - ref_frame_offset;
}
#endif  // CONFIG_FRAME_MARKER

125
126
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
127
128
129
           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
130
131
132
133
134
}

// 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,
Luc Trudeau's avatar
Luc Trudeau committed
135
                                      int search_col) {
Yaowu Xu's avatar
Yaowu Xu committed
136
  (void)search_col;
Deng's avatar
Deng committed
137
  return candidate->mbmi.mv[which_mv];
Jingning Han's avatar
Jingning Han committed
138
139
}

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

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

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

Jingning Han's avatar
Jingning Han committed
160
161
162
// 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
163
164
165
166
#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));      \
167
    if (refmv_count && (mv_ref_list)[1].as_int != (mv_ref_list)[0].as_int) { \
clang-format's avatar
clang-format committed
168
169
170
171
      (refmv_count) = 2;                                                     \
      goto Done;                                                             \
    }                                                                        \
    (refmv_count) = 1;                                                       \
Jingning Han's avatar
Jingning Han committed
172
173
174
175
176
  } 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
177
178
179
180
181
182
183
184
185
186
                                 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
187
188
  } while (0)

Zoe Liu's avatar
Zoe Liu committed
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
#if CONFIG_EXT_SKIP
// This macro is used to add a motion vector pair to the skip mode mv list.
#define SKIP_MODE_MV_LIST_ADD(mv, mv_list, mv_list_count, mv_list_idx, bw, bh, \
                              xd)                                              \
  do {                                                                         \
    const int mv_idx = (mv_list_count)[mv_list_idx];                           \
    (mv_list)[mv_list_idx][mv_idx][0] = (mv)[0];                               \
    CLIP_IN_ADD(&(mv_list)[mv_list_idx][mv_idx][0].as_mv, (bw), (bh), (xd));   \
    if (mv_list_idx == 2) {                                                    \
      (mv_list)[mv_list_idx][mv_idx][1] = (mv)[1];                             \
      CLIP_IN_ADD(&(mv_list)[mv_list_idx][mv_idx][1].as_mv, (bw), (bh), (xd)); \
    }                                                                          \
    (mv_list_count)[mv_list_idx]++;                                            \
  } while (0)
#endif  // CONFIG_EXT_SKIP

Jingning Han's avatar
Jingning Han committed
205
206
// Checks that the given mi_row, mi_col and search point
// are inside the borders of the tile.
207
static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row,
208
                            int mi_rows, const AV1_COMMON *cm,
209
                            const POSITION *mi_pos) {
210
211
212
213
214
215
#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
216
  if (dependent_horz_tile_flag && !tile->tg_horz_boundary) {
217
218
219
220
221
222
223
224
225
226
227
    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
228

Yunqing Wang's avatar
Yunqing Wang committed
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
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
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
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
267
  }
RogerZhou's avatar
RogerZhou committed
268
#endif
269
270
}

271
272
273
274
275
276
277
278
279
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
280
static INLINE int av1_nmv_ctx(const uint8_t ref_mv_count,
Yaowu Xu's avatar
Yaowu Xu committed
281
282
                              const CANDIDATE_MV *ref_mv_stack, int ref,
                              int ref_mv_idx) {
283
284
  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
285

286
287
288
  return 0;
}

Zoe Liu's avatar
Zoe Liu committed
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
#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
305
static INLINE int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) {
306
  if (rf[1] > INTRA_FRAME) {
Zoe Liu's avatar
Zoe Liu committed
307
308
309
310
311
312
313
314
315
316
317
318
319
#if CONFIG_EXT_COMP_REFS
    int8_t uni_comp_ref_idx = av1_uni_comp_ref_idx(rf);
    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
320
  }
Jingning Han's avatar
Jingning Han committed
321
322
323
324

  return rf[0];
}

325
// clang-format off
326
static MV_REFERENCE_FRAME ref_frame_map[COMP_REFS][2] = {
clang-format's avatar
clang-format committed
327
328
329
  { LAST_FRAME, BWDREF_FRAME },  { LAST2_FRAME, BWDREF_FRAME },
  { LAST3_FRAME, BWDREF_FRAME }, { GOLDEN_FRAME, BWDREF_FRAME },

330
331
332
  { LAST_FRAME, ALTREF2_FRAME },  { LAST2_FRAME, ALTREF2_FRAME },
  { LAST3_FRAME, ALTREF2_FRAME }, { GOLDEN_FRAME, ALTREF2_FRAME },

clang-format's avatar
clang-format committed
333
334
  { LAST_FRAME, ALTREF_FRAME },  { LAST2_FRAME, ALTREF_FRAME },
  { LAST3_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }
Zoe Liu's avatar
Zoe Liu committed
335
336
337

  // TODO(zoeliu): Temporarily disable uni-directional comp refs
#if CONFIG_EXT_COMP_REFS
338
339
  , { LAST_FRAME, LAST2_FRAME }, { LAST_FRAME, LAST3_FRAME },
  { LAST_FRAME, GOLDEN_FRAME }, { BWDREF_FRAME, ALTREF_FRAME }
340
341
  // TODO(zoeliu): When ALTREF2 is enabled, we may add:
  //               {BWDREF_FRAME, ALTREF2_FRAME}
Zoe Liu's avatar
Zoe Liu committed
342
#endif  // CONFIG_EXT_COMP_REFS
343
};
344
// clang-format on
345

Yaowu Xu's avatar
Yaowu Xu committed
346
347
static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf,
                                     int8_t ref_frame_type) {
348
349
350
  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
351
352
  } else {
    rf[0] = ref_frame_type;
Emil Keyder's avatar
Emil Keyder committed
353
    rf[1] = NONE_FRAME;
354
355
356
357
358
359
#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
360
361
362
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
363
static INLINE int16_t av1_mode_context_analyzer(
Yaowu Xu's avatar
Yaowu Xu committed
364
365
    const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf,
    BLOCK_SIZE bsize, int block) {
366
  int16_t mode_ctx = 0;
Yaowu Xu's avatar
Yaowu Xu committed
367
368
  int8_t ref_frame_type = av1_ref_frame_type(rf);

369
370
  if (block >= 0) {
    mode_ctx = mode_context[rf[0]] & 0x00ff;
371
372
    (void)block;
    (void)bsize;
373
374
375
376

    return mode_ctx;
  }

377
  return mode_context[ref_frame_type];
378
}
379

Yaowu Xu's avatar
Yaowu Xu committed
380
381
static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
                                  int ref_idx) {
382
383
384
385
386
387
388
#if CONFIG_OPT_REF_MV
  if (ref_mv_stack[0].weight >= REF_CAT_LEVEL)
    return 0;
  else
    return 2;
#endif

389
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
390
391
      ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL)
    return 0;
392

393
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
Jingning Han's avatar
Jingning Han committed
394
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
395
    return 2;
396

Jingning Han's avatar
Jingning Han committed
397
  if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
398
399
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
    return 3;
400
401
402

  return 0;
}
403

404
#if CONFIG_FRAME_MARKER
405
void av1_setup_frame_buf_refs(AV1_COMMON *cm);
406
407
408
#if CONFIG_FRAME_SIGN_BIAS
void av1_setup_frame_sign_bias(AV1_COMMON *cm);
#endif  // CONFIG_FRAME_SIGN_BIAS
Zoe Liu's avatar
Zoe Liu committed
409
410
411
#if CONFIG_EXT_SKIP
void av1_setup_skip_mode_allowed(AV1_COMMON *cm);
#endif  // CONFIG_EXT_SKIP
412
#if CONFIG_MFMV
413
void av1_setup_motion_field(AV1_COMMON *cm);
414
415
#endif  // CONFIG_MFMV
#endif  // CONFIG_FRAME_MARKER
416

417
418
419
void av1_copy_frame_mvs(const AV1_COMMON *const cm, MODE_INFO *mi, int mi_row,
                        int mi_col, int x_mis, int y_mis);

Jingning Han's avatar
Jingning Han committed
420
typedef void (*find_mv_refs_sync)(void *const data, int mi_row);
Yaowu Xu's avatar
Yaowu Xu committed
421
422
423
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,
424
425
426
                      int16_t *compound_mode_context, int_mv *mv_ref_list,
                      int mi_row, int mi_col, find_mv_refs_sync sync,
                      void *const data, int16_t *mode_context);
Zoe Liu's avatar
Zoe Liu committed
427
428
429
430
431
432
#if CONFIG_EXT_SKIP
void av1_setup_skip_mode_mvs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
                             MB_MODE_INFO *mbmi, int mi_row, int mi_col,
                             const int_mv nearest_mv[2], find_mv_refs_sync sync,
                             void *const data);
#endif  // CONFIG_EXT_SKIP
Jingning Han's avatar
Jingning Han committed
433
434
435
436

// 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
437
438
439
440
#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
441
442
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
443
#endif
Jingning Han's avatar
Jingning Han committed
444

Yue Chen's avatar
Yue Chen committed
445
// This function keeps a mode count for a given MB/SB
446
447
void av1_update_mv_context(const AV1_COMMON *cm, const MACROBLOCKD *xd,
                           MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
Luc Trudeau's avatar
Luc Trudeau committed
448
449
                           int_mv *mv_ref_list, int mi_row, int mi_col,
                           int16_t *mode_context);
Yue Chen's avatar
Yue Chen committed
450

Yunqing Wang's avatar
Yunqing Wang committed
451
#if CONFIG_EXT_WARPED_MOTION
452
453
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,
454
                int *pts, int *pts_inref, int *pts_mv, int *pts_wm);
455
#else
Yue Chen's avatar
Yue Chen committed
456
int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
457
                int *pts, int *pts_inref);
Yunqing Wang's avatar
Yunqing Wang committed
458
#endif  // CONFIG_EXT_WARPED_MOTION
Yue Chen's avatar
Yue Chen committed
459

Alex Converse's avatar
Alex Converse committed
460
#if CONFIG_INTRABC
Hui Su's avatar
Hui Su committed
461
462
463
464
465
466
467
#define INTRABC_DELAY_PIXELS 256  //  Delay of 256 pixels
#define INTRABC_DELAY_SB64 (INTRABC_DELAY_PIXELS / 64)
#define USE_WAVE_FRONT 1  // Use only top left area of frame for reference.
#define INTRABC_ROW_DELAY 8

static INLINE void av1_find_ref_dv(int_mv *ref_dv, const TileInfo *const tile,
                                   int mib_size, int mi_row, int mi_col) {
Alex Converse's avatar
Alex Converse committed
468
  (void)mi_col;
Hui Su's avatar
Hui Su committed
469
  if (mi_row - mib_size < tile->mi_row_start) {
Alex Converse's avatar
Alex Converse committed
470
    ref_dv->as_mv.row = 0;
Hui Su's avatar
Hui Su committed
471
    ref_dv->as_mv.col = -MI_SIZE * mib_size - INTRABC_DELAY_PIXELS;
Alex Converse's avatar
Alex Converse committed
472
  } else {
Hui Su's avatar
Hui Su committed
473
    ref_dv->as_mv.row = -MI_SIZE * mib_size;
Alex Converse's avatar
Alex Converse committed
474
475
    ref_dv->as_mv.col = 0;
  }
Hui Su's avatar
Hui Su committed
476
477
  ref_dv->as_mv.row *= 8;
  ref_dv->as_mv.col *= 8;
Alex Converse's avatar
Alex Converse committed
478
479
}

Hui Su's avatar
Hui Su committed
480
481
482
static INLINE int av1_is_dv_valid(const MV dv, const TileInfo *const tile,
                                  int mi_row, int mi_col, BLOCK_SIZE bsize,
                                  int mib_size_log2) {
Alex Converse's avatar
Alex Converse committed
483
484
485
486
487
  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
488
  if (((dv.row & (SCALE_PX_TO_MV - 1)) || (dv.col & (SCALE_PX_TO_MV - 1))))
Alex Converse's avatar
Alex Converse committed
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
    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;
Hui Su's avatar
Hui Su committed
504
505
506
507
508

  // Is the bottom right within an already coded SB? Also consider additional
  // constraints to facilitate HW decoder.
  const int max_mib_size = 1 << mib_size_log2;
  const int active_sb_row = mi_row >> mib_size_log2;
509
  const int active_sb64_col = (mi_col * MI_SIZE) >> 6;
Hui Su's avatar
Hui Su committed
510
511
  const int sb_size = max_mib_size * MI_SIZE;
  const int src_sb_row = ((src_bottom_edge >> 3) - 1) / sb_size;
512
513
514
515
516
517
  const int src_sb64_col = ((src_right_edge >> 3) - 1) >> 6;
  const int total_sb64_per_row =
      ((tile->mi_col_end - tile->mi_col_start - 1) >> 4) + 1;
  const int active_sb64 = active_sb_row * total_sb64_per_row + active_sb64_col;
  const int src_sb64 = src_sb_row * total_sb64_per_row + src_sb64_col;
  if (src_sb64 >= active_sb64 - INTRABC_DELAY_SB64) return 0;
518
519
520
521
522
523
524
525
526
527
528
529
530
531

#if CONFIG_LPF_SB
  // Because of loop filter, the last 8 rows of current superblock row can't be
  // used as intrabc search area.
  if ((src_bottom_edge >> 3) >=
      (active_sb_row + 1) * sb_size - INTRABC_ROW_DELAY)
    return 0;

  // The last 8 rows of the above superblock is invalid
  if ((src_bottom_edge >> 3) >= active_sb_row * sb_size - INTRABC_ROW_DELAY &&
      (src_right_edge >> 3) >= (mi_col >> mib_size_log2) * sb_size)
    return 0;
#endif  // CONFIG_LPF_SB

Hui Su's avatar
Hui Su committed
532
#if USE_WAVE_FRONT
533
534
  const int gradient = 1 + INTRABC_DELAY_SB64 + (sb_size > 64);
  const int wf_offset = gradient * (active_sb_row - src_sb_row);
Hui Su's avatar
Hui Su committed
535
  if (src_sb_row > active_sb_row ||
536
      src_sb64_col >= active_sb64_col - INTRABC_DELAY_SB64 + wf_offset)
Alex Converse's avatar
Alex Converse committed
537
    return 0;
Hui Su's avatar
Hui Su committed
538
#endif
539

Alex Converse's avatar
Alex Converse committed
540
541
542
543
  return 1;
}
#endif  // CONFIG_INTRABC

Jingning Han's avatar
Jingning Han committed
544
545
546
547
#ifdef __cplusplus
}  // extern "C"
#endif

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