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 47 matching lines @@
                  kLossRate5Margin *
                      (kPacketLossRate5 - old_loss_rate > 0 ? 1 : -1)) {
     return kPacketLossRate5;
   } else if (new_loss_rate >= kPacketLossRate1) {
     return kPacketLossRate1;
   } else {
     return 0.0;
   }
 }
 
+class PacketLossFractionSmoother {
+ public:
+  explicit PacketLossFractionSmoother(const Clock* clock)
+      : clock_(clock),
+        last_sample_time_ms_(clock_->TimeInMilliseconds()),
+        smoother_(new rtc::ExpFilter(0.9999f)) {}
+
+  ~PacketLossFractionSmoother() = default;

[kwiberg-webrtc, 2016/10/11 14:56:19]

I don't think this line does anything. This is what you'd get by default if you
didn't mention the destructor at all.

[minyue-webrtc, 2016/10/11 15:31:09]

Done.

+
+  // 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.
+  std::unique_ptr<rtc::ExpFilter> smoother_;

[kwiberg-webrtc, 2016/10/11 14:56:19]

Do you need to point to the ExpFilter? Can't you embed it directly?

[minyue-webrtc, 2016/10/11 15:31:09]

no. I simply copied from the old implementation. But of course, good to get rid
of pointer now.

+};
+
 }  // namespace
 
 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;
@@ skipping 13 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