diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index f9c478f..1cfc0f7 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -289,7 +289,7 @@
   assert(IMPLIES(cpi->gf_group.size > 0,
                  cpi->gf_group.index < cpi->gf_group.size));
   const int tpl_idx = cpi->gf_group.index;
-  const TplDepFrame *tpl_frame = &cpi->tpl_frame[tpl_idx];
+  const TplDepFrame *tpl_frame = &cpi->tpl_data.tpl_frame[tpl_idx];
   MACROBLOCKD *const xd = &x->e_mbd;
   const int deltaq_rdmult = set_deltaq_rdmult(cpi, xd);
   if (tpl_frame->is_valid == 0) return deltaq_rdmult;
@@ -3895,7 +3895,8 @@
   assert(IMPLIES(cpi->gf_group.size > 0,
                  cpi->gf_group.index < cpi->gf_group.size));
   const int tpl_idx = cpi->gf_group.index;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[tpl_idx];
+  TplParams *const tpl_data = &cpi->tpl_data;
+  TplDepFrame *tpl_frame = &tpl_data->tpl_frame[tpl_idx];
   TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
   int tpl_stride = tpl_frame->stride;
   int64_t intra_cost = 0;
@@ -3916,7 +3917,7 @@
   const int mi_col_end_sr =
       coded_to_superres_mi(mi_col + mi_wide, cm->superres_scale_denominator);
   const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
-  const int step = 1 << cpi->tpl_stats_block_mis_log2;
+  const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
   for (int row = mi_row; row < mi_row + mi_high; row += step) {
     for (int col = mi_col_sr; col < mi_col_end_sr; col += step) {
       if (row >= cm->mi_params.mi_rows || col >= mi_cols_sr) continue;
@@ -3978,7 +3979,7 @@
 
   AV1_COMMON *const cm = &cpi->common;
   const int gf_group_index = cpi->gf_group.index;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[gf_group_index];
+  TplDepFrame *tpl_frame = &cpi->tpl_data.tpl_frame[gf_group_index];
   TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
   int tpl_stride = tpl_frame->stride;
   const int mi_wide = mi_size_wide[bsize];
@@ -4027,7 +4028,8 @@
   assert(IMPLIES(cpi->gf_group.size > 0,
                  cpi->gf_group.index < cpi->gf_group.size));
   const int tpl_idx = cpi->gf_group.index;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[tpl_idx];
+  TplParams *const tpl_data = &cpi->tpl_data;
+  TplDepFrame *tpl_frame = &tpl_data->tpl_frame[tpl_idx];
   TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
   int tpl_stride = tpl_frame->stride;
   int64_t intra_cost = 0;
@@ -4049,7 +4051,7 @@
   const int mi_col_end_sr =
       coded_to_superres_mi(mi_col + mi_wide, cm->superres_scale_denominator);
   const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
-  const int step = 1 << cpi->tpl_stats_block_mis_log2;
+  const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
   for (int row = mi_row; row < mi_row + mi_high; row += step) {
     for (int col = mi_col_sr; col < mi_col_end_sr; col += step) {
       if (row >= cm->mi_params.mi_rows || col >= mi_cols_sr) continue;
@@ -4553,7 +4555,8 @@
   const CommonModeInfoParams *const mi_params = &cm->mi_params;
   MACROBLOCK *x = &td->mb;
   const int frame_idx = cpi->gf_group.index;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[frame_idx];
+  TplParams *const tpl_data = &cpi->tpl_data;
+  TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
 
   av1_zero(x->search_ref_frame);
 
@@ -4572,7 +4575,7 @@
   TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
   const int tpl_stride = tpl_frame->stride;
   int64_t inter_cost[INTER_REFS_PER_FRAME] = { 0 };
-  const int step = 1 << cpi->tpl_stats_block_mis_log2;
+  const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
   const BLOCK_SIZE sb_size = cm->seq_params.sb_size;
   const int mi_row_end =
       AOMMIN(mi_size_high[sb_size] + mi_row, mi_params->mi_rows);
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 69e125c..4758e7d 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -2677,12 +2677,12 @@
                   aom_calloc(mi_params->mi_rows * mi_params->mi_cols, 1));
 }
 
-static void set_tpl_stats_block_size(AV1_COMP *cpi) {
-  AV1_COMMON *const cm = &cpi->common;
-  const int is_720p_or_larger = AOMMIN(cm->width, cm->height) >= 720;
+static AOM_INLINE void set_tpl_stats_block_size(
+    int width, int height, uint8_t *tpl_stats_block_mis_log2) {
+  const int is_720p_or_larger = AOMMIN(width, height) >= 720;
 
   // 0: 4x4, 1: 8x8, 2: 16x16
-  cpi->tpl_stats_block_mis_log2 = is_720p_or_larger ? 2 : 1;
+  *tpl_stats_block_mis_log2 = is_720p_or_larger ? 2 : 1;
 }
 
 void av1_alloc_compound_type_rd_buffers(AV1_COMMON *const cm,
@@ -2950,35 +2950,37 @@
     av1_update_layer_context_change_config(cpi, oxcf->target_bandwidth);
 }
 
-static INLINE void setup_tpl_buffers(AV1_COMP *cpi) {
-  AV1_COMMON *cm = &cpi->common;
+static INLINE void setup_tpl_buffers(AV1_COMMON *const cm,
+                                     TplParams *const tpl_data) {
   CommonModeInfoParams *const mi_params = &cm->mi_params;
 
-  set_tpl_stats_block_size(cpi);
+  set_tpl_stats_block_size(cm->width, cm->height,
+                           &tpl_data->tpl_stats_block_mis_log2);
   for (int frame = 0; frame < MAX_LENGTH_TPL_FRAME_STATS; ++frame) {
     const int mi_cols =
         ALIGN_POWER_OF_TWO(mi_params->mi_cols, MAX_MIB_SIZE_LOG2);
     const int mi_rows =
         ALIGN_POWER_OF_TWO(mi_params->mi_rows, MAX_MIB_SIZE_LOG2);
 
-    cpi->tpl_stats_buffer[frame].is_valid = 0;
-    cpi->tpl_stats_buffer[frame].width =
-        mi_cols >> cpi->tpl_stats_block_mis_log2;
-    cpi->tpl_stats_buffer[frame].height =
-        mi_rows >> cpi->tpl_stats_block_mis_log2;
-    cpi->tpl_stats_buffer[frame].stride = cpi->tpl_stats_buffer[frame].width;
-    cpi->tpl_stats_buffer[frame].mi_rows = mi_params->mi_rows;
-    cpi->tpl_stats_buffer[frame].mi_cols = mi_params->mi_cols;
+    tpl_data->tpl_stats_buffer[frame].is_valid = 0;
+    tpl_data->tpl_stats_buffer[frame].width =
+        mi_cols >> tpl_data->tpl_stats_block_mis_log2;
+    tpl_data->tpl_stats_buffer[frame].height =
+        mi_rows >> tpl_data->tpl_stats_block_mis_log2;
+    tpl_data->tpl_stats_buffer[frame].stride =
+        tpl_data->tpl_stats_buffer[frame].width;
+    tpl_data->tpl_stats_buffer[frame].mi_rows = mi_params->mi_rows;
+    tpl_data->tpl_stats_buffer[frame].mi_cols = mi_params->mi_cols;
   }
 
   for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) {
     CHECK_MEM_ERROR(
-        cm, cpi->tpl_stats_pool[frame],
-        aom_calloc(cpi->tpl_stats_buffer[frame].width *
-                       cpi->tpl_stats_buffer[frame].height,
-                   sizeof(*cpi->tpl_stats_buffer[frame].tpl_stats_ptr)));
+        cm, tpl_data->tpl_stats_pool[frame],
+        aom_calloc(tpl_data->tpl_stats_buffer[frame].width *
+                       tpl_data->tpl_stats_buffer[frame].height,
+                   sizeof(*tpl_data->tpl_stats_buffer[frame].tpl_stats_ptr)));
     if (aom_alloc_frame_buffer(
-            &cpi->tpl_rec_pool[frame], cm->width, cm->height,
+            &tpl_data->tpl_rec_pool[frame], cm->width, cm->height,
             cm->seq_params.subsampling_x, cm->seq_params.subsampling_y,
             cm->seq_params.use_highbitdepth, AOM_ENC_NO_SCALE_BORDER,
             cm->features.byte_alignment))
@@ -2986,7 +2988,7 @@
                          "Failed to allocate frame buffer");
   }
 
-  cpi->tpl_frame = &cpi->tpl_stats_buffer[REF_FRAMES + 1];
+  tpl_data->tpl_frame = &tpl_data->tpl_stats_buffer[REF_FRAMES + 1];
 }
 
 static INLINE void init_frame_info(FRAME_INFO *frame_info,
@@ -3229,7 +3231,7 @@
 #endif
 
   if (!is_stat_generation_stage(cpi)) {
-    setup_tpl_buffers(cpi);
+    setup_tpl_buffers(cm, &cpi->tpl_data);
   }
 
 #if CONFIG_COLLECT_PARTITION_STATS == 2
@@ -3468,6 +3470,7 @@
 
 void av1_remove_compressor(AV1_COMP *cpi) {
   AV1_COMMON *cm;
+  TplParams *const tpl_data = &cpi->tpl_data;
   int t;
 
   if (!cpi) return;
@@ -3571,8 +3574,8 @@
   }
 
   for (int frame = 0; frame < MAX_LAG_BUFFERS; ++frame) {
-    aom_free(cpi->tpl_stats_pool[frame]);
-    aom_free_frame_buffer(&cpi->tpl_rec_pool[frame]);
+    aom_free(tpl_data->tpl_stats_pool[frame]);
+    aom_free_frame_buffer(&tpl_data->tpl_rec_pool[frame]);
   }
 
   for (t = cpi->num_workers - 1; t >= 0; --t) {
@@ -4104,7 +4107,8 @@
   assert(IMPLIES(gf_group->size > 0, gf_group->index < gf_group->size));
 
   const int tpl_idx = gf_group->index;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[tpl_idx];
+  TplParams *const tpl_data = &cpi->tpl_data;
+  TplDepFrame *tpl_frame = &tpl_data->tpl_frame[tpl_idx];
   TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
 
   if (tpl_frame->is_valid) {
@@ -4113,7 +4117,7 @@
     int64_t mc_dep_cost_base = 0;
     int64_t mc_saved_base = 0;
     int64_t mc_count_base = 0;
-    const int step = 1 << cpi->tpl_stats_block_mis_log2;
+    const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
     const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
 
     for (int row = 0; row < cm->mi_params.mi_rows; row += step) {
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 067f092..dd18779 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -183,6 +183,28 @@
   int base_rdmult;
 } TplDepFrame;
 
+typedef struct TplParams {
+  // Block granularity of tpl score storage.
+  uint8_t tpl_stats_block_mis_log2;
+
+  // Buffer to store the frame level tpl information for each frame in a gf
+  // group. tpl_stats_buffer[i] stores the tpl information of ith frame in a gf
+  // group
+  TplDepFrame tpl_stats_buffer[MAX_LENGTH_TPL_FRAME_STATS];
+
+  // Buffer to store tpl stats at block granularity.
+  // tpl_stats_pool[i][j] stores the tpl stats of jth block of ith frame in a gf
+  // group.
+  TplDepStats *tpl_stats_pool[MAX_LAG_BUFFERS];
+
+  // Buffer to store tpl reconstructed frame.
+  // tpl_rec_pool[i] stores the reconstructed frame of ith frame in a gf group.
+  YV12_BUFFER_CONFIG tpl_rec_pool[MAX_LAG_BUFFERS];
+
+  // Pointer to tpl_stats_buffer.
+  TplDepFrame *tpl_frame;
+} TplParams;
+
 typedef enum {
   COST_UPD_SB,
   COST_UPD_SBROW,
@@ -861,11 +883,7 @@
   YV12_BUFFER_CONFIG scaled_last_source;
   YV12_BUFFER_CONFIG *unfiltered_source;
 
-  uint8_t tpl_stats_block_mis_log2;  // block granularity of tpl score storage
-  TplDepFrame tpl_stats_buffer[MAX_LENGTH_TPL_FRAME_STATS];
-  TplDepStats *tpl_stats_pool[MAX_LAG_BUFFERS];
-  YV12_BUFFER_CONFIG tpl_rec_pool[MAX_LAG_BUFFERS];
-  TplDepFrame *tpl_frame;
+  TplParams tpl_data;
 
   // For a still frame, this flag is set to 1 to skip partition search.
   int partition_search_skippable_frame;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 4d13e1c..705d11c 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -2119,7 +2119,8 @@
 
   assert(IMPLIES(gf_group->size > 0, gf_group->index < gf_group->size));
   const int tpl_idx = gf_group->index;
-  const TplDepFrame *tpl_frame = &cpi->tpl_frame[tpl_idx];
+  TplParams *const tpl_data = &cpi->tpl_data;
+  const TplDepFrame *tpl_frame = &tpl_data->tpl_frame[tpl_idx];
   if (tpl_idx >= MAX_LAG_BUFFERS || !tpl_frame->is_valid) {
     return;
   }
@@ -2128,7 +2129,7 @@
   const int mi_wide = mi_size_wide[bsize];
   const int mi_high = mi_size_high[bsize];
   const int tpl_stride = tpl_frame->stride;
-  const int step = 1 << cpi->tpl_stats_block_mis_log2;
+  const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
   const int mi_col_sr =
       coded_to_superres_mi(mi_col, cm->superres_scale_denominator);
   const int mi_col_end_sr =
@@ -2231,7 +2232,7 @@
 
   const GF_GROUP *const gf_group = &cpi->gf_group;
   const int tpl_idx = gf_group->index;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[tpl_idx];
+  TplDepFrame *tpl_frame = &cpi->tpl_data.tpl_frame[tpl_idx];
   const int prune_modes_based_on_tpl =
       cpi->sf.inter_sf.prune_inter_modes_based_on_tpl &&
       tpl_idx >= MAX_LAG_BUFFERS && tpl_frame->is_valid;
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index 9520dc3..3eef2e2 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -200,7 +200,7 @@
 
   (void)gf_group;
 
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[frame_idx];
+  TplDepFrame *tpl_frame = &cpi->tpl_data.tpl_frame[frame_idx];
 
   const int bw = 4 << mi_size_wide_log2[bsize];
   const int bh = 4 << mi_size_high_log2[bsize];
@@ -503,7 +503,7 @@
 }
 
 int av1_tpl_ptr_pos(AV1_COMP *cpi, int mi_row, int mi_col, int stride) {
-  const int right_shift = cpi->tpl_stats_block_mis_log2;
+  const int right_shift = cpi->tpl_data.tpl_stats_block_mis_log2;
 
   return (mi_row >> right_shift) * stride + (mi_col >> right_shift);
 }
@@ -586,7 +586,7 @@
           grid_pos_row, grid_pos_col, ref_pos_row, ref_pos_col, block, bsize);
       int ref_mi_row = round_floor(grid_pos_row, bh) * mi_height;
       int ref_mi_col = round_floor(grid_pos_col, bw) * mi_width;
-      const int step = 1 << cpi->tpl_stats_block_mis_log2;
+      const int step = 1 << cpi->tpl_data.tpl_stats_block_mis_log2;
 
       for (int idy = 0; idy < mi_height; idy += step) {
         for (int idx = 0; idx < mi_width; idx += step) {
@@ -610,9 +610,9 @@
                                         int frame_idx) {
   const int mi_height = mi_size_high[bsize];
   const int mi_width = mi_size_wide[bsize];
-  const int step = 1 << cpi->tpl_stats_block_mis_log2;
-  const BLOCK_SIZE tpl_block_size =
-      convert_length_to_bsize(MI_SIZE << cpi->tpl_stats_block_mis_log2);
+  const int step = 1 << cpi->tpl_data.tpl_stats_block_mis_log2;
+  const BLOCK_SIZE tpl_block_size = convert_length_to_bsize(
+      MI_SIZE << cpi->tpl_data.tpl_stats_block_mis_log2);
 
   for (int idy = 0; idy < mi_height; idy += step) {
     for (int idx = 0; idx < mi_width; idx += step) {
@@ -630,7 +630,7 @@
                                        const TplDepStats *src_stats) {
   const int mi_height = mi_size_high[bsize];
   const int mi_width = mi_size_wide[bsize];
-  const int step = 1 << cpi->tpl_stats_block_mis_log2;
+  const int step = 1 << cpi->tpl_data.tpl_stats_block_mis_log2;
 
   int64_t intra_cost = src_stats->intra_cost / (mi_height * mi_width);
   int64_t inter_cost = src_stats->inter_cost / (mi_height * mi_width);
@@ -669,7 +669,8 @@
                                          int pframe_qindex) {
   const GF_GROUP *gf_group = &cpi->gf_group;
   if (frame_idx == gf_group->size) return;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[frame_idx];
+  TplParams *const tpl_data = &cpi->tpl_data;
+  TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
   const YV12_BUFFER_CONFIG *this_frame = tpl_frame->gf_picture;
   const YV12_BUFFER_CONFIG *ref_frame[7] = { NULL, NULL, NULL, NULL,
                                              NULL, NULL, NULL };
@@ -701,8 +702,10 @@
   xd->cur_buf = this_frame;
 
   for (idx = 0; idx < INTER_REFS_PER_FRAME; ++idx) {
-    ref_frame[idx] = cpi->tpl_frame[tpl_frame->ref_map_index[idx]].rec_picture;
-    src_frame[idx] = cpi->tpl_frame[tpl_frame->ref_map_index[idx]].gf_picture;
+    ref_frame[idx] =
+        tpl_data->tpl_frame[tpl_frame->ref_map_index[idx]].rec_picture;
+    src_frame[idx] =
+        tpl_data->tpl_frame[tpl_frame->ref_map_index[idx]].gf_picture;
   }
 
   // Store the reference frames based on priority order
@@ -777,7 +780,7 @@
   const GF_GROUP *gf_group = &cpi->gf_group;
   if (frame_idx == gf_group->size) return;
 
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[frame_idx];
+  TplDepFrame *tpl_frame = &cpi->tpl_data.tpl_frame[frame_idx];
 
   const BLOCK_SIZE bsize = convert_length_to_bsize(MC_FLOW_BSIZE_1D);
   const int mi_height = mi_size_high[bsize];
@@ -786,8 +789,8 @@
   for (int mi_row = 0; mi_row < cm->mi_params.mi_rows; mi_row += mi_height) {
     for (int mi_col = 0; mi_col < cm->mi_params.mi_cols; mi_col += mi_width) {
       if (frame_idx) {
-        tpl_model_update(cpi, cpi->tpl_frame, tpl_frame->tpl_stats_ptr, mi_row,
-                         mi_col, bsize, frame_idx);
+        tpl_model_update(cpi, cpi->tpl_data.tpl_frame, tpl_frame->tpl_stats_ptr,
+                         mi_row, mi_col, bsize, frame_idx);
       }
     }
   }
@@ -803,18 +806,19 @@
 
   RefBufferStack ref_buffer_stack = cpi->ref_buffer_stack;
   EncodeFrameParams frame_params = *init_frame_params;
+  TplParams *const tpl_data = &cpi->tpl_data;
 
   int ref_picture_map[REF_FRAMES];
 
   for (int i = 0; i < REF_FRAMES; ++i) {
     if (frame_params.frame_type == KEY_FRAME || gop_eval) {
-      cpi->tpl_frame[-i - 1].gf_picture = NULL;
-      cpi->tpl_frame[-1 - 1].rec_picture = NULL;
-      cpi->tpl_frame[-i - 1].frame_display_index = 0;
+      tpl_data->tpl_frame[-i - 1].gf_picture = NULL;
+      tpl_data->tpl_frame[-1 - 1].rec_picture = NULL;
+      tpl_data->tpl_frame[-i - 1].frame_display_index = 0;
     } else {
-      cpi->tpl_frame[-i - 1].gf_picture = &cm->ref_frame_map[i]->buf;
-      cpi->tpl_frame[-i - 1].rec_picture = &cm->ref_frame_map[i]->buf;
-      cpi->tpl_frame[-i - 1].frame_display_index =
+      tpl_data->tpl_frame[-i - 1].gf_picture = &cm->ref_frame_map[i]->buf;
+      tpl_data->tpl_frame[-i - 1].rec_picture = &cm->ref_frame_map[i]->buf;
+      tpl_data->tpl_frame[-i - 1].frame_display_index =
           cm->ref_frame_map[i]->display_order_hint;
     }
 
@@ -830,7 +834,7 @@
   const int gop_length =
       AOMMIN(gf_group->size - 1 + use_arf, MAX_LENGTH_TPL_FRAME_STATS - 1);
   for (gf_index = cur_frame_idx; gf_index <= gop_length; ++gf_index) {
-    TplDepFrame *tpl_frame = &cpi->tpl_frame[gf_index];
+    TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_index];
     FRAME_UPDATE_TYPE frame_update_type = gf_group->update_type[gf_index];
 
     frame_params.show_frame = frame_update_type != ARF_UPDATE &&
@@ -868,8 +872,8 @@
 
     if (frame_update_type != OVERLAY_UPDATE &&
         frame_update_type != INTNL_OVERLAY_UPDATE) {
-      tpl_frame->rec_picture = &cpi->tpl_rec_pool[process_frame_count];
-      tpl_frame->tpl_stats_ptr = cpi->tpl_stats_pool[process_frame_count];
+      tpl_frame->rec_picture = &tpl_data->tpl_rec_pool[process_frame_count];
+      tpl_frame->tpl_stats_ptr = tpl_data->tpl_stats_pool[process_frame_count];
       ++process_frame_count;
     }
 
@@ -902,7 +906,7 @@
   for (; gf_index < MAX_LENGTH_TPL_FRAME_STATS &&
          extend_frame_count < extend_frame_length;
        ++gf_index) {
-    TplDepFrame *tpl_frame = &cpi->tpl_frame[gf_index];
+    TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_index];
     FRAME_UPDATE_TYPE frame_update_type = LF_UPDATE;
     frame_params.show_frame = frame_update_type != ARF_UPDATE &&
                               frame_update_type != INTNL_ARF_UPDATE;
@@ -917,8 +921,8 @@
     if (buf == NULL) break;
 
     tpl_frame->gf_picture = &buf->img;
-    tpl_frame->rec_picture = &cpi->tpl_rec_pool[process_frame_count];
-    tpl_frame->tpl_stats_ptr = cpi->tpl_stats_pool[process_frame_count];
+    tpl_frame->rec_picture = &tpl_data->tpl_rec_pool[process_frame_count];
+    tpl_frame->tpl_stats_ptr = tpl_data->tpl_stats_pool[process_frame_count];
     ++process_frame_count;
 
     // frame display index = frame offset within the gf group + start frame of
@@ -956,10 +960,10 @@
   av1_get_ref_frames(cpi, &cpi->ref_buffer_stack);
 }
 
-static AOM_INLINE void init_tpl_stats(AV1_COMP *cpi) {
+static AOM_INLINE void init_tpl_stats(TplParams *const tpl_data) {
   for (int frame_idx = 0; frame_idx < MAX_LAG_BUFFERS; ++frame_idx) {
-    TplDepFrame *tpl_frame = &cpi->tpl_stats_buffer[frame_idx];
-    memset(cpi->tpl_stats_pool[frame_idx], 0,
+    TplDepFrame *tpl_frame = &tpl_data->tpl_stats_buffer[frame_idx];
+    memset(tpl_data->tpl_stats_pool[frame_idx], 0,
            tpl_frame->height * tpl_frame->width *
                sizeof(*tpl_frame->tpl_stats_ptr));
     tpl_frame->is_valid = 0;
@@ -973,6 +977,7 @@
   GF_GROUP *gf_group = &cpi->gf_group;
   int bottom_index, top_index;
   EncodeFrameParams this_frame_params = *frame_params;
+  TplParams *const tpl_data = &cpi->tpl_data;
 
   if (cpi->oxcf.superres_mode != SUPERRES_NONE) return 0;
 
@@ -1002,7 +1007,7 @@
 
   cpi->rc.base_layer_qp = pframe_qindex;
 
-  init_tpl_stats(cpi);
+  init_tpl_stats(tpl_data);
 
   // Backward propagation from tpl_group_frames to 1.
   for (int frame_idx = gf_group->index; frame_idx < tpl_gf_group_frames;
@@ -1013,7 +1018,7 @@
 
     mc_flow_dispenser(cpi, frame_idx, pframe_qindex);
 
-    aom_extend_frame_borders(cpi->tpl_frame[frame_idx].rec_picture,
+    aom_extend_frame_borders(tpl_data->tpl_frame[frame_idx].rec_picture,
                              av1_num_planes(cm));
   }
 
@@ -1037,12 +1042,12 @@
   double beta[2] = { 0.0 };
   for (int frame_idx = 1; frame_idx <= AOMMIN(tpl_gf_group_frames - 1, 2);
        ++frame_idx) {
-    TplDepFrame *tpl_frame = &cpi->tpl_frame[frame_idx];
+    TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx];
     TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr;
     int tpl_stride = tpl_frame->stride;
     int64_t intra_cost_base = 0;
     int64_t mc_dep_cost_base = 0;
-    const int step = 1 << cpi->tpl_stats_block_mis_log2;
+    const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
     const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width);
 
     for (int row = 0; row < cm->mi_params.mi_rows; row += step) {
@@ -1073,7 +1078,8 @@
 
   assert(IMPLIES(gf_group->size > 0, tpl_idx < gf_group->size));
 
-  const TplDepFrame *const tpl_frame = &cpi->tpl_frame[tpl_idx];
+  TplParams *const tpl_data = &cpi->tpl_data;
+  const TplDepFrame *const tpl_frame = &tpl_data->tpl_frame[tpl_idx];
 
   if (!tpl_frame->is_valid) return;
   if (cpi->oxcf.superres_mode != SUPERRES_NONE) return;
@@ -1088,7 +1094,7 @@
   const int num_cols = (mi_cols_sr + num_mi_w - 1) / num_mi_w;
   const int num_rows = (cm->mi_params.mi_rows + num_mi_h - 1) / num_mi_h;
   const double c = 1.2;
-  const int step = 1 << cpi->tpl_stats_block_mis_log2;
+  const int step = 1 << tpl_data->tpl_stats_block_mis_log2;
 
   aom_clear_system_state();
 
@@ -1126,7 +1132,7 @@
   assert(IMPLIES(cpi->gf_group.size > 0,
                  cpi->gf_group.index < cpi->gf_group.size));
   const int tpl_idx = cpi->gf_group.index;
-  TplDepFrame *tpl_frame = &cpi->tpl_frame[tpl_idx];
+  TplDepFrame *tpl_frame = &cpi->tpl_data.tpl_frame[tpl_idx];
 
   if (tpl_frame->is_valid == 0) return;
   if (!is_frame_tpl_eligible(cpi)) return;