Base screenshare layers on TemporalReferences.

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 19 matching lines @@
 
 // 5 frames per second at 90 kHz.
 const uint32_t kTimestampDelta5Fps = 90000 / 5;
 const int kDefaultQp = 54;
 const int kDefaultTl0BitrateKbps = 200;
 const int kDefaultTl1BitrateKbps = 2000;
 const int kFrameRate = 5;
 const int kSyncPeriodSeconds = 5;
 const int kMaxSyncPeriodSeconds = 10;
 
+// Expected flags for corresponding temporal layers.
+const int kTl0Flags = VP8_EFLAG_NO_UPD_GF | VP8_EFLAG_NO_UPD_ARF |
+                      VP8_EFLAG_NO_REF_GF | VP8_EFLAG_NO_REF_ARF;
+const int kTl1Flags =
+    VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+const int kTl1SyncFlags = VP8_EFLAG_NO_REF_ARF | VP8_EFLAG_NO_REF_GF |
+                          VP8_EFLAG_NO_UPD_ARF | VP8_EFLAG_NO_UPD_LAST;
+
 class ScreenshareLayerTest : public ::testing::Test {
  protected:
   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) {
     *flags = layers_->EncodeFlags(timestamp);
     if (*flags == -1)
       return;
     layers_->PopulateCodecSpecific(base_sync, vp8_info, timestamp);
     ASSERT_NE(-1, frame_size_);
-    layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
+    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,
                                         kDefaultTl1BitrateKbps, kFrameRate),
                 ElementsAre(kDefaultTl0BitrateKbps,
@@ skipping 28 matching lines @@
     return 0;
   }
 
   int SkipUntilTl(int layer, int timestamp) {
     CodecSpecificInfoVP8 vp8_info;
     for (int i = 0; i < 5; ++i) {
       layers_->EncodeFlags(timestamp);
       timestamp += kTimestampDelta5Fps;
       layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
       if (vp8_info.temporalIdx != layer) {
-        layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
+        layers_->FrameEncoded(frame_size_, kDefaultQp);
       } else {
         return timestamp;
       }
     }
     ADD_FAILURE() << "Did not get a frame of TL" << layer << " in time.";
     return 0;
   }
 
   vpx_codec_enc_cfg_t GetConfig() {
     vpx_codec_enc_cfg_t cfg;
@@ skipping 18 matching lines @@
   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 = layers_->EncodeFlags(timestamp);
   EXPECT_EQ(kSingleLayerFlags, flags);
   layers_->PopulateCodecSpecific(false, &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_, timestamp, kDefaultQp);
+  layers_->FrameEncoded(frame_size_, kDefaultQp);
   flags = layers_->EncodeFlags(timestamp);
   EXPECT_EQ(kSingleLayerFlags, flags);
   timestamp += kTimestampDelta5Fps;
   layers_->PopulateCodecSpecific(false, &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_, timestamp, kDefaultQp);
+  layers_->FrameEncoded(frame_size_, kDefaultQp);
 }
 
 TEST_F(ScreenshareLayerTest, 2Layer) {
   ConfigureBitrates();
   int flags = 0;
   uint32_t timestamp = 0;
   uint8_t expected_tl0_idx = 0;
   CodecSpecificInfoVP8 vp8_info;
   EncodeFrame(timestamp, false, &vp8_info, &flags);
-  EXPECT_EQ(ScreenshareLayers::kTl0Flags, flags);
+  EXPECT_EQ(kTl0Flags, flags);
   EXPECT_EQ(0, vp8_info.temporalIdx);
   EXPECT_FALSE(vp8_info.layerSync);
   ++expected_tl0_idx;
   EXPECT_EQ(expected_tl0_idx, vp8_info.tl0PicIdx);
 
   // Insert 5 frames, cover grace period. All should be in TL0.
   for (int i = 0; i < 5; ++i) {
     timestamp += kTimestampDelta5Fps;
     EncodeFrame(timestamp, false, &vp8_info, &flags);
     EXPECT_EQ(0, vp8_info.temporalIdx);
     EXPECT_FALSE(vp8_info.layerSync);
     ++expected_tl0_idx;
     EXPECT_EQ(expected_tl0_idx, vp8_info.tl0PicIdx);
   }
 
   // First frame in TL0.
   timestamp += kTimestampDelta5Fps;
   EncodeFrame(timestamp, false, &vp8_info, &flags);
-  EXPECT_EQ(ScreenshareLayers::kTl0Flags, flags);
+  EXPECT_EQ(kTl0Flags, flags);
   EXPECT_EQ(0, vp8_info.temporalIdx);
   EXPECT_FALSE(vp8_info.layerSync);
   ++expected_tl0_idx;
   EXPECT_EQ(expected_tl0_idx, vp8_info.tl0PicIdx);
 
   // Drop two frames from TL0, thus being coded in TL1.
   timestamp += kTimestampDelta5Fps;
   EncodeFrame(timestamp, false, &vp8_info, &flags);
   // First frame is sync frame.
-  EXPECT_EQ(ScreenshareLayers::kTl1SyncFlags, flags);
+  EXPECT_EQ(kTl1SyncFlags, flags);
   EXPECT_EQ(1, vp8_info.temporalIdx);
   EXPECT_TRUE(vp8_info.layerSync);
   EXPECT_EQ(expected_tl0_idx, vp8_info.tl0PicIdx);
 
   timestamp += kTimestampDelta5Fps;
   EncodeFrame(timestamp, false, &vp8_info, &flags);
-  EXPECT_EQ(ScreenshareLayers::kTl1Flags, flags);
+  EXPECT_EQ(kTl1Flags, flags);
   EXPECT_EQ(1, vp8_info.temporalIdx);
   EXPECT_FALSE(vp8_info.layerSync);
   EXPECT_EQ(expected_tl0_idx, vp8_info.tl0PicIdx);
 }
 
 TEST_F(ScreenshareLayerTest, 2LayersPeriodicSync) {
   ConfigureBitrates();
   int flags = 0;
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
@@ skipping 19 matching lines @@
   std::vector<int> sync_times;
 
   const int kNumFrames = kMaxSyncPeriodSeconds * kFrameRate * 2 - 1;
   for (int i = 0; i < kNumFrames; ++i) {
     timestamp += kTimestampDelta5Fps;
     layers_->EncodeFlags(timestamp);
     layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
 
     // Simulate TL1 being at least 8 qp steps better.
     if (vp8_info.temporalIdx == 0) {
-      layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
+      layers_->FrameEncoded(frame_size_, kDefaultQp);
     } else {
-      layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp - 8);
+      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_->EncodeFlags(timestamp);
     layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
 
     // Simulate TL1 being at least 8 qp steps better.
     if (vp8_info.temporalIdx == 0) {
-      layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
+      layers_->FrameEncoded(frame_size_, kDefaultQp);
     } else {
-      layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp - 8);
+      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;
     int flags = layers_->EncodeFlags(timestamp);
     layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
 
     if (vp8_info.temporalIdx == 0) {
       // Bump TL0 to same quality as TL1.
-      layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp - 8);
+      layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
       bumped_tl0_quality = true;
     } else {
-      layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp - 8);
+      layers_->FrameEncoded(frame_size_, kDefaultQp - 8);
       if (bumped_tl0_quality) {
         EXPECT_TRUE(vp8_info.layerSync);
-        EXPECT_EQ(ScreenshareLayers::kTl1SyncFlags, flags);
+        EXPECT_EQ(kTl1SyncFlags, flags);
         return;
       }
     }
   }
   ADD_FAILURE() << "No TL1 frame arrived within time limit.";
 }
 
 TEST_F(ScreenshareLayerTest, 2LayersToggling) {
   ConfigureBitrates();
   int flags = 0;
@@ skipping 25 matching lines @@
   ConfigureBitrates();
   frame_size_ = ((kDefaultTl0BitrateKbps * 1000) / 8) / kFrameRate;
 
   int flags = 0;
   uint32_t timestamp = 0;
   CodecSpecificInfoVP8 vp8_info;
   // Insert 50 frames, small enough that all fits in TL0.
   for (int i = 0; i < 50; ++i) {
     EncodeFrame(timestamp, false, &vp8_info, &flags);
     timestamp += kTimestampDelta5Fps;
-    EXPECT_EQ(ScreenshareLayers::kTl0Flags, flags);
+    EXPECT_EQ(kTl0Flags, flags);
     EXPECT_EQ(0, vp8_info.temporalIdx);
   }
 }
 
 TEST_F(ScreenshareLayerTest, TooHighBitrate) {
   ConfigureBitrates();
   frame_size_ = 2 * ((kDefaultTl1BitrateKbps * 1000) / 8) / kFrameRate;
   int flags = 0;
   CodecSpecificInfoVP8 vp8_info;
   uint32_t timestamp = RunGracePeriod();
@@ skipping 68 matching lines @@
   ConfigureBitrates();
   CodecSpecificInfoVP8 vp8_info;
   vpx_codec_enc_cfg_t cfg = GetConfig();
   // 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, timestamp, kDefaultQp);
+  layers_->FrameEncoded(0, kDefaultQp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_FALSE(layers_->UpdateConfiguration(&cfg));
-  EXPECT_EQ(ScreenshareLayers::kTl0Flags, layers_->EncodeFlags(timestamp));
+  EXPECT_EQ(kTl0Flags, layers_->EncodeFlags(timestamp));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
-  layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
+  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_, timestamp, kDefaultQp);
+  layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   layers_->EncodeFlags(timestamp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
-  layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
+  layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   // Next drop in TL1.
 
   timestamp = SkipUntilTl(1, timestamp);
-  layers_->FrameEncoded(0, timestamp, kDefaultQp);
+  layers_->FrameEncoded(0, kDefaultQp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_FALSE(layers_->UpdateConfiguration(&cfg));
-  EXPECT_EQ(ScreenshareLayers::kTl1Flags, layers_->EncodeFlags(timestamp));
+  EXPECT_EQ(kTl1Flags, layers_->EncodeFlags(timestamp));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
-  layers_->FrameEncoded(frame_size_, timestamp, kDefaultQp);
+  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_, timestamp, kDefaultQp);
+  layers_->FrameEncoded(frame_size_, kDefaultQp);
 
   layers_->EncodeFlags(timestamp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_TRUE(layers_->UpdateConfiguration(&cfg));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
   EXPECT_EQ(cfg.rc_max_quantizer, static_cast<unsigned int>(kDefaultQp));
-  layers_->FrameEncoded(frame_size_, timestamp, 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();
   layers_->OnRatesUpdated(kLowBitrateKbps, kLowBitrateKbps, 5);
   layers_->UpdateConfiguration(&cfg);
 
-  EXPECT_EQ(ScreenshareLayers::kTl0Flags,
-            layers_->EncodeFlags(kStartTimestamp));
-  layers_->FrameEncoded(kLargeFrameSizeBytes, kStartTimestamp, kDefaultQp);
+  EXPECT_EQ(kTl0Flags, layers_->EncodeFlags(kStartTimestamp));
+  layers_->FrameEncoded(kLargeFrameSizeBytes, kDefaultQp);
 
   const uint32_t kTwoSecondsLater =
       kStartTimestamp + (ScreenshareLayers::kMaxFrameIntervalMs * 90);
 
   // Sanity check, repayment time should exceed kMaxFrameIntervalMs.
   ASSERT_GT(kStartTimestamp + 90 * (kLargeFrameSizeBytes * 8) / kLowBitrateKbps,
             kStartTimestamp + (ScreenshareLayers::kMaxFrameIntervalMs * 90));
 
   EXPECT_EQ(-1, layers_->EncodeFlags(kTwoSecondsLater));
   // More than two seconds has passed since last frame, one should be emitted
   // even if bitrate target is then exceeded.
-  EXPECT_EQ(ScreenshareLayers::kTl0Flags,
-            layers_->EncodeFlags(kTwoSecondsLater + 90));
+  EXPECT_EQ(kTl0Flags, layers_->EncodeFlags(kTwoSecondsLater + 90));
 }
 
 TEST_F(ScreenshareLayerTest, UpdatesHistograms) {
   metrics::Reset();
   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) {
     int flags = layers_->EncodeFlags(timestamp);
     if (flags != -1)
       layers_->UpdateConfiguration(&cfg);
 
     if (timestamp >= kTimestampDelta5Fps * 5 && !overshoot && flags != -1) {
       // Simulate one overshoot.
-      layers_->FrameEncoded(0, timestamp, 0);
+      layers_->FrameEncoded(0, 0);
       overshoot = true;
       flags = layers_->EncodeFlags(timestamp);
     }
 
-    if (flags == ScreenshareLayers::kTl0Flags) {
+    if (flags == kTl0Flags) {
       if (timestamp >= kTimestampDelta5Fps * 20 && !trigger_drop) {
         // Simulate a too large frame, to cause frame drop.
-        layers_->FrameEncoded(frame_size_ * 5, timestamp, kTl0Qp);
+        layers_->FrameEncoded(frame_size_ * 5, kTl0Qp);
         trigger_drop = true;
       } else {
-        layers_->FrameEncoded(frame_size_, timestamp, kTl0Qp);
+        layers_->FrameEncoded(frame_size_, kTl0Qp);
       }
-    } else if (flags == ScreenshareLayers::kTl1Flags ||
-               flags == ScreenshareLayers::kTl1SyncFlags) {
-      layers_->FrameEncoded(frame_size_, timestamp, kTl1Qp);
+    } else if (flags == kTl1Flags || flags == kTl1SyncFlags) {
+      layers_->FrameEncoded(frame_size_, kTl1Qp);
     } else if (flags == -1) {
       dropped_frame = true;
     } else {
       RTC_NOTREACHED() << "Unexpected flags";
     }
     clock_.AdvanceTimeMilliseconds(1000 / 5);
   }
 
   EXPECT_TRUE(overshoot);
   EXPECT_TRUE(dropped_frame);
@@ skipping 45 matching lines @@
   uint32_t timestamp = 1234;
   int num_input_frames = 0;
   int num_discarded_frames = 0;
 
   // Send at regular rate - no drops expected.
   for (int64_t i = 0; i < kTestSpanMs; i += kFrameIntervalsMs) {
     if (layers_->EncodeFlags(timestamp) == -1) {
       ++num_discarded_frames;
     } else {
       size_t frame_size_bytes = kDefaultTl0BitrateKbps * kFrameIntervalsMs / 8;
-      layers_->FrameEncoded(frame_size_bytes, timestamp, kDefaultQp);
+      layers_->FrameEncoded(frame_size_bytes, kDefaultQp);
     }
     timestamp += kFrameIntervalsMs * 90;
     clock_.AdvanceTimeMilliseconds(kFrameIntervalsMs);
     ++num_input_frames;
   }
   EXPECT_EQ(0, num_discarded_frames);
 
   // Send at twice the configured rate - drop every other frame.
   num_input_frames = 0;
   num_discarded_frames = 0;
   for (int64_t i = 0; i < kTestSpanMs; i += kFrameIntervalsMs / 2) {
     if (layers_->EncodeFlags(timestamp) == -1) {
       ++num_discarded_frames;
     } else {
       size_t frame_size_bytes = kDefaultTl0BitrateKbps * kFrameIntervalsMs / 8;
-      layers_->FrameEncoded(frame_size_bytes, timestamp, kDefaultQp);
+      layers_->FrameEncoded(frame_size_bytes, kDefaultQp);
     }
     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