Remove redudant encoder rate calls.

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 76 matching lines @@
 }  // namespace
 
 //#define DEBUG_ENCODER_BIT_STREAM
 
 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),
+      encoder_params_({0,0,0,0}),

[stefan-webrtc, 2015/10/29 14:12:06]

spaces between elements.

[pbos-webrtc, 2015/10/29 14:37:33]

cl-format done.

       internal_source_(internalSource),
       rotation_(kVideoRotation_0),
       is_screenshare_(false) {
 }
 
 VCMGenericEncoder::~VCMGenericEncoder()
 {
 }
 
 int32_t VCMGenericEncoder::Release()
 {
     {
-      rtc::CritScope lock(&rates_lock_);
-      bit_rate_ = 0;
-      frame_rate_ = 0;
+      rtc::CritScope lock(&params_lock_);
+      encoder_params_ = {0, 0, 0, 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;
+      rtc::CritScope lock(&params_lock_);
+      encoder_params_.target_bitrate = settings->startBitrate * 1000;
+      encoder_params_.input_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;
 }
@@ skipping 16 matching lines @@
   int32_t result = encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   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, &frameTypes);
   }
 
   return result;
 }
 
-int32_t
-VCMGenericEncoder::SetChannelParameters(int32_t packetLoss, int64_t rtt)
-{
-    return encoder_->SetChannelParameters(packetLoss, rtt);
+void VCMGenericEncoder::SetEncoderParameters(const EncoderParameters& params) {
+  bool channel_parameters_have_changed;
+  bool rates_have_changed;
+  {
+    rtc::CritScope lock(&params_lock_);
+    channel_parameters_have_changed =
+        params.loss_rate != encoder_params_.loss_rate ||
+        params.rtt != encoder_params_.rtt;
+    rates_have_changed =
+        params.target_bitrate != encoder_params_.target_bitrate ||
+        params.input_frame_rate != encoder_params_.input_frame_rate;
+    encoder_params_ = params;
+  }
+  if (channel_parameters_have_changed)
+    encoder_->SetChannelParameters(params.loss_rate, params.rtt);
+  if (rates_have_changed) {
+    uint32_t target_bitrate_kbps = (params.target_bitrate + 500) / 1000;
+    encoder_->SetRates(target_bitrate_kbps, params.input_frame_rate);
+    if (rate_observer_ != nullptr) {
+      rate_observer_->OnSetRates(params.target_bitrate,
+                                 params.input_frame_rate);
+    }
+  }
+}
+
+uint32_t VCMGenericEncoder::BitRate() const {
+  rtc::CritScope lock(&params_lock_);
+  return encoder_params_.target_bitrate;
+}
+
+uint32_t VCMGenericEncoder::FrameRate() const {
+  rtc::CritScope lock(&params_lock_);
+  return encoder_params_.input_frame_rate;
 }
 
 int32_t
-VCMGenericEncoder::SetRates(uint32_t newBitRate, uint32_t frameRate)
-{
-    uint32_t target_bitrate_kbps = (newBitRate + 500) / 1000;
-    int32_t ret = encoder_->SetRates(target_bitrate_kbps, frameRate);
-    if (ret < 0)
-    {
-        return ret;
-    }
-
-    {
-      rtc::CritScope lock(&rates_lock_);
-      bit_rate_ = newBitRate;
-      frame_rate_ = frameRate;
-    }
-
-    if (rate_observer_ != nullptr)
-      rate_observer_->OnSetRates(newBitRate, frameRate);
-    return VCM_OK;
-}
-
-int32_t
-VCMGenericEncoder::CodecConfigParameters(uint8_t* buffer, int32_t size)
-{
-    int32_t ret = encoder_->CodecConfigParameters(buffer, size);
-    if (ret < 0)
-    {
-        return ret;
-    }
-    return ret;
-}
-
-uint32_t VCMGenericEncoder::BitRate() const
-{
-    rtc::CritScope lock(&rates_lock_);
-    return bit_rate_;
-}
-
-uint32_t VCMGenericEncoder::FrameRate() const
-{
-    rtc::CritScope lock(&rates_lock_);
-    return frame_rate_;
-}
-
-int32_t
 VCMGenericEncoder::SetPeriodicKeyFrames(bool enable)
 {
     return encoder_->SetPeriodicKeyFrames(enable);
 }
 
 int32_t VCMGenericEncoder::RequestFrame(
     const std::vector<FrameType>& frame_types) {
   VideoFrame image;
   return encoder_->Encode(image, NULL, &frame_types);
 }
@@ skipping 101 matching lines @@
 }
 
 void
 VCMEncodedFrameCallback::SetMediaOpt(
     media_optimization::MediaOptimization *mediaOpt)
 {
     _mediaOpt = mediaOpt;
 }
 
 }  // namespace webrtc