Make sure temporal layered screenshare frames are sent in at least 2s.

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 90 matching lines @@
       if (vp8_info.temporalIdx != layer) {
         layers_->FrameEncoded(frame_size_, timestamp, 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;
+    memset(&cfg, 0, sizeof(cfg));
+    cfg.rc_min_quantizer = 2;
+    cfg.rc_max_quantizer = kDefaultQp;
+    return cfg;
+  }
+
   int min_qp_;
   int max_qp_;
   int frame_size_;
   SimulatedClock clock_;
   std::unique_ptr<ScreenshareLayers> layers_;
 };
 
 TEST_F(ScreenshareLayerTest, 1Layer) {
   layers_.reset(new ScreenshareLayers(1, 0, &clock_));
   ConfigureBitrates();
@@ skipping 231 matching lines @@
           break;
         case 1:
           ++tl1_frames;
           break;
         default:
           abort();
       }
     }
   }
 
-  EXPECT_EQ(5, tl0_frames);
-  EXPECT_EQ(45, tl1_frames);
+  EXPECT_EQ(50, tl0_frames + tl1_frames);
   EXPECT_EQ(50, dropped_frames);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateCappedByTL0) {
-  vpx_codec_enc_cfg_t cfg;
+  vpx_codec_enc_cfg_t cfg = GetConfig();
   layers_->ConfigureBitrates(100, 1000, 5, &cfg);
 
   EXPECT_EQ(static_cast<unsigned int>(
                 ScreenshareLayers::kMaxTL0FpsReduction * 100 + 0.5),
             cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateCappedByTL1) {
-  vpx_codec_enc_cfg_t cfg;
+  vpx_codec_enc_cfg_t cfg = GetConfig();
   layers_->ConfigureBitrates(100, 450, 5, &cfg);
 
   EXPECT_EQ(static_cast<unsigned int>(
                 450 / ScreenshareLayers::kAcceptableTargetOvershoot),
             cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, TargetBitrateBelowTL0) {
-  vpx_codec_enc_cfg_t cfg;
+  vpx_codec_enc_cfg_t cfg = GetConfig();
   layers_->ConfigureBitrates(100, 100, 5, &cfg);
 
   EXPECT_EQ(100U, cfg.rc_target_bitrate);
 }
 
 TEST_F(ScreenshareLayerTest, EncoderDrop) {
   ConfigureBitrates();
   CodecSpecificInfoVP8 vp8_info;
-  vpx_codec_enc_cfg_t cfg;
-  cfg.rc_max_quantizer = kDefaultQp;
+  vpx_codec_enc_cfg_t cfg = GetConfig();
 
   uint32_t timestamp = RunGracePeriod();
   timestamp = SkipUntilTl(0, timestamp);
 
   // Size 0 indicates dropped frame.
   layers_->FrameEncoded(0, timestamp, kDefaultQp);
   timestamp += kTimestampDelta5Fps;
   EXPECT_FALSE(layers_->UpdateConfiguration(&cfg));
   EXPECT_EQ(ScreenshareLayers::kTl0Flags, layers_->EncodeFlags(timestamp));
   layers_->PopulateCodecSpecific(false, &vp8_info, timestamp);
@@ skipping 27 matching lines @@
   layers_->FrameEncoded(frame_size_, timestamp, 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);
 }
 
+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_->ConfigureBitrates(kLowBitrateKbps, kLowBitrateKbps, 5, &cfg);
+
+  EXPECT_EQ(ScreenshareLayers::kTl0Flags,
+            layers_->EncodeFlags(kStartTimestamp));
+  layers_->FrameEncoded(kLargeFrameSizeBytes, kStartTimestamp, 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));
+}
+
 TEST_F(ScreenshareLayerTest, UpdatesHistograms) {
   ConfigureBitrates();
-  vpx_codec_enc_cfg_t cfg;
-  cfg.rc_max_quantizer = kDefaultQp;
+  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)
@@ skipping 62 matching lines @@
             test::LastHistogramSample("WebRTC.Video.Screenshare.Layer1.Qp"));
   EXPECT_EQ(kDefaultTl0BitrateKbps,
             test::LastHistogramSample(
                 "WebRTC.Video.Screenshare.Layer0.TargetBitrate"));
   EXPECT_EQ(kDefaultTl1BitrateKbps,
             test::LastHistogramSample(
                 "WebRTC.Video.Screenshare.Layer1.TargetBitrate"));
 }
 
 }  // namespace webrtc