1 /* 2 * Copyright (c) 2016, Alliance for Open Media. All rights reserved 3 * 4 * This source code is subject to the terms of the BSD 2 Clause License and 5 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License 6 * was not distributed with this source code in the LICENSE file, you can 7 * obtain it at www.aomedia.org/license/software. If the Alliance for Open 8 * Media Patent License 1.0 was not distributed with this source code in the 9 * PATENTS file, you can obtain it at www.aomedia.org/license/patent. 10 */ 11 #ifndef AOM_AV1_COMMON_MVREF_COMMON_H_ 12 #define AOM_AV1_COMMON_MVREF_COMMON_H_ 13 14 #include "av1/common/onyxc_int.h" 15 #include "av1/common/blockd.h" 16 17 #ifdef __cplusplus 18 extern "C" { 19 #endif 20 21 #define MVREF_ROW_COLS 3 22 23 // Set the upper limit of the motion vector component magnitude. 24 // This would make a motion vector fit in 26 bits. Plus 3 bits for the 25 // reference frame index. A tuple of motion vector can hence be stored within 26 // 32 bit range for efficient load/store operations. 27 #define REFMVS_LIMIT ((1 << 12) - 1) 28 29 typedef struct position { 30 int row; 31 int col; 32 } POSITION; 33 34 // clamp_mv_ref 35 #define MV_BORDER (16 << 3) // Allow 16 pels in 1/8th pel units 36 37 static INLINE int get_relative_dist(const OrderHintInfo *oh, int a, int b) { 38 if (!oh->enable_order_hint) return 0; 39 40 const int bits = oh->order_hint_bits_minus_1 + 1; 41 42 assert(bits >= 1); 43 assert(a >= 0 && a < (1 << bits)); 44 assert(b >= 0 && b < (1 << bits)); 45 46 int diff = a - b; 47 const int m = 1 << (bits - 1); 48 diff = (diff & (m - 1)) - (diff & m); 49 return diff; 50 } 51 52 static INLINE void clamp_mv_ref(MV *mv, int bw, int bh, const MACROBLOCKD *xd) { 53 clamp_mv(mv, xd->mb_to_left_edge - bw * 8 - MV_BORDER, 54 xd->mb_to_right_edge + bw * 8 + MV_BORDER, 55 xd->mb_to_top_edge - bh * 8 - MV_BORDER, 56 xd->mb_to_bottom_edge + bh * 8 + MV_BORDER); 57 } 58 59 // This function returns either the appropriate sub block or block's mv 60 // on whether the block_size < 8x8 and we have check_sub_blocks set. 61 static INLINE int_mv get_sub_block_mv(const MB_MODE_INFO *candidate, 62 int which_mv, int search_col) { 63 (void)search_col; 64 return candidate->mv[which_mv]; 65 } 66 67 static INLINE int_mv get_sub_block_pred_mv(const MB_MODE_INFO *candidate, 68 int which_mv, int search_col) { 69 (void)search_col; 70 return candidate->mv[which_mv]; 71 } 72 73 // Checks that the given mi_row, mi_col and search point 74 // are inside the borders of the tile. 75 static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row, 76 const POSITION *mi_pos) { 77 return !(mi_row + mi_pos->row < tile->mi_row_start || 78 mi_col + mi_pos->col < tile->mi_col_start || 79 mi_row + mi_pos->row >= tile->mi_row_end || 80 mi_col + mi_pos->col >= tile->mi_col_end); 81 } 82 83 static INLINE int find_valid_row_offset(const TileInfo *const tile, int mi_row, 84 int row_offset) { 85 return clamp(row_offset, tile->mi_row_start - mi_row, 86 tile->mi_row_end - mi_row - 1); 87 } 88 89 static INLINE int find_valid_col_offset(const TileInfo *const tile, int mi_col, 90 int col_offset) { 91 return clamp(col_offset, tile->mi_col_start - mi_col, 92 tile->mi_col_end - mi_col - 1); 93 } 94 95 static INLINE void lower_mv_precision(MV *mv, int allow_hp, int is_integer) { 96 if (is_integer) { 97 integer_mv_precision(mv); 98 } else { 99 if (!allow_hp) { 100 if (mv->row & 1) mv->row += (mv->row > 0 ? -1 : 1); 101 if (mv->col & 1) mv->col += (mv->col > 0 ? -1 : 1); 102 } 103 } 104 } 105 106 static INLINE int8_t get_uni_comp_ref_idx(const MV_REFERENCE_FRAME *const rf) { 107 // Single ref pred 108 if (rf[1] <= INTRA_FRAME) return -1; 109 110 // Bi-directional comp ref pred 111 if ((rf[0] < BWDREF_FRAME) && (rf[1] >= BWDREF_FRAME)) return -1; 112 113 for (int8_t ref_idx = 0; ref_idx < TOTAL_UNIDIR_COMP_REFS; ++ref_idx) { 114 if (rf[0] == comp_ref0(ref_idx) && rf[1] == comp_ref1(ref_idx)) 115 return ref_idx; 116 } 117 return -1; 118 } 119 120 static INLINE int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) { 121 if (rf[1] > INTRA_FRAME) { 122 const int8_t uni_comp_ref_idx = get_uni_comp_ref_idx(rf); 123 if (uni_comp_ref_idx >= 0) { 124 assert((REF_FRAMES + FWD_REFS * BWD_REFS + uni_comp_ref_idx) < 125 MODE_CTX_REF_FRAMES); 126 return REF_FRAMES + FWD_REFS * BWD_REFS + uni_comp_ref_idx; 127 } else { 128 return REF_FRAMES + FWD_RF_OFFSET(rf[0]) + 129 BWD_RF_OFFSET(rf[1]) * FWD_REFS; 130 } 131 } 132 133 return rf[0]; 134 } 135 136 // clang-format off 137 static MV_REFERENCE_FRAME ref_frame_map[TOTAL_COMP_REFS][2] = { 138 { LAST_FRAME, BWDREF_FRAME }, { LAST2_FRAME, BWDREF_FRAME }, 139 { LAST3_FRAME, BWDREF_FRAME }, { GOLDEN_FRAME, BWDREF_FRAME }, 140 141 { LAST_FRAME, ALTREF2_FRAME }, { LAST2_FRAME, ALTREF2_FRAME }, 142 { LAST3_FRAME, ALTREF2_FRAME }, { GOLDEN_FRAME, ALTREF2_FRAME }, 143 144 { LAST_FRAME, ALTREF_FRAME }, { LAST2_FRAME, ALTREF_FRAME }, 145 { LAST3_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }, 146 147 { LAST_FRAME, LAST2_FRAME }, { LAST_FRAME, LAST3_FRAME }, 148 { LAST_FRAME, GOLDEN_FRAME }, { BWDREF_FRAME, ALTREF_FRAME }, 149 150 // NOTE: Following reference frame pairs are not supported to be explicitly 151 // signalled, but they are possibly chosen by the use of skip_mode, 152 // which may use the most recent one-sided reference frame pair. 153 { LAST2_FRAME, LAST3_FRAME }, { LAST2_FRAME, GOLDEN_FRAME }, 154 { LAST3_FRAME, GOLDEN_FRAME }, {BWDREF_FRAME, ALTREF2_FRAME}, 155 { ALTREF2_FRAME, ALTREF_FRAME } 156 }; 157 // clang-format on 158 159 static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf, 160 MV_REFERENCE_FRAME ref_frame_type) { 161 if (ref_frame_type >= REF_FRAMES) { 162 rf[0] = ref_frame_map[ref_frame_type - REF_FRAMES][0]; 163 rf[1] = ref_frame_map[ref_frame_type - REF_FRAMES][1]; 164 } else { 165 assert(ref_frame_type > NONE_FRAME); 166 rf[0] = ref_frame_type; 167 rf[1] = NONE_FRAME; 168 } 169 } 170 171 static uint16_t compound_mode_ctx_map[3][COMP_NEWMV_CTXS] = { 172 { 0, 1, 1, 1, 1 }, 173 { 1, 2, 3, 4, 4 }, 174 { 4, 4, 5, 6, 7 }, 175 }; 176 177 static INLINE int16_t av1_mode_context_analyzer( 178 const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf) { 179 const int8_t ref_frame = av1_ref_frame_type(rf); 180 181 if (rf[1] <= INTRA_FRAME) return mode_context[ref_frame]; 182 183 const int16_t newmv_ctx = mode_context[ref_frame] & NEWMV_CTX_MASK; 184 const int16_t refmv_ctx = 185 (mode_context[ref_frame] >> REFMV_OFFSET) & REFMV_CTX_MASK; 186 187 const int16_t comp_ctx = compound_mode_ctx_map[refmv_ctx >> 1][AOMMIN( 188 newmv_ctx, COMP_NEWMV_CTXS - 1)]; 189 return comp_ctx; 190 } 191 192 static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack, 193 int ref_idx) { 194 if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL && 195 ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL) 196 return 0; 197 198 if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL && 199 ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL) 200 return 1; 201 202 if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL && 203 ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL) 204 return 2; 205 206 return 0; 207 } 208 209 void av1_setup_frame_buf_refs(AV1_COMMON *cm); 210 void av1_setup_frame_sign_bias(AV1_COMMON *cm); 211 void av1_setup_skip_mode_allowed(AV1_COMMON *cm); 212 void av1_setup_motion_field(AV1_COMMON *cm); 213 void av1_set_frame_refs(AV1_COMMON *const cm, int *remapped_ref_idx, 214 int lst_map_idx, int gld_map_idx); 215 216 static INLINE void av1_collect_neighbors_ref_counts(MACROBLOCKD *const xd) { 217 av1_zero(xd->neighbors_ref_counts); 218 219 uint8_t *const ref_counts = xd->neighbors_ref_counts; 220 221 const MB_MODE_INFO *const above_mbmi = xd->above_mbmi; 222 const MB_MODE_INFO *const left_mbmi = xd->left_mbmi; 223 const int above_in_image = xd->up_available; 224 const int left_in_image = xd->left_available; 225 226 // Above neighbor 227 if (above_in_image && is_inter_block(above_mbmi)) { 228 ref_counts[above_mbmi->ref_frame[0]]++; 229 if (has_second_ref(above_mbmi)) { 230 ref_counts[above_mbmi->ref_frame[1]]++; 231 } 232 } 233 234 // Left neighbor 235 if (left_in_image && is_inter_block(left_mbmi)) { 236 ref_counts[left_mbmi->ref_frame[0]]++; 237 if (has_second_ref(left_mbmi)) { 238 ref_counts[left_mbmi->ref_frame[1]]++; 239 } 240 } 241 } 242 243 void av1_copy_frame_mvs(const AV1_COMMON *const cm, 244 const MB_MODE_INFO *const mi, int mi_row, int mi_col, 245 int x_mis, int y_mis); 246 247 // The global_mvs output parameter points to an array of REF_FRAMES elements. 248 // The caller may pass a null global_mvs if it does not need the global_mvs 249 // output. 250 void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, 251 MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, 252 uint8_t ref_mv_count[MODE_CTX_REF_FRAMES], 253 CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE], 254 int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], 255 int_mv *global_mvs, int mi_row, int mi_col, 256 int16_t *mode_context); 257 258 // check a list of motion vectors by sad score using a number rows of pixels 259 // above and a number cols of pixels in the left to select the one with best 260 // score to use as ref motion vector 261 void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, 262 int_mv *near_mv, int is_integer); 263 264 int selectSamples(MV *mv, int *pts, int *pts_inref, int len, BLOCK_SIZE bsize); 265 int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, 266 int *pts, int *pts_inref); 267 268 #define INTRABC_DELAY_PIXELS 256 // Delay of 256 pixels 269 #define INTRABC_DELAY_SB64 (INTRABC_DELAY_PIXELS / 64) 270 271 static INLINE void av1_find_ref_dv(int_mv *ref_dv, const TileInfo *const tile, 272 int mib_size, int mi_row, int mi_col) { 273 (void)mi_col; 274 if (mi_row - mib_size < tile->mi_row_start) { 275 ref_dv->as_mv.row = 0; 276 ref_dv->as_mv.col = -MI_SIZE * mib_size - INTRABC_DELAY_PIXELS; 277 } else { 278 ref_dv->as_mv.row = -MI_SIZE * mib_size; 279 ref_dv->as_mv.col = 0; 280 } 281 ref_dv->as_mv.row *= 8; 282 ref_dv->as_mv.col *= 8; 283 } 284 285 static INLINE int av1_is_dv_valid(const MV dv, const AV1_COMMON *cm, 286 const MACROBLOCKD *xd, int mi_row, int mi_col, 287 BLOCK_SIZE bsize, int mib_size_log2) { 288 const int bw = block_size_wide[bsize]; 289 const int bh = block_size_high[bsize]; 290 const int SCALE_PX_TO_MV = 8; 291 // Disallow subpixel for now 292 // SUBPEL_MASK is not the correct scale 293 if (((dv.row & (SCALE_PX_TO_MV - 1)) || (dv.col & (SCALE_PX_TO_MV - 1)))) 294 return 0; 295 296 const TileInfo *const tile = &xd->tile; 297 // Is the source top-left inside the current tile? 298 const int src_top_edge = mi_row * MI_SIZE * SCALE_PX_TO_MV + dv.row; 299 const int tile_top_edge = tile->mi_row_start * MI_SIZE * SCALE_PX_TO_MV; 300 if (src_top_edge < tile_top_edge) return 0; 301 const int src_left_edge = mi_col * MI_SIZE * SCALE_PX_TO_MV + dv.col; 302 const int tile_left_edge = tile->mi_col_start * MI_SIZE * SCALE_PX_TO_MV; 303 if (src_left_edge < tile_left_edge) return 0; 304 // Is the bottom right inside the current tile? 305 const int src_bottom_edge = (mi_row * MI_SIZE + bh) * SCALE_PX_TO_MV + dv.row; 306 const int tile_bottom_edge = tile->mi_row_end * MI_SIZE * SCALE_PX_TO_MV; 307 if (src_bottom_edge > tile_bottom_edge) return 0; 308 const int src_right_edge = (mi_col * MI_SIZE + bw) * SCALE_PX_TO_MV + dv.col; 309 const int tile_right_edge = tile->mi_col_end * MI_SIZE * SCALE_PX_TO_MV; 310 if (src_right_edge > tile_right_edge) return 0; 311 312 // Special case for sub 8x8 chroma cases, to prevent referring to chroma 313 // pixels outside current tile. 314 for (int plane = 1; plane < av1_num_planes(cm); ++plane) { 315 const struct macroblockd_plane *const pd = &xd->plane[plane]; 316 if (is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, 317 pd->subsampling_y)) { 318 if (bw < 8 && pd->subsampling_x) 319 if (src_left_edge < tile_left_edge + 4 * SCALE_PX_TO_MV) return 0; 320 if (bh < 8 && pd->subsampling_y) 321 if (src_top_edge < tile_top_edge + 4 * SCALE_PX_TO_MV) return 0; 322 } 323 } 324 325 // Is the bottom right within an already coded SB? Also consider additional 326 // constraints to facilitate HW decoder. 327 const int max_mib_size = 1 << mib_size_log2; 328 const int active_sb_row = mi_row >> mib_size_log2; 329 const int active_sb64_col = (mi_col * MI_SIZE) >> 6; 330 const int sb_size = max_mib_size * MI_SIZE; 331 const int src_sb_row = ((src_bottom_edge >> 3) - 1) / sb_size; 332 const int src_sb64_col = ((src_right_edge >> 3) - 1) >> 6; 333 const int total_sb64_per_row = 334 ((tile->mi_col_end - tile->mi_col_start - 1) >> 4) + 1; 335 const int active_sb64 = active_sb_row * total_sb64_per_row + active_sb64_col; 336 const int src_sb64 = src_sb_row * total_sb64_per_row + src_sb64_col; 337 if (src_sb64 >= active_sb64 - INTRABC_DELAY_SB64) return 0; 338 339 // Wavefront constraint: use only top left area of frame for reference. 340 const int gradient = 1 + INTRABC_DELAY_SB64 + (sb_size > 64); 341 const int wf_offset = gradient * (active_sb_row - src_sb_row); 342 if (src_sb_row > active_sb_row || 343 src_sb64_col >= active_sb64_col - INTRABC_DELAY_SB64 + wf_offset) 344 return 0; 345 346 return 1; 347 } 348 349 #ifdef __cplusplus 350 } // extern "C" 351 #endif 352 353 #endif // AOM_AV1_COMMON_MVREF_COMMON_H_ 354
