AudioCodingModule: Specify decoders using SdpAudioFormat

webrtc/modules/audio_coding/acm2/audio_coding_module_unittest_oldapi.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/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_oldapi.h"
 #include "webrtc/modules/audio_coding/acm2/acm_send_test_oldapi.h"
+#include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/modules/audio_coding/codecs/audio_encoder.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/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"
@@ skipping 143 matching lines @@
            0,
            input_frame_.samples_per_channel_ * sizeof(input_frame_.data_[0]));
 
     ASSERT_EQ(0, acm_->RegisterTransportCallback(&packet_cb_));
 
     SetUpL16Codec();
   }
 
   // Set up L16 codec.
   virtual void SetUpL16Codec() {
+    audio_format_ =
+        rtc::Optional<SdpAudioFormat>(SdpAudioFormat("L16", kSampleRateHz, 1));
     ASSERT_EQ(0, AudioCodingModule::Codec("L16", &codec_, kSampleRateHz, 1));
     codec_.pltype = kPayloadType;
   }
 
   virtual void RegisterCodec() {
-    ASSERT_EQ(0, acm_->RegisterReceiveCodec(codec_));
-    ASSERT_EQ(0, acm_->RegisterSendCodec(codec_));
+    EXPECT_EQ(true, acm_->RegisterReceiveCodec(kPayloadType, *audio_format_));
+    EXPECT_EQ(0, acm_->RegisterSendCodec(codec_));
   }
 
   virtual void InsertPacketAndPullAudio() {
     InsertPacket();
     PullAudio();
   }
 
   virtual void InsertPacket() {
     const uint8_t kPayload[kPayloadSizeBytes] = {0};
     ASSERT_EQ(0,
@@ skipping 23 matching lines @@
     InsertAudio();
     VerifyEncoding();
   }
 
   const int id_;
   std::unique_ptr<RtpUtility> rtp_utility_;
   std::unique_ptr<AudioCodingModule> acm_;
   PacketizationCallbackStubOldApi packet_cb_;
   WebRtcRTPHeader rtp_header_;
   AudioFrame input_frame_;
+
+  // These two have to be kept in sync for now. In the future, we'll be able to
+  // eliminate the CodecInst and keep only the SdpAudioFormat.
+  rtc::Optional<SdpAudioFormat> audio_format_;
   CodecInst codec_;
+
   Clock* clock_;
 };
 
 // Check if the statistics are initialized correctly. Before any call to ACM
 // all fields have to be zero.
 #if defined(WEBRTC_ANDROID)
 #define MAYBE_InitializedToZero DISABLED_InitializedToZero
 #else
 #define MAYBE_InitializedToZero InitializedToZero
 #endif
@@ skipping 138 matching lines @@
 
 // Introduce this class to set different expectations on the number of encoded
 // bytes. This class expects all encoded packets to be 9 bytes (matching one
 // CNG SID frame) or 0 bytes. This test depends on |input_frame_| containing
 // (near-)zero values. It also introduces a way to register comfort noise with
 // a custom payload type.
 class AudioCodingModuleTestWithComfortNoiseOldApi
     : public AudioCodingModuleTestOldApi {
  protected:
   void RegisterCngCodec(int rtp_payload_type) {
+    EXPECT_EQ(true,
+              acm_->RegisterReceiveCodec(
+                  rtp_payload_type, SdpAudioFormat("cn", kSampleRateHz, 1)));
+
     CodecInst codec;
-    AudioCodingModule::Codec("CN", &codec, kSampleRateHz, 1);
+    EXPECT_EQ(0, AudioCodingModule::Codec("CN", &codec, kSampleRateHz, 1));
     codec.pltype = rtp_payload_type;
-    ASSERT_EQ(0, acm_->RegisterReceiveCodec(codec));
-    ASSERT_EQ(0, acm_->RegisterSendCodec(codec));
+    EXPECT_EQ(0, acm_->RegisterSendCodec(codec));
   }
 
   void VerifyEncoding() override {
     int last_length = packet_cb_.last_payload_len_bytes();
     EXPECT_TRUE(last_length == 9 || last_length == 0)
         << "Last encoded packet was " << last_length << " bytes.";
   }
 
   void DoTest(int blocks_per_packet, int cng_pt) {
     const int kLoops = 40;
@@ skipping 235 matching lines @@
     }
     // Set |last_packet_number_| to one less that |num_calls| so that the packet
     // will be fetched in the next InsertPacket() call.
     last_packet_number_ = packet_cb_.num_calls() - 1;
 
     StartThreads();
   }
 
   void RegisterCodec() override {
     static_assert(kSampleRateHz == 16000, "test designed for iSAC 16 kHz");
+    audio_format_ =
+        rtc::Optional<SdpAudioFormat>(SdpAudioFormat("isac", kSampleRateHz, 1));
     AudioCodingModule::Codec("ISAC", &codec_, kSampleRateHz, 1);
     codec_.pltype = kPayloadType;
 
     // Register iSAC codec in ACM, effectively unregistering the PCM16B codec
     // registered in AudioCodingModuleTestOldApi::SetUp();
-    ASSERT_EQ(0, acm_->RegisterReceiveCodec(codec_));
-    ASSERT_EQ(0, acm_->RegisterSendCodec(codec_));
+    EXPECT_EQ(true, acm_->RegisterReceiveCodec(kPayloadType, *audio_format_));
+    EXPECT_EQ(0, acm_->RegisterSendCodec(codec_));
   }
 
   void InsertPacket() override {
     int num_calls = packet_cb_.num_calls();  // Store locally for thread safety.
     if (num_calls > last_packet_number_) {
       // Get the new payload out from the callback handler.
       // Note that since we swap buffers here instead of directly inserting
       // a pointer to the data in |packet_cb_|, we avoid locking the callback
       // for the duration of the IncomingPacket() call.
       packet_cb_.SwapBuffers(&last_payload_vec_);
@@ skipping 236 matching lines @@
 
  protected:
   struct ExternalDecoder {
     int rtp_payload_type;
     AudioDecoder* external_decoder;
     int sample_rate_hz;
     int num_channels;
     std::string name;
   };
 
+  void Run(int output_freq_hz, const std::string& checksum_ref) {
+    Run(output_freq_hz, checksum_ref, CreateBuiltinAudioDecoderFactory(),
+        [](AudioCodingModule*) {});
+  }
+
   void Run(int output_freq_hz,
            const std::string& checksum_ref,
-           const std::vector<ExternalDecoder>& external_decoders) {
+           rtc::scoped_refptr<AudioDecoderFactory> decoder_factory,
+           rtc::FunctionView<void(AudioCodingModule*)> decoder_reg) {
     const std::string input_file_name =
         webrtc::test::ResourcePath("audio_coding/neteq_universal_new", "rtp");
     std::unique_ptr<test::RtpFileSource> packet_source(
         test::RtpFileSource::Create(input_file_name));
 #ifdef WEBRTC_ANDROID
     // Filter out iLBC and iSAC-swb since they are not supported on Android.
     packet_source->FilterOutPayloadType(102);  // iLBC.
     packet_source->FilterOutPayloadType(104);  // iSAC-swb.
 #endif
 
     test::AudioChecksum checksum;
     const std::string output_file_name =
         webrtc::test::OutputPath() +
         ::testing::UnitTest::GetInstance()
             ->current_test_info()
             ->test_case_name() +
         "_" + ::testing::UnitTest::GetInstance()->current_test_info()->name() +
         "_output.pcm";
     test::OutputAudioFile output_file(output_file_name);
     test::AudioSinkFork output(&checksum, &output_file);
 
     test::AcmReceiveTestOldApi test(
-        packet_source.get(),
-        &output,
-        output_freq_hz,
-        test::AcmReceiveTestOldApi::kArbitraryChannels);
+        packet_source.get(), &output, output_freq_hz,
+        test::AcmReceiveTestOldApi::kArbitraryChannels,
+        std::move(decoder_factory));
     ASSERT_NO_FATAL_FAILURE(test.RegisterNetEqTestCodecs());
-    for (const auto& ed : external_decoders) {
-      ASSERT_EQ(0, test.RegisterExternalReceiveCodec(
-                       ed.rtp_payload_type, ed.external_decoder,
-                       ed.sample_rate_hz, ed.num_channels, ed.name));
-    }
+    decoder_reg(test.get_acm());
     test.Run();
 
     std::string checksum_string = checksum.Finish();
     EXPECT_EQ(checksum_ref, checksum_string);
 
     // Delete the output file.
     remove(output_file_name.c_str());
   }
 };
 
 #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) && \
     defined(WEBRTC_CODEC_ILBC) && defined(WEBRTC_CODEC_G722)
 TEST_F(AcmReceiverBitExactnessOldApi, 8kHzOutput) {
   Run(8000, PlatformChecksum("dce4890259e9ded50f472455aa470a6f",
                              "1c4ada78b12612147f3026920f8dcc14",
                              "d804791edf2d00be2bc31c81a47368d4",
-                             "b2611f7323ab1209d5056399d0babbf5"),
-      std::vector<ExternalDecoder>());
+                             "b2611f7323ab1209d5056399d0babbf5"));
 }
 
 TEST_F(AcmReceiverBitExactnessOldApi, 16kHzOutput) {
   Run(16000, PlatformChecksum("27356bddffaa42b5c841b49aa3a070c5",
                               "5667d1872fc351244092ae995e5a5b32",
                               "53f5dc8088148479ca112c4c6d0e91cb",
-                              "4061a876d64d6cec5a38450acf4f245d"),
-      std::vector<ExternalDecoder>());
+                              "4061a876d64d6cec5a38450acf4f245d"));
 }
 
 TEST_F(AcmReceiverBitExactnessOldApi, 32kHzOutput) {
   Run(32000, PlatformChecksum("eb326547e83292305423b0a7ea57fea1",
                               "be7fc3140e6b5188c2e5fae0a394543b",
                               "eab9a0bff17320d6457d04f4c56563c6",
-                              "b60241ef0bac4a75f66eead04e71bb12"),
-      std::vector<ExternalDecoder>());
+                              "b60241ef0bac4a75f66eead04e71bb12"));
 }
 
 TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutput) {
   Run(48000, PlatformChecksum("7eb79ea39b68472a5b04cf9a56e49cda",
                               "f8cdd6e018688b2fff25c9b865bebdbb",
                               "2d18f0f06e7e2fc63b74d06e3c58067f",
-                              "81c3e4d24ebec23ca48f42fbaec4aba0"),
-      std::vector<ExternalDecoder>());
+                              "81c3e4d24ebec23ca48f42fbaec4aba0"));
 }
 
 TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutputExternalDecoder) {
-  // Class intended to forward a call from a mock DecodeInternal to Decode on
-  // the real decoder's Decode. DecodeInternal for the real decoder isn't
-  // public.
-  class DecodeForwarder {
+  class ADFactory : public AudioDecoderFactory {
    public:
-    DecodeForwarder(AudioDecoder* decoder) : decoder_(decoder) {}
-    int Decode(const uint8_t* encoded,
-               size_t encoded_len,
-               int sample_rate_hz,
-               int16_t* decoded,
-               AudioDecoder::SpeechType* speech_type) {
-      return decoder_->Decode(encoded, encoded_len, sample_rate_hz,
-                              decoder_->PacketDuration(encoded, encoded_len) *
-                                  decoder_->Channels() * sizeof(int16_t),
-                              decoded, speech_type);
+    ADFactory()
+        : mock_decoder_(new MockAudioDecoder()),
+          pcmu_decoder_(1),
+          decode_forwarder_(&pcmu_decoder_),
+          fact_(CreateBuiltinAudioDecoderFactory()) {
+      // Set expectations on the mock decoder and also delegate the calls to
+      // the real decoder.
+      EXPECT_CALL(*mock_decoder_, IncomingPacket(_, _, _, _, _))
+          .Times(AtLeast(1))
+          .WillRepeatedly(
+              Invoke(&pcmu_decoder_, &AudioDecoderPcmU::IncomingPacket));
+      EXPECT_CALL(*mock_decoder_, SampleRateHz())
+          .Times(AtLeast(1))
+          .WillRepeatedly(
+              Invoke(&pcmu_decoder_, &AudioDecoderPcmU::SampleRateHz));
+      EXPECT_CALL(*mock_decoder_, Channels())
+          .Times(AtLeast(1))
+          .WillRepeatedly(Invoke(&pcmu_decoder_, &AudioDecoderPcmU::Channels));
+      EXPECT_CALL(*mock_decoder_, DecodeInternal(_, _, _, _, _))
+          .Times(AtLeast(1))
+          .WillRepeatedly(Invoke(&decode_forwarder_, &DecodeForwarder::Decode));
+      EXPECT_CALL(*mock_decoder_, HasDecodePlc())
+          .Times(AtLeast(1))
+          .WillRepeatedly(
+              Invoke(&pcmu_decoder_, &AudioDecoderPcmU::HasDecodePlc));
+      EXPECT_CALL(*mock_decoder_, PacketDuration(_, _))
+          .Times(AtLeast(1))
+          .WillRepeatedly(
+              Invoke(&pcmu_decoder_, &AudioDecoderPcmU::PacketDuration));
+      EXPECT_CALL(*mock_decoder_, Die());
+    }
+    std::vector<AudioCodecSpec> GetSupportedDecoders() override {
+      return fact_->GetSupportedDecoders();
+    }
+    std::unique_ptr<AudioDecoder> MakeAudioDecoder(
+        const SdpAudioFormat& format) override {
+      return format.name == "MockPCMu" ? std::move(mock_decoder_)
+                                       : fact_->MakeAudioDecoder(format);
     }
 
    private:
-    AudioDecoder* const decoder_;
+    // Class intended to forward a call from a mock DecodeInternal to Decode on
+    // the real decoder's Decode. DecodeInternal for the real decoder isn't
+    // public.
+    class DecodeForwarder {
+     public:
+      DecodeForwarder(AudioDecoder* decoder) : decoder_(decoder) {}
+      int Decode(const uint8_t* encoded,
+                 size_t encoded_len,
+                 int sample_rate_hz,
+                 int16_t* decoded,
+                 AudioDecoder::SpeechType* speech_type) {
+        return decoder_->Decode(encoded, encoded_len, sample_rate_hz,
+                                decoder_->PacketDuration(encoded, encoded_len) *
+                                    decoder_->Channels() * sizeof(int16_t),
+                                decoded, speech_type);
+      }
+
+     private:
+      AudioDecoder* const decoder_;
+    };
+
+    std::unique_ptr<MockAudioDecoder> mock_decoder_;
+    AudioDecoderPcmU pcmu_decoder_;
+    DecodeForwarder decode_forwarder_;
+    rtc::scoped_refptr<AudioDecoderFactory> fact_;  // Fallback factory.
   };
 
-  AudioDecoderPcmU decoder(1);
-  DecodeForwarder decode_forwarder(&decoder);
-  MockAudioDecoder mock_decoder;
-  // Set expectations on the mock decoder and also delegate the calls to the
-  // real decoder.
-  EXPECT_CALL(mock_decoder, IncomingPacket(_, _, _, _, _))
-      .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&decoder, &AudioDecoderPcmU::IncomingPacket));
-  EXPECT_CALL(mock_decoder, SampleRateHz())
-      .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&decoder, &AudioDecoderPcmU::SampleRateHz));
-  EXPECT_CALL(mock_decoder, Channels())
-      .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&decoder, &AudioDecoderPcmU::Channels));
-  EXPECT_CALL(mock_decoder, DecodeInternal(_, _, _, _, _))
-      .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&decode_forwarder, &DecodeForwarder::Decode));
-  EXPECT_CALL(mock_decoder, HasDecodePlc())
-      .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&decoder, &AudioDecoderPcmU::HasDecodePlc));
-  EXPECT_CALL(mock_decoder, PacketDuration(_, _))
-      .Times(AtLeast(1))
-      .WillRepeatedly(Invoke(&decoder, &AudioDecoderPcmU::PacketDuration));
-  ExternalDecoder ed;
-  ed.rtp_payload_type = 0;
-  ed.external_decoder = &mock_decoder;
-  ed.sample_rate_hz = 8000;
-  ed.num_channels = 1;
-  ed.name = "MockPCMU";
-  std::vector<ExternalDecoder> external_decoders;
-  external_decoders.push_back(ed);
-
+  rtc::scoped_refptr<rtc::RefCountedObject<ADFactory>> factory(
+      new rtc::RefCountedObject<ADFactory>);
   Run(48000, PlatformChecksum("7eb79ea39b68472a5b04cf9a56e49cda",
                               "f8cdd6e018688b2fff25c9b865bebdbb",
                               "2d18f0f06e7e2fc63b74d06e3c58067f",
                               "81c3e4d24ebec23ca48f42fbaec4aba0"),
-      external_decoders);
-
-  EXPECT_CALL(mock_decoder, Die());
+      factory, [](AudioCodingModule* acm) {
+        acm->RegisterReceiveCodec(0, {"MockPCMu", 8000, 1});
+      });
 }
 #endif
 
 // This test verifies bit exactness for the send-side of ACM. The test setup is
 // a chain of three different test classes:
 //
 // test::AcmSendTest -> AcmSenderBitExactness -> test::AcmReceiveTest
 //
 // The receiver side is driving the test by requesting new packets from
 // AcmSenderBitExactness::NextPacket(). This method, in turn, asks for the
@@ skipping 67 matching lines @@
         webrtc::test::OutputPath() +
         ::testing::UnitTest::GetInstance()
             ->current_test_info()
             ->test_case_name() +
         "_" + ::testing::UnitTest::GetInstance()->current_test_info()->name() +
         "_output.pcm";
     test::OutputAudioFile output_file(output_file_name);
     // Have the output audio sent both to file and to the checksum calculator.
     test::AudioSinkFork output(&audio_checksum, &output_file);
     const int kOutputFreqHz = 8000;
-    test::AcmReceiveTestOldApi receive_test(
-        this, &output, kOutputFreqHz, expected_channels);
+    test::AcmReceiveTestOldApi receive_test(this, &output, kOutputFreqHz,
+                                            expected_channels,
+                                            CreateBuiltinAudioDecoderFactory());
     ASSERT_NO_FATAL_FAILURE(receive_test.RegisterDefaultCodecs());
 
     // This is where the actual test is executed.
     receive_test.Run();
 
     // Extract and verify the audio checksum.
     std::string checksum_string = audio_checksum.Finish();
     EXPECT_EQ(audio_checksum_ref, checksum_string);
 
     // Extract and verify the payload checksum.
@@ skipping 649 matching lines @@
   Run(16000, 8000, 1000);
 }
 
 TEST_F(AcmSwitchingOutputFrequencyOldApi, Toggle8KhzTo16Khz) {
   Run(8000, 16000, 1000);
 }
 
 #endif
 
 }  // namespace webrtc