diff options
Diffstat (limited to 'third_party/aom/av1/common/mvref_common.c')
| -rw-r--r-- | third_party/aom/av1/common/mvref_common.c | 1164 |
1 files changed, 1164 insertions, 0 deletions
diff --git a/third_party/aom/av1/common/mvref_common.c b/third_party/aom/av1/common/mvref_common.c new file mode 100644 index 000000000..5222948c8 --- /dev/null +++ b/third_party/aom/av1/common/mvref_common.c @@ -0,0 +1,1164 @@ +/* + * Copyright (c) 2016, Alliance for Open Media. All rights reserved + * + * This source code is subject to the terms of the BSD 2 Clause License and + * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License + * was not distributed with this source code in the LICENSE file, you can + * obtain it at www.aomedia.org/license/software. If the Alliance for Open + * Media Patent License 1.0 was not distributed with this source code in the + * PATENTS file, you can obtain it at www.aomedia.org/license/patent. + */ + +#include "av1/common/mvref_common.h" +#if CONFIG_WARPED_MOTION +#include "av1/common/warped_motion.h" +#endif // CONFIG_WARPED_MOTION + +#if CONFIG_REF_MV + +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) { + int index = 0, ref; + int newmv_count = 0; +#if CONFIG_CB4X4 + const int unify_bsize = 1; +#else + const int unify_bsize = 0; +#endif + + 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); + lower_mv_precision(&this_refmv.as_mv, use_hp); + + 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; + + // 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; + ++(*refmv_count); + + if (candidate->mode == NEWMV) ++newmv_count; + } + + if (candidate_mi->mbmi.sb_type < BLOCK_8X8 && block >= 0 && + !unify_bsize) { + int alt_block = 3 - block; + this_refmv = get_sub_block_mv(candidate_mi, ref, col, alt_block); + lower_mv_precision(&this_refmv.as_mv, use_hp); + + 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 += 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, alt_block), + this_refmv); + ref_mv_stack[index].weight = len; + ++(*refmv_count); + + if (candidate->mode == NEWMV) ++newmv_count; + } + } + } + } + } else { + // compound reference frame + if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) { + int_mv this_refmv[2]; + + for (ref = 0; ref < 2; ++ref) { + this_refmv[ref] = get_sub_block_mv(candidate_mi, ref, col, block); + lower_mv_precision(&this_refmv[ref].as_mv, use_hp); + } + + 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)) + break; + + if (index < *refmv_count) ref_mv_stack[index].weight += 2 * len; + + // Add a new item to the list. + if (index == *refmv_count) { + ref_mv_stack[index].this_mv = this_refmv[0]; + ref_mv_stack[index].comp_mv = this_refmv[1]; + ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx( + 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; + ++(*refmv_count); + +#if CONFIG_EXT_INTER + if (candidate->mode == NEW_NEWMV) +#else + if (candidate->mode == NEWMV) +#endif // CONFIG_EXT_INTER + ++newmv_count; + } + + if (candidate_mi->mbmi.sb_type < BLOCK_8X8 && block >= 0 && + !unify_bsize) { + int alt_block = 3 - block; + 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) + lower_mv_precision(&this_refmv[ref].as_mv, use_hp); + + 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) + break; + + if (index < *refmv_count) ref_mv_stack[index].weight += len; + + // Add a new item to the list. + if (index == *refmv_count) { + ref_mv_stack[index].this_mv = this_refmv[0]; + ref_mv_stack[index].comp_mv = this_refmv[1]; + ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx( + get_sub_block_pred_mv(candidate_mi, 0, col, block), + this_refmv[0]); + ref_mv_stack[index].pred_diff[0] = av1_get_pred_diff_ctx( + get_sub_block_pred_mv(candidate_mi, 1, col, block), + this_refmv[1]); + 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; + } + } + } + } + return newmv_count; +} + +static uint8_t scan_row_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, + CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count) { + const TileInfo *const tile = &xd->tile; + int i; + uint8_t newmv_count = 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]; + // TODO(jingning): Revisit this part after cb4x4 is stable. + if (bsize >= BLOCK_8X8) row_offset *= 2; +#else + const int mi_offset = mi_size_wide[BLOCK_8X8]; +#endif + + 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); +#else + const int use_step_16 = (xd->n8_w >= 8); +#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; + } + } + + 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 MV_REFERENCE_FRAME rf[2], int col_offset, + CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count) { + const TileInfo *const tile = &xd->tile; + int i; + uint8_t newmv_count = 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; +#else + const int mi_offset = mi_size_wide[BLOCK_8X8]; +#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); +#else + const int use_step_16 = (xd->n8_h >= 8); +#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; + } + } + + return newmv_count; +} + +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, + uint8_t *refmv_count) { + const TileInfo *const tile = &xd->tile; + POSITION mi_pos; + uint8_t newmv_count = 0; + + mi_pos.row = row_offset; + mi_pos.col = col_offset; + + if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, &mi_pos) && + *refmv_count < MAX_REF_MV_STACK_SIZE) { + 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; + const int len = mi_size_wide[BLOCK_8X8]; + + 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); + } // 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; + + // In a split partition all apart from the bottom right has a top right + int has_tr = !((mask_row & bs) && (mask_col & bs)); + + // bs > 0 and bs is a power of 2 + assert(bs > 0 && !(bs & (bs - 1))); + + // 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) { + if (mask_col & bs) { + if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) { + has_tr = 0; + break; + } + } else { + break; + } + bs <<= 1; + } + + // The left hand of two vertical rectangles always has a top right (as the + // block above will have been decoded) + if (xd->n8_w < xd->n8_h) + if (!xd->is_sec_rect) has_tr = 1; + + // The bottom of two horizontal rectangles never has a top right (as the block + // to the right won't have been decoded) + 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 (xd->mi[0]->mbmi.partition == PARTITION_VERT_A) + if ((mask_row & bs) && !(mask_col & bs)) has_tr = 0; +#endif // CONFIG_EXT_PARTITION_TYPES + + return has_tr; +} + +static int add_col_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) { + const MV_REF *prev_frame_mvs = + prev_frame_mvs_base + blk_row * cm->mi_cols + blk_col; + POSITION mi_pos; + int ref, idx; + int coll_blk_count = 0; + const int weight_unit = 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; + for (ref = 0; ref < 2; ++ref) { + if (prev_frame_mvs->ref_frame[ref] == ref_frame) { + int_mv this_refmv = prev_frame_mvs->mv[ref]; + lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv); + + 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; + + 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].pred_diff[0] = + av1_get_pred_diff_ctx(prev_frame_mvs->pred_mv[ref], this_refmv); + ref_mv_stack[idx].weight = 2 * weight_unit; + ++(*refmv_count); + } + + ++coll_blk_count; + } + } + + return coll_blk_count; +} + +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 idx, nearest_refmv_count = 0; + uint8_t newmv_count = 0; + CANDIDATE_MV tmp_mv; + int len, nr_len; + +#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 + + ((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 + : NULL; +#endif + + const int bs = AOMMAX(xd->n8_w, xd->n8_h); + const int has_tr = has_top_right(xd, mi_row, mi_col, bs); + MV_REFERENCE_FRAME rf[2]; + + 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); + + // 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); + + nearest_refmv_count = *refmv_count; + + for (idx = 0; idx < nearest_refmv_count; ++idx) + ref_mv_stack[idx].weight += REF_CAT_LEVEL; +#if CONFIG_TEMPMV_SIGNALING + 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) { +#endif + int blk_row, blk_col; + int coll_blk_count = 0; +#if CONFIG_CB4X4 + const int mi_step = (xd->n8_w == 1 || xd->n8_h == 1) + ? mi_size_wide[BLOCK_8X8] + : mi_size_wide[BLOCK_16X16]; +#else + const int mi_step = mi_size_wide[BLOCK_16X16]; +#endif + +#if CONFIG_TPL_MV + int tpl_sample_pos[5][2] = { { -1, xd->n8_w }, + { 0, xd->n8_w }, + { xd->n8_h, xd->n8_w }, + { xd->n8_h, 0 }, + { xd->n8_h, -1 } }; + int i; +#endif + + 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_TPL_MV + 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); + } +#endif + + if (coll_blk_count == 0) mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); + } else { + mode_context[ref_frame] |= (1 << ZEROMV_OFFSET); + } + + // Scan the second outer area. + scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, -1, ref_mv_stack, + 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); + } + scan_col_mbmi(cm, xd, mi_row, mi_col, block, rf, -4, ref_mv_stack, + refmv_count); + + switch (nearest_refmv_count) { + case 0: + mode_context[ref_frame] |= 0; + 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); + break; + case 1: + mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3; + + if (*refmv_count == 1) + mode_context[ref_frame] |= (3 << REFMV_OFFSET); + else if (*refmv_count >= 2) + mode_context[ref_frame] |= (4 << REFMV_OFFSET); + break; + + case 2: + default: + if (newmv_count >= 2) + mode_context[ref_frame] |= 4; + else if (newmv_count == 1) + mode_context[ref_frame] |= 5; + else + mode_context[ref_frame] |= 6; + + mode_context[ref_frame] |= (5 << REFMV_OFFSET); + break; + } + + // Rank the likelihood and assign nearest and near mvs. + len = nearest_refmv_count; + while (len > 0) { + nr_len = 0; + for (idx = 1; idx < len; ++idx) { + if (ref_mv_stack[idx - 1].weight < ref_mv_stack[idx].weight) { + tmp_mv = ref_mv_stack[idx - 1]; + ref_mv_stack[idx - 1] = ref_mv_stack[idx]; + ref_mv_stack[idx] = tmp_mv; + nr_len = idx; + } + } + len = nr_len; + } + + len = *refmv_count; + while (len > nearest_refmv_count) { + nr_len = nearest_refmv_count; + for (idx = nearest_refmv_count + 1; idx < len; ++idx) { + if (ref_mv_stack[idx - 1].weight < ref_mv_stack[idx].weight) { + tmp_mv = ref_mv_stack[idx - 1]; + ref_mv_stack[idx - 1] = ref_mv_stack[idx]; + ref_mv_stack[idx] = tmp_mv; + nr_len = idx; + } + } + len = nr_len; + } + + if (rf[1] > NONE_FRAME) { + for (idx = 0; idx < *refmv_count; ++idx) { + clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->n8_w << MI_SIZE_LOG2, + xd->n8_h << MI_SIZE_LOG2, xd); + clamp_mv_ref(&ref_mv_stack[idx].comp_mv.as_mv, xd->n8_w << MI_SIZE_LOG2, + xd->n8_h << MI_SIZE_LOG2, xd); + } + } else { + for (idx = 0; idx < AOMMIN(MAX_MV_REF_CANDIDATES, *refmv_count); ++idx) { + mv_ref_list[idx].as_int = ref_mv_stack[idx].this_mv.as_int; + clamp_mv_ref(&mv_ref_list[idx].as_mv, xd->n8_w << MI_SIZE_LOG2, + xd->n8_h << MI_SIZE_LOG2, xd); + } + } +} +#endif + +// This function searches the neighbourhood of a given MB/SB +// to try and find candidate reference vectors. +static void find_mv_refs_idx(const AV1_COMMON *cm, const MACROBLOCKD *xd, + MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, + int_mv *mv_ref_list, int block, int mi_row, + int mi_col, find_mv_refs_sync sync, + void *const data, int16_t *mode_context, + int_mv zeromv) { + const int *ref_sign_bias = cm->ref_frame_sign_bias; + int i, refmv_count = 0; +#if !CONFIG_REF_MV + const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type]; +#endif + int different_ref_found = 0; + int context_counter = 0; +#if CONFIG_MV_COMPRESS + const TileInfo *const tile_ = &xd->tile; + int mi_row_end = tile_->mi_row_end; + int mi_col_end = tile_->mi_col_end; + const MV_REF *const prev_frame_mvs = + cm->use_prev_frame_mvs + ? cm->prev_frame->mvs + + AOMMIN(((mi_row >> 1) << 1) + 1 + (((xd->n8_h - 1) >> 1) << 1), + mi_row_end - 1) * + cm->mi_cols + + AOMMIN(((mi_col >> 1) << 1) + 1 + (((xd->n8_w - 1) >> 1) << 1), + mi_col_end - 1) + : NULL; +#else + const MV_REF *const prev_frame_mvs = + cm->use_prev_frame_mvs + ? cm->prev_frame->mvs + mi_row * cm->mi_cols + mi_col + : NULL; +#endif + const TileInfo *const tile = &xd->tile; + const BLOCK_SIZE bsize = mi->mbmi.sb_type; + const int bw = block_size_wide[AOMMAX(bsize, BLOCK_8X8)]; + const int bh = block_size_high[AOMMAX(bsize, BLOCK_8X8)]; +#if CONFIG_REF_MV + POSITION mv_ref_search[MVREF_NEIGHBOURS]; + const int num_8x8_blocks_wide = num_8x8_blocks_wide_lookup[bsize]; + const int num_8x8_blocks_high = num_8x8_blocks_high_lookup[bsize]; + mv_ref_search[0].row = num_8x8_blocks_high - 1; + mv_ref_search[0].col = -1; + mv_ref_search[1].row = -1; + mv_ref_search[1].col = num_8x8_blocks_wide - 1; + mv_ref_search[2].row = -1; + mv_ref_search[2].col = (num_8x8_blocks_wide - 1) >> 1; + mv_ref_search[3].row = (num_8x8_blocks_high - 1) >> 1; + mv_ref_search[3].col = -1; + mv_ref_search[4].row = -1; + mv_ref_search[4].col = -1; +#if CONFIG_EXT_PARTITION_TYPES + if (num_8x8_blocks_wide == num_8x8_blocks_high) { + mv_ref_search[5].row = -1; + mv_ref_search[5].col = 0; + mv_ref_search[6].row = 0; + mv_ref_search[6].col = -1; + } else { + mv_ref_search[5].row = -1; + mv_ref_search[5].col = num_8x8_blocks_wide; + mv_ref_search[6].row = num_8x8_blocks_high; + mv_ref_search[6].col = -1; + } +#else + mv_ref_search[5].row = -1; + mv_ref_search[5].col = num_8x8_blocks_wide; + mv_ref_search[6].row = num_8x8_blocks_high; + mv_ref_search[6].col = -1; +#endif // CONFIG_EXT_PARTITION_TYPES + mv_ref_search[7].row = -1; + mv_ref_search[7].col = -3; + mv_ref_search[8].row = num_8x8_blocks_high - 1; + mv_ref_search[8].col = -3; + +#if CONFIG_CB4X4 + for (i = 0; i < MVREF_NEIGHBOURS; ++i) { + mv_ref_search[i].row *= 2; + mv_ref_search[i].col *= 2; + } +#endif // CONFIG_CB4X4 +#endif // CONFIG_REF_MV + + // The nearest 2 blocks are treated differently + // if the size < 8x8 we get the mv from the bmi substructure, + // and we also need to keep a mode count. + for (i = 0; i < 2; ++i) { + const POSITION *const mv_ref = &mv_ref_search[i]; + if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, mv_ref)) { + const MODE_INFO *const candidate_mi = + xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]; + const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; + // Keep counts for entropy encoding. + context_counter += mode_2_counter[candidate->mode]; + different_ref_found = 1; + + if (candidate->ref_frame[0] == ref_frame) + ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 0, mv_ref->col, block), + refmv_count, mv_ref_list, bw, bh, xd, Done); + else if (candidate->ref_frame[1] == ref_frame) + ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 1, mv_ref->col, block), + refmv_count, mv_ref_list, bw, bh, xd, Done); + } + } + + // Check the rest of the neighbors in much the same way + // as before except we don't need to keep track of sub blocks or + // mode counts. + for (; i < MVREF_NEIGHBOURS; ++i) { + const POSITION *const mv_ref = &mv_ref_search[i]; + if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, mv_ref)) { + const MB_MODE_INFO *const candidate = + !xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride] + ? NULL + : &xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]->mbmi; +#if CONFIG_REF_MV + 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) + continue; +#endif + different_ref_found = 1; + + if (candidate->ref_frame[0] == ref_frame) + ADD_MV_REF_LIST(candidate->mv[0], refmv_count, mv_ref_list, bw, bh, xd, + Done); + else if (candidate->ref_frame[1] == ref_frame) + ADD_MV_REF_LIST(candidate->mv[1], refmv_count, mv_ref_list, bw, bh, xd, + Done); + } + } + +// TODO(hkuang): Remove this sync after fixing pthread_cond_broadcast +// on windows platform. The sync here is unncessary if use_perv_frame_mvs +// is 0. But after removing it, there will be hang in the unit test on windows +// due to several threads waiting for a thread's signal. +#if defined(_WIN32) && !HAVE_PTHREAD_H + if (cm->frame_parallel_decode && sync != NULL) { + sync(data, mi_row); + } +#endif + + // Check the last frame's mode and mv info. + if (cm->use_prev_frame_mvs) { + // Synchronize here for frame parallel decode if sync function is provided. + if (cm->frame_parallel_decode && sync != NULL) { + sync(data, mi_row); + } + + if (prev_frame_mvs->ref_frame[0] == ref_frame) { + ADD_MV_REF_LIST(prev_frame_mvs->mv[0], refmv_count, mv_ref_list, bw, bh, + xd, Done); + } else if (prev_frame_mvs->ref_frame[1] == ref_frame) { + ADD_MV_REF_LIST(prev_frame_mvs->mv[1], refmv_count, mv_ref_list, bw, bh, + xd, Done); + } + } + + // Since we couldn't find 2 mvs from the same reference frame + // go back through the neighbors and find motion vectors from + // different reference frames. + if (different_ref_found) { + for (i = 0; i < MVREF_NEIGHBOURS; ++i) { + const POSITION *mv_ref = &mv_ref_search[i]; + if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, mv_ref)) { + const MB_MODE_INFO *const candidate = + !xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride] + ? NULL + : &xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]->mbmi; +#if CONFIG_REF_MV + 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) + continue; +#endif + + // If the candidate is INTRA we don't want to consider its mv. + IF_DIFF_REF_FRAME_ADD_MV(candidate, ref_frame, ref_sign_bias, + refmv_count, mv_ref_list, bw, bh, xd, Done); + } + } + } + + // Since we still don't have a candidate we'll try the last frame. + if (cm->use_prev_frame_mvs) { + if (prev_frame_mvs->ref_frame[0] != ref_frame && + prev_frame_mvs->ref_frame[0] > INTRA_FRAME) { + int_mv mv = prev_frame_mvs->mv[0]; + if (ref_sign_bias[prev_frame_mvs->ref_frame[0]] != + ref_sign_bias[ref_frame]) { + mv.as_mv.row *= -1; + mv.as_mv.col *= -1; + } + ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done); + } + + if (prev_frame_mvs->ref_frame[1] > INTRA_FRAME && + prev_frame_mvs->ref_frame[1] != ref_frame) { + int_mv mv = prev_frame_mvs->mv[1]; + if (ref_sign_bias[prev_frame_mvs->ref_frame[1]] != + ref_sign_bias[ref_frame]) { + mv.as_mv.row *= -1; + mv.as_mv.col *= -1; + } + ADD_MV_REF_LIST(mv, refmv_count, mv_ref_list, bw, bh, xd, Done); + } + } + +Done: + if (mode_context) + mode_context[ref_frame] = counter_to_context[context_counter]; + for (i = refmv_count; i < MAX_MV_REF_CANDIDATES; ++i) + 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, + int_mv *mv_ref_list, int block, int mi_row, + int mi_col, int16_t *mode_context) { + int i, refmv_count = 0; +#if !CONFIG_REF_MV + const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type]; +#endif + int context_counter = 0; + const int bw = block_size_wide[mi->mbmi.sb_type]; + const int bh = block_size_high[mi->mbmi.sb_type]; + const TileInfo *const tile = &xd->tile; +#if CONFIG_REF_MV + POSITION mv_ref_search[MVREF_NEIGHBOURS]; + const int num_8x8_blocks_wide = mi_size_wide[mi->mbmi.sb_type]; + const int num_8x8_blocks_high = mi_size_high[mi->mbmi.sb_type]; + mv_ref_search[0].row = num_8x8_blocks_high - 1; + mv_ref_search[0].col = -1; + mv_ref_search[1].row = -1; + mv_ref_search[1].col = num_8x8_blocks_wide - 1; + mv_ref_search[2].row = -1; + mv_ref_search[2].col = (num_8x8_blocks_wide - 1) >> 1; + mv_ref_search[3].row = (num_8x8_blocks_high - 1) >> 1; + mv_ref_search[3].col = -1; + mv_ref_search[4].row = -1; + mv_ref_search[4].col = -1; +#if CONFIG_EXT_PARTITION_TYPES + if (num_8x8_blocks_wide == num_8x8_blocks_high) { + mv_ref_search[5].row = -1; + mv_ref_search[5].col = 0; + mv_ref_search[6].row = 0; + mv_ref_search[6].col = -1; + } else { + mv_ref_search[5].row = -1; + mv_ref_search[5].col = num_8x8_blocks_wide; + mv_ref_search[6].row = num_8x8_blocks_high; + mv_ref_search[6].col = -1; + } +#else + mv_ref_search[5].row = -1; + mv_ref_search[5].col = num_8x8_blocks_wide; + mv_ref_search[6].row = num_8x8_blocks_high; + mv_ref_search[6].col = -1; +#endif // CONFIG_EXT_PARTITION_TYPES + mv_ref_search[7].row = -1; + mv_ref_search[7].col = -3; + mv_ref_search[8].row = num_8x8_blocks_high - 1; + mv_ref_search[8].col = -3; +#endif + + // Blank the reference vector list + memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES); + + // The nearest 2 blocks are examined only. + // If the size < 8x8, we get the mv from the bmi substructure; + for (i = 0; i < 2; ++i) { + const POSITION *const mv_ref = &mv_ref_search[i]; + if (is_inside(tile, mi_col, mi_row, cm->mi_rows, cm, mv_ref)) { + const MODE_INFO *const candidate_mi = + xd->mi[mv_ref->col + mv_ref->row * xd->mi_stride]; + const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; + + // Keep counts for entropy encoding. + context_counter += mode_2_counter[candidate->mode]; + + if (candidate->ref_frame[0] == ref_frame) { + ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 0, mv_ref->col, block), + refmv_count, mv_ref_list, bw, bh, xd, Done); + } else if (candidate->ref_frame[1] == ref_frame) { + ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 1, mv_ref->col, block), + refmv_count, mv_ref_list, bw, bh, xd, Done); + } + } + } + +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, +#if CONFIG_REF_MV + uint8_t *ref_mv_count, CANDIDATE_MV *ref_mv_stack, +#if CONFIG_EXT_INTER + int16_t *compound_mode_context, +#endif // CONFIG_EXT_INTER +#endif + 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; +#endif // CONFIG_GLOBAL_MOTION +#if CONFIG_REF_MV + int idx, all_zero = 1; +#if CONFIG_GLOBAL_MOTION + MV_REFERENCE_FRAME rf[2]; +#endif // CONFIG_GLOBAL_MOTION +#endif // CONFIG_REF_MV +#if CONFIG_EXT_INTER + av1_update_mv_context(cm, xd, mi, ref_frame, mv_ref_list, -1, mi_row, mi_col, +#if CONFIG_REF_MV + compound_mode_context); +#else + mode_context); +#endif // CONFIG_REF_MV +#endif // CONFIG_EXT_INTER + +#if CONFIG_GLOBAL_MOTION +#if CONFIG_REF_MV + 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) + .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; +#else + zeromv[0].as_int = gm_get_motion_vector(&cm->global_motion[ref_frame], + cm->allow_high_precision_mv, bsize, + mi_col, mi_row, 0) + .as_int; + zeromv[1].as_int = 0; +#endif // CONFIG_REF_MV +#else + zeromv[0].as_int = zeromv[1].as_int = 0; +#endif // CONFIG_GLOBAL_MOTION + +#if CONFIG_REF_MV + if (ref_frame <= ALTREF_FRAME) +#endif // CONFIG_REF_MV + find_mv_refs_idx(cm, xd, mi, ref_frame, mv_ref_list, -1, mi_row, mi_col, + sync, data, mode_context, zeromv[0]); + +#if CONFIG_REF_MV + setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack, mv_ref_list, + -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 + to the global motion vector. + Note: For the following to work properly, the encoder can't throw away + any global motion models after calling this function, even if they are + unused. Instead we rely on the recode loop: If any non-IDENTITY model + is unused, the whole frame will be re-encoded without it. + The problem is that, otherwise, we can end up in the following situation: + * Encoder has a global motion model with nonzero translational part, + and all candidate MVs are zero. So the ALL_ZERO flag is unset. + * Encoder throws away global motion because it is never used. + * Decoder sees that there is no global motion and all candidate MVs are + 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 < MAX_MV_REF_CANDIDATES; ++idx) + if (mv_ref_list[idx].as_int != zeromv[0].as_int) all_zero = 0; + } + + if (all_zero) mode_context[ref_frame] |= (1 << ALL_ZERO_FLAG_OFFSET); +#endif +} + +void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, + int_mv *near_mv) { + int i; + // Make sure all the candidates are properly clamped etc + for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) { + lower_mv_precision(&mvlist[i].as_mv, allow_hp); + } + *nearest_mv = mvlist[0]; + *near_mv = mvlist[1]; +} + +void av1_append_sub8x8_mvs_for_idx(const AV1_COMMON *cm, MACROBLOCKD *xd, + int block, int ref, int mi_row, int mi_col, +#if CONFIG_REF_MV + CANDIDATE_MV *ref_mv_stack, + uint8_t *ref_mv_count, +#endif +#if CONFIG_EXT_INTER + int_mv *mv_list, +#endif // CONFIG_EXT_INTER + 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; + int_mv zeromv; +#if CONFIG_REF_MV + CANDIDATE_MV tmp_mv; + uint8_t idx; + uint8_t above_count = 0, left_count = 0; + MV_REFERENCE_FRAME rf[2] = { mi->mbmi.ref_frame[ref], NONE_FRAME }; + *ref_mv_count = 0; +#endif + + assert(MAX_MV_REF_CANDIDATES == 2); + +#if CONFIG_GLOBAL_MOTION + zeromv.as_int = + gm_get_motion_vector(&cm->global_motion[ref], cm->allow_high_precision_mv, + mi->mbmi.sb_type, mi_col, mi_row, block) + .as_int; +#else + zeromv.as_int = 0; +#endif + find_mv_refs_idx(cm, xd, mi, mi->mbmi.ref_frame[ref], mv_list, block, mi_row, + mi_col, NULL, NULL, NULL, zeromv); + +#if CONFIG_REF_MV + scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, -1, 0, ref_mv_stack, + ref_mv_count); + above_count = *ref_mv_count; + + scan_blk_mbmi(cm, xd, mi_row, mi_col, block, rf, 0, -1, ref_mv_stack, + ref_mv_count); + left_count = *ref_mv_count - above_count; + + if (above_count > 1 && left_count > 0) { + tmp_mv = ref_mv_stack[1]; + ref_mv_stack[1] = ref_mv_stack[above_count]; + ref_mv_stack[above_count] = tmp_mv; + } + + for (idx = 0; idx < *ref_mv_count; ++idx) + clamp_mv_ref(&ref_mv_stack[idx].this_mv.as_mv, xd->n8_w << MI_SIZE_LOG2, + xd->n8_h << MI_SIZE_LOG2, xd); + + for (idx = 0; idx < AOMMIN(MAX_MV_REF_CANDIDATES, *ref_mv_count); ++idx) + mv_list[idx].as_int = ref_mv_stack[idx].this_mv.as_int; +#endif + + near_mv->as_int = 0; + switch (block) { + case 0: + nearest_mv->as_int = mv_list[0].as_int; + near_mv->as_int = mv_list[1].as_int; + break; + case 1: + case 2: + nearest_mv->as_int = bmi[0].as_mv[ref].as_int; + for (n = 0; n < MAX_MV_REF_CANDIDATES; ++n) + if (nearest_mv->as_int != mv_list[n].as_int) { + near_mv->as_int = mv_list[n].as_int; + break; + } + break; + case 3: { + int_mv candidates[2 + MAX_MV_REF_CANDIDATES]; + candidates[0] = bmi[1].as_mv[ref]; + candidates[1] = bmi[0].as_mv[ref]; + candidates[2] = mv_list[0]; + candidates[3] = mv_list[1]; + + nearest_mv->as_int = bmi[2].as_mv[ref].as_int; + for (n = 0; n < 2 + MAX_MV_REF_CANDIDATES; ++n) + if (nearest_mv->as_int != candidates[n].as_int) { + near_mv->as_int = candidates[n].as_int; + break; + } + break; + } + default: assert(0 && "Invalid block index."); + } +} + +#if CONFIG_WARPED_MOTION +void calc_projection_samples(MB_MODE_INFO *const mbmi, int x, int y, + int *pts_inref) { + pts_inref[0] = (x * 8) + mbmi->mv[0].as_mv.col; + pts_inref[1] = (y * 8) + mbmi->mv[0].as_mv.row; +} + +// Note: Samples returned are at 1/8-pel precision +int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, + int *pts, int *pts_inref) { + MB_MODE_INFO *const mbmi0 = &(xd->mi[0]->mbmi); + int ref_frame = mbmi0->ref_frame[0]; + int up_available = xd->up_available; + int left_available = xd->left_available; + int i, mi_step, np = 0; + int global_offset_c = mi_col * MI_SIZE; + int global_offset_r = mi_row * MI_SIZE; + + // scan the above row + if (up_available) { + for (i = 0; i < AOMMIN(xd->n8_w, cm->mi_cols - mi_col); i += mi_step) { + int mi_row_offset = -1; + 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; + + mi_step = AOMMIN(xd->n8_w, mi_size_wide[mbmi->sb_type]); + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + int bw = block_size_wide[mbmi->sb_type]; + int bh = block_size_high[mbmi->sb_type]; + int cr_offset = -AOMMAX(bh, MI_SIZE) / 2 - 1; + int cc_offset = i * MI_SIZE + AOMMAX(bw, MI_SIZE) / 2 - 1; + int x = cc_offset + global_offset_c; + int y = cr_offset + global_offset_r; + + pts[0] = (x * 8); + pts[1] = (y * 8); + calc_projection_samples(mbmi, x, y, pts_inref); + pts += 2; + pts_inref += 2; + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } + } + assert(2 * np <= SAMPLES_ARRAY_SIZE); + + // scan the left column + if (left_available) { + for (i = 0; i < AOMMIN(xd->n8_h, cm->mi_rows - mi_row); i += mi_step) { + int mi_row_offset = i; + int mi_col_offset = -1; + + MODE_INFO *mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + MB_MODE_INFO *mbmi = &mi->mbmi; + + mi_step = AOMMIN(xd->n8_h, mi_size_high[mbmi->sb_type]); + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + int bw = block_size_wide[mbmi->sb_type]; + int bh = block_size_high[mbmi->sb_type]; + int cr_offset = i * MI_SIZE + AOMMAX(bh, MI_SIZE) / 2 - 1; + int cc_offset = -AOMMAX(bw, MI_SIZE) / 2 - 1; + int x = cc_offset + global_offset_c; + int y = cr_offset + global_offset_r; + + pts[0] = (x * 8); + pts[1] = (y * 8); + calc_projection_samples(mbmi, x, y, pts_inref); + pts += 2; + pts_inref += 2; + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } + } + assert(2 * np <= SAMPLES_ARRAY_SIZE); + + if (left_available && up_available) { + int mi_row_offset = -1; + int mi_col_offset = -1; + + MODE_INFO *mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + MB_MODE_INFO *mbmi = &mi->mbmi; + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + int bw = block_size_wide[mbmi->sb_type]; + int bh = block_size_high[mbmi->sb_type]; + int cr_offset = -AOMMAX(bh, MI_SIZE) / 2 - 1; + int cc_offset = -AOMMAX(bw, MI_SIZE) / 2 - 1; + int x = cc_offset + global_offset_c; + int y = cr_offset + global_offset_r; + + pts[0] = (x * 8); + pts[1] = (y * 8); + calc_projection_samples(mbmi, x, y, pts_inref); + np++; + } + } + assert(2 * np <= SAMPLES_ARRAY_SIZE); + + return np; +} +#endif // CONFIG_WARPED_MOTION |