diff options
Diffstat (limited to 'third_party/aom/av1/common/mvref_common.c')
| -rw-r--r-- | third_party/aom/av1/common/mvref_common.c | 1479 |
1 files changed, 1220 insertions, 259 deletions
diff --git a/third_party/aom/av1/common/mvref_common.c b/third_party/aom/av1/common/mvref_common.c index fdbcebcd1..891396e9b 100644 --- a/third_party/aom/av1/common/mvref_common.c +++ b/third_party/aom/av1/common/mvref_common.c @@ -14,10 +14,56 @@ #include "av1/common/warped_motion.h" #endif // CONFIG_WARPED_MOTION +#if CONFIG_GLOBAL_MOTION +#define USE_CUR_GM_REFMV 1 +#endif // CONFIG_GLOBAL_MOTION + +void av1_copy_frame_mvs(const AV1_COMMON *const cm, MODE_INFO *mi, int mi_row, + int mi_col, int x_mis, int y_mis) { +#if CONFIG_TMV + const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1); + MV_REF *frame_mvs = cm->cur_frame->mvs + + ((mi_row & 0xfffe) >> 1) * frame_mvs_stride + + ((mi_col & 0xfffe) >> 1); + x_mis = ROUND_POWER_OF_TWO(x_mis, 1); + y_mis = ROUND_POWER_OF_TWO(y_mis, 1); +#else + const int frame_mvs_stride = cm->mi_cols; + MV_REF *frame_mvs = cm->cur_frame->mvs + + (mi_row & 0xfffe) * frame_mvs_stride + (mi_col & 0xfffe); + x_mis = AOMMAX(x_mis, 2); + y_mis = AOMMAX(y_mis, 2); +#endif // CONFIG_TMV + int w, h; + + for (h = 0; h < y_mis; h++) { + MV_REF *const frame_mv = frame_mvs + h * frame_mvs_stride; + for (w = 0; w < x_mis; w++) { + MV_REF *const mv = frame_mv + w; + mv->ref_frame[0] = mi->mbmi.ref_frame[0]; + mv->ref_frame[1] = mi->mbmi.ref_frame[1]; + mv->mv[0].as_int = mi->mbmi.mv[0].as_int; + mv->mv[1].as_int = mi->mbmi.mv[1].as_int; + // (TODO:yunqing) The following 2 lines won't be used and can be removed. + mv->pred_mv[0].as_int = mi->mbmi.pred_mv[0].as_int; + mv->pred_mv[1].as_int = mi->mbmi.pred_mv[1].as_int; + } + } +} + static uint8_t add_ref_mv_candidate( const MODE_INFO *const candidate_mi, const MB_MODE_INFO *const candidate, const MV_REFERENCE_FRAME rf[2], uint8_t *refmv_count, - CANDIDATE_MV *ref_mv_stack, const int use_hp, int len, int block, int col) { + CANDIDATE_MV *ref_mv_stack, const int use_hp, int len, int block, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int_mv *gm_mv_candidates, const WarpedMotionParams *gm_params, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int col, int weight +#if CONFIG_AMVR + , + int is_integer +#endif + ) { int index = 0, ref; int newmv_count = 0; #if CONFIG_CB4X4 @@ -25,25 +71,36 @@ static uint8_t add_ref_mv_candidate( #else const int unify_bsize = 0; #endif + assert(weight % 2 == 0); if (rf[1] == NONE_FRAME) { // single reference frame for (ref = 0; ref < 2; ++ref) { if (candidate->ref_frame[ref] == rf[0]) { - int_mv this_refmv = get_sub_block_mv(candidate_mi, ref, col, block); + int_mv this_refmv; +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + if (is_global_mv_block(candidate_mi, block, gm_params[rf[0]].wmtype)) + this_refmv = gm_mv_candidates[0]; + else +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + this_refmv = get_sub_block_mv(candidate_mi, ref, col, block); +#if CONFIG_AMVR + lower_mv_precision(&this_refmv.as_mv, use_hp, is_integer); +#else lower_mv_precision(&this_refmv.as_mv, use_hp); +#endif // CONFIG_AMVR for (index = 0; index < *refmv_count; ++index) if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break; - if (index < *refmv_count) ref_mv_stack[index].weight += 2 * len; + if (index < *refmv_count) ref_mv_stack[index].weight += weight * len; // Add a new item to the list. if (index == *refmv_count) { ref_mv_stack[index].this_mv = this_refmv; ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx( get_sub_block_pred_mv(candidate_mi, ref, col, block), this_refmv); - ref_mv_stack[index].weight = 2 * len; + ref_mv_stack[index].weight = weight * len; ++(*refmv_count); if (candidate->mode == NEWMV) ++newmv_count; @@ -53,8 +110,11 @@ static uint8_t add_ref_mv_candidate( !unify_bsize) { int alt_block = 3 - block; this_refmv = get_sub_block_mv(candidate_mi, ref, col, alt_block); +#if CONFIG_AMVR + lower_mv_precision(&this_refmv.as_mv, use_hp, is_integer); +#else lower_mv_precision(&this_refmv.as_mv, use_hp); - +#endif for (index = 0; index < *refmv_count; ++index) if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break; @@ -80,8 +140,17 @@ static uint8_t add_ref_mv_candidate( int_mv this_refmv[2]; for (ref = 0; ref < 2; ++ref) { - this_refmv[ref] = get_sub_block_mv(candidate_mi, ref, col, block); +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + if (is_global_mv_block(candidate_mi, block, gm_params[rf[ref]].wmtype)) + this_refmv[ref] = gm_mv_candidates[ref]; + else +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + this_refmv[ref] = get_sub_block_mv(candidate_mi, ref, col, block); +#if CONFIG_AMVR + lower_mv_precision(&this_refmv[ref].as_mv, use_hp, is_integer); +#else lower_mv_precision(&this_refmv[ref].as_mv, use_hp); +#endif } for (index = 0; index < *refmv_count; ++index) @@ -89,7 +158,7 @@ static uint8_t add_ref_mv_candidate( (ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int)) break; - if (index < *refmv_count) ref_mv_stack[index].weight += 2 * len; + if (index < *refmv_count) ref_mv_stack[index].weight += weight * len; // Add a new item to the list. if (index == *refmv_count) { @@ -99,15 +168,10 @@ static uint8_t add_ref_mv_candidate( get_sub_block_pred_mv(candidate_mi, 0, col, block), this_refmv[0]); ref_mv_stack[index].pred_diff[1] = av1_get_pred_diff_ctx( get_sub_block_pred_mv(candidate_mi, 1, col, block), this_refmv[1]); - ref_mv_stack[index].weight = 2 * len; + ref_mv_stack[index].weight = weight * len; ++(*refmv_count); -#if CONFIG_EXT_INTER - if (candidate->mode == NEW_NEWMV) -#else - if (candidate->mode == NEWMV) -#endif // CONFIG_EXT_INTER - ++newmv_count; + if (candidate->mode == NEW_NEWMV) ++newmv_count; } if (candidate_mi->mbmi.sb_type < BLOCK_8X8 && block >= 0 && @@ -116,9 +180,13 @@ static uint8_t add_ref_mv_candidate( this_refmv[0] = get_sub_block_mv(candidate_mi, 0, col, alt_block); this_refmv[1] = get_sub_block_mv(candidate_mi, 1, col, alt_block); - for (ref = 0; ref < 2; ++ref) + for (ref = 0; ref < 2; ++ref) { +#if CONFIG_AMVR + lower_mv_precision(&this_refmv[ref].as_mv, use_hp, is_integer); +#else lower_mv_precision(&this_refmv[ref].as_mv, use_hp); - +#endif + } for (index = 0; index < *refmv_count; ++index) if (ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int && ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int) @@ -139,12 +207,7 @@ static uint8_t add_ref_mv_candidate( ref_mv_stack[index].weight = len; ++(*refmv_count); -#if CONFIG_EXT_INTER - if (candidate->mode == NEW_NEWMV) -#else - if (candidate->mode == NEWMV) -#endif // CONFIG_EXT_INTER - ++newmv_count; + if (candidate->mode == NEW_NEWMV) ++newmv_count; } } } @@ -153,95 +216,144 @@ static uint8_t add_ref_mv_candidate( } static uint8_t scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, - const int mi_row, const int mi_col, int block, + const int mi_col, int block, const MV_REFERENCE_FRAME rf[2], int row_offset, - CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count) { - const TileInfo *const tile = &xd->tile; + CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int_mv *gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int max_row_offset, int *processed_rows) { + const int end_mi = AOMMIN(xd->n8_w, cm->mi_cols - mi_col); + const int n8_w_8 = mi_size_wide[BLOCK_8X8]; + const int n8_w_16 = mi_size_wide[BLOCK_16X16]; int i; uint8_t newmv_count = 0; + int col_offset = 0; #if CONFIG_CB4X4 - const int bsize = xd->mi[0]->mbmi.sb_type; - const int mi_offset = - bsize < BLOCK_8X8 ? mi_size_wide[BLOCK_4X4] : mi_size_wide[BLOCK_8X8]; + const int shift = 0; // TODO(jingning): Revisit this part after cb4x4 is stable. - if (bsize >= BLOCK_8X8) row_offset *= 2; + if (abs(row_offset) > 1) { + col_offset = 1; + if (mi_col & 0x01 && xd->n8_w < n8_w_8) --col_offset; + } + const int use_step_16 = (xd->n8_w >= 16); #else - const int mi_offset = mi_size_wide[BLOCK_8X8]; + const int shift = 1; + const int use_step_16 = (xd->n8_w >= 8); #endif + MODE_INFO **const candidate_mi0 = xd->mi + row_offset * xd->mi_stride; - for (i = 0; i < xd->n8_w && *refmv_count < MAX_REF_MV_STACK_SIZE;) { - POSITION mi_pos; -#if CONFIG_CB4X4 - const int use_step_16 = (xd->n8_w >= 16); + for (i = 0; i < end_mi && *refmv_count < MAX_REF_MV_STACK_SIZE;) { + const MODE_INFO *const candidate_mi = candidate_mi0[col_offset + i]; + const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; + const int candidate_bsize = candidate->sb_type; + const int n8_w = mi_size_wide[candidate_bsize]; + int len = AOMMIN(xd->n8_w, n8_w); + if (use_step_16) + len = AOMMAX(n8_w_16, len); + else if (abs(row_offset) > 1) + len = AOMMAX(len, n8_w_8); + + int weight = 2; + if (xd->n8_w >= n8_w_8 && xd->n8_w <= n8_w) { + int inc = AOMMIN(-max_row_offset + row_offset + 1, + mi_size_high[candidate_bsize]); + // Obtain range used in weight calculation. + weight = AOMMAX(weight, (inc << shift)); + // Update processed rows. + *processed_rows = inc - row_offset - 1; + } + +#if CONFIG_AMVR + newmv_count += add_ref_mv_candidate( + candidate_mi, candidate, rf, refmv_count, ref_mv_stack, + cm->allow_high_precision_mv, len, block, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, cm->global_motion, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + col_offset + i, weight, cm->cur_frame_mv_precision_level); #else - const int use_step_16 = (xd->n8_w >= 8); + newmv_count += add_ref_mv_candidate(candidate_mi, candidate, rf, + refmv_count, ref_mv_stack, + cm->allow_high_precision_mv, len, block, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, cm->global_motion, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + col_offset + i, weight); #endif - mi_pos.row = row_offset; - mi_pos.col = i; - if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos)) { - const MODE_INFO *const candidate_mi = - xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col]; - const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; - int len = AOMMIN(xd->n8_w, mi_size_wide[candidate->sb_type]); - if (use_step_16) len = AOMMAX(mi_size_wide[BLOCK_16X16], len); - newmv_count += add_ref_mv_candidate( - candidate_mi, candidate, rf, refmv_count, ref_mv_stack, - cm->allow_high_precision_mv, len, block, mi_pos.col); - i += len; - } else { - if (use_step_16) - i += (mi_offset << 1); - else - i += mi_offset; - } + i += len; } return newmv_count; } static uint8_t scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, - const int mi_row, const int mi_col, int block, + const int mi_row, int block, const MV_REFERENCE_FRAME rf[2], int col_offset, - CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count) { - const TileInfo *const tile = &xd->tile; + CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int_mv *gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int max_col_offset, int *processed_cols) { + const int end_mi = AOMMIN(xd->n8_h, cm->mi_rows - mi_row); + const int n8_h_8 = mi_size_high[BLOCK_8X8]; + const int n8_h_16 = mi_size_high[BLOCK_16X16]; int i; uint8_t newmv_count = 0; + int row_offset = 0; #if CONFIG_CB4X4 - const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type; - const int mi_offset = - (bsize < BLOCK_8X8) ? mi_size_high[BLOCK_4X4] : mi_size_high[BLOCK_8X8]; - if (bsize >= BLOCK_8X8) col_offset *= 2; + const int shift = 0; + if (abs(col_offset) > 1) { + row_offset = 1; + if (mi_row & 0x01 && xd->n8_h < n8_h_8) --row_offset; + } + const int use_step_16 = (xd->n8_h >= 16); #else - const int mi_offset = mi_size_wide[BLOCK_8X8]; + const int shift = 1; + const int use_step_16 = (xd->n8_h >= 8); #endif - for (i = 0; i < xd->n8_h && *refmv_count < MAX_REF_MV_STACK_SIZE;) { - POSITION mi_pos; -#if CONFIG_CB4X4 - const int use_step_16 = (xd->n8_h >= 16); + for (i = 0; i < end_mi && *refmv_count < MAX_REF_MV_STACK_SIZE;) { + const MODE_INFO *const candidate_mi = + xd->mi[(row_offset + i) * xd->mi_stride + col_offset]; + const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; + const int candidate_bsize = candidate->sb_type; + const int n8_h = mi_size_high[candidate_bsize]; + int len = AOMMIN(xd->n8_h, n8_h); + if (use_step_16) + len = AOMMAX(n8_h_16, len); + else if (abs(col_offset) > 1) + len = AOMMAX(len, n8_h_8); + + int weight = 2; + if (xd->n8_h >= n8_h_8 && xd->n8_h <= n8_h) { + int inc = AOMMIN(-max_col_offset + col_offset + 1, + mi_size_wide[candidate_bsize]); + // Obtain range used in weight calculation. + weight = AOMMAX(weight, (inc << shift)); + // Update processed cols. + *processed_cols = inc - col_offset - 1; + } + +#if CONFIG_AMVR + newmv_count += add_ref_mv_candidate( + candidate_mi, candidate, rf, refmv_count, ref_mv_stack, + cm->allow_high_precision_mv, len, block, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, cm->global_motion, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + col_offset, weight, cm->cur_frame_mv_precision_level); #else - const int use_step_16 = (xd->n8_h >= 8); + newmv_count += add_ref_mv_candidate(candidate_mi, candidate, rf, + refmv_count, ref_mv_stack, + cm->allow_high_precision_mv, len, block, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, cm->global_motion, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + col_offset, weight); #endif - - mi_pos.row = i; - mi_pos.col = col_offset; - if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos)) { - const MODE_INFO *const candidate_mi = - xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col]; - const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; - int len = AOMMIN(xd->n8_h, mi_size_high[candidate->sb_type]); - if (use_step_16) len = AOMMAX(mi_size_high[BLOCK_16X16], len); - newmv_count += add_ref_mv_candidate( - candidate_mi, candidate, rf, refmv_count, ref_mv_stack, - cm->allow_high_precision_mv, len, block, mi_pos.col); - i += len; - } else { - if (use_step_16) - i += (mi_offset << 1); - else - i += mi_offset; - } + i += len; } return newmv_count; @@ -251,6 +363,9 @@ static uint8_t scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, const int mi_row, const int mi_col, int block, const MV_REFERENCE_FRAME rf[2], int row_offset, int col_offset, CANDIDATE_MV *ref_mv_stack, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int_mv *gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV uint8_t *refmv_count) { const TileInfo *const tile = &xd->tile; POSITION mi_pos; @@ -266,18 +381,33 @@ static uint8_t scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; const int len = mi_size_wide[BLOCK_8X8]; +#if CONFIG_AMVR newmv_count += add_ref_mv_candidate( candidate_mi, candidate, rf, refmv_count, ref_mv_stack, - cm->allow_high_precision_mv, len, block, mi_pos.col); + cm->allow_high_precision_mv, len, block, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, cm->global_motion, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + mi_pos.col, 2, cm->cur_frame_mv_precision_level); +#else + newmv_count += add_ref_mv_candidate(candidate_mi, candidate, rf, + refmv_count, ref_mv_stack, + cm->allow_high_precision_mv, len, block, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, cm->global_motion, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + mi_pos.col, 2); +#endif } // Analyze a single 8x8 block motion information. return newmv_count; } -static int has_top_right(const MACROBLOCKD *xd, int mi_row, int mi_col, - int bs) { - const int mask_row = mi_row & MAX_MIB_MASK; - const int mask_col = mi_col & MAX_MIB_MASK; +static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd, + int mi_row, int mi_col, int bs) { + const int sb_mi_size = mi_size_wide[cm->sb_size]; + const int mask_row = mi_row & (sb_mi_size - 1); + const int mask_col = mi_col & (sb_mi_size - 1); // In a split partition all apart from the bottom right has a top right int has_tr = !((mask_row & bs) && (mask_col & bs)); @@ -288,7 +418,7 @@ static int has_top_right(const MACROBLOCKD *xd, int mi_row, int mi_col, // For each 4x4 group of blocks, when the bottom right is decoded the blocks // to the right have not been decoded therefore the bottom right does // not have a top right - while (bs < MAX_MIB_SIZE) { + while (bs < sb_mi_size) { if (mask_col & bs) { if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) { has_tr = 0; @@ -310,9 +440,10 @@ static int has_top_right(const MACROBLOCKD *xd, int mi_row, int mi_col, if (xd->n8_w > xd->n8_h) if (xd->is_sec_rect) has_tr = 0; -#if CONFIG_EXT_PARTITION_TYPES - // The bottom left square of a Vertical A does not have a top right as it is - // decoded before the right hand rectangle of the partition +#if CONFIG_EXT_PARTITION_TYPES && !CONFIG_EXT_PARTITION_TYPES_AB + // The bottom left square of a Vertical A (in the old format) does + // not have a top right as it is decoded before the right hand + // rectangle of the partition if (xd->mi[0]->mbmi.partition == PARTITION_VERT_A) if ((mask_row & bs) && !(mask_col & bs)) has_tr = 0; #endif // CONFIG_EXT_PARTITION_TYPES @@ -320,19 +451,156 @@ static int has_top_right(const MACROBLOCKD *xd, int mi_row, int mi_col, return has_tr; } -static int add_col_ref_mv(const AV1_COMMON *cm, +#if CONFIG_MFMV +static int check_sb_border(const AV1_COMMON *cm, const int mi_row, + const int mi_col, const int row_offset, + const int col_offset) { + const int sb_mi_size = mi_size_wide[cm->sb_size]; + const int row = mi_row & (sb_mi_size - 1); + const int col = mi_col & (sb_mi_size - 1); + + if (row + row_offset < 0 || row + row_offset >= sb_mi_size || + col + col_offset < 0 || col + col_offset >= sb_mi_size) + return 0; + + return 1; +} + +static int add_tpl_ref_mv(const AV1_COMMON *cm, const MV_REF *prev_frame_mvs_base, const MACROBLOCKD *xd, int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame, int blk_row, int blk_col, uint8_t *refmv_count, CANDIDATE_MV *ref_mv_stack, int16_t *mode_context) { + (void)prev_frame_mvs_base; + POSITION mi_pos; + int idx; + int coll_blk_count = 0; + const int weight_unit = 1; // mi_size_wide[BLOCK_8X8]; + +#if CONFIG_MV_COMPRESS + mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1; + mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1; +#else + mi_pos.row = blk_row; + mi_pos.col = blk_col; +#endif + + if (!is_inside(&xd->tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos)) + return coll_blk_count; + + const TPL_MV_REF *prev_frame_mvs = cm->cur_frame->tpl_mvs + + (mi_row + mi_pos.row) * cm->mi_stride + + (mi_col + mi_pos.col); + + MV_REFERENCE_FRAME rf[2]; + av1_set_ref_frame(rf, ref_frame); + + if (rf[1] == NONE_FRAME) { + for (int i = 0; i < MFMV_STACK_SIZE; ++i) { + if (prev_frame_mvs->mfmv[ref_frame - LAST_FRAME][i].as_int != + INVALID_MV) { + int_mv this_refmv = prev_frame_mvs->mfmv[ref_frame - LAST_FRAME][i]; + lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv); + + if (blk_row == 0 && blk_col == 0) + if (abs(this_refmv.as_mv.row) >= 16 || + abs(this_refmv.as_mv.col) >= 16) + mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); + + for (idx = 0; idx < *refmv_count; ++idx) + if (abs(this_refmv.as_mv.row - ref_mv_stack[idx].this_mv.as_mv.row) < + 4 && + abs(this_refmv.as_mv.col - ref_mv_stack[idx].this_mv.as_mv.col) < + 4) + break; + + if (idx < *refmv_count) ref_mv_stack[idx].weight += 2 * weight_unit; + + if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { + ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; + // TODO(jingning): Hard coded context number. Need to make it better + // sense. + ref_mv_stack[idx].pred_diff[0] = 1; + ref_mv_stack[idx].weight = 2 * weight_unit; + ++(*refmv_count); + } + + ++coll_blk_count; + } + } + } else { + // Process compound inter mode + for (int i = 0; i < MFMV_STACK_SIZE; ++i) { + if (prev_frame_mvs->mfmv[rf[0] - LAST_FRAME][i].as_int != INVALID_MV && + prev_frame_mvs->mfmv[rf[1] - LAST_FRAME][i].as_int != INVALID_MV) { + int_mv this_refmv = prev_frame_mvs->mfmv[rf[0] - LAST_FRAME][i]; + int_mv comp_refmv = prev_frame_mvs->mfmv[rf[1] - LAST_FRAME][i]; + lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv); + lower_mv_precision(&comp_refmv.as_mv, cm->allow_high_precision_mv); + + if (blk_row == 0 && blk_col == 0) + if (abs(this_refmv.as_mv.row) >= 16 || + abs(this_refmv.as_mv.col) >= 16 || + abs(comp_refmv.as_mv.row) >= 16 || + abs(comp_refmv.as_mv.col) >= 16) + mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); + + for (idx = 0; idx < *refmv_count; ++idx) + if (abs(this_refmv.as_mv.row - ref_mv_stack[idx].this_mv.as_mv.row) < + 4 && + abs(this_refmv.as_mv.col - ref_mv_stack[idx].this_mv.as_mv.col) < + 4 && + abs(comp_refmv.as_mv.row - ref_mv_stack[idx].comp_mv.as_mv.row) < + 4 && + abs(comp_refmv.as_mv.col - ref_mv_stack[idx].comp_mv.as_mv.col) < + 4) + break; + + if (idx < *refmv_count) ref_mv_stack[idx].weight += 2 * weight_unit; + + if (idx == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { + ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; + ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int; + // TODO(jingning): Hard coded context number. Need to make it better + // sense. + ref_mv_stack[idx].pred_diff[0] = 1; + ref_mv_stack[idx].pred_diff[1] = 1; + ref_mv_stack[idx].weight = 2 * weight_unit; + ++(*refmv_count); + } + + ++coll_blk_count; + } + } + } + + return coll_blk_count; +} +#else +static int add_col_ref_mv(const AV1_COMMON *cm, + const MV_REF *prev_frame_mvs_base, + int prev_frame_mvs_stride, const MACROBLOCKD *xd, + int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame, + int blk_row, int blk_col, uint8_t *refmv_count, + CANDIDATE_MV *ref_mv_stack, int16_t *mode_context) { +#if CONFIG_TMV + const MV_REF *prev_frame_mvs = prev_frame_mvs_base + + ((blk_row + 1) >> 1) * prev_frame_mvs_stride + + ((blk_col + 1) >> 1); +#else const MV_REF *prev_frame_mvs = - prev_frame_mvs_base + blk_row * cm->mi_cols + blk_col; + prev_frame_mvs_base + blk_row * prev_frame_mvs_stride + blk_col; +#endif POSITION mi_pos; int ref, idx; int coll_blk_count = 0; const int weight_unit = mi_size_wide[BLOCK_8X8]; +#if CONFIG_TMV + mi_pos.row = blk_row; + mi_pos.col = blk_col; +#else #if CONFIG_MV_COMPRESS mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1; mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1; @@ -340,16 +608,27 @@ static int add_col_ref_mv(const AV1_COMMON *cm, mi_pos.row = blk_row; mi_pos.col = blk_col; #endif +#endif // CONFIG_TMV if (!is_inside(&xd->tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos)) return coll_blk_count; for (ref = 0; ref < 2; ++ref) { if (prev_frame_mvs->ref_frame[ref] == ref_frame) { int_mv this_refmv = prev_frame_mvs->mv[ref]; +#if CONFIG_AMVR + lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv, + cm->cur_frame_mv_precision_level); +#else lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv); +#endif - if (abs(this_refmv.as_mv.row) >= 16 || abs(this_refmv.as_mv.col) >= 16) - mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); +#if CONFIG_OPT_REF_MV + if (blk_row == 0 && blk_col == 0) +#endif + { + if (abs(this_refmv.as_mv.row) >= 16 || abs(this_refmv.as_mv.col) >= 16) + mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); + } for (idx = 0; idx < *refmv_count; ++idx) if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break; @@ -370,60 +649,161 @@ static int add_col_ref_mv(const AV1_COMMON *cm, return coll_blk_count; } +#endif static void setup_ref_mv_list(const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame, uint8_t *refmv_count, CANDIDATE_MV *ref_mv_stack, - int_mv *mv_ref_list, int block, int mi_row, - int mi_col, int16_t *mode_context) { + int_mv *mv_ref_list, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int_mv *gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + int block, int mi_row, int mi_col, + int16_t *mode_context) { int idx, nearest_refmv_count = 0; uint8_t newmv_count = 0; CANDIDATE_MV tmp_mv; int len, nr_len; +#if CONFIG_TMV + const int prev_frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1); + const int tmi_row = mi_row & 0xfffe; + const int tmi_col = mi_col & 0xfffe; + const MV_REF *const prev_frame_mvs_base = + cm->use_prev_frame_mvs + ? cm->prev_frame->mvs + (tmi_row >> 1) * prev_frame_mvs_stride + + (tmi_col >> 1) + : NULL; +#else + const int prev_frame_mvs_stride = cm->mi_cols; #if CONFIG_MV_COMPRESS const MV_REF *const prev_frame_mvs_base = cm->use_prev_frame_mvs - ? cm->prev_frame->mvs + (((mi_row >> 1) << 1) + 1) * cm->mi_cols + + ? cm->prev_frame->mvs + + (((mi_row >> 1) << 1) + 1) * prev_frame_mvs_stride + ((mi_col >> 1) << 1) + 1 : NULL; #else const MV_REF *const prev_frame_mvs_base = cm->use_prev_frame_mvs - ? cm->prev_frame->mvs + mi_row * cm->mi_cols + mi_col + ? cm->prev_frame->mvs + mi_row * prev_frame_mvs_stride + mi_col : NULL; #endif +#endif // CONFIG_TMV const int bs = AOMMAX(xd->n8_w, xd->n8_h); - const int has_tr = has_top_right(xd, mi_row, mi_col, bs); + const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs); MV_REFERENCE_FRAME rf[2]; + const TileInfo *const tile = &xd->tile; + int max_row_offset = 0, max_col_offset = 0; +#if CONFIG_CB4X4 + const int row_adj = (xd->n8_h < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01); + const int col_adj = (xd->n8_w < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01); +#endif + int processed_rows = 0; + int processed_cols = 0; + int row_offset, col_offset; + av1_set_ref_frame(rf, ref_frame); mode_context[ref_frame] = 0; *refmv_count = 0; - // Scan the first above row mode info. - newmv_count += scan_row_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, - ref_mv_stack, refmv_count); - // Scan the first left column mode info. - newmv_count += scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, - ref_mv_stack, refmv_count); + // Find valid maximum row/col offset. + if (xd->up_available) { +#if CONFIG_CB4X4 + max_row_offset = -(MVREF_ROWS << 1) + row_adj; +#else + max_row_offset = -MVREF_ROWS; +#endif + max_row_offset = + find_valid_row_offset(tile, mi_row, cm->mi_rows, cm, max_row_offset); + } + if (xd->left_available) { +#if CONFIG_CB4X4 + max_col_offset = -(MVREF_COLS << 1) + col_adj; +#else + max_col_offset = -MVREF_COLS; +#endif + max_col_offset = find_valid_col_offset(tile, mi_col, max_col_offset); + } + + // Scan the first above row mode info. row_offset = -1; + if (abs(max_row_offset) >= 1) + newmv_count += + scan_row_mbmi(cm, xd, mi_col, block, rf, -1, ref_mv_stack, refmv_count, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + max_row_offset, &processed_rows); + // Scan the first left column mode info. col_offset = -1; + if (abs(max_col_offset) >= 1) + newmv_count += + scan_col_mbmi(cm, xd, mi_row, block, rf, -1, ref_mv_stack, refmv_count, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + max_col_offset, &processed_cols); // Check top-right boundary if (has_tr) newmv_count += scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, - xd->n8_w, ref_mv_stack, refmv_count); + xd->n8_w, ref_mv_stack, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + refmv_count); nearest_refmv_count = *refmv_count; for (idx = 0; idx < nearest_refmv_count; ++idx) ref_mv_stack[idx].weight += REF_CAT_LEVEL; + +#if CONFIG_MFMV + int blk_row, blk_col; + int coll_blk_count = 0; + int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->n8_h); + int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->n8_w); + + int tpl_sample_pos[9][2] = { + { -2, hoffset }, { 0, hoffset }, { voffset, hoffset }, + { voffset, 0 }, { voffset, -2 }, { voffset, -4 }, + { -4, hoffset }, { voffset, 4 }, { 2, hoffset + 4 }, + }; + int i; + + for (blk_row = 0; blk_row < xd->n8_h; blk_row += mi_size_high[BLOCK_8X8]) { + for (blk_col = 0; blk_col < xd->n8_w; blk_col += mi_size_wide[BLOCK_8X8]) { + // (TODO: yunqing) prev_frame_mvs_base is not used here, tpl_mvs is used. + // Can be modified the same way. + int is_available = add_tpl_ref_mv( + cm, prev_frame_mvs_base, xd, mi_row, mi_col, ref_frame, blk_row, + blk_col, refmv_count, ref_mv_stack, mode_context); + if (blk_row == 0 && blk_col == 0) coll_blk_count = is_available; + } + } + + if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); + + for (i = 0; i < 9; ++i) { + blk_row = tpl_sample_pos[i][0]; + blk_col = tpl_sample_pos[i][1]; + + if (!check_sb_border(cm, mi_row, mi_col, blk_row, blk_col)) continue; + // (TODO: yunqing) prev_frame_mvs_base is not used here, tpl_mvs is used. + // Can be modified the same way. + coll_blk_count += add_tpl_ref_mv(cm, prev_frame_mvs_base, xd, mi_row, + mi_col, ref_frame, blk_row, blk_col, + refmv_count, ref_mv_stack, mode_context); + } +#else #if CONFIG_TEMPMV_SIGNALING - if (cm->use_prev_frame_mvs && rf[1] == NONE_FRAME) { + if (cm->use_prev_frame_mvs && rf[1] == NONE_FRAME) #else if (prev_frame_mvs_base && cm->show_frame && cm->last_show_frame && - rf[1] == NONE_FRAME) { + rf[1] == NONE_FRAME) #endif + { int blk_row, blk_col; int coll_blk_count = 0; #if CONFIG_CB4X4 @@ -435,6 +815,8 @@ static void setup_ref_mv_list(const AV1_COMMON *cm, const MACROBLOCKD *xd, #endif #if CONFIG_TPL_MV + // Modified sample positions to be consistent with frame_mvs + // spatial resolution. int tpl_sample_pos[5][2] = { { -1, xd->n8_w }, { 0, xd->n8_w }, { xd->n8_h, xd->n8_w }, @@ -445,9 +827,22 @@ static void setup_ref_mv_list(const AV1_COMMON *cm, const MACROBLOCKD *xd, for (blk_row = 0; blk_row < xd->n8_h; blk_row += mi_step) { for (blk_col = 0; blk_col < xd->n8_w; blk_col += mi_step) { - coll_blk_count += add_col_ref_mv( - cm, prev_frame_mvs_base, xd, mi_row, mi_col, ref_frame, blk_row, - blk_col, refmv_count, ref_mv_stack, mode_context); +#if CONFIG_TMV + int is_available = + add_col_ref_mv(cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd, + tmi_row, tmi_col, ref_frame, blk_row, blk_col, + refmv_count, ref_mv_stack, mode_context); +#else + int is_available = + add_col_ref_mv(cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd, + mi_row, mi_col, ref_frame, blk_row, blk_col, + refmv_count, ref_mv_stack, mode_context); +#endif // CONFIG_TMV +#if CONFIG_OPT_REF_MV + if (blk_row == 0 && blk_col == 0) coll_blk_count = is_available; +#else + coll_blk_count += is_available; +#endif } } @@ -455,9 +850,15 @@ static void setup_ref_mv_list(const AV1_COMMON *cm, const MACROBLOCKD *xd, for (i = 0; i < 5; ++i) { blk_row = tpl_sample_pos[i][0]; blk_col = tpl_sample_pos[i][1]; - coll_blk_count += add_col_ref_mv(cm, prev_frame_mvs_base, xd, mi_row, - mi_col, ref_frame, blk_row, blk_col, - refmv_count, ref_mv_stack, mode_context); +#if CONFIG_TMV + coll_blk_count += add_col_ref_mv( + cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd, tmi_row, tmi_col, + ref_frame, blk_row, blk_col, refmv_count, ref_mv_stack, mode_context); +#else + coll_blk_count += add_col_ref_mv( + cm, prev_frame_mvs_base, prev_frame_mvs_stride, xd, mi_row, mi_col, + ref_frame, blk_row, blk_col, refmv_count, ref_mv_stack, mode_context); +#endif // CONFIG_TMV } #endif @@ -465,36 +866,75 @@ static void setup_ref_mv_list(const AV1_COMMON *cm, const MACROBLOCKD *xd, } else { mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); } +#endif // Scan the second outer area. scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, -1, ref_mv_stack, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV refmv_count); - for (idx = 2; idx <= 3; ++idx) { - scan_row_mbmi(cm, xd, mi_row, mi_col, block, rf, -idx, ref_mv_stack, - refmv_count); - scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -idx, ref_mv_stack, - refmv_count); + for (idx = 2; idx <= MVREF_ROWS; ++idx) { +#if CONFIG_CB4X4 + row_offset = -(idx << 1) + 1 + row_adj; + col_offset = -(idx << 1) + 1 + col_adj; +#else + row_offset = -idx; + col_offset = -idx; +#endif + + if (abs(row_offset) <= abs(max_row_offset) && + abs(row_offset) > processed_rows) + scan_row_mbmi(cm, xd, mi_col, block, rf, row_offset, ref_mv_stack, + refmv_count, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + max_row_offset, &processed_rows); + + if (abs(col_offset) <= abs(max_col_offset) && + abs(col_offset) > processed_cols) + scan_col_mbmi(cm, xd, mi_row, block, rf, col_offset, ref_mv_stack, + refmv_count, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + max_col_offset, &processed_cols); } - scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -4, ref_mv_stack, - refmv_count); + +#if CONFIG_CB4X4 + col_offset = -(MVREF_COLS << 1) + 1 + col_adj; +#else + col_offset = -MVREF_COLS; +#endif + if (abs(col_offset) <= abs(max_col_offset) && + abs(col_offset) > processed_cols) + scan_col_mbmi(cm, xd, mi_row, block, rf, col_offset, ref_mv_stack, + refmv_count, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + gm_mv_candidates, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + max_col_offset, &processed_cols); switch (nearest_refmv_count) { - case 0: - mode_context[ref_frame] |= 0; + case 0: mode_context[ref_frame] |= 0; +#if !CONFIG_OPT_REF_MV if (*refmv_count >= 1) mode_context[ref_frame] |= 1; - if (*refmv_count == 1) mode_context[ref_frame] |= (1 << REFMV_OFFSET); else if (*refmv_count >= 2) mode_context[ref_frame] |= (2 << REFMV_OFFSET); +#endif break; - case 1: - mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3; - + case 1: mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3; +#if CONFIG_OPT_REF_MV + mode_context[ref_frame] |= (3 << REFMV_OFFSET); +#else if (*refmv_count == 1) mode_context[ref_frame] |= (3 << REFMV_OFFSET); else if (*refmv_count >= 2) mode_context[ref_frame] |= (4 << REFMV_OFFSET); +#endif break; case 2: @@ -564,9 +1004,22 @@ static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd, void *const data, int16_t *mode_context, int_mv zeromv) { const int *ref_sign_bias = cm->ref_frame_sign_bias; + const int sb_mi_size = mi_size_wide[cm->sb_size]; int i, refmv_count = 0; int different_ref_found = 0; int context_counter = 0; + +#if CONFIG_TMV + int tmi_row = mi_row & 0xfffe; + int tmi_col = mi_col & 0xfffe; + POSITION mi_pos = { 0, 0 }; + int inside = is_inside(&xd->tile, tmi_col, tmi_row, cm->mi_rows, cm, &mi_pos); + const MV_REF *const prev_frame_mvs = + cm->use_prev_frame_mvs && inside + ? cm->prev_frame->mvs + (tmi_row >> 1) * ((cm->mi_cols + 1) >> 1) + + (tmi_col >> 1) + : NULL; +#else #if CONFIG_MV_COMPRESS const TileInfo *const tile_ = &xd->tile; int mi_row_end = tile_->mi_row_end; @@ -586,6 +1039,8 @@ static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd, ? cm->prev_frame->mvs + mi_row * cm->mi_cols + mi_col : NULL; #endif +#endif // CONFIG_TMV + #if CONFIG_INTRABC assert(IMPLIES(ref_frame == INTRA_FRAME, cm->use_prev_frame_mvs == 0)); #endif @@ -669,8 +1124,8 @@ static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd, ? NULL : &xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]->mbmi; if (candidate == NULL) continue; - if ((mi_row % MAX_MIB_SIZE) + mv_ref->row >= MAX_MIB_SIZE || - (mi_col % MAX_MIB_SIZE) + mv_ref->col >= MAX_MIB_SIZE) + if ((mi_row & (sb_mi_size - 1)) + mv_ref->row >= sb_mi_size || + (mi_col & (sb_mi_size - 1)) + mv_ref->col >= sb_mi_size) continue; different_ref_found = 1; @@ -721,8 +1176,8 @@ static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd, ? NULL : &xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]->mbmi; if (candidate == NULL) continue; - if ((mi_row % MAX_MIB_SIZE) + mv_ref->row >= MAX_MIB_SIZE || - (mi_col % MAX_MIB_SIZE) + mv_ref->col >= MAX_MIB_SIZE) + if ((mi_row & (sb_mi_size - 1)) + mv_ref->row >= sb_mi_size || + (mi_col & (sb_mi_size - 1)) + mv_ref->col >= sb_mi_size) continue; // If the candidate is INTRA we don't want to consider its mv. @@ -764,7 +1219,6 @@ Done: mv_ref_list[i].as_int = zeromv.as_int; } -#if CONFIG_EXT_INTER // This function keeps a mode count for a given MB/SB void av1_update_mv_context(const AV1_COMMON *cm, const MACROBLOCKD *xd, MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, @@ -814,17 +1268,13 @@ Done: if (mode_context) mode_context[ref_frame] = counter_to_context[context_counter]; } -#endif // CONFIG_EXT_INTER void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, uint8_t *ref_mv_count, CANDIDATE_MV *ref_mv_stack, -#if CONFIG_EXT_INTER - int16_t *compound_mode_context, -#endif // CONFIG_EXT_INTER - int_mv *mv_ref_list, int mi_row, int mi_col, - find_mv_refs_sync sync, void *const data, - int16_t *mode_context) { + int16_t *compound_mode_context, int_mv *mv_ref_list, + int mi_row, int mi_col, find_mv_refs_sync sync, + void *const data, int16_t *mode_context) { int_mv zeromv[2]; #if CONFIG_GLOBAL_MOTION BLOCK_SIZE bsize = mi->mbmi.sb_type; @@ -834,24 +1284,33 @@ void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME rf[2]; #endif // CONFIG_GLOBAL_MOTION -#if CONFIG_EXT_INTER av1_update_mv_context(cm, xd, mi, ref_frame, mv_ref_list, -1, mi_row, mi_col, compound_mode_context); -#endif // CONFIG_EXT_INTER #if CONFIG_GLOBAL_MOTION if (!CONFIG_INTRABC || ref_frame != INTRA_FRAME) { av1_set_ref_frame(rf, ref_frame); zeromv[0].as_int = gm_get_motion_vector(&cm->global_motion[rf[0]], cm->allow_high_precision_mv, bsize, - mi_col, mi_row, 0) + mi_col, mi_row, 0 +#if CONFIG_AMVR + , + cm->cur_frame_mv_precision_level +#endif + ) .as_int; - zeromv[1].as_int = (rf[1] != NONE_FRAME) - ? gm_get_motion_vector(&cm->global_motion[rf[1]], - cm->allow_high_precision_mv, - bsize, mi_col, mi_row, 0) - .as_int - : 0; + zeromv[1].as_int = + (rf[1] != NONE_FRAME) + ? gm_get_motion_vector(&cm->global_motion[rf[1]], + cm->allow_high_precision_mv, bsize, mi_col, + mi_row, 0 +#if CONFIG_AMVR + , + cm->cur_frame_mv_precision_level +#endif + ) + .as_int + : 0; } else { zeromv[0].as_int = zeromv[1].as_int = 0; } @@ -864,6 +1323,9 @@ void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, sync, data, mode_context, zeromv[0]); setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack, mv_ref_list, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + zeromv, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV -1, mi_row, mi_col, mode_context); /* Note: If global motion is enabled, then we want to set the ALL_ZERO flag iff all of the MVs we could generate with NEARMV/NEARESTMV are equivalent @@ -880,26 +1342,38 @@ void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, zero, so sets the ALL_ZERO flag. * This leads to an encode/decode mismatch. */ - if (*ref_mv_count >= 2) { - for (idx = 0; idx < AOMMIN(3, *ref_mv_count); ++idx) { - if (ref_mv_stack[idx].this_mv.as_int != zeromv[0].as_int) all_zero = 0; - if (ref_frame > ALTREF_FRAME) - if (ref_mv_stack[idx].comp_mv.as_int != zeromv[1].as_int) all_zero = 0; - } - } else if (ref_frame <= ALTREF_FRAME) { + for (idx = 0; idx < AOMMIN(3, *ref_mv_count); ++idx) { + if (ref_mv_stack[idx].this_mv.as_int != zeromv[0].as_int) all_zero = 0; + if (ref_frame > ALTREF_FRAME) + if (ref_mv_stack[idx].comp_mv.as_int != zeromv[1].as_int) all_zero = 0; + } + if (*ref_mv_count < 2 && ref_frame <= ALTREF_FRAME) { for (idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx) if (mv_ref_list[idx].as_int != zeromv[0].as_int) all_zero = 0; } +#if !CONFIG_OPT_REF_MV if (all_zero) mode_context[ref_frame] |= (1 << ALL_ZERO_FLAG_OFFSET); +#else + (void)all_zero; +#endif } void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, - int_mv *near_mv) { + int_mv *near_mv +#if CONFIG_AMVR + , + int is_integer +#endif + ) { int i; // Make sure all the candidates are properly clamped etc for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) { +#if CONFIG_AMVR + lower_mv_precision(&mvlist[i].as_mv, allow_hp, is_integer); +#else lower_mv_precision(&mvlist[i].as_mv, allow_hp); +#endif } *nearest_mv = mvlist[0]; *near_mv = mvlist[1]; @@ -908,14 +1382,8 @@ void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd, int block, int ref, int mi_row, int mi_col, CANDIDATE_MV *ref_mv_stack, - uint8_t *ref_mv_count, -#if CONFIG_EXT_INTER - int_mv *mv_list, -#endif // CONFIG_EXT_INTER + uint8_t *ref_mv_count, int_mv *mv_list, int_mv *nearest_mv, int_mv *near_mv) { -#if !CONFIG_EXT_INTER - int_mv mv_list[MAX_MV_REF_CANDIDATES]; -#endif // !CONFIG_EXT_INTER MODE_INFO *const mi = xd->mi[0]; b_mode_info *bmi = mi->bmi; int n; @@ -931,7 +1399,12 @@ void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd, #if CONFIG_GLOBAL_MOTION zeromv.as_int = gm_get_motion_vector(&cm->global_motion[rf[0]], cm->allow_high_precision_mv, - mi->mbmi.sb_type, mi_col, mi_row, block) + mi->mbmi.sb_type, mi_col, mi_row, block +#if CONFIG_AMVR + , + cm->cur_frame_mv_precision_level +#endif + ) .as_int; #else zeromv.as_int = 0; @@ -940,10 +1413,16 @@ void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd, mi_col, NULL, NULL, NULL, zeromv); scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, 0, ref_mv_stack, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + &zeromv, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV ref_mv_count); above_count = *ref_mv_count; scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, 0, -1, ref_mv_stack, +#if CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV + &zeromv, +#endif // CONFIG_GLOBAL_MOTION && USE_CUR_GM_REFMV ref_mv_count); left_count = *ref_mv_count - above_count; @@ -994,6 +1473,526 @@ void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd, } } +#if CONFIG_FRAME_MARKER +void av1_setup_frame_buf_refs(AV1_COMMON *cm) { + cm->cur_frame->cur_frame_offset = cm->frame_offset; + int alt_buf_idx = cm->frame_refs[ALTREF_FRAME - LAST_FRAME].idx; + int lst_buf_idx = cm->frame_refs[LAST_FRAME - LAST_FRAME].idx; + int gld_buf_idx = cm->frame_refs[GOLDEN_FRAME - LAST_FRAME].idx; + +#if CONFIG_EXT_REFS + int lst2_buf_idx = cm->frame_refs[LAST2_FRAME - LAST_FRAME].idx; + int lst3_buf_idx = cm->frame_refs[LAST3_FRAME - LAST_FRAME].idx; + int bwd_buf_idx = cm->frame_refs[BWDREF_FRAME - LAST_FRAME].idx; + int alt2_buf_idx = cm->frame_refs[ALTREF2_FRAME - LAST_FRAME].idx; +#endif + + if (alt_buf_idx >= 0) + cm->cur_frame->alt_frame_offset = + cm->buffer_pool->frame_bufs[alt_buf_idx].cur_frame_offset; + + if (lst_buf_idx >= 0) + cm->cur_frame->lst_frame_offset = + cm->buffer_pool->frame_bufs[lst_buf_idx].cur_frame_offset; + + if (gld_buf_idx >= 0) + cm->cur_frame->gld_frame_offset = + cm->buffer_pool->frame_bufs[gld_buf_idx].cur_frame_offset; + +#if CONFIG_EXT_REFS + if (lst2_buf_idx >= 0) + cm->cur_frame->lst2_frame_offset = + cm->buffer_pool->frame_bufs[lst2_buf_idx].cur_frame_offset; + + if (lst3_buf_idx >= 0) + cm->cur_frame->lst3_frame_offset = + cm->buffer_pool->frame_bufs[lst3_buf_idx].cur_frame_offset; + + if (bwd_buf_idx >= 0) + cm->cur_frame->bwd_frame_offset = + cm->buffer_pool->frame_bufs[bwd_buf_idx].cur_frame_offset; + + if (alt2_buf_idx >= 0) + cm->cur_frame->alt2_frame_offset = + cm->buffer_pool->frame_bufs[alt2_buf_idx].cur_frame_offset; +#endif +} + +#if CONFIG_FRAME_SIGN_BIAS +void av1_setup_frame_sign_bias(AV1_COMMON *cm) { + MV_REFERENCE_FRAME ref_frame; + for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { + const int buf_idx = cm->frame_refs[ref_frame - LAST_FRAME].idx; + if (buf_idx != INVALID_IDX) { + const int ref_frame_offset = + cm->buffer_pool->frame_bufs[buf_idx].cur_frame_offset; + cm->ref_frame_sign_bias[ref_frame] = + (ref_frame_offset <= (int)cm->frame_offset) ? 0 : 1; + } else { + cm->ref_frame_sign_bias[ref_frame] = 0; + } + } +} +#endif // CONFIG_FRAME_SIGN_BIAS +#endif // CONFIG_FRAME_MARKER + +#if CONFIG_MFMV +// Although we assign 32 bit integers, all the values are strictly under 14 +// bits. +static int div_mult[32] = { + 0, 16384, 8192, 5461, 4096, 3276, 2730, 2340, 2048, 1820, 1638, + 1489, 1365, 1260, 1170, 1092, 1024, 963, 910, 862, 819, 780, + 744, 712, 682, 655, 630, 606, 585, 564, 546, 528, +}; + +// TODO(jingning): Consider the use of lookup table for (num / den) +// altogether. +static void get_mv_projection(MV *output, MV ref, int num, int den) { + output->row = + (int16_t)(ROUND_POWER_OF_TWO(ref.row * num * div_mult[den], 14)); + output->col = + (int16_t)(ROUND_POWER_OF_TWO(ref.col * num * div_mult[den], 14)); +} + +#define MAX_OFFSET_WIDTH 64 +#define MAX_OFFSET_HEIGHT 32 + +static int get_block_position(AV1_COMMON *cm, int *mi_r, int *mi_c, int blk_row, + int blk_col, MV mv, int sign_bias) { + if ((abs(mv.row) >> 3) > MAX_OFFSET_HEIGHT || + (abs(mv.col) >> 3) > MAX_OFFSET_WIDTH) + return 0; + + int row = (sign_bias == 1) ? blk_row - (mv.row >> (3 + MI_SIZE_LOG2)) + : blk_row + (mv.row >> (3 + MI_SIZE_LOG2)); + int col = (sign_bias == 1) ? blk_col - (mv.col >> (3 + MI_SIZE_LOG2)) + : blk_col + (mv.col >> (3 + MI_SIZE_LOG2)); + + if (row < 0 || row >= cm->mi_rows || col < 0 || col >= cm->mi_cols) return 0; + + *mi_r = row; + *mi_c = col; + + return 1; +} + +static uint32_t mv_sign_reverse(int_mv ref) { + int_mv this_mv; + this_mv.as_mv.row = -ref.as_mv.row; + this_mv.as_mv.col = -ref.as_mv.col; + + return this_mv.as_int; +} + +void av1_setup_motion_field(AV1_COMMON *cm) { + int cur_frame_index = cm->cur_frame->cur_frame_offset; + int lst_frame_index = 0, alt_frame_index = 0, gld_frame_index = 0; +#if CONFIG_EXT_REFS + int lst2_frame_index = 0, lst3_frame_index = 0; + int bwd_frame_index = 0, alt2_frame_index = 0; +#endif + TPL_MV_REF *tpl_mvs_base = cm->cur_frame->tpl_mvs; + + for (int ref_frame = 0; ref_frame < INTER_REFS_PER_FRAME; ++ref_frame) { + int size = (cm->mi_rows + 16) * cm->mi_stride; + for (int idx = 0; idx < size; ++idx) { + for (int i = 0; i < MFMV_STACK_SIZE; ++i) + tpl_mvs_base[idx].mfmv[ref_frame][i].as_int = INVALID_MV; + } + } + + int alt_buf_idx = cm->frame_refs[ALTREF_FRAME - LAST_FRAME].idx; + int lst_buf_idx = cm->frame_refs[LAST_FRAME - LAST_FRAME].idx; + int gld_buf_idx = cm->frame_refs[GOLDEN_FRAME - LAST_FRAME].idx; +#if CONFIG_EXT_REFS + int lst2_buf_idx = cm->frame_refs[LAST2_FRAME - LAST_FRAME].idx; + int lst3_buf_idx = cm->frame_refs[LAST3_FRAME - LAST_FRAME].idx; + int bwd_buf_idx = cm->frame_refs[BWDREF_FRAME - LAST_FRAME].idx; + int alt2_buf_idx = cm->frame_refs[ALTREF2_FRAME - LAST_FRAME].idx; +#endif + + if (alt_buf_idx >= 0) + alt_frame_index = cm->buffer_pool->frame_bufs[alt_buf_idx].cur_frame_offset; + + if (lst_buf_idx >= 0) + lst_frame_index = cm->buffer_pool->frame_bufs[lst_buf_idx].cur_frame_offset; + + if (gld_buf_idx >= 0) + gld_frame_index = cm->buffer_pool->frame_bufs[gld_buf_idx].cur_frame_offset; + +#if CONFIG_EXT_REFS + if (lst2_buf_idx >= 0) + lst2_frame_index = + cm->buffer_pool->frame_bufs[lst2_buf_idx].cur_frame_offset; + + if (lst3_buf_idx >= 0) + lst3_frame_index = + cm->buffer_pool->frame_bufs[lst3_buf_idx].cur_frame_offset; + + if (bwd_buf_idx >= 0) + bwd_frame_index = cm->buffer_pool->frame_bufs[bwd_buf_idx].cur_frame_offset; + + if (alt2_buf_idx >= 0) + alt2_frame_index = + cm->buffer_pool->frame_bufs[alt2_buf_idx].cur_frame_offset; +#endif + + if (alt_frame_index < cur_frame_index) return; + + // ====================== + // Process last frame + // ====================== + if (lst_buf_idx >= 0) { + MV_REF *mv_ref_base = cm->buffer_pool->frame_bufs[lst_buf_idx].mvs; + const int lst_frame_idx = + cm->buffer_pool->frame_bufs[lst_buf_idx].lst_frame_offset; + const int alt_frame_idx = + cm->buffer_pool->frame_bufs[lst_buf_idx].alt_frame_offset; + const int gld_frame_idx = + cm->buffer_pool->frame_bufs[lst_buf_idx].gld_frame_offset; +#if CONFIG_EXT_REFS + const int lst2_frame_idx = + cm->buffer_pool->frame_bufs[lst_buf_idx].lst2_frame_offset; + const int lst3_frame_idx = + cm->buffer_pool->frame_bufs[lst_buf_idx].lst3_frame_offset; + const int bwd_frame_idx = + cm->buffer_pool->frame_bufs[lst_buf_idx].bwd_frame_offset; + const int alt2_frame_idx = + cm->buffer_pool->frame_bufs[lst_buf_idx].alt2_frame_offset; +#endif + + int alt_offset = AOMMAX(1, alt_frame_idx - lst_frame_index); + int lst_offset = AOMMAX(1, lst_frame_index - lst_frame_idx); + int gld_offset = AOMMAX(1, lst_frame_index - gld_frame_idx); + int cur_to_lst = cur_frame_index - lst_frame_index; + int cur_to_alt = alt_frame_index - cur_frame_index; + int cur_to_gld = cur_frame_index - gld_frame_index; + +#if CONFIG_EXT_REFS + int bwd_offset = AOMMAX(1, bwd_frame_idx - lst_frame_index); + int alt2_offset = AOMMAX(1, alt2_frame_idx - lst_frame_index); + int lst2_offset = AOMMAX(1, lst_frame_index - lst2_frame_idx); + int lst3_offset = AOMMAX(1, lst_frame_index - lst3_frame_idx); + int cur_to_lst2 = cur_frame_index - lst2_frame_index; + int cur_to_lst3 = cur_frame_index - lst3_frame_index; + int cur_to_bwd = bwd_frame_index - cur_frame_index; + int cur_to_alt2 = alt2_frame_index - cur_frame_index; +#endif + + const int is_lst_overlay = (alt_frame_idx == gld_frame_index); + // clang-format off + const int ref_frame_offset_buffer[TOTAL_REFS_PER_FRAME] = { +#if CONFIG_EXT_REFS + 0, lst_offset, lst2_offset, lst3_offset, gld_offset, + bwd_offset, alt2_offset, alt_offset +#else + 0, lst_offset, gld_offset, alt_offset +#endif + }; + // clang-format on + + for (int blk_row = 0; blk_row < cm->mi_rows && !is_lst_overlay; ++blk_row) { + for (int blk_col = 0; blk_col < cm->mi_cols; ++blk_col) { + MV_REF *mv_ref = &mv_ref_base[blk_row * cm->mi_cols + blk_col]; + MV fwd_mv = mv_ref->mv[0].as_mv; + MV_REFERENCE_FRAME ref_frame[2] = { mv_ref->ref_frame[0], + mv_ref->ref_frame[1] }; + + // Derive motion vectors toward last reference frame. + if (ref_frame[0] <= GOLDEN_FRAME && ref_frame[0] > INTRA_FRAME) { + int_mv this_mv; + int mi_r, mi_c; + + const int ref_frame_offset = ref_frame_offset_buffer[ref_frame[0]]; + + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst, + ref_frame_offset); + int pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, + this_mv.as_mv, 1); + + if (pos_valid) { + int mi_offset = mi_r * cm->mi_stride + mi_c; + tpl_mvs_base[mi_offset].mfmv[FWD_RF_OFFSET(LAST_FRAME)][0].as_int = + this_mv.as_int; + +#if CONFIG_EXT_REFS + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst2, + ref_frame_offset); + tpl_mvs_base[mi_offset].mfmv[FWD_RF_OFFSET(LAST2_FRAME)][0].as_int = + this_mv.as_int; + + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst3, + ref_frame_offset); + tpl_mvs_base[mi_offset].mfmv[FWD_RF_OFFSET(LAST3_FRAME)][0].as_int = + this_mv.as_int; +#endif + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_gld, + ref_frame_offset); + tpl_mvs_base[mi_offset].mfmv[FWD_RF_OFFSET(GOLDEN_FRAME)] + [0].as_int = this_mv.as_int; + } + } + + for (int idx = 0; idx < 2; ++idx) { + if (ref_frame[idx] <= GOLDEN_FRAME) continue; + + int_mv this_mv; + int mi_r, mi_c; + fwd_mv = mv_ref->mv[idx].as_mv; + + const int ref_frame_offset = ref_frame_offset_buffer[ref_frame[idx]]; + + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst, + ref_frame_offset); + int pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, + this_mv.as_mv, 0); + + if (pos_valid) { + int mi_offset = mi_r * cm->mi_stride + mi_c; + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_alt, + ref_frame_offset); + tpl_mvs_base[mi_offset].mfmv[FWD_RF_OFFSET(ALTREF_FRAME)] + [0].as_int = this_mv.as_int; + +#if CONFIG_EXT_REFS + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_bwd, + ref_frame_offset); + tpl_mvs_base[mi_offset].mfmv[FWD_RF_OFFSET(BWDREF_FRAME)] + [0].as_int = this_mv.as_int; + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_alt2, + ref_frame_offset); + tpl_mvs_base[mi_offset].mfmv[FWD_RF_OFFSET(ALTREF2_FRAME)] + [0].as_int = this_mv.as_int; +#endif + } + } + } + } + } + + // ======================= + // Process ARF frame + // ======================= + if (alt_buf_idx >= 0) { + MV_REF *mv_ref_base = cm->buffer_pool->frame_bufs[alt_buf_idx].mvs; + const int lst_frame_idx = + cm->buffer_pool->frame_bufs[alt_buf_idx].lst_frame_offset; + const int gld_frame_idx = + cm->buffer_pool->frame_bufs[alt_buf_idx].gld_frame_offset; +#if CONFIG_EXT_REFS + const int lst2_frame_idx = + cm->buffer_pool->frame_bufs[alt_buf_idx].lst2_frame_offset; + const int lst3_frame_idx = + cm->buffer_pool->frame_bufs[alt_buf_idx].lst3_frame_offset; + const int bwd_frame_idx = + cm->buffer_pool->frame_bufs[alt_buf_idx].bwd_frame_offset; + const int alt2_frame_idx = + cm->buffer_pool->frame_bufs[alt_buf_idx].alt2_frame_offset; +#endif + + int lst_offset = AOMMAX(1, alt_frame_index - lst_frame_idx); + int gld_offset = AOMMAX(1, alt_frame_index - gld_frame_idx); + int cur_to_alt = alt_frame_index - cur_frame_index; + int cur_to_lst = cur_frame_index - lst_frame_index; + int cur_to_gld = cur_frame_index - gld_frame_index; +#if CONFIG_EXT_REFS + int bwd_offset = AOMMAX(1, alt_frame_index - bwd_frame_idx); + int alt2_offset = AOMMAX(1, alt_frame_index - alt2_frame_idx); + int lst2_offset = AOMMAX(1, alt_frame_index - lst2_frame_idx); + int lst3_offset = AOMMAX(1, alt_frame_index - lst3_frame_idx); + int cur_to_lst2 = cur_frame_index - lst2_frame_index; + int cur_to_lst3 = cur_frame_index - lst3_frame_index; + int cur_to_bwd = bwd_frame_index - cur_frame_index; + int cur_to_alt2 = alt2_frame_index - cur_frame_index; +#endif + const int ref_stamp = FWD_RF_OFFSET(ALTREF_FRAME); + // clang-format off + const int ref_frame_offset_buffer[TOTAL_REFS_PER_FRAME] = { +#if CONFIG_EXT_REFS + 0, lst_offset, lst2_offset, lst3_offset, gld_offset, + bwd_offset, alt2_offset, 0, +#else + 0, lst_offset, gld_offset, 0, +#endif + }; + // clang-format on + + for (int blk_row = 0; blk_row < cm->mi_rows; ++blk_row) { + for (int blk_col = 0; blk_col < cm->mi_cols; ++blk_col) { + MV_REF *mv_ref = &mv_ref_base[blk_row * cm->mi_cols + blk_col]; + MV fwd_mv = mv_ref->mv[0].as_mv; + MV_REFERENCE_FRAME ref_frame[2] = { mv_ref->ref_frame[0], + mv_ref->ref_frame[1] }; + + const int ref_frame_offset = ref_frame_offset_buffer[ref_frame[0]]; + + if (ref_frame[0] <= GOLDEN_FRAME && ref_frame[0] > INTRA_FRAME) { + int_mv this_mv; + int mi_r, mi_c; + + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_alt, + ref_frame_offset); + int pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, + this_mv.as_mv, 0); + + if (pos_valid) { + int mi_offset = mi_r * cm->mi_stride + mi_c; + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(ALTREF_FRAME)][ref_stamp] + .as_int = mv_sign_reverse(this_mv); + + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(LAST_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + +#if CONFIG_EXT_REFS + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_bwd, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(BWDREF_FRAME)][ref_stamp] + .as_int = mv_sign_reverse(this_mv); + + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_alt2, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(ALTREF2_FRAME)][ref_stamp] + .as_int = mv_sign_reverse(this_mv); + + if (ref_frame[0] >= LAST2_FRAME) { + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst2, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(LAST2_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + } + + if (ref_frame[0] >= LAST3_FRAME) { + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst3, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(LAST3_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + } +#endif + if (ref_frame[0] >= GOLDEN_FRAME) { + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_gld, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(GOLDEN_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + } + } + } + } + } + } + +// ========================================== +// Process BWD reference frame +// ========================================== +#if CONFIG_EXT_REFS + if (bwd_buf_idx >= 0) { + MV_REF *mv_ref_base = cm->buffer_pool->frame_bufs[bwd_buf_idx].mvs; + const int lst_frame_idx = + cm->buffer_pool->frame_bufs[bwd_buf_idx].lst_frame_offset; + const int gld_frame_idx = + cm->buffer_pool->frame_bufs[bwd_buf_idx].gld_frame_offset; + const int lst2_frame_idx = + cm->buffer_pool->frame_bufs[bwd_buf_idx].lst2_frame_offset; + const int lst3_frame_idx = + cm->buffer_pool->frame_bufs[bwd_buf_idx].lst3_frame_offset; + const int bwd_frame_idx = + cm->buffer_pool->frame_bufs[bwd_buf_idx].bwd_frame_offset; + const int alt2_frame_idx = + cm->buffer_pool->frame_bufs[bwd_buf_idx].alt2_frame_offset; + const int alt_frame_idx = + cm->buffer_pool->frame_bufs[bwd_buf_idx].alt_frame_offset; + + int lst_offset = AOMMAX(1, bwd_frame_index - lst_frame_idx); + int gld_offset = AOMMAX(1, bwd_frame_index - gld_frame_idx); + int cur_to_lst = cur_frame_index - lst_frame_index; + + int lst2_offset = AOMMAX(1, bwd_frame_index - lst2_frame_idx); + int lst3_offset = AOMMAX(1, bwd_frame_index - lst3_frame_idx); + int bwd_offset = AOMMAX(1, bwd_frame_idx - bwd_frame_index); + int alt2_offset = AOMMAX(1, alt2_frame_idx - bwd_frame_index); + int alt_offset = AOMMAX(1, alt_frame_idx - bwd_frame_index); + int cur_to_lst2 = cur_frame_index - lst2_frame_index; + int cur_to_lst3 = cur_frame_index - lst3_frame_index; + int cur_to_gld = cur_frame_index - gld_frame_index; + int cur_to_bwd = bwd_frame_index - cur_frame_index; + + const int ref_stamp = FWD_RF_OFFSET(BWDREF_FRAME); + const int ref_frame_offset_buffer[TOTAL_REFS_PER_FRAME] = { + 0, lst_offset, lst2_offset, lst3_offset, + gld_offset, bwd_offset, alt2_offset, alt_offset, + }; + + for (int blk_row = 0; blk_row < cm->mi_rows; ++blk_row) { + for (int blk_col = 0; blk_col < cm->mi_cols; ++blk_col) { + MV_REF *mv_ref = &mv_ref_base[blk_row * cm->mi_cols + blk_col]; + MV fwd_mv = mv_ref->mv[0].as_mv; + MV_REFERENCE_FRAME ref_frame[2] = { mv_ref->ref_frame[0], + mv_ref->ref_frame[1] }; + + if (ref_frame[0] <= GOLDEN_FRAME && ref_frame[0] > INTRA_FRAME) { + const int ref_frame_offset = ref_frame_offset_buffer[ref_frame[0]]; + int_mv this_mv; + int mi_r, mi_c; + + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_bwd, + ref_frame_offset); + int pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, + this_mv.as_mv, 0); + + if (pos_valid) { + int mi_offset = mi_r * cm->mi_stride + mi_c; + + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(BWDREF_FRAME)][ref_stamp] + .as_int = mv_sign_reverse(this_mv); + + // Project the motion vector onto last reference frame + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(LAST_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + + if (ref_frame[0] >= LAST2_FRAME) { + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst2, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(LAST2_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + } + + if (ref_frame[0] >= LAST3_FRAME) { + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_lst3, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(LAST3_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + } + + if (ref_frame[0] >= GOLDEN_FRAME) { + get_mv_projection(&this_mv.as_mv, fwd_mv, cur_to_gld, + ref_frame_offset); + tpl_mvs_base[mi_offset] + .mfmv[FWD_RF_OFFSET(GOLDEN_FRAME)][ref_stamp] + .as_int = this_mv.as_int; + } + } + } + } + } + } +#endif +} +#endif // CONFIG_MFMV + #if CONFIG_WARPED_MOTION #if WARPED_MOTION_SORT_SAMPLES static INLINE void record_samples(MB_MODE_INFO *mbmi, int *pts, int *pts_inref, @@ -1072,71 +2071,49 @@ int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, int ref_frame = mbmi0->ref_frame[0]; int up_available = xd->up_available; int left_available = xd->left_available; - int i, mi_step = 1, np = 0, n, j, k; + int i, mi_step = 1, np = 0; int global_offset_c = mi_col * MI_SIZE; int global_offset_r = mi_row * MI_SIZE; const TileInfo *const tile = &xd->tile; - // Search nb range in the unit of mi - int bs = - (AOMMAX(xd->n8_w, xd->n8_h) > 1) ? (AOMMAX(xd->n8_w, xd->n8_h) >> 1) : 1; - int marked[16 * 32]; // max array size for 128x128 int do_tl = 1; int do_tr = 1; - // scan the above rows + // scan the nearest above rows if (up_available) { - for (n = 0; n < bs; n++) { - int mi_row_offset = -1 * (n + 1); - - if (!n) { - MODE_INFO *mi = xd->mi[mi_row_offset * xd->mi_stride]; - MB_MODE_INFO *mbmi = &mi->mbmi; - uint8_t n8_w = mi_size_wide[mbmi->sb_type]; - - // Handle "current block width <= above block width" case. - if (xd->n8_w <= n8_w) { - int col_offset = -mi_col % n8_w; - - if (col_offset < 0) do_tl = 0; - if (col_offset + n8_w > xd->n8_w) do_tr = 0; - - if (mbmi->ref_frame[0] == ref_frame && - mbmi->ref_frame[1] == NONE_FRAME) { - record_samples(mbmi, pts, pts_inref, pts_mv, global_offset_r, - global_offset_c, 0, -1, col_offset, 1); - pts += 2; - pts_inref += 2; - pts_mv += 2; - np++; - } - break; - } - } + int mi_row_offset = -1; + MODE_INFO *mi = xd->mi[mi_row_offset * xd->mi_stride]; + MB_MODE_INFO *mbmi = &mi->mbmi; + uint8_t n8_w = mi_size_wide[mbmi->sb_type]; - // Handle "current block width > above block width" case. - if (!n) memset(marked, 0, bs * xd->n8_w * sizeof(*marked)); + if (xd->n8_w <= n8_w) { + // Handle "current block width <= above block width" case. + int col_offset = -mi_col % n8_w; + if (col_offset < 0) do_tl = 0; + if (col_offset + n8_w > xd->n8_w) do_tr = 0; + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, pts_mv, global_offset_r, + global_offset_c, 0, -1, col_offset, 1); + pts += 2; + pts_inref += 2; + pts_mv += 2; + np++; + } + } else { + // Handle "current block width > above block width" case. for (i = 0; i < AOMMIN(xd->n8_w, cm->mi_cols - mi_col); i += mi_step) { int mi_col_offset = i; - MODE_INFO *mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; - MB_MODE_INFO *mbmi = &mi->mbmi; - uint8_t n8_w = mi_size_wide[mbmi->sb_type]; - uint8_t n8_h = mi_size_high[mbmi->sb_type]; - + mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + mbmi = &mi->mbmi; + n8_w = mi_size_wide[mbmi->sb_type]; mi_step = AOMMIN(xd->n8_w, n8_w); - // Processed already - if (marked[n * xd->n8_w + i]) continue; - - for (j = 0; j < AOMMIN(bs, n8_h); j++) - for (k = 0; k < AOMMIN(xd->n8_w, n8_w); k++) - marked[(n + j) * xd->n8_w + i + k] = 1; - if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { record_samples(mbmi, pts, pts_inref, pts_mv, global_offset_r, - global_offset_c, -n, -1, i, 1); + global_offset_c, 0, -1, i, 1); pts += 2; pts_inref += 2; pts_mv += 2; @@ -1147,58 +2124,41 @@ int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, } assert(2 * np <= SAMPLES_ARRAY_SIZE); - // scan the left columns + // scan the nearest left columns if (left_available) { - for (n = 0; n < bs; n++) { - int mi_col_offset = -1 * (n + 1); - - if (!n) { - MODE_INFO *mi = xd->mi[mi_col_offset]; - MB_MODE_INFO *mbmi = &mi->mbmi; - uint8_t n8_h = mi_size_high[mbmi->sb_type]; - - // Handle "current block height <= above block height" case. - if (xd->n8_h <= n8_h) { - int row_offset = -mi_row % n8_h; - - if (row_offset < 0) do_tl = 0; - - if (mbmi->ref_frame[0] == ref_frame && - mbmi->ref_frame[1] == NONE_FRAME) { - record_samples(mbmi, pts, pts_inref, pts_mv, global_offset_r, - global_offset_c, row_offset, 1, 0, -1); - pts += 2; - pts_inref += 2; - pts_mv += 2; - np++; - } - break; - } - } + int mi_col_offset = -1; - // Handle "current block height > above block height" case. - if (!n) memset(marked, 0, bs * xd->n8_h * sizeof(*marked)); + MODE_INFO *mi = xd->mi[mi_col_offset]; + MB_MODE_INFO *mbmi = &mi->mbmi; + uint8_t n8_h = mi_size_high[mbmi->sb_type]; + if (xd->n8_h <= n8_h) { + // Handle "current block height <= above block height" case. + int row_offset = -mi_row % n8_h; + + if (row_offset < 0) do_tl = 0; + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, pts_mv, global_offset_r, + global_offset_c, row_offset, 1, 0, -1); + pts += 2; + pts_inref += 2; + pts_mv += 2; + np++; + } + } else { + // Handle "current block height > above block height" case. for (i = 0; i < AOMMIN(xd->n8_h, cm->mi_rows - mi_row); i += mi_step) { int mi_row_offset = i; - MODE_INFO *mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; - MB_MODE_INFO *mbmi = &mi->mbmi; - uint8_t n8_w = mi_size_wide[mbmi->sb_type]; - uint8_t n8_h = mi_size_high[mbmi->sb_type]; - + mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + mbmi = &mi->mbmi; + n8_h = mi_size_high[mbmi->sb_type]; mi_step = AOMMIN(xd->n8_h, n8_h); - // Processed already - if (marked[n * xd->n8_h + i]) continue; - - for (j = 0; j < AOMMIN(bs, n8_w); j++) - for (k = 0; k < AOMMIN(xd->n8_h, n8_h); k++) - marked[(n + j) * xd->n8_h + i + k] = 1; - if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { record_samples(mbmi, pts, pts_inref, pts_mv, global_offset_r, - global_offset_c, i, 1, -n, -1); + global_offset_c, i, 1, 0, -1); pts += 2; pts_inref += 2; pts_mv += 2; @@ -1229,7 +2189,8 @@ int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, assert(2 * np <= SAMPLES_ARRAY_SIZE); // Top-right block - if (do_tr && has_top_right(xd, mi_row, mi_col, AOMMAX(xd->n8_w, xd->n8_h))) { + if (do_tr && + has_top_right(cm, xd, mi_row, mi_col, AOMMAX(xd->n8_w, xd->n8_h))) { POSITION trb_pos = { -1, xd->n8_w }; if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, &trb_pos)) { |