Injectable audio encoders: BuiltinAudioEncoderFactory

webrtc/modules/audio_coding/acm2/audio_coding_module_unittest.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 <stdio.h>
 #include <string.h>
 #include <memory>
 #include <vector>
 
 #include "webrtc/api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/md5digest.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/audio_coding/acm2/acm_receive_test.h"
 #include "webrtc/modules/audio_coding/acm2/acm_send_test.h"
 #include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
 #include "webrtc/modules/audio_coding/codecs/audio_format_conversion.h"
 #include "webrtc/modules/audio_coding/codecs/g711/audio_decoder_pcm.h"
 #include "webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.h"
 #include "webrtc/modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h"
+#include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module.h"
 #include "webrtc/modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "webrtc/modules/audio_coding/neteq/audio_decoder_impl.h"
 #include "webrtc/modules/audio_coding/neteq/mock/mock_audio_decoder.h"
 #include "webrtc/modules/audio_coding/neteq/tools/audio_checksum.h"
 #include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h"
 #include "webrtc/modules/audio_coding/neteq/tools/constant_pcm_packet_source.h"
 #include "webrtc/modules/audio_coding/neteq/tools/input_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/output_audio_file.h"
 #include "webrtc/modules/audio_coding/neteq/tools/packet.h"
@@ skipping 1219 matching lines @@
   std::unique_ptr<test::AcmSendTestOldApi> send_test_;
   std::unique_ptr<test::InputAudioFile> audio_source_;
   uint32_t frame_size_rtp_timestamps_;
   int packet_count_;
   uint8_t payload_type_;
   uint16_t last_sequence_number_;
   uint32_t last_timestamp_;
   rtc::Md5Digest payload_checksum_;
 };
 
+class AcmSenderBitExactnessNewApi : public AcmSenderBitExactnessOldApi {};
+
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
 TEST_F(AcmSenderBitExactnessOldApi, IsacWb30ms) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("ISAC", 16000, 1, 103, 480, 480));
   Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "0b58f9eeee43d5891f5f6c75e77984a3",
           "c7e5bdadfa2871df95639fcc297cf23d",
           "0499ca260390769b3172136faad925b9",
           "866abf524acd2807efbe65e133c23f95"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "3c79f16f34218271f3dca4e2b1dfe1bb",
@@ skipping 204 matching lines @@
           "0de6249018fdd316c21086db84e10610",
           "9c4cb69db77b85841a5f8225bb8f508b"),
       AcmReceiverBitExactnessOldApi::PlatformChecksum(
           "c7340b1189652ab6b5e80dade7390cb4",
           "c7340b1189652ab6b5e80dade7390cb4",
           "95612864c954ee63e28cc6eebad56626",
           "ae33ea2e43407cf9ebdabbbd6ca912a3"),
       50, test::AcmReceiveTestOldApi::kStereoOutput);
 }
 
+static const SdpAudioFormat kOpusFormat("opus", 48000, 2, {{"stereo", "1"}});

[kwiberg-webrtc, 2017/03/24 12:43:24]

The style guide prohibits this:
https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables

Make a function that returns a reference to a local const static variable?

[ossu, 2017/04/05 14:41:51]

I don't see how this would break in practice, even if it is against the letter
of the style guide. It's not visible outside of this translation unit and its
construction does not depend on other static objects. Similar constructs exist
in other parts of the code.

I'd rather move it inside of the two tests using it, than introducing a separate
function for this.

+
+TEST_F(AcmSenderBitExactnessNewApi, OpusFromFormat_stereo_20ms) {

[minyue-webrtc, 2017/03/23 11:36:53]

need to carefully exclude newer Opus version, do the same as in
"Opus_stereo_20ms" after rebasing

[ossu, 2017/03/23 12:01:59]

Alright. Will keep that in mind.

[minyue-webrtc, 2017/03/23 12:20:22]

Make sure you do it before submit, otherwise may break internal bots.

[ossu, 2017/04/05 14:41:51]

I've added the MAYBE_ macros for the tests below. I'll make sure to run internal
bots before landing.

+  std::unique_ptr<AudioEncoder> encoder(
+      new AudioEncoderOpus(120, kOpusFormat));

[kwiberg-webrtc, 2017/03/24 12:43:24]

Put this on the stack instead of on the heap? (I count 4 more occurrences
below.)

[ossu, 2017/04/05 14:41:51]

Acknowledged.

+  ASSERT_NO_FATAL_FAILURE(SetUpTestExternalEncoder(encoder.get(), 120));
+  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
+          "855041f2490b887302bce9d544731849",
+          "855041f2490b887302bce9d544731849",
+          "9692eede45638eb425e0daf9c75b5c7a",
+          "86d3552bb3492247f965cdd0e88a1c82"),
+      AcmReceiverBitExactnessOldApi::PlatformChecksum(
+          "d781cce1ab986b618d0da87226cdde30",
+          "d781cce1ab986b618d0da87226cdde30",
+          "8d6782b905c3230d4b0e3e83e1fc3439",
+          "798347a685fac7d0c2d8f748ffe66881"),
+      50, test::AcmReceiveTestOldApi::kStereoOutput);
+}
+
+TEST_F(AcmSenderBitExactnessNewApi, OpusFromFormat_stereo_20ms_voip) {
+  std::unique_ptr<AudioEncoder> encoder(
+      new AudioEncoderOpus(120, kOpusFormat));
+  ASSERT_NO_FATAL_FAILURE(SetUpTestExternalEncoder(encoder.get(), 120));
+  // If not set, default will be kAudio in case of stereo.
+  EXPECT_EQ(0, send_test_->acm()->SetOpusApplication(kVoip));
+  Run(AcmReceiverBitExactnessOldApi::PlatformChecksum(
+          "9b9e12bc3cc793740966e11cbfa8b35b",
+          "9b9e12bc3cc793740966e11cbfa8b35b",
+          "0de6249018fdd316c21086db84e10610",
+          "9c4cb69db77b85841a5f8225bb8f508b"),
+      AcmReceiverBitExactnessOldApi::PlatformChecksum(
+          "c7340b1189652ab6b5e80dade7390cb4",
+          "c7340b1189652ab6b5e80dade7390cb4",
+          "95612864c954ee63e28cc6eebad56626",
+          "ae33ea2e43407cf9ebdabbbd6ca912a3"),
+      50, test::AcmReceiveTestOldApi::kStereoOutput);
+}
+
 // This test is for verifying the SetBitRate function. The bitrate is changed at
 // the beginning, and the number of generated bytes are checked.
-class AcmSetBitRateOldApi : public ::testing::Test {
+class AcmSetBitRateTest : public ::testing::Test {
  protected:
   static const int kTestDurationMs = 1000;
 
   // Sets up the test::AcmSendTest object. Returns true on success, otherwise
   // false.
   bool SetUpSender() {
     const std::string input_file_name =
         webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm");
     // Note that |audio_source_| will loop forever. The test duration is set
     // explicitly by |kTestDurationMs|.
     audio_source_.reset(new test::InputAudioFile(input_file_name));
     static const int kSourceRateHz = 32000;
     send_test_.reset(new test::AcmSendTestOldApi(
         audio_source_.get(), kSourceRateHz, kTestDurationMs));
     return send_test_.get();
   }
 
   // Registers a send codec in the test::AcmSendTest object. Returns true on
   // success, false on failure.
   virtual bool RegisterSendCodec(const char* payload_name,
                                  int sampling_freq_hz,
                                  int channels,
                                  int payload_type,
                                  int frame_size_samples,
                                  int frame_size_rtp_timestamps) {
     return send_test_->RegisterCodec(payload_name, sampling_freq_hz, channels,
                                      payload_type, frame_size_samples);
   }
 
-  // Runs the test. SetUpSender() and RegisterSendCodec() must have been called
-  // before calling this method.
-  void Run(int target_bitrate_bps, int expected_total_bits) {
-    ASSERT_TRUE(send_test_->acm());
-    send_test_->acm()->SetBitRate(target_bitrate_bps);
+  bool RegisterExternalSendCodec(AudioEncoder* external_speech_encoder,
+                                 int payload_type) {
+    return send_test_->RegisterExternalCodec(external_speech_encoder);
+  }
+
+  void RunInner(int expected_total_bits) {
     int nr_bytes = 0;
     while (std::unique_ptr<test::Packet> next_packet =
                send_test_->NextPacket()) {
       nr_bytes += next_packet->payload_length_bytes();
     }
     EXPECT_EQ(expected_total_bits, nr_bytes * 8);
   }
 
   void SetUpTest(const char* codec_name,
                  int codec_sample_rate_hz,
                  int channels,
                  int payload_type,
                  int codec_frame_size_samples,
                  int codec_frame_size_rtp_timestamps) {
     ASSERT_TRUE(SetUpSender());
     ASSERT_TRUE(RegisterSendCodec(codec_name, codec_sample_rate_hz, channels,
                                   payload_type, codec_frame_size_samples,
                                   codec_frame_size_rtp_timestamps));
   }
 
   std::unique_ptr<test::AcmSendTestOldApi> send_test_;
   std::unique_ptr<test::InputAudioFile> audio_source_;
 };
 
+class AcmSetBitRateOldApi : public AcmSetBitRateTest {
+ protected:
+  // Runs the test. SetUpSender() must have been called and a codec must be set
+  // up before calling this method.
+  void Run(int target_bitrate_bps, int expected_total_bits) {
+    ASSERT_TRUE(send_test_->acm());
+    send_test_->acm()->SetBitRate(target_bitrate_bps);
+    RunInner(expected_total_bits);
+  }
+};
+
+class AcmSetBitRateNewApi : public AcmSetBitRateTest {
+ protected:
+  // Runs the test. SetUpSender() must have been called and a codec must be set
+  // up before calling this method.
+  void Run(int expected_total_bits) {
+    RunInner(expected_total_bits);
+  }
+};
+
 TEST_F(AcmSetBitRateOldApi, Opus_48khz_20ms_10kbps) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
 #if defined(WEBRTC_ANDROID)
   Run(10000, 9288);
 #else
   Run(10000, 9024);
 #endif  // WEBRTC_ANDROID
 }
 
 TEST_F(AcmSetBitRateOldApi, Opus_48khz_20ms_50kbps) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
 #if defined(WEBRTC_ANDROID)
   Run(50000, 47960);
 #else
   Run(50000, 49544);
 #endif  // WEBRTC_ANDROID
 }
 
+
 // The result on the Android platforms is inconsistent for this test case.
 // On android_rel the result is different from android and android arm64 rel.
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_Opus_48khz_20ms_100kbps DISABLED_Opus_48khz_20ms_100kbps
+#define MAYBE_OpusFromFormat_48khz_20ms_100kbps \

[minyue-webrtc, 2017/03/23 11:36:53]

same here

+  DISABLED_OpusFromFormat_48khz_20ms_100kbps
 #else
 #define MAYBE_Opus_48khz_20ms_100kbps Opus_48khz_20ms_100kbps
+#define MAYBE_OpusFromFormat_48khz_20ms_100kbps \
+  OpusFromFormat_48khz_20ms_100kbps
 #endif
 TEST_F(AcmSetBitRateOldApi, MAYBE_Opus_48khz_20ms_100kbps) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("opus", 48000, 1, 107, 960, 960));
   Run(100000, 100888);
 }
 
+TEST_F(AcmSetBitRateNewApi, OpusFromFormat_48khz_20ms_10kbps) {
+  std::unique_ptr<AudioEncoder> encoder(new AudioEncoderOpus(
+      107, SdpAudioFormat("opus", 48000, 2, {{"maxaveragebitrate", "10000"}})));
+  ASSERT_TRUE(SetUpSender());
+  ASSERT_TRUE(RegisterExternalSendCodec(encoder.get(), 107));
+#if defined(WEBRTC_ANDROID)
+  RunInner(9288);
+#else
+  RunInner(9024);
+#endif  // WEBRTC_ANDROID
+}
+
+TEST_F(AcmSetBitRateNewApi, OpusFromFormat_48khz_20ms_50kbps) {
+  std::unique_ptr<AudioEncoder> encoder(new AudioEncoderOpus(
+      107, SdpAudioFormat("opus", 48000, 2, {{"maxaveragebitrate", "50000"}})));
+  ASSERT_TRUE(SetUpSender());
+  ASSERT_TRUE(RegisterExternalSendCodec(encoder.get(), 107));
+#if defined(WEBRTC_ANDROID)
+  RunInner(47960);
+#else
+  RunInner(49544);
+#endif  // WEBRTC_ANDROID
+}
+
+TEST_F(AcmSetBitRateNewApi, MAYBE_OpusFromFormat_48khz_20ms_100kbps) {
+  std::unique_ptr<AudioEncoder> encoder(new AudioEncoderOpus(
+      107,
+      SdpAudioFormat("opus", 48000, 2, {{"maxaveragebitrate", "100000"}})));
+  ASSERT_TRUE(SetUpSender());
+  ASSERT_TRUE(RegisterExternalSendCodec(encoder.get(), 107));
+  RunInner(100888);
+}
+
 // These next 2 tests ensure that the SetBitRate function has no effect on PCM
 TEST_F(AcmSetBitRateOldApi, Pcm16_8khz_10ms_8kbps) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 8000, 1, 107, 80, 80));
   Run(8000, 128000);
 }
 
 TEST_F(AcmSetBitRateOldApi, Pcm16_8khz_10ms_32kbps) {
   ASSERT_NO_FATAL_FAILURE(SetUpTest("L16", 8000, 1, 107, 80, 80));
   Run(32000, 128000);
 }
@@ skipping 246 matching lines @@
   Run(16000, 8000, 1000);
 }
 
 TEST_F(AcmSwitchingOutputFrequencyOldApi, Toggle8KhzTo16Khz) {
   Run(8000, 16000, 1000);
 }
 
 #endif
 
 }  // namespace webrtc