Port interintra experiment from nextgen.
The interintra experiment, which combines an inter prediction and an
inter prediction have been ported from the nextgen branch. The
experiment is merged into ext_inter, so there is no separate configure
option to enable it.
Change-Id: I0cc20cefd29e9b77ab7bbbb709abc11512320325
diff --git a/vp10/encoder/rdopt.c b/vp10/encoder/rdopt.c
index 416c11c..ff07489 100644
--- a/vp10/encoder/rdopt.c
+++ b/vp10/encoder/rdopt.c
@@ -44,6 +44,10 @@
#include "vp10/encoder/rdopt.h"
#include "vp10/encoder/aq_variance.h"
+// TODO(geza.lore) Update this when the extended coding unit size experiment
+// have been ported.
+#define CU_SIZE 64
+
#if CONFIG_EXT_REFS
#define LAST_FRAME_MODE_MASK ((1 << GOLDEN_FRAME) | (1 << ALTREF_FRAME) | \
@@ -260,6 +264,40 @@
{D63_PRED, {INTRA_FRAME, NONE}},
{D117_PRED, {INTRA_FRAME, NONE}},
{D45_PRED, {INTRA_FRAME, NONE}},
+
+#if CONFIG_EXT_INTER
+ {ZEROMV, {LAST_FRAME, INTRA_FRAME}},
+ {NEARESTMV, {LAST_FRAME, INTRA_FRAME}},
+ {NEARMV, {LAST_FRAME, INTRA_FRAME}},
+ {NEWMV, {LAST_FRAME, INTRA_FRAME}},
+
+#if CONFIG_EXT_REFS
+ {ZEROMV, {LAST2_FRAME, INTRA_FRAME}},
+ {NEARESTMV, {LAST2_FRAME, INTRA_FRAME}},
+ {NEARMV, {LAST2_FRAME, INTRA_FRAME}},
+ {NEWMV, {LAST2_FRAME, INTRA_FRAME}},
+
+ {ZEROMV, {LAST3_FRAME, INTRA_FRAME}},
+ {NEARESTMV, {LAST3_FRAME, INTRA_FRAME}},
+ {NEARMV, {LAST3_FRAME, INTRA_FRAME}},
+ {NEWMV, {LAST3_FRAME, INTRA_FRAME}},
+
+ {ZEROMV, {LAST4_FRAME, INTRA_FRAME}},
+ {NEARESTMV, {LAST4_FRAME, INTRA_FRAME}},
+ {NEARMV, {LAST4_FRAME, INTRA_FRAME}},
+ {NEWMV, {LAST4_FRAME, INTRA_FRAME}},
+#endif // CONFIG_EXT_REFS
+
+ {ZEROMV, {GOLDEN_FRAME, INTRA_FRAME}},
+ {NEARESTMV, {GOLDEN_FRAME, INTRA_FRAME}},
+ {NEARMV, {GOLDEN_FRAME, INTRA_FRAME}},
+ {NEWMV, {GOLDEN_FRAME, INTRA_FRAME}},
+
+ {ZEROMV, {ALTREF_FRAME, INTRA_FRAME}},
+ {NEARESTMV, {ALTREF_FRAME, INTRA_FRAME}},
+ {NEARMV, {ALTREF_FRAME, INTRA_FRAME}},
+ {NEWMV, {ALTREF_FRAME, INTRA_FRAME}},
+#endif // CONFIG_EXT_INTER
};
static const REF_DEFINITION vp10_ref_order[MAX_REFS] = {
@@ -1056,33 +1094,6 @@
rate, distortion, skip,
sse, ref_best_rd, 0, bs,
mbmi->tx_size, cpi->sf.use_fast_coef_costing);
-
-#if CONFIG_EXT_TX
- if (get_ext_tx_types(mbmi->tx_size, bs, is_inter) > 1 &&
- !xd->lossless[mbmi->segment_id] && *rate != INT_MAX) {
- int ext_tx_set = get_ext_tx_set(mbmi->tx_size, bs, is_inter);
- if (is_inter) {
- if (ext_tx_set > 0)
- *rate += cpi->inter_tx_type_costs[ext_tx_set][mbmi->tx_size]
- [mbmi->tx_type];
- } else {
- if (ext_tx_set > 0 && ALLOW_INTRA_EXT_TX)
- *rate +=
- cpi->intra_tx_type_costs[ext_tx_set][mbmi->tx_size]
- [mbmi->mode][mbmi->tx_type];
- }
- }
-#else
- if (mbmi->tx_size < TX_32X32 && !xd->lossless[mbmi->segment_id] &&
- *rate != INT_MAX) {
- if (is_inter)
- *rate += cpi->inter_tx_type_costs[mbmi->tx_size][mbmi->tx_type];
- else
- *rate += cpi->intra_tx_type_costs[mbmi->tx_size]
- [intra_mode_to_tx_type_context[mbmi->mode]]
- [mbmi->tx_type];
- }
-#endif // CONFIG_EXT_TX
}
static void choose_smallest_tx_size(VP10_COMP *cpi, MACROBLOCK *x,
@@ -3818,9 +3829,14 @@
int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES], int this_mode,
const MV_REFERENCE_FRAME ref_frames[2],
const BLOCK_SIZE bsize, int block) {
+
+#if !CONFIG_EXT_INTER
+ assert(ref_frames[1] != INTRA_FRAME); // Just sanity check
+#endif
+
if ((this_mode == NEARMV || this_mode == NEARESTMV || this_mode == ZEROMV) &&
frame_mv[this_mode][ref_frames[0]].as_int == 0 &&
- (ref_frames[1] == NONE ||
+ (ref_frames[1] <= INTRA_FRAME ||
frame_mv[this_mode][ref_frames[1]].as_int == 0)) {
#if CONFIG_REF_MV
int16_t rfc = vp10_mode_context_analyzer(mode_context,
@@ -3849,7 +3865,7 @@
if (c2 > c3) return 0;
} else {
assert(this_mode == ZEROMV);
- if (ref_frames[1] == NONE) {
+ if (ref_frames[1] <= INTRA_FRAME) {
if ((c3 >= c2 && frame_mv[NEARESTMV][ref_frames[0]].as_int == 0) ||
(c3 >= c1 && frame_mv[NEARMV][ref_frames[0]].as_int == 0))
return 0;
@@ -3889,26 +3905,16 @@
if (c4 > c3) return 0;
} else {
assert(this_mode == ZERO_ZEROMV);
- if (ref_frames[1] == NONE) {
- if ((c3 >= c2 &&
- frame_mv[NEAREST_NEARESTMV][ref_frames[0]].as_int == 0) ||
- (c3 >= c1 &&
- frame_mv[NEAREST_NEARMV][ref_frames[0]].as_int == 0) ||
- (c3 >= c4 &&
- frame_mv[NEAR_NEARESTMV][ref_frames[0]].as_int == 0))
- return 0;
- } else {
- if ((c3 >= c2 &&
- frame_mv[NEAREST_NEARESTMV][ref_frames[0]].as_int == 0 &&
- frame_mv[NEAREST_NEARESTMV][ref_frames[1]].as_int == 0) ||
- (c3 >= c1 &&
- frame_mv[NEAREST_NEARMV][ref_frames[0]].as_int == 0 &&
- frame_mv[NEAREST_NEARMV][ref_frames[1]].as_int == 0) ||
- (c3 >= c4 &&
- frame_mv[NEAR_NEARESTMV][ref_frames[0]].as_int == 0 &&
- frame_mv[NEAR_NEARESTMV][ref_frames[1]].as_int == 0))
- return 0;
- }
+ if ((c3 >= c2 &&
+ frame_mv[NEAREST_NEARESTMV][ref_frames[0]].as_int == 0 &&
+ frame_mv[NEAREST_NEARESTMV][ref_frames[1]].as_int == 0) ||
+ (c3 >= c1 &&
+ frame_mv[NEAREST_NEARMV][ref_frames[0]].as_int == 0 &&
+ frame_mv[NEAREST_NEARMV][ref_frames[1]].as_int == 0) ||
+ (c3 >= c4 &&
+ frame_mv[NEAR_NEARESTMV][ref_frames[0]].as_int == 0 &&
+ frame_mv[NEAR_NEARESTMV][ref_frames[1]].as_int == 0))
+ return 0;
}
}
#endif // CONFIG_EXT_INTER
@@ -5160,6 +5166,8 @@
#endif // CONFIG_OBMC
#if CONFIG_EXT_INTER
int_mv single_newmvs[2][MAX_REF_FRAMES],
+ int single_newmvs_rate[2][MAX_REF_FRAMES],
+ int *compmode_interintra_cost,
#else
int_mv single_newmv[MAX_REF_FRAMES],
#endif // CONFIG_EXT_INTER
@@ -5183,6 +5191,9 @@
#if CONFIG_EXT_INTER
int mv_idx = (this_mode == NEWFROMNEARMV) ? 1 : 0;
int_mv single_newmv[MAX_REF_FRAMES];
+ const int * const intra_mode_cost =
+ cpi->mbmode_cost[size_group_lookup[bsize]];
+ const int is_comp_interintra_pred = (mbmi->ref_frame[1] == INTRA_FRAME);
#if CONFIG_REF_MV
uint8_t ref_frame_type = vp10_ref_frame_type(mbmi->ref_frame);
#endif
@@ -5193,6 +5204,9 @@
#else
DECLARE_ALIGNED(16, uint8_t, tmp_buf[MAX_MB_PLANE * 64 * 64]);
#endif // CONFIG_VP9_HIGHBITDEPTH
+#if CONFIG_EXT_INTER
+ const int tmp_buf_sz = CU_SIZE * CU_SIZE;
+#endif // CONFIG_EXT_INTER
#if CONFIG_OBMC
int allow_obmc = is_obmc_allowed(mbmi);
int best_obmc_flag = 0;
@@ -5243,6 +5257,15 @@
int64_t distortion_y = 0, distortion_uv = 0;
int16_t mode_ctx = mbmi_ext->mode_context[refs[0]];
+#if CONFIG_EXT_INTER
+ *compmode_interintra_cost = 0;
+
+ // is_comp_interintra_pred implies !is_comp_pred
+ assert(!is_comp_interintra_pred || (!is_comp_pred));
+ // is_comp_interintra_pred implies is_interintra_allowed(mbmi->sb_type)
+ assert(!is_comp_interintra_pred || is_interintra_allowed(mbmi));
+#endif // CONFIG_EXT_INTER
+
#if CONFIG_OBMC
tmp_rd = 0;
#endif // CONFIG_OBMC
@@ -5345,35 +5368,39 @@
x->nmvjointcost, x->mvcost, MV_COST_WEIGHT);
}
#endif // CONFIG_EXT_INTER
- *rate2 += rate_mv;
} else {
int_mv tmp_mv;
- single_motion_search(cpi, x, bsize, mi_row, mi_col,
+
#if CONFIG_EXT_INTER
- 0, mv_idx,
+ if (is_comp_interintra_pred) {
+ tmp_mv = single_newmvs[mv_idx][refs[0]];
+ rate_mv = single_newmvs_rate[mv_idx][refs[0]];
+ } else {
+ single_motion_search(cpi, x, bsize, mi_row, mi_col,
+ 0, mv_idx, &tmp_mv, &rate_mv);
+ single_newmvs[mv_idx][refs[0]] = tmp_mv;
+ single_newmvs_rate[mv_idx][refs[0]] = rate_mv;
+ }
+#else
+ single_motion_search(cpi, x, bsize, mi_row, mi_col, &tmp_mv, &rate_mv);
+ single_newmv[refs[0]] = tmp_mv;
#endif // CONFIG_EXT_INTER
- &tmp_mv, &rate_mv);
+
if (tmp_mv.as_int == INVALID_MV)
return INT64_MAX;
- frame_mv[refs[0]].as_int =
- xd->mi[0]->bmi[0].as_mv[0].as_int = tmp_mv.as_int;
-#if CONFIG_EXT_INTER
- single_newmvs[mv_idx][refs[0]].as_int = tmp_mv.as_int;
-#else
- single_newmv[refs[0]].as_int = tmp_mv.as_int;
-#endif // CONFIG_EXT_INTER
+ frame_mv[refs[0]] = tmp_mv;
+ xd->mi[0]->bmi[0].as_mv[0] = tmp_mv;
// Estimate the rate implications of a new mv but discount this
// under certain circumstances where we want to help initiate a weak
// motion field, where the distortion gain for a single block may not
// be enough to overcome the cost of a new mv.
if (discount_newmv_test(cpi, this_mode, tmp_mv, mode_mv, refs[0])) {
- *rate2 += VPXMAX((rate_mv / NEW_MV_DISCOUNT_FACTOR), 1);
- } else {
- *rate2 += rate_mv;
+ rate_mv = VPXMAX((rate_mv / NEW_MV_DISCOUNT_FACTOR), 1);
}
}
+ *rate2 += rate_mv;
}
for (i = 0; i < is_comp_pred + 1; ++i) {
@@ -5586,6 +5613,9 @@
if ((cm->interp_filter == SWITCHABLE &&
(!i || best_needs_copy)) ||
+#if CONFIG_EXT_INTER
+ is_comp_interintra_pred ||
+#endif // CONFIG_EXT_INTER
(cm->interp_filter != SWITCHABLE &&
(cm->interp_filter == mbmi->interp_filter ||
(i == 0 && intpel_mv && IsInterpolatingFilter(i))))) {
@@ -5714,6 +5744,63 @@
mbmi->interp_filter = cm->interp_filter != SWITCHABLE ?
cm->interp_filter : best_filter;
rs = cm->interp_filter == SWITCHABLE ? vp10_get_switchable_rate(cpi, xd) : 0;
+
+#if CONFIG_EXT_INTER
+ if (is_comp_interintra_pred) {
+ PREDICTION_MODE interintra_mode, best_interintra_mode = DC_PRED;
+ int64_t best_interintra_rd = INT64_MAX;
+ int rmode, rate_sum;
+ int64_t dist_sum;
+ int j;
+ mbmi->ref_frame[1] = NONE;
+ for (j = 0; j < MAX_MB_PLANE; j++) {
+ xd->plane[j].dst.buf = tmp_buf + j * tmp_buf_sz;
+ xd->plane[j].dst.stride = CU_SIZE;
+ }
+ vp10_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
+ restore_dst_buf(xd, orig_dst, orig_dst_stride);
+ mbmi->ref_frame[1] = INTRA_FRAME;
+
+ for (interintra_mode = DC_PRED; interintra_mode <= TM_PRED;
+ ++interintra_mode) {
+ mbmi->interintra_mode = interintra_mode;
+ mbmi->interintra_uv_mode = interintra_mode;
+ rmode = intra_mode_cost[mbmi->interintra_mode];
+ vp10_build_interintra_predictors(xd,
+ tmp_buf,
+ tmp_buf + tmp_buf_sz,
+ tmp_buf + 2 * tmp_buf_sz,
+ CU_SIZE,
+ CU_SIZE,
+ CU_SIZE,
+ bsize);
+ model_rd_for_sb(cpi, bsize, x, xd, &rate_sum, &dist_sum,
+ &skip_txfm_sb, &skip_sse_sb);
+ rd = RDCOST(x->rdmult, x->rddiv, rmode + rate_sum, dist_sum);
+ if (rd < best_interintra_rd) {
+ best_interintra_rd = rd;
+ best_interintra_mode = interintra_mode;
+ }
+ }
+ mbmi->interintra_mode = best_interintra_mode;
+ mbmi->interintra_uv_mode = best_interintra_mode;
+ if (ref_best_rd < INT64_MAX &&
+ best_interintra_rd / 2 > ref_best_rd) {
+ return INT64_MAX;
+ }
+
+ pred_exists = 0;
+ tmp_rd = best_interintra_rd;
+
+ *compmode_interintra_cost =
+ vp10_cost_bit(cm->fc->interintra_prob[bsize], 1);
+ *compmode_interintra_cost += intra_mode_cost[mbmi->interintra_mode];
+ } else if (is_interintra_allowed(mbmi)) {
+ *compmode_interintra_cost =
+ vp10_cost_bit(cm->fc->interintra_prob[bsize], 0);
+ }
+#endif // CONFIG_EXT_INTER
+
#if CONFIG_OBMC
if (allow_obmc)
mbmi->obmc = best_obmc_flag;
@@ -6303,6 +6390,7 @@
struct buf_2d yv12_mb[MAX_REF_FRAMES][MAX_MB_PLANE];
#if CONFIG_EXT_INTER
int_mv single_newmvs[2][MAX_REF_FRAMES] = { { { 0 } }, { { 0 } } };
+ int single_newmvs_rate[2][MAX_REF_FRAMES] = { { 0 }, { 0 } };
#else
int_mv single_newmv[MAX_REF_FRAMES] = { { 0 } };
#endif // CONFIG_EXT_INTER
@@ -6325,9 +6413,6 @@
int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS];
int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
MB_MODE_INFO best_mbmode;
-#if CONFIG_REF_MV
- uint8_t best_ref_mv_idx[MODE_CTX_REF_FRAMES] = { 0 };
-#endif
int best_mode_skippable = 0;
int midx, best_mode_index = -1;
unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES];
@@ -6594,6 +6679,9 @@
int64_t this_rd = INT64_MAX;
int disable_skip = 0;
int compmode_cost = 0;
+#if CONFIG_EXT_INTER
+ int compmode_interintra_cost = 0;
+#endif // CONFIG_EXT_INTER
int rate2 = 0, rate_y = 0, rate_uv = 0;
int64_t distortion2 = 0, distortion_y = 0, distortion_uv = 0;
int skippable = 0;
@@ -6609,6 +6697,14 @@
second_ref_frame = vp10_mode_order[mode_index].ref_frame[1];
#if CONFIG_EXT_INTER
+ if (ref_frame > INTRA_FRAME && second_ref_frame == INTRA_FRAME) {
+ // Mode must by compatible
+ assert(is_interintra_allowed_mode(this_mode));
+
+ if (!is_interintra_allowed_bsize(bsize))
+ continue;
+ }
+
if (this_mode == NEAREST_NEARESTMV) {
frame_mv[NEAREST_NEARESTMV][ref_frame].as_int =
frame_mv[NEARESTMV][ref_frame].as_int;
@@ -6792,6 +6888,11 @@
xd->plane[i].pre[1] = yv12_mb[second_ref_frame][i];
}
+#if CONFIG_EXT_INTER
+ mbmi->interintra_mode = (PREDICTION_MODE)(DC_PRED - 1);
+ mbmi->interintra_uv_mode = (PREDICTION_MODE)(DC_PRED - 1);
+#endif // CONFIG_EXT_INTER
+
if (ref_frame == INTRA_FRAME) {
TX_SIZE uv_tx;
struct macroblockd_plane *const pd = &xd->plane[1];
@@ -6936,6 +7037,21 @@
rate2 += intra_cost_penalty;
distortion2 = distortion_y + distortion_uv;
} else {
+#if CONFIG_EXT_INTER
+ if (second_ref_frame == INTRA_FRAME) {
+ mbmi->interintra_mode = best_intra_mode;
+ mbmi->interintra_uv_mode = best_intra_mode;
+#if CONFIG_EXT_INTRA
+ // TODO(debargha|geza.lore):
+ // Should we use ext_intra modes for interintra?
+ mbmi->ext_intra_mode_info.use_ext_intra_mode[0] = 0;
+ mbmi->ext_intra_mode_info.use_ext_intra_mode[1] = 0;
+ mbmi->angle_delta[0] = 0;
+ mbmi->angle_delta[1] = 0;
+ mbmi->intra_filter = INTRA_FILTER_LINEAR;
+#endif // CONFIG_EXT_INTRA
+ }
+#endif // CONFIG_EXT_INTER
#if CONFIG_REF_MV
mbmi->ref_mv_idx = 0;
ref_frame_type = vp10_ref_frame_type(mbmi->ref_frame);
@@ -6951,11 +7067,14 @@
#endif // CONFIG_OBMC
#if CONFIG_EXT_INTER
single_newmvs,
+ single_newmvs_rate,
+ &compmode_interintra_cost,
#else
single_newmv,
#endif // CONFIG_EXT_INTER
single_inter_filter,
- single_skippable, &total_sse, best_rd,
+ single_skippable,
+ &total_sse, best_rd,
&mask_filter, filter_cache);
#if CONFIG_REF_MV
@@ -7008,6 +7127,9 @@
#if CONFIG_EXT_INTER
int_mv dummy_single_newmvs[2][MAX_REF_FRAMES] =
{ { { 0 } }, { { 0 } } };
+ int dummy_single_newmvs_rate[2][MAX_REF_FRAMES] =
+ { { 0 }, { 0 } };
+ int dummy_compmode_interintra_cost = 0;
#else
int_mv dummy_single_newmv[MAX_REF_FRAMES] = { { 0 } };
#endif
@@ -7027,6 +7149,8 @@
#endif // CONFIG_OBMC
#if CONFIG_EXT_INTER
dummy_single_newmvs,
+ dummy_single_newmvs_rate,
+ &dummy_compmode_interintra_cost,
#else
dummy_single_newmv,
#endif
@@ -7071,8 +7195,6 @@
rate_uv = tmp_rate_uv;
total_sse = tmp_sse;
this_rd = tmp_alt_rd;
- // Indicator of the effective nearmv reference motion vector.
- best_ref_mv_idx[ref_frame_type] = 1 + ref_idx;
tmp_ref_rd = tmp_alt_rd;
backup_mbmi = *mbmi;
} else {
@@ -7082,7 +7204,7 @@
frame_mv[NEARMV][ref_frame] = backup_mv;
}
-#endif
+#endif // CONFIG_REF_MV
if (this_rd == INT64_MAX)
continue;
@@ -7093,6 +7215,10 @@
rate2 += compmode_cost;
}
+#if CONFIG_EXT_INTER
+ rate2 += compmode_interintra_cost;
+#endif // CONFIG_EXT_INTER
+
// Estimate the reference frame signaling cost and add it
// to the rolling cost variable.
if (comp_pred) {
@@ -7308,12 +7434,11 @@
best_mbmode.ref_frame[1]};
int comp_pred_mode = refs[1] > INTRA_FRAME;
#if CONFIG_REF_MV
+ const uint8_t rf_type = vp10_ref_frame_type(best_mbmode.ref_frame);
if (!comp_pred_mode) {
- if (best_ref_mv_idx[best_mbmode.ref_frame[0]] > 0 &&
- best_mbmode.ref_frame[1] == NONE) {
- int idx = best_ref_mv_idx[best_mbmode.ref_frame[0]] + 1;
- int_mv cur_mv =
- mbmi_ext->ref_mv_stack[best_mbmode.ref_frame[0]][idx].this_mv;
+ if (best_mbmode.ref_mv_idx > 0 && refs[1] == NONE) {
+ int idx = best_mbmode.ref_mv_idx + 1;
+ int_mv cur_mv = mbmi_ext->ref_mv_stack[refs[0]][idx].this_mv;
lower_mv_precision(&cur_mv.as_mv, cm->allow_high_precision_mv);
frame_mv[NEARMV][refs[0]] = cur_mv;
}
@@ -7325,7 +7450,6 @@
else if (best_mbmode.mv[0].as_int == 0)
best_mbmode.mode = ZEROMV;
} else {
- uint8_t rf_type = vp10_ref_frame_type(best_mbmode.ref_frame);
int i;
const int allow_hp = cm->allow_high_precision_mv;
int_mv nearestmv[2] = { frame_mv[NEARESTMV][refs[0]],
@@ -7340,7 +7464,7 @@
}
if (mbmi_ext->ref_mv_count[rf_type] > 1) {
- int ref_mv_idx = best_ref_mv_idx[rf_type] + 1;
+ int ref_mv_idx = best_mbmode.ref_mv_idx + 1;
nearmv[0] = mbmi_ext->ref_mv_stack[rf_type][ref_mv_idx].this_mv;
nearmv[1] = mbmi_ext->ref_mv_stack[rf_type][ref_mv_idx].comp_mv;
}
@@ -7417,10 +7541,11 @@
if (best_mbmode.ref_frame[0] > INTRA_FRAME &&
best_mbmode.mv[0].as_int == 0 &&
#if CONFIG_EXT_INTER
- best_mbmode.ref_frame[1] == NONE) {
+ (best_mbmode.ref_frame[1] <= INTRA_FRAME)
#else
- (best_mbmode.ref_frame[1] == NONE || best_mbmode.mv[1].as_int == 0)) {
+ (best_mbmode.ref_frame[1] == NONE || best_mbmode.mv[1].as_int == 0)
#endif // CONFIG_EXT_INTER
+ ) {
int16_t mode_ctx = mbmi_ext->mode_context[best_mbmode.ref_frame[0]];
#if !CONFIG_EXT_INTER
if (best_mbmode.ref_frame[1] > NONE)
@@ -7430,11 +7555,6 @@
if (mode_ctx & (1 << ALL_ZERO_FLAG_OFFSET))
best_mbmode.mode = ZEROMV;
}
-
- if (best_mbmode.mode == NEARMV) {
- uint8_t ref_frame_type = vp10_ref_frame_type(best_mbmode.ref_frame);
- best_mbmode.ref_mv_idx = best_ref_mv_idx[ref_frame_type];
- }
#endif
if (best_mode_index < 0 || best_rd >= best_rd_so_far) {
