Drop frames until specified bitrate is achieved.

webrtc/video/vie_encoder.cc

 /*
  *  Copyright (c) 2012 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 37 matching lines @@
 // remotely cope with the load right now.
 CpuOveruseOptions GetCpuOveruseOptions(bool full_overuse_time) {
   CpuOveruseOptions options;
   if (full_overuse_time) {
     options.low_encode_usage_threshold_percent = 150;
     options.high_encode_usage_threshold_percent = 200;
   }
   return options;
 }
 
+int MaximumFrameSizeForBitrate(int kbps) {

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

uint32_t encoder_start_bitrate_bps_

 MaximumFrameSizeForBitrate can never get a negative bitrate and thus does not
have to check for that. Param should also be a uint.

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

Done.

+  if (kbps > 0) {
+    if (kbps < 300 /* qvga */) {
+      return 320 * 240;
+    } else if (kbps < 500 /* vga */) {
+      return 640 * 480;
+    }
+  }
+  return std::numeric_limits<int>::max();
+}
+
 }  //  namespace
 
 class ViEEncoder::ConfigureEncoderTask : public rtc::QueuedTask {
  public:
   ConfigureEncoderTask(ViEEncoder* vie_encoder,
                        VideoEncoderConfig config,
                        size_t max_data_payload_length,
                        bool nack_enabled)
       : vie_encoder_(vie_encoder),
         config_(std::move(config)),
@@ skipping 169 matching lines @@
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoSourceProxy);
 };
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        SendStatisticsProxy* stats_proxy,
                        const VideoSendStream::Config::EncoderSettings& settings,
                        rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
                        EncodedFrameObserver* encoder_timing)
     : shutdown_event_(true /* manual_reset */, false),
       number_of_cores_(number_of_cores),
+      initial_rampup_(false),
       source_proxy_(new VideoSourceProxy(this)),
       sink_(nullptr),
       settings_(settings),
       codec_type_(PayloadNameToCodecType(settings.payload_name)
                       .value_or(VideoCodecType::kVideoCodecUnknown)),
       video_sender_(Clock::GetRealTimeClock(), this, this),
       overuse_detector_(Clock::GetRealTimeClock(),
                         GetCpuOveruseOptions(settings.full_overuse_time),
                         this,
                         encoder_timing,
@@ skipping 177 matching lines @@
         encoder_config_, rate_allocator_->GetPreferredBitrateBps(framerate));
   }
 
   pending_encoder_reconfiguration_ = false;
 
   sink_->OnEncoderConfigurationChanged(
       std::move(streams), encoder_config_.min_transmit_bitrate_bps);
 
   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_ = true;
     if (scaling_settings.thresholds) {
       quality_scaler_.reset(
           new QualityScaler(this, *(scaling_settings.thresholds)));
     } else {
       quality_scaler_.reset(new QualityScaler(this, codec_type_));
     }
   } else {
     quality_scaler_.reset(nullptr);
     stats_proxy_->SetResolutionRestrictionStats(
         false, scale_counter_[kCpu] > 0, scale_counter_[kQuality]);
@@ skipping 99 matching lines @@
 
   if (EncoderPaused()) {
     TraceFrameDropStart();
     return;
   }
   TraceFrameDropEnd();
 
   last_frame_height_ = video_frame.height();
   last_frame_width_ = video_frame.width();
 
+  int expected_pixel_count =

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

nit: please remove this unnecessary temp.

[perkj_webrtc, 2017/01/17 10:30:02]

oh, we should probably do this before Reconfiguring the encoder too since will
drop the frame and wait for a new resolution anyway.

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

Done.

+      MaximumFrameSizeForBitrate(encoder_start_bitrate_bps_ / 1000);

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

nit: Why not use unit bps here too since that is what we already have.

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

I started out implementing it that way, but changed it to kbps for readability.
It's really hard (at least for me) to quickly tell the difference between 100000
and 1000000.

+  if (initial_rampup_ && video_frame.size() > expected_pixel_count) {

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

instead of initial_rampup being a bool- can we let it be a counter and drop the
first say 3 frames after a reconfiguration if the configured bitrate is too low
?
Otherwise, what happens if the source can not scale down further? Then we will
never encode these frames and drop all. 

something like 
if( video_frame.size() > MaximumFrameSizeForBitrate(encoder_start_bitrate_bps_)
&& frames_dropped_due_to_bitrate_ > ....) { 

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

That's a very good point, thanks. Done!

+    LOG(LS_INFO) << "Dropping frame. Too large for target bitrate.";
+    ScaleDown(kQuality);
+    return;
+  }
+  initial_rampup_ = false;
+
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
 
   overuse_detector_.FrameCaptured(video_frame, time_when_posted_in_ms);
 
   if (codec_type_ == webrtc::kVideoCodecVP8) {
     webrtc::CodecSpecificInfo codec_specific_info;
     codec_specific_info.codecType = webrtc::kVideoCodecVP8;
 
     codec_specific_info.codecSpecific.VP8.hasReceivedRPSI = has_received_rpsi_;
@@ skipping 145 matching lines @@
       stats_proxy_->OnCpuRestrictedResolutionChanged(true);
       break;
   }
   max_pixel_count_ = rtc::Optional<int>(current_pixel_count);
   max_pixel_count_step_up_ = rtc::Optional<int>();
   ++scale_counter_[reason];
   source_proxy_->RequestResolutionLowerThan(current_pixel_count);
   LOG(LS_INFO) << "Scaling down resolution.";
   for (size_t i = 0; i < kScaleReasonSize; ++i) {
     LOG(LS_INFO) << "Scaled " << scale_counter_[i]
-                 << " times for reason: " << (i ? "quality" : "cpu");
+                 << " times for reason: " << (i ? "cpu" : "quality");
   }
 }
 
 void ViEEncoder::ScaleUp(ScaleReason reason) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   if (scale_counter_[reason] == 0 || !scaling_enabled_)
     return;
   // Only scale if resolution is higher than last time
   // we requested higher resolution.
   int current_pixel_count = last_frame_height_ * last_frame_width_;
@@ skipping 15 matching lines @@
   --scale_counter_[reason];
   source_proxy_->RequestHigherResolutionThan(current_pixel_count);
   LOG(LS_INFO) << "Scaling up resolution.";
   for (size_t i = 0; i < kScaleReasonSize; ++i) {
     LOG(LS_INFO) << "Scaled " << scale_counter_[i]
                  << " times for reason: " << (i ? "cpu" : "quality");
   }
 }
 
 }  // namespace webrtc