Drop frames until specified bitrate is achieved.

webrtc/video/vie_encoder_unittest.cc

 /*
  *  Copyright (c) 2016 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 20 matching lines @@
 #endif
 }
 
 namespace webrtc {
 
 using DegredationPreference = VideoSendStream::DegradationPreference;
 using ScaleReason = ScalingObserverInterface::ScaleReason;
 
 namespace {
 const size_t kMaxPayloadLength = 1440;
-const int kTargetBitrateBps = 100000;
+const int kTargetBitrateBps = 1000000;
 
 class TestBuffer : public webrtc::I420Buffer {
  public:
   TestBuffer(rtc::Event* event, int width, int height)
       : I420Buffer(width, height), event_(event) {}
 
  private:
   friend class rtc::RefCountedObject<TestBuffer>;
   ~TestBuffer() override {
     if (event_)
@@ skipping 85 matching lines @@
 
   void ConfigureEncoder(VideoEncoderConfig video_encoder_config,
                         bool nack_enabled) {
     if (vie_encoder_)
       vie_encoder_->Stop();
     vie_encoder_.reset(new ViEEncoderUnderTest(
         stats_proxy_.get(), video_send_config_.encoder_settings));
     vie_encoder_->SetSink(&sink_, false /* rotation_applied */);
     vie_encoder_->SetSource(&video_source_,
                             VideoSendStream::DegradationPreference::kBalanced);
-    vie_encoder_->SetStartBitrate(10000);
+    vie_encoder_->SetStartBitrate(kTargetBitrateBps);
     vie_encoder_->ConfigureEncoder(std::move(video_encoder_config),
                                    kMaxPayloadLength, nack_enabled);
   }
 
   void ResetEncoder(const std::string& payload_name,
                     size_t num_streams,
                     size_t num_temporal_layers,
                     bool nack_enabled) {
     video_send_config_.encoder_settings.payload_name = payload_name;
 
     VideoEncoderConfig video_encoder_config;
     video_encoder_config.number_of_streams = num_streams;
-    video_encoder_config.max_bitrate_bps = 1000000;
+    video_encoder_config.max_bitrate_bps = kTargetBitrateBps;
     video_encoder_config.video_stream_factory =
         new rtc::RefCountedObject<VideoStreamFactory>(num_temporal_layers);
     ConfigureEncoder(std::move(video_encoder_config), nack_enabled);
   }
 
   VideoFrame CreateFrame(int64_t ntp_ts, rtc::Event* destruction_event) const {
     VideoFrame frame(new rtc::RefCountedObject<TestBuffer>(
                          destruction_event, codec_width_, codec_height_),
                      99, 99, kVideoRotation_0);
     frame.set_ntp_time_ms(ntp_ts);
@@ skipping 495 matching lines @@
   sink_.WaitForEncodedFrame(3);
 
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, SwitchingSourceKeepsCpuAdaptation) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 1280;
   int frame_height = 720;
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
   sink_.WaitForEncodedFrame(1);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
@@ skipping 49 matching lines @@
       CreateFrame(6, frame_width, frame_height));
   sink_.WaitForEncodedFrame(6);
   stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
   EXPECT_EQ(2, stats.number_of_cpu_adapt_changes);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, SwitchingSourceKeepsQualityAdaptation) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 1280;
   int frame_height = 720;
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
   sink_.WaitForEncodedFrame(1);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_FALSE(stats.cpu_limited_resolution);
@@ skipping 115 matching lines @@
   sink_.WaitForEncodedFrame(1);
 
   VideoSendStream::Stats stats = stats_proxy_->GetStats();
   EXPECT_EQ(video_encoder_config_.max_bitrate_bps,
             stats.preferred_media_bitrate_bps);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, ScalingUpAndDownDoesNothingWithMaintainResolution) {
-  const int kTargetBitrateBps = 100000;
   int frame_width = 1280;
   int frame_height = 720;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   // Expect no scaling to begin with
   EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
   EXPECT_FALSE(video_source_.sink_wants().max_pixel_count_step_up);
 
   video_source_.IncomingCapturedFrame(
       CreateFrame(1, frame_width, frame_height));
@@ skipping 32 matching lines @@
       CreateFrame(4, frame_width, frame_height));
   sink_.WaitForEncodedFrame(4);
 
   // Expect nothing to change, still no scaling
   EXPECT_FALSE(new_video_source.sink_wants().max_pixel_count);
 
   vie_encoder_->Stop();
 }
 
 TEST_F(ViEEncoderTest, DoesNotScaleBelowSetLimit) {
-  const int kTargetBitrateBps = 100000;
   int frame_width = 1280;
   int frame_height = 720;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   for (size_t i = 1; i <= 10; i++) {
     video_source_.IncomingCapturedFrame(
         CreateFrame(i, frame_width, frame_height));
     sink_.WaitForEncodedFrame(i);
     // Trigger scale down
     vie_encoder_->TriggerQualityLow();
@@ skipping 26 matching lines @@
 
   vie_encoder_->Stop();
 
   stats_proxy_.reset();
   EXPECT_EQ(1,
             metrics::NumSamples("WebRTC.Video.CpuLimitedResolutionInPercent"));
   EXPECT_EQ(
       1, metrics::NumEvents("WebRTC.Video.CpuLimitedResolutionInPercent", 50));
 }
 
+TEST_F(ViEEncoderTest, DropsFramesUntilTartgetBitrateIsReached) {
+  vie_encoder_->OnBitrateUpdated(100000, 0, 0);
+  int frame_width = 1000;
+  int frame_height = 1000;
+  int dropped_frames = 0;
+
+  rtc::Event ev(false, false);
+  for (int i = 1; i <= 10; ++i) {
+    video_source_.IncomingCapturedFrame(
+        CreateFrame(i, frame_width, frame_height));
+    // Don't wait for the dropped frames.
+    ev.Wait(10);
+    if (*video_source_.sink_wants().max_pixel_count <
+        frame_width * frame_height)
+      dropped_frames++;

[sprang_webrtc, 2017/01/16 16:48:35]

nit: {} for multi-line if

+    frame_width = frame_height =
+        std::sqrt(*video_source_.sink_wants().max_pixel_count);
+  }
+  sink_.WaitForEncodedFrame(10);

[perkj_webrtc, 2017/01/17 08:53:10]

So you only expect one frame to be encoded. 
Can you write this a bit more readable? Skip the for- you only need two frames
and check the expectations for each frame you insert. 

If you do as I suggest and change so that a frame is encoded even if it is too
large you should also test that (maybe in a separate test since multiple simple
tests are prefered).

[kthelgason, 2017/01/18 09:16:16]

Good comments, thanks. I added some more thorough tests.

+  EXPECT_GT(dropped_frames, 0);
+
+  // Expect the sink_wants to specify a scaled frame.
+  EXPECT_TRUE(video_source_.sink_wants().max_pixel_count);
+  EXPECT_LT(*video_source_.sink_wants().max_pixel_count, 1000 * 1000);
+
+  const auto stats = stats_proxy_->GetStats();
+  EXPECT_FALSE(stats.cpu_limited_resolution);
+  EXPECT_TRUE(stats.bw_limited_resolution);
+
+  vie_encoder_->Stop();
+}
+
 }  // namespace webrtc