Remove redudant encoder rate calls.

webrtc/modules/video_coding/main/source/generic_encoder.cc

Index: webrtc/modules/video_coding/main/source/generic_encoder.cc
diff --git a/webrtc/modules/video_coding/main/source/generic_encoder.cc b/webrtc/modules/video_coding/main/source/generic_encoder.cc
index dbb1c17ff9e671425c3e69d0b5b94aa318f579ce..06a7650653e94a980d43b4a5adc921e5ee11d562 100644
--- a/webrtc/modules/video_coding/main/source/generic_encoder.cc
+++ b/webrtc/modules/video_coding/main/source/generic_encoder.cc
@@ -94,8 +94,7 @@ VCMGenericEncoder::VCMGenericEncoder(VideoEncoder* encoder,
     : 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) {
@@ -108,9 +107,8 @@ 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;
     }
 
@@ -123,9 +121,9 @@ VCMGenericEncoder::InitEncode(const VideoCodec* settings,
                               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;
@@ -162,54 +160,39 @@ int32_t VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
   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)
-{
-    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;
+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);
     }
-    return ret;
+  }
 }
 
-uint32_t VCMGenericEncoder::BitRate() const
-{
-    rtc::CritScope lock(&rates_lock_);
-    return bit_rate_;
+uint32_t VCMGenericEncoder::BitRate() const {
+  rtc::CritScope lock(&params_lock_);
+  return encoder_params_.target_bitrate;
 }
 
-uint32_t VCMGenericEncoder::FrameRate() const
-{
-    rtc::CritScope lock(&rates_lock_);
-    return frame_rate_;
+uint32_t VCMGenericEncoder::FrameRate() const {
+  rtc::CritScope lock(&params_lock_);
+  return encoder_params_.input_frame_rate;
 }
 
 int32_t