Adding OnReceivedOverhead to AudioEncoder.

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.
  */
 
 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "webrtc/base/analytics/exp_filter.h"
 #include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h"
 #include "webrtc/modules/audio_coding/codecs/opus/opus_interface.h"
 #include "webrtc/system_wrappers/include/clock.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace webrtc {
 
 namespace {
 
 constexpr int kSampleRateHz = 48000;
 constexpr int kMinBitrateBps = 500;
 constexpr int kMaxBitrateBps = 512000;
 constexpr int kSupportedFrameLengths[] = {20, 60};
 
@@ skipping 250 matching lines @@
     float average_fraction_loss = packet_loss_fraction_smoother_->GetAverage();
     return SetProjectedPacketLossRate(average_fraction_loss);
   }
   audio_network_adaptor_->SetUplinkPacketLossFraction(
       uplink_packet_loss_fraction);
   ApplyAudioNetworkAdaptor();
 }
 
 void AudioEncoderOpus::OnReceivedTargetAudioBitrate(
     int target_audio_bitrate_bps) {
-  if (!audio_network_adaptor_)
-    return SetTargetBitrate(target_audio_bitrate_bps);
-  audio_network_adaptor_->SetTargetAudioBitrate(target_audio_bitrate_bps);
-  ApplyAudioNetworkAdaptor();
+  if (audio_network_adaptor_) {
+    audio_network_adaptor_->SetTargetAudioBitrate(target_audio_bitrate_bps);
+    ApplyAudioNetworkAdaptor();
+    return;
+  }
+  if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe-WithOverhead") ==
+      "Enabled") {
+    if (!overhead_bytes_per_packet_) {
+      LOG(LS_INFO)
+          << "AudioEncoderOpus: Overhead unknown, target audio bitrate "
+          << target_audio_bitrate_bps << " bps is ignored.";
+      return;
+    }
+    int overhead_rate =
+        8 * 100 * *overhead_bytes_per_packet_ / Num10MsFramesInNextPacket();

[kwiberg-webrtc, 2016/12/03 00:30:56]

I had a hard time deciphering this calculation. Could you call the variable
"overhead_bps" or something instead?

Also, const.

[minyue-webrtc, 2016/12/06 09:04:19]

Done.

+    SetTargetBitrate(std::min(
+        kMaxBitrateBps,
+        std::max(kMinBitrateBps, target_audio_bitrate_bps - overhead_rate)));
+    return;
+  }
+  SetTargetBitrate(target_audio_bitrate_bps);

[kwiberg-webrtc, 2016/12/03 00:30:56]

I'd argue this would be easier to read if you removed the explicit returns and
did

  if (...) {
    ...
  } else if (...) {
    ...
  } else {
    ...
  }

[minyue-webrtc, 2016/12/06 09:04:19]

Done.

 }
 
 void AudioEncoderOpus::OnReceivedRtt(int rtt_ms) {
   if (!audio_network_adaptor_)
     return;
   audio_network_adaptor_->SetRtt(rtt_ms);
   ApplyAudioNetworkAdaptor();
 }
 
+void AudioEncoderOpus::OnReceivedOverhead(size_t overhead_bytes_per_packet) {
+  if (audio_network_adaptor_) {
+    audio_network_adaptor_->SetOverhead(overhead_bytes_per_packet);
+    ApplyAudioNetworkAdaptor();
+    return;
+  }
+  overhead_bytes_per_packet_ = rtc::Optional<size_t>(overhead_bytes_per_packet);

[kwiberg-webrtc, 2016/12/03 00:30:56]

if ... else ... instead of the explicit return.

[minyue-webrtc, 2016/12/06 09:04:19]

Done.

+}
+
 void AudioEncoderOpus::SetReceiverFrameLengthRange(int min_frame_length_ms,
                                                    int max_frame_length_ms) {
   // Ensure that |SetReceiverFrameLengthRange| is called before
   // |EnableAudioNetworkAdaptor|, otherwise we need to recreate
   // |audio_network_adaptor_|, which is not a needed use case.
   RTC_DCHECK(!audio_network_adaptor_);
 
   config_.supported_frame_lengths_ms.clear();
   std::copy_if(std::begin(kSupportedFrameLengths),
                std::end(kSupportedFrameLengths),
@@ skipping 173 matching lines @@
   AudioNetworkAdaptorImpl::Config config;
   config.clock = clock;
   return std::unique_ptr<AudioNetworkAdaptor>(new AudioNetworkAdaptorImpl(
       config, ControllerManagerImpl::Create(
                   config_string, NumChannels(), supported_frame_lengths_ms(),
                   num_channels_to_encode_, next_frame_length_ms_,
                   GetTargetBitrate(), config_.fec_enabled, GetDtx(), clock)));
 }
 
 }  // namespace webrtc