diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index a907860..73e32a5 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -2782,11 +2782,6 @@
       cpi->vbr_rc_info.actual_mv_bitrate_byframe[cpi->gf_frame_index] =
           rc->projected_frame_size -
           cpi->vbr_rc_info.actual_coeff_bitrate_byframe[cpi->gf_frame_index];
-      if (cpi->ppi->gf_group.update_type[cpi->gf_frame_index] == KF_UPDATE) {
-        vbr_rc_set_keyframe_bitrate(&cpi->vbr_rc_info,
-                                    rc->projected_frame_size);
-      }
-
 #if 0
       vbr_rc_info_log(&cpi->vbr_rc_info, cpi->gf_frame_index,
                       cpi->ppi->gf_group.size, cpi->ppi->gf_group.update_type);
diff --git a/av1/encoder/pass2_strategy.c b/av1/encoder/pass2_strategy.c
index c76ac65..8eb9afa 100644
--- a/av1/encoder/pass2_strategy.c
+++ b/av1/encoder/pass2_strategy.c
@@ -2388,7 +2388,8 @@
   }
 #if CONFIG_BITRATE_ACCURACY
   if (is_final_pass) {
-    vbr_rc_set_gop_bit_budget(&cpi->vbr_rc_info, p_rc->baseline_gf_interval);
+    av1_vbr_rc_set_gop_bit_budget(&cpi->vbr_rc_info,
+                                  p_rc->baseline_gf_interval);
   }
 #endif
 }
@@ -3882,8 +3883,8 @@
       (int64_t)(stats->duration * oxcf->rc_cfg.target_bandwidth / 10000000.0);
 
 #if CONFIG_BITRATE_ACCURACY
-  vbr_rc_init(&cpi->vbr_rc_info, cpi->ppi->twopass.bits_left,
-              (int)round(stats->count));
+  av1_vbr_rc_init(&cpi->vbr_rc_info, cpi->ppi->twopass.bits_left,
+                  (int)round(stats->count));
 #endif
 
   // This variable monitors how far behind the second ref update is lagging.
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index cae79cb..7d05a8d 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -47,10 +47,13 @@
 }
 
 void av1_init_tpl_txfm_stats(TplTxfmStats *tpl_txfm_stats) {
+  tpl_txfm_stats->ready = 0;
   tpl_txfm_stats->coeff_num = 256;
   tpl_txfm_stats->txfm_block_count = 0;
   memset(tpl_txfm_stats->abs_coeff_sum, 0,
          sizeof(tpl_txfm_stats->abs_coeff_sum[0]) * tpl_txfm_stats->coeff_num);
+  memset(tpl_txfm_stats->abs_coeff_mean, 0,
+         sizeof(tpl_txfm_stats->abs_coeff_mean[0]) * tpl_txfm_stats->coeff_num);
 }
 
 void av1_accumulate_tpl_txfm_stats(const TplTxfmStats *sub_stats,
@@ -72,6 +75,18 @@
   ++tpl_txfm_stats->txfm_block_count;
 }
 
+void av1_tpl_txfm_stats_update_abs_coeff_mean(TplTxfmStats *txfm_stats) {
+  if (txfm_stats->txfm_block_count > 0) {
+    for (int j = 0; j < txfm_stats->coeff_num; j++) {
+      txfm_stats->abs_coeff_mean[j] =
+          txfm_stats->abs_coeff_sum[j] / txfm_stats->txfm_block_count;
+    }
+    txfm_stats->ready = 1;
+  } else {
+    txfm_stats->ready = 0;
+  }
+}
+
 static AOM_INLINE void av1_tpl_store_txfm_stats(
     TplParams *tpl_data, const TplTxfmStats *tpl_txfm_stats,
     const int frame_index) {
@@ -1616,6 +1631,7 @@
     } else {
       mc_flow_dispenser(cpi);
     }
+    av1_tpl_txfm_stats_update_abs_coeff_mean(&cpi->td.tpl_txfm_stats);
     av1_tpl_store_txfm_stats(tpl_data, &cpi->td.tpl_txfm_stats, frame_idx);
 
     aom_extend_frame_borders(tpl_data->tpl_frame[frame_idx].rec_picture,
@@ -1818,35 +1834,6 @@
   return est_rate;
 }
 
-double av1_estimate_gop_bitrate(const int *q_index_list, const int frame_count,
-                                const TplTxfmStats *stats_list,
-                                const int *stats_valid_list,
-                                double *bitrate_byframe_list) {
-  double gop_bitrate = 0;
-  for (int frame_index = 0; frame_index < frame_count; frame_index++) {
-    if (stats_valid_list[frame_index]) {
-      int q_index = q_index_list[frame_index];
-      TplTxfmStats frame_stats = stats_list[frame_index];
-
-      /* Convert to mean absolute deviation */
-      double abs_coeff_mean[256] = { 0 };
-      for (int i = 0; i < 256; i++) {
-        abs_coeff_mean[i] =
-            frame_stats.abs_coeff_sum[i] / frame_stats.txfm_block_count;
-      }
-
-      double frame_bitrate = av1_laplace_estimate_frame_rate(
-          q_index, frame_stats.txfm_block_count, abs_coeff_mean, 256);
-      gop_bitrate += frame_bitrate;
-
-      if (bitrate_byframe_list != NULL) {
-        bitrate_byframe_list[frame_index] = frame_bitrate;
-      }
-    }
-  }
-  return gop_bitrate;
-}
-
 double av1_estimate_coeff_entropy(double q_step, double b,
                                   double zero_bin_ratio, int qcoeff) {
   b = AOMMAX(b, TPL_EPSILON);
@@ -1900,75 +1887,6 @@
 }
 #endif  // CONFIG_RD_COMMAND
 
-void get_tpl_stats_valid_list(const TplParams *tpl_data, int gop_size,
-                              int *stats_valid_list) {
-  for (int i = 0; i < gop_size; ++i) {
-    stats_valid_list[i] = av1_tpl_stats_ready(tpl_data, i);
-  }
-}
-
-/*
- * Estimate the optimal base q index for a GOP.
- */
-int av1_q_mode_estimate_base_q(const GF_GROUP *gf_group,
-                               const TplTxfmStats *txfm_stats_list,
-                               const int *stats_valid_list, double bit_budget,
-                               aom_bit_depth_t bit_depth, double scale_factor,
-                               const double *qstep_ratio_list,
-                               int *q_index_list,
-                               double *estimated_bitrate_byframe) {
-  int q_max = 255;  // Maximum q value.
-  int q_min = 0;    // Minimum q value.
-  int q = (q_max + q_min) / 2;
-
-  av1_q_mode_compute_gop_q_indices(q_max, qstep_ratio_list, bit_depth, gf_group,
-                                   q_index_list);
-  double q_max_estimate = av1_estimate_gop_bitrate(
-      q_index_list, gf_group->size, txfm_stats_list, stats_valid_list, NULL);
-  av1_q_mode_compute_gop_q_indices(q_min, qstep_ratio_list, bit_depth, gf_group,
-                                   q_index_list);
-  double q_min_estimate = av1_estimate_gop_bitrate(
-      q_index_list, gf_group->size, txfm_stats_list, stats_valid_list, NULL);
-
-  while (true) {
-    av1_q_mode_compute_gop_q_indices(q, qstep_ratio_list, bit_depth, gf_group,
-                                     q_index_list);
-
-    double estimate = av1_estimate_gop_bitrate(
-        q_index_list, gf_group->size, txfm_stats_list, stats_valid_list, NULL);
-
-    estimate *= scale_factor;
-
-    // We want to find the lowest q that satisfies the bit budget constraint.
-    // A binary search narrows the result down to two values: q_min and q_max.
-    if (q_max <= q_min + 1 || estimate == bit_budget) {
-      // Pick the estimate that lands closest to the budget.
-      if (fabs(q_max_estimate - bit_budget) <
-          fabs(q_min_estimate - bit_budget)) {
-        q = q_max;
-      } else {
-        q = q_min;
-      }
-      break;
-    } else if (estimate > bit_budget) {
-      q_min = q;
-      q_min_estimate = estimate;
-      q = (q_max + q_min) / 2;
-    } else if (estimate < bit_budget) {
-      q_max = q;
-      q_max_estimate = estimate;
-      q = (q_max + q_min) / 2;
-    }
-  }
-
-  // Update q_index_list and vbr_rc_info.
-  av1_q_mode_compute_gop_q_indices(q, qstep_ratio_list, bit_depth, gf_group,
-                                   q_index_list);
-  av1_estimate_gop_bitrate(q_index_list, gf_group->size, txfm_stats_list,
-                           stats_valid_list, estimated_bitrate_byframe);
-  return q;
-}
-
 double av1_tpl_get_frame_importance(const TplParams *tpl_data,
                                     int gf_frame_index) {
   const TplDepFrame *tpl_frame = &tpl_data->tpl_frame[gf_frame_index];
@@ -2021,6 +1939,113 @@
 }
 
 #if CONFIG_BITRATE_ACCURACY
+void av1_vbr_rc_init(VBR_RATECTRL_INFO *vbr_rc_info, double total_bit_budget,
+                     int show_frame_count) {
+  vbr_rc_info->total_bit_budget = total_bit_budget;
+  vbr_rc_info->show_frame_count = show_frame_count;
+  const double scale_factors[FRAME_UPDATE_TYPES] = { 0.94559, 0.94559, 1,
+                                                     0.94559, 1,       1,
+                                                     0.94559 };
+
+  // TODO(angiebird): Based on the previous code, only the scale factor 0.94559
+  // will be used in most of the cases with --limi=17. Figure out if the
+  // following scale factors works better.
+  // const double scale_factors[FRAME_UPDATE_TYPES] = { 0.94559, 0.12040, 1,
+  //                                                    1.10199, 1,       1,
+  //                                                    0.16393 };
+
+  const double mv_scale_factors[FRAME_UPDATE_TYPES] = { 3, 3, 3, 3, 3, 3, 3 };
+  memcpy(vbr_rc_info->scale_factors, scale_factors,
+         sizeof(scale_factors[0]) * FRAME_UPDATE_TYPES);
+  memcpy(vbr_rc_info->mv_scale_factors, mv_scale_factors,
+         sizeof(mv_scale_factors[0]) * FRAME_UPDATE_TYPES);
+
+  vbr_rc_reset_gop_data(vbr_rc_info);
+}
+
+void av1_vbr_rc_set_gop_bit_budget(VBR_RATECTRL_INFO *vbr_rc_info,
+                                   int gop_showframe_count) {
+  vbr_rc_info->gop_showframe_count = gop_showframe_count;
+  vbr_rc_info->gop_bit_budget = vbr_rc_info->total_bit_budget *
+                                gop_showframe_count /
+                                vbr_rc_info->show_frame_count;
+}
+
+double av1_vbr_rc_info_estimate_gop_bitrate(
+    const VBR_RATECTRL_INFO *vbr_rc_info, const GF_GROUP *gf_group,
+    int base_q_index, const TplTxfmStats *stats_list, aom_bit_depth_t bit_depth,
+    int *q_index_list, double *estimated_bitrate_byframe) {
+  av1_q_mode_compute_gop_q_indices(base_q_index, vbr_rc_info->qstep_ratio_list,
+                                   bit_depth, gf_group, q_index_list);
+  double gop_bitrate = 0;
+  for (int frame_index = 0; frame_index < gf_group->size; frame_index++) {
+    const TplTxfmStats *frame_stats = &stats_list[frame_index];
+    if (frame_stats->ready) {
+      int q_index = q_index_list[frame_index];
+
+      double frame_bitrate = av1_laplace_estimate_frame_rate(
+          q_index, frame_stats->txfm_block_count, frame_stats->abs_coeff_mean,
+          frame_stats->coeff_num);
+      gop_bitrate += frame_bitrate;
+
+      estimated_bitrate_byframe[frame_index] = frame_bitrate;
+    } else {
+      estimated_bitrate_byframe[frame_index] = 0;
+    }
+  }
+  double estimated_gop_bitrate = 0;
+  for (int i = 0; i < gf_group->size; ++i) {
+    FRAME_UPDATE_TYPE update_type = gf_group->update_type[i];
+    estimated_gop_bitrate +=
+        estimated_bitrate_byframe[i] * vbr_rc_info->scale_factors[update_type];
+  }
+  return estimated_gop_bitrate;
+}
+
+int av1_vbr_rc_info_estimate_base_q(const VBR_RATECTRL_INFO *vbr_rc_info,
+                                    const GF_GROUP *gf_group,
+                                    const TplTxfmStats *txfm_stats_list,
+                                    double bit_budget,
+                                    aom_bit_depth_t bit_depth,
+                                    int *q_index_list,
+                                    double *estimated_bitrate_byframe) {
+  int q_max = 255;  // Maximum q value.
+  int q_min = 0;    // Minimum q value.
+  int q = (q_max + q_min) / 2;
+
+  double q_max_estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+      vbr_rc_info, gf_group, q_max, txfm_stats_list, bit_depth, q_index_list,
+      estimated_bitrate_byframe);
+
+  double q_min_estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+      vbr_rc_info, gf_group, q_min, txfm_stats_list, bit_depth, q_index_list,
+      estimated_bitrate_byframe);
+
+  while (q_min + 1 < q_max) {
+    double estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+        vbr_rc_info, gf_group, q, txfm_stats_list, bit_depth, q_index_list,
+        estimated_bitrate_byframe);
+    if (estimate > bit_budget) {
+      q_min = q;
+      q_min_estimate = estimate;
+    } else {
+      q_max = q;
+      q_max_estimate = estimate;
+    }
+    q = (q_max + q_min) / 2;
+  }
+  // Pick the estimate that lands closest to the budget.
+  if (fabs(q_max_estimate - bit_budget) < fabs(q_min_estimate - bit_budget)) {
+    q = q_max;
+  } else {
+    q = q_min;
+  }
+  // Update q_index_list and vbr_rc_info.
+  av1_vbr_rc_info_estimate_gop_bitrate(vbr_rc_info, gf_group, q,
+                                       txfm_stats_list, bit_depth, q_index_list,
+                                       estimated_bitrate_byframe);
+  return q;
+}
 void av1_vbr_rc_update_q_index_list(VBR_RATECTRL_INFO *vbr_rc_info,
                                     const TplParams *tpl_data,
                                     const GF_GROUP *gf_group,
@@ -2032,26 +2057,15 @@
     vbr_rc_info->qstep_ratio_list[i] = av1_tpl_get_qstep_ratio(tpl_data, i);
   }
 
-  // We update the q indices in vbr_rc_info in vbr_rc_info->q_index_list
-  // rather than gf_group->q_val to avoid conflicts with the existing code.
-  int stats_valid_list[MAX_LENGTH_TPL_FRAME_STATS] = { 0 };
-  get_tpl_stats_valid_list(tpl_data, gf_group->size, stats_valid_list);
-
   double mv_bits = av1_tpl_compute_mv_bits(tpl_data, gf_group, vbr_rc_info);
 
   mv_bits = AOMMIN(mv_bits, 0.6 * gop_bit_budget);
   gop_bit_budget -= mv_bits;
 
-  int gf_frame_index = 0;
-  // TODO(angiebird): This part seems like a bug. We only use scale_factor
-  // for gf_frame_index == 0. Fix this part in a follow-up CL
-  double scale_factor =
-      vbr_rc_info->scale_factors[gf_group->update_type[gf_frame_index]];
-
-  vbr_rc_info->base_q_index = av1_q_mode_estimate_base_q(
-      gf_group, tpl_data->txfm_stats_list, stats_valid_list, gop_bit_budget,
-      bit_depth, scale_factor, vbr_rc_info->qstep_ratio_list,
-      vbr_rc_info->q_index_list, vbr_rc_info->estimated_bitrate_byframe);
+  vbr_rc_info->base_q_index = av1_vbr_rc_info_estimate_base_q(
+      vbr_rc_info, gf_group, tpl_data->txfm_stats_list, gop_bit_budget,
+      bit_depth, vbr_rc_info->q_index_list,
+      vbr_rc_info->estimated_bitrate_byframe);
 }
 
 /* For a GOP, calculate the bits used by motion vectors. */
diff --git a/av1/encoder/tpl_model.h b/av1/encoder/tpl_model.h
index 34565cf..98e76bc 100644
--- a/av1/encoder/tpl_model.h
+++ b/av1/encoder/tpl_model.h
@@ -95,7 +95,9 @@
 #define TPL_EPSILON 0.0000001
 
 typedef struct TplTxfmStats {
+  int ready;                  // Whether abs_coeff_mean is ready
   double abs_coeff_sum[256];  // Assume we are using 16x16 transform block
+  double abs_coeff_mean[256];
   int txfm_block_count;
   int coeff_num;
 } TplTxfmStats;
@@ -226,7 +228,6 @@
  * experiment.
  */
 typedef struct {
-  double keyframe_bitrate;
   double total_bit_budget;  // The total bit budget of the entire video
   int show_frame_count;     // Number of show frames in the entire video
 
@@ -263,35 +264,10 @@
   av1_zero(vbr_rc_info->actual_coeff_bitrate_byframe);
 }
 
-static INLINE void vbr_rc_init(VBR_RATECTRL_INFO *vbr_rc_info,
-                               double total_bit_budget, int show_frame_count) {
-  vbr_rc_info->total_bit_budget = total_bit_budget;
-  vbr_rc_info->show_frame_count = show_frame_count;
-  vbr_rc_info->keyframe_bitrate = 0;
-  const double scale_factors[FRAME_UPDATE_TYPES] = { 0.94559, 0.12040, 1,
-                                                     1.10199, 1,       1,
-                                                     0.16393 };
-  const double mv_scale_factors[FRAME_UPDATE_TYPES] = { 3, 3, 3, 3, 3, 3, 3 };
-  memcpy(vbr_rc_info->scale_factors, scale_factors,
-         sizeof(scale_factors[0]) * FRAME_UPDATE_TYPES);
-  memcpy(vbr_rc_info->mv_scale_factors, mv_scale_factors,
-         sizeof(mv_scale_factors[0]) * FRAME_UPDATE_TYPES);
-
-  vbr_rc_reset_gop_data(vbr_rc_info);
-}
-
-static INLINE void vbr_rc_set_gop_bit_budget(VBR_RATECTRL_INFO *vbr_rc_info,
-                                             int gop_showframe_count) {
-  vbr_rc_info->gop_showframe_count = gop_showframe_count;
-  vbr_rc_info->gop_bit_budget = vbr_rc_info->total_bit_budget *
-                                gop_showframe_count /
-                                vbr_rc_info->show_frame_count;
-}
-
-static INLINE void vbr_rc_set_keyframe_bitrate(VBR_RATECTRL_INFO *vbr_rc_info,
-                                               double keyframe_bitrate) {
-  vbr_rc_info->keyframe_bitrate = keyframe_bitrate;
-}
+void av1_vbr_rc_init(VBR_RATECTRL_INFO *vbr_rc_info, double total_bit_budget,
+                     int show_frame_count);
+void av1_vbr_rc_set_gop_bit_budget(VBR_RATECTRL_INFO *vbr_rc_info,
+                                   int gop_showframe_count);
 
 static INLINE void vbr_rc_info_log(const VBR_RATECTRL_INFO *vbr_rc_info,
                                    int gf_frame_index, int gf_group_size,
@@ -313,6 +289,74 @@
   }
 }
 
+/*!\brief Update q_index_list in vbr_rc_info based on tpl stats
+ *
+ * \param[out]      vbr_rc_info    Rate control info for BITRATE_ACCURACY
+ *                                 experiment
+ * \param[in]       tpl_data       TPL struct
+ * \param[in]       gf_group       GOP struct
+ * \param[in]       bit_depth      bit depth
+ */
+void av1_vbr_rc_update_q_index_list(VBR_RATECTRL_INFO *vbr_rc_info,
+                                    const TplParams *tpl_data,
+                                    const struct GF_GROUP *gf_group,
+                                    aom_bit_depth_t bit_depth);
+/*
+ *!\brief Compute the number of bits needed to encode a GOP
+ *
+ * \param[out]   vbr_rc_info       Rate control info for BITRATE_ACCURACY
+ *                                 experiment
+ * \param[in]    gf_group          GOP struct
+ * \param[in]    base_q_index      base layer q_index
+ * \param[in]    stats_list        array of transform stats, one per frame
+ * \param[in]    bit_depth         bit depth
+ * \param[out]   q_index_list      array of q_index, one per frame
+ * \param[out]   estimated_bitrate_byframe Array to keep track of frame bitrate
+ *
+ * \return The estimated GOP bitrate.
+ *
+ */
+double av1_vbr_rc_info_estimate_gop_bitrate(
+    const VBR_RATECTRL_INFO *vbr_rc_info, const GF_GROUP *gf_group,
+    int base_q_index, const TplTxfmStats *stats_list, aom_bit_depth_t bit_depth,
+    int *q_index_list, double *estimated_bitrate_byframe);
+
+/*!\brief Estimate the optimal base q index for a GOP.
+ *
+ * This function uses a binary search to find base layer q index to
+ * achieve the specified bit budget.
+ *
+ * \param[out]  vbr_rc_info       Rate control info for BITRATE_ACCURACY
+ *                                experiment
+ * \param[in]   gf_group          GOP structure
+ * \param[in]   txfm_stats_list   Transform stats struct
+ * \param[in]   bit_budget        The specified bit budget to achieve
+ * \param[in]   bit_depth         bit depth
+ * \param[out]  q_index_list      array of q indices for the GOP inferred from
+ * base q index using qstep_ratio_list. \param[out]  estimated_bitrate_byframe
+ * bits usage per frame in the GOP
+ *
+ * \return Returns the optimal base q index to use.
+ */
+int av1_vbr_rc_info_estimate_base_q(const VBR_RATECTRL_INFO *vbr_rc_info,
+                                    const GF_GROUP *gf_group,
+                                    const TplTxfmStats *txfm_stats_list,
+                                    double bit_budget,
+                                    aom_bit_depth_t bit_depth,
+                                    int *q_index_list,
+                                    double *estimated_bitrate_byframe);
+
+/*!\brief For a GOP, calculate the bits used by motion vectors.
+ *
+ * \param[in]       tpl_data          TPL struct
+ * \param[in]       gf_group          GOP struct
+ * \param[in]       vbr_rc_info       Rate control info struct
+ *
+ * \return Bits used by the motion vectors for the GOP.
+ */
+double av1_tpl_compute_mv_bits(const TplParams *tpl_data,
+                               const GF_GROUP *gf_group,
+                               VBR_RATECTRL_INFO *vbr_rc_info);
 #endif  // CONFIG_BITRATE_ACCURACY
 
 #if CONFIG_RD_COMMAND
@@ -430,24 +474,6 @@
                                        int coeff_num);
 
 /*
- *!\brief Compute the number of bits needed to encode a GOP
- *
- * \param[in]    q_index_list      array of q_index, one per frame
- * \param[in]    frame_count       number of frames in the GOP
- * \param[in]    stats             array of transform stats, one per frame
- * \param[in]    stats_valid_list  List indicates whether transform stats
- *                                 exists
- * \param[out]   bitrate_byframe_list    Array to keep track of frame bitrate
- *
- * \return The estimated GOP bitrate.
- *
- */
-double av1_estimate_gop_bitrate(const int *q_index_list, const int frame_count,
-                                const TplTxfmStats *stats,
-                                const int *stats_valid_list,
-                                double *bitrate_byframe_list);
-
-/*
  *!\brief Init TplTxfmStats
  *
  * \param[in]    tpl_txfm_stats  a structure for storing transform stats
@@ -477,6 +503,16 @@
 void av1_record_tpl_txfm_block(TplTxfmStats *tpl_txfm_stats,
                                const tran_low_t *coeff);
 
+/*
+ *!\brief Update abs_coeff_mean and ready of txfm_stats
+ * If txfm_block_count > 0, this function will use abs_coeff_sum and
+ * txfm_block_count to compute abs_coeff_mean. Moreover, reday flag
+ * will be set to one.
+ *
+ * \param[in]  txfm_stats     A structure for storing transform stats
+ */
+void av1_tpl_txfm_stats_update_abs_coeff_mean(TplTxfmStats *txfm_stats);
+
 /*!\brief  Estimate coefficient entropy using Laplace dsitribution
  *
  *\ingroup tpl_modelling
@@ -533,33 +569,6 @@
 int av1_get_overlap_area(int row_a, int col_a, int row_b, int col_b, int width,
                          int height);
 
-/*!\brief Estimate the optimal base q index for a GOP.
- *
- * This function picks q based on a chosen bit rate. It
- * estimates the bit rate using the starting base q, then uses
- * a binary search to find q to achieve the specified bit rate.
- *
- * \param[in]       gf_group          GOP structure
- * \param[in]       txfm_stats_list   Transform stats struct
- * \param[in]       stats_valid_list  List indicates whether transform stats
- *                                    exists
- * \param[in]       bit_budget        The specified bit budget to achieve
- * \param[in]       bit_depth         bit depth
- * \param[in]       scale_factor      Scale factor to improve budget estimation
- * \param[in]       qstep_ratio_list  Stores the qstep_ratio for each frame
- * \param[out]      q_index_list      array of q_index, one per frame
- * \param[out]      estimated_bitrate_byframe  bits usage per frame in the GOP
- *
- * \return Returns the optimal base q index to use.
- */
-int av1_q_mode_estimate_base_q(const struct GF_GROUP *gf_group,
-                               const TplTxfmStats *txfm_stats_list,
-                               const int *stats_valid_list, double bit_budget,
-                               aom_bit_depth_t bit_depth, double scale_factor,
-                               const double *qstep_ratio_list,
-                               int *q_index_list,
-                               double *estimated_bitrate_byframe);
-
 /*!\brief Get current frame's q_index from tpl stats and leaf_qindex
  *
  * \param[in]       tpl_data          TPL struct
@@ -606,33 +615,6 @@
 int av1_get_q_index_from_qstep_ratio(int leaf_qindex, double qstep_ratio,
                                      aom_bit_depth_t bit_depth);
 
-#if CONFIG_BITRATE_ACCURACY
-/*!\brief Update q_index_list in vbr_rc_info based on tpl stats
- *
- * \param[out]      vbr_rc_info    Rate control info for BITRATE_ACCURACY
- *                                 experiment
- * \param[in]       tpl_data       TPL struct
- * \param[in]       gf_group       GOP struct
- * \param[in]       bit_depth      bit depth
- */
-void av1_vbr_rc_update_q_index_list(VBR_RATECTRL_INFO *vbr_rc_info,
-                                    const TplParams *tpl_data,
-                                    const struct GF_GROUP *gf_group,
-                                    aom_bit_depth_t bit_depth);
-
-/*!\brief For a GOP, calculate the bits used by motion vectors.
- *
- * \param[in]       tpl_data          TPL struct
- * \param[in]       gf_group          GOP struct
- * \param[in]       vbr_rc_info       Rate control info struct
- *
- * \return Bits used by the motion vectors for the GOP.
- */
-double av1_tpl_compute_mv_bits(const TplParams *tpl_data,
-                               const GF_GROUP *gf_group,
-                               VBR_RATECTRL_INFO *vbr_rc_info);
-#endif  // CONFIG_BITRATE_ACCURACY
-
 /*!\brief Improve the motion vector estimation by taking neighbors into account.
  *
  * Use the upper and left neighbor block as the reference MVs.
diff --git a/test/tpl_model_test.cc b/test/tpl_model_test.cc
index b507a8a..3d097de 100644
--- a/test/tpl_model_test.cc
+++ b/test/tpl_model_test.cc
@@ -19,6 +19,10 @@
 
 namespace {
 
+#if CONFIG_BITRATE_ACCURACY
+constexpr double epsilon = 0.0000001;
+#endif
+
 double laplace_prob(double q_step, double b, double zero_bin_ratio,
                     int qcoeff) {
   int abs_qcoeff = abs(qcoeff);
@@ -147,33 +151,6 @@
   EXPECT_EQ(overlap_area, 0);
 }
 
-TEST(TPLModelTest, EstimateFrameRateTest) {
-  /*
-   * Transform size: 16x16
-   * Frame count: 16
-   * Transform block count: 20
-   */
-  const int txfm_size = 256;  // 16x16
-  const int frame_count = 16;
-  int q_index_list[16];
-  int valid_list[16];
-  TplTxfmStats stats_list[16];
-
-  for (int i = 0; i < frame_count; i++) {
-    q_index_list[i] = 1;
-    valid_list[i] = 1;
-    stats_list[i].txfm_block_count = 8;
-
-    for (int j = 0; j < txfm_size; j++) {
-      stats_list[i].abs_coeff_sum[j] = 0;
-    }
-  }
-
-  double result = av1_estimate_gop_bitrate(q_index_list, frame_count,
-                                           stats_list, valid_list, NULL);
-  EXPECT_NEAR(result, 0, 0.1);
-}
-
 TEST(TPLModelTest, TxfmStatsInitTest) {
   TplTxfmStats tpl_txfm_stats;
   av1_init_tpl_txfm_stats(&tpl_txfm_stats);
@@ -231,89 +208,6 @@
   }
 }
 
-/*
- * Helper method to brute-force search for the closest q_index
- * that achieves the specified bit budget.
- */
-int find_gop_q_iterative(double bit_budget, const double *qstep_ratio_list,
-                         GF_GROUP gf_group, const int *stats_valid_list,
-                         TplTxfmStats *stats_list, aom_bit_depth_t bit_depth) {
-  // Brute force iterative method to find the optimal q.
-  // Use the result to test against the binary search result.
-
-  // Initial estimate when q = 255
-  av1_q_mode_compute_gop_q_indices(255, qstep_ratio_list, bit_depth, &gf_group,
-                                   gf_group.q_val);
-  double curr_estimate = av1_estimate_gop_bitrate(
-      gf_group.q_val, gf_group.size, stats_list, stats_valid_list, NULL);
-  double best_estimate_budget_distance = fabs(curr_estimate - bit_budget);
-  int best_q = 255;
-
-  // Start at q = 254 because we already have an estimate for q = 255.
-  for (int q = 254; q >= 0; q--) {
-    av1_q_mode_compute_gop_q_indices(q, qstep_ratio_list, bit_depth, &gf_group,
-                                     gf_group.q_val);
-    curr_estimate = av1_estimate_gop_bitrate(
-        gf_group.q_val, gf_group.size, stats_list, stats_valid_list, NULL);
-    double curr_estimate_budget_distance = fabs(curr_estimate - bit_budget);
-    if (curr_estimate_budget_distance <= best_estimate_budget_distance) {
-      best_estimate_budget_distance = curr_estimate_budget_distance;
-      best_q = q;
-    }
-  }
-  return best_q;
-}
-
-TEST(TplModelTest, QModeEstimateBaseQTest) {
-  GF_GROUP gf_group = {};
-  gf_group.size = 25;
-  TplTxfmStats stats_list[25];
-  int q_index_list[25];
-  const int gf_group_update_types[25] = { 0, 3, 6, 6, 6, 1, 5, 1, 5, 6, 1, 5, 1,
-                                          5, 6, 6, 1, 5, 1, 5, 6, 1, 5, 1, 4 };
-  int stats_valid_list[25] = { 0 };
-  const aom_bit_depth_t bit_depth = AOM_BITS_8;
-  const double scale_factor = 1.0;
-
-  double qstep_ratio_list[25];
-  for (int i = 0; i < 25; i++) {
-    qstep_ratio_list[i] = 1;
-  }
-
-  for (int i = 0; i < gf_group.size; i++) {
-    stats_valid_list[i] = 1;
-    gf_group.update_type[i] = gf_group_update_types[i];
-    stats_list[i].txfm_block_count = 8;
-
-    for (int j = 0; j < 256; j++) {
-      stats_list[i].abs_coeff_sum[j] = 1000 + j;
-    }
-  }
-
-  // Test multiple bit budgets.
-  const std::vector<double> bit_budgets = { 0,      100,    1000,   10000,
-                                            100000, 300000, 500000, 750000,
-                                            800000, DBL_MAX };
-
-  for (double bit_budget : bit_budgets) {
-    // Binary search method to find the optimal q.
-    const int result = av1_q_mode_estimate_base_q(
-        &gf_group, stats_list, stats_valid_list, bit_budget, bit_depth,
-        scale_factor, qstep_ratio_list, q_index_list, NULL);
-    const int test_result =
-        find_gop_q_iterative(bit_budget, qstep_ratio_list, gf_group,
-                             stats_valid_list, stats_list, bit_depth);
-
-    if (bit_budget == 0) {
-      EXPECT_EQ(result, 255);
-    } else if (bit_budget == DBL_MAX) {
-      EXPECT_EQ(result, 0);
-    }
-
-    EXPECT_EQ(result, test_result);
-  }
-}
-
 TEST(TplModelTest, ComputeMVDifferenceTest) {
   TplDepFrame tpl_frame_small;
   tpl_frame_small.is_valid = true;
@@ -420,5 +314,168 @@
   // Neighboring vectors will have different values, increasing the cost.
   EXPECT_NEAR(result, 70, 5);
 }
+#if CONFIG_BITRATE_ACCURACY
+
+TEST(TplModelTest, VbrRcInfoSetGopBitBudget) {
+  VBR_RATECTRL_INFO vbr_rc_info;
+  const double total_bit_budget = 2000;
+  const int show_frame_count = 8;
+  const int gop_show_frame_count = 4;
+  av1_vbr_rc_init(&vbr_rc_info, total_bit_budget, show_frame_count);
+  av1_vbr_rc_set_gop_bit_budget(&vbr_rc_info, gop_show_frame_count);
+  EXPECT_NEAR(vbr_rc_info.gop_bit_budget, 1000, epsilon);
+}
+
+void init_toy_gf_group(GF_GROUP *gf_group) {
+  av1_zero(*gf_group);
+  gf_group->size = 4;
+  const FRAME_UPDATE_TYPE update_type[4] = { KF_UPDATE, ARF_UPDATE,
+                                             INTNL_ARF_UPDATE, LF_UPDATE };
+  for (int i = 0; i < gf_group->size; ++i) {
+    gf_group->update_type[i] = update_type[i];
+  }
+}
+
+void init_toy_vbr_rc_info(VBR_RATECTRL_INFO *vbr_rc_info, int gop_size) {
+  int total_bit_budget = 2000;
+  int show_frame_count = 8;
+  av1_vbr_rc_init(vbr_rc_info, total_bit_budget, show_frame_count);
+
+  for (int i = 0; i < gop_size; ++i) {
+    vbr_rc_info->qstep_ratio_list[i] = 1;
+  }
+}
+
+void init_toy_tpl_txfm_stats(std::vector<TplTxfmStats> *stats_list) {
+  for (size_t i = 0; i < stats_list->size(); i++) {
+    TplTxfmStats *txfm_stats = &stats_list->at(i);
+    av1_init_tpl_txfm_stats(txfm_stats);
+    txfm_stats->txfm_block_count = 8;
+    for (int j = 0; j < txfm_stats->coeff_num; j++) {
+      txfm_stats->abs_coeff_sum[j] = 1000 + j;
+    }
+    av1_tpl_txfm_stats_update_abs_coeff_mean(txfm_stats);
+  }
+}
+
+/*
+ * Helper method to brute-force search for the closest q_index
+ * that achieves the specified bit budget.
+ */
+int find_gop_q_iterative(const VBR_RATECTRL_INFO *vbr_rc_info,
+                         const GF_GROUP *gf_group,
+                         const TplTxfmStats *txfm_stats_list, double bit_budget,
+                         aom_bit_depth_t bit_depth, int *q_index_list,
+                         double *estimated_bitrate_byframe) {
+  int best_q = 255;
+  double curr_estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+      vbr_rc_info, gf_group, best_q, txfm_stats_list, bit_depth, q_index_list,
+      estimated_bitrate_byframe);
+  double min_bits_diff = fabs(curr_estimate - bit_budget);
+  // Start at q = 254 because we already have an estimate for q = 255.
+  for (int q = 254; q >= 0; q--) {
+    double curr_estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+        vbr_rc_info, gf_group, q, txfm_stats_list, bit_depth, q_index_list,
+        estimated_bitrate_byframe);
+    double bits_diff = fabs(curr_estimate - bit_budget);
+    if (bits_diff <= min_bits_diff) {
+      min_bits_diff = bits_diff;
+      best_q = q;
+    }
+  }
+  return best_q;
+}
+
+TEST(TPLModelTest, EstimateFrameRateTest) {
+  GF_GROUP gf_group;
+  init_toy_gf_group(&gf_group);
+
+  VBR_RATECTRL_INFO vbr_rc_info;
+  init_toy_vbr_rc_info(&vbr_rc_info, gf_group.size);
+
+  std::vector<TplTxfmStats> stats_list(gf_group.size);
+  init_toy_tpl_txfm_stats(&stats_list);
+  const aom_bit_depth_t bit_depth = AOM_BITS_8;
+
+  const int q = 125;
+
+  // Case1: all scale factors are 0
+  double scale_factors[FRAME_UPDATE_TYPES] = { 0 };
+  memcpy(vbr_rc_info.scale_factors, scale_factors, sizeof(scale_factors));
+  double estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+      &vbr_rc_info, &gf_group, q, stats_list.data(), bit_depth,
+      vbr_rc_info.q_index_list, vbr_rc_info.estimated_bitrate_byframe);
+  EXPECT_NEAR(estimate, 0, epsilon);
+
+  // Case2: all scale factors are 1
+  for (int i = 0; i < FRAME_UPDATE_TYPES; i++) {
+    scale_factors[i] = 1;
+  }
+  memcpy(vbr_rc_info.scale_factors, scale_factors, sizeof(scale_factors));
+  estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+      &vbr_rc_info, &gf_group, q, stats_list.data(), bit_depth,
+      vbr_rc_info.q_index_list, vbr_rc_info.estimated_bitrate_byframe);
+  double ref_estimate = 0;
+  for (int i = 0; i < gf_group.size; i++) {
+    ref_estimate += vbr_rc_info.estimated_bitrate_byframe[i];
+  }
+  EXPECT_NEAR(estimate, ref_estimate, epsilon);
+
+  // Case3: Key frame scale factor is 0 and others are 1
+  for (int i = 0; i < FRAME_UPDATE_TYPES; i++) {
+    if (i == KF_UPDATE) {
+      scale_factors[i] = 0;
+    } else {
+      scale_factors[i] = 1;
+    }
+  }
+  memcpy(vbr_rc_info.scale_factors, scale_factors, sizeof(scale_factors));
+  estimate = av1_vbr_rc_info_estimate_gop_bitrate(
+      &vbr_rc_info, &gf_group, q, stats_list.data(), bit_depth,
+      vbr_rc_info.q_index_list, vbr_rc_info.estimated_bitrate_byframe);
+  ref_estimate = 0;
+  for (int i = 0; i < gf_group.size; i++) {
+    if (gf_group.update_type[i] != KF_UPDATE) {
+      ref_estimate += vbr_rc_info.estimated_bitrate_byframe[i];
+    }
+  }
+  EXPECT_NEAR(estimate, ref_estimate, epsilon);
+}
+
+TEST(TplModelTest, VbrRcInfoEstimateBaseQTest) {
+  GF_GROUP gf_group;
+  init_toy_gf_group(&gf_group);
+
+  VBR_RATECTRL_INFO vbr_rc_info;
+  init_toy_vbr_rc_info(&vbr_rc_info, gf_group.size);
+
+  VBR_RATECTRL_INFO ref_vbr_rc_info;
+  init_toy_vbr_rc_info(&ref_vbr_rc_info, gf_group.size);
+
+  std::vector<TplTxfmStats> stats_list(gf_group.size);
+  init_toy_tpl_txfm_stats(&stats_list);
+  const aom_bit_depth_t bit_depth = AOM_BITS_8;
+
+  // Test multiple bit budgets.
+  const std::vector<double> bit_budgets = { 0,     2470,  19200,  30750,
+                                            41315, 65017, DBL_MAX };
+
+  for (double bit_budget : bit_budgets) {
+    // Binary search method to find the optimal q.
+    const int base_q = av1_vbr_rc_info_estimate_base_q(
+        &vbr_rc_info, &gf_group, stats_list.data(), bit_budget, bit_depth,
+        vbr_rc_info.q_index_list, vbr_rc_info.estimated_bitrate_byframe);
+    const int ref_base_q = find_gop_q_iterative(
+        &ref_vbr_rc_info, &gf_group, stats_list.data(), bit_budget, bit_depth,
+        ref_vbr_rc_info.q_index_list, vbr_rc_info.estimated_bitrate_byframe);
+    if (bit_budget == 0) {
+      EXPECT_EQ(base_q, 255);
+    } else if (bit_budget == DBL_MAX) {
+      EXPECT_EQ(base_q, 0);
+    }
+    EXPECT_EQ(base_q, ref_base_q);
+  }
+}
+#endif  // CONFIG_BITRATE_ACCURACY
 
 }  // namespace