blob: 164c1493029f3571678886e9a20313b7db7f2f69 [file] [log] [blame]
/*
* Copyright (c) 2017 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 "api/audio_codecs/audio_decoder_factory_template.h"
#include <memory>
#include <optional>
#include <utility>
#include <vector>
#include "api/audio_codecs/L16/audio_decoder_L16.h"
#include "api/audio_codecs/audio_codec_pair_id.h"
#include "api/audio_codecs/audio_decoder.h"
#include "api/audio_codecs/audio_decoder_factory.h"
#include "api/audio_codecs/audio_format.h"
#include "api/audio_codecs/g711/audio_decoder_g711.h"
#include "api/audio_codecs/g722/audio_decoder_g722.h"
#include "api/audio_codecs/opus/audio_decoder_opus.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/make_ref_counted.h"
#include "api/scoped_refptr.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/mock_audio_decoder.h"
namespace webrtc {
namespace {
using ::testing::NiceMock;
using ::testing::NotNull;
using ::testing::Pointer;
using ::testing::Property;
using ::testing::Return;
struct BogusParams {
static SdpAudioFormat AudioFormat() { return {"bogus", 8000, 1}; }
static AudioCodecInfo CodecInfo() { return {8000, 1, 12345}; }
};
struct ShamParams {
static SdpAudioFormat AudioFormat() {
return {"sham", 16000, 2, {{"param", "value"}}};
}
static AudioCodecInfo CodecInfo() { return {16000, 2, 23456}; }
};
template <typename Params>
struct AudioDecoderFakeApi {
struct Config {
SdpAudioFormat audio_format;
};
static std::optional<Config> SdpToConfig(const SdpAudioFormat& audio_format) {
if (Params::AudioFormat() == audio_format) {
Config config = {audio_format};
return config;
} else {
return std::nullopt;
}
}
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs) {
specs->push_back({Params::AudioFormat(), Params::CodecInfo()});
}
static AudioCodecInfo QueryAudioDecoder(const Config&) {
return Params::CodecInfo();
}
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const Config&,
std::optional<AudioCodecPairId> /*codec_pair_id*/ = std::nullopt) {
auto dec = std::make_unique<testing::StrictMock<MockAudioDecoder>>();
EXPECT_CALL(*dec, SampleRateHz())
.WillOnce(::testing::Return(Params::CodecInfo().sample_rate_hz));
EXPECT_CALL(*dec, Die());
return std::move(dec);
}
};
// Trait to pass as template parameter to `CreateAudioDecoderFactory` with
// all the functions except the functions to create the audio decoder.
struct BaseAudioDecoderApi {
struct Config {};
static SdpAudioFormat AudioFormat() { return {"fake", 16'000, 2, {}}; }
static std::optional<Config> SdpToConfig(const SdpAudioFormat& audio_format) {
return Config();
}
static void AppendSupportedDecoders(std::vector<AudioCodecSpec>* specs) {
specs->push_back({.format = AudioFormat(), .info = {16'000, 2, 23456}});
}
};
struct TraitWithTwoMakeAudioDecoders : BaseAudioDecoderApi {
// Create Decoders with different sample rates depending if it is created
// through one or another `MAkeAudioDecoder` so that a test may detect which
// method was used.
static constexpr int kRateWithoutEnv = 10'000;
static constexpr int kRateWithEnv = 20'000;
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const Config& config,
std::optional<AudioCodecPairId> codec_pair_id) {
auto decoder = std::make_unique<NiceMock<MockAudioDecoder>>();
ON_CALL(*decoder, SampleRateHz).WillByDefault(Return(kRateWithoutEnv));
return decoder;
}
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const Environment& env,
const Config& config,
std::optional<AudioCodecPairId> codec_pair_id) {
auto decoder = std::make_unique<NiceMock<MockAudioDecoder>>();
ON_CALL(*decoder, SampleRateHz).WillByDefault(Return(kRateWithEnv));
return decoder;
}
};
TEST(AudioDecoderFactoryTemplateTest,
PrefersToPassEnvironmentToMakeAudioDecoder) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<TraitWithTwoMakeAudioDecoders>();
EXPECT_THAT(factory->Create(env, BaseAudioDecoderApi::AudioFormat(), {}),
Pointer(Property(&AudioDecoder::SampleRateHz,
TraitWithTwoMakeAudioDecoders::kRateWithEnv)));
}
struct AudioDecoderApiWithV1Make : BaseAudioDecoderApi {
static std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const Config& config,
std::optional<AudioCodecPairId> codec_pair_id) {
return std::make_unique<NiceMock<MockAudioDecoder>>();
}
};
TEST(AudioDecoderFactoryTemplateTest,
CanUseMakeAudioDecoderWithoutPassingEnvironment) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<AudioDecoderApiWithV1Make>();
EXPECT_THAT(factory->Create(env, BaseAudioDecoderApi::AudioFormat(), {}),
NotNull());
}
TEST(AudioDecoderFactoryTemplateTest, NoDecoderTypes) {
const Environment env = CreateEnvironment();
rtc::scoped_refptr<AudioDecoderFactory> factory(
rtc::make_ref_counted<
audio_decoder_factory_template_impl::AudioDecoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedDecoders(), ::testing::IsEmpty());
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_EQ(nullptr, factory->Create(env, {"bar", 16000, 1}, std::nullopt));
}
TEST(AudioDecoderFactoryTemplateTest, OneDecoderType) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<AudioDecoderFakeApi<BogusParams>>();
EXPECT_THAT(factory->GetSupportedDecoders(),
::testing::ElementsAre(
AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"bogus", 8000, 1}));
EXPECT_EQ(nullptr, factory->Create(env, {"bar", 16000, 1}, std::nullopt));
auto dec = factory->Create(env, {"bogus", 8000, 1}, std::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(8000, dec->SampleRateHz());
}
TEST(AudioDecoderFactoryTemplateTest, TwoDecoderTypes) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<AudioDecoderFakeApi<BogusParams>,
AudioDecoderFakeApi<ShamParams>>();
EXPECT_THAT(factory->GetSupportedDecoders(),
::testing::ElementsAre(
AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}},
AudioCodecSpec{{"sham", 16000, 2, {{"param", "value"}}},
{16000, 2, 23456}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"bogus", 8000, 1}));
EXPECT_TRUE(
factory->IsSupportedDecoder({"sham", 16000, 2, {{"param", "value"}}}));
EXPECT_EQ(nullptr, factory->Create(env, {"bar", 16000, 1}, std::nullopt));
auto dec1 = factory->Create(env, {"bogus", 8000, 1}, std::nullopt);
ASSERT_NE(nullptr, dec1);
EXPECT_EQ(8000, dec1->SampleRateHz());
EXPECT_EQ(nullptr, factory->Create(env, {"sham", 16000, 2}, std::nullopt));
auto dec2 = factory->Create(env, {"sham", 16000, 2, {{"param", "value"}}},
std::nullopt);
ASSERT_NE(nullptr, dec2);
EXPECT_EQ(16000, dec2->SampleRateHz());
}
TEST(AudioDecoderFactoryTemplateTest, G711) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<AudioDecoderG711>();
EXPECT_THAT(factory->GetSupportedDecoders(),
::testing::ElementsAre(
AudioCodecSpec{{"PCMU", 8000, 1}, {8000, 1, 64000}},
AudioCodecSpec{{"PCMA", 8000, 1}, {8000, 1, 64000}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"G711", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"PCMU", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"pcma", 8000, 1}));
EXPECT_EQ(nullptr, factory->Create(env, {"pcmu", 16000, 1}, std::nullopt));
auto dec1 = factory->Create(env, {"pcmu", 8000, 1}, std::nullopt);
ASSERT_NE(nullptr, dec1);
EXPECT_EQ(8000, dec1->SampleRateHz());
auto dec2 = factory->Create(env, {"PCMA", 8000, 1}, std::nullopt);
ASSERT_NE(nullptr, dec2);
EXPECT_EQ(8000, dec2->SampleRateHz());
}
TEST(AudioDecoderFactoryTemplateTest, G722) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<AudioDecoderG722>();
EXPECT_THAT(factory->GetSupportedDecoders(),
::testing::ElementsAre(
AudioCodecSpec{{"G722", 8000, 1}, {16000, 1, 64000}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"G722", 8000, 1}));
EXPECT_EQ(nullptr, factory->Create(env, {"bar", 16000, 1}, std::nullopt));
auto dec1 = factory->Create(env, {"G722", 8000, 1}, std::nullopt);
ASSERT_NE(nullptr, dec1);
EXPECT_EQ(16000, dec1->SampleRateHz());
EXPECT_EQ(1u, dec1->Channels());
auto dec2 = factory->Create(env, {"G722", 8000, 2}, std::nullopt);
ASSERT_NE(nullptr, dec2);
EXPECT_EQ(16000, dec2->SampleRateHz());
EXPECT_EQ(2u, dec2->Channels());
auto dec3 = factory->Create(env, {"G722", 8000, 3}, std::nullopt);
ASSERT_EQ(nullptr, dec3);
}
TEST(AudioDecoderFactoryTemplateTest, L16) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<AudioDecoderL16>();
EXPECT_THAT(
factory->GetSupportedDecoders(),
::testing::ElementsAre(
AudioCodecSpec{{"L16", 8000, 1}, {8000, 1, 8000 * 16}},
AudioCodecSpec{{"L16", 16000, 1}, {16000, 1, 16000 * 16}},
AudioCodecSpec{{"L16", 32000, 1}, {32000, 1, 32000 * 16}},
AudioCodecSpec{{"L16", 8000, 2}, {8000, 2, 8000 * 16 * 2}},
AudioCodecSpec{{"L16", 16000, 2}, {16000, 2, 16000 * 16 * 2}},
AudioCodecSpec{{"L16", 32000, 2}, {32000, 2, 32000 * 16 * 2}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"L16", 48000, 1}));
EXPECT_FALSE(factory->IsSupportedDecoder({"L16", 96000, 1}));
EXPECT_EQ(nullptr, factory->Create(env, {"L16", 8000, 0}, std::nullopt));
auto dec = factory->Create(env, {"L16", 48000, 2}, std::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(48000, dec->SampleRateHz());
}
TEST(AudioDecoderFactoryTemplateTest, Opus) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioDecoderFactory<AudioDecoderOpus>();
AudioCodecInfo opus_info{48000, 1, 64000, 6000, 510000};
opus_info.allow_comfort_noise = false;
opus_info.supports_network_adaption = true;
const SdpAudioFormat opus_format(
{"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}});
EXPECT_THAT(factory->GetSupportedDecoders(),
::testing::ElementsAre(AudioCodecSpec{opus_format, opus_info}));
EXPECT_FALSE(factory->IsSupportedDecoder({"opus", 48000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"opus", 48000, 2}));
EXPECT_EQ(nullptr, factory->Create(env, {"bar", 16000, 1}, std::nullopt));
auto dec = factory->Create(env, {"opus", 48000, 2}, std::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(48000, dec->SampleRateHz());
}
} // namespace
} // namespace webrtc