Update smoothed bitrate.

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 <array>
 #include <memory>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/fakeclock.h"
+#include "webrtc/common_audio/mocks/mock_smoothing_filter.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/field_trial.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 using ::testing::NiceMock;
@@ skipping 11 matching lines @@
   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;
   config.supported_frame_lengths_ms.push_back(config.frame_size_ms);
   return config;
 }
 
 struct AudioEncoderOpusStates {
   std::shared_ptr<MockAudioNetworkAdaptor*> mock_audio_network_adaptor;
+  MockSmoothingFilter* mock_bitrate_smoother;
   std::unique_ptr<AudioEncoderOpus> encoder;
   std::unique_ptr<SimulatedClock> simulated_clock;
+  AudioEncoderOpus::Config config;
 };
 
 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.config = CreateConfig(codec_inst);
+  std::unique_ptr<MockSmoothingFilter> bitrate_smoother(
+      new MockSmoothingFilter());
+  states.mock_bitrate_smoother = bitrate_smoother.get();
   states.simulated_clock.reset(new SimulatedClock(kInitialTimeUs));
-  config.clock = states.simulated_clock.get();
+  states.config.clock = states.simulated_clock.get();
 
-  states.encoder.reset(new AudioEncoderOpus(config, std::move(creator)));
+  states.encoder.reset(new AudioEncoderOpus(states.config, std::move(creator),
+                                            std::move(bitrate_smoother)));
   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;
   constexpr float kPacketLossFraction = 0.1f;
@@ skipping 60 matching lines @@
   auto states = CreateCodec(2);
   // Enable DTX
   EXPECT_TRUE(states.encoder->SetDtx(true));
   // Verify that the mode is still kAudio.
   EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application());
   // Turn off DTX.
   EXPECT_TRUE(states.encoder->SetDtx(false));
 }
 
 TEST(AudioEncoderOpusTest,
-     OnReceivedTargetAudioBitrateWithoutAudioNetworkAdaptor) {
+     OnReceivedUplinkBandwidthWithoutAudioNetworkAdaptor) {
   auto states = CreateCodec(1);
   // Constants are replicated from audio_states.encoderopus.cc.
   const int kMinBitrateBps = 500;
   const int kMaxBitrateBps = 512000;
   // Set a too low bitrate.
-  states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps - 1);
+  states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps - 1,
+                                            rtc::Optional<int64_t>());
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
   // Set a too high bitrate.
-  states.encoder->OnReceivedTargetAudioBitrate(kMaxBitrateBps + 1);
+  states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + 1,
+                                            rtc::Optional<int64_t>());
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
   // Set the minimum rate.
-  states.encoder->OnReceivedTargetAudioBitrate(kMinBitrateBps);
+  states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps,
+                                            rtc::Optional<int64_t>());
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
   // Set the maximum rate.
-  states.encoder->OnReceivedTargetAudioBitrate(kMaxBitrateBps);
+  states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps,
+                                            rtc::Optional<int64_t>());
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
   // Set rates from 1000 up to 32000 bps.
   for (int rate = 1000; rate <= 32000; rate += 1000) {
-    states.encoder->OnReceivedTargetAudioBitrate(rate);
+    states.encoder->OnReceivedUplinkBandwidth(rate, rtc::Optional<int64_t>());
     EXPECT_EQ(rate, states.encoder->GetTargetBitrate());
   }
 }
 
 namespace {
 
 // Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1),
 // ..., b.
 std::vector<float> IntervalSteps(float a, float b, size_t n) {
   RTC_DCHECK_GT(n, 1u);
@@ skipping 57 matching lines @@
               ElementsAre(states.encoder->next_frame_length_ms()));
   states.encoder->SetReceiverFrameLengthRange(0, 12345);
   EXPECT_THAT(states.encoder->supported_frame_lengths_ms(),
               ElementsAre(20, 60));
   states.encoder->SetReceiverFrameLengthRange(21, 60);
   EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(60));
   states.encoder->SetReceiverFrameLengthRange(20, 59);
   EXPECT_THAT(states.encoder->supported_frame_lengths_ms(), ElementsAre(20));
 }
 
-TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
-  auto states = CreateCodec(2);
-  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
-
-  auto config = CreateEncoderRuntimeConfig();
-  EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
-      .WillOnce(Return(config));
-
-  // Since using mock audio network adaptor, any bandwidth value is fine.
-  constexpr int kUplinkBandwidth = 50000;
-  EXPECT_CALL(**states.mock_audio_network_adaptor,
-              SetUplinkBandwidth(kUplinkBandwidth));
-  states.encoder->OnReceivedUplinkBandwidth(kUplinkBandwidth);
-
-  CheckEncoderRuntimeConfig(states.encoder.get(), config);
-}
-
 TEST(AudioEncoderOpusTest,
      InvokeAudioNetworkAdaptorOnReceivedUplinkPacketLossFraction) {
   auto states = CreateCodec(2);
   states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
       .WillOnce(Return(config));
 
   // Since using mock audio network adaptor, any packet loss fraction is fine.
   constexpr float kUplinkPacketLoss = 0.1f;
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetUplinkPacketLossFraction(kUplinkPacketLoss));
   states.encoder->OnReceivedUplinkPacketLossFraction(kUplinkPacketLoss);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
-TEST(AudioEncoderOpusTest,
-     InvokeAudioNetworkAdaptorOnReceivedTargetAudioBitrate) {
+TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedUplinkBandwidth) {
   auto states = CreateCodec(2);
   states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
       .WillOnce(Return(config));
 
   // Since using mock audio network adaptor, any target audio bitrate is fine.
   constexpr int kTargetAudioBitrate = 30000;
+  constexpr int64_t kProbingIntervalMs = 3000;
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetTargetAudioBitrate(kTargetAudioBitrate));
-  states.encoder->OnReceivedTargetAudioBitrate(kTargetAudioBitrate);
+  EXPECT_CALL(*states.mock_bitrate_smoother,
+              SetTimeConstantMs(kProbingIntervalMs * 4));
+  EXPECT_CALL(*states.mock_bitrate_smoother, AddSample(kTargetAudioBitrate));
+  states.encoder->OnReceivedUplinkBandwidth(
+      kTargetAudioBitrate, rtc::Optional<int64_t>(kProbingIntervalMs));
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
 TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) {
   auto states = CreateCodec(2);
   states.encoder->EnableAudioNetworkAdaptor("", nullptr);
 
   auto config = CreateEncoderRuntimeConfig();
   EXPECT_CALL(**states.mock_audio_network_adaptor, GetEncoderRuntimeConfig())
@@ skipping 48 matching lines @@
   // optimized packet loss rate should have been increase to 0.1.
   EXPECT_FLOAT_EQ(0.05f, states.encoder->packet_loss_rate());
 }
 
 TEST(AudioEncoderOpusTest, DoNotInvokeSetTargetBitrateIfOverheadUnknown) {
   test::ScopedFieldTrials override_field_trials(
       "WebRTC-SendSideBwe-WithOverhead/Enabled/");
 
   auto states = CreateCodec(2);
 
-  states.encoder->OnReceivedTargetAudioBitrate(kDefaultOpusSettings.rate * 2);
+  states.encoder->OnReceivedUplinkBandwidth(kDefaultOpusSettings.rate * 2,
+                                            rtc::Optional<int64_t>());
 
   // Since |OnReceivedOverhead| has not been called, the codec bitrate should
   // not change.
   EXPECT_EQ(kDefaultOpusSettings.rate, states.encoder->GetTargetBitrate());
 }
 
 TEST(AudioEncoderOpusTest, OverheadRemovedFromTargetAudioBitrate) {
   test::ScopedFieldTrials override_field_trials(
       "WebRTC-SendSideBwe-WithOverhead/Enabled/");
 
   auto states = CreateCodec(2);
 
   constexpr size_t kOverheadBytesPerPacket = 64;
   states.encoder->OnReceivedOverhead(kOverheadBytesPerPacket);
 
   constexpr int kTargetBitrateBps = 40000;
-  states.encoder->OnReceivedTargetAudioBitrate(kTargetBitrateBps);
+  states.encoder->OnReceivedUplinkBandwidth(kTargetBitrateBps,
+                                            rtc::Optional<int64_t>());
 
   int packet_rate = rtc::CheckedDivExact(48000, kDefaultOpusSettings.pacsize);
   EXPECT_EQ(kTargetBitrateBps -
                 8 * static_cast<int>(kOverheadBytesPerPacket) * packet_rate,
             states.encoder->GetTargetBitrate());
 }
 
 TEST(AudioEncoderOpusTest, BitrateBounded) {
   test::ScopedFieldTrials override_field_trials(
       "WebRTC-SendSideBwe-WithOverhead/Enabled/");
 
   constexpr int kMinBitrateBps = 500;
   constexpr int kMaxBitrateBps = 512000;
 
   auto states = CreateCodec(2);
 
   constexpr size_t kOverheadBytesPerPacket = 64;
   states.encoder->OnReceivedOverhead(kOverheadBytesPerPacket);
 
   int packet_rate = rtc::CheckedDivExact(48000, kDefaultOpusSettings.pacsize);
 
   // Set a target rate that is smaller than |kMinBitrateBps| when overhead is
   // subtracted. The eventual codec rate should be bounded by |kMinBitrateBps|.
   int target_bitrate =
       kOverheadBytesPerPacket * 8 * packet_rate + kMinBitrateBps - 1;
-  states.encoder->OnReceivedTargetAudioBitrate(target_bitrate);
+  states.encoder->OnReceivedUplinkBandwidth(target_bitrate,
+                                            rtc::Optional<int64_t>());
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
 
   // Set a target rate that is greater than |kMaxBitrateBps| when overhead is
   // subtracted. The eventual codec rate should be bounded by |kMaxBitrateBps|.
   target_bitrate =
       kOverheadBytesPerPacket * 8 * packet_rate + kMaxBitrateBps + 1;
-  states.encoder->OnReceivedTargetAudioBitrate(target_bitrate);
+  states.encoder->OnReceivedUplinkBandwidth(target_bitrate,
+                                            rtc::Optional<int64_t>());
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
 }
 
 // Verifies that the complexity adaptation in the config works as intended.
 TEST(AudioEncoderOpusTest, ConfigComplexityAdaptation) {
   AudioEncoderOpus::Config config;
   config.low_rate_complexity = 8;
   config.complexity = 6;
 
   // Bitrate within hysteresis window. Expect empty output.
@@ skipping 26 matching lines @@
 
   constexpr size_t kOverhead = 64;
   EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead))
       .Times(2);
   states.encoder->OnReceivedOverhead(kOverhead);
   states.encoder->OnReceivedOverhead(kOverhead);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
+TEST(AudioEncoderOpusTest, UpdateUplinkBandwidthInAudioNetworkAdaptor) {
+  rtc::ScopedFakeClock fake_clock;
+  auto states = CreateCodec(2);
+  states.encoder->EnableAudioNetworkAdaptor("", nullptr);
+  std::array<int16_t, 480 * 2> audio;
+  audio.fill(0);
+  rtc::Buffer encoded;
+  EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage())
+      .WillOnce(Return(rtc::Optional<float>(50000)));
+  EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(50000));
+  states.encoder->Encode(
+      0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
+
+  // Repeat update uplink bandwidth tests.
+  for (int i = 0; i < 5; i++) {
+    // Don't update till it is time to update again.
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(
+        states.config.uplink_bandwidth_update_interval_ms - 1));
+    states.encoder->Encode(
+        0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
+
+    // Update when it is time to update.
+    EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage())
+        .WillOnce(Return(rtc::Optional<float>(40000)));
+    EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(40000));
+    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
+    states.encoder->Encode(
+        0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
+  }
+}
+
 }  // namespace webrtc