Derive current layer from TL frame config.

webrtc/modules/video_coding/codecs/vp8/screenshare_layers_unittest.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.
  */
 
@@ skipping 40 matching lines @@
   ScreenshareLayerTest()
       : min_qp_(2), max_qp_(kDefaultQp), frame_size_(-1), clock_(1) {}
   virtual ~ScreenshareLayerTest() {}
 
   void SetUp() override { layers_.reset(new ScreenshareLayers(2, 0, &clock_)); }
 
   void EncodeFrame(uint32_t timestamp,
                    bool base_sync,
                    CodecSpecificInfoVP8* vp8_info,
                    int* flags) {
-    TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+    TemporalLayers::FrameConfig tl_config =
+        layers_->UpdateLayerConfig(timestamp);
     if (tl_config.drop_frame) {
       *flags = -1;
       return;
     }
     *flags = VP8EncoderImpl::EncodeFlags(tl_config);
-    layers_->PopulateCodecSpecific(base_sync, vp8_info, timestamp);
+    layers_->PopulateCodecSpecific(base_sync, tl_config, vp8_info, timestamp);
     ASSERT_NE(-1, frame_size_);
     layers_->FrameEncoded(frame_size_, kDefaultQp);
   }
 
   void ConfigureBitrates() {
     vpx_codec_enc_cfg_t vpx_cfg;
     memset(&vpx_cfg, 0, sizeof(vpx_codec_enc_cfg_t));
     vpx_cfg.rc_min_quantizer = min_qp_;
     vpx_cfg.rc_max_quantizer = max_qp_;
     EXPECT_THAT(layers_->OnRatesUpdated(kDefaultTl0BitrateKbps,
@@ skipping 26 matching lines @@
       if (got_tl0 && got_tl1)
         return timestamp;
     }
     ADD_FAILURE() << "Frames from both layers not received in time.";
     return 0;
   }
 
   int SkipUntilTl(int layer, int timestamp) {
     CodecSpecificInfoVP8 vp8_info;
     for (int i = 0; i < 5; ++i) {
-      TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+      TemporalLayers::FrameConfig tl_config =
+          layers_->UpdateLayerConfig(timestamp);
       VP8EncoderImpl::EncodeFlags(tl_config);
       timestamp += kTimestampDelta5Fps;
-      layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+      layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
       if (vp8_info.temporalIdx != layer) {
         layers_->FrameEncoded(frame_size_, kDefaultQp);
       } else {
         return timestamp;
       }
     }
     ADD_FAILURE() << "Did not get a frame of TL" << layer << " in time.";
     return 0;
   }
 
@@ skipping 14 matching lines @@
 
 TEST_F(ScreenshareLayerTest, 1Layer) {
   layers_.reset(new ScreenshareLayers(1, 0, &clock_));
   ConfigureBitrates();
   int flags = 0;
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
   // One layer screenshare should not use the frame dropper as all frames will
   // belong to the base layer.
   const int kSingleLayerFlags = 0;
-  flags = VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp));
+  TemporalLayers::FrameConfig tl_config;
+  tl_config = layers_->UpdateLayerConfig(timestamp);
+  flags = VP8EncoderImpl::EncodeFlags(tl_config);
   EXPECT_EQ(kSingleLayerFlags, flags);
-  layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+  layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
   EXPECT_EQ(static_cast<uint8_t>(kNoTemporalIdx), vp8_info.temporalIdx);
   EXPECT_FALSE(vp8_info.layerSync);
   EXPECT_EQ(kNoTl0PicIdx, vp8_info.tl0PicIdx);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
-  flags = VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp));
+  tl_config = layers_->UpdateLayerConfig(timestamp);
+  flags = VP8EncoderImpl::EncodeFlags(tl_config);
   EXPECT_EQ(kSingleLayerFlags, flags);
   timestamp += kTimestampDelta5Fps;
-  layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+  layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
   EXPECT_EQ(static_cast<uint8_t>(kNoTemporalIdx), vp8_info.temporalIdx);
   EXPECT_FALSE(vp8_info.layerSync);
   EXPECT_EQ(kNoTl0PicIdx, vp8_info.tl0PicIdx);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 }
 
 TEST_F(ScreenshareLayerTest, 2Layer) {
   ConfigureBitrates();
   int flags = 0;
   uint32_t timestamp = 0;
@@ skipping 64 matching lines @@
 
 TEST_F(ScreenshareLayerTest, 2LayersSyncAfterTimeout) {
   ConfigureBitrates();
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
   std::vector<int> sync_times;
 
   const int kNumFrames = kMaxSyncPeriodSeconds * kFrameRate * 2 - 1;
   for (int i = 0; i < kNumFrames; ++i) {
     timestamp += kTimestampDelta5Fps;
-    layers_->UpdateLayerConfig(timestamp);
-    layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+    TemporalLayers::FrameConfig tl_config =
+        layers_->UpdateLayerConfig(timestamp);
+    layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
 
     // Simulate TL1 being at least 8 qp steps better.
     if (vp8_info.temporalIdx == 0) {
       layers_->FrameEncoded(frame_size_, kDefaultQp);
     } else {
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
     }
 
     if (vp8_info.temporalIdx == 1 && vp8_info.layerSync)
       sync_times.push_back(timestamp);
   }
 
   ASSERT_EQ(2u, sync_times.size());
   EXPECT_GE(sync_times[1] - sync_times[0], 90000 * kMaxSyncPeriodSeconds);
 }
 
 TEST_F(ScreenshareLayerTest, 2LayersSyncAfterSimilarQP) {
   ConfigureBitrates();
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
   std::vector<int> sync_times;
 
   const int kNumFrames = (kSyncPeriodSeconds +
                           ((kMaxSyncPeriodSeconds - kSyncPeriodSeconds) / 2)) *
                          kFrameRate;
   for (int i = 0; i < kNumFrames; ++i) {
     timestamp += kTimestampDelta5Fps;
-    layers_->UpdateLayerConfig(timestamp);
-    layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+    TemporalLayers::FrameConfig tl_config =
+        layers_->UpdateLayerConfig(timestamp);
+    layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
 
     // Simulate TL1 being at least 8 qp steps better.
     if (vp8_info.temporalIdx == 0) {
       layers_->FrameEncoded(frame_size_, kDefaultQp);
     } else {
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
     }
 
     if (vp8_info.temporalIdx == 1 && vp8_info.layerSync)
       sync_times.push_back(timestamp);
   }
 
   ASSERT_EQ(1u, sync_times.size());
 
   bool bumped_tl0_quality = false;
   for (int i = 0; i < 3; ++i) {
     timestamp += kTimestampDelta5Fps;
-    TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+    TemporalLayers::FrameConfig tl_config =
+        layers_->UpdateLayerConfig(timestamp);
     int flags = VP8EncoderImpl::EncodeFlags(tl_config);
-    layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+    layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
 
     if (vp8_info.temporalIdx == 0) {
       // Bump TL0 to same quality as TL1.
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
       bumped_tl0_quality = true;
     } else {
       layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
       if (bumped_tl0_quality) {
         EXPECT_TRUE(vp8_info.layerSync);
         EXPECT_EQ(kTl1SyncFlags, flags);
@@ skipping 127 matching lines @@
   // Updates cfg with current target bitrate.
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
 
   uint32_t timestamp = RunGracePeriod();
   timestamp = SkipUntilTl(0, timestamp);
 
   // Size 0 indicates dropped frame.
   layers_->FrameEncoded(0, kDefaultQp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_FALSE(layers_->UpdateConfiguration(&cfg));
-  EXPECT_EQ(kTl0Flags,
-            VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp)));
-  layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+  TemporalLayers::FrameConfig tl_config = layers_->UpdateLayerConfig(timestamp);
+  EXPECT_EQ(kTl0Flags, VP8EncoderImpl::EncodeFlags(tl_config));
+  layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   timestamp = SkipUntilTl(0, timestamp);
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   EXPECT_LT(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
-  layers_->UpdateLayerConfig(timestamp);
+  tl_config = layers_->UpdateLayerConfig(timestamp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
-  layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+  layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   // Next drop in TL1.
 
   timestamp = SkipUntilTl(1, timestamp);
   layers_->FrameEncoded(0, kDefaultQp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_FALSE(layers_->UpdateConfiguration(&cfg));
-  EXPECT_EQ(kTl1Flags,
-            VP8EncoderImpl::EncodeFlags(layers_->UpdateLayerConfig(timestamp)));
-  layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+  tl_config = layers_->UpdateLayerConfig(timestamp);
+  EXPECT_EQ(kTl1Flags, VP8EncoderImpl::EncodeFlags(tl_config));
+  layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   timestamp = SkipUntilTl(1, timestamp);
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   EXPECT_LT(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 
-  layers_->UpdateLayerConfig(timestamp);
+  tl_config = layers_->UpdateLayerConfig(timestamp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
-  layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
+  layers_->PopulateCodecSpecific(false, tl_config, &vp8_info, timestamp);
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
   layers_->FrameEncoded(frame_size_, kDefaultQp);
 }
 
 TEST_F(ScreenshareLayerTest, RespectsMaxIntervalBetweenFrames) {
   const int kLowBitrateKbps = 50;
   const int kLargeFrameSizeBytes = 100000;
   const uint32_t kStartTimestamp = 1234;
 
   vpx_codec_enc_cfg_t cfg = GetConfig();
@@ skipping 23 matching lines @@
   ConfigureBitrates();
   vpx_codec_enc_cfg_t cfg = GetConfig();
   bool trigger_drop = false;
   bool dropped_frame = false;
   bool overshoot = false;
   const int kTl0Qp = 35;
   const int kTl1Qp = 30;
   for (int64_t timestamp = 0;
        timestamp < kTimestampDelta5Fps * 5 * metrics::kMinRunTimeInSeconds;
        timestamp += kTimestampDelta5Fps) {
-    TemporalReferences tl_config = layers_->UpdateLayerConfig(timestamp);
+    TemporalLayers::FrameConfig tl_config =
+        layers_->UpdateLayerConfig(timestamp);
     if (tl_config.drop_frame) {
       dropped_frame = true;
       continue;
     }
     int flags = VP8EncoderImpl::EncodeFlags(tl_config);
     if (flags != -1)
       layers_->UpdateConfiguration(&cfg);
 
     if (timestamp >= kTimestampDelta5Fps * 5 && !overshoot && flags != -1) {
       // Simulate one overshoot.
@@ skipping 98 matching lines @@
     }
     timestamp += kFrameIntervalsMs * 90 / 2;
     clock_.AdvanceTimeMilliseconds(kFrameIntervalsMs / 2);
     ++num_input_frames;
   }
 
   // Allow for some rounding errors in the measurements.
   EXPECT_NEAR(num_discarded_frames, num_input_frames / 2, 2);
 }
 }  // namespace webrtc