Move temporal-layer properties to FrameConfig.

webrtc/modules/video_coding/codecs/vp8/default_temporal_layers.cc

 /* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */
 
 #include "webrtc/modules/video_coding/codecs/vp8/default_temporal_layers.h"
@@ skipping 30 matching lines @@
 TemporalLayers::FrameConfig::FrameConfig(TemporalLayers::BufferFlags last,
                                          TemporalLayers::BufferFlags golden,
                                          TemporalLayers::BufferFlags arf,
                                          bool freeze_entropy)
     : drop_frame(last == TemporalLayers::kNone &&
                  golden == TemporalLayers::kNone &&
                  arf == TemporalLayers::kNone),
       last_buffer_flags(last),
       golden_buffer_flags(golden),
       arf_buffer_flags(arf),
+      encoder_layer_id(0),
+      packetizer_temporal_idx(0),
+      layer_sync(false),
       freeze_entropy(freeze_entropy) {}
 
 namespace {
 
 std::vector<unsigned int> GetTemporalIds(size_t num_layers) {
   switch (num_layers) {
     case 1:
       // Temporal layer structure (single layer):
       // 0 0 0 0 ...
       return {0};
@@ skipping 186 matching lines @@
 }  // namespace
 
 DefaultTemporalLayers::DefaultTemporalLayers(int number_of_temporal_layers,
                                              uint8_t initial_tl0_pic_idx)
     : num_layers_(std::max(1, number_of_temporal_layers)),
       temporal_ids_(GetTemporalIds(num_layers_)),
       temporal_layer_sync_(GetTemporalLayerSync(num_layers_)),
       temporal_pattern_(GetTemporalPattern(num_layers_)),
       tl0_pic_idx_(initial_tl0_pic_idx),
       pattern_idx_(255),
-      timestamp_(0),
       last_base_layer_sync_(false) {
   RTC_DCHECK_EQ(temporal_pattern_.size(), temporal_layer_sync_.size());
   RTC_CHECK_GE(kMaxTemporalStreams, number_of_temporal_layers);
   RTC_CHECK_GE(number_of_temporal_layers, 0);
   RTC_CHECK_LE(number_of_temporal_layers, 4);
   // pattern_idx_ wraps around temporal_pattern_.size, this is incorrect if
   // temporal_ids_ are ever longer. If this is no longer correct it needs to
   // wrap at max(temporal_ids_.size(), temporal_pattern_.size()).
   RTC_DCHECK_LE(temporal_ids_.size(), temporal_pattern_.size());
 }
 
-int DefaultTemporalLayers::GetTemporalLayerId(
-    const TemporalLayers::FrameConfig& tl_config) const {
-  RTC_DCHECK(!tl_config.drop_frame);
-  return temporal_ids_[tl_config.pattern_idx % temporal_ids_.size()];
-}
-
 uint8_t DefaultTemporalLayers::Tl0PicIdx() const {
   return tl0_pic_idx_;
 }
 
 std::vector<uint32_t> DefaultTemporalLayers::OnRatesUpdated(
     int bitrate_kbps,
     int max_bitrate_kbps,
     int framerate) {
   std::vector<uint32_t> bitrates;
   for (size_t i = 0; i < num_layers_; ++i) {
@@ skipping 40 matching lines @@
 
   return true;
 }
 
 TemporalLayers::FrameConfig DefaultTemporalLayers::UpdateLayerConfig(
     uint32_t timestamp) {
   RTC_DCHECK_GT(num_layers_, 0);
   RTC_DCHECK_LT(0, temporal_pattern_.size());
   pattern_idx_ = (pattern_idx_ + 1) % temporal_pattern_.size();
   TemporalLayers::FrameConfig tl_config = temporal_pattern_[pattern_idx_];
-  tl_config.pattern_idx = pattern_idx_;
+  tl_config.layer_sync =
+      temporal_layer_sync_[pattern_idx_ % temporal_layer_sync_.size()];
+  tl_config.encoder_layer_id = tl_config.packetizer_temporal_idx =
+      temporal_ids_[pattern_idx_ % temporal_ids_.size()];
   return tl_config;
 }
 
 void DefaultTemporalLayers::PopulateCodecSpecific(
     bool frame_is_keyframe,
     const TemporalLayers::FrameConfig& tl_config,
     CodecSpecificInfoVP8* vp8_info,
     uint32_t timestamp) {
   RTC_DCHECK_GT(num_layers_, 0);
 
   if (num_layers_ == 1) {
     vp8_info->temporalIdx = kNoTemporalIdx;
     vp8_info->layerSync = false;
     vp8_info->tl0PicIdx = kNoTl0PicIdx;
   } else {
+    vp8_info->temporalIdx = tl_config.packetizer_temporal_idx;
+    vp8_info->layerSync = tl_config.layer_sync;
     if (frame_is_keyframe) {
       vp8_info->temporalIdx = 0;
       vp8_info->layerSync = true;
-    } else {
-      vp8_info->temporalIdx = GetTemporalLayerId(tl_config);
-
-      vp8_info->layerSync = temporal_layer_sync_[tl_config.pattern_idx %
-                                                 temporal_layer_sync_.size()];
     }
     if (last_base_layer_sync_ && vp8_info->temporalIdx != 0) {
       // Regardless of pattern the frame after a base layer sync will always
       // be a layer sync.
       vp8_info->layerSync = true;
     }
-    if (vp8_info->temporalIdx == 0 && timestamp != timestamp_) {

[brandtr, 2017/06/12 15:15:53]

How about keeping timestamp != timestamp_ as a DCHECK?

[pbos-webrtc, 2017/06/15 21:59:09]

I believe that timestamp == timestamp_ is OK if this wraps around during a
pause, so technically it's correct to not check timestamp != timestamp_, so long
as we don't get repeat input frames? The int64_t increasing timestamp check is
handled in the capturer input.

Not sure if interesting corner case, also not sure this'll likely catch more
bugs?

[brandtr, 2017/06/19 06:54:19]

Hmm, my idea was to guard against repeat input frames to avoid any confusion
with the tl0_pic_idx. But looking again, I guess it's more robust to not do the
check at all.

-      timestamp_ = timestamp;
+    if (vp8_info->temporalIdx == 0)
       tl0_pic_idx_++;
-    }
     last_base_layer_sync_ = frame_is_keyframe;
     vp8_info->tl0PicIdx = tl0_pic_idx_;
   }
 }
 
 TemporalLayers* TemporalLayersFactory::Create(
     int simulcast_id,
     int temporal_layers,
     uint8_t initial_tl0_pic_idx) const {
   TemporalLayers* tl =
       new DefaultTemporalLayers(temporal_layers, initial_tl0_pic_idx);
   if (listener_)
     listener_->OnTemporalLayersCreated(simulcast_id, tl);
   return tl;
 }
 
 void TemporalLayersFactory::SetListener(TemporalLayersListener* listener) {
   listener_ = listener;
 }
 
 }  // namespace webrtc