mvref_common.h 11.7 KB
Newer Older
Jingning Han's avatar
Jingning Han committed
1 2 3 4 5 6 7 8 9
/*
 *  Copyright (c) 2012 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
10 11
#ifndef VP10_COMMON_MVREF_COMMON_H_
#define VP10_COMMON_MVREF_COMMON_H_
Jingning Han's avatar
Jingning Han committed
12

13 14
#include "vp10/common/onyxc_int.h"
#include "vp10/common/blockd.h"
Jingning Han's avatar
Jingning Han committed
15 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

#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
Yue Chen's avatar
Yue Chen committed
58 59
#if CONFIG_EXT_INTER
  1,  // NEWFROMNEARMV
60 61 62 63 64 65 66 67 68
  0,  // NEAREST_NEARESTMV
  0,  // NEAREST_NEARMV
  0,  // NEAR_NEARESTMV
  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
69
#endif  // CONFIG_EXT_INTER
Jingning Han's avatar
Jingning Han committed
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
};

// 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] = {
  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
  INTRA_PLUS_NON_INTRA,  // 9
  INTRA_PLUS_NON_INTRA,  // 10
  INVALID_CASE,  // 11
  INTRA_PLUS_NON_INTRA,  // 12
  INVALID_CASE,  // 13
  INVALID_CASE,  // 14
  INVALID_CASE,  // 15
  INVALID_CASE,  // 16
  INVALID_CASE,  // 17
  BOTH_INTRA  // 18
};

static const POSITION mv_ref_blocks[BLOCK_SIZES][MVREF_NEIGHBOURS] = {
  // 4X4
  {{-1, 0}, {0, -1}, {-1, -1}, {-2, 0}, {0, -2}, {-2, -1}, {-1, -2}, {-2, -2}},
  // 4X8
  {{-1, 0}, {0, -1}, {-1, -1}, {-2, 0}, {0, -2}, {-2, -1}, {-1, -2}, {-2, -2}},
  // 8X4
  {{-1, 0}, {0, -1}, {-1, -1}, {-2, 0}, {0, -2}, {-2, -1}, {-1, -2}, {-2, -2}},
  // 8X8
  {{-1, 0}, {0, -1}, {-1, -1}, {-2, 0}, {0, -2}, {-2, -1}, {-1, -2}, {-2, -2}},
  // 8X16
  {{0, -1}, {-1, 0}, {1, -1}, {-1, -1}, {0, -2}, {-2, 0}, {-2, -1}, {-1, -2}},
  // 16X8
  {{-1, 0}, {0, -1}, {-1, 1}, {-1, -1}, {-2, 0}, {0, -2}, {-1, -2}, {-2, -1}},
  // 16X16
  {{-1, 0}, {0, -1}, {-1, 1}, {1, -1}, {-1, -1}, {-3, 0}, {0, -3}, {-3, -3}},
  // 16X32
  {{0, -1}, {-1, 0}, {2, -1}, {-1, -1}, {-1, 1}, {0, -3}, {-3, 0}, {-3, -3}},
  // 32X16
  {{-1, 0}, {0, -1}, {-1, 2}, {-1, -1}, {1, -1}, {-3, 0}, {0, -3}, {-3, -3}},
  // 32X32
  {{-1, 1}, {1, -1}, {-1, 2}, {2, -1}, {-1, -1}, {-3, 0}, {0, -3}, {-3, -3}},
  // 32X64
  {{0, -1}, {-1, 0}, {4, -1}, {-1, 2}, {-1, -1}, {0, -3}, {-3, 0}, {2, -1}},
  // 64X32
  {{-1, 0}, {0, -1}, {-1, 4}, {2, -1}, {-1, -1}, {-3, 0}, {0, -3}, {-1, 2}},
  // 64X64
  {{-1, 3}, {3, -1}, {-1, 4}, {4, -1}, {-1, -1}, {-1, 0}, {0, -1}, {-1, 6}}
};

static const int idx_n_column_to_subblock[4][2] = {
  {1, 2},
  {1, 3},
  {3, 2},
  {3, 3}
};

// clamp_mv_ref
134
#define MV_BORDER (8 << 3)  // Allow 8 pels in 1/8th pel units
Jingning Han's avatar
Jingning Han committed
135

136 137 138 139 140
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,
               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
141 142 143 144 145 146 147 148 149 150 151 152
}

// 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
          ? 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
153 154 155 156 157 158 159 160 161 162
#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
163 164 165 166 167 168 169 170 171 172 173 174 175

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

176 177
#define CLIP_IN_ADD(mv, bw, bh, xd) clamp_mv_ref(mv, bw, bh, xd)

Jingning Han's avatar
Jingning Han committed
178 179 180
// 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!
181
#define ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done) \
Jingning Han's avatar
Jingning Han committed
182
  do { \
183 184 185 186
    (mv_ref_list)[(refmv_count)] = (mv); \
    CLIP_IN_ADD(&(mv_ref_list)[(refmv_count)].as_mv, (bw), (bh), (xd)); \
    if (refmv_count && (mv_ref_list)[1].as_int != (mv_ref_list)[0].as_int) { \
        (refmv_count) = 2; \
Jingning Han's avatar
Jingning Han committed
187 188
        goto Done; \
    } \
189
    (refmv_count) = 1; \
Jingning Han's avatar
Jingning Han committed
190 191 192 193 194
  } 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, \
195
                                 mv_ref_list, bw, bh, xd, Done) \
Jingning Han's avatar
Jingning Han committed
196 197 198 199
  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), \
200
                        refmv_count, mv_ref_list, bw, bh, xd, Done); \
Jingning Han's avatar
Jingning Han committed
201
      if (has_second_ref(mbmi) && \
202
          (mbmi)->ref_frame[1] != ref_frame) \
Jingning Han's avatar
Jingning Han committed
203
        ADD_MV_REF_LIST(scale_mv((mbmi), 1, ref_frame, ref_sign_bias), \
204
                        refmv_count, mv_ref_list, bw, bh, xd, Done); \
Jingning Han's avatar
Jingning Han committed
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
    } \
  } while (0)


// Checks that the given mi_row, mi_col and search point
// are inside the borders of the tile.
static INLINE int is_inside(const TileInfo *const tile,
                            int mi_col, int mi_row, int mi_rows,
                            const POSITION *mi_pos) {
  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);
}

220 221 222 223 224 225 226 227 228 229
static INLINE void lower_mv_precision(MV *mv, int allow_hp) {
  const int use_hp = allow_hp && vp10_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);
  }
}

230
#if CONFIG_REF_MV
231 232 233 234 235 236 237 238
static INLINE int vp10_nmv_ctx(const uint8_t ref_mv_count,
                               const CANDIDATE_MV *ref_mv_stack) {
#if CONFIG_EXT_INTER
  return 0;
#endif
  if (ref_mv_stack[0].weight > REF_CAT_LEVEL &&
      ref_mv_count > 0) {
    if (abs(ref_mv_stack[0].this_mv.as_mv.row -
239 240 241 242 243
             ref_mv_stack[0].pred_mv.as_mv.row) <= 4 &&
         abs(ref_mv_stack[0].this_mv.as_mv.col -
             ref_mv_stack[0].pred_mv.as_mv.col) <= 4)
      return 2;
    else
244 245 246 247 248
      return 1;
  }
  return 0;
}

Yaowu Xu's avatar
Yaowu Xu committed
249
static INLINE int8_t vp10_ref_frame_type(const MV_REFERENCE_FRAME *const rf) {
Jingning Han's avatar
Jingning Han committed
250 251 252 253 254 255
  if (rf[1] > INTRA_FRAME)
    return rf[0] + ALTREF_FRAME;

  return rf[0];
}

Yaowu Xu's avatar
Yaowu Xu committed
256 257
static INLINE void vp10_set_ref_frame(MV_REFERENCE_FRAME *rf,
                                      int8_t ref_frame_type) {
Jingning Han's avatar
Jingning Han committed
258 259 260 261 262 263 264 265 266 267
  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);
  }
}

Yaowu Xu's avatar
Yaowu Xu committed
268 269 270
static INLINE int16_t vp10_mode_context_analyzer(
    const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf,
    BLOCK_SIZE bsize, int block) {
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
  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]];
}
288 289 290

static INLINE uint8_t vp10_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
                                   int ref_idx) {
Jingning Han's avatar
Jingning Han committed
291
  if (ref_mv_stack[ref_idx].weight > REF_CAT_LEVEL &&
292 293 294 295 296 297
      ref_mv_stack[ref_idx + 1].weight > REF_CAT_LEVEL) {
    if (ref_mv_stack[ref_idx].weight == ref_mv_stack[ref_idx + 1].weight)
      return 0;
    else
      return 1;
  }
298

Jingning Han's avatar
Jingning Han committed
299 300
  if (ref_mv_stack[ref_idx].weight > REF_CAT_LEVEL &&
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
301
    return 2;
302

Jingning Han's avatar
Jingning Han committed
303
  if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
304 305 306 307 308 309
      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL) {
    if (ref_mv_stack[ref_idx].weight == ref_mv_stack[ref_idx + 1].weight)
      return 3;
    else
      return 4;
  }
310 311 312 313

  assert(0);
  return 0;
}
314 315
#endif

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
void vp10_find_mv_refs(const VP10_COMMON *cm, const MACROBLOCKD *xd,
318 319 320 321
                       MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
#if CONFIG_REF_MV
                       uint8_t *ref_mv_count,
                       CANDIDATE_MV *ref_mv_stack,
322 323 324
#if CONFIG_EXT_INTER
                       int16_t *compound_mode_context,
#endif  // CONFIG_EXT_INTER
325 326 327
#endif
                       int_mv *mv_ref_list, int mi_row, int mi_col,
                       find_mv_refs_sync sync, void *const data,
328
                       int16_t *mode_context);
Jingning Han's avatar
Jingning Han committed
329 330 331 332

// 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
333
void vp10_find_best_ref_mvs(int allow_hp,
Jingning Han's avatar
Jingning Han committed
334 335
                           int_mv *mvlist, int_mv *nearest_mv, int_mv *near_mv);

Yaowu Xu's avatar
Yaowu Xu committed
336
void vp10_append_sub8x8_mvs_for_idx(VP10_COMMON *cm, MACROBLOCKD *xd,
337
                                    int block, int ref, int mi_row, int mi_col,
Yue Chen's avatar
Yue Chen committed
338 339 340
#if CONFIG_EXT_INTER
                                    int_mv *mv_list,
#endif  // CONFIG_EXT_INTER
341
                                    int_mv *nearest_mv, int_mv *near_mv);
Jingning Han's avatar
Jingning Han committed
342

Yue Chen's avatar
Yue Chen committed
343 344 345 346 347 348 349 350 351
#if CONFIG_EXT_INTER
// This function keeps a mode count for a given MB/SB
void vp10_update_mv_context(const VP10_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);
#endif  // CONFIG_EXT_INTER

Jingning Han's avatar
Jingning Han committed
352 353 354 355
#ifdef __cplusplus
}  // extern "C"
#endif

356
#endif  // VP10_COMMON_MVREF_COMMON_H_