admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Tests: Pass codec ID argument to audio codecs

Browse Source 
Bug: webrtc:8941
Change-Id: Ia6d51dcbf7d69b38f3615e01d3f7031b8f5c31d0
Reviewed-on: https://webrtc-review.googlesource.com/58092
Commit-Queue: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22383}
This commit is contained in:
Karl Wiberg 2018-02-27 13:37:31 +01:00 committed by Commit Bot
parent 6fed924857
commit d6fbf2a4b1
11 changed files with 179 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
api/audio_codecs/test/audio_decoder_factory_template_unittest.cc
View File

@ -79,7 +79,8 @@ TEST(AudioDecoderFactoryTemplateTest, NoDecoderTypes) {
audio_decoder_factory_template_impl::AudioDecoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedDecoders(), testing::IsEmpty());
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 16000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
}
TEST(AudioDecoderFactoryTemplateTest, OneDecoderType) {
@ -89,8 +90,9 @@ TEST(AudioDecoderFactoryTemplateTest, OneDecoderType) {
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->MakeAudioDecoder({"bar", 16000, 1}));
auto dec = factory->MakeAudioDecoder({"bogus", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(8000, dec->SampleRateHz());
}
@ -107,13 +109,15 @@ TEST(AudioDecoderFactoryTemplateTest, TwoDecoderTypes) {
EXPECT_TRUE(factory->IsSupportedDecoder({"bogus", 8000, 1}));
EXPECT_TRUE(
factory->IsSupportedDecoder({"sham", 16000, 2, {{"param", "value"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 16000, 1}));
auto dec1 = factory->MakeAudioDecoder({"bogus", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1);
EXPECT_EQ(8000, dec1->SampleRateHz());
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"sham", 16000, 2}));
auto dec2 =
factory->MakeAudioDecoder({"sham", 16000, 2, {{"param", "value"}}});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"sham", 16000, 2}, rtc::nullopt));
auto dec2 = factory->MakeAudioDecoder(
{"sham", 16000, 2, {{"param", "value"}}}, rtc::nullopt);
ASSERT_NE(nullptr, dec2);
EXPECT_EQ(16000, dec2->SampleRateHz());
}
@ -127,11 +131,12 @@ TEST(AudioDecoderFactoryTemplateTest, G711) {
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->MakeAudioDecoder({"pcmu", 16000, 1}));
auto dec1 = factory->MakeAudioDecoder({"pcmu", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"pcmu", 16000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"pcmu", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1);
EXPECT_EQ(8000, dec1->SampleRateHz());
auto dec2 = factory->MakeAudioDecoder({"PCMA", 8000, 1});
auto dec2 = factory->MakeAudioDecoder({"PCMA", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec2);
EXPECT_EQ(8000, dec2->SampleRateHz());
}
@ -143,16 +148,17 @@ TEST(AudioDecoderFactoryTemplateTest, G722) {
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->MakeAudioDecoder({"bar", 16000, 1}));
auto dec1 = factory->MakeAudioDecoder({"G722", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"G722", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1);
EXPECT_EQ(16000, dec1->SampleRateHz());
EXPECT_EQ(1u, dec1->Channels());
auto dec2 = factory->MakeAudioDecoder({"G722", 8000, 2});
auto dec2 = factory->MakeAudioDecoder({"G722", 8000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, dec2);
EXPECT_EQ(16000, dec2->SampleRateHz());
EXPECT_EQ(2u, dec2->Channels());
auto dec3 = factory->MakeAudioDecoder({"G722", 8000, 3});
auto dec3 = factory->MakeAudioDecoder({"G722", 8000, 3}, rtc::nullopt);
ASSERT_EQ(nullptr, dec3);
}
@ -163,8 +169,8 @@ TEST(AudioDecoderFactoryTemplateTest, Ilbc) {
AudioCodecSpec{{"ILBC", 8000, 1}, {8000, 1, 13300}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"ilbc", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 8000, 1}));
auto dec = factory->MakeAudioDecoder({"ilbc", 8000, 1});
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 8000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"ilbc", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(8000, dec->SampleRateHz());
}
@ -177,8 +183,9 @@ TEST(AudioDecoderFactoryTemplateTest, IsacFix) {
EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 16000, 2}));
EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 16000, 1}));
EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"isac", 8000, 1}));
auto dec = factory->MakeAudioDecoder({"isac", 16000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"isac", 8000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"isac", 16000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(16000, dec->SampleRateHz());
}
@ -193,11 +200,12 @@ TEST(AudioDecoderFactoryTemplateTest, IsacFloat) {
EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 16000, 2}));
EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 16000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"isac", 8000, 1}));
auto dec1 = factory->MakeAudioDecoder({"isac", 16000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"isac", 8000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"isac", 16000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1);
EXPECT_EQ(16000, dec1->SampleRateHz());
auto dec2 = factory->MakeAudioDecoder({"isac", 32000, 1});
auto dec2 = factory->MakeAudioDecoder({"isac", 32000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec2);
EXPECT_EQ(32000, dec2->SampleRateHz());
}
@ -216,8 +224,8 @@ TEST(AudioDecoderFactoryTemplateTest, L16) {
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->MakeAudioDecoder({"L16", 8000, 0}));
auto dec = factory->MakeAudioDecoder({"L16", 48000, 2});
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"L16", 8000, 0}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"L16", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(48000, dec->SampleRateHz());
}
@ -233,8 +241,9 @@ TEST(AudioDecoderFactoryTemplateTest, Opus) {
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->MakeAudioDecoder({"bar", 16000, 1}));
auto dec = factory->MakeAudioDecoder({"opus", 48000, 2});
EXPECT_EQ(nullptr,
factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"opus", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, dec);
EXPECT_EQ(48000, dec->SampleRateHz());
}

63
api/audio_codecs/test/audio_encoder_factory_template_unittest.cc
View File

@ -79,7 +79,8 @@ TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) {
audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedEncoders(), testing::IsEmpty());
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
}
TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
@ -90,8 +91,9 @@ TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
EXPECT_EQ(rtc::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}));
auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(8000, enc->SampleRateHz());
}
@ -110,13 +112,15 @@ TEST(AudioEncoderFactoryTemplateTest, TwoEncoderTypes) {
EXPECT_EQ(
AudioCodecInfo(16000, 2, 23456),
factory->QueryAudioEncoder({"sham", 16000, 2, {{"param", "value"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc1);
EXPECT_EQ(8000, enc1->SampleRateHz());
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"sham", 16000, 2}));
auto enc2 =
factory->MakeAudioEncoder(17, {"sham", 16000, 2, {{"param", "value"}}});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"sham", 16000, 2}, rtc::nullopt));
auto enc2 = factory->MakeAudioEncoder(
17, {"sham", 16000, 2, {{"param", "value"}}}, rtc::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(16000, enc2->SampleRateHz());
}
@ -130,11 +134,12 @@ TEST(AudioEncoderFactoryTemplateTest, G711) {
EXPECT_EQ(rtc::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}));
auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"PCMU", 16000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc1);
EXPECT_EQ(8000, enc1->SampleRateHz());
auto enc2 = factory->MakeAudioEncoder(17, {"PCMA", 8000, 1});
auto enc2 = factory->MakeAudioEncoder(17, {"PCMA", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(8000, enc2->SampleRateHz());
}
@ -147,8 +152,9 @@ TEST(AudioEncoderFactoryTemplateTest, G722) {
EXPECT_EQ(rtc::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}));
auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(16000, enc->SampleRateHz());
}
@ -161,8 +167,9 @@ TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
EXPECT_EQ(rtc::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}));
auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 8000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(8000, enc->SampleRateHz());
}
@ -176,13 +183,14 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFix) {
EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
factory->QueryAudioEncoder({"isac", 16000, 1}));
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"isac", 8000, 1}));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"isac", 8000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}, rtc::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"}}});
auto enc2 = factory->MakeAudioEncoder(
17, {"isac", 16000, 1, {{"ptime", "60"}}}, rtc::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(6u, enc2->Num10MsFramesInNextPacket());
}
@ -199,11 +207,12 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFloat) {
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}));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"isac", 8000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc1);
EXPECT_EQ(16000, enc1->SampleRateHz());
auto enc2 = factory->MakeAudioEncoder(17, {"isac", 32000, 1});
auto enc2 = factory->MakeAudioEncoder(17, {"isac", 32000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc2);
EXPECT_EQ(32000, enc2->SampleRateHz());
}
@ -222,8 +231,9 @@ TEST(AudioEncoderFactoryTemplateTest, L16) {
EXPECT_EQ(rtc::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}));
auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"L16", 8000, 0}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(48000, enc->SampleRateHz());
}
@ -243,8 +253,9 @@ TEST(AudioEncoderFactoryTemplateTest, Opus) {
info,
factory->QueryAudioEncoder(
{"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1}));
auto enc = factory->MakeAudioEncoder(17, {"opus", 48000, 2});
EXPECT_EQ(nullptr,
factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"opus", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, enc);
EXPECT_EQ(48000, enc->SampleRateHz());
}

6
audio/audio_send_stream_unittest.cc
View File

@ -116,8 +116,9 @@ rtc::scoped_refptr<MockAudioEncoderFactory> SetupEncoderFactoryMock() {
}
return rtc::nullopt;
}));
ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _))
ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _))
.WillByDefault(Invoke([](int payload_type, const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>* return_value) {
*return_value = SetupAudioEncoderMock(payload_type, format);
}));
@ -422,9 +423,10 @@ TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) {
helper.config().audio_network_adaptor_config = kAnaConfigString;
EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _))
EXPECT_CALL(helper.mock_encoder_factory(), MakeAudioEncoderMock(_, _, _, _))
.WillOnce(Invoke([&kAnaConfigString, &kAnaReconfigString](
int payload_type, const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>* return_value) {
auto mock_encoder = SetupAudioEncoderMock(payload_type, format);
EXPECT_CALL(*mock_encoder,

8
modules/audio_coding/acm2/audio_coding_module_unittest.cc
View File

@ -1053,9 +1053,11 @@ TEST_F(AcmReceiverBitExactnessOldApi, 48kHzOutputExternalDecoder) {
: fact_->IsSupportedDecoder(format);
}
std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const SdpAudioFormat& format) override {
return format.name == "MockPCMu" ? std::move(mock_decoder_)
: fact_->MakeAudioDecoder(format);
const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id) override {
return format.name == "MockPCMu"
? std::move(mock_decoder_)
: fact_->MakeAudioDecoder(format, codec_pair_id);
}
private:

99
modules/audio_coding/codecs/builtin_audio_decoder_factory_unittest.cc
View File

@ -19,7 +19,8 @@ TEST(AudioDecoderFactoryTest, CreateUnknownDecoder) {
rtc::scoped_refptr<AudioDecoderFactory> adf =
CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf);
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("rey", 8000, 1)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("rey", 8000, 1), rtc::nullopt));
}
TEST(AudioDecoderFactoryTest, CreatePcmu) {
@ -27,11 +28,16 @@ TEST(AudioDecoderFactoryTest, CreatePcmu) {
CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf);
// PCMu supports 8 kHz, and any number of channels.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 0)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 1)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 2)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 3)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 16000, 1)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 0), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 1), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 2), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 3), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 16000, 1), rtc::nullopt));
}
TEST(AudioDecoderFactoryTest, CreatePcma) {
@ -39,11 +45,16 @@ TEST(AudioDecoderFactoryTest, CreatePcma) {
CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf);
// PCMa supports 8 kHz, and any number of channels.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 0)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 1)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 2)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 3)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 16000, 1)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 0), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 1), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 2), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 3), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("pcma", 16000, 1), rtc::nullopt));
}
TEST(AudioDecoderFactoryTest, CreateIlbc) {
@ -51,12 +62,16 @@ TEST(AudioDecoderFactoryTest, CreateIlbc) {
CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf);
// iLBC supports 8 kHz, 1 channel.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 0)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 0), rtc::nullopt));
#ifdef WEBRTC_CODEC_ILBC
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 1)));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 1), rtc::nullopt));
#endif
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 2)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 16000, 1)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 2), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 16000, 1), rtc::nullopt));
}
TEST(AudioDecoderFactoryTest, CreateIsac) {
@ -65,15 +80,22 @@ TEST(AudioDecoderFactoryTest, CreateIsac) {
ASSERT_TRUE(adf);
// iSAC supports 16 kHz, 1 channel. The float implementation additionally
// supports 32 kHz, 1 channel.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 0)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 1)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 2)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 8000, 1)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 48000, 1)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 0), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 1), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 2), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 8000, 1), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 48000, 1), rtc::nullopt));
#ifdef WEBRTC_ARCH_ARM
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1), rtc::nullopt));
#else
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1)));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1), rtc::nullopt));
#endif
}
@ -85,10 +107,11 @@ TEST(AudioDecoderFactoryTest, CreateL16) {
const int clockrates[] = {8000, 16000, 32000, 48000};
const int num_channels[] = {1, 2, 3, 4711};
for (int clockrate : clockrates) {
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("l16", clockrate, 0)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("l16", clockrate, 0),
rtc::nullopt));
for (int channels : num_channels) {
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("l16", clockrate, channels)));
EXPECT_TRUE(adf->MakeAudioDecoder(
SdpAudioFormat("l16", clockrate, channels), rtc::nullopt));
}
}
}
@ -98,16 +121,22 @@ TEST(AudioDecoderFactoryTest, CreateG722) {
CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf);
// g722 supports 8 kHz, 1-2 channels.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 0)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1)));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 2)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 3)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 16000, 1)));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 32000, 1)));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 0), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1), rtc::nullopt));
EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 2), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 3), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("g722", 16000, 1), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("g722", 32000, 1), rtc::nullopt));
// g722 actually uses a 16 kHz sample rate instead of the nominal 8 kHz.
std::unique_ptr<AudioDecoder> dec =
adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1));
adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1), rtc::nullopt);
EXPECT_EQ(16000, dec->SampleRateHz());
}
@ -126,8 +155,10 @@ TEST(AudioDecoderFactoryTest, CreateOpus) {
}
const bool good = (hz == 48000 && channels == 2 &&
(stereo == "XX" || stereo == "0" || stereo == "1"));
EXPECT_EQ(good, static_cast<bool>(adf->MakeAudioDecoder(SdpAudioFormat(
"opus", hz, channels, std::move(params)))));
EXPECT_EQ(good,
static_cast<bool>(adf->MakeAudioDecoder(
SdpAudioFormat("opus", hz, channels, std::move(params)),
rtc::nullopt)));
}
}
}

5
modules/audio_coding/codecs/builtin_audio_encoder_factory_unittest.cc
View File

@ -43,7 +43,7 @@ TEST_P(AudioEncoderFactoryTest, CanConstructAllSupportedEncoders) {
auto supported_encoders = factory->GetSupportedEncoders();
for (const auto& spec : supported_encoders) {
auto info = factory->QueryAudioEncoder(spec.format);
auto encoder = factory->MakeAudioEncoder(127, spec.format);
auto encoder = factory->MakeAudioEncoder(127, spec.format, rtc::nullopt);
EXPECT_TRUE(encoder);
EXPECT_EQ(encoder->SampleRateHz(), info->sample_rate_hz);
EXPECT_EQ(encoder->NumChannels(), info->num_channels);
@ -56,7 +56,8 @@ TEST_P(AudioEncoderFactoryTest, CanRunAllSupportedEncoders) {
auto factory = GetParam();
auto supported_encoders = factory->GetSupportedEncoders();
for (const auto& spec : supported_encoders) {
auto encoder = factory->MakeAudioEncoder(kTestPayloadType, spec.format);
auto encoder =
factory->MakeAudioEncoder(kTestPayloadType, spec.format, rtc::nullopt);
EXPECT_TRUE(encoder);
encoder->Reset();
const int num_samples = rtc::checked_cast<int>(

3
modules/audio_coding/neteq/decoder_database_unittest.cc
View File

@ -89,8 +89,9 @@ TEST(DecoderDatabase, GetDecoderInfo) {
return true;
}));
auto* decoder = new MockAudioDecoder;
EXPECT_CALL(*factory, MakeAudioDecoderMock(_, _))
EXPECT_CALL(*factory, MakeAudioDecoderMock(_, _, _))
.WillOnce(Invoke([decoder](const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>* dec) {
EXPECT_EQ("pcmu", format.name);
dec->reset(decoder);

3
modules/audio_coding/neteq/neteq_impl_unittest.cc
View File

@ -313,8 +313,9 @@ TEST_F(NetEqImplTest, InsertPacket) {
rtc::scoped_refptr<MockAudioDecoderFactory> mock_decoder_factory(
new rtc::RefCountedObject<MockAudioDecoderFactory>);
EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _))
EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _, _))
.WillOnce(Invoke([&](const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>* dec) {
EXPECT_EQ("pcmu", format.name);

6
pc/peerconnectionendtoend_unittest.cc
View File

@ -261,13 +261,15 @@ CreateForwardingMockDecoderFactory(
Invoke([real_decoder_factory](const webrtc::SdpAudioFormat& format) {
return real_decoder_factory->IsSupportedDecoder(format);
}));
EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _))
EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _, _))
.Times(AtLeast(2))
.WillRepeatedly(
Invoke([real_decoder_factory](
const webrtc::SdpAudioFormat& format,
rtc::Optional<webrtc::AudioCodecPairId> codec_pair_id,
std::unique_ptr<webrtc::AudioDecoder>* return_value) {
auto real_decoder = real_decoder_factory->MakeAudioDecoder(format);
auto real_decoder =
real_decoder_factory->MakeAudioDecoder(format, codec_pair_id);
*return_value =
real_decoder
? CreateForwardingMockDecoder(std::move(real_decoder))

18
test/mock_audio_decoder_factory.h
View File

@ -26,13 +26,16 @@ class MockAudioDecoderFactory : public AudioDecoderFactory {
public:
MOCK_METHOD0(GetSupportedDecoders, std::vector<AudioCodecSpec>());
MOCK_METHOD1(IsSupportedDecoder, bool(const SdpAudioFormat&));
std::unique_ptr<AudioDecoder> MakeAudioDecoder(const SdpAudioFormat& format) {
std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id) {
std::unique_ptr<AudioDecoder> return_value;
MakeAudioDecoderMock(format, &return_value);
MakeAudioDecoderMock(format, codec_pair_id, &return_value);
return return_value;
}
MOCK_METHOD2(MakeAudioDecoderMock,
MOCK_METHOD3(MakeAudioDecoderMock,
void(const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>* return_value));
// Creates a MockAudioDecoderFactory with no formats and that may not be
@ -51,7 +54,7 @@ class MockAudioDecoderFactory : public AudioDecoderFactory {
EXPECT_CALL(*factory.get(), GetSupportedDecoders()).Times(AnyNumber());
ON_CALL(*factory, IsSupportedDecoder(_)).WillByDefault(Return(false));
EXPECT_CALL(*factory, IsSupportedDecoder(_)).Times(AnyNumber());
EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _)).Times(0);
EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _, _)).Times(0);
return factory;
}
@ -72,9 +75,10 @@ class MockAudioDecoderFactory : public AudioDecoderFactory {
EXPECT_CALL(*factory.get(), GetSupportedDecoders()).Times(AnyNumber());
ON_CALL(*factory, IsSupportedDecoder(_)).WillByDefault(Return(false));
EXPECT_CALL(*factory, IsSupportedDecoder(_)).Times(AnyNumber());
ON_CALL(*factory.get(), MakeAudioDecoderMock(_, _))
.WillByDefault(SetArgPointee<1>(nullptr));
EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _)).Times(AnyNumber());
ON_CALL(*factory.get(), MakeAudioDecoderMock(_, _, _))
.WillByDefault(SetArgPointee<2>(nullptr));
EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _, _))
.Times(AnyNumber());
return factory;
}
};

19
test/mock_audio_encoder_factory.h
View File

@ -27,15 +27,18 @@ class MockAudioEncoderFactory : public testing::NiceMock<AudioEncoderFactory> {
MOCK_METHOD1(QueryAudioEncoder,
rtc::Optional<AudioCodecInfo>(const SdpAudioFormat& format));
std::unique_ptr<AudioEncoder> MakeAudioEncoder(int payload_type,
const SdpAudioFormat& format) {
std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type,
const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id) {
std::unique_ptr<AudioEncoder> return_value;
MakeAudioEncoderMock(payload_type, format, &return_value);
MakeAudioEncoderMock(payload_type, format, codec_pair_id, &return_value);
return return_value;
}
MOCK_METHOD3(MakeAudioEncoderMock,
MOCK_METHOD4(MakeAudioEncoderMock,
void(int payload_type,
const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>* return_value));
// Creates a MockAudioEncoderFactory with no formats and that may not be
@ -56,7 +59,7 @@ class MockAudioEncoderFactory : public testing::NiceMock<AudioEncoderFactory> {
EXPECT_CALL(*factory.get(), GetSupportedEncoders()).Times(AnyNumber());
EXPECT_CALL(*factory.get(), QueryAudioEncoder(_)).Times(AnyNumber());
EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _)).Times(0);
EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _)).Times(0);
return factory;
}
@ -76,12 +79,12 @@ class MockAudioEncoderFactory : public testing::NiceMock<AudioEncoderFactory> {
.WillByDefault(Return(std::vector<webrtc::AudioCodecSpec>()));
ON_CALL(*factory.get(), QueryAudioEncoder(_))
.WillByDefault(Return(rtc::nullopt));
ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _))
.WillByDefault(SetArgPointee<2>(nullptr));
ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _))
.WillByDefault(SetArgPointee<3>(nullptr));
EXPECT_CALL(*factory.get(), GetSupportedEncoders()).Times(AnyNumber());
EXPECT_CALL(*factory.get(), QueryAudioEncoder(_)).Times(AnyNumber());
EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _))
EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _))
.Times(AnyNumber());
return factory;
}