diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index 7338d15..ef516e8 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -313,11 +313,6 @@
     const int frame_order = (int)buf->display_order_hint;
     frame_level = buf->pyramid_level;
 
-    // Handle special cases where the pyramid level computed in the gf group
-    // won't match the assumptions made in the subgop cfg.
-    frame_level =
-        get_true_pyr_level(frame_level, frame_order, gf_group.max_layer_depth);
-
     // Sometimes a frame index is in multiple reference buffers.
     // Do not add a frame to the pyramid list multiple times.
     int found = 0;
@@ -1235,7 +1230,218 @@
   return INVALID_IDX;
 }
 
-void av1_get_ref_frames(AV1_COMP *const cpi, RefBufferStack *ref_buffer_stack) {
+/*!\cond */
+// Struct to keep track of relevant reference frame data
+typedef struct {
+  int map_idx;
+  int disp_order;
+  int pyr_level;
+  int used;
+} RefBufMapData;
+/*!\endcond */
+
+// Comparison function to sort reference frames in ascending display order
+static int compare_map_idx_pair_asc(const void *a, const void *b) {
+  if (((RefBufMapData *)a)->disp_order == ((RefBufMapData *)b)->disp_order) {
+    return 0;
+  } else if (((const RefBufMapData *)a)->disp_order >
+             ((const RefBufMapData *)b)->disp_order) {
+    return 1;
+  } else {
+    return -1;
+  }
+}
+
+// Checks to see if a particular reference frame is already in the reference
+// frame map
+static int is_in_ref_map(RefBufMapData *map, int disp_order, int n_frames) {
+  for (int i = 0; i < n_frames; i++) {
+    if (disp_order == map[i].disp_order) return 1;
+  }
+  return 0;
+}
+
+// Add a reference buffer index to a named reference slot
+static void add_ref_to_slot(RefBufMapData *ref, int *const remapped_ref_idx,
+                            int frame) {
+  remapped_ref_idx[frame - LAST_FRAME] = ref->map_idx;
+  ref->used = 1;
+}
+
+// Find which reference buffer should be left out of the named mapping.
+// This is because there are 8 reference buffers and only 7 named slots.
+static void set_unmapped_ref(RefBufMapData *buffer_map, int n_bufs,
+                             int min_level, int cur_frame_disp) {
+  int max_dist = 0;
+  int unmapped_idx = -1;
+  if (n_bufs <= ALTREF_FRAME) return;
+  for (int i = 0; i < n_bufs; i++) {
+    if (buffer_map[i].used) continue;
+    if (buffer_map[i].pyr_level != min_level) {
+      int dist = abs(cur_frame_disp - buffer_map[i].disp_order);
+      if (dist > max_dist) {
+        max_dist = dist;
+        unmapped_idx = i;
+      }
+    }
+  }
+  assert(unmapped_idx >= 0 && "Unmapped reference not found");
+  buffer_map[unmapped_idx].used = 1;
+}
+
+static void get_ref_frames_subgop(
+    AV1_COMP *const cpi, RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
+  AV1_COMMON *cm = &cpi->common;
+  GF_GROUP gf_group = cpi->gf_group;
+  int *const remapped_ref_idx = cm->remapped_ref_idx;
+
+  // The current display index stored has not yet been updated. We must add
+  // The order offset to get the correct value here.
+  const int order_offset = gf_group.arf_src_offset[gf_group.index];
+  const int cur_frame_disp =
+      cpi->common.current_frame.frame_number + order_offset;
+  int buf_map_idx = 0;
+
+  // Initialize reference frame mappings
+  for (int i = 0; i < REF_FRAMES; ++i) remapped_ref_idx[i] = INVALID_IDX;
+
+  RefBufMapData buffer_map[REF_FRAMES];
+  int n_bufs = 0;
+  memset(buffer_map, 0, REF_FRAMES * sizeof(buffer_map[0]));
+  int min_level = MAX_ARF_LAYERS;
+  int max_level = 0;
+
+  // Go through current reference buffers and store display order, pyr level,
+  // and map index.
+  for (int map_idx = 0; map_idx < REF_FRAMES; map_idx++) {
+    // Get reference frame buffer
+    RefFrameMapPair ref_pair = ref_frame_map_pairs[map_idx];
+    if (ref_pair.disp_order == -1) continue;
+    const int frame_order = ref_pair.disp_order;
+    // Avoid duplicates
+    if (is_in_ref_map(buffer_map, frame_order, n_bufs)) continue;
+    const int reference_frame_level = ref_pair.pyr_level;
+
+    // Keep track of the lowest and highest levels that currently exist
+    if (reference_frame_level < min_level) min_level = reference_frame_level;
+    if (reference_frame_level > max_level) max_level = reference_frame_level;
+
+    buffer_map[n_bufs].map_idx = map_idx;
+    buffer_map[n_bufs].disp_order = frame_order;
+    buffer_map[n_bufs].pyr_level = reference_frame_level;
+    buffer_map[n_bufs].used = 0;
+    n_bufs++;
+  }
+
+  // Sort frames in ascending display order
+  qsort(buffer_map, n_bufs, sizeof(buffer_map[0]), compare_map_idx_pair_asc);
+
+  int n_min_level_refs = 0;
+  int n_past_high_level = 0;
+  int closest_past_ref = -1;
+
+  // Find the GOLDEN_FRAME and BWDREF_FRAME.
+  // Also collect various stats about the reference frames for the remaining
+  // mappings
+  for (int i = n_bufs - 1; i >= 0; i--) {
+    if (buffer_map[i].pyr_level == min_level) {
+      // Keep track of the number of lowest level frames
+      n_min_level_refs++;
+      if (buffer_map[i].disp_order < cur_frame_disp &&
+          remapped_ref_idx[GOLDEN_FRAME - LAST_FRAME] == INVALID_IDX) {
+        // Map the GOLDEN_FRAME
+        add_ref_to_slot(&buffer_map[i], remapped_ref_idx, GOLDEN_FRAME);
+      }
+    } else if (buffer_map[i].disp_order == cur_frame_disp) {
+      // Map the BWDREF_FRAME if this is the show_existing_frame
+      add_ref_to_slot(&buffer_map[i], remapped_ref_idx, BWDREF_FRAME);
+    }
+
+    // Keep track of the number of past frames that are not at the lowest level
+    if (buffer_map[i].disp_order < cur_frame_disp &&
+        buffer_map[i].pyr_level != min_level)
+      n_past_high_level++;
+
+    // Keep track of where the frames change from being past frames to future
+    // frames
+    if (buffer_map[i].disp_order < cur_frame_disp && closest_past_ref < 0)
+      closest_past_ref = i;
+  }
+
+  // Find the buffer to be excluded from the mapping
+  set_unmapped_ref(buffer_map, n_bufs, min_level, cur_frame_disp);
+
+  // Map LAST3_FRAME
+  if (n_bufs >= ALTREF_FRAME) {
+    const int use_low_level_last3 =
+        n_past_high_level < 4 && n_bufs > ALTREF_FRAME;
+    for (int i = 0; i < n_bufs; i++) {
+      if (buffer_map[i].used) continue;
+      if ((buffer_map[i].pyr_level != min_level ||
+           (use_low_level_last3 && buffer_map[i].pyr_level == min_level))) {
+        add_ref_to_slot(&buffer_map[i], remapped_ref_idx, LAST3_FRAME);
+        break;
+      }
+    }
+  }
+
+  // Assign low level frames
+  buf_map_idx = n_bufs - 1;
+  for (int frame = ALTREF_FRAME; frame >= LAST_FRAME; frame--) {
+    // Continue if the current ref slot is already full
+    if (remapped_ref_idx[frame - LAST_FRAME] != INVALID_IDX) continue;
+    // Find the next unmapped low level reference buffer
+    for (; buf_map_idx >= 0; buf_map_idx--) {
+      if (buffer_map[buf_map_idx].pyr_level != min_level) continue;
+      if (!buffer_map[buf_map_idx].used) break;
+    }
+    if (buf_map_idx < 0) break;
+    if (buffer_map[buf_map_idx].used) break;
+    add_ref_to_slot(&buffer_map[buf_map_idx], remapped_ref_idx, frame);
+  }
+
+  // Place remaining past frames
+  buf_map_idx = closest_past_ref;
+  for (int frame = LAST_FRAME; frame < REF_FRAMES; frame++) {
+    // Continue if the current ref slot is already full
+    if (remapped_ref_idx[frame - LAST_FRAME] != INVALID_IDX) continue;
+    // Find the next unmapped reference buffer
+    for (; buf_map_idx >= 0; buf_map_idx--) {
+      if (!buffer_map[buf_map_idx].used) break;
+    }
+    if (buf_map_idx < 0) break;
+    if (buffer_map[buf_map_idx].used) break;
+    add_ref_to_slot(&buffer_map[buf_map_idx], remapped_ref_idx, frame);
+  }
+
+  // Place remaining future frames
+  buf_map_idx = n_bufs - 1;
+  for (int frame = ALTREF_FRAME; frame >= LAST_FRAME; frame--) {
+    // Continue if the current ref slot is already full
+    if (remapped_ref_idx[frame - LAST_FRAME] != INVALID_IDX) continue;
+    // Find the next unmapped reference buffer
+    for (; buf_map_idx > closest_past_ref; buf_map_idx--) {
+      if (!buffer_map[buf_map_idx].used) break;
+    }
+    if (buf_map_idx < 0) break;
+    if (buffer_map[buf_map_idx].used) break;
+    add_ref_to_slot(&buffer_map[buf_map_idx], remapped_ref_idx, frame);
+  }
+
+  // Fill any slots that are empty (should only happen for the first 7 frames)
+  for (int i = 0; i < REF_FRAMES; ++i)
+    if (remapped_ref_idx[i] == INVALID_IDX) remapped_ref_idx[i] = 0;
+}
+
+void av1_get_ref_frames(AV1_COMP *const cpi, RefBufferStack *ref_buffer_stack,
+                        RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]) {
+  // TODO(sarahparker) Fix compatibility with tpl model
+  if (!cpi->oxcf.algo_cfg.enable_tpl_model &&
+      use_subgop_cfg(&cpi->gf_group, cpi->gf_group.index)) {
+    get_ref_frames_subgop(cpi, ref_frame_map_pairs);
+    return;
+  }
+
   AV1_COMMON *cm = &cpi->common;
   int *const remapped_ref_idx = cm->remapped_ref_idx;
   int *const arf_stack = ref_buffer_stack->arf_stack;
@@ -1489,12 +1695,15 @@
                                frame_update_type, frame_params.frame_type,
                                force_refresh_all);
 
+  RefFrameMapPair ref_frame_map_pairs[REF_FRAMES];
+  init_ref_map_pair(cpi, ref_frame_map_pairs);
+
   if (!is_stat_generation_stage(cpi)) {
     const RefCntBuffer *ref_frames[INTER_REFS_PER_FRAME];
     const YV12_BUFFER_CONFIG *ref_frame_buf[INTER_REFS_PER_FRAME];
 
     if (!ext_flags->refresh_frame.update_pending) {
-      av1_get_ref_frames(cpi, &cpi->ref_buffer_stack);
+      av1_get_ref_frames(cpi, &cpi->ref_buffer_stack, ref_frame_map_pairs);
     } else if (cpi->svc.external_ref_frame_config) {
       for (unsigned int i = 0; i < INTER_REFS_PER_FRAME; i++)
         cm->remapped_ref_idx[i] = cpi->svc.ref_idx[i];
@@ -1531,9 +1740,6 @@
     const int cur_frame_disp =
         cpi->common.current_frame.frame_number + frame_params.order_offset;
 
-    RefFrameMapPair ref_frame_map_pairs[REF_FRAMES];
-    init_ref_map_pair(cpi, ref_frame_map_pairs);
-
     frame_params.refresh_frame_flags = av1_get_refresh_frame_flags(
         cpi, &frame_params, frame_update_type, cpi->gf_group.index,
         cur_frame_disp, ref_frame_map_pairs, &cpi->ref_buffer_stack);
diff --git a/av1/encoder/encode_strategy.h b/av1/encoder/encode_strategy.h
index 59ee094..e236fc5 100644
--- a/av1/encoder/encode_strategy.h
+++ b/av1/encoder/encode_strategy.h
@@ -81,7 +81,8 @@
                               int show_existing_frame, int ref_map_index,
                               RefBufferStack *ref_buffer_stack);
 
-void av1_get_ref_frames(AV1_COMP *const cpi, RefBufferStack *ref_buffer_stack);
+void av1_get_ref_frames(AV1_COMP *const cpi, RefBufferStack *ref_buffer_stack,
+                        RefFrameMapPair ref_frame_map_pairs[REF_FRAMES]);
 
 int is_forced_keyframe_pending(struct lookahead_ctx *lookahead,
                                const int up_to_index,
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 2e42c9d..b5e8287 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -3176,7 +3176,9 @@
   current_frame->order_hint =
       current_frame->frame_number + frame_params->order_offset;
   current_frame->display_order_hint = current_frame->order_hint;
-  current_frame->pyramid_level = cpi->gf_group.layer_depth[cpi->gf_group.index];
+  current_frame->pyramid_level = get_true_pyr_level(
+      cpi->gf_group.layer_depth[cpi->gf_group.index],
+      current_frame->display_order_hint, cpi->gf_group.max_layer_depth);
 
   current_frame->absolute_poc =
       current_frame->key_frame_number + current_frame->display_order_hint;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index bc88f74..f14da5d 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -118,6 +118,21 @@
   FRAMEFLAGS_ERROR_RESILIENT = 1 << 6,
 } UENUM1BYTE(FRAMETYPE_FLAGS);
 
+static INLINE int get_true_pyr_level(int frame_level, int frame_order,
+                                     int max_layer_depth) {
+  if (frame_order == 0) {
+    // Keyframe case
+    return 1;
+  } else if (frame_level == MAX_ARF_LAYERS) {
+    // Leaves
+    return max_layer_depth;
+  } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
+    // Altrefs
+    return 1;
+  }
+  return frame_level;
+}
+
 enum {
   NO_AQ = 0,
   VARIANCE_AQ = 1,
@@ -2812,21 +2827,6 @@
 void av1_set_screen_content_options(const struct AV1_COMP *cpi,
                                     FeatureFlags *features);
 
-static INLINE int get_true_pyr_level(int frame_level, int frame_order,
-                                     int max_layer_depth) {
-  if (frame_order == 0) {
-    // Keyframe case
-    return 1;
-  } else if (frame_level == MAX_ARF_LAYERS) {
-    // Leaves
-    return max_layer_depth;
-  } else if (frame_level == (MAX_ARF_LAYERS + 1)) {
-    // Altrefs
-    return 1;
-  }
-  return frame_level;
-}
-
 typedef struct {
   int pyr_level;
   int disp_order;
@@ -2840,9 +2840,7 @@
     const RefCntBuffer *const buf = cpi->common.ref_frame_map[map_idx];
     if (buf == NULL) continue;
     ref_frame_map_pairs[map_idx].disp_order = (int)buf->display_order_hint;
-    const int reference_frame_level = get_true_pyr_level(
-        buf->pyramid_level, ref_frame_map_pairs[map_idx].disp_order,
-        cpi->gf_group.max_layer_depth);
+    const int reference_frame_level = buf->pyramid_level;
     ref_frame_map_pairs[map_idx].pyr_level = reference_frame_level;
   }
 }
@@ -3301,6 +3299,7 @@
   cpi->frame_component_time[component] +=
       aom_usec_timer_elapsed(&cpi->component_timer[component]);
 }
+
 static INLINE char const *get_frame_type_enum(int type) {
   switch (type) {
     case 0: return "KEY_FRAME";
diff --git a/av1/encoder/tpl_model.c b/av1/encoder/tpl_model.c
index 0a39855..e4e2732 100644
--- a/av1/encoder/tpl_model.c
+++ b/av1/encoder/tpl_model.c
@@ -1010,7 +1010,7 @@
       ++process_frame_count;
     }
 
-    av1_get_ref_frames(cpi, &ref_buffer_stack);
+    av1_get_ref_frames(cpi, &ref_buffer_stack, ref_frame_map_pairs);
     const int true_disp =
         (int)(tpl_frame->frame_display_index) - frame_params.show_frame;
     int refresh_mask = av1_get_refresh_frame_flags(
@@ -1082,7 +1082,7 @@
     gf_group->update_type[gf_index] = LF_UPDATE;
     gf_group->q_val[gf_index] = *pframe_qindex;
 
-    av1_get_ref_frames(cpi, &ref_buffer_stack);
+    av1_get_ref_frames(cpi, &ref_buffer_stack, ref_frame_map_pairs);
     // TODO(sarahparker) av1_get_refresh_frame_flags() and
     // av1_update_ref_frame_map() will execute default behavior even when
     // subgop cfg is enabled. This should be addressed if we ever remove the
@@ -1119,7 +1119,7 @@
     ++frame_display_index;
   }
 
-  av1_get_ref_frames(cpi, &cpi->ref_buffer_stack);
+  av1_get_ref_frames(cpi, &cpi->ref_buffer_stack, ref_frame_map_pairs);
 }
 
 static AOM_INLINE void init_tpl_stats(TplParams *const tpl_data) {