From: Paul Wilkins Date: Tue, 2 Jul 2013 11:34:41 +0000 (+0100) Subject: Revert "New motion threshold factor - speed feature." X-Git-Tag: v1.3.0~969 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=b7cd01ed7375b1e5b6dc67f7427d07298f244471;p=libvpx Revert "New motion threshold factor - speed feature." This reverts commit 13772781807ebff8b5c7d100e90d0eac6c61cbd4. Also fixes a spelling mistake. Change-Id: I5be8aa4d8d3c0323d4a6f41968a7b2c048949c3f --- diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c index 51dc7911c..96207af32 100644 --- a/vp9/encoder/vp9_onyx_if.c +++ b/vp9/encoder/vp9_onyx_if.c @@ -536,9 +536,7 @@ static void set_default_lf_deltas(VP9_COMP *cpi) { static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode, int speed) { SPEED_FEATURES *sf = &cpi->sf; - int speed_multiplier = (cpi->sf.adjust_thresholds_by_speed) ? speed + 1 : 1; - int new_motion_multiplier = speed_multiplier * - (sf->new_motion_thresh_factor + 1); + int speed_multiplier = speed + 1; int i; // Set baseline threshold values @@ -557,20 +555,26 @@ static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode, int speed) { sf->thresh_mult[THR_NEARG] += speed_multiplier * 1000; sf->thresh_mult[THR_NEARA] += speed_multiplier * 1000; - sf->thresh_mult[THR_DC] += speed_multiplier * 1000; + sf->thresh_mult[THR_DC ] = 0; sf->thresh_mult[THR_TM] += speed_multiplier * 1000; - sf->thresh_mult[THR_V_PRED] += speed_multiplier * 1500; - sf->thresh_mult[THR_H_PRED] += speed_multiplier * 1500; - sf->thresh_mult[THR_D45_PRED] += speed_multiplier * 2000; - sf->thresh_mult[THR_D135_PRED] += speed_multiplier * 2000; - sf->thresh_mult[THR_D117_PRED] += speed_multiplier * 2000; - sf->thresh_mult[THR_D153_PRED] += speed_multiplier * 2000; - sf->thresh_mult[THR_D27_PRED] += speed_multiplier * 2000; - sf->thresh_mult[THR_D63_PRED] += speed_multiplier * 2000; - - sf->thresh_mult[THR_NEWMV] += new_motion_multiplier * 1000; - sf->thresh_mult[THR_NEWG] += new_motion_multiplier * 1000; - sf->thresh_mult[THR_NEWA] += new_motion_multiplier * 1000; + sf->thresh_mult[THR_V_PRED ] += speed_multiplier * 1000; + sf->thresh_mult[THR_H_PRED ] += speed_multiplier * 1000; + sf->thresh_mult[THR_D45_PRED ] += speed_multiplier * 1500; + sf->thresh_mult[THR_D135_PRED] += speed_multiplier * 1500; + sf->thresh_mult[THR_D117_PRED] += speed_multiplier * 1500; + sf->thresh_mult[THR_D153_PRED] += speed_multiplier * 1500; + sf->thresh_mult[THR_D27_PRED ] += speed_multiplier * 1500; + sf->thresh_mult[THR_D63_PRED ] += speed_multiplier * 1500; + + sf->thresh_mult[THR_B_PRED ] += speed_multiplier * 2500; + + sf->thresh_mult[THR_NEWMV ] += speed_multiplier * 1000; + sf->thresh_mult[THR_NEWG ] += speed_multiplier * 1000; + sf->thresh_mult[THR_NEWA ] += speed_multiplier * 1000; + + sf->thresh_mult[THR_SPLITMV ] += speed_multiplier * 2500; + sf->thresh_mult[THR_SPLITG ] += speed_multiplier * 2500; + sf->thresh_mult[THR_SPLITA ] += speed_multiplier * 2500; sf->thresh_mult[THR_COMP_ZEROLA] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_ZEROGA] += speed_multiplier * 1500; @@ -581,13 +585,11 @@ static void set_rd_speed_thresholds(VP9_COMP *cpi, int mode, int speed) { sf->thresh_mult[THR_COMP_NEARLA] += speed_multiplier * 1500; sf->thresh_mult[THR_COMP_NEARGA] += speed_multiplier * 1500; - sf->thresh_mult[THR_COMP_NEWLA] += new_motion_multiplier * 2000; - sf->thresh_mult[THR_COMP_NEWGA] += new_motion_multiplier * 2000; - - sf->thresh_mult[THR_B_PRED] += speed_multiplier * 2500; + sf->thresh_mult[THR_COMP_NEWLA ] += speed_multiplier * 2000; + sf->thresh_mult[THR_COMP_NEWGA ] += speed_multiplier * 2000; - sf->thresh_mult[THR_SPLITMV] += new_motion_multiplier * 2500; - sf->thresh_mult[THR_SPLITG] += new_motion_multiplier * 2500; + sf->thresh_mult[THR_COMP_SPLITLA ] += speed_multiplier * 4500; + sf->thresh_mult[THR_COMP_SPLITGA ] += speed_multiplier * 4500; if (cpi->sf.skip_lots_of_modes) { for (i = 0; i < MAX_MODES; ++i) @@ -688,9 +690,7 @@ void vp9_set_speed_features(VP9_COMP *cpi) { sf->auto_mv_step_size = 0; sf->max_step_search_steps = MAX_MVSEARCH_STEPS; sf->comp_inter_joint_search_thresh = BLOCK_SIZE_AB4X4; - sf->adpative_rd_thresh = 0; - sf->adjust_thresholds_by_speed = 0; - sf->new_motion_thresh_factor = 0; + sf->adaptive_rd_thresh = 0; sf->use_lastframe_partitioning = 0; sf->use_largest_txform = 0; sf->use_8tap_always = 0; @@ -726,12 +726,13 @@ void vp9_set_speed_features(VP9_COMP *cpi) { #else sf->static_segmentation = 0; #endif - sf->use_avoid_tested_higherror = 1; + sf->comp_inter_joint_search_thresh = BLOCK_SIZE_MB16X16; sf->auto_mv_step_size = 1; - sf->adpative_rd_thresh = 1; + sf->use_avoid_tested_higherror = 1; + sf->adaptive_rd_thresh = 1; + if (speed == 1) { sf->comp_inter_joint_search_thresh = BLOCK_SIZE_TYPES; - sf->new_motion_thresh_factor = 1; sf->less_rectangular_check = 1; sf->use_largest_txform = !(cpi->common.frame_type == KEY_FRAME || cpi->common.intra_only || diff --git a/vp9/encoder/vp9_onyx_int.h b/vp9/encoder/vp9_onyx_int.h index 5aa0947bd..8dd088d3d 100644 --- a/vp9/encoder/vp9_onyx_int.h +++ b/vp9/encoder/vp9_onyx_int.h @@ -216,15 +216,14 @@ typedef struct { int search_best_filter; int static_segmentation; int comp_inter_joint_search_thresh; + int adaptive_rd_thresh; int skip_encode_sb; int use_lastframe_partitioning; int use_largest_txform; int use_8tap_always; int use_avoid_tested_higherror; int skip_lots_of_modes; - int adpative_rd_thresh; int adjust_thresholds_by_speed; - int new_motion_thresh_factor; int partition_by_variance; int use_one_partition_size_always; int less_rectangular_check; diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c index e91ed00c4..e0eca812a 100644 --- a/vp9/encoder/vp9_rdopt.c +++ b/vp9/encoder/vp9_rdopt.c @@ -54,20 +54,20 @@ DECLARE_ALIGNED(16, extern const uint8_t, const MODE_DEFINITION vp9_mode_order[MAX_MODES] = { {ZEROMV, LAST_FRAME, NONE}, + {DC_PRED, INTRA_FRAME, NONE}, + {NEARESTMV, LAST_FRAME, NONE}, {NEARMV, LAST_FRAME, NONE}, - {ZEROMV, ALTREF_FRAME, NONE}, - {NEARESTMV, ALTREF_FRAME, NONE}, - {ZEROMV, GOLDEN_FRAME, NONE}, {NEARESTMV, GOLDEN_FRAME, NONE}, + {ZEROMV, ALTREF_FRAME, NONE}, + {NEARESTMV, ALTREF_FRAME, NONE}, + {NEARMV, GOLDEN_FRAME, NONE}, {NEARMV, ALTREF_FRAME, NONE}, - {DC_PRED, INTRA_FRAME, NONE}, - {TM_PRED, INTRA_FRAME, NONE}, {V_PRED, INTRA_FRAME, NONE}, {H_PRED, INTRA_FRAME, NONE}, {D45_PRED, INTRA_FRAME, NONE}, @@ -77,10 +77,18 @@ const MODE_DEFINITION vp9_mode_order[MAX_MODES] = { {D27_PRED, INTRA_FRAME, NONE}, {D63_PRED, INTRA_FRAME, NONE}, + {TM_PRED, INTRA_FRAME, NONE}, + {NEWMV, LAST_FRAME, NONE}, {NEWMV, GOLDEN_FRAME, NONE}, {NEWMV, ALTREF_FRAME, NONE}, + {SPLITMV, LAST_FRAME, NONE}, + {SPLITMV, GOLDEN_FRAME, NONE}, + {SPLITMV, ALTREF_FRAME, NONE}, + + {I4X4_PRED, INTRA_FRAME, NONE}, + /* compound prediction modes */ {ZEROMV, LAST_FRAME, ALTREF_FRAME}, {NEARESTMV, LAST_FRAME, ALTREF_FRAME}, @@ -93,12 +101,8 @@ const MODE_DEFINITION vp9_mode_order[MAX_MODES] = { {NEWMV, LAST_FRAME, ALTREF_FRAME}, {NEWMV, GOLDEN_FRAME, ALTREF_FRAME}, - {SPLITMV, LAST_FRAME, NONE}, - {SPLITMV, GOLDEN_FRAME, NONE}, - {SPLITMV, ALTREF_FRAME, NONE}, {SPLITMV, LAST_FRAME, ALTREF_FRAME}, {SPLITMV, GOLDEN_FRAME, ALTREF_FRAME}, - {I4X4_PRED, INTRA_FRAME, NONE}, }; // The baseline rd thresholds for breaking out of the rd loop for @@ -223,7 +227,7 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) { } cpi->rd_baseline_thresh[bsize][i] = cpi->rd_threshes[bsize][i]; - if (cpi->sf.adpative_rd_thresh) + if (cpi->sf.adaptive_rd_thresh) cpi->rd_thresh_freq_fact[bsize][i] = MAX_RD_THRESH_FREQ_FACT; else cpi->rd_thresh_freq_fact[bsize][i] = BASE_RD_THRESH_FREQ_FACT; @@ -247,7 +251,7 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi, int qindex) { } cpi->rd_baseline_thresh[bsize][i] = cpi->rd_threshes[bsize][i]; - if (cpi->sf.adpative_rd_thresh) + if (cpi->sf.adaptive_rd_thresh) cpi->rd_thresh_freq_fact[bsize][i] = MAX_RD_THRESH_FREQ_FACT; else cpi->rd_thresh_freq_fact[bsize][i] = BASE_RD_THRESH_FREQ_FACT; @@ -3284,16 +3288,16 @@ int64_t vp9_rd_pick_inter_mode_sb(VP9_COMP *cpi, MACROBLOCK *x, // choice for the current partition. It may well be better to keep a scaled // best rd so far value and update rd_thresh_freq_fact based on the mode/size // combination that wins out. - if (cpi->sf.adpative_rd_thresh) { + if (cpi->sf.adaptive_rd_thresh) { for (mode_index = 0; mode_index < MAX_MODES; ++mode_index) { if (mode_index == best_mode_index) { cpi->rd_thresh_freq_fact[bsize][mode_index] = BASE_RD_THRESH_FREQ_FACT; } else { cpi->rd_thresh_freq_fact[bsize][mode_index] += MAX_RD_THRESH_FREQ_INC; if (cpi->rd_thresh_freq_fact[bsize][mode_index] > - (cpi->sf.adpative_rd_thresh * MAX_RD_THRESH_FREQ_FACT)) { + (cpi->sf.adaptive_rd_thresh * MAX_RD_THRESH_FREQ_FACT)) { cpi->rd_thresh_freq_fact[bsize][mode_index] = - cpi->sf.adpative_rd_thresh * MAX_RD_THRESH_FREQ_FACT; + cpi->sf.adaptive_rd_thresh * MAX_RD_THRESH_FREQ_FACT; } } }