diff --git a/av1/encoder/firstpass.h b/av1/encoder/firstpass.h
index df99057..ce11375 100644
--- a/av1/encoder/firstpass.h
+++ b/av1/encoder/firstpass.h
@@ -167,8 +167,8 @@
                   : 0;
   }
   // Max extra (internal) alt-refs allowed based on max pyramid height.
-  assert(max_pyr_height >= 1);
-  const int ext_arfs_from_max_height = max_pyr_height - 1;
+  const int ext_arfs_from_max_height = AOMMAX(max_pyr_height - 1, 0);
+
   // Finally, min of the two above is our actual max allowance.
   return AOMMIN(extra_arfs_from_interval, ext_arfs_from_max_height);
 }
diff --git a/av1/encoder/gop_structure.c b/av1/encoder/gop_structure.c
index 20b5732..cd6c382 100644
--- a/av1/encoder/gop_structure.c
+++ b/av1/encoder/gop_structure.c
@@ -25,83 +25,92 @@
 #include "av1/encoder/firstpass.h"
 #include "av1/encoder/gop_structure.h"
 
-static void set_multi_layer_params(GF_GROUP *const gf_group, int l, int r,
+// Set parameters for frames between 'start' and 'end' (excluding both).
+static void set_multi_layer_params(GF_GROUP *const gf_group, int start, int end,
                                    int *frame_ind, int arf_ind, int level) {
-  if (r - l < 4) {
-    while (++l < r) {
-      // leaf nodes, not a look-ahead frame
+  assert(level >= MIN_PYRAMID_LVL);
+  const int num_frames_to_process = end - start - 1;
+  assert(num_frames_to_process >= 0);
+  if (num_frames_to_process == 0) return;
+
+  // Either we are at the last level of the pyramid, or we don't have enough
+  // frames between 'l' and 'r' to create one more level.
+  if (level == MIN_PYRAMID_LVL || num_frames_to_process < 3) {
+    // Leaf nodes.
+    while (++start < end) {
       gf_group->update_type[*frame_ind] = LF_UPDATE;
       gf_group->arf_src_offset[*frame_ind] = 0;
       gf_group->arf_pos_in_gf[*frame_ind] = 0;
       gf_group->arf_update_idx[*frame_ind] = arf_ind;
-      gf_group->pyramid_level[*frame_ind] = 0;
-      ++gf_group->pyramid_lvl_nodes[0];
+      gf_group->pyramid_level[*frame_ind] = MIN_PYRAMID_LVL;
+      ++gf_group->pyramid_lvl_nodes[MIN_PYRAMID_LVL];
       ++(*frame_ind);
     }
   } else {
-    int m = (l + r) / 2;
-    int arf_pos_in_gf = *frame_ind;
+    const int m = (start + end) / 2;
+    const int arf_pos_in_gf = *frame_ind;
 
+    // Internal ARF.
     gf_group->update_type[*frame_ind] = INTNL_ARF_UPDATE;
-    gf_group->arf_src_offset[*frame_ind] = m - l - 1;
+    gf_group->arf_src_offset[*frame_ind] = m - start - 1;
     gf_group->arf_pos_in_gf[*frame_ind] = 0;
     gf_group->arf_update_idx[*frame_ind] = 1;  // mark all internal ARF 1
     gf_group->pyramid_level[*frame_ind] = level;
     ++gf_group->pyramid_lvl_nodes[level];
     ++(*frame_ind);
 
-    // set parameters for frames displayed before this frame
-    set_multi_layer_params(gf_group, l, m, frame_ind, 1, level - 1);
+    // Frames displayed before this internal ARF.
+    set_multi_layer_params(gf_group, start, m, frame_ind, 1, level - 1);
 
-    // for overlay frames, we need to record the position of its corresponding
-    // arf frames for bit allocation
+    // Overlay for internal ARF.
     gf_group->update_type[*frame_ind] = INTNL_OVERLAY_UPDATE;
     gf_group->arf_src_offset[*frame_ind] = 0;
-    gf_group->arf_pos_in_gf[*frame_ind] = arf_pos_in_gf;
+    gf_group->arf_pos_in_gf[*frame_ind] = arf_pos_in_gf;  // For bit allocation.
     gf_group->arf_update_idx[*frame_ind] = 1;
-    gf_group->pyramid_level[*frame_ind] = 0;
+    gf_group->pyramid_level[*frame_ind] = MIN_PYRAMID_LVL;
     ++(*frame_ind);
 
-    // set parameters for frames displayed after this frame
-    set_multi_layer_params(gf_group, m, r, frame_ind, arf_ind, level - 1);
+    // Frames displayed after this internal ARF.
+    set_multi_layer_params(gf_group, m, end, frame_ind, arf_ind, level - 1);
   }
 }
 
-static INLINE unsigned char get_pyramid_height(int pyramid_width) {
-  assert(pyramid_width <= MAX_GF_INTERVAL && pyramid_width >= MIN_GF_INTERVAL &&
-         "invalid gf interval for pyramid structure");
-
-  return pyramid_width > 12 ? 4 : (pyramid_width > 6 ? 3 : 2);
-}
-
-static int construct_multi_layer_gf_structure(GF_GROUP *const gf_group,
-                                              const int gf_interval) {
-  int frame_index = 0;
-  gf_group->pyramid_height = get_pyramid_height(gf_interval);
-
-  assert(gf_group->pyramid_height <= MAX_PYRAMID_LVL);
-
+static int construct_multi_layer_gf_structure(
+    GF_GROUP *const gf_group, int gf_interval, int pyr_height,
+    FRAME_UPDATE_TYPE first_frame_update_type) {
+  gf_group->pyramid_height = pyr_height;
   av1_zero_array(gf_group->pyramid_lvl_nodes, MAX_PYRAMID_LVL);
+  int frame_index = 0;
 
-  // At the beginning of each GF group it will be a key or overlay frame,
-  gf_group->update_type[frame_index] = OVERLAY_UPDATE;
+  // Keyframe / Overlay frame / Golden frame.
+  assert(gf_interval >= 1);
+  assert(first_frame_update_type == KF_UPDATE ||
+         first_frame_update_type == OVERLAY_UPDATE ||
+         first_frame_update_type == GF_UPDATE);
+  gf_group->update_type[frame_index] = first_frame_update_type;
   gf_group->arf_src_offset[frame_index] = 0;
   gf_group->arf_pos_in_gf[frame_index] = 0;
   gf_group->arf_update_idx[frame_index] = 0;
-  gf_group->pyramid_level[frame_index] = 0;
+  gf_group->pyramid_level[frame_index] = MIN_PYRAMID_LVL;
   ++frame_index;
 
-  // ALT0
-  gf_group->update_type[frame_index] = ARF_UPDATE;
-  gf_group->arf_src_offset[frame_index] = gf_interval - 1;
-  gf_group->arf_pos_in_gf[frame_index] = 0;
-  gf_group->arf_update_idx[frame_index] = 0;
-  gf_group->pyramid_level[frame_index] = gf_group->pyramid_height;
-  ++frame_index;
+  // ALTREF.
+  const int use_altref = (gf_group->pyramid_height > 0);
+  if (use_altref) {
+    gf_group->update_type[frame_index] = ARF_UPDATE;
+    gf_group->arf_src_offset[frame_index] = gf_interval - 1;
+    gf_group->arf_pos_in_gf[frame_index] = 0;
+    gf_group->arf_update_idx[frame_index] = 0;
+    gf_group->pyramid_level[frame_index] = gf_group->pyramid_height;
+    ++frame_index;
+  }
 
-  // set parameters for the rest of the frames
+  // Rest of the frames.
+  const int next_height =
+      use_altref ? gf_group->pyramid_height - 1 : gf_group->pyramid_height;
+  assert(next_height >= MIN_PYRAMID_LVL);
   set_multi_layer_params(gf_group, 0, gf_interval, &frame_index, 0,
-                         gf_group->pyramid_height - 1);
+                         next_height);
   return frame_index;
 }
 
@@ -117,9 +126,9 @@
   };
   FILE *fid = fopen("GF_PARAMS.txt", "a");
 
-  fprintf(fid, "\n{%d}\n", gf_interval);
+  fprintf(fid, "\ngf_interval = {%d}\n", gf_interval);
   for (int i = 0; i <= frame_nums; ++i) {
-    fprintf(fid, "%s %d %d %d %d\n",
+    fprintf(fid, "#%2d : %s %d %d %d %d\n", i,
             update_type_strings[gf_group->update_type[i]],
             gf_group->arf_src_offset[i], gf_group->arf_pos_in_gf[i],
             gf_group->arf_update_idx[i], gf_group->pyramid_level[i]);
@@ -134,6 +143,34 @@
 }
 #endif  // CHECK_GF_PARAMETER
 
+static INLINE int max_pyramid_height_from_width(int pyramid_width) {
+#if CONFIG_FLAT_GF_STRUCTURE_ALLOWED
+  assert(pyramid_width <= MAX_GF_INTERVAL && pyramid_width >= MIN_GF_INTERVAL &&
+         "invalid gf interval for pyramid structure");
+#endif  // CONFIG_FLAT_GF_STRUCTURE_ALLOWED
+  if (pyramid_width > 12) return 4;
+  if (pyramid_width > 6) return 3;
+  if (pyramid_width > 3) return 2;
+  if (pyramid_width > 1) return 1;
+  return 0;
+}
+
+static int get_pyramid_height(const AV1_COMP *const cpi) {
+  const RATE_CONTROL *const rc = &cpi->rc;
+  assert(IMPLIES(cpi->oxcf.gf_max_pyr_height == MIN_PYRAMID_LVL,
+                 !rc->source_alt_ref_pending));  // define_gf_group() enforced.
+  if (!rc->source_alt_ref_pending) {
+    return MIN_PYRAMID_LVL;
+  }
+  assert(cpi->oxcf.gf_max_pyr_height > MIN_PYRAMID_LVL);
+  if (!cpi->extra_arf_allowed) {
+    assert(MIN_PYRAMID_LVL + 1 <= cpi->oxcf.gf_max_pyr_height);
+    return MIN_PYRAMID_LVL + 1;
+  }
+  return AOMMIN(max_pyramid_height_from_width(rc->baseline_gf_interval),
+                cpi->oxcf.gf_max_pyr_height);
+}
+
 static int update_type_2_rf_level(FRAME_UPDATE_TYPE update_type) {
   // Derive rf_level from update_type
   switch (update_type) {
@@ -154,69 +191,55 @@
   RATE_CONTROL *const rc = &cpi->rc;
   TWO_PASS *const twopass = &cpi->twopass;
   GF_GROUP *const gf_group = &twopass->gf_group;
-  const int key_frame = frame_params->frame_type == KEY_FRAME;
+  const int key_frame = (frame_params->frame_type == KEY_FRAME);
+  const FRAME_UPDATE_TYPE first_frame_update_type =
+      key_frame ? KF_UPDATE
+                : rc->source_alt_ref_active ? OVERLAY_UPDATE : GF_UPDATE;
+  const int gf_update_frames = construct_multi_layer_gf_structure(
+      gf_group, rc->baseline_gf_interval, get_pyramid_height(cpi),
+      first_frame_update_type);
 
-  assert(rc->baseline_gf_interval >= MIN_GF_INTERVAL &&
-         rc->baseline_gf_interval <=
-             get_max_gf_length(cpi->oxcf.gf_max_pyr_height));
-  assert(cpi->oxcf.gf_max_pyr_height >= MIN_PYRAMID_LVL &&
-         cpi->oxcf.gf_max_pyr_height <= MAX_PYRAMID_LVL);
+  // Unused, so set to default value.
+  memset(gf_group->brf_src_offset, 0,
+         gf_update_frames * sizeof(*gf_group->brf_src_offset));
 
-  const int gf_update_frames =
-      construct_multi_layer_gf_structure(gf_group, rc->baseline_gf_interval);
-  int frame_index;
+  // Set rate factor level for 1st frame.
+  if (!key_frame) {  // For a key-frame, rate factor is already assigned.
+    assert(first_frame_update_type == OVERLAY_UPDATE ||
+           first_frame_update_type == GF_UPDATE);
+    gf_group->rf_level[0] =
+        (first_frame_update_type == OVERLAY_UPDATE) ? INTER_NORMAL : GF_ARF_STD;
+  }
 
+  // Set rate factor levels for rest of the frames, and also count extra arfs.
   cpi->num_extra_arfs = 0;
-
-  for (frame_index = 0; frame_index < gf_update_frames; ++frame_index) {
-    // Set unused variables to default values
-    gf_group->brf_src_offset[frame_index] = 0;
-
-    // Special handle for the first frame for assigning update_type
-    if (frame_index == 0) {
-      // For key frames the frame target rate is already set and it
-      // is also the golden frame.
-      if (key_frame) {
-        gf_group->update_type[frame_index] = KF_UPDATE;
-        continue;
-      }
-
-      if (rc->source_alt_ref_active) {
-        gf_group->update_type[frame_index] = OVERLAY_UPDATE;
-      } else {
-        gf_group->update_type[frame_index] = GF_UPDATE;
-      }
-    } else {
-      if (gf_group->update_type[frame_index] == INTNL_ARF_UPDATE)
-        ++cpi->num_extra_arfs;
-    }
-
-    // Assign rf level based on update type
-    gf_group->rf_level[frame_index] =
-        update_type_2_rf_level(gf_group->update_type[frame_index]);
+  for (int frame_index = 1; frame_index < gf_update_frames; ++frame_index) {
+    const int this_update_type = gf_group->update_type[frame_index];
+    gf_group->rf_level[frame_index] = update_type_2_rf_level(this_update_type);
+    if (this_update_type == INTNL_ARF_UPDATE) ++cpi->num_extra_arfs;
   }
 
-  // NOTE: We need to configure the frame at the end of the sequence + 1 that
-  //       will be the start frame for the next group. Otherwise prior to the
-  //       call to av1_get_second_pass_params() the data will be undefined.
+  // We need to configure the frame at the end of the sequence + 1 that
+  // will be the start frame for the next group. Otherwise prior to the
+  // call to av1_get_second_pass_params(), the data will be undefined.
   if (rc->source_alt_ref_pending) {
-    gf_group->update_type[frame_index] = OVERLAY_UPDATE;
-    gf_group->rf_level[frame_index] = INTER_NORMAL;
+    gf_group->update_type[gf_update_frames] = OVERLAY_UPDATE;
+    gf_group->rf_level[gf_update_frames] = INTER_NORMAL;
   } else {
-    gf_group->update_type[frame_index] = GF_UPDATE;
-    gf_group->rf_level[frame_index] = GF_ARF_STD;
+    gf_group->update_type[gf_update_frames] = GF_UPDATE;
+    gf_group->rf_level[gf_update_frames] = GF_ARF_STD;
   }
+  gf_group->brf_src_offset[gf_update_frames] = 0;
+  gf_group->arf_update_idx[gf_update_frames] = 0;
+  gf_group->arf_pos_in_gf[gf_update_frames] = 0;
 
-  gf_group->brf_src_offset[frame_index] = 0;
-  gf_group->arf_update_idx[frame_index] = 0;
-  // This value is only used for INTNL_OVERLAY_UPDATE
-  gf_group->arf_pos_in_gf[frame_index] = 0;
-
-#ifdef CHCEK_GF_PARAMETER
+#if CHECK_GF_PARAMETER
   check_frame_params(gf_group, rc->baseline_gf_interval, gf_update_frames);
 #endif
 }
 
+#if CONFIG_FLAT_GF_STRUCTURE_ALLOWED
+
 static void define_flat_gf_group_structure(
     AV1_COMP *cpi, const EncodeFrameParams *const frame_params) {
   RATE_CONTROL *const rc = &cpi->rc;
@@ -424,23 +447,27 @@
   gf_group->brf_src_offset[frame_index] = 0;
 }
 
+#endif  // CONFIG_FLAT_GF_STRUCTURE_ALLOWED
+
 void av1_gop_setup_structure(AV1_COMP *cpi,
                              const EncodeFrameParams *const frame_params) {
-  RATE_CONTROL *const rc = &cpi->rc;
-
+  // Decide whether to use a flat or pyramid structure for this GF
+#if CONFIG_FLAT_GF_STRUCTURE_ALLOWED
+  const RATE_CONTROL *const rc = &cpi->rc;
   const int max_pyr_height = cpi->oxcf.gf_max_pyr_height;
   const int valid_pyramid_gf_length =
       max_pyr_height >= MIN_PYRAMID_LVL && max_pyr_height <= MAX_PYRAMID_LVL &&
       rc->baseline_gf_interval >= MIN_GF_INTERVAL &&
-      rc->baseline_gf_interval <= get_max_gf_length(max_pyr_height);
-
-  // Decide whether to use a flat or pyramid structure for this GF
-  if (valid_pyramid_gf_length && rc->source_alt_ref_pending &&
-      cpi->extra_arf_allowed > 0) {
+      rc->baseline_gf_interval <= get_max_gf_length(max_pyr_height) &&
+      rc->source_alt_ref_pending && cpi->extra_arf_allowed > 0;
+  if (valid_pyramid_gf_length) {
+#endif  // ALWAYS_USE_PYRAMID_STRUCTURE
     define_pyramid_gf_group_structure(cpi, frame_params);
     cpi->new_bwdref_update_rule = 1;
+#if CONFIG_FLAT_GF_STRUCTURE_ALLOWED
   } else {
     define_flat_gf_group_structure(cpi, frame_params);
     cpi->new_bwdref_update_rule = 0;
   }
+#endif  // CONFIG_FLAT_GF_STRUCTURE_ALLOWED
 }
diff --git a/av1/encoder/gop_structure.h b/av1/encoder/gop_structure.h
index 497e61a..63db06f 100644
--- a/av1/encoder/gop_structure.h
+++ b/av1/encoder/gop_structure.h
@@ -19,6 +19,7 @@
 extern "C" {
 #endif
 
+#if CONFIG_FLAT_GF_STRUCTURE_ALLOWED
 // Given the maximum allowed height of the pyramid structure, return the maximum
 // GF length supported by the same.
 static INLINE int get_max_gf_length(int max_pyr_height) {
@@ -39,6 +40,7 @@
     default: assert(0 && "Invalid max_pyr_height"); return -1;
   }
 }
+#endif  // CONFIG_FLAT_GF_STRUCTURE_ALLOWED
 
 struct AV1_COMP;
 struct EncodeFrameParams;
diff --git a/av1/encoder/pass2_strategy.c b/av1/encoder/pass2_strategy.c
index 4cd6062..82b7dca 100644
--- a/av1/encoder/pass2_strategy.c
+++ b/av1/encoder/pass2_strategy.c
@@ -624,9 +624,9 @@
   const int tmp_frame_index = frame_index;
   int budget_reduced_from_leaf_level = 0;
 
-  // Allocate bits to the other frames in the group.
-  const int normal_frames =
-      rc->baseline_gf_interval - (key_frame || rc->source_alt_ref_pending);
+  // Allocate bits to frames other than first frame, which is either a keyframe,
+  // overlay frame or golden frame.
+  const int normal_frames = rc->baseline_gf_interval - 1;
 
   for (i = 0; i < normal_frames; ++i) {
     FIRSTPASS_STATS frame_stats;
@@ -667,7 +667,7 @@
       assert(gf_group->update_type[frame_index] == LF_UPDATE ||
              gf_group->update_type[frame_index] == INTNL_OVERLAY_UPDATE);
       gf_group->bit_allocation[frame_index] = target_frame_size;
-      if (cpi->new_bwdref_update_rule) {
+      if (cpi->new_bwdref_update_rule && cpi->num_extra_arfs > 0) {
         const int this_budget_reduction =
             (int)(target_frame_size * LEAF_REDUCTION_FACTOR);
         gf_group->bit_allocation[frame_index] -= this_budget_reduction;
@@ -685,6 +685,8 @@
   }
 
   if (budget_reduced_from_leaf_level > 0) {
+    assert(cpi->new_bwdref_update_rule);
+    assert(cpi->num_extra_arfs > 0);
     // Restore.
     frame_index = tmp_frame_index;
 
@@ -739,8 +741,13 @@
 // Given the maximum allowed height of the pyramid structure, return the fixed
 // GF length to be used.
 static INLINE int get_fixed_gf_length(int max_pyr_height) {
+#if CONFIG_FLAT_GF_STRUCTURE_ALLOWED
   const int max_gf_length_allowed = get_max_gf_length(max_pyr_height);
   return AOMMIN(max_gf_length_allowed, MAX_GF_INTERVAL);
+#else
+  (void)max_pyr_height;
+  return MAX_GF_INTERVAL;
+#endif  // CONFIG_FLAT_GF_STRUCTURE_ALLOWED
 }
 
 // Returns true if KF group and GF group both are almost completely static.
@@ -943,7 +950,8 @@
   const int use_alt_ref =
       !is_almost_static(zero_motion_accumulator, twopass->kf_zeromotion_pct) &&
       allow_alt_ref && (i < cpi->oxcf.lag_in_frames) &&
-      (i >= rc->min_gf_interval);
+      (i >= rc->min_gf_interval) &&
+      (cpi->oxcf.gf_max_pyr_height > MIN_PYRAMID_LVL);
 
 #define REDUCE_GF_LENGTH_THRESH 4
 #define REDUCE_GF_LENGTH_TO_KEY_THRESH 9
diff --git a/av1/encoder/ratectrl.h b/av1/encoder/ratectrl.h
index 2d8a762..664127b 100644
--- a/av1/encoder/ratectrl.h
+++ b/av1/encoder/ratectrl.h
@@ -38,7 +38,7 @@
 
 // Minimum and maximum height for the new pyramid structure.
 // (Old structure supports height = 1, but does NOT support height = 4).
-#define MIN_PYRAMID_LVL 2
+#define MIN_PYRAMID_LVL 0
 #define MAX_PYRAMID_LVL 4
 
 #define MIN_GF_INTERVAL 4
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index f498acd..ea7fb34 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -133,6 +133,12 @@
                    "Collect stats on partition decisions.")
 set_aom_config_var(CONFIG_COLLECT_COMPONENT_TIMING 0 NUMBER
                    "Collect encoding component timing information.")
+
+# TODO(urvang): Consider removing flat GF structure if and when pyramid
+# structure is generic enough to handle all cases, and performs equally well /
+# better.
+set_aom_config_var(CONFIG_FLAT_GF_STRUCTURE_ALLOWED 1 NUMBER
+                   "AV1 experiment flag.")
 #
 # Variables in this section control optional features of the build system.
 #