mvref_common.h 14.7 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
Jingning Han's avatar
Jingning Han committed
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

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 ).
static const int mode_2_counter[MB_MODE_COUNT] = {
  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
54
55
56
57
58
59
60
61
#if CONFIG_ALT_INTRA
  9,    // SMOOTH_PRED
#endif  // CONFIG_ALT_INTRA
  9,    // TM_PRED
  0,    // NEARESTMV
  0,    // NEARMV
  3,    // ZEROMV
  1,    // NEWMV
Yue Chen's avatar
Yue Chen committed
62
#if CONFIG_EXT_INTER
63
64
65
66
67
68
69
#if CONFIG_COMPOUND_SINGLEREF
  0,    // SR_NEAREST_NEARMV
  1,    // SR_NEAREST_NEWMV
  1,    // SR_NEAR_NEWMV
  3,    // SR_ZERO_NEWMV
  1,    // SR_NEW_NEWMV
#endif  // CONFIG_COMPOUND_SINGLEREF
clang-format's avatar
clang-format committed
70
71
72
73
74
75
76
77
  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
78
#endif  // CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
79
80
81
82
83
84
};

// 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
85
86
87
88
89
90
91
92
93
  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
94
95
  INTRA_PLUS_NON_INTRA,  // 9
  INTRA_PLUS_NON_INTRA,  // 10
clang-format's avatar
clang-format committed
96
  INVALID_CASE,          // 11
Jingning Han's avatar
Jingning Han committed
97
  INTRA_PLUS_NON_INTRA,  // 12
clang-format's avatar
clang-format committed
98
99
100
101
102
103
  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
104
105
106
};

static const int idx_n_column_to_subblock[4][2] = {
clang-format's avatar
clang-format committed
107
  { 1, 2 }, { 1, 3 }, { 3, 2 }, { 3, 3 }
Jingning Han's avatar
Jingning Han committed
108
109
110
};

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

117
118
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
119
120
121
           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
122
123
124
125
126
127
}

// 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
128
  (void)search_col;
129
  (void)block_idx;
Deng's avatar
Deng committed
130
  return candidate->mbmi.mv[which_mv];
Jingning Han's avatar
Jingning Han committed
131
132
}

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

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

153
154
#define CLIP_IN_ADD(mv, bw, bh, xd) clamp_mv_ref(mv, bw, bh, xd)

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

// Checks that the given mi_row, mi_col and search point
// are inside the borders of the tile.
186
static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row,
187
                            int mi_rows, const AV1_COMMON *cm,
188
                            const POSITION *mi_pos) {
189
190
191
192
193
194
#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
195
196
197
#if CONFIG_TILE_GROUPS
  if (dependent_horz_tile_flag && !tile->tg_horz_boundary) {
#else
198
  if (dependent_horz_tile_flag) {
199
#endif
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

212
static INLINE void lower_mv_precision(MV *mv, int allow_hp) {
Alex Converse's avatar
Alex Converse committed
213
  if (!allow_hp) {
clang-format's avatar
clang-format committed
214
215
    if (mv->row & 1) mv->row += (mv->row > 0 ? -1 : 1);
    if (mv->col & 1) mv->col += (mv->col > 0 ? -1 : 1);
216
217
218
  }
}

219
220
221
222
223
224
225
226
227
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
228
static INLINE int av1_nmv_ctx(const uint8_t ref_mv_count,
Yaowu Xu's avatar
Yaowu Xu committed
229
230
                              const CANDIDATE_MV *ref_mv_stack, int ref,
                              int ref_mv_idx) {
231
232
  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
233

234
235
236
  return 0;
}

Yaowu Xu's avatar
Yaowu Xu committed
237
static INLINE int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) {
238
  if (rf[1] > INTRA_FRAME) {
239
    return TOTAL_REFS_PER_FRAME + FWD_RF_OFFSET(rf[0]) +
clang-format's avatar
clang-format committed
240
           BWD_RF_OFFSET(rf[1]) * FWD_REFS;
241
  }
Jingning Han's avatar
Jingning Han committed
242
243
244
245

  return rf[0];
}

246
// clang-format off
247
static MV_REFERENCE_FRAME ref_frame_map[COMP_REFS][2] = {
248
#if CONFIG_EXT_REFS
clang-format's avatar
clang-format committed
249
250
251
252
253
  { LAST_FRAME, BWDREF_FRAME },  { LAST2_FRAME, BWDREF_FRAME },
  { LAST3_FRAME, BWDREF_FRAME }, { GOLDEN_FRAME, BWDREF_FRAME },

  { LAST_FRAME, ALTREF_FRAME },  { LAST2_FRAME, ALTREF_FRAME },
  { LAST3_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }
254
#else
clang-format's avatar
clang-format committed
255
  { LAST_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }
256
257
#endif
};
258
// clang-format on
259

Yaowu Xu's avatar
Yaowu Xu committed
260
261
static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf,
                                     int8_t ref_frame_type) {
262
263
264
  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
265
266
  } else {
    rf[0] = ref_frame_type;
Emil Keyder's avatar
Emil Keyder committed
267
    rf[1] = NONE_FRAME;
268
269
270
271
272
273
#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
274
275
276
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
277
static INLINE int16_t av1_mode_context_analyzer(
Yaowu Xu's avatar
Yaowu Xu committed
278
279
    const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf,
    BLOCK_SIZE bsize, int block) {
280
  int16_t mode_ctx = 0;
Yaowu Xu's avatar
Yaowu Xu committed
281
282
  int8_t ref_frame_type = av1_ref_frame_type(rf);

283
284
  if (block >= 0) {
    mode_ctx = mode_context[rf[0]] & 0x00ff;
285
#if !CONFIG_CB4X4
286
287
    if (block > 0 && bsize < BLOCK_8X8 && bsize > BLOCK_4X4)
      mode_ctx |= (1 << SKIP_NEARESTMV_SUB8X8_OFFSET);
288
289
290
291
#else
    (void)block;
    (void)bsize;
#endif
292
293
294
295

    return mode_ctx;
  }

296
  return mode_context[ref_frame_type];
297
}
298

Yaowu Xu's avatar
Yaowu Xu committed
299
300
static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
                                  int ref_idx) {
301
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
302
303
      ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL)
    return 0;
304

305
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
Jingning Han's avatar
Jingning Han committed
306
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
307
    return 2;
308

Jingning Han's avatar
Jingning Han committed
309
  if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
310
311
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
    return 3;
312
313
314

  return 0;
}
315

Jingning Han's avatar
Jingning Han committed
316
typedef void (*find_mv_refs_sync)(void *const data, int mi_row);
Yaowu Xu's avatar
Yaowu Xu committed
317
318
319
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,
320
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
321
                      int16_t *compound_mode_context,
322
#endif  // CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
323
324
325
                      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
326
327
328
329

// 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
Yaowu Xu's avatar
Yaowu Xu committed
330
331
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
332

333
334
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
335
336
                                   CANDIDATE_MV *ref_mv_stack,
                                   uint8_t *ref_mv_count,
Yue Chen's avatar
Yue Chen committed
337
#if CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
338
                                   int_mv *mv_list,
Yue Chen's avatar
Yue Chen committed
339
#endif  // CONFIG_EXT_INTER
Yaowu Xu's avatar
Yaowu Xu committed
340
                                   int_mv *nearest_mv, int_mv *near_mv);
Jingning Han's avatar
Jingning Han committed
341

Yue Chen's avatar
Yue Chen committed
342
343
#if CONFIG_EXT_INTER
// This function keeps a mode count for a given MB/SB
344
345
346
347
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
348
349
#endif  // CONFIG_EXT_INTER

Yue Chen's avatar
Yue Chen committed
350
351
#if CONFIG_WARPED_MOTION
int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
352
                int *pts, int *pts_inref);
Yue Chen's avatar
Yue Chen committed
353
354
#endif  // CONFIG_WARPED_MOTION

Alex Converse's avatar
Alex Converse committed
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
#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
406
407
408
409
#ifdef __cplusplus
}  // extern "C"
#endif

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