Hooking up audio network adaptor to VoE.

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 "webrtc/base/checks.h"
+#include "webrtc/base/exp_filter.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"
 
 namespace webrtc {
 
 namespace {
@@ skipping 49 matching lines @@
     return kPacketLossRate5;
   } else if (new_loss_rate >= kPacketLossRate1) {
     return kPacketLossRate1;
   } else {
     return 0.0;
   }
 }
 
 }  // namespace
 
+class AudioEncoderOpus::PacketLossFractionSmoother {
+ public:
+  explicit PacketLossFractionSmoother(const Clock* clock)
+      : clock_(clock),
+        last_sample_time_ms_(clock_->TimeInMilliseconds()),
+        smoother_(0.9999f) {}

[the sun, 2016/10/11 17:52:42]

Would be nice with a comment about what the filter coeff means physically - e.g.
settles to within 1% in N millisecs.

[minyue-webrtc, 2016/10/12 11:27:35]

I do not quite recall what that number means :P, that is why comments are
important. Now added.

+
+  // Gets the smoothed packet loss fraction.
+  float GetAverage() const {
+    float value = smoother_.filtered();
+    return (value == rtc::ExpFilter::kValueUndefined) ? 0.0f : value;
+  }
+
+  // Add new observation to the packet loss fraction smoother.
+  void AddSample(float packet_loss_fraction) {
+    int64_t now_ms = clock_->TimeInMilliseconds();
+    smoother_.Apply(static_cast<float>(now_ms - last_sample_time_ms_),
+                    packet_loss_fraction);
+    last_sample_time_ms_ = now_ms;
+  }
+
+ private:
+  const Clock* const clock_;
+  int64_t last_sample_time_ms_;
+
+  // An exponential filter is used to smooth the packet loss fraction.
+  rtc::ExpFilter smoother_;
+};
+
 AudioEncoderOpus::Config::Config() = default;
 AudioEncoderOpus::Config::Config(const Config&) = default;
 AudioEncoderOpus::Config::~Config() = default;
 auto AudioEncoderOpus::Config::operator=(const Config&) -> Config& = default;
 
 bool AudioEncoderOpus::Config::IsOk() const {
   if (frame_size_ms <= 0 || frame_size_ms % 10 != 0)
     return false;
   if (num_channels != 1 && num_channels != 2)
     return false;
@@ skipping 11 matching lines @@
     return *bitrate_bps;  // Explicitly set value.
   else
     return num_channels == 1 ? 32000 : 64000;  // Default value.
 }
 
 AudioEncoderOpus::AudioEncoderOpus(
     const Config& config,
     AudioNetworkAdaptorCreator&& audio_network_adaptor_creator)
     : packet_loss_rate_(0.0),
       inst_(nullptr),
+      packet_loss_fraction_smoother_(new PacketLossFractionSmoother(
+          config.clock ? config.clock : Clock::GetRealTimeClock())),
       audio_network_adaptor_creator_(
           audio_network_adaptor_creator
-              ? audio_network_adaptor_creator
+              ? std::move(audio_network_adaptor_creator)
               : [this](const std::string& config_string, const Clock* clock) {
                   return DefaultAudioNetworkAdaptorCreator(config_string,
                                                            clock);
                 }) {
   RTC_CHECK(RecreateEncoderInstance(config));
 }
 
 AudioEncoderOpus::AudioEncoderOpus(const CodecInst& codec_inst)
     : AudioEncoderOpus(CreateConfig(codec_inst), nullptr) {}
 
@@ skipping 98 matching lines @@
 
 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;
+  if (!audio_network_adaptor_) {
+    packet_loss_fraction_smoother_->AddSample(uplink_packet_loss_fraction);
+    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;
+    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 149 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