diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 89e2a1b..51bbea7 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -1073,8 +1073,8 @@
   // but could do with fuller testing
   if (cm->large_scale_tile) {
     for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-      if (cm->frame_refs[i].buf != NULL)
-        cm->frame_refs[i].buf->frame_context = *cm->fc;
+      if (cm->current_frame.frame_refs[i].buf != NULL)
+        cm->current_frame.frame_refs[i].buf->frame_context = *cm->fc;
     }
     for (int i = 0; i < FRAME_BUFFERS; ++i)
       cm->buffer_pool->frame_bufs[i].frame_context = *cm->fc;
diff --git a/av1/common/mvref_common.c b/av1/common/mvref_common.c
index 858fc5d..b3d9c2f 100644
--- a/av1/common/mvref_common.c
+++ b/av1/common/mvref_common.c
@@ -347,7 +347,8 @@
 
   if (rf[1] == NONE_FRAME) {
     int cur_frame_index = cm->cur_frame->order_hint;
-    const RefCntBuffer *const buf_0 = cm->frame_refs[FWD_RF_OFFSET(rf[0])].buf;
+    const RefCntBuffer *const buf_0 =
+        cm->current_frame.frame_refs[FWD_RF_OFFSET(rf[0])].buf;
     int frame0_index = buf_0->order_hint;
     int cur_offset_0 = get_relative_dist(&cm->seq_params.order_hint_info,
                                          cur_frame_index, frame0_index);
@@ -382,12 +383,14 @@
   } else {
     // Process compound inter mode
     int cur_frame_index = cm->cur_frame->order_hint;
-    const RefCntBuffer *const buf_0 = cm->frame_refs[FWD_RF_OFFSET(rf[0])].buf;
+    const RefCntBuffer *const buf_0 =
+        cm->current_frame.frame_refs[FWD_RF_OFFSET(rf[0])].buf;
     int frame0_index = buf_0->order_hint;
 
     int cur_offset_0 = get_relative_dist(&cm->seq_params.order_hint_info,
                                          cur_frame_index, frame0_index);
-    const RefCntBuffer *const buf_1 = cm->frame_refs[FWD_RF_OFFSET(rf[1])].buf;
+    const RefCntBuffer *const buf_1 =
+        cm->current_frame.frame_refs[FWD_RF_OFFSET(rf[1])].buf;
     int frame1_index = buf_1->order_hint;
     int cur_offset_1 = get_relative_dist(&cm->seq_params.order_hint_info,
                                          cur_frame_index, frame1_index);
@@ -868,7 +871,8 @@
 
   MV_REFERENCE_FRAME ref_frame;
   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
-    const RefCntBuffer *const buf = cm->frame_refs[ref_frame - LAST_FRAME].buf;
+    const RefCntBuffer *const buf =
+        cm->current_frame.frame_refs[ref_frame - LAST_FRAME].buf;
     if (buf != NULL)
       cm->cur_frame->ref_order_hints[ref_frame - LAST_FRAME] = buf->order_hint;
   }
@@ -877,7 +881,8 @@
 void av1_setup_frame_sign_bias(AV1_COMMON *cm) {
   MV_REFERENCE_FRAME ref_frame;
   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
-    const RefCntBuffer *const buf = cm->frame_refs[ref_frame - LAST_FRAME].buf;
+    const RefCntBuffer *const buf =
+        cm->current_frame.frame_refs[ref_frame - LAST_FRAME].buf;
     if (cm->seq_params.order_hint_info.enable_order_hint && buf != NULL) {
       const int ref_order_hint = buf->order_hint;
       cm->ref_frame_sign_bias[ref_frame] =
@@ -940,7 +945,7 @@
   (void)dir;
 
   const RefCntBuffer *const start_frame_buf =
-      cm->frame_refs[FWD_RF_OFFSET(start_frame)].buf;
+      cm->current_frame.frame_refs[FWD_RF_OFFSET(start_frame)].buf;
   if (start_frame_buf == NULL) return 0;
 
   if (start_frame_buf->intra_only) return 0;
@@ -1024,7 +1029,7 @@
 
   for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) {
     const int ref_idx = ref_frame - LAST_FRAME;
-    const RefCntBuffer *const buf = cm->frame_refs[ref_idx].buf;
+    const RefCntBuffer *const buf = cm->current_frame.frame_refs[ref_idx].buf;
     int order_hint = 0;
 
     if (buf != NULL) order_hint = buf->order_hint;
@@ -1288,7 +1293,7 @@
 
   // Identify the nearest forward and backward references.
   for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    const RefCntBuffer *const buf = cm->frame_refs[i].buf;
+    const RefCntBuffer *const buf = cm->current_frame.frame_refs[i].buf;
     if (buf == NULL) continue;
 
     const int ref_order_hint = buf->order_hint;
@@ -1323,7 +1328,7 @@
     // Identify the second nearest forward reference.
     ref_order_hints[1] = -1;
     for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-      const RefCntBuffer *const buf = cm->frame_refs[i].buf;
+      const RefCntBuffer *const buf = cm->current_frame.frame_refs[i].buf;
       if (buf == NULL) continue;
 
       const int ref_order_hint = buf->order_hint;
@@ -1369,8 +1374,9 @@
 
   const int buf_idx = ref_info->buf_idx;
 
-  cm->frame_refs[frame_idx].buf = &cm->buffer_pool->frame_bufs[buf_idx];
-  cm->frame_refs[frame_idx].map_idx = ref_info->map_idx;
+  cm->current_frame.frame_refs[frame_idx].buf =
+      &cm->buffer_pool->frame_bufs[buf_idx];
+  cm->current_frame.frame_refs[frame_idx].map_idx = ref_info->map_idx;
 }
 
 void av1_set_frame_refs(AV1_COMMON *const cm, int lst_map_idx,
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 945a8dd..2a91167 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -325,6 +325,9 @@
   unsigned int order_hint;
   unsigned int frame_number;
   SkipModeInfo skip_mode_info;
+  // Each Inter frame can reference INTER_REFS_PER_FRAME buffers. This maps each
+  // (inter) reference frame type to the corresponding reference buffer.
+  RefBuffer frame_refs[INTER_REFS_PER_FRAME];
 } CurrentFrame;
 
 typedef struct AV1Common {
@@ -368,10 +371,6 @@
   // Only used in frame parallel decode.
   int next_ref_frame_map[REF_FRAMES];
 
-  // Each Inter frame can reference INTER_REFS_PER_FRAME buffers. This maps each
-  // (inter) reference frame type to the corresponding reference buffer.
-  RefBuffer frame_refs[INTER_REFS_PER_FRAME];
-
   // Index to the 'new' frame (i.e. the frame currently being encoded or
   // decoded) in the buffer pool 'cm->buffer_pool'.
   int new_fb_idx;
@@ -680,10 +679,10 @@
 
 static INLINE RefCntBuffer *get_prev_frame(const AV1_COMMON *const cm) {
   if (cm->primary_ref_frame == PRIMARY_REF_NONE ||
-      cm->frame_refs[cm->primary_ref_frame].buf == NULL) {
+      cm->current_frame.frame_refs[cm->primary_ref_frame].buf == NULL) {
     return NULL;
   } else {
-    return cm->frame_refs[cm->primary_ref_frame].buf;
+    return cm->current_frame.frame_refs[cm->primary_ref_frame].buf;
   }
 }
 
diff --git a/av1/common/pred_common.h b/av1/common/pred_common.h
index 721c8fe..f667057 100644
--- a/av1/common/pred_common.h
+++ b/av1/common/pred_common.h
@@ -91,9 +91,9 @@
                                          const MACROBLOCKD *xd) {
   MB_MODE_INFO *mbmi = xd->mi[0];
   const RefCntBuffer *const bck_buf =
-      cm->frame_refs[mbmi->ref_frame[0] - LAST_FRAME].buf;
+      cm->current_frame.frame_refs[mbmi->ref_frame[0] - LAST_FRAME].buf;
   const RefCntBuffer *const fwd_buf =
-      cm->frame_refs[mbmi->ref_frame[1] - LAST_FRAME].buf;
+      cm->current_frame.frame_refs[mbmi->ref_frame[1] - LAST_FRAME].buf;
   int bck_frame_index = 0, fwd_frame_index = 0;
   int cur_frame_index = cm->cur_frame->order_hint;
 
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index 230b55d..f338e1b 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -637,9 +637,9 @@
 
   *use_jnt_comp_avg = 1;
   const RefCntBuffer *const bck_buf =
-      cm->frame_refs[mbmi->ref_frame[0] - LAST_FRAME].buf;
+      cm->current_frame.frame_refs[mbmi->ref_frame[0] - LAST_FRAME].buf;
   const RefCntBuffer *const fwd_buf =
-      cm->frame_refs[mbmi->ref_frame[1] - LAST_FRAME].buf;
+      cm->current_frame.frame_refs[mbmi->ref_frame[1] - LAST_FRAME].buf;
   const int cur_frame_index = cm->cur_frame->order_hint;
   int bck_frame_index = 0, fwd_frame_index = 0;
 
@@ -968,7 +968,8 @@
   for (int ref = 0; ref < num_refs; ++ref) {
     const MV_REFERENCE_FRAME frame = above_mbmi->ref_frame[ref];
 
-    const RefBuffer *const ref_buf = &ctxt->cm->frame_refs[frame - LAST_FRAME];
+    const RefBuffer *const ref_buf =
+        &ctxt->cm->current_frame.frame_refs[frame - LAST_FRAME];
 
     xd->block_refs[ref] = ref_buf;
     if ((!av1_is_valid_scale(&ref_buf->sf)))
@@ -1005,7 +1006,8 @@
   for (int ref = 0; ref < num_refs; ++ref) {
     const MV_REFERENCE_FRAME frame = left_mbmi->ref_frame[ref];
 
-    const RefBuffer *const ref_buf = &ctxt->cm->frame_refs[frame - LAST_FRAME];
+    const RefBuffer *const ref_buf =
+        &ctxt->cm->current_frame.frame_refs[frame - LAST_FRAME];
 
     xd->block_refs[ref] = ref_buf;
     if ((!av1_is_valid_scale(&ref_buf->sf)))
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index f9fd0a2..d28d500 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -702,7 +702,8 @@
 
         ref = 0;
         const RefBuffer *ref_buf =
-            &cm->frame_refs[this_mbmi->ref_frame[ref] - LAST_FRAME];
+            &cm->current_frame
+                 .frame_refs[this_mbmi->ref_frame[ref] - LAST_FRAME];
 
         pd->pre[ref].buf0 = (plane == 1) ? ref_buf->buf->buf.u_buffer
                                          : ref_buf->buf->buf.v_buffer;
@@ -1062,7 +1063,7 @@
       assert(frame == INTRA_FRAME);
       assert(ref == 0);
     } else {
-      RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];
+      RefBuffer *ref_buf = &cm->current_frame.frame_refs[frame - LAST_FRAME];
 
       xd->block_refs[ref] = ref_buf;
       av1_setup_pre_planes(xd, ref, &ref_buf->buf->buf, mi_row, mi_col,
@@ -2444,7 +2445,7 @@
   int has_valid_ref_frame = 0;
   for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
     if (aom_rb_read_bit(rb)) {
-      YV12_BUFFER_CONFIG *const buf = &cm->frame_refs[i].buf->buf;
+      YV12_BUFFER_CONFIG *const buf = &cm->current_frame.frame_refs[i].buf->buf;
       width = buf->y_crop_width;
       height = buf->y_crop_height;
       cm->render_width = buf->render_width;
@@ -2474,7 +2475,7 @@
   // Check to make sure at least one of frames that this frame references
   // has valid dimensions.
   for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    RefBuffer *const ref_frame = &cm->frame_refs[i];
+    RefBuffer *const ref_frame = &cm->current_frame.frame_refs[i];
     has_valid_ref_frame |=
         valid_ref_frame_size(ref_frame->buf->buf.y_crop_width,
                              ref_frame->buf->buf.y_crop_height, width, height);
@@ -2483,7 +2484,7 @@
     aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
                        "Referenced frame has invalid size");
   for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    RefBuffer *const ref_frame = &cm->frame_refs[i];
+    RefBuffer *const ref_frame = &cm->current_frame.frame_refs[i];
     if (!valid_ref_frame_img_fmt(
             ref_frame->buf->buf.bit_depth, ref_frame->buf->buf.subsampling_x,
             ref_frame->buf->buf.subsampling_y, seq_params->bit_depth,
@@ -4721,7 +4722,7 @@
   pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1;
 
   for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-    cm->frame_refs[i].buf = NULL;
+    cm->current_frame.frame_refs[i].buf = NULL;
   }
 
   if (pbi->need_resync) {
@@ -4752,7 +4753,7 @@
   generate_next_ref_frame_map(pbi);
 
   // Reload the adapted CDFs from when we originally coded this keyframe
-  *cm->fc = cm->frame_refs[existing_frame_idx].buf->frame_context;
+  *cm->fc = cm->current_frame.frame_refs[existing_frame_idx].buf->frame_context;
 }
 
 static INLINE void reset_frame_buffers(AV1_COMMON *cm) {
@@ -5026,7 +5027,7 @@
       pbi->refresh_frame_flags = (1 << REF_FRAMES) - 1;
 
     for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-      cm->frame_refs[i].buf = NULL;
+      cm->current_frame.frame_refs[i].buf = NULL;
     }
     if (pbi->need_resync) {
       reset_ref_frame_map(cm);
@@ -5165,11 +5166,11 @@
             aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
                                "Inter frame requests nonexistent reference");
 
-          RefBuffer *const ref_frame = &cm->frame_refs[i];
+          RefBuffer *const ref_frame = &cm->current_frame.frame_refs[i];
           ref_frame->buf = &frame_bufs[idx];
           ref_frame->map_idx = ref;
         } else {
-          ref = cm->frame_refs[i].map_idx;
+          ref = cm->current_frame.frame_refs[i].map_idx;
         }
 
         cm->ref_frame_sign_bias[LAST_FRAME + i] = 0;
@@ -5208,7 +5209,7 @@
 
     cm->prev_frame = get_prev_frame(cm);
     if (cm->primary_ref_frame != PRIMARY_REF_NONE &&
-        cm->frame_refs[cm->primary_ref_frame].buf == NULL) {
+        cm->current_frame.frame_refs[cm->primary_ref_frame].buf == NULL) {
       aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
                          "Reference frame containing this frame's initial "
                          "frame context is unavailable.");
@@ -5221,7 +5222,7 @@
         cm->allow_ref_frame_mvs = 0;
 
       for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
-        RefBuffer *const ref_buf = &cm->frame_refs[i];
+        RefBuffer *const ref_buf = &cm->current_frame.frame_refs[i];
         av1_setup_scale_factors_for_frame(
             &ref_buf->sf, ref_buf->buf->buf.y_crop_width,
             ref_buf->buf->buf.y_crop_height, cm->width, cm->height);
@@ -5509,7 +5510,8 @@
     // use the default frame context values
     *cm->fc = *cm->default_frame_context;
   } else {
-    *cm->fc = cm->frame_refs[cm->primary_ref_frame].buf->frame_context;
+    *cm->fc =
+        cm->current_frame.frame_refs[cm->primary_ref_frame].buf->frame_context;
   }
   if (!cm->fc->initialized)
     aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 4cfed5b..df09996 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -1390,7 +1390,7 @@
 
   for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
     const MV_REFERENCE_FRAME frame = mbmi->ref_frame[ref];
-    RefBuffer *ref_buf = &cm->frame_refs[frame - LAST_FRAME];
+    RefBuffer *ref_buf = &cm->current_frame.frame_refs[frame - LAST_FRAME];
 
     xd->block_refs[ref] = ref_buf;
   }
diff --git a/av1/decoder/decoder.c b/av1/decoder/decoder.c
index b917648..9b958e6 100644
--- a/av1/decoder/decoder.c
+++ b/av1/decoder/decoder.c
@@ -444,7 +444,7 @@
 
     // Invalidate these references until the next frame starts.
     for (ref_index = 0; ref_index < INTER_REFS_PER_FRAME; ref_index++) {
-      cm->frame_refs[ref_index].buf = NULL;
+      cm->current_frame.frame_refs[ref_index].buf = NULL;
     }
   }
 }
@@ -467,8 +467,8 @@
     // TODO(jkoleszar): Error concealment is undefined and non-normative
     // at this point, but if it becomes so, [0] may not always be the correct
     // thing to do here.
-    if (cm->frame_refs[0].buf != NULL) {
-      cm->frame_refs[0].buf->buf.corrupted = 1;
+    if (cm->current_frame.frame_refs[0].buf != NULL) {
+      cm->current_frame.frame_refs[0].buf->buf.corrupted = 1;
     }
   }
 
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 2121a6f..a462fc7 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -1943,7 +1943,9 @@
     if (lf->mode_ref_delta_update) {
       const int prime_idx = cm->primary_ref_frame;
       const RefCntBuffer *const buf =
-          prime_idx == PRIMARY_REF_NONE ? NULL : cm->frame_refs[prime_idx].buf;
+          prime_idx == PRIMARY_REF_NONE
+              ? NULL
+              : cm->current_frame.frame_refs[prime_idx].buf;
       int8_t last_ref_deltas[REF_FRAMES];
       if (prime_idx == PRIMARY_REF_NONE || buf == NULL) {
         av1_set_default_ref_deltas(last_ref_deltas);
@@ -2875,7 +2877,7 @@
   RefBuffer frame_refs_copy[INTER_REFS_PER_FRAME];
 
   // Backup the frame refs info
-  memcpy(frame_refs_copy, cm->frame_refs,
+  memcpy(frame_refs_copy, cm->current_frame.frame_refs,
          INTER_REFS_PER_FRAME * sizeof(RefBuffer));
 
   const int lst_map_idx = get_ref_frame_map_idx(cpi, LAST_FRAME);
@@ -2890,7 +2892,8 @@
   for (int ref_idx = 0; ref_idx < INTER_REFS_PER_FRAME; ++ref_idx) {
     // Compare the buffer index between two reference frames indexed
     // respectively by the encoder and the decoder side decisions.
-    if (cm->frame_refs[ref_idx].buf != frame_refs_copy[ref_idx].buf) {
+    if (cm->current_frame.frame_refs[ref_idx].buf !=
+        frame_refs_copy[ref_idx].buf) {
       cm->frame_refs_short_signaling = 0;
       break;
     }
@@ -2904,13 +2907,14 @@
         "dec_ref(map_idx=%d)=%d\n",
         get_ref_frame_map_idx(cpi, ref_frame),
         get_ref_frame_buf_idx(cpi, ref_frame), ref_frame,
-        cm->frame_refs[ref_frame - LAST_FRAME].map_idx, ref_frame);
+        cm->current_frame.frame_refs[ref_frame - LAST_FRAME].map_idx,
+        ref_frame);
   }
 #endif  // 0
 
   // Restore the frame refs info if frame_refs_short_signaling is off.
   if (!cm->frame_refs_short_signaling)
-    memcpy(cm->frame_refs, frame_refs_copy,
+    memcpy(cm->current_frame.frame_refs, frame_refs_copy,
            INTER_REFS_PER_FRAME * sizeof(RefBuffer));
 }
 
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 452a520..8bf16dd 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -3420,7 +3420,8 @@
                          num_planes);
   } else {
     av1_setup_pre_planes(xd, ref_idx, yv12, mi_row, mi_col,
-                         &cm->frame_refs[ref - LAST_FRAME].sf, num_planes);
+                         &cm->current_frame.frame_refs[ref - LAST_FRAME].sf,
+                         num_planes);
   }
 
   mbmi->ref_frame[0] = ref;
@@ -5442,7 +5443,7 @@
       if (ref_frame == GOLDEN_FRAME || ref_frame == ALTREF_FRAME) continue;
 
       const RefCntBuffer *const buf =
-          cm->frame_refs[ref_frame - LAST_FRAME].buf;
+          cm->current_frame.frame_refs[ref_frame - LAST_FRAME].buf;
       if (buf != NULL) {
         const unsigned int ref_order_hint = buf->order_hint;
 
@@ -5511,7 +5512,7 @@
 
   int one_sided_refs = 1;
   for (int ref = 0; ref < INTER_REFS_PER_FRAME; ++ref) {
-    const RefCntBuffer *const buf = cm->frame_refs[ref].buf;
+    const RefCntBuffer *const buf = cm->current_frame.frame_refs[ref].buf;
     if (buf == NULL) continue;
 
     const int ref_order_hint = buf->order_hint;
@@ -5531,9 +5532,9 @@
   if (!skip_mode_info->skip_mode_allowed) return;
 
   const RefCntBuffer *const buf_0 =
-      cm->frame_refs[skip_mode_info->ref_frame_idx_0].buf;
+      cm->current_frame.frame_refs[skip_mode_info->ref_frame_idx_0].buf;
   const RefCntBuffer *const buf_1 =
-      cm->frame_refs[skip_mode_info->ref_frame_idx_1].buf;
+      cm->current_frame.frame_refs[skip_mode_info->ref_frame_idx_1].buf;
   assert(buf_0 != NULL && buf_1 != NULL);
 
   ref_order_hint[0] = buf_0->order_hint;
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 3011cfa..703eeb5 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -410,12 +410,13 @@
     set_sb_size(&cm->seq_params, select_sb_size(cpi));
   } else {
     if (cm->primary_ref_frame == PRIMARY_REF_NONE ||
-        cm->frame_refs[cm->primary_ref_frame].buf == NULL) {
+        cm->current_frame.frame_refs[cm->primary_ref_frame].buf == NULL) {
       av1_setup_past_independence(cm);
       cm->seg.update_map = 1;
       cm->seg.update_data = 1;
     } else {
-      *cm->fc = cm->frame_refs[cm->primary_ref_frame].buf->frame_context;
+      *cm->fc = cm->current_frame.frame_refs[cm->primary_ref_frame]
+                    .buf->frame_context;
     }
     av1_zero(cpi->interp_filter_selected[0]);
   }
@@ -4103,7 +4104,8 @@
   init_motion_estimation(cpi);
 
   for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
-    RefBuffer *const ref_buf = &cm->frame_refs[ref_frame - LAST_FRAME];
+    RefBuffer *const ref_buf =
+        &cm->current_frame.frame_refs[ref_frame - LAST_FRAME];
     const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
 
     if (buf_idx != INVALID_IDX) {
@@ -4581,7 +4583,7 @@
     // Base q-index may have changed, so we need to assign proper default coef
     // probs before every iteration.
     if (cm->primary_ref_frame == PRIMARY_REF_NONE ||
-        cm->frame_refs[cm->primary_ref_frame].buf == NULL) {
+        cm->current_frame.frame_refs[cm->primary_ref_frame].buf == NULL) {
       av1_default_coef_probs(cm);
       av1_setup_frame_contexts(cm);
     }
@@ -4924,7 +4926,7 @@
       current_frame->frame_number, current_frame->order_hint, cm->show_frame,
       cm->show_existing_frame);
   for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
-    RefBuffer *buf = &cm->frame_refs[ref_frame - LAST_FRAME];
+    RefBuffer *buf = &cm->current_frame.frame_refs[ref_frame - LAST_FRAME];
     const int ref_offset = (buf->buf) ? (int)buf->buf->order_hint : -1;
     printf(" %d(%c-%d-%4.2f)", ref_offset,
            (cpi->ref_frame_flags & flag_list[ref_frame]) ? 'Y' : 'N',
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index d2f9b84..1ff2ef7 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -1027,9 +1027,9 @@
                                 MV_REFERENCE_FRAME ref0,
                                 MV_REFERENCE_FRAME ref1) {
   xd->block_refs[0] =
-      &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME : 0];
+      &cm->current_frame.frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME : 0];
   xd->block_refs[1] =
-      &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME : 0];
+      &cm->current_frame.frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME : 0];
 }
 
 static INLINE int get_chessboard_index(int frame_index) {
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 970f53d..c4876e5 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -7038,7 +7038,8 @@
   const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
   MACROBLOCKD *const xd = &x->e_mbd;
   MB_MODE_INFO *const mbmi = xd->mi[0];
-  const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf;
+  const struct scale_factors *const sf =
+      &cm->current_frame.frame_refs[ref_frame - 1].sf;
   MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
 
   assert(yv12 != NULL);
@@ -8549,7 +8550,8 @@
   const int is_compound = has_second_ref(mbmi);
   assert(is_intrabc_block(mbmi) == 0);
   for (int j = 0; j < 1 + is_compound; ++j) {
-    const RefBuffer *ref_buf = &cm->frame_refs[mbmi->ref_frame[j] - LAST_FRAME];
+    const RefBuffer *ref_buf =
+        &cm->current_frame.frame_refs[mbmi->ref_frame[j] - LAST_FRAME];
     const struct scale_factors *const sf = &ref_buf->sf;
     // TODO(any): Refine skip flag calculation considering scaling
     if (av1_is_scaled(sf)) {
@@ -11200,7 +11202,7 @@
     unsigned int ref_offsets[2];
     for (int i = 0; i < 2; ++i) {
       const RefCntBuffer *const buf =
-          cm->frame_refs[ref_frame[i] - LAST_FRAME].buf;
+          cm->current_frame.frame_refs[ref_frame[i] - LAST_FRAME].buf;
       assert(buf != NULL);
       ref_offsets[i] = buf->order_hint;
     }
diff --git a/av1/encoder/reconinter_enc.c b/av1/encoder/reconinter_enc.c
index 9e3c7a4..87f5132 100644
--- a/av1/encoder/reconinter_enc.c
+++ b/av1/encoder/reconinter_enc.c
@@ -144,7 +144,8 @@
 
         ref = 0;
         const RefBuffer *ref_buf =
-            &cm->frame_refs[this_mbmi->ref_frame[ref] - LAST_FRAME];
+            &cm->current_frame
+                 .frame_refs[this_mbmi->ref_frame[ref] - LAST_FRAME];
 
         pd->pre[ref].buf0 = (plane == 1) ? ref_buf->buf->buf.u_buffer
                                          : ref_buf->buf->buf.v_buffer;