diff --git a/common_video/generic_frame_descriptor/generic_frame_info.cc b/common_video/generic_frame_descriptor/generic_frame_info.cc
index 94a6192..1c01b6c 100644
--- a/common_video/generic_frame_descriptor/generic_frame_info.cc
+++ b/common_video/generic_frame_descriptor/generic_frame_info.cc
@@ -15,6 +15,24 @@
 
 namespace webrtc {
 
+absl::InlinedVector<GenericFrameInfo::DecodeTargetIndication, 10>
+GenericFrameInfo::DecodeTargetInfo(absl::string_view indication_symbols) {
+  absl::InlinedVector<DecodeTargetIndication, 10> decode_targets;
+  for (char symbol : indication_symbols) {
+    DecodeTargetIndication indication;
+    switch (symbol) {
+      case '-': indication = DecodeTargetIndication::kNotPresent; break;
+      case 'D': indication = DecodeTargetIndication::kDiscardable; break;
+      case 'R': indication = DecodeTargetIndication::kRequired; break;
+      case 'S': indication = DecodeTargetIndication::kSwitch; break;
+      default: RTC_NOTREACHED();
+    }
+    decode_targets.push_back(indication);
+  }
+
+  return decode_targets;
+}
+
 GenericFrameInfo::GenericFrameInfo() = default;
 GenericFrameInfo::GenericFrameInfo(const GenericFrameInfo&) = default;
 GenericFrameInfo::~GenericFrameInfo() = default;
@@ -38,19 +56,7 @@
 
 GenericFrameInfo::Builder& GenericFrameInfo::Builder::Dtis(
     absl::string_view indication_symbols) {
-  for (const auto& symbol : indication_symbols) {
-    DecodeTargetIndication indication;
-    switch (symbol) {
-      case '-': indication = DecodeTargetIndication::kNotPresent; break;
-      case 'D': indication = DecodeTargetIndication::kDiscardable; break;
-      case 'R': indication = DecodeTargetIndication::kRequired; break;
-      case 'S': indication = DecodeTargetIndication::kSwitch; break;
-      default: RTC_NOTREACHED();
-    }
-
-    info_.decode_target_indications.push_back(indication);
-  }
-
+  info_.decode_target_indications = DecodeTargetInfo(indication_symbols);
   return *this;
 }
 
diff --git a/common_video/generic_frame_descriptor/generic_frame_info.h b/common_video/generic_frame_descriptor/generic_frame_info.h
index 91a0868..7909291 100644
--- a/common_video/generic_frame_descriptor/generic_frame_info.h
+++ b/common_video/generic_frame_descriptor/generic_frame_info.h
@@ -22,12 +22,15 @@
 
 struct GenericFrameInfo {
   enum class DecodeTargetIndication {
-    kNotPresent,   // GenericFrameInfo::Builder symbol '-'
-    kDiscardable,  // GenericFrameInfo::Builder symbol 'D'
-    kSwitch,       // GenericFrameInfo::Builder symbol 'S'
-    kRequired      // GenericFrameInfo::Builder symbol 'R'
+    kNotPresent,   // DecodeTargetInfo symbol '-'
+    kDiscardable,  // DecodeTargetInfo symbol 'D'
+    kSwitch,       // DecodeTargetInfo symbol 'S'
+    kRequired      // DecodeTargetInfo symbol 'R'
   };
 
+  static absl::InlinedVector<DecodeTargetIndication, 10> DecodeTargetInfo(
+      absl::string_view indication_symbols);
+
   class Builder;
 
   GenericFrameInfo();
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers.cc b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
index d47317e..abab490 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers.cc
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.cc
@@ -31,10 +31,10 @@
 DefaultTemporalLayers::PendingFrame::PendingFrame(
     bool expired,
     uint8_t updated_buffers_mask,
-    const Vp8FrameConfig& frame_config)
+    const DependencyInfo& dependency_info)
     : expired(expired),
       updated_buffer_mask(updated_buffers_mask),
-      frame_config(frame_config) {}
+      dependency_info(dependency_info) {}
 
 namespace {
 using Buffer = Vp8FrameConfig::Buffer;
@@ -99,27 +99,10 @@
   }
   return flags;
 }
-
-// Find the set of buffers that are never updated by the given pattern.
-std::set<Vp8BufferReference> FindKfBuffers(
-    const std::vector<Vp8FrameConfig>& frame_configs) {
-  std::set<Vp8BufferReference> kf_buffers(kAllBuffers.begin(),
-                                          kAllBuffers.end());
-  for (Vp8FrameConfig config : frame_configs) {
-    // Get bit-masked set of update buffers for this frame config.
-    uint8_t updated_buffers = GetUpdatedBuffers(config);
-    for (Vp8BufferReference buffer : kAllBuffers) {
-      if (static_cast<uint8_t>(buffer) & updated_buffers) {
-        kf_buffers.erase(buffer);
-      }
-    }
-  }
-  return kf_buffers;
-}
 }  // namespace
 
-std::vector<Vp8FrameConfig> DefaultTemporalLayers::GetTemporalPattern(
-    size_t num_layers) {
+std::vector<DefaultTemporalLayers::DependencyInfo>
+DefaultTemporalLayers::GetDependencyInfo(size_t num_layers) {
   // For indexing in the patterns described below (which temporal layers they
   // belong to), see the diagram above.
   // Layer sync is done similarly for all patterns (except single stream) and
@@ -133,10 +116,11 @@
   // so that if scene changes occur (user walks between rooms or rotates webcam)
   // the 'arf' (or 'golden' respectively) is not stuck on a no-longer relevant
   // keyframe.
+
   switch (num_layers) {
     case 1:
       // Always reference and update the same buffer.
-      return {Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone)};
+      return {{"S", {kReferenceAndUpdate, kNone, kNone}}};
     case 2:
       // All layers can reference but not update the 'alt' buffer, this means
       // that the 'alt' buffer reference is effectively the last keyframe.
@@ -147,23 +131,23 @@
         //   1---1   1---1 ...
         //  /   /   /   /
         // 0---0---0---0 ...
-        return {Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-                Vp8FrameConfig(kReference, kUpdate, kNone),
-                Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-                Vp8FrameConfig(kReference, kReference, kNone, kFreezeEntropy)};
+        return {{"SS", {kReferenceAndUpdate, kNone, kNone}},
+                {"-S", {kReference, kUpdate, kNone}},
+                {"SR", {kReferenceAndUpdate, kNone, kNone}},
+                {"-D", {kReference, kReference, kNone, kFreezeEntropy}}};
       } else {
         // "Default" 8-frame pattern:
         //   1---1---1---1   1---1---1---1 ...
         //  /   /   /   /   /   /   /   /
         // 0---0---0---0---0---0---0---0 ...
-        return {Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-                Vp8FrameConfig(kReference, kUpdate, kNone),
-                Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-                Vp8FrameConfig(kReference, kReferenceAndUpdate, kNone),
-                Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-                Vp8FrameConfig(kReference, kReferenceAndUpdate, kNone),
-                Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-                Vp8FrameConfig(kReference, kReference, kNone, kFreezeEntropy)};
+        return {{"SS", {kReferenceAndUpdate, kNone, kNone}},
+                {"-S", {kReference, kUpdate, kNone}},
+                {"SR", {kReferenceAndUpdate, kNone, kNone}},
+                {"-R", {kReference, kReferenceAndUpdate, kNone}},
+                {"SR", {kReferenceAndUpdate, kNone, kNone}},
+                {"-R", {kReference, kReferenceAndUpdate, kNone}},
+                {"SR", {kReferenceAndUpdate, kNone, kNone}},
+                {"-D", {kReference, kReference, kNone, kFreezeEntropy}}};
       }
     case 3:
       if (field_trial::IsEnabled("WebRTC-UseShortVP8TL3Pattern")) {
@@ -183,62 +167,59 @@
         // TL1  references 'last' and references and updates 'golden'.
         // TL2 references both 'last' & 'golden' and references and updates
         // 'arf'.
-        return {
-            Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-            Vp8FrameConfig(kReference, kNone, kUpdate),
-            Vp8FrameConfig(kReference, kUpdate, kNone),
-            Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy)};
+        return {{"SSS", {kReferenceAndUpdate, kNone, kNone}},
+                {"--S", {kReference, kNone, kUpdate}},
+                {"-DR", {kReference, kUpdate, kNone}},
+                {"--D", {kReference, kReference, kReference, kFreezeEntropy}}};
       } else {
         // All layers can reference but not update the 'alt' buffer, this means
         // that the 'alt' buffer reference is effectively the last keyframe.
         // TL0 also references and updates the 'last' buffer.
         // TL1 also references 'last' and references and updates 'golden'.
         // TL2 references both 'last' and 'golden' but updates no buffer.
-        return {
-            Vp8FrameConfig(kReferenceAndUpdate, kNone, kReference),
-            Vp8FrameConfig(kReference, kNone, kReference, kFreezeEntropy),
-            Vp8FrameConfig(kReference, kUpdate, kReference),
-            Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy),
-            Vp8FrameConfig(kReferenceAndUpdate, kNone, kReference),
-            Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy),
-            Vp8FrameConfig(kReference, kReferenceAndUpdate, kReference),
-            Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy)};
+        return {{"SSS", {kReferenceAndUpdate, kNone, kReference}},
+                {"--D", {kReference, kNone, kReference, kFreezeEntropy}},
+                {"-SS", {kReference, kUpdate, kReference}},
+                {"--D", {kReference, kReference, kReference, kFreezeEntropy}},
+                {"SRR", {kReferenceAndUpdate, kNone, kReference}},
+                {"--D", {kReference, kReference, kReference, kFreezeEntropy}},
+                {"-DS", {kReference, kReferenceAndUpdate, kReference}},
+                {"--D", {kReference, kReference, kReference, kFreezeEntropy}}};
       }
     case 4:
       // TL0 references and updates only the 'last' buffer.
       // TL1 references 'last' and updates and references 'golden'.
       // TL2 references 'last' and 'golden', and references and updates 'arf'.
       // TL3 references all buffers but update none of them.
-      return {
-          Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-          Vp8FrameConfig(kReference, kNone, kNone, kFreezeEntropy),
-          Vp8FrameConfig(kReference, kNone, kUpdate),
-          Vp8FrameConfig(kReference, kNone, kReference, kFreezeEntropy),
-          Vp8FrameConfig(kReference, kUpdate, kNone),
-          Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy),
-          Vp8FrameConfig(kReference, kReference, kReferenceAndUpdate),
-          Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy),
-          Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone),
-          Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy),
-          Vp8FrameConfig(kReference, kReference, kReferenceAndUpdate),
-          Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy),
-          Vp8FrameConfig(kReference, kReferenceAndUpdate, kNone),
-          Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy),
-          Vp8FrameConfig(kReference, kReference, kReferenceAndUpdate),
-          Vp8FrameConfig(kReference, kReference, kReference, kFreezeEntropy)};
+      // TODO(philipel): Set decode target information for this structure.
+      return {{"----", {kReferenceAndUpdate, kNone, kNone}},
+              {"----", {kReference, kNone, kNone, kFreezeEntropy}},
+              {"----", {kReference, kNone, kUpdate}},
+              {"----", {kReference, kNone, kReference, kFreezeEntropy}},
+              {"----", {kReference, kUpdate, kNone}},
+              {"----", {kReference, kReference, kReference, kFreezeEntropy}},
+              {"----", {kReference, kReference, kReferenceAndUpdate}},
+              {"----", {kReference, kReference, kReference, kFreezeEntropy}},
+              {"----", {kReferenceAndUpdate, kNone, kNone}},
+              {"----", {kReference, kReference, kReference, kFreezeEntropy}},
+              {"----", {kReference, kReference, kReferenceAndUpdate}},
+              {"----", {kReference, kReference, kReference, kFreezeEntropy}},
+              {"----", {kReference, kReferenceAndUpdate, kNone}},
+              {"----", {kReference, kReference, kReference, kFreezeEntropy}},
+              {"----", {kReference, kReference, kReferenceAndUpdate}},
+              {"----", {kReference, kReference, kReference, kFreezeEntropy}}};
     default:
       RTC_NOTREACHED();
       break;
   }
   RTC_NOTREACHED();
-  return {Vp8FrameConfig(kNone, kNone, kNone)};
+  return {{"", {kNone, kNone, kNone}}};
 }
 
 DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers)
     : num_layers_(std::max(1, number_of_temporal_layers)),
       temporal_ids_(GetTemporalIds(num_layers_)),
-      temporal_pattern_(GetTemporalPattern(num_layers_)),
-      kf_buffers_(FindKfBuffers(temporal_pattern_)),
+      temporal_pattern_(GetDependencyInfo(num_layers_)),
       pattern_idx_(kUninitializedPatternIndex) {
   RTC_CHECK_GE(kMaxTemporalStreams, number_of_temporal_layers);
   RTC_CHECK_GE(number_of_temporal_layers, 0);
@@ -257,6 +238,16 @@
   for (Vp8BufferReference buffer : kAllBuffers) {
     frames_since_buffer_refresh_[buffer] = 0;
   }
+
+  kf_buffers_ = {kAllBuffers.begin(), kAllBuffers.end()};
+  for (DependencyInfo info : temporal_pattern_) {
+    uint8_t updated_buffers = GetUpdatedBuffers(info.frame_config);
+
+    for (Vp8BufferReference buffer : kAllBuffers) {
+      if (static_cast<uint8_t>(buffer) & updated_buffers)
+        kf_buffers_.erase(buffer);
+    }
+  }
 }
 
 DefaultTemporalLayers::~DefaultTemporalLayers() = default;
@@ -347,7 +338,8 @@
   RTC_DCHECK_GT(temporal_pattern_.size(), 0);
 
   pattern_idx_ = (pattern_idx_ + 1) % temporal_pattern_.size();
-  Vp8FrameConfig tl_config = temporal_pattern_[pattern_idx_];
+  DependencyInfo dependency_info = temporal_pattern_[pattern_idx_];
+  Vp8FrameConfig& tl_config = dependency_info.frame_config;
   tl_config.encoder_layer_id = tl_config.packetizer_temporal_idx =
       temporal_ids_[pattern_idx_ % temporal_ids_.size()];
 
@@ -386,7 +378,7 @@
 
   // Add frame to set of pending frames, awaiting completion.
   pending_frames_[timestamp] =
-      PendingFrame{false, GetUpdatedBuffers(tl_config), tl_config};
+      PendingFrame{false, GetUpdatedBuffers(tl_config), dependency_info};
 
 #if RTC_DCHECK_IS_ON
   // Checker does not yet support encoder frame dropping, so validate flags
@@ -472,10 +464,11 @@
   }
 
   PendingFrame& frame = pending_frame->second;
+  const Vp8FrameConfig& frame_config = frame.dependency_info.frame_config;
 #if RTC_DCHECK_IS_ON
   if (is_keyframe) {
     // Signal key-frame so checker resets state.
-    RTC_DCHECK(checker_->CheckTemporalConfig(true, frame.frame_config));
+    RTC_DCHECK(checker_->CheckTemporalConfig(true, frame_config));
   }
 #endif
 
@@ -503,8 +496,8 @@
       }
     } else {
       // Delta frame, update codec specifics with temporal id and sync flag.
-      vp8_info.temporalIdx = frame.frame_config.packetizer_temporal_idx;
-      vp8_info.layerSync = frame.frame_config.layer_sync;
+      vp8_info.temporalIdx = frame_config.packetizer_temporal_idx;
+      vp8_info.layerSync = frame_config.layer_sync;
     }
   }
 
@@ -513,13 +506,13 @@
   RTC_DCHECK_EQ(vp8_info.updatedBuffersCount, 0u);
 
   for (int i = 0; i < static_cast<int>(Buffer::kCount); ++i) {
-    if (!is_keyframe && frame.frame_config.References(static_cast<Buffer>(i))) {
+    if (!is_keyframe && frame_config.References(static_cast<Buffer>(i))) {
       RTC_DCHECK_LT(vp8_info.referencedBuffersCount,
                     arraysize(CodecSpecificInfoVP8::referencedBuffers));
       vp8_info.referencedBuffers[vp8_info.referencedBuffersCount++] = i;
     }
 
-    if (is_keyframe || frame.frame_config.Updates(static_cast<Buffer>(i))) {
+    if (is_keyframe || frame_config.Updates(static_cast<Buffer>(i))) {
       RTC_DCHECK_LT(vp8_info.updatedBuffersCount,
                     arraysize(CodecSpecificInfoVP8::updatedBuffers));
       vp8_info.updatedBuffers[vp8_info.updatedBuffersCount++] = i;
@@ -532,6 +525,10 @@
     info->template_structure = GetTemplateStructure(num_layers_);
   }
 
+  GenericFrameInfo& generic_frame_info = info->generic_frame_info.emplace();
+  generic_frame_info.decode_target_indications =
+      frame.dependency_info.decode_target_indications;
+
   if (!frame.expired) {
     for (Vp8BufferReference buffer : kAllBuffers) {
       if (frame.updated_buffer_mask & static_cast<uint8_t>(buffer)) {
diff --git a/modules/video_coding/codecs/vp8/default_temporal_layers.h b/modules/video_coding/codecs/vp8/default_temporal_layers.h
index ee2333e..9aa95db 100644
--- a/modules/video_coding/codecs/vp8/default_temporal_layers.h
+++ b/modules/video_coding/codecs/vp8/default_temporal_layers.h
@@ -18,6 +18,7 @@
 #include <map>
 #include <memory>
 #include <set>
+#include <utility>
 #include <vector>
 
 #include "absl/types/optional.h"
@@ -61,7 +62,20 @@
   void OnRttUpdate(int64_t rtt_ms) override;
 
  private:
-  static std::vector<Vp8FrameConfig> GetTemporalPattern(size_t num_layers);
+  struct DependencyInfo {
+    DependencyInfo() = default;
+    DependencyInfo(absl::string_view indication_symbols,
+                   Vp8FrameConfig frame_config)
+        : decode_target_indications(
+              GenericFrameInfo::DecodeTargetInfo(indication_symbols)),
+          frame_config(frame_config) {}
+
+    absl::InlinedVector<GenericFrameInfo::DecodeTargetIndication, 10>
+        decode_target_indications;
+    Vp8FrameConfig frame_config;
+  };
+
+  static std::vector<DependencyInfo> GetDependencyInfo(size_t num_layers);
   bool IsSyncFrame(const Vp8FrameConfig& config) const;
   void ValidateReferences(Vp8FrameConfig::BufferFlags* flags,
                           Vp8FrameConfig::Vp8BufferReference ref) const;
@@ -69,9 +83,9 @@
 
   const size_t num_layers_;
   const std::vector<unsigned int> temporal_ids_;
-  const std::vector<Vp8FrameConfig> temporal_pattern_;
+  const std::vector<DependencyInfo> temporal_pattern_;
   // Set of buffers that are never updated except by keyframes.
-  const std::set<Vp8FrameConfig::Vp8BufferReference> kf_buffers_;
+  std::set<Vp8FrameConfig::Vp8BufferReference> kf_buffers_;
   TemplateStructure GetTemplateStructure(int num_layers) const;
 
   uint8_t pattern_idx_;
@@ -82,7 +96,7 @@
     PendingFrame();
     PendingFrame(bool expired,
                  uint8_t updated_buffers_mask,
-                 const Vp8FrameConfig& frame_config);
+                 const DependencyInfo& dependency_info);
     // Flag indicating if this frame has expired, ie it belongs to a previous
     // iteration of the temporal pattern.
     bool expired = false;
@@ -90,7 +104,7 @@
     // updates.
     uint8_t updated_buffer_mask = 0;
     // The frame config return by UpdateLayerConfig() for this frame.
-    Vp8FrameConfig frame_config;
+    DependencyInfo dependency_info;
   };
   // Map from rtp timestamp to pending frame status. Reset on pattern loop.
   std::map<uint32_t, PendingFrame> pending_frames_;
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers.cc b/modules/video_coding/codecs/vp8/screenshare_layers.cc
index 9412ba4..11a1cbd 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers.cc
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.cc
@@ -90,16 +90,16 @@
   auto it = pending_frame_configs_.find(timestamp);
   if (it != pending_frame_configs_.end()) {
     // Drop and re-encode, reuse the previous config.
-    return it->second;
+    return it->second.frame_config;
   }
 
   if (number_of_temporal_layers_ <= 1) {
     // No flags needed for 1 layer screenshare.
     // TODO(pbos): Consider updating only last, and not all buffers.
-    Vp8FrameConfig tl_config(kReferenceAndUpdate, kReferenceAndUpdate,
-                             kReferenceAndUpdate);
-    pending_frame_configs_[timestamp] = tl_config;
-    return tl_config;
+    DependencyInfo dependency_info{
+        "S", {kReferenceAndUpdate, kReferenceAndUpdate, kReferenceAndUpdate}};
+    pending_frame_configs_[timestamp] = dependency_info;
+    return dependency_info.frame_config;
   }
 
   const int64_t now_ms = rtc::TimeMillis();
@@ -199,35 +199,35 @@
       RTC_NOTREACHED();
   }
 
-  Vp8FrameConfig tl_config;
+  DependencyInfo dependency_info;
   // TODO(pbos): Consider referencing but not updating the 'alt' buffer for all
   // layers.
   switch (layer_state) {
     case TemporalLayerState::kDrop:
-      tl_config = Vp8FrameConfig(kNone, kNone, kNone);
+      dependency_info = {"", {kNone, kNone, kNone}};
       break;
     case TemporalLayerState::kTl0:
       // TL0 only references and updates 'last'.
-      tl_config = Vp8FrameConfig(kReferenceAndUpdate, kNone, kNone);
-      tl_config.packetizer_temporal_idx = 0;
+      dependency_info = {"SS", {kReferenceAndUpdate, kNone, kNone}};
+      dependency_info.frame_config.packetizer_temporal_idx = 0;
       break;
     case TemporalLayerState::kTl1:
       // TL1 references both 'last' and 'golden' but only updates 'golden'.
-      tl_config = Vp8FrameConfig(kReference, kReferenceAndUpdate, kNone);
-      tl_config.packetizer_temporal_idx = 1;
+      dependency_info = {"-R", {kReference, kReferenceAndUpdate, kNone}};
+      dependency_info.frame_config.packetizer_temporal_idx = 1;
       break;
     case TemporalLayerState::kTl1Sync:
       // Predict from only TL0 to allow participants to switch to the high
       // bitrate stream. Updates 'golden' so that TL1 can continue to refer to
       // and update 'golden' from this point on.
-      tl_config = Vp8FrameConfig(kReference, kUpdate, kNone);
-      tl_config.packetizer_temporal_idx = 1;
+      dependency_info = {"-S", {kReference, kUpdate, kNone}};
+      dependency_info.frame_config.packetizer_temporal_idx = 1;
+      dependency_info.frame_config.layer_sync = true;
       break;
   }
 
-  tl_config.layer_sync = layer_state == TemporalLayerState::kTl1Sync;
-  pending_frame_configs_[timestamp] = tl_config;
-  return tl_config;
+  pending_frame_configs_[timestamp] = dependency_info;
+  return dependency_info.frame_config;
 }
 
 void ScreenshareLayers::OnRatesUpdated(
@@ -286,28 +286,38 @@
     return;
   }
 
-  absl::optional<Vp8FrameConfig> frame_config;
+  absl::optional<DependencyInfo> dependency_info;
   auto it = pending_frame_configs_.find(rtp_timestamp);
   if (it != pending_frame_configs_.end()) {
-    frame_config = it->second;
+    dependency_info = it->second;
     pending_frame_configs_.erase(it);
 
     if (checker_) {
-      RTC_DCHECK(checker_->CheckTemporalConfig(is_keyframe, *frame_config));
+      RTC_DCHECK(checker_->CheckTemporalConfig(is_keyframe,
+                                               dependency_info->frame_config));
     }
   }
 
   CodecSpecificInfoVP8& vp8_info = info->codecSpecific.VP8;
+  GenericFrameInfo& generic_frame_info = info->generic_frame_info.emplace();
+
   if (number_of_temporal_layers_ == 1) {
     vp8_info.temporalIdx = kNoTemporalIdx;
     vp8_info.layerSync = false;
+    generic_frame_info.decode_target_indications =
+        GenericFrameInfo::DecodeTargetInfo("S");
   } else {
     int64_t unwrapped_timestamp = time_wrap_handler_.Unwrap(rtp_timestamp);
-    if (frame_config) {
-      vp8_info.temporalIdx = frame_config->packetizer_temporal_idx;
-      vp8_info.layerSync = frame_config->layer_sync;
+    if (dependency_info) {
+      vp8_info.temporalIdx =
+          dependency_info->frame_config.packetizer_temporal_idx;
+      vp8_info.layerSync = dependency_info->frame_config.layer_sync;
+      generic_frame_info.decode_target_indications =
+          dependency_info->decode_target_indications;
     } else {
       RTC_DCHECK(is_keyframe);
+      generic_frame_info.decode_target_indications =
+          GenericFrameInfo::DecodeTargetInfo("SS");
     }
 
     if (is_keyframe) {
@@ -328,13 +338,15 @@
     // Note that |frame_config| is not derefernced if |is_keyframe|,
     // meaning it's never dereferenced if the optional may be unset.
     for (int i = 0; i < static_cast<int>(Buffer::kCount); ++i) {
-      if (!is_keyframe && frame_config->References(static_cast<Buffer>(i))) {
+      if (!is_keyframe &&
+          dependency_info->frame_config.References(static_cast<Buffer>(i))) {
         RTC_DCHECK_LT(vp8_info.referencedBuffersCount,
                       arraysize(CodecSpecificInfoVP8::referencedBuffers));
         vp8_info.referencedBuffers[vp8_info.referencedBuffersCount++] = i;
       }
 
-      if (is_keyframe || frame_config->Updates(static_cast<Buffer>(i))) {
+      if (is_keyframe ||
+          dependency_info->frame_config.Updates(static_cast<Buffer>(i))) {
         RTC_DCHECK_LT(vp8_info.updatedBuffersCount,
                       arraysize(CodecSpecificInfoVP8::updatedBuffers));
         vp8_info.updatedBuffers[vp8_info.updatedBuffersCount++] = i;
diff --git a/modules/video_coding/codecs/vp8/screenshare_layers.h b/modules/video_coding/codecs/vp8/screenshare_layers.h
index 6b1bc7e..8fe5fa3 100644
--- a/modules/video_coding/codecs/vp8/screenshare_layers.h
+++ b/modules/video_coding/codecs/vp8/screenshare_layers.h
@@ -11,6 +11,7 @@
 
 #include <map>
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "api/video_codecs/vp8_frame_config.h"
@@ -67,6 +68,19 @@
  private:
   enum class TemporalLayerState : int { kDrop, kTl0, kTl1, kTl1Sync };
 
+  struct DependencyInfo {
+    DependencyInfo() = default;
+    DependencyInfo(absl::string_view indication_symbols,
+                   Vp8FrameConfig frame_config)
+        : decode_target_indications(
+              GenericFrameInfo::DecodeTargetInfo(indication_symbols)),
+          frame_config(frame_config) {}
+
+    absl::InlinedVector<GenericFrameInfo::DecodeTargetIndication, 10>
+        decode_target_indications;
+    Vp8FrameConfig frame_config;
+  };
+
   bool TimeToSync(int64_t timestamp) const;
   uint32_t GetCodecTargetBitrateKbps() const;
 
@@ -81,7 +95,7 @@
   int max_qp_;
   uint32_t max_debt_bytes_;
 
-  std::map<uint32_t, Vp8FrameConfig> pending_frame_configs_;
+  std::map<uint32_t, DependencyInfo> pending_frame_configs_;
 
   // Configured max framerate.
   absl::optional<uint32_t> target_framerate_;