mvref_common.h 12.2 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
Jingning Han's avatar
Jingning Han committed
3
 *
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
#ifndef AV1_COMMON_MVREF_COMMON_H_
#define AV1_COMMON_MVREF_COMMON_H_
Jingning Han's avatar
Jingning Han committed
13

Yaowu Xu's avatar
Yaowu Xu committed
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 21 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 54 55 56 57 58 59 60 61 62 63 64

#ifdef __cplusplus
extern "C" {
#endif

#define MVREF_NEIGHBOURS 8

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
  9,  // TM_PRED
  0,  // NEARESTMV
  0,  // NEARMV
  3,  // ZEROMV
  1,  // NEWMV
};

// 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
65 66 67 68 69 70 71 72 73
  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
74 75
  INTRA_PLUS_NON_INTRA,  // 9
  INTRA_PLUS_NON_INTRA,  // 10
clang-format's avatar
clang-format committed
76
  INVALID_CASE,          // 11
Jingning Han's avatar
Jingning Han committed
77
  INTRA_PLUS_NON_INTRA,  // 12
clang-format's avatar
clang-format committed
78 79 80 81 82 83
  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
84 85 86 87
};

static const POSITION mv_ref_blocks[BLOCK_SIZES][MVREF_NEIGHBOURS] = {
  // 4X4
clang-format's avatar
clang-format committed
88 89 90 91 92 93 94 95
  { { -1, 0 },
    { 0, -1 },
    { -1, -1 },
    { -2, 0 },
    { 0, -2 },
    { -2, -1 },
    { -1, -2 },
    { -2, -2 } },
Jingning Han's avatar
Jingning Han committed
96
  // 4X8
clang-format's avatar
clang-format committed
97 98 99 100 101 102 103 104
  { { -1, 0 },
    { 0, -1 },
    { -1, -1 },
    { -2, 0 },
    { 0, -2 },
    { -2, -1 },
    { -1, -2 },
    { -2, -2 } },
Jingning Han's avatar
Jingning Han committed
105
  // 8X4
clang-format's avatar
clang-format committed
106 107 108 109 110 111 112 113
  { { -1, 0 },
    { 0, -1 },
    { -1, -1 },
    { -2, 0 },
    { 0, -2 },
    { -2, -1 },
    { -1, -2 },
    { -2, -2 } },
Jingning Han's avatar
Jingning Han committed
114
  // 8X8
clang-format's avatar
clang-format committed
115 116 117 118 119 120 121 122
  { { -1, 0 },
    { 0, -1 },
    { -1, -1 },
    { -2, 0 },
    { 0, -2 },
    { -2, -1 },
    { -1, -2 },
    { -2, -2 } },
Jingning Han's avatar
Jingning Han committed
123
  // 8X16
clang-format's avatar
clang-format committed
124 125 126 127 128 129 130 131
  { { 0, -1 },
    { -1, 0 },
    { 1, -1 },
    { -1, -1 },
    { 0, -2 },
    { -2, 0 },
    { -2, -1 },
    { -1, -2 } },
Jingning Han's avatar
Jingning Han committed
132
  // 16X8
clang-format's avatar
clang-format committed
133 134 135 136 137 138 139 140
  { { -1, 0 },
    { 0, -1 },
    { -1, 1 },
    { -1, -1 },
    { -2, 0 },
    { 0, -2 },
    { -1, -2 },
    { -2, -1 } },
Jingning Han's avatar
Jingning Han committed
141
  // 16X16
clang-format's avatar
clang-format committed
142 143 144 145 146 147 148 149
  { { -1, 0 },
    { 0, -1 },
    { -1, 1 },
    { 1, -1 },
    { -1, -1 },
    { -3, 0 },
    { 0, -3 },
    { -3, -3 } },
Jingning Han's avatar
Jingning Han committed
150
  // 16X32
clang-format's avatar
clang-format committed
151 152 153 154 155 156 157 158
  { { 0, -1 },
    { -1, 0 },
    { 2, -1 },
    { -1, -1 },
    { -1, 1 },
    { 0, -3 },
    { -3, 0 },
    { -3, -3 } },
Jingning Han's avatar
Jingning Han committed
159
  // 32X16
clang-format's avatar
clang-format committed
160 161 162 163 164 165 166 167
  { { -1, 0 },
    { 0, -1 },
    { -1, 2 },
    { -1, -1 },
    { 1, -1 },
    { -3, 0 },
    { 0, -3 },
    { -3, -3 } },
Jingning Han's avatar
Jingning Han committed
168
  // 32X32
clang-format's avatar
clang-format committed
169 170 171 172 173 174 175 176
  { { -1, 1 },
    { 1, -1 },
    { -1, 2 },
    { 2, -1 },
    { -1, -1 },
    { -3, 0 },
    { 0, -3 },
    { -3, -3 } },
Jingning Han's avatar
Jingning Han committed
177
  // 32X64
clang-format's avatar
clang-format committed
178 179 180 181 182 183 184 185
  { { 0, -1 },
    { -1, 0 },
    { 4, -1 },
    { -1, 2 },
    { -1, -1 },
    { 0, -3 },
    { -3, 0 },
    { 2, -1 } },
Jingning Han's avatar
Jingning Han committed
186
  // 64X32
clang-format's avatar
clang-format committed
187 188 189 190 191 192 193 194
  { { -1, 0 },
    { 0, -1 },
    { -1, 4 },
    { 2, -1 },
    { -1, -1 },
    { -3, 0 },
    { 0, -3 },
    { -1, 2 } },
Jingning Han's avatar
Jingning Han committed
195
  // 64X64
clang-format's avatar
clang-format committed
196 197 198 199 200 201 202 203
  { { -1, 3 },
    { 3, -1 },
    { -1, 4 },
    { 4, -1 },
    { -1, -1 },
    { -1, 0 },
    { 0, -1 },
    { -1, 6 } }
Jingning Han's avatar
Jingning Han committed
204 205 206
};

static const int idx_n_column_to_subblock[4][2] = {
clang-format's avatar
clang-format committed
207
  { 1, 2 }, { 1, 3 }, { 3, 2 }, { 3, 3 }
Jingning Han's avatar
Jingning Han committed
208 209 210
};

// clamp_mv_ref
211 212 213
#if CONFIG_MISC_FIXES
#define MV_BORDER (8 << 3)  // Allow 8 pels in 1/8th pel units
#else
Jingning Han's avatar
Jingning Han committed
214
#define MV_BORDER (16 << 3)  // Allow 16 pels in 1/8th pel units
215
#endif
Jingning Han's avatar
Jingning Han committed
216

217 218 219
static INLINE void clamp_mv_ref(MV *mv, int bw, int bh, const MACROBLOCKD *xd) {
#if CONFIG_MISC_FIXES
  clamp_mv(mv, xd->mb_to_left_edge - bw * 8 - MV_BORDER,
clang-format's avatar
clang-format committed
220 221 222
           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);
223
#else
clang-format's avatar
clang-format committed
224 225
  (void)bw;
  (void)bh;
Jingning Han's avatar
Jingning Han committed
226
  clamp_mv(mv, xd->mb_to_left_edge - MV_BORDER,
clang-format's avatar
clang-format committed
227 228
           xd->mb_to_right_edge + MV_BORDER, xd->mb_to_top_edge - MV_BORDER,
           xd->mb_to_bottom_edge + MV_BORDER);
229
#endif
Jingning Han's avatar
Jingning Han committed
230 231 232 233 234 235 236
}

// 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) {
  return block_idx >= 0 && candidate->mbmi.sb_type < BLOCK_8X8
clang-format's avatar
clang-format committed
237 238 239 240
             ? candidate
                   ->bmi[idx_n_column_to_subblock[block_idx][search_col == 0]]
                   .as_mv[which_mv]
             : candidate->mbmi.mv[which_mv];
Jingning Han's avatar
Jingning Han committed
241 242
}

243 244 245 246 247 248 249 250 251 252 253
#if CONFIG_REF_MV
static INLINE int_mv get_sub_block_pred_mv(const MODE_INFO *candidate,
                                           int which_mv,
                                           int search_col, int block_idx) {
  return block_idx >= 0 && candidate->mbmi.sb_type < BLOCK_8X8 ?
      candidate->bmi[idx_n_column_to_subblock[block_idx]
                    [search_col == 0]].pred_mv[which_mv] :
      candidate->mbmi.pred_mv[which_mv];
}
#endif

Jingning Han's avatar
Jingning Han committed
254 255 256 257 258 259 260 261 262 263 264 265
// 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;
}

266 267 268
#if CONFIG_MISC_FIXES
#define CLIP_IN_ADD(mv, bw, bh, xd) clamp_mv_ref(mv, bw, bh, xd)
#else
clang-format's avatar
clang-format committed
269 270 271
#define CLIP_IN_ADD(mv, bw, bh, xd) \
  do {                              \
  } while (0)
272 273
#endif

Jingning Han's avatar
Jingning Han committed
274 275 276
// 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
277 278 279 280
#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));      \
281
    if (refmv_count && (mv_ref_list)[1].as_int != (mv_ref_list)[0].as_int) { \
clang-format's avatar
clang-format committed
282 283 284 285
      (refmv_count) = 2;                                                     \
      goto Done;                                                             \
    }                                                                        \
    (refmv_count) = 1;                                                       \
Jingning Han's avatar
Jingning Han committed
286 287 288 289 290
  } 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
291 292 293 294 295 296 297 298 299 300 301 302 303
                                 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) &&                                             \
          (CONFIG_MISC_FIXES ||                                               \
           (mbmi)->mv[1].as_int != (mbmi)->mv[0].as_int) &&                   \
          (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
304 305 306 307
  } while (0)

// Checks that the given mi_row, mi_col and search point
// are inside the borders of the tile.
clang-format's avatar
clang-format committed
308 309
static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row,
                            int mi_rows, const POSITION *mi_pos) {
Jingning Han's avatar
Jingning Han committed
310 311 312 313 314 315
  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);
}

316 317 318 319 320 321 322 323 324 325
static INLINE void lower_mv_precision(MV *mv, int allow_hp) {
  const int use_hp = allow_hp && av1_use_mv_hp(mv);
  if (!use_hp) {
    if (mv->row & 1)
      mv->row += (mv->row > 0 ? -1 : 1);
    if (mv->col & 1)
      mv->col += (mv->col > 0 ? -1 : 1);
  }
}

326
#if CONFIG_REF_MV
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
static int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) {
  if (rf[1] > INTRA_FRAME)
    return rf[0] + ALTREF_FRAME;

  return rf[0];
}

static void av1_set_ref_frame(MV_REFERENCE_FRAME *rf, int8_t ref_frame_type) {
  if (ref_frame_type > ALTREF_FRAME) {
    rf[0] = ref_frame_type - ALTREF_FRAME;
    rf[1] = ALTREF_FRAME;
  } else {
    rf[0] = ref_frame_type;
    rf[1] = NONE;
    assert(ref_frame_type > INTRA_FRAME && ref_frame_type < MAX_REF_FRAMES);
  }
}

345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
static int16_t av1_mode_context_analyzer(const int16_t *const mode_context,
                                         const MV_REFERENCE_FRAME *const rf,
                                         BLOCK_SIZE bsize, int block) {
  int16_t mode_ctx = 0;
  if (block >= 0) {
    mode_ctx = mode_context[rf[0]] & 0x00ff;

    if (block > 0 && bsize < BLOCK_8X8 && bsize > BLOCK_4X4)
      mode_ctx |= (1 << SKIP_NEARESTMV_SUB8X8_OFFSET);

    return mode_ctx;
  }

  if (rf[1] > INTRA_FRAME)
    return mode_context[rf[0]] & (mode_context[rf[1]] | 0x00ff);
  else if (rf[0] != ALTREF_FRAME)
    return mode_context[rf[0]] & ~(mode_context[ALTREF_FRAME] & 0xfe00);
  else
    return mode_context[rf[0]];
}
365 366 367

static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
                                   int ref_idx) {
Jingning Han's avatar
Jingning Han committed
368 369
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
      ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL)
370 371
    return 0;

Jingning Han's avatar
Jingning Han committed
372 373
  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
374 375
    return 1;

Jingning Han's avatar
Jingning Han committed
376 377
  if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
378 379 380 381 382
    return 2;

  assert(0);
  return 0;
}
383 384
#endif

Jingning Han's avatar
Jingning Han committed
385
typedef void (*find_mv_refs_sync)(void *const data, int mi_row);
386
void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
387 388 389 390 391 392 393
                      MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
#if CONFIG_REF_MV
                      uint8_t *ref_mv_count,
                      CANDIDATE_MV *ref_mv_stack,
#endif
                      int_mv *mv_ref_list, int mi_row, int mi_col,
                      find_mv_refs_sync sync, void *const data,
394
                      int16_t *mode_context);
Jingning Han's avatar
Jingning Han committed
395 396 397 398

// 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
399
void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
clang-format's avatar
clang-format committed
400
                            int_mv *near_mv);
Jingning Han's avatar
Jingning Han committed
401

402
void av1_append_sub8x8_mvs_for_idx(AV1_COMMON *cm, MACROBLOCKD *xd, int block,
403 404
                                   int ref, int mi_row, int mi_col,
                                   int_mv *nearest_mv, int_mv *near_mv);
Jingning Han's avatar
Jingning Han committed
405 406 407 408 409

#ifdef __cplusplus
}  // extern "C"
#endif

410
#endif  // AV1_COMMON_MVREF_COMMON_H_