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

Provide Environment to create an audio encoder in tests

Browse Source 
Bug: webrtc:343086059
Change-Id: I73a48770ae67e529eb5065e957ea6420dea44975
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/354881
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Jakob Ivarsson‎ <jakobi@webrtc.org>
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42542}
This commit is contained in:
Danil Chapovalov 2024-06-18 11:20:40 +02:00 committed by WebRTC LUCI CQ
parent eb3da2b1ec
commit 1030eaaffe
23 changed files with 156 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -216,8 +216,6 @@ TEST(AudioEncoderFactoryTemplateTest, NoEncoderTypes) {
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));
EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
}
@ -231,11 +229,6 @@ TEST(AudioEncoderFactoryTemplateTest, OneEncoderType) {
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());
EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
EXPECT_THAT(factory->Create(env, {"bogus", 8000, 1}, {}),
@ -257,27 +250,18 @@ 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}, 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());
EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
EXPECT_THAT(factory->Create(env, {"bogus", 8000, 1}, {}),
Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
EXPECT_THAT(factory->Create(env, {"sham", 16000, 2}, {}), IsNull());
EXPECT_THAT(
factory->Create(env, {"sham", 16000, 2, {{"param", "value"}}}, {}),
Pointer(Property(&AudioEncoder::SampleRateHz, 16000)));
}
TEST(AudioEncoderFactoryTemplateTest, G711) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioEncoderFactory<AudioEncoderG711>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
@ -286,17 +270,16 @@ TEST(AudioEncoderFactoryTemplateTest, G711) {
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());
EXPECT_THAT(factory->Create(env, {"PCMU", 16000, 1}, {}), IsNull());
EXPECT_THAT(factory->Create(env, {"PCMU", 8000, 1}, {}),
Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
EXPECT_THAT(factory->Create(env, {"PCMA", 8000, 1}, {}),
Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
}
TEST(AudioEncoderFactoryTemplateTest, G722) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioEncoderFactory<AudioEncoderG722>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
@ -304,14 +287,14 @@ TEST(AudioEncoderFactoryTemplateTest, G722) {
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());
EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {}), IsNull());
EXPECT_THAT(factory->Create(env, {"G722", 8000, 1}, {}),
Pointer(Property(&AudioEncoder::SampleRateHz, 16000)));
}
TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioEncoderFactory<AudioEncoderIlbc>();
EXPECT_THAT(factory->GetSupportedEncoders(),
::testing::ElementsAre(
@ -319,14 +302,14 @@ TEST(AudioEncoderFactoryTemplateTest, Ilbc) {
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());
EXPECT_THAT(factory->Create(env, {"bar", 8000, 1}, {}), IsNull());
EXPECT_THAT(factory->Create(env, {"ilbc", 8000, 1}, {}),
Pointer(Property(&AudioEncoder::SampleRateHz, 8000)));
}
TEST(AudioEncoderFactoryTemplateTest, L16) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioEncoderFactory<AudioEncoderL16>();
EXPECT_THAT(
factory->GetSupportedEncoders(),
@ -340,14 +323,14 @@ TEST(AudioEncoderFactoryTemplateTest, L16) {
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());
EXPECT_THAT(factory->Create(env, {"L16", 8000, 0}, {}), IsNull());
EXPECT_THAT(factory->Create(env, {"L16", 48000, 2}, {}),
Pointer(Property(&AudioEncoder::SampleRateHz, 48000)));
}
TEST(AudioEncoderFactoryTemplateTest, Opus) {
const Environment env = CreateEnvironment();
auto factory = CreateAudioEncoderFactory<AudioEncoderOpus>();
AudioCodecInfo info = {48000, 1, 32000, 6000, 510000};
info.allow_comfort_noise = false;
@ -362,11 +345,11 @@ TEST(AudioEncoderFactoryTemplateTest, Opus) {
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());
EXPECT_THAT(factory->Create(env, {"bar", 16000, 1}, {.payload_type = 17}),
IsNull());
EXPECT_THAT(factory->Create(env, {"opus", 48000, 2}, {.payload_type = 17}),
Pointer(Property(&AudioEncoder::SampleRateHz, 48000)));
}
} // namespace

2
audio/channel_send_unittest.cc
View File

@ -67,7 +67,7 @@ class ChannelSendTest : public ::testing::Test {
encoder_factory_ = CreateBuiltinAudioEncoderFactory();
SdpAudioFormat opus = SdpAudioFormat("opus", kRtpRateHz, 2);
std::unique_ptr<AudioEncoder> encoder =
encoder_factory_->MakeAudioEncoder(kPayloadType, opus, {});
encoder_factory_->Create(env_, opus, {.payload_type = kPayloadType});
channel_->SetEncoder(kPayloadType, opus, std::move(encoder));
transport_controller_.EnsureStarted();
channel_->RegisterSenderCongestionControlObjects(&transport_controller_);

6
audio/voip/test/BUILD.gn
View File

@ -49,6 +49,8 @@ if (rtc_include_tests) {
"../../../api:transport_api",
"../../../api/audio_codecs:builtin_audio_decoder_factory",
"../../../api/audio_codecs:builtin_audio_encoder_factory",
"../../../api/environment",
"../../../api/environment:environment_factory",
"../../../api/task_queue:task_queue",
"../../../modules/audio_mixer:audio_mixer_impl",
"../../../modules/audio_mixer:audio_mixer_test_utils",
@ -70,6 +72,8 @@ if (rtc_include_tests) {
"../../../api:transport_api",
"../../../api/audio_codecs:builtin_audio_decoder_factory",
"../../../api/audio_codecs:builtin_audio_encoder_factory",
"../../../api/environment",
"../../../api/environment:environment_factory",
"../../../api/task_queue:default_task_queue_factory",
"../../../api/units:time_delta",
"../../../api/units:timestamp",
@ -91,6 +95,8 @@ if (rtc_include_tests) {
"..:audio_egress",
"../../../api:transport_api",
"../../../api/audio_codecs:builtin_audio_encoder_factory",
"../../../api/environment",
"../../../api/environment:environment_factory",
"../../../api/task_queue:default_task_queue_factory",
"../../../api/units:time_delta",
"../../../api/units:timestamp",

20
audio/voip/test/audio_channel_unittest.cc
View File

@ -14,6 +14,8 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/call/transport.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/task_queue/task_queue_base.h"
#include "api/task_queue/task_queue_factory.h"
#include "audio/voip/test/mock_task_queue.h"
@ -44,8 +46,11 @@ class AudioChannelTest : public ::testing::Test {
const SdpAudioFormat kPcmuFormat = {"pcmu", 8000, 1};
AudioChannelTest()
: fake_clock_(kStartTime), wave_generator_(1000.0, kAudioLevel) {
task_queue_factory_ = std::make_unique<MockTaskQueueFactory>(&task_queue_);
: fake_clock_(kStartTime),
wave_generator_(1000.0, kAudioLevel),
env_(CreateEnvironment(
&fake_clock_,
std::make_unique<MockTaskQueueFactory>(&task_queue_))) {
audio_mixer_ = AudioMixerImpl::Create();
encoder_factory_ = CreateBuiltinAudioEncoderFactory();
decoder_factory_ = CreateBuiltinAudioDecoderFactory();
@ -68,11 +73,12 @@ class AudioChannelTest : public ::testing::Test {
// simplify network routing logic.
rtc::scoped_refptr<AudioChannel> audio_channel =
rtc::make_ref_counted<AudioChannel>(
&transport_, ssrc, task_queue_factory_.get(), audio_mixer_.get(),
&transport_, ssrc, &env_.task_queue_factory(), audio_mixer_.get(),
decoder_factory_);
audio_channel->SetEncoder(kPcmuPayload, kPcmuFormat,
encoder_factory_->MakeAudioEncoder(
kPcmuPayload, kPcmuFormat, absl::nullopt));
audio_channel->SetEncoder(
kPcmuPayload, kPcmuFormat,
encoder_factory_->Create(env_, kPcmuFormat,
{.payload_type = kPcmuPayload}));
audio_channel->SetReceiveCodecs({{kPcmuPayload, kPcmuFormat}});
audio_channel->StartSend();
audio_channel->StartPlay();
@ -93,7 +99,7 @@ class AudioChannelTest : public ::testing::Test {
SineWaveGenerator wave_generator_;
NiceMock<MockTransport> transport_;
NiceMock<MockTaskQueue> task_queue_;
std::unique_ptr<TaskQueueFactory> task_queue_factory_;
const Environment env_;
rtc::scoped_refptr<AudioMixer> audio_mixer_;
rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_;

14
audio/voip/test/audio_egress_unittest.cc
View File

@ -12,7 +12,8 @@
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/call/transport.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "modules/audio_mixer/sine_wave_generator.h"
@ -74,8 +75,8 @@ class AudioEgressTest : public ::testing::Test {
time_controller_.GetTaskQueueFactory());
constexpr int kPcmuPayload = 0;
egress_->SetEncoder(kPcmuPayload, kPcmuFormat,
encoder_factory_->MakeAudioEncoder(
kPcmuPayload, kPcmuFormat, absl::nullopt));
encoder_factory_->Create(
env_, kPcmuFormat, {.payload_type = kPcmuPayload}));
egress_->StartSend();
rtp_rtcp_->SetSequenceNumber(kSeqNum);
rtp_rtcp_->SetSendingStatus(true);
@ -104,6 +105,9 @@ class AudioEgressTest : public ::testing::Test {
}
GlobalSimulatedTimeController time_controller_{Timestamp::Micros(kStartTime)};
const Environment env_ =
CreateEnvironment(time_controller_.GetClock(),
time_controller_.GetTaskQueueFactory());
NiceMock<MockTransport> transport_;
SineWaveGenerator wave_generator_;
std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_;
@ -235,8 +239,8 @@ TEST_F(AudioEgressTest, ChangeEncoderFromPcmuToOpus) {
const SdpAudioFormat kOpusFormat = {"opus", 48000, 2};
egress_->SetEncoder(kOpusPayload, kOpusFormat,
encoder_factory_->MakeAudioEncoder(
kOpusPayload, kOpusFormat, absl::nullopt));
encoder_factory_->Create(env_, kOpusFormat,
{.payload_type = kOpusPayload}));
absl::optional<SdpAudioFormat> opus = egress_->GetEncoderFormat();
EXPECT_TRUE(opus);

9
audio/voip/test/audio_ingress_unittest.cc
View File

@ -13,6 +13,8 @@
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/call/transport.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/task_queue/default_task_queue_factory.h"
#include "api/units/time_delta.h"
#include "audio/voip/audio_egress.h"
@ -70,8 +72,8 @@ class AudioIngressTest : public ::testing::Test {
rtp_rtcp_.get(), time_controller_.GetClock(),
time_controller_.GetTaskQueueFactory());
egress_->SetEncoder(kPcmuPayload, kPcmuFormat,
encoder_factory_->MakeAudioEncoder(
kPcmuPayload, kPcmuFormat, absl::nullopt));
encoder_factory_->Create(
env_, kPcmuFormat, {.payload_type = kPcmuPayload}));
egress_->StartSend();
ingress_->StartPlay();
rtp_rtcp_->SetSendingStatus(true);
@ -96,6 +98,9 @@ class AudioIngressTest : public ::testing::Test {
}
GlobalSimulatedTimeController time_controller_{Timestamp::Micros(123456789)};
const Environment env_ =
CreateEnvironment(time_controller_.GetClock(),
time_controller_.GetTaskQueueFactory());
SineWaveGenerator wave_generator_;
NiceMock<MockTransport> transport_;
std::unique_ptr<ReceiveStatistics> receive_statistics_;

8
modules/audio_coding/BUILD.gn
View File

@ -942,6 +942,8 @@ rtc_library("audio_coding_modules_tests_shared") {
"../../api/audio:audio_frame_api",
"../../api/audio_codecs:builtin_audio_decoder_factory",
"../../api/audio_codecs:builtin_audio_encoder_factory",
"../../api/environment",
"../../api/environment:environment_factory",
"../../api/neteq:neteq_api",
"../../api/units:timestamp",
"../../rtc_base:checks",
@ -1073,6 +1075,8 @@ if (rtc_include_tests) {
"../../api/audio_codecs/ilbc:audio_encoder_ilbc",
"../../api/audio_codecs/opus:audio_decoder_opus",
"../../api/audio_codecs/opus:audio_encoder_opus",
"../../api/environment",
"../../api/environment:environment_factory",
"../../api/units:timestamp",
"../../common_audio",
"../../rtc_base:checks",
@ -1155,6 +1159,8 @@ if (rtc_include_tests) {
"../../api/audio_codecs:audio_codecs_api",
"../../api/audio_codecs:builtin_audio_decoder_factory",
"../../api/audio_codecs:builtin_audio_encoder_factory",
"../../api/environment",
"../../api/environment:environment_factory",
"../../rtc_base:checks",
"../../rtc_base:stringutils",
"../../test:test_support",
@ -1686,6 +1692,8 @@ if (rtc_include_tests) {
"../../api/audio_codecs/opus:audio_decoder_opus",
"../../api/audio_codecs/opus:audio_encoder_multiopus",
"../../api/audio_codecs/opus:audio_encoder_opus",
"../../api/environment",
"../../api/environment:environment_factory",
"../../api/neteq:default_neteq_controller_factory",
"../../api/neteq:neteq_api",
"../../api/neteq:neteq_controller_api",

5
modules/audio_coding/acm2/acm_receiver_unittest.cc
View File

@ -16,6 +16,8 @@
#include "absl/types/optional.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/units/timestamp.h"
#include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
#include "modules/audio_coding/include/audio_coding_module.h"
@ -69,7 +71,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
encoder_factory_->QueryAudioEncoder(format);
RTC_CHECK(info.has_value());
std::unique_ptr<AudioEncoder> enc =
encoder_factory_->MakeAudioEncoder(payload_type, format, absl::nullopt);
encoder_factory_->Create(env_, format, {.payload_type = payload_type});
// If we have a compatible CN specification, stack a CNG on top.
auto it = cng_payload_types.find(info->sample_rate_hz);
@ -132,6 +134,7 @@ class AcmReceiverTestOldApi : public AudioPacketizationCallback,
return 0;
}
const Environment env_ = CreateEnvironment();
const rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_ =
CreateBuiltinAudioEncoderFactory();
const rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_ =

4
modules/audio_coding/acm2/acm_send_test.cc
View File

@ -18,6 +18,7 @@
#include "api/audio_codecs/audio_encoder.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/environment/environment_factory.h"
#include "modules/audio_coding/include/audio_coding_module.h"
#include "modules/audio_coding/neteq/tools/input_audio_file.h"
#include "modules/audio_coding/neteq/tools/packet.h"
@ -32,6 +33,7 @@ AcmSendTestOldApi::AcmSendTestOldApi(InputAudioFile* audio_source,
int source_rate_hz,
int test_duration_ms)
: clock_(0),
env_(CreateEnvironment(&clock_)),
acm_(webrtc::AudioCodingModule::Create()),
audio_source_(audio_source),
source_rate_hz_(source_rate_hz),
@ -73,7 +75,7 @@ bool AcmSendTestOldApi::RegisterCodec(absl::string_view payload_name,
frame_size_samples, rtc::CheckedDivExact(clockrate_hz, 1000)));
auto factory = CreateBuiltinAudioEncoderFactory();
acm_->SetEncoder(
factory->MakeAudioEncoder(payload_type, format, absl::nullopt));
factory->Create(env_, format, {.payload_type = payload_type}));
codec_registered_ = true;
input_frame_.num_channels_ = num_channels;
RTC_DCHECK_LE(input_block_size_samples_ * input_frame_.num_channels_,

2
modules/audio_coding/acm2/acm_send_test.h
View File

@ -16,6 +16,7 @@
#include "absl/strings/string_view.h"
#include "api/audio/audio_frame.h"
#include "api/environment/environment.h"
#include "modules/audio_coding/include/audio_coding_module.h"
#include "modules/audio_coding/neteq/tools/packet_source.h"
#include "system_wrappers/include/clock.h"
@ -70,6 +71,7 @@ class AcmSendTestOldApi : public AudioPacketizationCallback,
std::unique_ptr<Packet> CreatePacket();
SimulatedClock clock_;
const Environment env_;
std::unique_ptr<AudioCodingModule> acm_;
InputAudioFile* audio_source_;
int source_rate_hz_;

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

@ -25,6 +25,8 @@
#include "api/audio_codecs/opus/audio_decoder_opus.h"
#include "api/audio_codecs/opus/audio_encoder_multi_channel_opus.h"
#include "api/audio_codecs/opus/audio_encoder_opus.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "api/units/timestamp.h"
#include "modules/audio_coding/acm2/acm_receive_test.h"
#include "modules/audio_coding/acm2/acm_send_test.h"
@ -163,8 +165,8 @@ class PacketizationCallbackStubOldApi : public AudioPacketizationCallback {
class AudioCodingModuleTestOldApi : public ::testing::Test {
protected:
AudioCodingModuleTestOldApi()
: rtp_utility_(new RtpData(kFrameSizeSamples, kPayloadType)),
clock_(Clock::GetRealTimeClock()) {}
: env_(CreateEnvironment()),
rtp_utility_(new RtpData(kFrameSizeSamples, kPayloadType)) {}
~AudioCodingModuleTestOldApi() {}
@ -173,7 +175,7 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
void SetUp() {
acm_ = AudioCodingModule::Create();
acm2::AcmReceiver::Config config;
config.clock = *clock_;
config.clock = env_.clock();
config.decoder_factory = CreateBuiltinAudioDecoderFactory();
acm_receiver_ = std::make_unique<acm2::AcmReceiver>(config);
@ -199,8 +201,8 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
virtual void RegisterCodec() {
acm_receiver_->SetCodecs({{kPayloadType, *audio_format_}});
acm_->SetEncoder(CreateBuiltinAudioEncoderFactory()->MakeAudioEncoder(
kPayloadType, *audio_format_, absl::nullopt));
acm_->SetEncoder(CreateBuiltinAudioEncoderFactory()->Create(
env_, *audio_format_, {.payload_type = kPayloadType}));
}
virtual void InsertPacketAndPullAudio() {
@ -240,6 +242,7 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
VerifyEncoding();
}
Environment env_;
std::unique_ptr<RtpData> rtp_utility_;
std::unique_ptr<AudioCodingModule> acm_;
std::unique_ptr<acm2::AcmReceiver> acm_receiver_;
@ -249,8 +252,6 @@ class AudioCodingModuleTestOldApi : public ::testing::Test {
absl::optional<SdpAudioFormat> audio_format_;
int pac_size_ = -1;
Clock* clock_;
};
class AudioCodingModuleTestOldApiDeathTest
@ -381,7 +382,9 @@ class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
pull_audio_count_(0),
next_insert_packet_time_ms_(0),
fake_clock_(new SimulatedClock(0)) {
clock_ = fake_clock_.get();
EnvironmentFactory override_clock(env_);
override_clock.Set(fake_clock_.get());
env_ = override_clock.Create();
}
void SetUp() {
@ -458,7 +461,7 @@ class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
SleepMs(1);
{
MutexLock lock(&mutex_);
if (clock_->TimeInMilliseconds() < next_insert_packet_time_ms_) {
if (env_.clock().TimeInMilliseconds() < next_insert_packet_time_ms_) {
return;
}
next_insert_packet_time_ms_ += 10;
@ -473,7 +476,7 @@ class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
{
MutexLock lock(&mutex_);
// Don't let the insert thread fall behind.
if (next_insert_packet_time_ms_ < clock_->TimeInMilliseconds()) {
if (next_insert_packet_time_ms_ < env_.clock().TimeInMilliseconds()) {
return;
}
++pull_audio_count_;
@ -534,9 +537,10 @@ class AcmAbsoluteCaptureTimestamp : public ::testing::Test {
rtc::scoped_refptr<AudioEncoderFactory> codec_factory =
CreateBuiltinAudioEncoderFactory();
acm_ = AudioCodingModule::Create();
std::unique_ptr<AudioEncoder> encoder = codec_factory->MakeAudioEncoder(
111, SdpAudioFormat("OPUS", kSampleRateHz, kNumChannels),
absl::nullopt);
std::unique_ptr<AudioEncoder> encoder = codec_factory->Create(
CreateEnvironment(),
SdpAudioFormat("OPUS", kSampleRateHz, kNumChannels),
{.payload_type = 111});
encoder->SetDtx(true);
encoder->SetReceiverFrameLengthRange(kPTimeMs, kPTimeMs);
acm_->SetEncoder(std::move(encoder));

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

@ -14,6 +14,8 @@
#include <memory>
#include <vector>
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "test/gmock.h"
#include "test/gtest.h"
@ -40,11 +42,12 @@ TEST_P(AudioEncoderFactoryTest, CanQueryAllSupportedFormats) {
}
TEST_P(AudioEncoderFactoryTest, CanConstructAllSupportedEncoders) {
const Environment env = CreateEnvironment();
auto factory = GetParam();
auto supported_encoders = factory->GetSupportedEncoders();
for (const auto& spec : supported_encoders) {
auto info = factory->QueryAudioEncoder(spec.format);
auto encoder = factory->MakeAudioEncoder(127, spec.format, absl::nullopt);
auto encoder = factory->Create(env, spec.format, {.payload_type = 127});
EXPECT_TRUE(encoder);
EXPECT_EQ(encoder->SampleRateHz(), info->sample_rate_hz);
EXPECT_EQ(encoder->NumChannels(), info->num_channels);
@ -54,6 +57,7 @@ TEST_P(AudioEncoderFactoryTest, CanConstructAllSupportedEncoders) {
TEST_P(AudioEncoderFactoryTest, CanRunAllSupportedEncoders) {
constexpr int kTestPayloadType = 127;
const Environment env = CreateEnvironment();
auto factory = GetParam();
auto supported_encoders = factory->GetSupportedEncoders();
for (const auto& spec : supported_encoders) {
@ -64,7 +68,7 @@ TEST_P(AudioEncoderFactoryTest, CanRunAllSupportedEncoders) {
}
#endif
auto encoder =
factory->MakeAudioEncoder(kTestPayloadType, spec.format, absl::nullopt);
factory->Create(env, spec.format, {.payload_type = kTestPayloadType});
EXPECT_TRUE(encoder);
encoder->Reset();
const int num_samples = rtc::checked_cast<int>(
@ -153,6 +157,7 @@ TEST(BuiltinAudioEncoderFactoryTest, SupportsTheExpectedFormats) {
// Tests that using more channels than the maximum does not work.
TEST(BuiltinAudioEncoderFactoryTest, MaxNrOfChannels) {
const Environment env = CreateEnvironment();
rtc::scoped_refptr<AudioEncoderFactory> aef =
CreateBuiltinAudioEncoderFactory();
std::vector<std::string> codecs = {
@ -173,11 +178,10 @@ TEST(BuiltinAudioEncoderFactoryTest, MaxNrOfChannels) {
};
for (auto codec : codecs) {
EXPECT_FALSE(aef->MakeAudioEncoder(
/*payload_type=*/111,
/*format=*/
EXPECT_FALSE(aef->Create(
env, /*format=*/
SdpAudioFormat(codec, 32000, AudioEncoder::kMaxNumberOfChannels + 1),
/*codec_pair_id=*/absl::nullopt));
{.payload_type = 111}));
}
}

6
modules/audio_coding/test/EncodeDecodeTest.cc
View File

@ -18,6 +18,8 @@
#include "absl/strings/string_view.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/environment/environment.h"
#include "api/environment/environment_factory.h"
#include "modules/audio_coding/include/audio_coding_module.h"
#include "rtc_base/strings/string_builder.h"
#include "test/gtest.h"
@ -67,8 +69,8 @@ void Sender::Setup(AudioCodingModule* acm,
// Fast-forward 1 second (100 blocks) since the file starts with silence.
_pcmFile.FastForward(100);
acm->SetEncoder(CreateBuiltinAudioEncoderFactory()->MakeAudioEncoder(
payload_type, format, absl::nullopt));
acm->SetEncoder(CreateBuiltinAudioEncoderFactory()->Create(
CreateEnvironment(), format, {.payload_type = payload_type}));
_packetization = new TestPacketization(rtpStream, format.clockrate_hz);
EXPECT_EQ(0, acm->RegisterTransportCallback(_packetization));

8
modules/audio_coding/test/TestAllCodecs.cc
View File

@ -17,6 +17,7 @@
#include "absl/strings/match.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/environment/environment_factory.h"
#include "modules/audio_coding/include/audio_coding_module_typedefs.h"
#include "modules/include/module_common_types.h"
#include "rtc_base/logging.h"
@ -107,7 +108,8 @@ void TestPack::reset_payload_size() {
}
TestAllCodecs::TestAllCodecs()
: acm_a_(AudioCodingModule::Create()),
: env_(CreateEnvironment()),
acm_a_(AudioCodingModule::Create()),
acm_b_(std::make_unique<acm2::AcmReceiver>(
acm2::AcmReceiver::Config(CreateBuiltinAudioDecoderFactory()))),
channel_a_to_b_(NULL),
@ -319,12 +321,10 @@ void TestAllCodecs::RegisterSendCodec(char* codec_name,
}
auto factory = CreateBuiltinAudioEncoderFactory();
constexpr int payload_type = 17;
SdpAudioFormat format = {codec_name, clockrate_hz, num_channels};
format.parameters["ptime"] = rtc::ToString(rtc::CheckedDivExact(
packet_size, rtc::CheckedDivExact(sampling_freq_hz, 1000)));
acm_a_->SetEncoder(
factory->MakeAudioEncoder(payload_type, format, absl::nullopt));
acm_a_->SetEncoder(factory->Create(env_, format, {.payload_type = 17}));
}
void TestAllCodecs::Run(TestPack* channel) {

2
modules/audio_coding/test/TestAllCodecs.h
View File

@ -13,6 +13,7 @@
#include <memory>
#include "api/environment/environment.h"
#include "modules/audio_coding/acm2/acm_receiver.h"
#include "modules/audio_coding/include/audio_coding_module.h"
#include "modules/audio_coding/test/PCMFile.h"
@ -68,6 +69,7 @@ class TestAllCodecs {
void Run(TestPack* channel);
void OpenOutFile(int test_number);
const Environment env_;
std::unique_ptr<AudioCodingModule> acm_a_;
std::unique_ptr<acm2::AcmReceiver> acm_b_;
TestPack* channel_a_to_b_;

8
modules/audio_coding/test/TestRedFec.cc
View File

@ -24,6 +24,7 @@
#include "api/audio_codecs/g722/audio_encoder_g722.h"
#include "api/audio_codecs/opus/audio_decoder_opus.h"
#include "api/audio_codecs/opus/audio_encoder_opus.h"
#include "api/environment/environment_factory.h"
#include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
#include "modules/audio_coding/codecs/red/audio_encoder_copy_red.h"
#include "modules/audio_coding/include/audio_coding_module_typedefs.h"
@ -34,7 +35,8 @@
namespace webrtc {
TestRedFec::TestRedFec()
: encoder_factory_(CreateAudioEncoderFactory<AudioEncoderG711,
: env_(CreateEnvironment(&field_trials_)),
encoder_factory_(CreateAudioEncoderFactory<AudioEncoderG711,
AudioEncoderG722,
AudioEncoderL16,
AudioEncoderOpus>()),
@ -136,8 +138,8 @@ void TestRedFec::RegisterSendCodec(
bool use_red) {
constexpr int payload_type = 17, cn_payload_type = 27, red_payload_type = 37;
auto encoder = encoder_factory_->MakeAudioEncoder(payload_type, codec_format,
absl::nullopt);
auto encoder = encoder_factory_->Create(env_, codec_format,
{.payload_type = payload_type});
EXPECT_NE(encoder, nullptr);
std::map<int, SdpAudioFormat> receive_codecs = {{payload_type, codec_format}};
if (!absl::EqualsIgnoreCase(codec_format.name, "opus")) {

2
modules/audio_coding/test/TestRedFec.h
View File

@ -16,6 +16,7 @@
#include "api/audio_codecs/audio_decoder_factory.h"
#include "api/audio_codecs/audio_encoder_factory.h"
#include "api/environment/environment.h"
#include "common_audio/vad/include/vad.h"
#include "modules/audio_coding/acm2/acm_receiver.h"
#include "modules/audio_coding/test/Channel.h"
@ -40,6 +41,7 @@ class TestRedFec final {
void OpenOutFile(int16_t testNumber);
test::ScopedKeyValueConfig field_trials_;
const Environment env_;
const rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_;
const rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
std::unique_ptr<AudioCodingModule> _acmA;

11
modules/audio_coding/test/TestStereo.cc
View File

@ -15,6 +15,7 @@
#include "absl/strings/match.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
#include "api/environment/environment_factory.h"
#include "modules/audio_coding/include/audio_coding_module_typedefs.h"
#include "modules/include/module_common_types.h"
#include "rtc_base/strings/string_builder.h"
@ -98,7 +99,8 @@ void TestPackStereo::set_lost_packet(bool lost) {
}
TestStereo::TestStereo()
: acm_a_(AudioCodingModule::Create()),
: env_(CreateEnvironment()),
acm_a_(AudioCodingModule::Create()),
acm_b_(std::make_unique<acm2::AcmReceiver>(
acm2::AcmReceiver::Config(CreateBuiltinAudioDecoderFactory()))),
channel_a2b_(NULL),
@ -488,10 +490,9 @@ void TestStereo::RegisterSendCodec(char side,
channels = 2;
params["maxaveragebitrate"] = rtc::ToString(rate);
}
constexpr int payload_type = 17;
auto encoder = encoder_factory->MakeAudioEncoder(
payload_type, SdpAudioFormat(codec_name, clockrate_hz, channels, params),
absl::nullopt);
auto encoder = encoder_factory->Create(
env_, SdpAudioFormat(codec_name, clockrate_hz, channels, params),
{.payload_type = 17});
EXPECT_NE(nullptr, encoder);
my_acm->SetEncoder(std::move(encoder));

2
modules/audio_coding/test/TestStereo.h
View File

@ -15,6 +15,7 @@
#include <memory>
#include "api/environment/environment.h"
#include "modules/audio_coding/acm2/acm_receiver.h"
#include "modules/audio_coding/include/audio_coding_module.h"
#include "modules/audio_coding/test/PCMFile.h"
@ -81,6 +82,7 @@ class TestStereo {
int percent_loss = 0);
void OpenOutFile(int16_t test_number);
const Environment env_;
std::unique_ptr<AudioCodingModule> acm_a_;
std::unique_ptr<acm2::AcmReceiver> acm_b_;

8
modules/audio_coding/test/TestVADDTX.cc
View File

@ -20,6 +20,7 @@
#include "api/audio_codecs/ilbc/audio_encoder_ilbc.h"
#include "api/audio_codecs/opus/audio_decoder_opus.h"
#include "api/audio_codecs/opus/audio_encoder_opus.h"
#include "api/environment/environment_factory.h"
#include "modules/audio_coding/codecs/cng/audio_encoder_cng.h"
#include "modules/audio_coding/test/PCMFile.h"
#include "rtc_base/strings/string_builder.h"
@ -66,7 +67,8 @@ void MonitoringAudioPacketizationCallback::GetStatistics(uint32_t* counter) {
}
TestVadDtx::TestVadDtx()
: encoder_factory_(
: env_(CreateEnvironment()),
encoder_factory_(
CreateAudioEncoderFactory<AudioEncoderIlbc, AudioEncoderOpus>()),
decoder_factory_(
CreateAudioDecoderFactory<AudioDecoderIlbc, AudioDecoderOpus>()),
@ -87,8 +89,8 @@ bool TestVadDtx::RegisterCodec(const SdpAudioFormat& codec_format,
constexpr int payload_type = 17, cn_payload_type = 117;
bool added_comfort_noise = false;
auto encoder = encoder_factory_->MakeAudioEncoder(payload_type, codec_format,
absl::nullopt);
auto encoder = encoder_factory_->Create(env_, codec_format,
{.payload_type = payload_type});
if (vad_mode.has_value() &&
!absl::EqualsIgnoreCase(codec_format.name, "opus")) {
AudioEncoderCngConfig config;

2
modules/audio_coding/test/TestVADDTX.h
View File

@ -16,6 +16,7 @@
#include "absl/strings/string_view.h"
#include "api/audio_codecs/audio_decoder_factory.h"
#include "api/audio_codecs/audio_encoder_factory.h"
#include "api/environment/environment.h"
#include "common_audio/vad/include/vad.h"
#include "modules/audio_coding/acm2/acm_receiver.h"
#include "modules/audio_coding/include/audio_coding_module.h"
@ -82,6 +83,7 @@ class TestVadDtx {
bool append,
const int* expects);
const Environment env_;
const rtc::scoped_refptr<AudioEncoderFactory> encoder_factory_;
const rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
std::unique_ptr<AudioCodingModule> acm_send_;

1
pc/BUILD.gn
View File

@ -2338,6 +2338,7 @@ if (rtc_include_tests && !build_with_chromium) {
"../api/crypto:frame_decryptor_interface",
"../api/crypto:frame_encryptor_interface",
"../api/crypto:options",
"../api/environment",
"../api/environment:environment_factory",
"../api/rtc_event_log",
"../api/rtc_event_log:rtc_event_log_factory",

19
pc/peer_connection_end_to_end_unittest.cc
View File

@ -34,6 +34,7 @@
#include "api/audio_codecs/opus_audio_encoder_factory.h"
#include "api/audio_options.h"
#include "api/data_channel_interface.h"
#include "api/environment/environment.h"
#include "api/media_stream_interface.h"
#include "api/peer_connection_interface.h"
#include "api/rtc_error.h"
@ -63,11 +64,11 @@ using ::testing::AtLeast;
using ::testing::Invoke;
using ::testing::StrictMock;
using ::testing::Values;
using webrtc::DataChannelInterface;
using webrtc::MediaStreamInterface;
using webrtc::PeerConnectionInterface;
using webrtc::SdpSemantics;
using ::webrtc::DataChannelInterface;
using ::webrtc::Environment;
using ::webrtc::MediaStreamInterface;
using ::webrtc::PeerConnectionInterface;
using ::webrtc::SdpSemantics;
namespace {
@ -427,6 +428,14 @@ TEST_P(PeerConnectionEndToEndTest, CallWithCustomCodec) {
codec_ids_->push_back(*codec_pair_id);
return fact_->MakeAudioEncoder(payload_type, format, codec_pair_id);
}
std::unique_ptr<webrtc::AudioEncoder> Create(
const Environment& env,
const webrtc::SdpAudioFormat& format,
Options options) override {
EXPECT_TRUE(options.codec_pair_id.has_value());
codec_ids_->push_back(*options.codec_pair_id);
return fact_->Create(env, format, options);
}
private:
const rtc::scoped_refptr<webrtc::AudioEncoderFactory> fact_;