diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 44992c4..1c3038d 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -5915,9 +5915,9 @@
           ? WINNER_MODE_EVAL
           : DEFAULT_EVAL;
   const TX_SIZE_SEARCH_METHOD tx_search_type =
-      cpi->tx_size_search_methods[eval_type];
+      cpi->winner_mode_params.tx_size_search_methods[eval_type];
   assert(cpi->oxcf.enable_tx64 || tx_search_type != USE_LARGESTALL);
-  features->tx_mode = select_tx_mode(cpi, tx_search_type);
+  features->tx_mode = select_tx_mode(cm, tx_search_type);
 
   if (cpi->sf.tx_sf.tx_type_search.prune_tx_type_using_stats) {
     const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group);
@@ -6288,7 +6288,8 @@
 
   // Initialize tx_mode and tx_size_search_method
   set_tx_size_search_method(
-      cpi, x, cpi->sf.winner_mode_sf.enable_winner_mode_for_tx_size_srch, 1);
+      cm, &cpi->winner_mode_params, x,
+      cpi->sf.winner_mode_sf.enable_winner_mode_for_tx_size_srch, 1);
 
   const int mi_row = xd->mi_row;
   const int mi_col = xd->mi_col;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 06c093a..539bd35 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -858,6 +858,47 @@
 } MotionVectorSearchParams;
 
 typedef struct {
+  // Threshold of transform domain distortion
+  // Index 0: Default mode evaluation, Winner mode processing is not applicable
+  // (Eg : IntraBc).
+  // Index 1: Mode evaluation.
+  // Index 2: Winner mode evaluation.
+  // Index 1 and 2 are applicable when enable_winner_mode_for_use_tx_domain_dist
+  // speed feature is ON
+  unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
+
+  // Factor to control R-D optimization of coeffs based on block
+  // mse.
+  // Index 0: Default mode evaluation, Winner mode processing is not applicable
+  // (Eg : IntraBc). Index 1: Mode evaluation.
+  // Index 2: Winner mode evaluation
+  // Index 1 and 2 are applicable when enable_winner_mode_for_coeff_opt speed
+  // feature is ON
+  unsigned int coeff_opt_dist_threshold[MODE_EVAL_TYPES];
+
+  // Transform size to be used in transform search
+  // Index 0: Default mode evaluation, Winner mode processing is not applicable
+  // (Eg : IntraBc).
+  // Index 1: Mode evaluation. Index 2: Winner mode evaluation
+  // Index 1 and 2 are applicable when enable_winner_mode_for_tx_size_srch speed
+  // feature is ON
+  TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
+
+  // Transform domain distortion levels
+  // Index 0: Default mode evaluation, Winner mode processing is not applicable
+  // (Eg : IntraBc).
+  // Index 1: Mode evaluation. Index 2: Winner mode evaluation
+  // Index 1 and 2 are applicable when enable_winner_mode_for_use_tx_domain_dist
+  // speed feature is ON
+  unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
+
+  // Predict transform skip levels to be used for default, mode and winner mode
+  // evaluation. Index 0: Default mode evaluation, Winner mode processing is not
+  // applicable. Index 1: Mode evaluation, Index 2: Winner mode evaluation
+  unsigned int predict_skip_level[MODE_EVAL_TYPES];
+} WinnerModeParams;
+
+typedef struct {
   int arf_stack[FRAME_BUFFERS];
   int arf_stack_size;
   int lst_stack[FRAME_BUFFERS];
@@ -987,6 +1028,9 @@
   // Parameters related to global motion search.
   GlobalMotionInfo gm_info;
 
+  // Parameters related to winner mode processing.
+  WinnerModeParams winner_mode_params;
+
   int64_t last_time_stamp_seen;
   int64_t last_end_time_stamp_seen;
   int64_t first_time_stamp_ever;
@@ -1132,45 +1176,6 @@
   // Mark which ref frames can be skipped for encoding current frame druing RDO.
   int prune_ref_frame_mask;
 
-  // Threshold of transform domain distortion
-  // Index 0: Default mode evaluation, Winner mode processing is not applicable
-  // (Eg : IntraBc).
-  // Index 1: Mode evaluation.
-  // Index 2: Winner mode evaluation.
-  // Index 1 and 2 are applicable when enable_winner_mode_for_use_tx_domain_dist
-  // speed feature is ON
-  unsigned int tx_domain_dist_threshold[MODE_EVAL_TYPES];
-
-  // Factor to control R-D optimization of coeffs based on block
-  // mse.
-  // Index 0: Default mode evaluation, Winner mode processing is not applicable
-  // (Eg : IntraBc). Index 1: Mode evaluation.
-  // Index 2: Winner mode evaluation
-  // Index 1 and 2 are applicable when enable_winner_mode_for_coeff_opt speed
-  // feature is ON
-  unsigned int coeff_opt_dist_threshold[MODE_EVAL_TYPES];
-
-  // Transform size to be used in transform search
-  // Index 0: Default mode evaluation, Winner mode processing is not applicable
-  // (Eg : IntraBc).
-  // Index 1: Mode evaluation. Index 2: Winner mode evaluation
-  // Index 1 and 2 are applicable when enable_winner_mode_for_tx_size_srch speed
-  // feature is ON
-  TX_SIZE_SEARCH_METHOD tx_size_search_methods[MODE_EVAL_TYPES];
-
-  // Transform domain distortion levels
-  // Index 0: Default mode evaluation, Winner mode processing is not applicable
-  // (Eg : IntraBc).
-  // Index 1: Mode evaluation. Index 2: Winner mode evaluation
-  // Index 1 and 2 are applicable when enable_winner_mode_for_use_tx_domain_dist
-  // speed feature is ON
-  unsigned int use_transform_domain_distortion[MODE_EVAL_TYPES];
-
-  // Predict transform skip levels to be used for default, mode and winner mode
-  // evaluation. Index 0: Default mode evaluation, Winner mode processing is not
-  // applicable. Index 1: Mode evaluation, Index 2: Winner mode evaluation
-  unsigned int predict_skip_level[MODE_EVAL_TYPES];
-
   AV1LfSync lf_row_sync;
   AV1LrSync lr_row_sync;
   AV1LrStruct lr_ctxt;
diff --git a/av1/encoder/rdopt_utils.h b/av1/encoder/rdopt_utils.h
index 9c4f5899..53b410a 100644
--- a/av1/encoder/rdopt_utils.h
+++ b/av1/encoder/rdopt_utils.h
@@ -364,8 +364,8 @@
 }
 
 static TX_MODE select_tx_mode(
-    const AV1_COMP *cpi, const TX_SIZE_SEARCH_METHOD tx_size_search_method) {
-  if (cpi->common.features.coded_lossless) return ONLY_4X4;
+    const AV1_COMMON *cm, const TX_SIZE_SEARCH_METHOD tx_size_search_method) {
+  if (cm->features.coded_lossless) return ONLY_4X4;
   if (tx_size_search_method == USE_LARGESTALL) {
     return TX_MODE_LARGEST;
   } else {
@@ -403,17 +403,21 @@
 }
 
 static INLINE void set_tx_size_search_method(
-    const struct AV1_COMP *cpi, MACROBLOCK *x,
-    int enable_winner_mode_for_tx_size_srch, int is_winner_mode) {
+    const AV1_COMMON *cm, const WinnerModeParams *winner_mode_params,
+    MACROBLOCK *x, int enable_winner_mode_for_tx_size_srch,
+    int is_winner_mode) {
   // Populate transform size search method/transform mode appropriately
-  x->tx_size_search_method = cpi->tx_size_search_methods[DEFAULT_EVAL];
+  x->tx_size_search_method =
+      winner_mode_params->tx_size_search_methods[DEFAULT_EVAL];
   if (enable_winner_mode_for_tx_size_srch) {
     if (is_winner_mode)
-      x->tx_size_search_method = cpi->tx_size_search_methods[WINNER_MODE_EVAL];
+      x->tx_size_search_method =
+          winner_mode_params->tx_size_search_methods[WINNER_MODE_EVAL];
     else
-      x->tx_size_search_method = cpi->tx_size_search_methods[MODE_EVAL];
+      x->tx_size_search_method =
+          winner_mode_params->tx_size_search_methods[MODE_EVAL];
   }
-  x->tx_mode_search_type = select_tx_mode(cpi, x->tx_size_search_method);
+  x->tx_mode_search_type = select_tx_mode(cm, x->tx_size_search_method);
 }
 
 static INLINE void set_tx_type_prune(const SPEED_FEATURES *sf, MACROBLOCK *x,
@@ -430,24 +434,26 @@
 }
 
 static INLINE void set_tx_domain_dist_params(
-    const struct AV1_COMP *cpi, MACROBLOCK *x,
+    const WinnerModeParams *winner_mode_params, MACROBLOCK *x,
     int enable_winner_mode_for_tx_domain_dist, int is_winner_mode) {
   if (!enable_winner_mode_for_tx_domain_dist) {
     x->use_transform_domain_distortion =
-        cpi->use_transform_domain_distortion[DEFAULT_EVAL];
-    x->tx_domain_dist_threshold = cpi->tx_domain_dist_threshold[DEFAULT_EVAL];
+        winner_mode_params->use_transform_domain_distortion[DEFAULT_EVAL];
+    x->tx_domain_dist_threshold =
+        winner_mode_params->tx_domain_dist_threshold[DEFAULT_EVAL];
     return;
   }
 
   if (is_winner_mode) {
     x->use_transform_domain_distortion =
-        cpi->use_transform_domain_distortion[WINNER_MODE_EVAL];
+        winner_mode_params->use_transform_domain_distortion[WINNER_MODE_EVAL];
     x->tx_domain_dist_threshold =
-        cpi->tx_domain_dist_threshold[WINNER_MODE_EVAL];
+        winner_mode_params->tx_domain_dist_threshold[WINNER_MODE_EVAL];
   } else {
     x->use_transform_domain_distortion =
-        cpi->use_transform_domain_distortion[MODE_EVAL];
-    x->tx_domain_dist_threshold = cpi->tx_domain_dist_threshold[MODE_EVAL];
+        winner_mode_params->use_transform_domain_distortion[MODE_EVAL];
+    x->tx_domain_dist_threshold =
+        winner_mode_params->tx_domain_dist_threshold[MODE_EVAL];
   }
 }
 
@@ -455,21 +461,24 @@
 static INLINE void set_mode_eval_params(const struct AV1_COMP *cpi,
                                         MACROBLOCK *x,
                                         MODE_EVAL_TYPE mode_eval_type) {
+  const AV1_COMMON *cm = &cpi->common;
   const SPEED_FEATURES *sf = &cpi->sf;
+  const WinnerModeParams *winner_mode_params = &cpi->winner_mode_params;
 
   switch (mode_eval_type) {
     case DEFAULT_EVAL:
       x->use_default_inter_tx_type = 0;
       x->use_default_intra_tx_type = 0;
-      x->predict_skip_level = cpi->predict_skip_level[DEFAULT_EVAL];
+      x->predict_skip_level =
+          winner_mode_params->predict_skip_level[DEFAULT_EVAL];
       // Set default transform domain distortion type
-      set_tx_domain_dist_params(cpi, x, 0, 0);
+      set_tx_domain_dist_params(winner_mode_params, x, 0, 0);
 
       // Get default threshold for R-D optimization of coefficients
-      x->coeff_opt_dist_threshold =
-          get_rd_opt_coeff_thresh(cpi->coeff_opt_dist_threshold, 0, 0);
+      x->coeff_opt_dist_threshold = get_rd_opt_coeff_thresh(
+          winner_mode_params->coeff_opt_dist_threshold, 0, 0);
       // Set default transform size search method
-      set_tx_size_search_method(cpi, x, 0, 0);
+      set_tx_size_search_method(cm, winner_mode_params, x, 0, 0);
       // Set default transform type prune
       set_tx_type_prune(sf, x, 0, 0);
       break;
@@ -479,21 +488,22 @@
            cpi->oxcf.use_intra_default_tx_only);
       x->use_default_inter_tx_type =
           cpi->sf.tx_sf.tx_type_search.fast_inter_tx_type_search;
-      x->predict_skip_level = cpi->predict_skip_level[MODE_EVAL];
+      x->predict_skip_level = winner_mode_params->predict_skip_level[MODE_EVAL];
 
       // Set transform domain distortion type for mode evaluation
       set_tx_domain_dist_params(
-          cpi, x, sf->winner_mode_sf.enable_winner_mode_for_use_tx_domain_dist,
-          0);
+          winner_mode_params, x,
+          sf->winner_mode_sf.enable_winner_mode_for_use_tx_domain_dist, 0);
 
       // Get threshold for R-D optimization of coefficients during mode
       // evaluation
       x->coeff_opt_dist_threshold = get_rd_opt_coeff_thresh(
-          cpi->coeff_opt_dist_threshold,
+          winner_mode_params->coeff_opt_dist_threshold,
           sf->winner_mode_sf.enable_winner_mode_for_coeff_opt, 0);
       // Set the transform size search method for mode evaluation
       set_tx_size_search_method(
-          cpi, x, sf->winner_mode_sf.enable_winner_mode_for_tx_size_srch, 0);
+          cm, winner_mode_params, x,
+          sf->winner_mode_sf.enable_winner_mode_for_tx_size_srch, 0);
       // Set transform type prune for mode evaluation
       set_tx_type_prune(
           sf, x, sf->tx_sf.tx_type_search.enable_winner_mode_tx_type_pruning,
@@ -502,21 +512,23 @@
     case WINNER_MODE_EVAL:
       x->use_default_inter_tx_type = 0;
       x->use_default_intra_tx_type = 0;
-      x->predict_skip_level = cpi->predict_skip_level[WINNER_MODE_EVAL];
+      x->predict_skip_level =
+          winner_mode_params->predict_skip_level[WINNER_MODE_EVAL];
 
       // Set transform domain distortion type for winner mode evaluation
       set_tx_domain_dist_params(
-          cpi, x, sf->winner_mode_sf.enable_winner_mode_for_use_tx_domain_dist,
-          1);
+          winner_mode_params, x,
+          sf->winner_mode_sf.enable_winner_mode_for_use_tx_domain_dist, 1);
 
       // Get threshold for R-D optimization of coefficients for winner mode
       // evaluation
       x->coeff_opt_dist_threshold = get_rd_opt_coeff_thresh(
-          cpi->coeff_opt_dist_threshold,
+          winner_mode_params->coeff_opt_dist_threshold,
           sf->winner_mode_sf.enable_winner_mode_for_coeff_opt, 1);
       // Set the transform size search method for winner mode evaluation
       set_tx_size_search_method(
-          cpi, x, sf->winner_mode_sf.enable_winner_mode_for_tx_size_srch, 1);
+          cm, winner_mode_params, x,
+          sf->winner_mode_sf.enable_winner_mode_for_tx_size_srch, 1);
       // Set default transform type prune mode for winner mode evaluation
       set_tx_type_prune(
           sf, x, sf->tx_sf.tx_type_search.enable_winner_mode_tx_type_pruning,
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index a085e44..ecba055 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -1132,6 +1132,7 @@
   AV1_COMMON *const cm = &cpi->common;
   SPEED_FEATURES *const sf = &cpi->sf;
   MACROBLOCK *const x = &cpi->td.mb;
+  WinnerModeParams *const winner_mode_params = &cpi->winner_mode_params;
   const AV1EncoderConfig *const oxcf = &cpi->oxcf;
   int i;
 
@@ -1223,37 +1224,37 @@
   // assert ensures that tx_domain_dist_level is accessed correctly
   assert(cpi->sf.rd_sf.tx_domain_dist_thres_level >= 0 &&
          cpi->sf.rd_sf.tx_domain_dist_thres_level < 3);
-  memcpy(cpi->tx_domain_dist_threshold,
+  memcpy(winner_mode_params->tx_domain_dist_threshold,
          tx_domain_dist_thresholds[cpi->sf.rd_sf.tx_domain_dist_thres_level],
-         sizeof(cpi->tx_domain_dist_threshold));
+         sizeof(winner_mode_params->tx_domain_dist_threshold));
 
   assert(cpi->sf.rd_sf.tx_domain_dist_level >= 0 &&
          cpi->sf.rd_sf.tx_domain_dist_level < 3);
-  memcpy(cpi->use_transform_domain_distortion,
+  memcpy(winner_mode_params->use_transform_domain_distortion,
          tx_domain_dist_types[cpi->sf.rd_sf.tx_domain_dist_level],
-         sizeof(cpi->use_transform_domain_distortion));
+         sizeof(winner_mode_params->use_transform_domain_distortion));
 
   // assert ensures that coeff_opt_dist_thresholds is accessed correctly
   assert(cpi->sf.rd_sf.perform_coeff_opt >= 0 &&
          cpi->sf.rd_sf.perform_coeff_opt < 6);
-  memcpy(cpi->coeff_opt_dist_threshold,
+  memcpy(winner_mode_params->coeff_opt_dist_threshold,
          coeff_opt_dist_thresholds[cpi->sf.rd_sf.perform_coeff_opt],
-         sizeof(cpi->coeff_opt_dist_threshold));
+         sizeof(winner_mode_params->coeff_opt_dist_threshold));
 
   // assert ensures that predict_skip_levels is accessed correctly
   assert(cpi->sf.tx_sf.tx_type_search.use_skip_flag_prediction >= 0 &&
          cpi->sf.tx_sf.tx_type_search.use_skip_flag_prediction < 3);
-  memcpy(cpi->predict_skip_level,
+  memcpy(winner_mode_params->predict_skip_level,
          predict_skip_levels[cpi->sf.tx_sf.tx_type_search
                                  .use_skip_flag_prediction],
-         sizeof(cpi->predict_skip_level));
+         sizeof(winner_mode_params->predict_skip_level));
 
   // assert ensures that tx_size_search_level is accessed correctly
   assert(cpi->sf.winner_mode_sf.tx_size_search_level >= 0 &&
          cpi->sf.winner_mode_sf.tx_size_search_level < 3);
-  memcpy(cpi->tx_size_search_methods,
+  memcpy(winner_mode_params->tx_size_search_methods,
          tx_size_search_methods[cpi->sf.winner_mode_sf.tx_size_search_level],
-         sizeof(cpi->tx_size_search_methods));
+         sizeof(winner_mode_params->tx_size_search_methods));
 
   if (cpi->oxcf.row_mt == 1 && (cpi->oxcf.max_threads > 1)) {
     if (sf->inter_sf.inter_mode_rd_model_estimation == 1) {
@@ -1267,14 +1268,15 @@
 void av1_set_speed_features_qindex_dependent(AV1_COMP *cpi, int speed) {
   AV1_COMMON *const cm = &cpi->common;
   SPEED_FEATURES *const sf = &cpi->sf;
+  WinnerModeParams *const winner_mode_params = &cpi->winner_mode_params;
   const int boosted = frame_is_boosted(cpi);
   const int is_720p_or_larger = AOMMIN(cm->width, cm->height) >= 720;
   if (is_720p_or_larger && cpi->oxcf.mode == GOOD && speed == 0) {
     if (cm->quant_params.base_qindex <= 80) {
       sf->rd_sf.perform_coeff_opt = 2;
-      memcpy(cpi->coeff_opt_dist_threshold,
+      memcpy(winner_mode_params->coeff_opt_dist_threshold,
              coeff_opt_dist_thresholds[sf->rd_sf.perform_coeff_opt],
-             sizeof(cpi->coeff_opt_dist_threshold));
+             sizeof(winner_mode_params->coeff_opt_dist_threshold));
       sf->part_sf.simple_motion_search_split =
           cm->features.allow_screen_content_tools ? 1 : 2;
       sf->tx_sf.inter_tx_size_search_init_depth_rect = 1;