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<>>()); audio_decoder_factory_template_impl::AudioDecoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedDecoders(), testing::IsEmpty()); EXPECT_THAT(factory->GetSupportedDecoders(), testing::IsEmpty());
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1})); 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) { TEST(AudioDecoderFactoryTemplateTest, OneDecoderType) {
@ -89,8 +90,9 @@ TEST(AudioDecoderFactoryTemplateTest, OneDecoderType) {
AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}})); AudioCodecSpec{{"bogus", 8000, 1}, {8000, 1, 12345}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"bogus", 8000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"bogus", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto dec = factory->MakeAudioDecoder({"bogus", 8000, 1}); factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec); ASSERT_NE(nullptr, dec);
EXPECT_EQ(8000, dec->SampleRateHz()); EXPECT_EQ(8000, dec->SampleRateHz());
} }
@ -107,13 +109,15 @@ TEST(AudioDecoderFactoryTemplateTest, TwoDecoderTypes) {
EXPECT_TRUE(factory->IsSupportedDecoder({"bogus", 8000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"bogus", 8000, 1}));
EXPECT_TRUE( EXPECT_TRUE(
factory->IsSupportedDecoder({"sham", 16000, 2, {{"param", "value"}}})); factory->IsSupportedDecoder({"sham", 16000, 2, {{"param", "value"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto dec1 = factory->MakeAudioDecoder({"bogus", 8000, 1}); factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1); ASSERT_NE(nullptr, dec1);
EXPECT_EQ(8000, dec1->SampleRateHz()); EXPECT_EQ(8000, dec1->SampleRateHz());
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"sham", 16000, 2})); EXPECT_EQ(nullptr,
auto dec2 = factory->MakeAudioDecoder({"sham", 16000, 2}, rtc::nullopt));
factory->MakeAudioDecoder({"sham", 16000, 2, {{"param", "value"}}}); auto dec2 = factory->MakeAudioDecoder(
{"sham", 16000, 2, {{"param", "value"}}}, rtc::nullopt);
ASSERT_NE(nullptr, dec2); ASSERT_NE(nullptr, dec2);
EXPECT_EQ(16000, dec2->SampleRateHz()); EXPECT_EQ(16000, dec2->SampleRateHz());
} }
@ -127,11 +131,12 @@ TEST(AudioDecoderFactoryTemplateTest, G711) {
EXPECT_FALSE(factory->IsSupportedDecoder({"G711", 8000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"G711", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"PCMU", 8000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"PCMU", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"pcma", 8000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"pcma", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"pcmu", 16000, 1})); EXPECT_EQ(nullptr,
auto dec1 = factory->MakeAudioDecoder({"pcmu", 8000, 1}); factory->MakeAudioDecoder({"pcmu", 16000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"pcmu", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1); ASSERT_NE(nullptr, dec1);
EXPECT_EQ(8000, dec1->SampleRateHz()); 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); ASSERT_NE(nullptr, dec2);
EXPECT_EQ(8000, dec2->SampleRateHz()); EXPECT_EQ(8000, dec2->SampleRateHz());
} }
@ -143,16 +148,17 @@ TEST(AudioDecoderFactoryTemplateTest, G722) {
AudioCodecSpec{{"G722", 8000, 1}, {16000, 1, 64000}})); AudioCodecSpec{{"G722", 8000, 1}, {16000, 1, 64000}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"G722", 8000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"G722", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto dec1 = factory->MakeAudioDecoder({"G722", 8000, 1}); factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"G722", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1); ASSERT_NE(nullptr, dec1);
EXPECT_EQ(16000, dec1->SampleRateHz()); EXPECT_EQ(16000, dec1->SampleRateHz());
EXPECT_EQ(1u, dec1->Channels()); 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); ASSERT_NE(nullptr, dec2);
EXPECT_EQ(16000, dec2->SampleRateHz()); EXPECT_EQ(16000, dec2->SampleRateHz());
EXPECT_EQ(2u, dec2->Channels()); 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); ASSERT_EQ(nullptr, dec3);
} }
@ -163,8 +169,8 @@ TEST(AudioDecoderFactoryTemplateTest, Ilbc) {
AudioCodecSpec{{"ILBC", 8000, 1}, {8000, 1, 13300}})); AudioCodecSpec{{"ILBC", 8000, 1}, {8000, 1, 13300}}));
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"ilbc", 8000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"ilbc", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 8000, 1})); EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 8000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"ilbc", 8000, 1}); auto dec = factory->MakeAudioDecoder({"ilbc", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec); ASSERT_NE(nullptr, dec);
EXPECT_EQ(8000, dec->SampleRateHz()); EXPECT_EQ(8000, dec->SampleRateHz());
} }
@ -177,8 +183,9 @@ TEST(AudioDecoderFactoryTemplateTest, IsacFix) {
EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 16000, 2})); EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 16000, 2}));
EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 16000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 16000, 1}));
EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 32000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"isac", 8000, 1})); EXPECT_EQ(nullptr,
auto dec = factory->MakeAudioDecoder({"isac", 16000, 1}); factory->MakeAudioDecoder({"isac", 8000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"isac", 16000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec); ASSERT_NE(nullptr, dec);
EXPECT_EQ(16000, dec->SampleRateHz()); EXPECT_EQ(16000, dec->SampleRateHz());
} }
@ -193,11 +200,12 @@ TEST(AudioDecoderFactoryTemplateTest, IsacFloat) {
EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 16000, 2})); EXPECT_FALSE(factory->IsSupportedDecoder({"isac", 16000, 2}));
EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 16000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 16000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 32000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"isac", 8000, 1})); EXPECT_EQ(nullptr,
auto dec1 = factory->MakeAudioDecoder({"isac", 16000, 1}); factory->MakeAudioDecoder({"isac", 8000, 1}, rtc::nullopt));
auto dec1 = factory->MakeAudioDecoder({"isac", 16000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, dec1); ASSERT_NE(nullptr, dec1);
EXPECT_EQ(16000, dec1->SampleRateHz()); 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); ASSERT_NE(nullptr, dec2);
EXPECT_EQ(32000, dec2->SampleRateHz()); EXPECT_EQ(32000, dec2->SampleRateHz());
} }
@ -216,8 +224,8 @@ TEST(AudioDecoderFactoryTemplateTest, L16) {
EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"foo", 8000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"L16", 48000, 1})); EXPECT_TRUE(factory->IsSupportedDecoder({"L16", 48000, 1}));
EXPECT_FALSE(factory->IsSupportedDecoder({"L16", 96000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"L16", 96000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"L16", 8000, 0})); EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"L16", 8000, 0}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"L16", 48000, 2}); auto dec = factory->MakeAudioDecoder({"L16", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, dec); ASSERT_NE(nullptr, dec);
EXPECT_EQ(48000, dec->SampleRateHz()); EXPECT_EQ(48000, dec->SampleRateHz());
} }
@ -233,8 +241,9 @@ TEST(AudioDecoderFactoryTemplateTest, Opus) {
testing::ElementsAre(AudioCodecSpec{opus_format, opus_info})); testing::ElementsAre(AudioCodecSpec{opus_format, opus_info}));
EXPECT_FALSE(factory->IsSupportedDecoder({"opus", 48000, 1})); EXPECT_FALSE(factory->IsSupportedDecoder({"opus", 48000, 1}));
EXPECT_TRUE(factory->IsSupportedDecoder({"opus", 48000, 2})); EXPECT_TRUE(factory->IsSupportedDecoder({"opus", 48000, 2}));
EXPECT_EQ(nullptr, factory->MakeAudioDecoder({"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto dec = factory->MakeAudioDecoder({"opus", 48000, 2}); factory->MakeAudioDecoder({"bar", 16000, 1}, rtc::nullopt));
auto dec = factory->MakeAudioDecoder({"opus", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, dec); ASSERT_NE(nullptr, dec);
EXPECT_EQ(48000, dec->SampleRateHz()); 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<>>()); audio_encoder_factory_template_impl::AudioEncoderFactoryT<>>());
EXPECT_THAT(factory->GetSupportedEncoders(), testing::IsEmpty()); EXPECT_THAT(factory->GetSupportedEncoders(), testing::IsEmpty());
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1})); 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) { TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
@ -90,8 +91,9 @@ TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1})); EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 12345), EXPECT_EQ(AudioCodecInfo(8000, 1, 12345),
factory->QueryAudioEncoder({"bogus", 8000, 1})); factory->QueryAudioEncoder({"bogus", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}); factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc); ASSERT_NE(nullptr, enc);
EXPECT_EQ(8000, enc->SampleRateHz()); EXPECT_EQ(8000, enc->SampleRateHz());
} }
@ -110,13 +112,15 @@ TEST(AudioEncoderFactoryTemplateTest, TwoEncoderTypes) {
EXPECT_EQ( EXPECT_EQ(
AudioCodecInfo(16000, 2, 23456), AudioCodecInfo(16000, 2, 23456),
factory->QueryAudioEncoder({"sham", 16000, 2, {{"param", "value"}}})); factory->QueryAudioEncoder({"sham", 16000, 2, {{"param", "value"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}); factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"bogus", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc1); ASSERT_NE(nullptr, enc1);
EXPECT_EQ(8000, enc1->SampleRateHz()); EXPECT_EQ(8000, enc1->SampleRateHz());
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"sham", 16000, 2})); EXPECT_EQ(nullptr,
auto enc2 = factory->MakeAudioEncoder(17, {"sham", 16000, 2}, rtc::nullopt));
factory->MakeAudioEncoder(17, {"sham", 16000, 2, {{"param", "value"}}}); auto enc2 = factory->MakeAudioEncoder(
17, {"sham", 16000, 2, {{"param", "value"}}}, rtc::nullopt);
ASSERT_NE(nullptr, enc2); ASSERT_NE(nullptr, enc2);
EXPECT_EQ(16000, enc2->SampleRateHz()); EXPECT_EQ(16000, enc2->SampleRateHz());
} }
@ -130,11 +134,12 @@ TEST(AudioEncoderFactoryTemplateTest, G711) {
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"PCMA", 16000, 1})); EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"PCMA", 16000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 64000), EXPECT_EQ(AudioCodecInfo(8000, 1, 64000),
factory->QueryAudioEncoder({"PCMA", 8000, 1})); factory->QueryAudioEncoder({"PCMA", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"PCMU", 16000, 1})); EXPECT_EQ(nullptr,
auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1}); factory->MakeAudioEncoder(17, {"PCMU", 16000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"PCMU", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc1); ASSERT_NE(nullptr, enc1);
EXPECT_EQ(8000, enc1->SampleRateHz()); 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); ASSERT_NE(nullptr, enc2);
EXPECT_EQ(8000, enc2->SampleRateHz()); EXPECT_EQ(8000, enc2->SampleRateHz());
} }
@ -147,8 +152,9 @@ TEST(AudioEncoderFactoryTemplateTest, G722) {
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1})); EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(16000, 1, 64000), EXPECT_EQ(AudioCodecInfo(16000, 1, 64000),
factory->QueryAudioEncoder({"G722", 8000, 1})); factory->QueryAudioEncoder({"G722", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1}); factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"G722", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc); ASSERT_NE(nullptr, enc);
EXPECT_EQ(16000, enc->SampleRateHz()); EXPECT_EQ(16000, enc->SampleRateHz());
} }
@ -161,8 +167,9 @@ TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1})); EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"foo", 8000, 1}));
EXPECT_EQ(AudioCodecInfo(8000, 1, 13333), EXPECT_EQ(AudioCodecInfo(8000, 1, 13333),
factory->QueryAudioEncoder({"ilbc", 8000, 1})); factory->QueryAudioEncoder({"ilbc", 8000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 8000, 1})); EXPECT_EQ(nullptr,
auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1}); factory->MakeAudioEncoder(17, {"bar", 8000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"ilbc", 8000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc); ASSERT_NE(nullptr, enc);
EXPECT_EQ(8000, enc->SampleRateHz()); EXPECT_EQ(8000, enc->SampleRateHz());
} }
@ -176,13 +183,14 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFix) {
EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000), EXPECT_EQ(AudioCodecInfo(16000, 1, 32000, 10000, 32000),
factory->QueryAudioEncoder({"isac", 16000, 1})); factory->QueryAudioEncoder({"isac", 16000, 1}));
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 32000, 1})); EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"isac", 8000, 1})); EXPECT_EQ(nullptr,
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}); factory->MakeAudioEncoder(17, {"isac", 8000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc1); ASSERT_NE(nullptr, enc1);
EXPECT_EQ(16000, enc1->SampleRateHz()); EXPECT_EQ(16000, enc1->SampleRateHz());
EXPECT_EQ(3u, enc1->Num10MsFramesInNextPacket()); EXPECT_EQ(3u, enc1->Num10MsFramesInNextPacket());
auto enc2 = auto enc2 = factory->MakeAudioEncoder(
factory->MakeAudioEncoder(17, {"isac", 16000, 1, {{"ptime", "60"}}}); 17, {"isac", 16000, 1, {{"ptime", "60"}}}, rtc::nullopt);
ASSERT_NE(nullptr, enc2); ASSERT_NE(nullptr, enc2);
EXPECT_EQ(6u, enc2->Num10MsFramesInNextPacket()); EXPECT_EQ(6u, enc2->Num10MsFramesInNextPacket());
} }
@ -199,11 +207,12 @@ TEST(AudioEncoderFactoryTemplateTest, IsacFloat) {
factory->QueryAudioEncoder({"isac", 16000, 1})); factory->QueryAudioEncoder({"isac", 16000, 1}));
EXPECT_EQ(AudioCodecInfo(32000, 1, 56000, 10000, 56000), EXPECT_EQ(AudioCodecInfo(32000, 1, 56000, 10000, 56000),
factory->QueryAudioEncoder({"isac", 32000, 1})); factory->QueryAudioEncoder({"isac", 32000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"isac", 8000, 1})); EXPECT_EQ(nullptr,
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}); factory->MakeAudioEncoder(17, {"isac", 8000, 1}, rtc::nullopt));
auto enc1 = factory->MakeAudioEncoder(17, {"isac", 16000, 1}, rtc::nullopt);
ASSERT_NE(nullptr, enc1); ASSERT_NE(nullptr, enc1);
EXPECT_EQ(16000, enc1->SampleRateHz()); 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); ASSERT_NE(nullptr, enc2);
EXPECT_EQ(32000, enc2->SampleRateHz()); EXPECT_EQ(32000, enc2->SampleRateHz());
} }
@ -222,8 +231,9 @@ TEST(AudioEncoderFactoryTemplateTest, L16) {
EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"L16", 8000, 0})); EXPECT_EQ(rtc::nullopt, factory->QueryAudioEncoder({"L16", 8000, 0}));
EXPECT_EQ(AudioCodecInfo(48000, 1, 48000 * 16), EXPECT_EQ(AudioCodecInfo(48000, 1, 48000 * 16),
factory->QueryAudioEncoder({"L16", 48000, 1})); factory->QueryAudioEncoder({"L16", 48000, 1}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"L16", 8000, 0})); EXPECT_EQ(nullptr,
auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2}); factory->MakeAudioEncoder(17, {"L16", 8000, 0}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"L16", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, enc); ASSERT_NE(nullptr, enc);
EXPECT_EQ(48000, enc->SampleRateHz()); EXPECT_EQ(48000, enc->SampleRateHz());
} }
@ -243,8 +253,9 @@ TEST(AudioEncoderFactoryTemplateTest, Opus) {
info, info,
factory->QueryAudioEncoder( factory->QueryAudioEncoder(
{"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}})); {"opus", 48000, 2, {{"minptime", "10"}, {"useinbandfec", "1"}}}));
EXPECT_EQ(nullptr, factory->MakeAudioEncoder(17, {"bar", 16000, 1})); EXPECT_EQ(nullptr,
auto enc = factory->MakeAudioEncoder(17, {"opus", 48000, 2}); factory->MakeAudioEncoder(17, {"bar", 16000, 1}, rtc::nullopt));
auto enc = factory->MakeAudioEncoder(17, {"opus", 48000, 2}, rtc::nullopt);
ASSERT_NE(nullptr, enc); ASSERT_NE(nullptr, enc);
EXPECT_EQ(48000, enc->SampleRateHz()); 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; return rtc::nullopt;
})); }));
ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _)) ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _, _))
.WillByDefault(Invoke([](int payload_type, const SdpAudioFormat& format, .WillByDefault(Invoke([](int payload_type, const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>* return_value) { std::unique_ptr<AudioEncoder>* return_value) {
*return_value = SetupAudioEncoderMock(payload_type, format); *return_value = SetupAudioEncoderMock(payload_type, format);
})); }));
@ -422,9 +423,10 @@ TEST(AudioSendStreamTest, SendCodecAppliesAudioNetworkAdaptor) {
helper.config().audio_network_adaptor_config = kAnaConfigString; 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]( .WillOnce(Invoke([&kAnaConfigString, &kAnaReconfigString](
int payload_type, const SdpAudioFormat& format, int payload_type, const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>* return_value) { std::unique_ptr<AudioEncoder>* return_value) {
auto mock_encoder = SetupAudioEncoderMock(payload_type, format); auto mock_encoder = SetupAudioEncoderMock(payload_type, format);
EXPECT_CALL(*mock_encoder, 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); : fact_->IsSupportedDecoder(format);
} }
std::unique_ptr<AudioDecoder> MakeAudioDecoder( std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const SdpAudioFormat& format) override { const SdpAudioFormat& format,
return format.name == "MockPCMu" ? std::move(mock_decoder_) rtc::Optional<AudioCodecPairId> codec_pair_id) override {
: fact_->MakeAudioDecoder(format); return format.name == "MockPCMu"
? std::move(mock_decoder_)
: fact_->MakeAudioDecoder(format, codec_pair_id);
} }
private: 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 = rtc::scoped_refptr<AudioDecoderFactory> adf =
CreateBuiltinAudioDecoderFactory(); CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf); ASSERT_TRUE(adf);
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("rey", 8000, 1))); EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("rey", 8000, 1), rtc::nullopt));
} }
TEST(AudioDecoderFactoryTest, CreatePcmu) { TEST(AudioDecoderFactoryTest, CreatePcmu) {
@ -27,11 +28,16 @@ TEST(AudioDecoderFactoryTest, CreatePcmu) {
CreateBuiltinAudioDecoderFactory(); CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf); ASSERT_TRUE(adf);
// PCMu supports 8 kHz, and any number of channels. // PCMu supports 8 kHz, and any number of channels.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 0))); EXPECT_FALSE(
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 1))); adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 0), rtc::nullopt));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 2))); EXPECT_TRUE(
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 3))); adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 8000, 1), rtc::nullopt));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcmu", 16000, 1))); 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) { TEST(AudioDecoderFactoryTest, CreatePcma) {
@ -39,11 +45,16 @@ TEST(AudioDecoderFactoryTest, CreatePcma) {
CreateBuiltinAudioDecoderFactory(); CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf); ASSERT_TRUE(adf);
// PCMa supports 8 kHz, and any number of channels. // PCMa supports 8 kHz, and any number of channels.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 0))); EXPECT_FALSE(
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 1))); adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 0), rtc::nullopt));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 2))); EXPECT_TRUE(
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 3))); adf->MakeAudioDecoder(SdpAudioFormat("pcma", 8000, 1), rtc::nullopt));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("pcma", 16000, 1))); 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) { TEST(AudioDecoderFactoryTest, CreateIlbc) {
@ -51,12 +62,16 @@ TEST(AudioDecoderFactoryTest, CreateIlbc) {
CreateBuiltinAudioDecoderFactory(); CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf); ASSERT_TRUE(adf);
// iLBC supports 8 kHz, 1 channel. // 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 #ifdef WEBRTC_CODEC_ILBC
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 1))); EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 1), rtc::nullopt));
#endif #endif
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 2))); EXPECT_FALSE(
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 16000, 1))); adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 8000, 2), rtc::nullopt));
EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("ilbc", 16000, 1), rtc::nullopt));
} }
TEST(AudioDecoderFactoryTest, CreateIsac) { TEST(AudioDecoderFactoryTest, CreateIsac) {
@ -65,15 +80,22 @@ TEST(AudioDecoderFactoryTest, CreateIsac) {
ASSERT_TRUE(adf); ASSERT_TRUE(adf);
// iSAC supports 16 kHz, 1 channel. The float implementation additionally // iSAC supports 16 kHz, 1 channel. The float implementation additionally
// supports 32 kHz, 1 channel. // supports 32 kHz, 1 channel.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 0))); EXPECT_FALSE(
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 1))); adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 0), rtc::nullopt));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 2))); EXPECT_TRUE(
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 8000, 1))); adf->MakeAudioDecoder(SdpAudioFormat("isac", 16000, 1), rtc::nullopt));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 48000, 1))); 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 #ifdef WEBRTC_ARCH_ARM
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1))); EXPECT_FALSE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1), rtc::nullopt));
#else #else
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1))); EXPECT_TRUE(
adf->MakeAudioDecoder(SdpAudioFormat("isac", 32000, 1), rtc::nullopt));
#endif #endif
} }
@ -85,10 +107,11 @@ TEST(AudioDecoderFactoryTest, CreateL16) {
const int clockrates[] = {8000, 16000, 32000, 48000}; const int clockrates[] = {8000, 16000, 32000, 48000};
const int num_channels[] = {1, 2, 3, 4711}; const int num_channels[] = {1, 2, 3, 4711};
for (int clockrate : clockrates) { 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) { for (int channels : num_channels) {
EXPECT_TRUE( EXPECT_TRUE(adf->MakeAudioDecoder(
adf->MakeAudioDecoder(SdpAudioFormat("l16", clockrate, channels))); SdpAudioFormat("l16", clockrate, channels), rtc::nullopt));
} }
} }
} }
@ -98,16 +121,22 @@ TEST(AudioDecoderFactoryTest, CreateG722) {
CreateBuiltinAudioDecoderFactory(); CreateBuiltinAudioDecoderFactory();
ASSERT_TRUE(adf); ASSERT_TRUE(adf);
// g722 supports 8 kHz, 1-2 channels. // g722 supports 8 kHz, 1-2 channels.
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 0))); EXPECT_FALSE(
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1))); adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 0), rtc::nullopt));
EXPECT_TRUE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 2))); EXPECT_TRUE(
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 3))); adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1), rtc::nullopt));
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 16000, 1))); EXPECT_TRUE(
EXPECT_FALSE(adf->MakeAudioDecoder(SdpAudioFormat("g722", 32000, 1))); 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. // g722 actually uses a 16 kHz sample rate instead of the nominal 8 kHz.
std::unique_ptr<AudioDecoder> dec = std::unique_ptr<AudioDecoder> dec =
adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1)); adf->MakeAudioDecoder(SdpAudioFormat("g722", 8000, 1), rtc::nullopt);
EXPECT_EQ(16000, dec->SampleRateHz()); EXPECT_EQ(16000, dec->SampleRateHz());
} }
@ -126,8 +155,10 @@ TEST(AudioDecoderFactoryTest, CreateOpus) {
} }
const bool good = (hz == 48000 && channels == 2 && const bool good = (hz == 48000 && channels == 2 &&
(stereo == "XX" || stereo == "0" || stereo == "1")); (stereo == "XX" || stereo == "0" || stereo == "1"));
EXPECT_EQ(good, static_cast<bool>(adf->MakeAudioDecoder(SdpAudioFormat( EXPECT_EQ(good,
"opus", hz, channels, std::move(params))))); 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(); auto supported_encoders = factory->GetSupportedEncoders();
for (const auto& spec : supported_encoders) { for (const auto& spec : supported_encoders) {
auto info = factory->QueryAudioEncoder(spec.format); 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_TRUE(encoder);
EXPECT_EQ(encoder->SampleRateHz(), info->sample_rate_hz); EXPECT_EQ(encoder->SampleRateHz(), info->sample_rate_hz);
EXPECT_EQ(encoder->NumChannels(), info->num_channels); EXPECT_EQ(encoder->NumChannels(), info->num_channels);
@ -56,7 +56,8 @@ TEST_P(AudioEncoderFactoryTest, CanRunAllSupportedEncoders) {
auto factory = GetParam(); auto factory = GetParam();
auto supported_encoders = factory->GetSupportedEncoders(); auto supported_encoders = factory->GetSupportedEncoders();
for (const auto& spec : supported_encoders) { 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); EXPECT_TRUE(encoder);
encoder->Reset(); encoder->Reset();
const int num_samples = rtc::checked_cast<int>( 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; return true;
})); }));
auto* decoder = new MockAudioDecoder; auto* decoder = new MockAudioDecoder;
EXPECT_CALL(*factory, MakeAudioDecoderMock(_, _)) EXPECT_CALL(*factory, MakeAudioDecoderMock(_, _, _))
.WillOnce(Invoke([decoder](const SdpAudioFormat& format, .WillOnce(Invoke([decoder](const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>* dec) { std::unique_ptr<AudioDecoder>* dec) {
EXPECT_EQ("pcmu", format.name); EXPECT_EQ("pcmu", format.name);
dec->reset(decoder); 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( rtc::scoped_refptr<MockAudioDecoderFactory> mock_decoder_factory(
new rtc::RefCountedObject<MockAudioDecoderFactory>); new rtc::RefCountedObject<MockAudioDecoderFactory>);
EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _)) EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _, _))
.WillOnce(Invoke([&](const SdpAudioFormat& format, .WillOnce(Invoke([&](const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>* dec) { std::unique_ptr<AudioDecoder>* dec) {
EXPECT_EQ("pcmu", format.name); 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) { Invoke([real_decoder_factory](const webrtc::SdpAudioFormat& format) {
return real_decoder_factory->IsSupportedDecoder(format); return real_decoder_factory->IsSupportedDecoder(format);
})); }));
EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _)) EXPECT_CALL(*mock_decoder_factory, MakeAudioDecoderMock(_, _, _))
.Times(AtLeast(2)) .Times(AtLeast(2))
.WillRepeatedly( .WillRepeatedly(
Invoke([real_decoder_factory]( Invoke([real_decoder_factory](
const webrtc::SdpAudioFormat& format, const webrtc::SdpAudioFormat& format,
rtc::Optional<webrtc::AudioCodecPairId> codec_pair_id,
std::unique_ptr<webrtc::AudioDecoder>* return_value) { 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 = *return_value =
real_decoder real_decoder
? CreateForwardingMockDecoder(std::move(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: public:
MOCK_METHOD0(GetSupportedDecoders, std::vector<AudioCodecSpec>()); MOCK_METHOD0(GetSupportedDecoders, std::vector<AudioCodecSpec>());
MOCK_METHOD1(IsSupportedDecoder, bool(const SdpAudioFormat&)); 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; std::unique_ptr<AudioDecoder> return_value;
MakeAudioDecoderMock(format, &return_value); MakeAudioDecoderMock(format, codec_pair_id, &return_value);
return return_value; return return_value;
} }
MOCK_METHOD2(MakeAudioDecoderMock, MOCK_METHOD3(MakeAudioDecoderMock,
void(const SdpAudioFormat& format, void(const SdpAudioFormat& format,
rtc::Optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>* return_value)); std::unique_ptr<AudioDecoder>* return_value));
// Creates a MockAudioDecoderFactory with no formats and that may not be // 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()); EXPECT_CALL(*factory.get(), GetSupportedDecoders()).Times(AnyNumber());
ON_CALL(*factory, IsSupportedDecoder(_)).WillByDefault(Return(false)); ON_CALL(*factory, IsSupportedDecoder(_)).WillByDefault(Return(false));
EXPECT_CALL(*factory, IsSupportedDecoder(_)).Times(AnyNumber()); EXPECT_CALL(*factory, IsSupportedDecoder(_)).Times(AnyNumber());
EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _)).Times(0); EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _, _)).Times(0);
return factory; return factory;
} }
@ -72,9 +75,10 @@ class MockAudioDecoderFactory : public AudioDecoderFactory {
EXPECT_CALL(*factory.get(), GetSupportedDecoders()).Times(AnyNumber()); EXPECT_CALL(*factory.get(), GetSupportedDecoders()).Times(AnyNumber());
ON_CALL(*factory, IsSupportedDecoder(_)).WillByDefault(Return(false)); ON_CALL(*factory, IsSupportedDecoder(_)).WillByDefault(Return(false));
EXPECT_CALL(*factory, IsSupportedDecoder(_)).Times(AnyNumber()); EXPECT_CALL(*factory, IsSupportedDecoder(_)).Times(AnyNumber());
ON_CALL(*factory.get(), MakeAudioDecoderMock(_, _)) ON_CALL(*factory.get(), MakeAudioDecoderMock(_, _, _))
.WillByDefault(SetArgPointee<1>(nullptr)); .WillByDefault(SetArgPointee<2>(nullptr));
EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _)).Times(AnyNumber()); EXPECT_CALL(*factory.get(), MakeAudioDecoderMock(_, _, _))
.Times(AnyNumber());
return factory; return factory;
} }
}; };

19
test/mock_audio_encoder_factory.h
View File

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