generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge "Select prediction filter type in non-RD mode decision"

Browse Source
This commit is contained in:
Jingning Han 2014-04-09 09:07:45 -07:00 committed by Gerrit Code Review
commit ae6485663a
4 changed files with 74 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
vp9/encoder/vp9_encodeframe.c
View File

@ -3360,8 +3360,7 @@ void vp9_encode_frame(VP9_COMP *cpi) {
} }
} else { } else {
cm->reference_mode = SINGLE_REFERENCE; cm->reference_mode = SINGLE_REFERENCE;
// Force the usage of the BILINEAR interp_filter. cm->interp_filter = SWITCHABLE;
cm->interp_filter = BILINEAR;
encode_frame_internal(cpi); encode_frame_internal(cpi);
} }
} }

67
vp9/encoder/vp9_pickmode.c
View File

@ -214,6 +214,7 @@ int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
struct macroblockd_plane *const pd = &xd->plane[0]; struct macroblockd_plane *const pd = &xd->plane[0];
MB_PREDICTION_MODE this_mode, best_mode = ZEROMV; MB_PREDICTION_MODE this_mode, best_mode = ZEROMV;
MV_REFERENCE_FRAME ref_frame, best_ref_frame = LAST_FRAME; MV_REFERENCE_FRAME ref_frame, best_ref_frame = LAST_FRAME;
INTERP_FILTER best_pred_filter = EIGHTTAP;
int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES]; int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES];
struct buf_2d yv12_mb[4][MAX_MB_PLANE]; struct buf_2d yv12_mb[4][MAX_MB_PLANE];
static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG,
@ -236,6 +237,7 @@ int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
const int *const rd_thresh_freq_fact = cpi->rd_thresh_freq_fact[bsize]; const int *const rd_thresh_freq_fact = cpi->rd_thresh_freq_fact[bsize];
// Mode index conversion form THR_MODES to MB_PREDICTION_MODE for a ref frame. // Mode index conversion form THR_MODES to MB_PREDICTION_MODE for a ref frame.
int mode_idx[MB_MODE_COUNT] = {0}; int mode_idx[MB_MODE_COUNT] = {0};
INTERP_FILTER filter_ref = SWITCHABLE;
x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH; x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH;
@ -267,6 +269,11 @@ int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
frame_mv[ZEROMV][ref_frame].as_int = 0; frame_mv[ZEROMV][ref_frame].as_int = 0;
} }
if (xd->up_available)
filter_ref = xd->mi[-xd->mi_stride]->mbmi.interp_filter;
else if (xd->left_available)
filter_ref = xd->mi[-1]->mbmi.interp_filter;
for (ref_frame = LAST_FRAME; ref_frame <= LAST_FRAME ; ++ref_frame) { for (ref_frame = LAST_FRAME; ref_frame <= LAST_FRAME ; ++ref_frame) {
if (!(cpi->ref_frame_flags & flag_list[ref_frame])) if (!(cpi->ref_frame_flags & flag_list[ref_frame]))
continue; continue;
@ -326,9 +333,63 @@ int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
mbmi->mode = this_mode; mbmi->mode = this_mode;
mbmi->mv[0].as_int = frame_mv[this_mode][ref_frame].as_int; mbmi->mv[0].as_int = frame_mv[this_mode][ref_frame].as_int;
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
model_rd_for_sb_y(cpi, bsize, x, xd, &rate, &dist); // Search for the best prediction filter type, when the resulting
// motion vector is at sub-pixel accuracy level for luma component, i.e.,
// the last three bits are all zeros.
if ((this_mode == NEWMV || filter_ref == SWITCHABLE) &&
((mbmi->mv[0].as_mv.row & 0x07) != 0 ||
(mbmi->mv[0].as_mv.col & 0x07) != 0)) {
int64_t tmp_rdcost1 = INT64_MAX;
int64_t tmp_rdcost2 = INT64_MAX;
int64_t tmp_rdcost3 = INT64_MAX;
int pf_rate[3];
int64_t pf_dist[3];
mbmi->interp_filter = EIGHTTAP;
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[EIGHTTAP],
&pf_dist[EIGHTTAP]);
tmp_rdcost1 = RDCOST(x->rdmult, x->rddiv,
vp9_get_switchable_rate(x) + pf_rate[EIGHTTAP],
pf_dist[EIGHTTAP]);
mbmi->interp_filter = EIGHTTAP_SHARP;
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[EIGHTTAP_SHARP],
&pf_dist[EIGHTTAP_SHARP]);
tmp_rdcost2 = RDCOST(x->rdmult, x->rddiv,
vp9_get_switchable_rate(x) + pf_rate[EIGHTTAP_SHARP],
pf_dist[EIGHTTAP_SHARP]);
mbmi->interp_filter = EIGHTTAP_SMOOTH;
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[EIGHTTAP_SMOOTH],
&pf_dist[EIGHTTAP_SMOOTH]);
tmp_rdcost3 = RDCOST(x->rdmult, x->rddiv,
vp9_get_switchable_rate(x) + pf_rate[EIGHTTAP_SMOOTH],
pf_dist[EIGHTTAP_SMOOTH]);
if (tmp_rdcost2 < tmp_rdcost1) {
if (tmp_rdcost2 < tmp_rdcost3)
mbmi->interp_filter = EIGHTTAP_SHARP;
else
mbmi->interp_filter = EIGHTTAP_SMOOTH;
} else {
if (tmp_rdcost1 < tmp_rdcost3)
mbmi->interp_filter = EIGHTTAP;
else
mbmi->interp_filter = EIGHTTAP_SMOOTH;
}
rate = pf_rate[mbmi->interp_filter];
dist = pf_dist[mbmi->interp_filter];
} else {
mbmi->interp_filter = (filter_ref == SWITCHABLE) ? EIGHTTAP: filter_ref;
vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize);
model_rd_for_sb_y(cpi, bsize, x, xd, &rate, &dist);
}
rate += rate_mv; rate += rate_mv;
rate += x->inter_mode_cost[mbmi->mode_context[ref_frame]] rate += x->inter_mode_cost[mbmi->mode_context[ref_frame]]
[INTER_OFFSET(this_mode)]; [INTER_OFFSET(this_mode)];
@ -339,12 +400,14 @@ int64_t vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
*returnrate = rate; *returnrate = rate;
*returndistortion = dist; *returndistortion = dist;
best_mode = this_mode; best_mode = this_mode;
best_pred_filter = mbmi->interp_filter;
best_ref_frame = ref_frame; best_ref_frame = ref_frame;
} }
} }
} }
mbmi->mode = best_mode; mbmi->mode = best_mode;
mbmi->interp_filter = best_pred_filter;
mbmi->ref_frame[0] = best_ref_frame; mbmi->ref_frame[0] = best_ref_frame;
mbmi->mv[0].as_int = frame_mv[best_mode][best_ref_frame].as_int; mbmi->mv[0].as_int = frame_mv[best_mode][best_ref_frame].as_int;
xd->mi[0]->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int; xd->mi[0]->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int;

12
vp9/encoder/vp9_rdopt.c
View File

@ -2358,7 +2358,7 @@ const YV12_BUFFER_CONFIG *vp9_get_scaled_ref_frame(const VP9_COMP *cpi,
return (scaled_idx != ref_idx) ? &cm->frame_bufs[scaled_idx].buf : NULL; return (scaled_idx != ref_idx) ? &cm->frame_bufs[scaled_idx].buf : NULL;
} }
static INLINE int get_switchable_rate(const MACROBLOCK *x) { int vp9_get_switchable_rate(const MACROBLOCK *x) {
const MACROBLOCKD *const xd = &x->e_mbd; const MACROBLOCKD *const xd = &x->e_mbd;
const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi; const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
const int ctx = vp9_get_pred_context_switchable_interp(xd); const int ctx = vp9_get_pred_context_switchable_interp(xd);
@ -2815,7 +2815,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
int j; int j;
int64_t rs_rd; int64_t rs_rd;
mbmi->interp_filter = i; mbmi->interp_filter = i;
rs = get_switchable_rate(x); rs = vp9_get_switchable_rate(x);
rs_rd = RDCOST(x->rdmult, x->rddiv, rs, 0); rs_rd = RDCOST(x->rdmult, x->rddiv, rs, 0);
if (i > 0 && intpel_mv) { if (i > 0 && intpel_mv) {
@ -2885,7 +2885,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
// Set the appropriate filter // Set the appropriate filter
mbmi->interp_filter = cm->interp_filter != SWITCHABLE ? mbmi->interp_filter = cm->interp_filter != SWITCHABLE ?
cm->interp_filter : *best_filter; cm->interp_filter : *best_filter;
rs = cm->interp_filter == SWITCHABLE ? get_switchable_rate(x) : 0; rs = cm->interp_filter == SWITCHABLE ? vp9_get_switchable_rate(x) : 0;
if (pred_exists) { if (pred_exists) {
if (best_needs_copy) { if (best_needs_copy) {
@ -2915,7 +2915,7 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
} }
if (cm->interp_filter == SWITCHABLE) if (cm->interp_filter == SWITCHABLE)
*rate2 += get_switchable_rate(x); *rate2 += vp9_get_switchable_rate(x);
if (!is_comp_pred) { if (!is_comp_pred) {
if (!x->in_active_map) { if (!x->in_active_map) {
@ -4072,7 +4072,7 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
if (tmp_rd == INT64_MAX) if (tmp_rd == INT64_MAX)
continue; continue;
rs = get_switchable_rate(x); rs = vp9_get_switchable_rate(x);
rs_rd = RDCOST(x->rdmult, x->rddiv, rs, 0); rs_rd = RDCOST(x->rdmult, x->rddiv, rs, 0);
cpi->rd_filter_cache[switchable_filter_index] = tmp_rd; cpi->rd_filter_cache[switchable_filter_index] = tmp_rd;
cpi->rd_filter_cache[SWITCHABLE_FILTERS] = cpi->rd_filter_cache[SWITCHABLE_FILTERS] =
@ -4153,7 +4153,7 @@ int64_t vp9_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
distortion2 += distortion; distortion2 += distortion;
if (cm->interp_filter == SWITCHABLE) if (cm->interp_filter == SWITCHABLE)
rate2 += get_switchable_rate(x); rate2 += vp9_get_switchable_rate(x);
if (!mode_excluded) if (!mode_excluded)
mode_excluded = comp_pred ? cm->reference_mode == SINGLE_REFERENCE mode_excluded = comp_pred ? cm->reference_mode == SINGLE_REFERENCE

2
vp9/encoder/vp9_rdopt.h
View File

@ -40,6 +40,8 @@ void vp9_model_rd_from_var_lapndz(unsigned int var, unsigned int n,
unsigned int qstep, int *rate, unsigned int qstep, int *rate,
int64_t *dist); int64_t *dist);
int vp9_get_switchable_rate(const MACROBLOCK *x);
void vp9_setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x, void vp9_setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x,
const TileInfo *const tile, const TileInfo *const tile,
MV_REFERENCE_FRAME ref_frame, MV_REFERENCE_FRAME ref_frame,