Hooking up audio network adaptor to VoE.

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

 /*
  *  Copyright (c) 2015 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 <memory>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h"
 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
 #include "webrtc/test/gtest.h"
+#include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 using ::testing::NiceMock;
 using ::testing::Return;
 
 namespace {
 
 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000};
+constexpr int64_t kInitialTimeUs = 12345678;
 
 AudioEncoderOpus::Config CreateConfig(const CodecInst& codec_inst) {
   AudioEncoderOpus::Config config;
   config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48);
   config.num_channels = codec_inst.channels;
   config.bitrate_bps = rtc::Optional<int>(codec_inst.rate);
   config.payload_type = codec_inst.pltype;
   config.application = config.num_channels == 1 ? AudioEncoderOpus::kVoip
                                                 : AudioEncoderOpus::kAudio;
   return config;
 }
 
 struct AudioEncoderOpusStates {
   std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor;
   std::unique_ptr<AudioEncoderOpus> encoder;
+  std::unique_ptr<SimulatedClock> simulated_clock;
 };
 
 AudioEncoderOpusStates CreateCodec(size_t num_channels) {
   AudioEncoderOpusStates states;
   states.mock_audio_network_adaptor =
       std::make_shared<MockAudioNetworkAdaptor*>(nullptr);
 
   std::weak_ptr<MockAudioNetworkAdaptor*> mock_ptr(
       states.mock_audio_network_adaptor);
   AudioEncoderOpus::AudioNetworkAdaptorCreator creator = [mock_ptr](
       const std::string&, const Clock*) {
     std::unique_ptr<MockAudioNetworkAdaptor> adaptor(
         new NiceMock<MockAudioNetworkAdaptor>());
     EXPECT_CALL(*adaptor, Die());
     if (auto sp = mock_ptr.lock()) {
       *sp = adaptor.get();
     } else {
       RTC_NOTREACHED();
     }
     return adaptor;
   };
 
   CodecInst codec_inst = kDefaultOpusSettings;
   codec_inst.channels = num_channels;
   auto config = CreateConfig(codec_inst);
+  states.simulated_clock.reset(new SimulatedClock(kInitialTimeUs));
+  config.clock = states.simulated_clock.get();
+
   states.encoder.reset(new AudioEncoderOpus(config, std::move(creator)));
   return states;
 }
 
 AudioNetworkAdaptor::EncoderRuntimeConfig CreateEncoderRuntimeConfig() {
   constexpr int kBitrate = 40000;
   constexpr int kFrameLength = 60;
   constexpr bool kEnableFec = true;
   constexpr bool kEnableDtx = false;
   constexpr size_t kNumChannels = 1;
@@ skipping 220 matching lines @@
 
   constexpr int kMinFrameLength = 10;
   constexpr int kMaxFrameLength = 60;
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetReceiverFrameLengthRange(kMinFrameLength, kMaxFrameLength));
   states.encoder->SetReceiverFrameLengthRange(kMinFrameLength, kMaxFrameLength);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
+TEST(AudioEncoderOpusTest,
+     PacketLossFractionSmoothedOnSetUplinkPacketLossFraction) {
+  auto states = CreateCodec(2);
+
+  // The values are carefully chosen so that if no smoothing is made, the test
+  // will fail.
+  constexpr float kPacketLossFraction_1 = 0.02f;
+  constexpr float kPacketLossFraction_2 = 0.198f;
+  // |kSecondSampleTimeMs| is chose to ease the calculation since
+  // 0.9999 ^ 6931 = 0.5.
+  constexpr float kSecondSampleTimeMs = 6931;
+
+  // First time, no filtering.
+  states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
+  EXPECT_DOUBLE_EQ(0.01, states.encoder->packet_loss_rate());
+
+  states.simulated_clock->AdvanceTimeMilliseconds(kSecondSampleTimeMs);
+  states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_2);
+
+  // Now the output of packet loss fraction smoother should be
+  // (0.02 + 0.198) / 2 = 0.109, which reach the threshold for the optimized
+  // packet loss rate to increase to 0.05. If no smoothing has been made, the
+  // optimized packet loss rate should have been increase to 0.1.
+  EXPECT_DOUBLE_EQ(0.05, states.encoder->packet_loss_rate());
+}
+
 }  // namespace webrtc