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 51dc7911c342b4ed8565381272111e0cbce27db2..96207af32a3b09287202c29f7391e03a8e23f2c6 100644 (file)
--- 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 5aa0947bdbd564fbe8943c71388ab7a278e66951..8dd088d3db211fcc8e9f777b7da3689ce68c9a13 100644 (file)
--- 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 e91ed00c4c34094244293e03fa025bee745d6de7..e0eca812ad59246916b4c1b0709524815658af1b 100644 (file)
--- 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;
         }
       }
     }