mvref_common.c (58277B)
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 12 #include <stdlib.h> 13 14 #include "av1/common/mvref_common.h" 15 #include "av1/common/warped_motion.h" 16 17 // Although we assign 32 bit integers, all the values are strictly under 14 18 // bits. 19 static const int div_mult[32] = { 0, 16384, 8192, 5461, 4096, 3276, 2730, 20 2340, 2048, 1820, 1638, 1489, 1365, 1260, 21 1170, 1092, 1024, 963, 910, 862, 819, 22 780, 744, 712, 682, 655, 630, 606, 23 585, 564, 546, 528 }; 24 25 // TODO(jingning): Consider the use of lookup table for (num / den) 26 // altogether. 27 void av1_get_mv_projection(MV *output, MV ref, int num, int den) { 28 den = AOMMIN(den, MAX_FRAME_DISTANCE); 29 num = num > 0 ? AOMMIN(num, MAX_FRAME_DISTANCE) 30 : AOMMAX(num, -MAX_FRAME_DISTANCE); 31 const int mv_row = 32 ROUND_POWER_OF_TWO_SIGNED(ref.row * num * div_mult[den], 14); 33 const int mv_col = 34 ROUND_POWER_OF_TWO_SIGNED(ref.col * num * div_mult[den], 14); 35 const int clamp_max = MV_UPP - 1; 36 const int clamp_min = MV_LOW + 1; 37 output->row = (int16_t)clamp(mv_row, clamp_min, clamp_max); 38 output->col = (int16_t)clamp(mv_col, clamp_min, clamp_max); 39 } 40 41 void av1_copy_frame_mvs(const AV1_COMMON *const cm, 42 const MB_MODE_INFO *const mi, int mi_row, int mi_col, 43 int x_mis, int y_mis) { 44 const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_params.mi_cols, 1); 45 MV_REF *frame_mvs = 46 cm->cur_frame->mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1); 47 x_mis = ROUND_POWER_OF_TWO(x_mis, 1); 48 y_mis = ROUND_POWER_OF_TWO(y_mis, 1); 49 int w, h; 50 51 for (h = 0; h < y_mis; h++) { 52 MV_REF *mv = frame_mvs; 53 for (w = 0; w < x_mis; w++) { 54 mv->ref_frame = NONE_FRAME; 55 mv->mv.as_int = 0; 56 57 for (int idx = 0; idx < 2; ++idx) { 58 MV_REFERENCE_FRAME ref_frame = mi->ref_frame[idx]; 59 if (ref_frame > INTRA_FRAME) { 60 int8_t ref_idx = cm->ref_frame_side[ref_frame]; 61 if (ref_idx) continue; 62 if ((abs(mi->mv[idx].as_mv.row) > REFMVS_LIMIT) || 63 (abs(mi->mv[idx].as_mv.col) > REFMVS_LIMIT)) 64 continue; 65 mv->ref_frame = ref_frame; 66 mv->mv.as_int = mi->mv[idx].as_int; 67 } 68 } 69 mv++; 70 } 71 frame_mvs += frame_mvs_stride; 72 } 73 } 74 75 static inline void add_ref_mv_candidate( 76 const MB_MODE_INFO *const candidate, const MV_REFERENCE_FRAME rf[2], 77 uint8_t *refmv_count, uint8_t *ref_match_count, uint8_t *newmv_count, 78 CANDIDATE_MV *ref_mv_stack, uint16_t *ref_mv_weight, 79 int_mv *gm_mv_candidates, const WarpedMotionParams *gm_params, 80 uint16_t weight) { 81 if (!is_inter_block(candidate)) return; 82 assert(weight % 2 == 0); 83 int index, ref; 84 85 if (rf[1] == NONE_FRAME) { 86 // single reference frame 87 for (ref = 0; ref < 2; ++ref) { 88 if (candidate->ref_frame[ref] == rf[0]) { 89 const int is_gm_block = 90 is_global_mv_block(candidate, gm_params[rf[0]].wmtype); 91 const int_mv this_refmv = 92 is_gm_block ? gm_mv_candidates[0] : get_block_mv(candidate, ref); 93 for (index = 0; index < *refmv_count; ++index) { 94 if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) { 95 ref_mv_weight[index] += weight; 96 break; 97 } 98 } 99 100 // Add a new item to the list. 101 if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { 102 ref_mv_stack[index].this_mv = this_refmv; 103 ref_mv_weight[index] = weight; 104 ++(*refmv_count); 105 } 106 if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; 107 ++*ref_match_count; 108 } 109 } 110 } else { 111 // compound reference frame 112 if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) { 113 int_mv this_refmv[2]; 114 115 for (ref = 0; ref < 2; ++ref) { 116 if (is_global_mv_block(candidate, gm_params[rf[ref]].wmtype)) 117 this_refmv[ref] = gm_mv_candidates[ref]; 118 else 119 this_refmv[ref] = get_block_mv(candidate, ref); 120 } 121 122 for (index = 0; index < *refmv_count; ++index) { 123 if ((ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int) && 124 (ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int)) { 125 ref_mv_weight[index] += weight; 126 break; 127 } 128 } 129 130 // Add a new item to the list. 131 if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { 132 ref_mv_stack[index].this_mv = this_refmv[0]; 133 ref_mv_stack[index].comp_mv = this_refmv[1]; 134 ref_mv_weight[index] = weight; 135 ++(*refmv_count); 136 } 137 if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; 138 ++*ref_match_count; 139 } 140 } 141 } 142 143 static inline void scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, 144 int mi_col, const MV_REFERENCE_FRAME rf[2], 145 int row_offset, CANDIDATE_MV *ref_mv_stack, 146 uint16_t *ref_mv_weight, uint8_t *refmv_count, 147 uint8_t *ref_match_count, uint8_t *newmv_count, 148 int_mv *gm_mv_candidates, int max_row_offset, 149 int *processed_rows) { 150 int end_mi = AOMMIN(xd->width, cm->mi_params.mi_cols - mi_col); 151 end_mi = AOMMIN(end_mi, mi_size_wide[BLOCK_64X64]); 152 const int width_8x8 = mi_size_wide[BLOCK_8X8]; 153 const int width_16x16 = mi_size_wide[BLOCK_16X16]; 154 int col_offset = 0; 155 // TODO(jingning): Revisit this part after cb4x4 is stable. 156 if (abs(row_offset) > 1) { 157 col_offset = 1; 158 if ((mi_col & 0x01) && xd->width < width_8x8) --col_offset; 159 } 160 const int use_step_16 = (xd->width >= 16); 161 MB_MODE_INFO **const candidate_mi0 = xd->mi + row_offset * xd->mi_stride; 162 163 for (int i = 0; i < end_mi;) { 164 const MB_MODE_INFO *const candidate = candidate_mi0[col_offset + i]; 165 const int candidate_bsize = candidate->bsize; 166 const int n4_w = mi_size_wide[candidate_bsize]; 167 int len = AOMMIN(xd->width, n4_w); 168 if (use_step_16) 169 len = AOMMAX(width_16x16, len); 170 else if (abs(row_offset) > 1) 171 len = AOMMAX(len, width_8x8); 172 173 uint16_t weight = 2; 174 if (xd->width >= width_8x8 && xd->width <= n4_w) { 175 uint16_t inc = AOMMIN(-max_row_offset + row_offset + 1, 176 mi_size_high[candidate_bsize]); 177 // Obtain range used in weight calculation. 178 weight = AOMMAX(weight, inc); 179 // Update processed rows. 180 *processed_rows = inc - row_offset - 1; 181 } 182 183 add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, 184 newmv_count, ref_mv_stack, ref_mv_weight, 185 gm_mv_candidates, cm->global_motion, len * weight); 186 187 i += len; 188 } 189 } 190 191 static inline void scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, 192 int mi_row, const MV_REFERENCE_FRAME rf[2], 193 int col_offset, CANDIDATE_MV *ref_mv_stack, 194 uint16_t *ref_mv_weight, uint8_t *refmv_count, 195 uint8_t *ref_match_count, uint8_t *newmv_count, 196 int_mv *gm_mv_candidates, int max_col_offset, 197 int *processed_cols) { 198 int end_mi = AOMMIN(xd->height, cm->mi_params.mi_rows - mi_row); 199 end_mi = AOMMIN(end_mi, mi_size_high[BLOCK_64X64]); 200 const int n8_h_8 = mi_size_high[BLOCK_8X8]; 201 const int n8_h_16 = mi_size_high[BLOCK_16X16]; 202 int i; 203 int row_offset = 0; 204 if (abs(col_offset) > 1) { 205 row_offset = 1; 206 if ((mi_row & 0x01) && xd->height < n8_h_8) --row_offset; 207 } 208 const int use_step_16 = (xd->height >= 16); 209 210 for (i = 0; i < end_mi;) { 211 const MB_MODE_INFO *const candidate = 212 xd->mi[(row_offset + i) * xd->mi_stride + col_offset]; 213 const int candidate_bsize = candidate->bsize; 214 const int n4_h = mi_size_high[candidate_bsize]; 215 int len = AOMMIN(xd->height, n4_h); 216 if (use_step_16) 217 len = AOMMAX(n8_h_16, len); 218 else if (abs(col_offset) > 1) 219 len = AOMMAX(len, n8_h_8); 220 221 int weight = 2; 222 if (xd->height >= n8_h_8 && xd->height <= n4_h) { 223 int inc = AOMMIN(-max_col_offset + col_offset + 1, 224 mi_size_wide[candidate_bsize]); 225 // Obtain range used in weight calculation. 226 weight = AOMMAX(weight, inc); 227 // Update processed cols. 228 *processed_cols = inc - col_offset - 1; 229 } 230 231 add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, 232 newmv_count, ref_mv_stack, ref_mv_weight, 233 gm_mv_candidates, cm->global_motion, len * weight); 234 235 i += len; 236 } 237 } 238 239 static inline void scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, 240 const int mi_row, const int mi_col, 241 const MV_REFERENCE_FRAME rf[2], int row_offset, 242 int col_offset, CANDIDATE_MV *ref_mv_stack, 243 uint16_t *ref_mv_weight, 244 uint8_t *ref_match_count, uint8_t *newmv_count, 245 int_mv *gm_mv_candidates, 246 uint8_t *refmv_count) { 247 const TileInfo *const tile = &xd->tile; 248 POSITION mi_pos; 249 250 mi_pos.row = row_offset; 251 mi_pos.col = col_offset; 252 253 if (is_inside(tile, mi_col, mi_row, &mi_pos)) { 254 const MB_MODE_INFO *const candidate = 255 xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col]; 256 const int len = mi_size_wide[BLOCK_8X8]; 257 258 add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, 259 newmv_count, ref_mv_stack, ref_mv_weight, 260 gm_mv_candidates, cm->global_motion, 2 * len); 261 } // Analyze a single 8x8 block motion information. 262 } 263 264 static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd, 265 int mi_row, int mi_col, int bs) { 266 const int sb_mi_size = mi_size_wide[cm->seq_params->sb_size]; 267 const int mask_row = mi_row & (sb_mi_size - 1); 268 const int mask_col = mi_col & (sb_mi_size - 1); 269 270 if (bs > mi_size_wide[BLOCK_64X64]) return 0; 271 272 // In a split partition all apart from the bottom right has a top right 273 int has_tr = !((mask_row & bs) && (mask_col & bs)); 274 275 // bs > 0 and bs is a power of 2 276 assert(bs > 0 && !(bs & (bs - 1))); 277 278 // For each 4x4 group of blocks, when the bottom right is decoded the blocks 279 // to the right have not been decoded therefore the bottom right does 280 // not have a top right 281 while (bs < sb_mi_size) { 282 if (mask_col & bs) { 283 if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) { 284 has_tr = 0; 285 break; 286 } 287 } else { 288 break; 289 } 290 bs <<= 1; 291 } 292 293 // In a VERTICAL or VERTICAL_4 partition, all partition before the last one 294 // always have a top right (as the block above will have been decoded). 295 if (xd->width < xd->height) { 296 if (!xd->is_last_vertical_rect) has_tr = 1; 297 } 298 299 // In a HORIZONTAL or HORIZONTAL_4 partition, partitions after the first one 300 // never have a top right (as the block to the right won't have been decoded). 301 if (xd->width > xd->height) { 302 if (!xd->is_first_horizontal_rect) has_tr = 0; 303 } 304 305 // The bottom left square of a Vertical A (in the old format) does 306 // not have a top right as it is decoded before the right hand 307 // rectangle of the partition 308 if (xd->mi[0]->partition == PARTITION_VERT_A) { 309 if (xd->width == xd->height) 310 if (mask_row & bs) has_tr = 0; 311 } 312 313 return has_tr; 314 } 315 316 static int check_sb_border(const int mi_row, const int mi_col, 317 const int row_offset, const int col_offset) { 318 const int sb_mi_size = mi_size_wide[BLOCK_64X64]; 319 const int row = mi_row & (sb_mi_size - 1); 320 const int col = mi_col & (sb_mi_size - 1); 321 322 if (row + row_offset < 0 || row + row_offset >= sb_mi_size || 323 col + col_offset < 0 || col + col_offset >= sb_mi_size) 324 return 0; 325 326 return 1; 327 } 328 329 static int add_tpl_ref_mv(const AV1_COMMON *cm, const MACROBLOCKD *xd, 330 int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame, 331 int blk_row, int blk_col, int_mv *gm_mv_candidates, 332 uint8_t *const refmv_count, 333 CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE], 334 uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE], 335 int16_t *mode_context) { 336 POSITION mi_pos; 337 mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1; 338 mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1; 339 340 if (!is_inside(&xd->tile, mi_col, mi_row, &mi_pos)) return 0; 341 342 const TPL_MV_REF *prev_frame_mvs = 343 cm->tpl_mvs + 344 ((mi_row + mi_pos.row) >> 1) * (cm->mi_params.mi_stride >> 1) + 345 ((mi_col + mi_pos.col) >> 1); 346 if (prev_frame_mvs->mfmv0.as_int == INVALID_MV) return 0; 347 348 MV_REFERENCE_FRAME rf[2]; 349 av1_set_ref_frame(rf, ref_frame); 350 351 const uint16_t weight_unit = 1; // mi_size_wide[BLOCK_8X8]; 352 const int cur_frame_index = cm->cur_frame->order_hint; 353 const RefCntBuffer *const buf_0 = get_ref_frame_buf(cm, rf[0]); 354 const int frame0_index = buf_0->order_hint; 355 const int cur_offset_0 = get_relative_dist(&cm->seq_params->order_hint_info, 356 cur_frame_index, frame0_index); 357 int idx; 358 const int allow_high_precision_mv = cm->features.allow_high_precision_mv; 359 const int force_integer_mv = cm->features.cur_frame_force_integer_mv; 360 361 int_mv this_refmv; 362 av1_get_mv_projection(&this_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, 363 cur_offset_0, prev_frame_mvs->ref_frame_offset); 364 lower_mv_precision(&this_refmv.as_mv, allow_high_precision_mv, 365 force_integer_mv); 366 367 if (rf[1] == NONE_FRAME) { 368 if (blk_row == 0 && blk_col == 0) { 369 if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || 370 abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16) 371 mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); 372 } 373 374 for (idx = 0; idx < *refmv_count; ++idx) 375 if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break; 376 377 if (idx < *refmv_count) ref_mv_weight[idx] += 2 * weight_unit; 378 379 if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { 380 ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; 381 ref_mv_weight[idx] = 2 * weight_unit; 382 ++(*refmv_count); 383 } 384 } else { 385 // Process compound inter mode 386 const RefCntBuffer *const buf_1 = get_ref_frame_buf(cm, rf[1]); 387 const int frame1_index = buf_1->order_hint; 388 const int cur_offset_1 = get_relative_dist(&cm->seq_params->order_hint_info, 389 cur_frame_index, frame1_index); 390 int_mv comp_refmv; 391 av1_get_mv_projection(&comp_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, 392 cur_offset_1, prev_frame_mvs->ref_frame_offset); 393 lower_mv_precision(&comp_refmv.as_mv, allow_high_precision_mv, 394 force_integer_mv); 395 396 if (blk_row == 0 && blk_col == 0) { 397 if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || 398 abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16 || 399 abs(comp_refmv.as_mv.row - gm_mv_candidates[1].as_mv.row) >= 16 || 400 abs(comp_refmv.as_mv.col - gm_mv_candidates[1].as_mv.col) >= 16) 401 mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); 402 } 403 404 for (idx = 0; idx < *refmv_count; ++idx) { 405 if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int && 406 comp_refmv.as_int == ref_mv_stack[idx].comp_mv.as_int) 407 break; 408 } 409 410 if (idx < *refmv_count) ref_mv_weight[idx] += 2 * weight_unit; 411 412 if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { 413 ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; 414 ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int; 415 ref_mv_weight[idx] = 2 * weight_unit; 416 ++(*refmv_count); 417 } 418 } 419 420 return 1; 421 } 422 423 static inline void process_compound_ref_mv_candidate( 424 const MB_MODE_INFO *const candidate, const AV1_COMMON *const cm, 425 const MV_REFERENCE_FRAME *const rf, int_mv ref_id[2][2], 426 int ref_id_count[2], int_mv ref_diff[2][2], int ref_diff_count[2]) { 427 for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { 428 MV_REFERENCE_FRAME can_rf = candidate->ref_frame[rf_idx]; 429 430 for (int cmp_idx = 0; cmp_idx < 2; ++cmp_idx) { 431 if (can_rf == rf[cmp_idx] && ref_id_count[cmp_idx] < 2) { 432 ref_id[cmp_idx][ref_id_count[cmp_idx]] = candidate->mv[rf_idx]; 433 ++ref_id_count[cmp_idx]; 434 } else if (can_rf > INTRA_FRAME && ref_diff_count[cmp_idx] < 2) { 435 int_mv this_mv = candidate->mv[rf_idx]; 436 if (cm->ref_frame_sign_bias[can_rf] != 437 cm->ref_frame_sign_bias[rf[cmp_idx]]) { 438 this_mv.as_mv.row = -this_mv.as_mv.row; 439 this_mv.as_mv.col = -this_mv.as_mv.col; 440 } 441 ref_diff[cmp_idx][ref_diff_count[cmp_idx]] = this_mv; 442 ++ref_diff_count[cmp_idx]; 443 } 444 } 445 } 446 } 447 448 static inline void process_single_ref_mv_candidate( 449 const MB_MODE_INFO *const candidate, const AV1_COMMON *const cm, 450 MV_REFERENCE_FRAME ref_frame, uint8_t *const refmv_count, 451 CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE], 452 uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE]) { 453 for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { 454 if (candidate->ref_frame[rf_idx] > INTRA_FRAME) { 455 int_mv this_mv = candidate->mv[rf_idx]; 456 if (cm->ref_frame_sign_bias[candidate->ref_frame[rf_idx]] != 457 cm->ref_frame_sign_bias[ref_frame]) { 458 this_mv.as_mv.row = -this_mv.as_mv.row; 459 this_mv.as_mv.col = -this_mv.as_mv.col; 460 } 461 int stack_idx; 462 for (stack_idx = 0; stack_idx < *refmv_count; ++stack_idx) { 463 const int_mv stack_mv = ref_mv_stack[stack_idx].this_mv; 464 if (this_mv.as_int == stack_mv.as_int) break; 465 } 466 467 if (stack_idx == *refmv_count) { 468 ref_mv_stack[stack_idx].this_mv = this_mv; 469 470 // TODO(jingning): Set an arbitrary small number here. The weight 471 // doesn't matter as long as it is properly initialized. 472 ref_mv_weight[stack_idx] = 2; 473 ++(*refmv_count); 474 } 475 } 476 } 477 } 478 479 static inline void setup_ref_mv_list( 480 const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame, 481 uint8_t *const refmv_count, 482 CANDIDATE_MV ref_mv_stack[MAX_REF_MV_STACK_SIZE], 483 uint16_t ref_mv_weight[MAX_REF_MV_STACK_SIZE], 484 int_mv mv_ref_list[MAX_MV_REF_CANDIDATES], int_mv *gm_mv_candidates, 485 int mi_row, int mi_col, int16_t *mode_context) { 486 const int bs = AOMMAX(xd->width, xd->height); 487 const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs); 488 MV_REFERENCE_FRAME rf[2]; 489 490 const TileInfo *const tile = &xd->tile; 491 int max_row_offset = 0, max_col_offset = 0; 492 const int row_adj = (xd->height < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01); 493 const int col_adj = (xd->width < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01); 494 int processed_rows = 0; 495 int processed_cols = 0; 496 497 av1_set_ref_frame(rf, ref_frame); 498 mode_context[ref_frame] = 0; 499 *refmv_count = 0; 500 501 // Find valid maximum row/col offset. 502 if (xd->up_available) { 503 max_row_offset = -(MVREF_ROW_COLS << 1) + row_adj; 504 505 if (xd->height < mi_size_high[BLOCK_8X8]) 506 max_row_offset = -(2 << 1) + row_adj; 507 508 max_row_offset = find_valid_row_offset(tile, mi_row, max_row_offset); 509 } 510 511 if (xd->left_available) { 512 max_col_offset = -(MVREF_ROW_COLS << 1) + col_adj; 513 514 if (xd->width < mi_size_wide[BLOCK_8X8]) 515 max_col_offset = -(2 << 1) + col_adj; 516 517 max_col_offset = find_valid_col_offset(tile, mi_col, max_col_offset); 518 } 519 520 uint8_t col_match_count = 0; 521 uint8_t row_match_count = 0; 522 uint8_t newmv_count = 0; 523 524 // Scan the first above row mode info. row_offset = -1; 525 if (abs(max_row_offset) >= 1) 526 scan_row_mbmi(cm, xd, mi_col, rf, -1, ref_mv_stack, ref_mv_weight, 527 refmv_count, &row_match_count, &newmv_count, gm_mv_candidates, 528 max_row_offset, &processed_rows); 529 // Scan the first left column mode info. col_offset = -1; 530 if (abs(max_col_offset) >= 1) 531 scan_col_mbmi(cm, xd, mi_row, rf, -1, ref_mv_stack, ref_mv_weight, 532 refmv_count, &col_match_count, &newmv_count, gm_mv_candidates, 533 max_col_offset, &processed_cols); 534 // Check top-right boundary 535 if (has_tr) 536 scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->width, ref_mv_stack, 537 ref_mv_weight, &row_match_count, &newmv_count, 538 gm_mv_candidates, refmv_count); 539 540 const uint8_t nearest_match = (row_match_count > 0) + (col_match_count > 0); 541 const uint8_t nearest_refmv_count = *refmv_count; 542 543 // TODO(yunqing): for comp_search, do it for all 3 cases. 544 for (int idx = 0; idx < nearest_refmv_count; ++idx) 545 ref_mv_weight[idx] += REF_CAT_LEVEL; 546 547 if (cm->features.allow_ref_frame_mvs) { 548 int is_available = 0; 549 const int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->height); 550 const int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->width); 551 const int blk_row_end = AOMMIN(xd->height, mi_size_high[BLOCK_64X64]); 552 const int blk_col_end = AOMMIN(xd->width, mi_size_wide[BLOCK_64X64]); 553 554 const int tpl_sample_pos[3][2] = { 555 { voffset, -2 }, 556 { voffset, hoffset }, 557 { voffset - 2, hoffset }, 558 }; 559 const int allow_extension = (xd->height >= mi_size_high[BLOCK_8X8]) && 560 (xd->height < mi_size_high[BLOCK_64X64]) && 561 (xd->width >= mi_size_wide[BLOCK_8X8]) && 562 (xd->width < mi_size_wide[BLOCK_64X64]); 563 564 const int step_h = (xd->height >= mi_size_high[BLOCK_64X64]) 565 ? mi_size_high[BLOCK_16X16] 566 : mi_size_high[BLOCK_8X8]; 567 const int step_w = (xd->width >= mi_size_wide[BLOCK_64X64]) 568 ? mi_size_wide[BLOCK_16X16] 569 : mi_size_wide[BLOCK_8X8]; 570 571 for (int blk_row = 0; blk_row < blk_row_end; blk_row += step_h) { 572 for (int blk_col = 0; blk_col < blk_col_end; blk_col += step_w) { 573 int ret = add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, 574 blk_col, gm_mv_candidates, refmv_count, 575 ref_mv_stack, ref_mv_weight, mode_context); 576 if (blk_row == 0 && blk_col == 0) is_available = ret; 577 } 578 } 579 580 if (is_available == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); 581 582 for (int i = 0; i < 3 && allow_extension; ++i) { 583 const int blk_row = tpl_sample_pos[i][0]; 584 const int blk_col = tpl_sample_pos[i][1]; 585 586 if (!check_sb_border(mi_row, mi_col, blk_row, blk_col)) continue; 587 add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, blk_col, 588 gm_mv_candidates, refmv_count, ref_mv_stack, ref_mv_weight, 589 mode_context); 590 } 591 } 592 593 uint8_t dummy_newmv_count = 0; 594 595 // Scan the second outer area. 596 scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack, ref_mv_weight, 597 &row_match_count, &dummy_newmv_count, gm_mv_candidates, 598 refmv_count); 599 600 for (int idx = 2; idx <= MVREF_ROW_COLS; ++idx) { 601 const int row_offset = -(idx << 1) + 1 + row_adj; 602 const int col_offset = -(idx << 1) + 1 + col_adj; 603 604 if (abs(row_offset) <= abs(max_row_offset) && 605 abs(row_offset) > processed_rows) 606 scan_row_mbmi(cm, xd, mi_col, rf, row_offset, ref_mv_stack, ref_mv_weight, 607 refmv_count, &row_match_count, &dummy_newmv_count, 608 gm_mv_candidates, max_row_offset, &processed_rows); 609 610 if (abs(col_offset) <= abs(max_col_offset) && 611 abs(col_offset) > processed_cols) 612 scan_col_mbmi(cm, xd, mi_row, rf, col_offset, ref_mv_stack, ref_mv_weight, 613 refmv_count, &col_match_count, &dummy_newmv_count, 614 gm_mv_candidates, max_col_offset, &processed_cols); 615 } 616 617 const uint8_t ref_match_count = (row_match_count > 0) + (col_match_count > 0); 618 619 switch (nearest_match) { 620 case 0: 621 if (ref_match_count >= 1) mode_context[ref_frame] |= 1; 622 if (ref_match_count == 1) 623 mode_context[ref_frame] |= (1 << REFMV_OFFSET); 624 else if (ref_match_count >= 2) 625 mode_context[ref_frame] |= (2 << REFMV_OFFSET); 626 break; 627 case 1: 628 mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3; 629 if (ref_match_count == 1) 630 mode_context[ref_frame] |= (3 << REFMV_OFFSET); 631 else if (ref_match_count >= 2) 632 mode_context[ref_frame] |= (4 << REFMV_OFFSET); 633 break; 634 case 2: 635 default: 636 if (newmv_count >= 1) 637 mode_context[ref_frame] |= 4; 638 else 639 mode_context[ref_frame] |= 5; 640 641 mode_context[ref_frame] |= (5 << REFMV_OFFSET); 642 break; 643 } 644 645 // Rank the likelihood and assign nearest and near mvs. 646 int len = nearest_refmv_count; 647 while (len > 0) { 648 int nr_len = 0; 649 for (int idx = 1; idx < len; ++idx) { 650 if (ref_mv_weight[idx - 1] < ref_mv_weight[idx]) { 651 const CANDIDATE_MV tmp_mv = ref_mv_stack[idx - 1]; 652 const uint16_t tmp_ref_mv_weight = ref_mv_weight[idx - 1]; 653 ref_mv_stack[idx - 1] = ref_mv_stack[idx]; 654 ref_mv_stack[idx] = tmp_mv; 655 ref_mv_weight[idx - 1] = ref_mv_weight[idx]; 656 ref_mv_weight[idx] = tmp_ref_mv_weight; 657 nr_len = idx; 658 } 659 } 660 len = nr_len; 661 } 662 663 len = *refmv_count; 664 while (len > nearest_refmv_count) { 665 int nr_len = nearest_refmv_count; 666 for (int idx = nearest_refmv_count + 1; idx < len; ++idx) { 667 if (ref_mv_weight[idx - 1] < ref_mv_weight[idx]) { 668 const CANDIDATE_MV tmp_mv = ref_mv_stack[idx - 1]; 669 const uint16_t tmp_ref_mv_weight = ref_mv_weight[idx - 1]; 670 ref_mv_stack[idx - 1] = ref_mv_stack[idx]; 671 ref_mv_stack[idx] = tmp_mv; 672 ref_mv_weight[idx - 1] = ref_mv_weight[idx]; 673 ref_mv_weight[idx] = tmp_ref_mv_weight; 674 nr_len = idx; 675 } 676 } 677 len = nr_len; 678 } 679 680 int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->width); 681 mi_width = AOMMIN(mi_width, cm->mi_params.mi_cols - mi_col); 682 int mi_height = AOMMIN(mi_size_high[BLOCK_64X64], xd->height); 683 mi_height = AOMMIN(mi_height, cm->mi_params.mi_rows - mi_row); 684 const int mi_size = AOMMIN(mi_width, mi_height); 685 if (rf[1] > NONE_FRAME) { 686 // TODO(jingning, yunqing): Refactor and consolidate the compound and 687 // single reference frame modes. Reduce unnecessary redundancy. 688 if (*refmv_count < MAX_MV_REF_CANDIDATES) { 689 int_mv ref_id[2][2], ref_diff[2][2]; 690 int ref_id_count[2] = { 0 }, ref_diff_count[2] = { 0 }; 691 692 for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size;) { 693 const MB_MODE_INFO *const candidate = xd->mi[-xd->mi_stride + idx]; 694 process_compound_ref_mv_candidate( 695 candidate, cm, rf, ref_id, ref_id_count, ref_diff, ref_diff_count); 696 idx += mi_size_wide[candidate->bsize]; 697 } 698 699 for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size;) { 700 const MB_MODE_INFO *const candidate = xd->mi[idx * xd->mi_stride - 1]; 701 process_compound_ref_mv_candidate( 702 candidate, cm, rf, ref_id, ref_id_count, ref_diff, ref_diff_count); 703 idx += mi_size_high[candidate->bsize]; 704 } 705 706 // Build up the compound mv predictor 707 int_mv comp_list[MAX_MV_REF_CANDIDATES][2]; 708 709 for (int idx = 0; idx < 2; ++idx) { 710 int comp_idx = 0; 711 for (int list_idx = 0; 712 list_idx < ref_id_count[idx] && comp_idx < MAX_MV_REF_CANDIDATES; 713 ++list_idx, ++comp_idx) 714 comp_list[comp_idx][idx] = ref_id[idx][list_idx]; 715 for (int list_idx = 0; 716 list_idx < ref_diff_count[idx] && comp_idx < MAX_MV_REF_CANDIDATES; 717 ++list_idx, ++comp_idx) 718 comp_list[comp_idx][idx] = ref_diff[idx][list_idx]; 719 for (; comp_idx < MAX_MV_REF_CANDIDATES; ++comp_idx) 720 comp_list[comp_idx][idx] = gm_mv_candidates[idx]; 721 } 722 723 if (*refmv_count) { 724 assert(*refmv_count == 1); 725 if (comp_list[0][0].as_int == ref_mv_stack[0].this_mv.as_int && 726 comp_list[0][1].as_int == ref_mv_stack[0].comp_mv.as_int) { 727 ref_mv_stack[*refmv_count].this_mv = comp_list[1][0]; 728 ref_mv_stack[*refmv_count].comp_mv = comp_list[1][1]; 729 } else { 730 ref_mv_stack[*refmv_count].this_mv = comp_list[0][0]; 731 ref_mv_stack[*refmv_count].comp_mv = comp_list[0][1]; 732 } 733 ref_mv_weight[*refmv_count] = 2; 734 ++*refmv_count; 735 } else { 736 for (int idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx) { 737 ref_mv_stack[*refmv_count].this_mv = comp_list[idx][0]; 738 ref_mv_stack[*refmv_count].comp_mv = comp_list[idx][1]; 739 ref_mv_weight[*refmv_count] = 2; 740 ++*refmv_count; 741 } 742 } 743 } 744 745 assert(*refmv_count >= 2); 746 747 for (int idx = 0; idx < *refmv_count; ++idx) { 748 clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->width << MI_SIZE_LOG2, 749 xd->height << MI_SIZE_LOG2, xd); 750 clamp_mv_ref(&ref_mv_stack[idx].comp_mv.as_mv, xd->width << MI_SIZE_LOG2, 751 xd->height << MI_SIZE_LOG2, xd); 752 } 753 } else { 754 // Handle single reference frame extension 755 for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size && 756 *refmv_count < MAX_MV_REF_CANDIDATES;) { 757 const MB_MODE_INFO *const candidate = xd->mi[-xd->mi_stride + idx]; 758 process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count, 759 ref_mv_stack, ref_mv_weight); 760 idx += mi_size_wide[candidate->bsize]; 761 } 762 763 for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size && 764 *refmv_count < MAX_MV_REF_CANDIDATES;) { 765 const MB_MODE_INFO *const candidate = xd->mi[idx * xd->mi_stride - 1]; 766 process_single_ref_mv_candidate(candidate, cm, ref_frame, refmv_count, 767 ref_mv_stack, ref_mv_weight); 768 idx += mi_size_high[candidate->bsize]; 769 } 770 771 for (int idx = 0; idx < *refmv_count; ++idx) { 772 clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->width << MI_SIZE_LOG2, 773 xd->height << MI_SIZE_LOG2, xd); 774 } 775 776 if (mv_ref_list != NULL) { 777 for (int idx = *refmv_count; idx < MAX_MV_REF_CANDIDATES; ++idx) 778 mv_ref_list[idx].as_int = gm_mv_candidates[0].as_int; 779 780 for (int idx = 0; idx < AOMMIN(MAX_MV_REF_CANDIDATES, *refmv_count); 781 ++idx) { 782 mv_ref_list[idx].as_int = ref_mv_stack[idx].this_mv.as_int; 783 } 784 } 785 } 786 } 787 788 void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, 789 MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, 790 uint8_t ref_mv_count[MODE_CTX_REF_FRAMES], 791 CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE], 792 uint16_t ref_mv_weight[][MAX_REF_MV_STACK_SIZE], 793 int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], 794 int_mv *global_mvs, int16_t *mode_context) { 795 const int mi_row = xd->mi_row; 796 const int mi_col = xd->mi_col; 797 int_mv gm_mv[2]; 798 799 if (ref_frame == INTRA_FRAME) { 800 gm_mv[0].as_int = gm_mv[1].as_int = 0; 801 if (global_mvs != NULL) { 802 global_mvs[ref_frame].as_int = INVALID_MV; 803 } 804 } else { 805 const BLOCK_SIZE bsize = mi->bsize; 806 const int allow_high_precision_mv = cm->features.allow_high_precision_mv; 807 const int force_integer_mv = cm->features.cur_frame_force_integer_mv; 808 if (ref_frame < REF_FRAMES) { 809 gm_mv[0] = gm_get_motion_vector(&cm->global_motion[ref_frame], 810 allow_high_precision_mv, bsize, mi_col, 811 mi_row, force_integer_mv); 812 gm_mv[1].as_int = 0; 813 if (global_mvs != NULL) global_mvs[ref_frame] = gm_mv[0]; 814 } else { 815 MV_REFERENCE_FRAME rf[2]; 816 av1_set_ref_frame(rf, ref_frame); 817 gm_mv[0] = gm_get_motion_vector(&cm->global_motion[rf[0]], 818 allow_high_precision_mv, bsize, mi_col, 819 mi_row, force_integer_mv); 820 gm_mv[1] = gm_get_motion_vector(&cm->global_motion[rf[1]], 821 allow_high_precision_mv, bsize, mi_col, 822 mi_row, force_integer_mv); 823 } 824 } 825 826 setup_ref_mv_list(cm, xd, ref_frame, &ref_mv_count[ref_frame], 827 ref_mv_stack[ref_frame], ref_mv_weight[ref_frame], 828 mv_ref_list ? mv_ref_list[ref_frame] : NULL, gm_mv, mi_row, 829 mi_col, mode_context); 830 } 831 832 void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, 833 int_mv *near_mv, int is_integer) { 834 int i; 835 // Make sure all the candidates are properly clamped etc 836 for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) { 837 lower_mv_precision(&mvlist[i].as_mv, allow_hp, is_integer); 838 } 839 *nearest_mv = mvlist[0]; 840 *near_mv = mvlist[1]; 841 } 842 843 void av1_setup_frame_buf_refs(AV1_COMMON *cm) { 844 cm->cur_frame->order_hint = cm->current_frame.order_hint; 845 cm->cur_frame->display_order_hint = cm->current_frame.display_order_hint; 846 cm->cur_frame->pyramid_level = cm->current_frame.pyramid_level; 847 cm->cur_frame->filter_level[0] = -1; 848 cm->cur_frame->filter_level[1] = -1; 849 MV_REFERENCE_FRAME ref_frame; 850 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { 851 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); 852 if (buf != NULL) { 853 cm->cur_frame->ref_order_hints[ref_frame - LAST_FRAME] = buf->order_hint; 854 cm->cur_frame->ref_display_order_hint[ref_frame - LAST_FRAME] = 855 buf->display_order_hint; 856 } 857 } 858 } 859 860 void av1_setup_frame_sign_bias(AV1_COMMON *cm) { 861 MV_REFERENCE_FRAME ref_frame; 862 for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { 863 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); 864 if (cm->seq_params->order_hint_info.enable_order_hint && buf != NULL) { 865 const int ref_order_hint = buf->order_hint; 866 cm->ref_frame_sign_bias[ref_frame] = 867 (get_relative_dist(&cm->seq_params->order_hint_info, ref_order_hint, 868 (int)cm->current_frame.order_hint) <= 0) 869 ? 0 870 : 1; 871 } else { 872 cm->ref_frame_sign_bias[ref_frame] = 0; 873 } 874 } 875 } 876 877 #define MAX_OFFSET_WIDTH 64 878 #define MAX_OFFSET_HEIGHT 0 879 880 static int get_block_position(AV1_COMMON *cm, int *mi_r, int *mi_c, int blk_row, 881 int blk_col, MV mv, int sign_bias) { 882 const int base_blk_row = (blk_row >> 3) << 3; 883 const int base_blk_col = (blk_col >> 3) << 3; 884 885 const int row_offset = (mv.row >= 0) ? (mv.row >> (4 + MI_SIZE_LOG2)) 886 : -((-mv.row) >> (4 + MI_SIZE_LOG2)); 887 888 const int col_offset = (mv.col >= 0) ? (mv.col >> (4 + MI_SIZE_LOG2)) 889 : -((-mv.col) >> (4 + MI_SIZE_LOG2)); 890 891 const int row = 892 (sign_bias == 1) ? blk_row - row_offset : blk_row + row_offset; 893 const int col = 894 (sign_bias == 1) ? blk_col - col_offset : blk_col + col_offset; 895 896 if (row < 0 || row >= (cm->mi_params.mi_rows >> 1) || col < 0 || 897 col >= (cm->mi_params.mi_cols >> 1)) 898 return 0; 899 900 if (row < base_blk_row - (MAX_OFFSET_HEIGHT >> 3) || 901 row >= base_blk_row + 8 + (MAX_OFFSET_HEIGHT >> 3) || 902 col < base_blk_col - (MAX_OFFSET_WIDTH >> 3) || 903 col >= base_blk_col + 8 + (MAX_OFFSET_WIDTH >> 3)) 904 return 0; 905 906 *mi_r = row; 907 *mi_c = col; 908 909 return 1; 910 } 911 912 // Note: motion_filed_projection finds motion vectors of current frame's 913 // reference frame, and projects them to current frame. To make it clear, 914 // let's call current frame's reference frame as start frame. 915 // Call Start frame's reference frames as reference frames. 916 // Call ref_offset as frame distances between start frame and its reference 917 // frames. 918 static int motion_field_projection(AV1_COMMON *cm, 919 MV_REFERENCE_FRAME start_frame, int dir) { 920 TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; 921 int ref_offset[REF_FRAMES] = { 0 }; 922 923 const RefCntBuffer *const start_frame_buf = 924 get_ref_frame_buf(cm, start_frame); 925 if (start_frame_buf == NULL) return 0; 926 927 if (start_frame_buf->frame_type == KEY_FRAME || 928 start_frame_buf->frame_type == INTRA_ONLY_FRAME) 929 return 0; 930 931 if (start_frame_buf->mi_rows != cm->mi_params.mi_rows || 932 start_frame_buf->mi_cols != cm->mi_params.mi_cols) 933 return 0; 934 935 const int start_frame_order_hint = start_frame_buf->order_hint; 936 const unsigned int *const ref_order_hints = 937 &start_frame_buf->ref_order_hints[0]; 938 const int cur_order_hint = cm->cur_frame->order_hint; 939 int start_to_current_frame_offset = get_relative_dist( 940 &cm->seq_params->order_hint_info, start_frame_order_hint, cur_order_hint); 941 942 for (MV_REFERENCE_FRAME rf = LAST_FRAME; rf <= INTER_REFS_PER_FRAME; ++rf) { 943 ref_offset[rf] = get_relative_dist(&cm->seq_params->order_hint_info, 944 start_frame_order_hint, 945 ref_order_hints[rf - LAST_FRAME]); 946 } 947 948 if (dir == 2) start_to_current_frame_offset = -start_to_current_frame_offset; 949 950 MV_REF *mv_ref_base = start_frame_buf->mvs; 951 const int mvs_rows = (cm->mi_params.mi_rows + 1) >> 1; 952 const int mvs_cols = (cm->mi_params.mi_cols + 1) >> 1; 953 954 for (int blk_row = 0; blk_row < mvs_rows; ++blk_row) { 955 for (int blk_col = 0; blk_col < mvs_cols; ++blk_col) { 956 MV_REF *mv_ref = &mv_ref_base[blk_row * mvs_cols + blk_col]; 957 MV fwd_mv = mv_ref->mv.as_mv; 958 959 if (mv_ref->ref_frame > INTRA_FRAME) { 960 int_mv this_mv; 961 int mi_r, mi_c; 962 const int ref_frame_offset = ref_offset[mv_ref->ref_frame]; 963 964 int pos_valid = 965 abs(ref_frame_offset) <= MAX_FRAME_DISTANCE && 966 ref_frame_offset > 0 && 967 abs(start_to_current_frame_offset) <= MAX_FRAME_DISTANCE; 968 969 if (pos_valid) { 970 av1_get_mv_projection(&this_mv.as_mv, fwd_mv, 971 start_to_current_frame_offset, 972 ref_frame_offset); 973 pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, 974 this_mv.as_mv, dir >> 1); 975 } 976 977 if (pos_valid) { 978 const int mi_offset = mi_r * (cm->mi_params.mi_stride >> 1) + mi_c; 979 980 tpl_mvs_base[mi_offset].mfmv0.as_mv.row = fwd_mv.row; 981 tpl_mvs_base[mi_offset].mfmv0.as_mv.col = fwd_mv.col; 982 tpl_mvs_base[mi_offset].ref_frame_offset = ref_frame_offset; 983 } 984 } 985 } 986 } 987 988 return 1; 989 } 990 991 // cm->ref_frame_side is calculated here, and will be used in 992 // av1_copy_frame_mvs() to affect how mvs are copied. 993 void av1_calculate_ref_frame_side(AV1_COMMON *cm) { 994 const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; 995 996 memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side)); 997 if (!order_hint_info->enable_order_hint) return; 998 999 const int cur_order_hint = cm->cur_frame->order_hint; 1000 1001 for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { 1002 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); 1003 int order_hint = 0; 1004 1005 if (buf != NULL) order_hint = buf->order_hint; 1006 1007 if (get_relative_dist(order_hint_info, order_hint, cur_order_hint) > 0) 1008 cm->ref_frame_side[ref_frame] = 1; 1009 else if (order_hint == cur_order_hint) 1010 cm->ref_frame_side[ref_frame] = -1; 1011 } 1012 } 1013 1014 void av1_setup_motion_field(AV1_COMMON *cm) { 1015 const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; 1016 1017 if (!order_hint_info->enable_order_hint) return; 1018 1019 TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; 1020 int size = ((cm->mi_params.mi_rows + MAX_MIB_SIZE) >> 1) * 1021 (cm->mi_params.mi_stride >> 1); 1022 for (int idx = 0; idx < size; ++idx) { 1023 tpl_mvs_base[idx].mfmv0.as_int = INVALID_MV; 1024 tpl_mvs_base[idx].ref_frame_offset = 0; 1025 } 1026 1027 const int cur_order_hint = cm->cur_frame->order_hint; 1028 const RefCntBuffer *ref_buf[INTER_REFS_PER_FRAME]; 1029 int ref_order_hint[INTER_REFS_PER_FRAME]; 1030 1031 for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { 1032 const int ref_idx = ref_frame - LAST_FRAME; 1033 const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref_frame); 1034 int order_hint = 0; 1035 1036 if (buf != NULL) order_hint = buf->order_hint; 1037 1038 ref_buf[ref_idx] = buf; 1039 ref_order_hint[ref_idx] = order_hint; 1040 } 1041 1042 int ref_stamp = MFMV_STACK_SIZE - 1; 1043 1044 if (ref_buf[LAST_FRAME - LAST_FRAME] != NULL) { 1045 const int alt_of_lst_order_hint = 1046 ref_buf[LAST_FRAME - LAST_FRAME] 1047 ->ref_order_hints[ALTREF_FRAME - LAST_FRAME]; 1048 1049 const int is_lst_overlay = 1050 (alt_of_lst_order_hint == ref_order_hint[GOLDEN_FRAME - LAST_FRAME]); 1051 if (!is_lst_overlay) motion_field_projection(cm, LAST_FRAME, 2); 1052 --ref_stamp; 1053 } 1054 1055 if (get_relative_dist(order_hint_info, 1056 ref_order_hint[BWDREF_FRAME - LAST_FRAME], 1057 cur_order_hint) > 0) { 1058 if (motion_field_projection(cm, BWDREF_FRAME, 0)) --ref_stamp; 1059 } 1060 1061 if (get_relative_dist(order_hint_info, 1062 ref_order_hint[ALTREF2_FRAME - LAST_FRAME], 1063 cur_order_hint) > 0) { 1064 if (motion_field_projection(cm, ALTREF2_FRAME, 0)) --ref_stamp; 1065 } 1066 1067 if (get_relative_dist(order_hint_info, 1068 ref_order_hint[ALTREF_FRAME - LAST_FRAME], 1069 cur_order_hint) > 0 && 1070 ref_stamp >= 0) 1071 if (motion_field_projection(cm, ALTREF_FRAME, 0)) --ref_stamp; 1072 1073 if (ref_stamp >= 0) motion_field_projection(cm, LAST2_FRAME, 2); 1074 } 1075 1076 static inline void record_samples(const MB_MODE_INFO *mbmi, int *pts, 1077 int *pts_inref, int row_offset, int sign_r, 1078 int col_offset, int sign_c) { 1079 const int bw = block_size_wide[mbmi->bsize]; 1080 const int bh = block_size_high[mbmi->bsize]; 1081 const int x = col_offset * MI_SIZE + sign_c * bw / 2 - 1; 1082 const int y = row_offset * MI_SIZE + sign_r * bh / 2 - 1; 1083 1084 pts[0] = GET_MV_SUBPEL(x); 1085 pts[1] = GET_MV_SUBPEL(y); 1086 pts_inref[0] = pts[0] + mbmi->mv[0].as_mv.col; 1087 pts_inref[1] = pts[1] + mbmi->mv[0].as_mv.row; 1088 } 1089 1090 // Select samples according to the motion vector difference. 1091 uint8_t av1_selectSamples(MV *mv, int *pts, int *pts_inref, int len, 1092 BLOCK_SIZE bsize) { 1093 const int bw = block_size_wide[bsize]; 1094 const int bh = block_size_high[bsize]; 1095 const int thresh = clamp(AOMMAX(bw, bh), 16, 112); 1096 uint8_t ret = 0; 1097 assert(len <= LEAST_SQUARES_SAMPLES_MAX); 1098 1099 // Only keep the samples with MV differences within threshold. 1100 for (int i = 0; i < len; ++i) { 1101 const int diff = abs(pts_inref[2 * i] - pts[2 * i] - mv->col) + 1102 abs(pts_inref[2 * i + 1] - pts[2 * i + 1] - mv->row); 1103 if (diff > thresh) continue; 1104 if (ret != i) { 1105 memcpy(pts + 2 * ret, pts + 2 * i, 2 * sizeof(pts[0])); 1106 memcpy(pts_inref + 2 * ret, pts_inref + 2 * i, 2 * sizeof(pts_inref[0])); 1107 } 1108 ++ret; 1109 } 1110 // Keep at least 1 sample. 1111 return AOMMAX(ret, 1); 1112 } 1113 1114 // Note: Samples returned are at 1/8-pel precision 1115 // Sample are the neighbor block center point's coordinates relative to the 1116 // left-top pixel of current block. 1117 uint8_t av1_findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int *pts, 1118 int *pts_inref) { 1119 const MB_MODE_INFO *const mbmi0 = xd->mi[0]; 1120 const int ref_frame = mbmi0->ref_frame[0]; 1121 const int up_available = xd->up_available; 1122 const int left_available = xd->left_available; 1123 uint8_t np = 0; 1124 int do_tl = 1; 1125 int do_tr = 1; 1126 const int mi_stride = xd->mi_stride; 1127 const int mi_row = xd->mi_row; 1128 const int mi_col = xd->mi_col; 1129 1130 // scan the nearest above rows 1131 if (up_available) { 1132 const int mi_row_offset = -1; 1133 const MB_MODE_INFO *mbmi = xd->mi[mi_row_offset * mi_stride]; 1134 uint8_t superblock_width = mi_size_wide[mbmi->bsize]; 1135 1136 if (xd->width <= superblock_width) { 1137 // Handle "current block width <= above block width" case. 1138 const int col_offset = -mi_col % superblock_width; 1139 1140 if (col_offset < 0) do_tl = 0; 1141 if (col_offset + superblock_width > xd->width) do_tr = 0; 1142 1143 if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { 1144 record_samples(mbmi, pts, pts_inref, 0, -1, col_offset, 1); 1145 pts += 2; 1146 pts_inref += 2; 1147 if (++np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; 1148 } 1149 } else { 1150 // Handle "current block width > above block width" case. 1151 for (int i = 0; i < AOMMIN(xd->width, cm->mi_params.mi_cols - mi_col); 1152 i += superblock_width) { 1153 mbmi = xd->mi[i + mi_row_offset * mi_stride]; 1154 superblock_width = mi_size_wide[mbmi->bsize]; 1155 1156 if (mbmi->ref_frame[0] == ref_frame && 1157 mbmi->ref_frame[1] == NONE_FRAME) { 1158 record_samples(mbmi, pts, pts_inref, 0, -1, i, 1); 1159 pts += 2; 1160 pts_inref += 2; 1161 if (++np >= LEAST_SQUARES_SAMPLES_MAX) 1162 return LEAST_SQUARES_SAMPLES_MAX; 1163 } 1164 } 1165 } 1166 } 1167 assert(np <= LEAST_SQUARES_SAMPLES_MAX); 1168 1169 // scan the nearest left columns 1170 if (left_available) { 1171 const int mi_col_offset = -1; 1172 const MB_MODE_INFO *mbmi = xd->mi[mi_col_offset]; 1173 uint8_t superblock_height = mi_size_high[mbmi->bsize]; 1174 1175 if (xd->height <= superblock_height) { 1176 // Handle "current block height <= above block height" case. 1177 const int row_offset = -mi_row % superblock_height; 1178 1179 if (row_offset < 0) do_tl = 0; 1180 1181 if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { 1182 record_samples(mbmi, pts, pts_inref, row_offset, 1, 0, -1); 1183 pts += 2; 1184 pts_inref += 2; 1185 np++; 1186 if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; 1187 } 1188 } else { 1189 // Handle "current block height > above block height" case. 1190 for (int i = 0; i < AOMMIN(xd->height, cm->mi_params.mi_rows - mi_row); 1191 i += superblock_height) { 1192 mbmi = xd->mi[mi_col_offset + i * mi_stride]; 1193 superblock_height = mi_size_high[mbmi->bsize]; 1194 1195 if (mbmi->ref_frame[0] == ref_frame && 1196 mbmi->ref_frame[1] == NONE_FRAME) { 1197 record_samples(mbmi, pts, pts_inref, i, 1, 0, -1); 1198 pts += 2; 1199 pts_inref += 2; 1200 if (++np >= LEAST_SQUARES_SAMPLES_MAX) 1201 return LEAST_SQUARES_SAMPLES_MAX; 1202 } 1203 } 1204 } 1205 } 1206 assert(np <= LEAST_SQUARES_SAMPLES_MAX); 1207 1208 // Top-left block 1209 if (do_tl && left_available && up_available) { 1210 const int mi_row_offset = -1; 1211 const int mi_col_offset = -1; 1212 MB_MODE_INFO *mbmi = xd->mi[mi_col_offset + mi_row_offset * mi_stride]; 1213 1214 if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { 1215 record_samples(mbmi, pts, pts_inref, 0, -1, 0, -1); 1216 pts += 2; 1217 pts_inref += 2; 1218 if (++np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; 1219 } 1220 } 1221 assert(np <= LEAST_SQUARES_SAMPLES_MAX); 1222 1223 // Top-right block 1224 if (do_tr && 1225 has_top_right(cm, xd, mi_row, mi_col, AOMMAX(xd->width, xd->height))) { 1226 const POSITION trb_pos = { -1, xd->width }; 1227 const TileInfo *const tile = &xd->tile; 1228 if (is_inside(tile, mi_col, mi_row, &trb_pos)) { 1229 const int mi_row_offset = -1; 1230 const int mi_col_offset = xd->width; 1231 const MB_MODE_INFO *mbmi = 1232 xd->mi[mi_col_offset + mi_row_offset * mi_stride]; 1233 1234 if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { 1235 record_samples(mbmi, pts, pts_inref, 0, -1, xd->width, 1); 1236 if (++np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; 1237 } 1238 } 1239 } 1240 assert(np <= LEAST_SQUARES_SAMPLES_MAX); 1241 1242 return np; 1243 } 1244 1245 void av1_setup_skip_mode_allowed(AV1_COMMON *cm) { 1246 const OrderHintInfo *const order_hint_info = &cm->seq_params->order_hint_info; 1247 SkipModeInfo *const skip_mode_info = &cm->current_frame.skip_mode_info; 1248 1249 skip_mode_info->skip_mode_allowed = 0; 1250 skip_mode_info->ref_frame_idx_0 = INVALID_IDX; 1251 skip_mode_info->ref_frame_idx_1 = INVALID_IDX; 1252 1253 if (!order_hint_info->enable_order_hint || frame_is_intra_only(cm) || 1254 cm->current_frame.reference_mode == SINGLE_REFERENCE) 1255 return; 1256 1257 const int cur_order_hint = cm->current_frame.order_hint; 1258 int ref_order_hints[2] = { -1, INT_MAX }; 1259 int ref_idx[2] = { INVALID_IDX, INVALID_IDX }; 1260 1261 // Identify the nearest forward and backward references. 1262 for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { 1263 const RefCntBuffer *const buf = get_ref_frame_buf(cm, LAST_FRAME + i); 1264 if (buf == NULL) continue; 1265 1266 const int ref_order_hint = buf->order_hint; 1267 if (get_relative_dist(order_hint_info, ref_order_hint, cur_order_hint) < 1268 0) { 1269 // Forward reference 1270 if (ref_order_hints[0] == -1 || 1271 get_relative_dist(order_hint_info, ref_order_hint, 1272 ref_order_hints[0]) > 0) { 1273 ref_order_hints[0] = ref_order_hint; 1274 ref_idx[0] = i; 1275 } 1276 } else if (get_relative_dist(order_hint_info, ref_order_hint, 1277 cur_order_hint) > 0) { 1278 // Backward reference 1279 if (ref_order_hints[1] == INT_MAX || 1280 get_relative_dist(order_hint_info, ref_order_hint, 1281 ref_order_hints[1]) < 0) { 1282 ref_order_hints[1] = ref_order_hint; 1283 ref_idx[1] = i; 1284 } 1285 } 1286 } 1287 1288 if (ref_idx[0] != INVALID_IDX && ref_idx[1] != INVALID_IDX) { 1289 // == Bi-directional prediction == 1290 skip_mode_info->skip_mode_allowed = 1; 1291 skip_mode_info->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]); 1292 skip_mode_info->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]); 1293 } else if (ref_idx[0] != INVALID_IDX && ref_idx[1] == INVALID_IDX) { 1294 // == Forward prediction only == 1295 // Identify the second nearest forward reference. 1296 ref_order_hints[1] = -1; 1297 for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { 1298 const RefCntBuffer *const buf = get_ref_frame_buf(cm, LAST_FRAME + i); 1299 if (buf == NULL) continue; 1300 1301 const int ref_order_hint = buf->order_hint; 1302 if ((ref_order_hints[0] != -1 && 1303 get_relative_dist(order_hint_info, ref_order_hint, 1304 ref_order_hints[0]) < 0) && 1305 (ref_order_hints[1] == -1 || 1306 get_relative_dist(order_hint_info, ref_order_hint, 1307 ref_order_hints[1]) > 0)) { 1308 // Second closest forward reference 1309 ref_order_hints[1] = ref_order_hint; 1310 ref_idx[1] = i; 1311 } 1312 } 1313 if (ref_order_hints[1] != -1) { 1314 skip_mode_info->skip_mode_allowed = 1; 1315 skip_mode_info->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]); 1316 skip_mode_info->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]); 1317 } 1318 } 1319 } 1320 1321 typedef struct { 1322 int map_idx; // frame map index 1323 RefCntBuffer *buf; // frame buffer 1324 int sort_idx; // index based on the offset to be used for sorting 1325 } REF_FRAME_INFO; 1326 1327 // Compares the sort_idx fields. If they are equal, then compares the map_idx 1328 // fields to break the tie. This ensures a stable sort. 1329 static int compare_ref_frame_info(const void *arg_a, const void *arg_b) { 1330 const REF_FRAME_INFO *info_a = (REF_FRAME_INFO *)arg_a; 1331 const REF_FRAME_INFO *info_b = (REF_FRAME_INFO *)arg_b; 1332 1333 const int sort_idx_diff = info_a->sort_idx - info_b->sort_idx; 1334 if (sort_idx_diff != 0) return sort_idx_diff; 1335 return info_a->map_idx - info_b->map_idx; 1336 } 1337 1338 static inline void set_ref_frame_info(int *remapped_ref_idx, int frame_idx, 1339 REF_FRAME_INFO *ref_info) { 1340 assert(frame_idx >= 0 && frame_idx < INTER_REFS_PER_FRAME); 1341 1342 remapped_ref_idx[frame_idx] = ref_info->map_idx; 1343 } 1344 1345 void av1_set_frame_refs(AV1_COMMON *const cm, int *remapped_ref_idx, 1346 int lst_map_idx, int gld_map_idx) { 1347 int lst_frame_sort_idx = -1; 1348 int gld_frame_sort_idx = -1; 1349 1350 assert(cm->seq_params->order_hint_info.enable_order_hint); 1351 assert(cm->seq_params->order_hint_info.order_hint_bits_minus_1 >= 0); 1352 const int cur_order_hint = (int)cm->current_frame.order_hint; 1353 const int cur_frame_sort_idx = 1354 1 << cm->seq_params->order_hint_info.order_hint_bits_minus_1; 1355 1356 REF_FRAME_INFO ref_frame_info[REF_FRAMES]; 1357 int ref_flag_list[INTER_REFS_PER_FRAME] = { 0, 0, 0, 0, 0, 0, 0 }; 1358 1359 for (int i = 0; i < REF_FRAMES; ++i) { 1360 const int map_idx = i; 1361 1362 ref_frame_info[i].map_idx = map_idx; 1363 ref_frame_info[i].sort_idx = -1; 1364 1365 RefCntBuffer *const buf = cm->ref_frame_map[map_idx]; 1366 ref_frame_info[i].buf = buf; 1367 1368 if (buf == NULL) continue; 1369 // If this assertion fails, there is a reference leak. 1370 assert(buf->ref_count > 0); 1371 1372 const int offset = (int)buf->order_hint; 1373 ref_frame_info[i].sort_idx = 1374 (offset == -1) ? -1 1375 : cur_frame_sort_idx + 1376 get_relative_dist(&cm->seq_params->order_hint_info, 1377 offset, cur_order_hint); 1378 assert(ref_frame_info[i].sort_idx >= -1); 1379 1380 if (map_idx == lst_map_idx) lst_frame_sort_idx = ref_frame_info[i].sort_idx; 1381 if (map_idx == gld_map_idx) gld_frame_sort_idx = ref_frame_info[i].sort_idx; 1382 } 1383 1384 // Confirm both LAST_FRAME and GOLDEN_FRAME are valid forward reference 1385 // frames. 1386 if (lst_frame_sort_idx == -1 || lst_frame_sort_idx >= cur_frame_sort_idx) { 1387 aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME, 1388 "Inter frame requests a look-ahead frame as LAST"); 1389 } 1390 if (gld_frame_sort_idx == -1 || gld_frame_sort_idx >= cur_frame_sort_idx) { 1391 aom_internal_error(cm->error, AOM_CODEC_CORRUPT_FRAME, 1392 "Inter frame requests a look-ahead frame as GOLDEN"); 1393 } 1394 1395 // Sort ref frames based on their frame_offset values. 1396 qsort(ref_frame_info, REF_FRAMES, sizeof(REF_FRAME_INFO), 1397 compare_ref_frame_info); 1398 1399 // Identify forward and backward reference frames. 1400 // Forward reference: offset < order_hint 1401 // Backward reference: offset >= order_hint 1402 int fwd_start_idx = 0, fwd_end_idx = REF_FRAMES - 1; 1403 1404 for (int i = 0; i < REF_FRAMES; i++) { 1405 if (ref_frame_info[i].sort_idx == -1) { 1406 fwd_start_idx++; 1407 continue; 1408 } 1409 1410 if (ref_frame_info[i].sort_idx >= cur_frame_sort_idx) { 1411 fwd_end_idx = i - 1; 1412 break; 1413 } 1414 } 1415 1416 int bwd_start_idx = fwd_end_idx + 1; 1417 int bwd_end_idx = REF_FRAMES - 1; 1418 1419 // === Backward Reference Frames === 1420 1421 // == ALTREF_FRAME == 1422 if (bwd_start_idx <= bwd_end_idx) { 1423 set_ref_frame_info(remapped_ref_idx, ALTREF_FRAME - LAST_FRAME, 1424 &ref_frame_info[bwd_end_idx]); 1425 ref_flag_list[ALTREF_FRAME - LAST_FRAME] = 1; 1426 bwd_end_idx--; 1427 } 1428 1429 // == BWDREF_FRAME == 1430 if (bwd_start_idx <= bwd_end_idx) { 1431 set_ref_frame_info(remapped_ref_idx, BWDREF_FRAME - LAST_FRAME, 1432 &ref_frame_info[bwd_start_idx]); 1433 ref_flag_list[BWDREF_FRAME - LAST_FRAME] = 1; 1434 bwd_start_idx++; 1435 } 1436 1437 // == ALTREF2_FRAME == 1438 if (bwd_start_idx <= bwd_end_idx) { 1439 set_ref_frame_info(remapped_ref_idx, ALTREF2_FRAME - LAST_FRAME, 1440 &ref_frame_info[bwd_start_idx]); 1441 ref_flag_list[ALTREF2_FRAME - LAST_FRAME] = 1; 1442 } 1443 1444 // === Forward Reference Frames === 1445 1446 for (int i = fwd_start_idx; i <= fwd_end_idx; ++i) { 1447 // == LAST_FRAME == 1448 if (ref_frame_info[i].map_idx == lst_map_idx) { 1449 set_ref_frame_info(remapped_ref_idx, LAST_FRAME - LAST_FRAME, 1450 &ref_frame_info[i]); 1451 ref_flag_list[LAST_FRAME - LAST_FRAME] = 1; 1452 } 1453 1454 // == GOLDEN_FRAME == 1455 if (ref_frame_info[i].map_idx == gld_map_idx) { 1456 set_ref_frame_info(remapped_ref_idx, GOLDEN_FRAME - LAST_FRAME, 1457 &ref_frame_info[i]); 1458 ref_flag_list[GOLDEN_FRAME - LAST_FRAME] = 1; 1459 } 1460 } 1461 1462 assert(ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && 1463 ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1); 1464 1465 // == LAST2_FRAME == 1466 // == LAST3_FRAME == 1467 // == BWDREF_FRAME == 1468 // == ALTREF2_FRAME == 1469 // == ALTREF_FRAME == 1470 1471 // Set up the reference frames in the anti-chronological order. 1472 static const MV_REFERENCE_FRAME ref_frame_list[INTER_REFS_PER_FRAME - 2] = { 1473 LAST2_FRAME, LAST3_FRAME, BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME 1474 }; 1475 1476 int ref_idx; 1477 for (ref_idx = 0; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { 1478 const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; 1479 1480 if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; 1481 1482 while (fwd_start_idx <= fwd_end_idx && 1483 (ref_frame_info[fwd_end_idx].map_idx == lst_map_idx || 1484 ref_frame_info[fwd_end_idx].map_idx == gld_map_idx)) { 1485 fwd_end_idx--; 1486 } 1487 if (fwd_start_idx > fwd_end_idx) break; 1488 1489 set_ref_frame_info(remapped_ref_idx, ref_frame - LAST_FRAME, 1490 &ref_frame_info[fwd_end_idx]); 1491 ref_flag_list[ref_frame - LAST_FRAME] = 1; 1492 1493 fwd_end_idx--; 1494 } 1495 1496 // Assign all the remaining frame(s), if any, to the earliest reference 1497 // frame. 1498 for (; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { 1499 const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; 1500 if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; 1501 set_ref_frame_info(remapped_ref_idx, ref_frame - LAST_FRAME, 1502 &ref_frame_info[fwd_start_idx]); 1503 ref_flag_list[ref_frame - LAST_FRAME] = 1; 1504 } 1505 1506 for (int i = 0; i < INTER_REFS_PER_FRAME; i++) { 1507 assert(ref_flag_list[i] == 1); 1508 } 1509 }