Injectable audio encoders: BuiltinAudioEncoderFactory

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 <utility>
 
 #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/modules/audio_coding/neteq/tools/audio_loop.h"
 #include "webrtc/test/field_trial.h"
 #include "webrtc/test/gmock.h"
@@ skipping 15 matching lines @@
   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;
   config.supported_frame_lengths_ms.push_back(config.frame_size_ms);
   return config;
 }
 
+AudioEncoderOpus::Config CreateConfigWithParameters(
+    const SdpAudioFormat::Parameters& params) {
+  SdpAudioFormat format("opus", 48000, 2, params);
+  return AudioEncoderOpus::CreateConfig(0, format);
+}
+
 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;
@@ skipping 43 matching lines @@
   config.enable_dtx = rtc::Optional<bool>(kEnableDtx);
   config.num_channels = rtc::Optional<size_t>(kNumChannels);
   config.uplink_packet_loss_fraction =
       rtc::Optional<float>(kPacketLossFraction);
   return config;
 }
 
 void CheckEncoderRuntimeConfig(
     const AudioEncoderOpus* encoder,
     const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
-  EXPECT_EQ(*config.bitrate_bps, encoder->GetTargetBitrate());
-  EXPECT_EQ(*config.frame_length_ms, encoder->next_frame_length_ms());
-  EXPECT_EQ(*config.enable_fec, encoder->fec_enabled());
-  EXPECT_EQ(*config.enable_dtx, encoder->GetDtx());
-  EXPECT_EQ(*config.num_channels, encoder->num_channels_to_encode());
+  EXPECT_EQ(config.bitrate_bps, encoder->GetTargetBitrate());
+  EXPECT_EQ(config.frame_length_ms, encoder->next_frame_length_ms());
+  EXPECT_EQ(config.enable_fec, encoder->fec_enabled());
+  EXPECT_EQ(config.enable_dtx, encoder->GetDtx());
+  EXPECT_EQ(config.num_channels, encoder->num_channels_to_encode());
 }
 
 // Create 10ms audio data blocks for a total packet size of "packet_size_ms".
 std::unique_ptr<test::AudioLoop> Create10msAudioBlocks(
     const std::unique_ptr<AudioEncoderOpus>& encoder,
     int packet_size_ms) {
   const std::string file_name =
       test::ResourcePath("audio_coding/testfile32kHz", "pcm");
 
   std::unique_ptr<test::AudioLoop> speech_data(new test::AudioLoop());
@@ skipping 54 matching lines @@
   EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application());
   // Turn off DTX.
   EXPECT_TRUE(states.encoder->SetDtx(false));
 }
 
 TEST(AudioEncoderOpusTest,
      OnReceivedUplinkBandwidthWithoutAudioNetworkAdaptor) {
   auto states = CreateCodec(1);
   // Constants are replicated from audio_states.encoderopus.cc.
   const int kMinBitrateBps = 6000;
-  const int kMaxBitrateBps = 512000;
+  const int kMaxBitrateBps = 510000;
   // Set a too low bitrate.
   states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps - 1,
                                             rtc::Optional<int64_t>());
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
   // Set a too high bitrate.
   states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + 1,
                                             rtc::Optional<int64_t>());
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
   // Set the minimum rate.
   states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps,
@@ skipping 210 matching lines @@
   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 = 6000;
-  constexpr int kMaxBitrateBps = 512000;
+  constexpr int kMaxBitrateBps = 510000;
 
   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|.
@@ skipping 107 matching lines @@
     }
 
     // Should encode now.
     states.encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(),
                            &encoded);
     EXPECT_GT(encoded.size(), 0u);
     encoded.Clear();
   }
 }
 
+TEST(AudioEncoderOpusTest, TestConfigDefaults) {
+  const AudioEncoderOpus::Config config =
+      AudioEncoderOpus::CreateConfig(0, {"opus", 48000, 2});
+
+  EXPECT_EQ(48000, config.max_playback_rate_hz);
+  EXPECT_EQ(1u, config.num_channels);
+  EXPECT_FALSE(config.fec_enabled);
+  EXPECT_FALSE(config.dtx_enabled);
+  EXPECT_EQ(20, config.frame_size_ms);
+}
+
+TEST(AudioEncoderOpusTest, TestConfigFromParams) {
+  AudioEncoderOpus::Config config;
+
+  config = CreateConfigWithParameters({{"stereo", "0"}});
+  EXPECT_EQ(1U, config.num_channels);
+
+  config = CreateConfigWithParameters({{"stereo", "1"}});
+  EXPECT_EQ(2U, config.num_channels);
+
+  config = CreateConfigWithParameters({{"useinbandfec", "0"}});
+  EXPECT_EQ(false, config.fec_enabled);
+
+  config = CreateConfigWithParameters({{"useinbandfec", "1"}});
+  EXPECT_EQ(true, config.fec_enabled);
+
+  config = CreateConfigWithParameters({{"usedtx", "0"}});
+  EXPECT_EQ(false, config.dtx_enabled);
+
+  config = CreateConfigWithParameters({{"usedtx", "1"}});
+  EXPECT_EQ(true, config.dtx_enabled);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "12345"}});
+  EXPECT_EQ(12345, config.max_playback_rate_hz);
+
+  config = CreateConfigWithParameters({{"maxaveragebitrate", "96000"}});
+  EXPECT_EQ(96000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxptime", "40"}});
+  for (int frame_length : config.supported_frame_lengths_ms) {
+    EXPECT_LE(frame_length, 40);
+  }
+
+  config = CreateConfigWithParameters({{"minptime", "40"}});
+  for (int frame_length : config.supported_frame_lengths_ms) {
+    EXPECT_GE(frame_length, 40);
+  }
+
+  config = CreateConfigWithParameters({{"ptime", "40"}});
+  EXPECT_EQ(40, config.frame_size_ms);
+
+  constexpr int kMinSupportedFrameLength = 10;
+  constexpr int kMaxSupportedFrameLength =
+      WEBRTC_OPUS_SUPPORT_120MS_PTIME ? 120 : 60;
+
+  config = CreateConfigWithParameters({{"ptime", "1"}});
+  EXPECT_EQ(kMinSupportedFrameLength, config.frame_size_ms);
+
+  config = CreateConfigWithParameters({{"ptime", "2000"}});
+  EXPECT_EQ(kMaxSupportedFrameLength, config.frame_size_ms);
+}
+
+TEST(AudioEncoderOpusTest, TestConfigFromInvalidParams) {
+  const webrtc::SdpAudioFormat format("opus", 48000, 2);
+  const AudioEncoderOpus::Config default_config =
+      AudioEncoderOpus::CreateConfig(0, format);
+  const std::vector<int> default_supported_frame_lengths_ms({20, 60});
+
+  AudioEncoderOpus::Config config;
+  config = CreateConfigWithParameters({{"stereo", "invalid"}});
+  EXPECT_EQ(default_config.num_channels, config.num_channels);
+
+  config = CreateConfigWithParameters({{"useinbandfec", "invalid"}});
+  EXPECT_EQ(default_config.fec_enabled, config.fec_enabled);
+
+  config = CreateConfigWithParameters({{"usedtx", "invalid"}});
+  EXPECT_EQ(default_config.dtx_enabled, config.dtx_enabled);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "0"}});
+  EXPECT_EQ(default_config.max_playback_rate_hz, config.max_playback_rate_hz);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "-23"}});
+  EXPECT_EQ(default_config.max_playback_rate_hz, config.max_playback_rate_hz);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "not a number!"}});
+  EXPECT_EQ(default_config.max_playback_rate_hz, config.max_playback_rate_hz);
+
+  config = CreateConfigWithParameters({{"maxaveragebitrate", "0"}});
+  EXPECT_EQ(6000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxaveragebitrate", "-1000"}});
+  EXPECT_EQ(6000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxaveragebitrate", "1024000"}});
+  EXPECT_EQ(510000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxaveragebitrate", "not a number!"}});
+  EXPECT_EQ(default_config.bitrate_bps, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxptime", "invalid"}});
+  EXPECT_EQ(default_supported_frame_lengths_ms,
+            config.supported_frame_lengths_ms);
+
+  config = CreateConfigWithParameters({{"minptime", "invalid"}});
+  EXPECT_EQ(default_supported_frame_lengths_ms,
+            config.supported_frame_lengths_ms);
+
+  config = CreateConfigWithParameters({{"ptime", "invalid"}});
+  EXPECT_EQ(default_supported_frame_lengths_ms,
+            config.supported_frame_lengths_ms);
+}
+
+// Test that bitrate will be overridden by the "maxaveragebitrate" parameter.
+// Also test that the "maxaveragebitrate" can't be set to values outside the
+// range of 6000 and 510000
+TEST(AudioEncoderOpusTest, SetSendCodecOpusMaxAverageBitrate) {
+  // Ignore if less than 6000.
+  const AudioEncoderOpus::Config config1 = AudioEncoderOpus::CreateConfig(
+      0, {"opus", 48000, 2, {{"maxaveragebitrate", "5999"}}});
+  EXPECT_EQ(6000, config1.bitrate_bps);
+
+  // Ignore if larger than 510000.
+  const AudioEncoderOpus::Config config2 = AudioEncoderOpus::CreateConfig(
+      0, {"opus", 48000, 2, {{"maxaveragebitrate", "510001"}}});
+  EXPECT_EQ(510000, config2.bitrate_bps);
+
+  const AudioEncoderOpus::Config config3 = AudioEncoderOpus::CreateConfig(
+      0, {"opus", 48000, 2, {{"maxaveragebitrate", "200000"}}});
+  EXPECT_EQ(200000, config3.bitrate_bps);
+}
+
+// Test maxplaybackrate <= 8000 triggers Opus narrow band mode.
+TEST(AudioEncoderOpusTest, SetMaxPlaybackRateNb) {
+  auto config = CreateConfigWithParameters({{"maxplaybackrate", "8000"}});
+  EXPECT_EQ(8000, config.max_playback_rate_hz);
+  EXPECT_EQ(12000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "8000"},
+                                       {"stereo", "1"}});
+  EXPECT_EQ(8000, config.max_playback_rate_hz);
+  EXPECT_EQ(24000, config.bitrate_bps);
+}
+
+// Test 8000 < maxplaybackrate <= 12000 triggers Opus medium band mode.
+TEST(AudioEncoderOpusTest, SetMaxPlaybackRateMb) {
+  auto config = CreateConfigWithParameters({{"maxplaybackrate", "8001"}});
+  EXPECT_EQ(8001, config.max_playback_rate_hz);
+  EXPECT_EQ(20000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "8001"},
+                                       {"stereo", "1"}});
+  EXPECT_EQ(8001, config.max_playback_rate_hz);
+  EXPECT_EQ(40000, config.bitrate_bps);
+}
+
+// Test 12000 < maxplaybackrate <= 16000 triggers Opus wide band mode.
+TEST(AudioEncoderOpusTest, SetMaxPlaybackRateWb) {
+  auto config = CreateConfigWithParameters({{"maxplaybackrate", "12001"}});
+  EXPECT_EQ(12001, config.max_playback_rate_hz);
+  EXPECT_EQ(20000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "12001"},
+                                       {"stereo", "1"}});
+  EXPECT_EQ(12001, config.max_playback_rate_hz);
+  EXPECT_EQ(40000, config.bitrate_bps);
+}
+
+// Test 16000 < maxplaybackrate <= 24000 triggers Opus super wide band mode.
+TEST(AudioEncoderOpusTest, SetMaxPlaybackRateSwb) {
+  auto config = CreateConfigWithParameters({{"maxplaybackrate", "16001"}});
+  EXPECT_EQ(16001, config.max_playback_rate_hz);
+  EXPECT_EQ(32000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "16001"},
+                                       {"stereo", "1"}});
+  EXPECT_EQ(16001, config.max_playback_rate_hz);
+  EXPECT_EQ(64000, config.bitrate_bps);
+}
+
+// Test 24000 < maxplaybackrate triggers Opus full band mode.
+TEST(AudioEncoderOpusTest, SetMaxPlaybackRateFb) {
+  auto config = CreateConfigWithParameters({{"maxplaybackrate", "24001"}});
+  EXPECT_EQ(24001, config.max_playback_rate_hz);
+  EXPECT_EQ(32000, config.bitrate_bps);
+
+  config = CreateConfigWithParameters({{"maxplaybackrate", "24001"},
+                                       {"stereo", "1"}});
+  EXPECT_EQ(24001, config.max_playback_rate_hz);
+  EXPECT_EQ(64000, config.bitrate_bps);
+}
+
 }  // namespace webrtc