Renaming AudioEncoder::SetTargetBitrate and SetProjectedPacketLossRate.

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc

 /*
  *  Copyright (c) 2014 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 179 matching lines @@
   }
   return RecreateEncoderInstance(conf);
 }
 
 void AudioEncoderOpus::SetMaxPlaybackRate(int frequency_hz) {
   auto conf = config_;
   conf.max_playback_rate_hz = frequency_hz;
   RTC_CHECK(RecreateEncoderInstance(conf));
 }
 
-void AudioEncoderOpus::SetProjectedPacketLossRate(double fraction) {
-  double opt_loss_rate = OptimizePacketLossRate(fraction, packet_loss_rate_);
-  if (packet_loss_rate_ != opt_loss_rate) {
-    packet_loss_rate_ = opt_loss_rate;
-    RTC_CHECK_EQ(
-        0, WebRtcOpus_SetPacketLossRate(
-               inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
-  }
-}
-
-void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
-  config_.bitrate_bps = rtc::Optional<int>(
-      std::max(std::min(bits_per_second, kMaxBitrateBps), kMinBitrateBps));
-  RTC_DCHECK(config_.IsOk());
-  RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.GetBitrateBps()));
-}
-
 bool AudioEncoderOpus::EnableAudioNetworkAdaptor(
     const std::string& config_string,
     const Clock* clock) {
   audio_network_adaptor_ = audio_network_adaptor_creator_(config_string, clock);
   return audio_network_adaptor_.get() != nullptr;
 }
 
 void AudioEncoderOpus::DisableAudioNetworkAdaptor() {
   audio_network_adaptor_.reset(nullptr);
 }
 
 void AudioEncoderOpus::OnReceivedUplinkBandwidth(int uplink_bandwidth_bps) {
   if (!audio_network_adaptor_)
     return;
   audio_network_adaptor_->SetUplinkBandwidth(uplink_bandwidth_bps);
   ApplyAudioNetworkAdaptor();
 }
 
 void AudioEncoderOpus::OnReceivedUplinkPacketLossFraction(
     float uplink_packet_loss_fraction) {
-  if (!audio_network_adaptor_) {
-    return AudioEncoder::OnReceivedTargetAudioBitrate(
-        uplink_packet_loss_fraction);
-  }
+  if (!audio_network_adaptor_)
+    SetProjectedPacketLossRate(uplink_packet_loss_fraction);

[kwiberg-webrtc, 2016/10/20 21:46:23]

Shouldn't there be an early retirn here? Or an else?

[minyue-webrtc, 2016/11/08 13:37:24]

Yes, it should early return :)

This is self-solved after rebasing.

   audio_network_adaptor_->SetUplinkPacketLossFraction(
       uplink_packet_loss_fraction);
   ApplyAudioNetworkAdaptor();
 }
 
 void AudioEncoderOpus::OnReceivedTargetAudioBitrate(
     int target_audio_bitrate_bps) {
   if (!audio_network_adaptor_)
-    return AudioEncoder::OnReceivedTargetAudioBitrate(target_audio_bitrate_bps);
+    return SetTargetBitrate(target_audio_bitrate_bps);
   audio_network_adaptor_->SetTargetAudioBitrate(target_audio_bitrate_bps);
   ApplyAudioNetworkAdaptor();
 }
 
 void AudioEncoderOpus::OnReceivedRtt(int rtt_ms) {
   if (!audio_network_adaptor_)
     return;
   audio_network_adaptor_->SetRtt(rtt_ms);
   ApplyAudioNetworkAdaptor();
 }
@@ skipping 114 matching lines @@
   RTC_DCHECK_GT(num_channels_to_encode, 0u);
   RTC_DCHECK_LE(num_channels_to_encode, config_.num_channels);
 
   if (num_channels_to_encode_ == num_channels_to_encode)
     return;
 
   RTC_CHECK_EQ(0, WebRtcOpus_SetForceChannels(inst_, num_channels_to_encode));
   num_channels_to_encode_ = num_channels_to_encode;
 }
 
+void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
+  config_.bitrate_bps = rtc::Optional<int>(
+      std::max(std::min(bits_per_second, kMaxBitrateBps), kMinBitrateBps));
+  RTC_DCHECK(config_.IsOk());
+  RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.GetBitrateBps()));
+}
+
+void AudioEncoderOpus::SetProjectedPacketLossRate(double fraction) {
+  double opt_loss_rate = OptimizePacketLossRate(fraction, packet_loss_rate_);
+  if (packet_loss_rate_ != opt_loss_rate) {
+    packet_loss_rate_ = opt_loss_rate;
+    RTC_CHECK_EQ(
+        0, WebRtcOpus_SetPacketLossRate(
+               inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
+  }
+}
+
 void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {
   auto config = audio_network_adaptor_->GetEncoderRuntimeConfig();
   // |audio_network_adaptor_| is supposed to be configured to output all
   // following parameters.
   RTC_DCHECK(config.bitrate_bps);
   RTC_DCHECK(config.frame_length_ms);
   RTC_DCHECK(config.uplink_packet_loss_fraction);
   RTC_DCHECK(config.enable_fec);
   RTC_DCHECK(config.enable_dtx);
   RTC_DCHECK(config.num_channels);
@@ skipping 15 matching lines @@
   AudioNetworkAdaptorImpl::Config config;
   config.clock = clock;
   return std::unique_ptr<AudioNetworkAdaptor>(new AudioNetworkAdaptorImpl(
       config, ControllerManagerImpl::Create(
                   config_string, NumChannels(), kSupportedFrameLengths,
                   num_channels_to_encode_, next_frame_length_ms_,
                   GetTargetBitrate(), config_.fec_enabled, GetDtx(), clock)));
 }
 
 }  // namespace webrtc