blob: b1a5a51408b144444d82bf35f9482a6345ae564d [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_encoder_factory_template.h"
#include "absl/memory/memory.h"
#include "api/audio_codecs/L16/audio_encoder_L16.h"
#include "api/audio_codecs/g711/audio_encoder_g711.h"
#include "api/audio_codecs/g722/audio_encoder_g722.h"
#include "api/audio_codecs/ilbc/audio_encoder_ilbc.h"
#include "api/audio_codecs/isac/audio_encoder_isac_fix.h"
#include "api/audio_codecs/isac/audio_encoder_isac_float.h"
#include "api/audio_codecs/opus/audio_encoder_opus.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/mock_audio_encoder.h"
namespace webrtc {
namespace {
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 AudioEncoderFakeApi {
struct Config {
SdpAudioFormat audio_format;
};
static absl::optional<Config> SdpToConfig(
const SdpAudioFormat& audio_format) {
if (Params::AudioFormat() == audio_format) {
Config config = {audio_format};
return config;
} else {
return absl::nullopt;
}
}
static void AppendSupportedEncoders(std::vector<AudioCodecSpec>* specs) {
specs->push_back({Params::AudioFormat(), Params::CodecInfo()});
}
static AudioCodecInfo QueryAudioEncoder(const Config&) {
return Params::CodecInfo();
}
static std::unique_ptr<AudioEncoder> MakeAudioEncoder(
const Config&,
int payload_type,
absl::optional<AudioCodecPairId> /*codec_pair_id*/ = absl::nullopt) {
auto enc = absl::make_unique<testing::StrictMock<MockAudioEncoder>>();
EXPECT_CALL(*enc, SampleRateHz())
.WillOnce(::testing::Return(Params::CodecInfo().sample_rate_hz));
return std::move(enc);
}
};
} // namespace
TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) {
rtc::scoped_refptr<AudioEncoderFactory> factory(
new rtc::RefCountedObject<
audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedEncoders(), ::testing::IsEmpty());
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
}
TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
auto factory = CreateAudioEncoderFactory<AudioEncoderFakeApi<BogusParams>>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
factory->QueryAudioEncoder({"bogus", 8000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(8000, enc->SampleRateHz());
}
TEST(AudioEncoderFactoryTemplateTest, TwoEncoderTypes) {
auto factory = CreateAudioEncoderFactory<AudioEncoderFakeApi<BogusParams>,
AudioEncoderFakeApi<ShamParams>>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}},
AudioCodecSpec{{"sham", 16000, 2, {{"param", "value"}}},
{16000, 2, 23456}}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
factory->QueryAudioEncoder({"bogus", 8000, 1}));
EXPECT_EQ(
AudioCodecInfo(16000, 2, 23456),
factory->QueryAudioEncoder({"sham", 16000, 2, {{"param", "value"}}}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc1);
EXPECT_EQ(8000, enc1->SampleRateHz());
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"sham", 16000, 2}, absl::nullopt));
auto enc2 = factory->MakeAudioEncoder(
17, {"sham", 16000, 2, {{"param", "value"}}}, absl::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(16000, enc2->SampleRateHz());
}
TEST(AudioEncoderFactoryTemplateTest, G711) {
auto factory = CreateAudioEncoderFactory<AudioEncoderG711>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
AudioCodecSpec{{"PCMU", 8000, 1}, {8000, 1, 64000}},
AudioCodecSpec{{"PCMA", 8000, 1}, {8000, 1, 64000}}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"PCMA", 16000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 64000),
factory->QueryAudioEncoder({"PCMA", 8000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"PCMU", 16000, 1}, absl::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc1);
EXPECT_EQ(8000, enc1->SampleRateHz());
auto enc2 = factory->MakeAudioEncoder(17, {"PCMA", 8000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(8000, enc2->SampleRateHz());
}
TEST(AudioEncoderFactoryTemplateTest, G722) {
auto factory = CreateAudioEncoderFactory<AudioEncoderG722>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
AudioCodecSpec{{"G722", 8000, 1}, {16000, 1, 64000}}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(16000, 1, 64000),
factory->QueryAudioEncoder({"G722", 8000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(16000, enc->SampleRateHz());
}
TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
auto factory = CreateAudioEncoderFactory<AudioEncoderIlbc>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
AudioCodecSpec{{"ILBC", 8000, 1}, {8000, 1, 13333}}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 13333),
factory->QueryAudioEncoder({"ilbc", 8000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 8000, 1}, absl::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(8000, enc->SampleRateHz());
}
TEST(AudioEncoderFactoryTemplateTest, IsacFix) {
auto factory = CreateAudioEncoderFactory<AudioEncoderIsacFix>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(AudioCodecSpec{
{"ISAC", 16000, 1}, {16000, 1, 32000, 10000, 32000}}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"isac", 16000, 2}));
EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
factory->QueryAudioEncoder({"isac", 16000, 1}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"isac", 8000, 1}, absl::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc1);
EXPECT_EQ(16000, enc1->SampleRateHz());
EXPECT_EQ(3u, enc1->Num10MsFramesInNextPacket());
auto enc2 = factory->MakeAudioEncoder(
17, {"isac", 16000, 1, {{"ptime", "60"}}}, absl::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(6u, enc2->Num10MsFramesInNextPacket());
}
TEST(AudioEncoderFactoryTemplateTest, IsacFloat) {
auto factory = CreateAudioEncoderFactory<AudioEncoderIsacFloat>();
EXPECT_THAT(
factory->GetSupportedEncoders(),
::testing::ElementsAre(
AudioCodecSpec{{"ISAC", 16000, 1}, {16000, 1, 32000, 10000, 32000}},
AudioCodecSpec{{"ISAC", 32000, 1}, {32000, 1, 56000, 10000, 56000}}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"isac", 16000, 2}));
EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
factory->QueryAudioEncoder({"isac", 16000, 1}));
EXPECT_EQ(AudioCodecInfo(32000, 1, 56000, 10000, 56000),
factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"isac", 8000, 1}, absl::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc1);
EXPECT_EQ(16000, enc1->SampleRateHz());
auto enc2 = factory->MakeAudioEncoder(17, {"isac", 32000, 1}, absl::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(32000, enc2->SampleRateHz());
}
TEST(AudioEncoderFactoryTemplateTest, L16) {
auto factory = CreateAudioEncoderFactory<AudioEncoderL16>();
EXPECT_THAT(
factory->GetSupportedEncoders(),
::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_EQ(absl::nullopt, factory->QueryAudioEncoder({"L16", 8000, 0}));
EXPECT_EQ(AudioCodecInfo(48000, 1, 48000 * 16),
factory->QueryAudioEncoder({"L16", 48000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"L16", 8000, 0}, absl::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2}, absl::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(48000, enc->SampleRateHz());
}
TEST(AudioEncoderFactoryTemplateTest, Opus) {
auto factory = CreateAudioEncoderFactory<AudioEncoderOpus>();
AudioCodecInfo info = {48000, 1, 32000, 6000, 510000};
info.allow_comfort_noise = false;
info.supports_network_adaption = true;
EXPECT_THAT(
factory->GetSupportedEncoders(),
::testing::ElementsAre(AudioCodecSpec{
{"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}},
info}));
EXPECT_EQ(absl::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(
info,
factory->QueryAudioEncoder(
{"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, absl::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"opus", 48000, 2}, absl::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(48000, enc->SampleRateHz());
}
} // namespace webrtc