In screenshare mode, suppress VP8 bitrate overshoot and increase quality

webrtc/modules/video_coding/main/source/generic_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 42 matching lines @@
 
 VCMGenericEncoder::VCMGenericEncoder(VideoEncoder* encoder,
                                      VideoEncoderRateObserver* rate_observer,
                                      bool internalSource)
     : encoder_(encoder),
       rate_observer_(rate_observer),
       vcm_encoded_frame_callback_(nullptr),
       bit_rate_(0),
       frame_rate_(0),
       internal_source_(internalSource),
-      rotation_(kVideoRotation_0) {
-}
+      rotation_(kVideoRotation_0),
+      is_screenshare_(false) {}
 
 VCMGenericEncoder::~VCMGenericEncoder()
 {
 }
 
 int32_t VCMGenericEncoder::Release()
 {
     {
       rtc::CritScope lock(&rates_lock_);
       bit_rate_ = 0;
       frame_rate_ = 0;
       vcm_encoded_frame_callback_ = nullptr;
     }
 
     return encoder_->Release();
 }
 
 int32_t
 VCMGenericEncoder::InitEncode(const VideoCodec* settings,
                               int32_t numberOfCores,
                               size_t maxPayloadSize)
 {
     {
       rtc::CritScope lock(&rates_lock_);
       bit_rate_ = settings->startBitrate * 1000;
       frame_rate_ = settings->maxFramerate;
     }
 
+    is_screenshare_ = settings->mode == VideoCodecMode::kScreensharing;
     if (encoder_->InitEncode(settings, numberOfCores, maxPayloadSize) != 0) {
       LOG(LS_ERROR) << "Failed to initialize the encoder associated with "
                        "payload name: " << settings->plName;
       return -1;
     }
     return 0;
 }
 
 int32_t VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
                                   const CodecSpecificInfo* codecSpecificInfo,
                                   const std::vector<FrameType>& frameTypes) {
   std::vector<VideoFrameType> video_frame_types(frameTypes.size(),
                                                 kDeltaFrame);
   VCMEncodedFrame::ConvertFrameTypes(frameTypes, &video_frame_types);
 
   rotation_ = inputFrame.rotation();
 
   if (vcm_encoded_frame_callback_) {
     // Keep track of the current frame rotation and apply to the output of the
     // encoder. There might not be exact as the encoder could have one frame
     // delay but it should be close enough.
     vcm_encoded_frame_callback_->SetRotation(rotation_);
   }
 
-  return encoder_->Encode(inputFrame, codecSpecificInfo, &video_frame_types);
+  int32_t result =
+      encoder_->Encode(inputFrame, codecSpecificInfo, &video_frame_types);
+  if (is_screenshare_ &&
+      result == WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT) {
+    // Target bitrate exceeded, encoder state has been reset - try again.
+    return encoder_->Encode(inputFrame, codecSpecificInfo, &video_frame_types);
+  }
+
+  return result;
 }
 
 int32_t
 VCMGenericEncoder::SetChannelParameters(int32_t packetLoss, int64_t rtt)
 {
     return encoder_->SetChannelParameters(packetLoss, rtt);
 }
 
 int32_t
 VCMGenericEncoder::SetRates(uint32_t newBitRate, uint32_t frameRate)
@@ skipping 151 matching lines @@
 }
 
 void
 VCMEncodedFrameCallback::SetMediaOpt(
     media_optimization::MediaOptimization *mediaOpt)
 {
     _mediaOpt = mediaOpt;
 }
 
 }  // namespace webrtc