diff --git a/vp10/encoder/context_tree.h b/vp10/encoder/context_tree.h
index 4fa58064ed958719e749a60235a81fbdf309c7ad..53c7142d5ab16ad67d4d029891a5176f96ecdb80 100644
--- a/vp10/encoder/context_tree.h
+++ b/vp10/encoder/context_tree.h
@@ -54,7 +54,6 @@ typedef struct {
int hybrid_pred_diff;
int comp_pred_diff;
int single_pred_diff;
- int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
// TODO(jingning) Use RD_COST struct here instead. This involves a boarder
// scope of refactoring.
diff --git a/vp10/encoder/encodeframe.c b/vp10/encoder/encodeframe.c
index aafde450baf3a48a876a327e0d7d0d3fa7dda371..ec00b62e9b358c138347b0d708542a6a109e3916 100644
--- a/vp10/encoder/encodeframe.c
+++ b/vp10/encoder/encodeframe.c
@@ -1194,9 +1194,6 @@ static void update_state(VP10_COMP *cpi, ThreadData *td,
rdc->comp_pred_diff[SINGLE_REFERENCE] += ctx->single_pred_diff;
rdc->comp_pred_diff[COMPOUND_REFERENCE] += ctx->comp_pred_diff;
rdc->comp_pred_diff[REFERENCE_MODE_SELECT] += ctx->hybrid_pred_diff;
-
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- rdc->filter_diff[i] += ctx->best_filter_diff[i];
}
for (h = 0; h < y_mis; ++h) {
@@ -1316,9 +1313,6 @@ static void update_state_supertx(VP10_COMP *cpi, ThreadData *td,
rdc->comp_pred_diff[SINGLE_REFERENCE] += ctx->single_pred_diff;
rdc->comp_pred_diff[COMPOUND_REFERENCE] += ctx->comp_pred_diff;
rdc->comp_pred_diff[REFERENCE_MODE_SELECT] += ctx->hybrid_pred_diff;
-
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- rdc->filter_diff[i] += ctx->best_filter_diff[i];
}
for (h = 0; h < y_mis; ++h) {
@@ -3962,7 +3956,6 @@ static void encode_frame_internal(VP10_COMP *cpi) {
vp10_zero(*td->counts);
vp10_zero(rdc->coef_counts);
vp10_zero(rdc->comp_pred_diff);
- vp10_zero(rdc->filter_diff);
rdc->m_search_count = 0; // Count of motion search hits.
rdc->ex_search_count = 0; // Exhaustive mesh search hits.
@@ -4030,31 +4023,9 @@ static void encode_frame_internal(VP10_COMP *cpi) {
cpi->last_frame_distortion = cpi->frame_distortion;
#endif
}
-
-static INTERP_FILTER get_interp_filter(
- const int64_t threshes[SWITCHABLE_FILTER_CONTEXTS], int is_alt_ref) {
-#if CONFIG_EXT_INTERP
- if (!is_alt_ref &&
- threshes[EIGHTTAP_SMOOTH2] > threshes[EIGHTTAP_SMOOTH] &&
- threshes[EIGHTTAP_SMOOTH2] > threshes[EIGHTTAP_REGULAR] &&
- threshes[EIGHTTAP_SMOOTH2] > threshes[MULTITAP_SHARP] &&
- threshes[EIGHTTAP_SMOOTH2] > threshes[SWITCHABLE - 1]) {
- return EIGHTTAP_SMOOTH2;
- }
-#endif // CONFIG_EXT_INTERP
- if (!is_alt_ref &&
- threshes[EIGHTTAP_SMOOTH] > threshes[EIGHTTAP_REGULAR] &&
- threshes[EIGHTTAP_SMOOTH] > threshes[MULTITAP_SHARP] &&
- threshes[EIGHTTAP_SMOOTH] > threshes[SWITCHABLE - 1]) {
- return EIGHTTAP_SMOOTH;
- } else if (threshes[MULTITAP_SHARP] > threshes[EIGHTTAP_REGULAR] &&
- threshes[MULTITAP_SHARP] > threshes[SWITCHABLE - 1]) {
- return MULTITAP_SHARP;
- } else if (threshes[EIGHTTAP_REGULAR] > threshes[SWITCHABLE - 1]) {
- return EIGHTTAP_REGULAR;
- } else {
- return SWITCHABLE;
- }
+static INTERP_FILTER get_cm_interp_filter(VP10_COMP *cpi) {
+ (void)cpi;
+ return SWITCHABLE;
}
void vp10_encode_frame(VP10_COMP *cpi) {
@@ -4107,7 +4078,6 @@ void vp10_encode_frame(VP10_COMP *cpi) {
// INTRA/ALTREF/GOLDEN/LAST needs to be specified seperately.
const MV_REFERENCE_FRAME frame_type = get_frame_type(cpi);
int64_t *const mode_thrs = rd_opt->prediction_type_threshes[frame_type];
- int64_t *const filter_thrs = rd_opt->filter_threshes[frame_type];
const int is_alt_ref = frame_type == ALTREF_FRAME;
/* prediction (compound, single or hybrid) mode selection */
@@ -4125,7 +4095,7 @@ void vp10_encode_frame(VP10_COMP *cpi) {
cm->reference_mode = REFERENCE_MODE_SELECT;
if (cm->interp_filter == SWITCHABLE) {
- cm->interp_filter = get_interp_filter(filter_thrs, is_alt_ref);
+ cm->interp_filter = get_cm_interp_filter(cpi);
}
encode_frame_internal(cpi);
@@ -4133,9 +4103,6 @@ void vp10_encode_frame(VP10_COMP *cpi) {
for (i = 0; i < REFERENCE_MODES; ++i)
mode_thrs[i] = (mode_thrs[i] + rdc->comp_pred_diff[i] / cm->MBs) / 2;
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- filter_thrs[i] = (filter_thrs[i] + rdc->filter_diff[i] / cm->MBs) / 2;
-
if (cm->reference_mode == REFERENCE_MODE_SELECT) {
int single_count_zero = 0;
int comp_count_zero = 0;
diff --git a/vp10/encoder/encoder.h b/vp10/encoder/encoder.h
index afe3292d37a3661eb808874082b7ad00b65f480d..a319901e22e1cdce3cfb953b91fce51a143bbf8b 100644
--- a/vp10/encoder/encoder.h
+++ b/vp10/encoder/encoder.h
@@ -251,7 +251,6 @@ typedef struct TileDataEnc {
typedef struct RD_COUNTS {
vp10_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
int64_t comp_pred_diff[REFERENCE_MODES];
- int64_t filter_diff[SWITCHABLE_FILTER_CONTEXTS];
int m_search_count;
int ex_search_count;
} RD_COUNTS;
diff --git a/vp10/encoder/ethread.c b/vp10/encoder/ethread.c
index 6cb9494a9b260911de6b792256aa17df3c4e5686..c586b9a1c4c936ec503d55cb6b90569a997ab7a5 100644
--- a/vp10/encoder/ethread.c
+++ b/vp10/encoder/ethread.c
@@ -19,9 +19,6 @@ static void accumulate_rd_opt(ThreadData *td, ThreadData *td_t) {
for (i = 0; i < REFERENCE_MODES; i++)
td->rd_counts.comp_pred_diff[i] += td_t->rd_counts.comp_pred_diff[i];
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
- td->rd_counts.filter_diff[i] += td_t->rd_counts.filter_diff[i];
-
for (i = 0; i < TX_SIZES; i++)
for (j = 0; j < PLANE_TYPES; j++)
for (k = 0; k < REF_TYPES; k++)
diff --git a/vp10/encoder/rd.h b/vp10/encoder/rd.h
index 5a6a44a99611e537f8b6a2795ca633bbedda66ea..61feabe974df8359d3440c83d78d26a8d2202e02 100644
--- a/vp10/encoder/rd.h
+++ b/vp10/encoder/rd.h
@@ -279,8 +279,6 @@ typedef struct RD_OPT {
int64_t prediction_type_threshes[MAX_REF_FRAMES][REFERENCE_MODES];
- int64_t filter_threshes[MAX_REF_FRAMES][SWITCHABLE_FILTER_CONTEXTS];
-
int RDMULT;
int RDDIV;
} RD_OPT;
diff --git a/vp10/encoder/rdopt.c b/vp10/encoder/rdopt.c
index 830761dbd4125c32cb24c5fcd6d4945e88008e64..16deebf0c7a2324fd60389c337820be8c514f567 100644
--- a/vp10/encoder/rdopt.c
+++ b/vp10/encoder/rdopt.c
@@ -5452,7 +5452,6 @@ static void estimate_ref_frame_costs(const VP10_COMMON *cm,
static void store_coding_context(MACROBLOCK *x, PICK_MODE_CONTEXT *ctx,
int mode_index,
int64_t comp_pred_diff[REFERENCE_MODES],
- int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS],
int skippable) {
MACROBLOCKD *const xd = &x->e_mbd;
@@ -5466,9 +5465,6 @@ static void store_coding_context(MACROBLOCK *x, PICK_MODE_CONTEXT *ctx,
ctx->single_pred_diff = (int)comp_pred_diff[SINGLE_REFERENCE];
ctx->comp_pred_diff = (int)comp_pred_diff[COMPOUND_REFERENCE];
ctx->hybrid_pred_diff = (int)comp_pred_diff[REFERENCE_MODE_SELECT];
-
- memcpy(ctx->best_filter_diff, best_filter_diff,
- sizeof(*best_filter_diff) * SWITCHABLE_FILTER_CONTEXTS);
}
static void setup_buffer_inter(
@@ -6036,9 +6032,7 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
INTERP_FILTER (*single_filter)[MAX_REF_FRAMES],
int (*single_skippable)[MAX_REF_FRAMES],
int64_t *psse,
- const int64_t ref_best_rd,
- int64_t *mask_filter,
- int64_t filter_cache[]) {
+ const int64_t ref_best_rd) {
VP10_COMMON *cm = &cpi->common;
MACROBLOCKD *xd = &x->e_mbd;
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
@@ -6381,11 +6375,6 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
if (is_comp_pred)
intpel_mv &= !mv_has_subpel(&mbmi->mv[1].as_mv);
- // Search for best switchable filter by checking the variance of
- // pred error irrespective of whether the filter will be used
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- filter_cache[i] = INT64_MAX;
-
best_filter = predict_interp_filter(cpi, x, bsize, mi_row, mi_col,
single_filter);
if (cm->interp_filter != BILINEAR && best_filter == SWITCHABLE) {
@@ -6405,12 +6394,8 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
if (i > 0 && intpel_mv && IsInterpolatingFilter(i)) {
rd = RDCOST(x->rdmult, x->rddiv, tmp_rate_sum, tmp_dist_sum);
- filter_cache[i] = rd;
- filter_cache[SWITCHABLE_FILTERS] =
- VPXMIN(filter_cache[SWITCHABLE_FILTERS], rd + rs_rd);
if (cm->interp_filter == SWITCHABLE)
rd += rs_rd;
- *mask_filter = VPXMAX(*mask_filter, rd);
} else {
int rate_sum = 0;
int64_t dist_sum = 0;
@@ -6442,12 +6427,8 @@ static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
&tmp_skip_sb, &tmp_skip_sse);
rd = RDCOST(x->rdmult, x->rddiv, rate_sum, dist_sum);
- filter_cache[i] = rd;
- filter_cache[SWITCHABLE_FILTERS] =
- VPXMIN(filter_cache[SWITCHABLE_FILTERS], rd + rs_rd);
if (cm->interp_filter == SWITCHABLE)
rd += rs_rd;
- *mask_filter = VPXMAX(*mask_filter, rd);
if (i == 0 && intpel_mv && IsInterpolatingFilter(i)) {
tmp_rate_sum = rate_sum;
@@ -7391,8 +7372,6 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
int64_t best_rd = best_rd_so_far;
int64_t best_pred_diff[REFERENCE_MODES];
int64_t best_pred_rd[REFERENCE_MODES];
- int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS];
- int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
MB_MODE_INFO best_mbmode;
int best_mode_skippable = 0;
int midx, best_mode_index = -1;
@@ -7430,8 +7409,6 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
int64_t mode_threshold[MAX_MODES];
int *mode_map = tile_data->mode_map[bsize];
const int mode_search_skip_flags = sf->mode_search_skip_flags;
- int64_t mask_filter = 0;
- int64_t filter_cache[SWITCHABLE_FILTER_CONTEXTS];
const TX_SIZE max_tx_size = max_txsize_lookup[bsize];
int palette_ctx = 0;
const int rows = 4 * num_4x4_blocks_high_lookup[bsize];
@@ -7487,16 +7464,11 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
sizeof(directional_mode_skip_mask[0]) * INTRA_MODES);
#endif // CONFIG_EXT_INTRA
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- filter_cache[i] = INT64_MAX;
-
estimate_ref_frame_costs(cm, xd, segment_id, ref_costs_single, ref_costs_comp,
&comp_mode_p);
for (i = 0; i < REFERENCE_MODES; ++i)
best_pred_rd[i] = INT64_MAX;
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
- best_filter_rd[i] = INT64_MAX;
for (i = 0; i < TX_SIZES; i++)
rate_uv_intra[i] = INT_MAX;
for (i = 0; i < MAX_REF_FRAMES; ++i)
@@ -8081,8 +8053,7 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
#endif // CONFIG_EXT_INTER
single_inter_filter,
single_skippable,
- &total_sse, best_rd,
- &mask_filter, filter_cache);
+ &total_sse, best_rd);
#if CONFIG_REF_MV
// TODO(jingning): This needs some refactoring to improve code quality
@@ -8130,12 +8101,10 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
clamp_mv2(&cur_mv.as_mv, xd);
if (!mv_check_bounds(x, &cur_mv.as_mv)) {
- int64_t dummy_filter_cache[SWITCHABLE_FILTER_CONTEXTS];
INTERP_FILTER dummy_single_inter_filter[MB_MODE_COUNT]
[MAX_REF_FRAMES];
int dummy_single_skippable[MB_MODE_COUNT][MAX_REF_FRAMES];
int dummy_disable_skip = 0;
- int64_t dummy_mask_filter = 0;
#if CONFIG_EXT_INTER
int_mv dummy_single_newmvs[2][MAX_REF_FRAMES] =
{ { { 0 } }, { { 0 } } };
@@ -8168,9 +8137,7 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
#endif
dummy_single_inter_filter,
dummy_single_skippable,
- &tmp_sse, best_rd,
- &dummy_mask_filter,
- dummy_filter_cache);
+ &tmp_sse, best_rd);
}
tmp_rate += cpi->drl_mode_cost0[drl0_ctx][1];
@@ -8312,8 +8279,6 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
if (!disable_skip && ref_frame == INTRA_FRAME) {
for (i = 0; i < REFERENCE_MODES; ++i)
best_pred_rd[i] = VPXMIN(best_pred_rd[i], this_rd);
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
- best_filter_rd[i] = VPXMIN(best_filter_rd[i], this_rd);
}
// Did this mode help.. i.e. is it the new best mode
@@ -8413,29 +8378,6 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
}
if (hybrid_rd < best_pred_rd[REFERENCE_MODE_SELECT])
best_pred_rd[REFERENCE_MODE_SELECT] = hybrid_rd;
-
- /* keep record of best filter type */
- if (!mode_excluded && cm->interp_filter != BILINEAR) {
- int64_t ref = filter_cache[cm->interp_filter == SWITCHABLE ?
- SWITCHABLE_FILTERS : cm->interp_filter];
-
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
- int64_t adj_rd;
- if (ref == INT64_MAX)
- adj_rd = 0;
- else if (filter_cache[i] == INT64_MAX)
- // when early termination is triggered, the encoder does not have
- // access to the rate-distortion cost. it only knows that the cost
- // should be above the maximum valid value. hence it takes the known
- // maximum plus an arbitrary constant as the rate-distortion cost.
- adj_rd = mask_filter - ref + 10;
- else
- adj_rd = filter_cache[i] - ref;
-
- adj_rd += this_rd;
- best_filter_rd[i] = VPXMIN(best_filter_rd[i], adj_rd);
- }
- }
}
if (early_term)
@@ -8730,21 +8672,6 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
best_pred_diff[i] = best_rd - best_pred_rd[i];
}
- if (!x->skip) {
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
- if (best_filter_rd[i] == INT64_MAX)
- best_filter_diff[i] = 0;
- else
- best_filter_diff[i] = best_rd - best_filter_rd[i];
- }
- if (cm->interp_filter == SWITCHABLE)
- assert(best_filter_diff[SWITCHABLE_FILTERS] == 0);
- } else {
- vp10_zero(best_filter_diff);
- }
-
- // TODO(yunqingwang): Moving this line in front of the above best_filter_diff
- // updating code causes PSNR loss. Need to figure out the confliction.
x->skip |= best_mode_skippable;
if (!x->skip && !x->select_tx_size) {
@@ -8768,7 +8695,7 @@ void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
assert(best_mode_index >= 0);
store_coding_context(x, ctx, best_mode_index, best_pred_diff,
- best_filter_diff, best_mode_skippable);
+ best_mode_skippable);
if (cm->allow_screen_content_tools && pmi->palette_size[1] > 0) {
restore_uv_color_map(cpi, x);
@@ -8789,7 +8716,6 @@ void vp10_rd_pick_inter_mode_sb_seg_skip(VP10_COMP *cpi,
const int comp_pred = 0;
int i;
int64_t best_pred_diff[REFERENCE_MODES];
- int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES];
vpx_prob comp_mode_p;
INTERP_FILTER best_filter = SWITCHABLE;
@@ -8874,12 +8800,11 @@ void vp10_rd_pick_inter_mode_sb_seg_skip(VP10_COMP *cpi,
cpi->sf.adaptive_rd_thresh, bsize, THR_ZEROMV);
vp10_zero(best_pred_diff);
- vp10_zero(best_filter_diff);
if (!x->select_tx_size)
swap_block_ptr(x, ctx, 1, 0, 0, MAX_MB_PLANE);
store_coding_context(x, ctx, THR_ZEROMV,
- best_pred_diff, best_filter_diff, 0);
+ best_pred_diff, 0);
}
void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
@@ -8919,8 +8844,6 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
int64_t best_yrd = best_rd_so_far; // FIXME(rbultje) more precise
int64_t best_pred_diff[REFERENCE_MODES];
int64_t best_pred_rd[REFERENCE_MODES];
- int64_t best_filter_rd[SWITCHABLE_FILTER_CONTEXTS];
- int64_t best_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
MB_MODE_INFO best_mbmode;
int ref_index, best_ref_index = 0;
unsigned int ref_costs_single[MAX_REF_FRAMES], ref_costs_comp[MAX_REF_FRAMES];
@@ -8940,8 +8863,6 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
b_mode_info best_bmodes[4];
int best_skip2 = 0;
int ref_frame_skip_mask[2] = { 0 };
- int64_t mask_filter = 0;
- int64_t filter_cache[SWITCHABLE_FILTER_CONTEXTS];
int internal_active_edge =
vp10_active_edge_sb(cpi, mi_row, mi_col) && vp10_internal_image_edge(cpi);
@@ -8965,9 +8886,6 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
mbmi->use_wedge_interintra = 0;
#endif // CONFIG_EXT_INTER
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- filter_cache[i] = INT64_MAX;
-
for (i = 0; i < 4; i++) {
int j;
#if CONFIG_EXT_INTER
@@ -8987,8 +8905,6 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
for (i = 0; i < REFERENCE_MODES; ++i)
best_pred_rd[i] = INT64_MAX;
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
- best_filter_rd[i] = INT64_MAX;
rate_uv_intra = INT_MAX;
rd_cost->rate = INT_MAX;
@@ -9246,8 +9162,6 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
#endif // CONFIG_EXT_REFS
this_rd_thresh = (ref_frame == GOLDEN_FRAME) ?
rd_opt->threshes[segment_id][bsize][THR_GOLD] : this_rd_thresh;
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- filter_cache[i] = INT64_MAX;
// TODO(any): Add search of the tx_type to improve rd performance at the
// expense of speed.
@@ -9291,14 +9205,9 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
continue;
rs = vp10_get_switchable_rate(cpi, xd);
rs_rd = RDCOST(x->rdmult, x->rddiv, rs, 0);
- filter_cache[switchable_filter_index] = tmp_rd;
- filter_cache[SWITCHABLE_FILTERS] =
- VPXMIN(filter_cache[SWITCHABLE_FILTERS], tmp_rd + rs_rd);
if (cm->interp_filter == SWITCHABLE)
tmp_rd += rs_rd;
- mask_filter = VPXMAX(mask_filter, tmp_rd);
-
newbest = (tmp_rd < tmp_best_rd);
if (newbest) {
tmp_best_filter = mbmi->interp_filter;
@@ -9470,8 +9379,6 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
if (!disable_skip && ref_frame == INTRA_FRAME) {
for (i = 0; i < REFERENCE_MODES; ++i)
best_pred_rd[i] = VPXMIN(best_pred_rd[i], this_rd);
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++)
- best_filter_rd[i] = VPXMIN(best_filter_rd[i], this_rd);
}
// Did this mode help.. i.e. is it the new best mode
@@ -9566,29 +9473,6 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
best_pred_rd[REFERENCE_MODE_SELECT] = hybrid_rd;
}
- /* keep record of best filter type */
- if (!mode_excluded && !disable_skip && ref_frame != INTRA_FRAME &&
- cm->interp_filter != BILINEAR) {
- int64_t ref = filter_cache[cm->interp_filter == SWITCHABLE ?
- SWITCHABLE_FILTERS : cm->interp_filter];
- int64_t adj_rd;
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
- if (ref == INT64_MAX)
- adj_rd = 0;
- else if (filter_cache[i] == INT64_MAX)
- // when early termination is triggered, the encoder does not have
- // access to the rate-distortion cost. it only knows that the cost
- // should be above the maximum valid value. hence it takes the known
- // maximum plus an arbitrary constant as the rate-distortion cost.
- adj_rd = mask_filter - ref + 10;
- else
- adj_rd = filter_cache[i] - ref;
-
- adj_rd += this_rd;
- best_filter_rd[i] = VPXMIN(best_filter_rd[i], adj_rd);
- }
- }
-
if (early_term)
break;
@@ -9660,21 +9544,8 @@ void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
best_pred_diff[i] = best_rd - best_pred_rd[i];
}
- if (!x->skip) {
- for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) {
- if (best_filter_rd[i] == INT64_MAX)
- best_filter_diff[i] = 0;
- else
- best_filter_diff[i] = best_rd - best_filter_rd[i];
- }
- if (cm->interp_filter == SWITCHABLE)
- assert(best_filter_diff[SWITCHABLE_FILTERS] == 0);
- } else {
- vp10_zero(best_filter_diff);
- }
-
store_coding_context(x, ctx, best_ref_index,
- best_pred_diff, best_filter_diff, 0);
+ best_pred_diff, 0);
}
#if CONFIG_OBMC