Drop frames until specified bitrate is achieved.

webrtc/video/vie_encoder.cc

Index: webrtc/video/vie_encoder.cc
diff --git a/webrtc/video/vie_encoder.cc b/webrtc/video/vie_encoder.cc
index eaf693af169392883496a2f7fff370029248b433..4ef05fb0a1313e638c1cc11de15eafb5d876dfd5 100644
--- a/webrtc/video/vie_encoder.cc
+++ b/webrtc/video/vie_encoder.cc
@@ -42,6 +42,10 @@ const int kMinPixelsPerFrame = 320 * 180;
 const int kMinPixelsPerFrame = 120 * 90;
 #endif
 
+// The maximum number of frames to drop at beginning of stream

[perkj_webrtc, 2017/01/24 09:06:16]

same here. It happens every time the resolution change.

[kthelgason, 2017/01/24 10:53:10]

Acknowledged.

+// to try and achieve desired bitrate.
+const int kMaxInitialFramedrop = 4;
+
 // TODO(pbos): Lower these thresholds (to closer to 100%) when we handle
 // pipelining encoders better (multiple input frames before something comes
 // out). This should effectively turn off CPU adaptations for systems that
@@ -55,6 +59,17 @@ CpuOveruseOptions GetCpuOveruseOptions(bool full_overuse_time) {
   return options;
 }
 
+uint32_t MaximumFrameSizeForBitrate(uint32_t kbps) {
+  if (kbps > 0) {

[perkj_webrtc, 2017/01/24 09:06:16]

kbps can never be 0 right? 
RTC_DCHECK(kbps >0) instead of if.

[kthelgason, 2017/01/24 10:53:10]

It can actually be zero. |encoder_start_bitrate_| is initialized to 0 and it
seems that it's used to signal no bandwidth constraint or something. At least it
happens in practice, and the old code that used to handle this in the quality
scaler included this guard.

+    if (kbps < 300 /* qvga */) {
+      return 320 * 240;
+    } else if (kbps < 500 /* vga */) {
+      return 640 * 480;
+    }
+  }
+  return std::numeric_limits<uint32_t>::max();
+}
+
 }  //  namespace
 
 class ViEEncoder::ConfigureEncoderTask : public rtc::QueuedTask {
@@ -244,6 +259,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        EncodedFrameObserver* encoder_timing)
     : shutdown_event_(true /* manual_reset */, false),
       number_of_cores_(number_of_cores),
+      initial_rampup_(kMaxInitialFramedrop),
       source_proxy_(new VideoSourceProxy(this)),
       sink_(nullptr),
       settings_(settings),
@@ -439,6 +455,8 @@ void ViEEncoder::ReconfigureEncoder() {
 
   const auto scaling_settings = settings_.encoder->GetScalingSettings();
   if (scaling_enabled_ && scaling_settings.enabled) {
+    // Drop frames and scale down until desired quality is achieved.
+    initial_rampup_ = 0;
     if (scaling_settings.thresholds) {
       quality_scaler_.reset(
           new QualityScaler(this, *(scaling_settings.thresholds)));
@@ -562,6 +580,17 @@ void ViEEncoder::EncodeVideoFrame(const VideoFrame& video_frame,
   }
   TraceFrameDropEnd();
 
+  uint32_t max_pixel_count =

[perkj_webrtc, 2017/01/24 09:06:16]

Move all this to above the check for if(pending_encoder_recon..)

There is no need to reconfigure if the frame will be dropped anyway and lower
resolution requested.

[kthelgason, 2017/01/24 10:53:10]

Done.

+      MaximumFrameSizeForBitrate(encoder_start_bitrate_bps_ / 1000);
+  if (initial_rampup_ < kMaxInitialFramedrop &&
+      video_frame.size() > max_pixel_count) {
+    LOG(LS_INFO) << "Dropping frame. Too large for target bitrate.";
+    ScaleDown(kQuality);
+    ++initial_rampup_;
+    return;
+  }
+  initial_rampup_ = kMaxInitialFramedrop;
+
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");