Adding OnReceivedOverhead to AudioEncoder.

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/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;
 using ::testing::Return;
 
 namespace {
 
@@ skipping 215 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, InvokeAudioNetworkAdaptorOnSetUplinkBandwidth) {
+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,
-     InvokeAudioNetworkAdaptorOnSetUplinkPacketLossFraction) {
+     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, InvokeAudioNetworkAdaptorOnSetTargetAudioBitrate) {
+TEST(AudioEncoderOpusTest,
+     InvokeAudioNetworkAdaptorOnReceivedTargetAudioBitrate) {
   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;
   EXPECT_CALL(**states.mock_audio_network_adaptor,
               SetTargetAudioBitrate(kTargetAudioBitrate));
   states.encoder->OnReceivedTargetAudioBitrate(kTargetAudioBitrate);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
-TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnSetRtt) {
+TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedRtt) {
   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 rtt is fine.
   constexpr int kRtt = 30;
   EXPECT_CALL(**states.mock_audio_network_adaptor, SetRtt(kRtt));
   states.encoder->OnReceivedRtt(kRtt);
 
   CheckEncoderRuntimeConfig(states.encoder.get(), config);
 }
 
+TEST(AudioEncoderOpusTest, InvokeAudioNetworkAdaptorOnReceivedOverhead) {
+  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 overhead is fine.
+  constexpr size_t kOverhead = 64;

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

You don't have to use the kCamelCase naming convention for local variables.

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

ok. But if it is not a hard rule, I'd like to maintain consistency of this file.

[kwiberg-webrtc, 2016/12/06 09:43:25]

Acknowledged.

+  EXPECT_CALL(**states.mock_audio_network_adaptor, SetOverhead(kOverhead));
+  states.encoder->OnReceivedOverhead(kOverhead);
+
+  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 chosen to ease the calculation since
   // 0.9999 ^ 6931 = 0.5.
   constexpr int64_t kSecondSampleTimeMs = 6931;
 
   // First time, no filtering.
   states.encoder->OnReceivedUplinkPacketLossFraction(kPacketLossFraction_1);
   EXPECT_FLOAT_EQ(0.01f, 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_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);
+
+  // 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);
+
+  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);
+  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);
+  EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
+}
+
 }  // namespace webrtc