diff options
Diffstat (limited to 'third_party/libwebrtc/test/call_test.cc')
| -rw-r--r-- | third_party/libwebrtc/test/call_test.cc | 861 |
1 files changed, 861 insertions, 0 deletions
diff --git a/third_party/libwebrtc/test/call_test.cc b/third_party/libwebrtc/test/call_test.cc new file mode 100644 index 0000000000..62d18394f9 --- /dev/null +++ b/third_party/libwebrtc/test/call_test.cc @@ -0,0 +1,861 @@ +/* + * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "test/call_test.h" + +#include <algorithm> +#include <memory> + +#include "api/audio_codecs/builtin_audio_decoder_factory.h" +#include "api/audio_codecs/builtin_audio_encoder_factory.h" +#include "api/task_queue/default_task_queue_factory.h" +#include "api/task_queue/task_queue_base.h" +#include "api/test/create_frame_generator.h" +#include "api/video/builtin_video_bitrate_allocator_factory.h" +#include "call/fake_network_pipe.h" +#include "call/packet_receiver.h" +#include "call/simulated_network.h" +#include "modules/audio_mixer/audio_mixer_impl.h" +#include "rtc_base/checks.h" +#include "rtc_base/event.h" +#include "rtc_base/task_queue_for_test.h" +#include "test/fake_encoder.h" +#include "test/rtp_rtcp_observer.h" +#include "test/testsupport/file_utils.h" +#include "video/config/video_encoder_config.h" + +namespace webrtc { +namespace test { + +CallTest::CallTest() + : clock_(Clock::GetRealTimeClock()), + task_queue_factory_(CreateDefaultTaskQueueFactory()), + send_event_log_(std::make_unique<RtcEventLogNull>()), + recv_event_log_(std::make_unique<RtcEventLogNull>()), + audio_send_config_(/*send_transport=*/nullptr), + audio_send_stream_(nullptr), + frame_generator_capturer_(nullptr), + fake_encoder_factory_([this]() { + std::unique_ptr<FakeEncoder> fake_encoder; + if (video_encoder_configs_[0].codec_type == kVideoCodecVP8) { + fake_encoder = std::make_unique<FakeVp8Encoder>(clock_); + } else { + fake_encoder = std::make_unique<FakeEncoder>(clock_); + } + fake_encoder->SetMaxBitrate(fake_encoder_max_bitrate_); + return fake_encoder; + }), + fake_decoder_factory_([]() { return std::make_unique<FakeDecoder>(); }), + bitrate_allocator_factory_(CreateBuiltinVideoBitrateAllocatorFactory()), + num_video_streams_(1), + num_audio_streams_(0), + num_flexfec_streams_(0), + audio_decoder_factory_(CreateBuiltinAudioDecoderFactory()), + audio_encoder_factory_(CreateBuiltinAudioEncoderFactory()), + task_queue_(task_queue_factory_->CreateTaskQueue( + "CallTestTaskQueue", + TaskQueueFactory::Priority::NORMAL)) {} + +CallTest::~CallTest() = default; + +void CallTest::RegisterRtpExtension(const RtpExtension& extension) { + for (const RtpExtension& registered_extension : rtp_extensions_) { + if (registered_extension.id == extension.id) { + ASSERT_EQ(registered_extension.uri, extension.uri) + << "Different URIs associated with ID " << extension.id << "."; + ASSERT_EQ(registered_extension.encrypt, extension.encrypt) + << "Encryption mismatch associated with ID " << extension.id << "."; + return; + } else { // Different IDs. + // Different IDs referring to the same extension probably indicate + // a mistake in the test. + ASSERT_FALSE(registered_extension.uri == extension.uri && + registered_extension.encrypt == extension.encrypt) + << "URI " << extension.uri + << (extension.encrypt ? " with " : " without ") + << "encryption already registered with a different " + "ID (" + << extension.id << " vs. " << registered_extension.id << ")."; + } + } + rtp_extensions_.push_back(extension); +} + +void CallTest::RunBaseTest(BaseTest* test) { + SendTask(task_queue(), [this, test]() { + num_video_streams_ = test->GetNumVideoStreams(); + num_audio_streams_ = test->GetNumAudioStreams(); + num_flexfec_streams_ = test->GetNumFlexfecStreams(); + RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0); + Call::Config send_config(send_event_log_.get()); + test->ModifySenderBitrateConfig(&send_config.bitrate_config); + if (num_audio_streams_ > 0) { + CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer()); + test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(), + fake_recv_audio_device_.get()); + apm_send_ = AudioProcessingBuilder().Create(); + apm_recv_ = AudioProcessingBuilder().Create(); + EXPECT_EQ(0, fake_send_audio_device_->Init()); + EXPECT_EQ(0, fake_recv_audio_device_->Init()); + AudioState::Config audio_state_config; + audio_state_config.audio_mixer = AudioMixerImpl::Create(); + audio_state_config.audio_processing = apm_send_; + audio_state_config.audio_device_module = fake_send_audio_device_; + send_config.audio_state = AudioState::Create(audio_state_config); + fake_send_audio_device_->RegisterAudioCallback( + send_config.audio_state->audio_transport()); + } + CreateSenderCall(send_config); + if (test->ShouldCreateReceivers()) { + Call::Config recv_config(recv_event_log_.get()); + test->ModifyReceiverBitrateConfig(&recv_config.bitrate_config); + if (num_audio_streams_ > 0) { + AudioState::Config audio_state_config; + audio_state_config.audio_mixer = AudioMixerImpl::Create(); + audio_state_config.audio_processing = apm_recv_; + audio_state_config.audio_device_module = fake_recv_audio_device_; + recv_config.audio_state = AudioState::Create(audio_state_config); + fake_recv_audio_device_->RegisterAudioCallback( + recv_config.audio_state->audio_transport()); + } + CreateReceiverCall(recv_config); + } + test->OnCallsCreated(sender_call_.get(), receiver_call_.get()); + CreateReceiveTransport(test->GetReceiveTransportConfig(), test); + CreateSendTransport(test->GetSendTransportConfig(), test); + test->OnTransportCreated(send_transport_.get(), send_simulated_network_, + receive_transport_.get(), + receive_simulated_network_); + if (test->ShouldCreateReceivers()) { + if (num_video_streams_ > 0) + receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); + if (num_audio_streams_ > 0) + receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp); + } else { + // Sender-only call delivers to itself. + send_transport_->SetReceiver(sender_call_->Receiver()); + receive_transport_->SetReceiver(nullptr); + } + + CreateSendConfig(num_video_streams_, num_audio_streams_, + num_flexfec_streams_, send_transport_.get()); + if (test->ShouldCreateReceivers()) { + CreateMatchingReceiveConfigs(); + } + if (num_video_streams_ > 0) { + test->ModifyVideoConfigs(GetVideoSendConfig(), &video_receive_configs_, + GetVideoEncoderConfig()); + } + if (num_audio_streams_ > 0) { + test->ModifyAudioConfigs(&audio_send_config_, &audio_receive_configs_); + } + if (num_flexfec_streams_ > 0) { + test->ModifyFlexfecConfigs(&flexfec_receive_configs_); + } + + if (num_flexfec_streams_ > 0) { + CreateFlexfecStreams(); + test->OnFlexfecStreamsCreated(flexfec_receive_streams_); + } + if (num_video_streams_ > 0) { + CreateVideoStreams(); + test->OnVideoStreamsCreated(GetVideoSendStream(), video_receive_streams_); + } + if (num_audio_streams_ > 0) { + CreateAudioStreams(); + test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_); + } + + if (num_video_streams_ > 0) { + int width = kDefaultWidth; + int height = kDefaultHeight; + int frame_rate = kDefaultFramerate; + test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate); + test->ModifyVideoDegradationPreference(°radation_preference_); + CreateFrameGeneratorCapturer(frame_rate, width, height); + test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_); + } + + Start(); + }); + + test->PerformTest(); + + SendTask(task_queue(), [this, test]() { + Stop(); + test->OnStreamsStopped(); + DestroyStreams(); + send_transport_.reset(); + receive_transport_.reset(); + + frame_generator_capturer_ = nullptr; + DestroyCalls(); + + fake_send_audio_device_ = nullptr; + fake_recv_audio_device_ = nullptr; + }); +} + +void CallTest::CreateCalls() { + CreateCalls(Call::Config(send_event_log_.get()), + Call::Config(recv_event_log_.get())); +} + +void CallTest::CreateCalls(const Call::Config& sender_config, + const Call::Config& receiver_config) { + CreateSenderCall(sender_config); + CreateReceiverCall(receiver_config); +} + +void CallTest::CreateSenderCall() { + CreateSenderCall(Call::Config(send_event_log_.get())); +} + +void CallTest::CreateSenderCall(const Call::Config& config) { + auto sender_config = config; + sender_config.task_queue_factory = task_queue_factory_.get(); + sender_config.network_state_predictor_factory = + network_state_predictor_factory_.get(); + sender_config.network_controller_factory = network_controller_factory_.get(); + sender_config.trials = &field_trials_; + sender_call_.reset(Call::Create(sender_config)); +} + +void CallTest::CreateReceiverCall(const Call::Config& config) { + auto receiver_config = config; + receiver_config.task_queue_factory = task_queue_factory_.get(); + receiver_config.trials = &field_trials_; + receiver_call_.reset(Call::Create(receiver_config)); +} + +void CallTest::DestroyCalls() { + send_transport_.reset(); + receive_transport_.reset(); + sender_call_.reset(); + receiver_call_.reset(); +} + +void CallTest::CreateVideoSendConfig(VideoSendStream::Config* video_config, + size_t num_video_streams, + size_t num_used_ssrcs, + Transport* send_transport) { + RTC_DCHECK_LE(num_video_streams + num_used_ssrcs, kNumSsrcs); + *video_config = VideoSendStream::Config(send_transport); + video_config->encoder_settings.encoder_factory = &fake_encoder_factory_; + video_config->encoder_settings.bitrate_allocator_factory = + bitrate_allocator_factory_.get(); + video_config->rtp.payload_name = "FAKE"; + video_config->rtp.payload_type = kFakeVideoSendPayloadType; + video_config->rtp.extmap_allow_mixed = true; + AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri, + &video_config->rtp.extensions); + AddRtpExtensionByUri(RtpExtension::kAbsSendTimeUri, + &video_config->rtp.extensions); + AddRtpExtensionByUri(RtpExtension::kTimestampOffsetUri, + &video_config->rtp.extensions); + AddRtpExtensionByUri(RtpExtension::kVideoContentTypeUri, + &video_config->rtp.extensions); + AddRtpExtensionByUri(RtpExtension::kGenericFrameDescriptorUri00, + &video_config->rtp.extensions); + AddRtpExtensionByUri(RtpExtension::kDependencyDescriptorUri, + &video_config->rtp.extensions); + if (video_encoder_configs_.empty()) { + video_encoder_configs_.emplace_back(); + FillEncoderConfiguration(kVideoCodecGeneric, num_video_streams, + &video_encoder_configs_.back()); + } + for (size_t i = 0; i < num_video_streams; ++i) + video_config->rtp.ssrcs.push_back(kVideoSendSsrcs[num_used_ssrcs + i]); + AddRtpExtensionByUri(RtpExtension::kVideoRotationUri, + &video_config->rtp.extensions); + AddRtpExtensionByUri(RtpExtension::kColorSpaceUri, + &video_config->rtp.extensions); +} + +void CallTest::CreateAudioAndFecSendConfigs(size_t num_audio_streams, + size_t num_flexfec_streams, + Transport* send_transport) { + RTC_DCHECK_LE(num_audio_streams, 1); + RTC_DCHECK_LE(num_flexfec_streams, 1); + if (num_audio_streams > 0) { + AudioSendStream::Config audio_send_config(send_transport); + audio_send_config.rtp.ssrc = kAudioSendSsrc; + AddRtpExtensionByUri(RtpExtension::kTransportSequenceNumberUri, + &audio_send_config.rtp.extensions); + + audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec( + kAudioSendPayloadType, {"opus", 48000, 2, {{"stereo", "1"}}}); + audio_send_config.encoder_factory = audio_encoder_factory_; + SetAudioConfig(audio_send_config); + } + + // TODO(brandtr): Update this when we support multistream protection. + if (num_flexfec_streams > 0) { + SetSendFecConfig({kVideoSendSsrcs[0]}); + } +} + +void CallTest::SetAudioConfig(const AudioSendStream::Config& config) { + audio_send_config_ = config; +} + +void CallTest::SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs) { + GetVideoSendConfig()->rtp.flexfec.payload_type = kFlexfecPayloadType; + GetVideoSendConfig()->rtp.flexfec.ssrc = kFlexfecSendSsrc; + GetVideoSendConfig()->rtp.flexfec.protected_media_ssrcs = video_send_ssrcs; +} + +void CallTest::SetSendUlpFecConfig(VideoSendStream::Config* send_config) { + send_config->rtp.ulpfec.red_payload_type = kRedPayloadType; + send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType; + send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType; +} + +void CallTest::SetReceiveUlpFecConfig( + VideoReceiveStreamInterface::Config* receive_config) { + receive_config->rtp.red_payload_type = kRedPayloadType; + receive_config->rtp.ulpfec_payload_type = kUlpfecPayloadType; + receive_config->rtp.rtx_associated_payload_types[kRtxRedPayloadType] = + kRedPayloadType; +} + +void CallTest::CreateSendConfig(size_t num_video_streams, + size_t num_audio_streams, + size_t num_flexfec_streams, + Transport* send_transport) { + if (num_video_streams > 0) { + video_send_configs_.clear(); + video_send_configs_.emplace_back(nullptr); + CreateVideoSendConfig(&video_send_configs_.back(), num_video_streams, 0, + send_transport); + } + CreateAudioAndFecSendConfigs(num_audio_streams, num_flexfec_streams, + send_transport); +} + +void CallTest::CreateMatchingVideoReceiveConfigs( + const VideoSendStream::Config& video_send_config, + Transport* rtcp_send_transport) { + CreateMatchingVideoReceiveConfigs(video_send_config, rtcp_send_transport, + &fake_decoder_factory_, absl::nullopt, + false, 0); +} + +void CallTest::CreateMatchingVideoReceiveConfigs( + const VideoSendStream::Config& video_send_config, + Transport* rtcp_send_transport, + VideoDecoderFactory* decoder_factory, + absl::optional<size_t> decode_sub_stream, + bool receiver_reference_time_report, + int rtp_history_ms) { + AddMatchingVideoReceiveConfigs( + &video_receive_configs_, video_send_config, rtcp_send_transport, + decoder_factory, decode_sub_stream, receiver_reference_time_report, + rtp_history_ms); +} + +void CallTest::AddMatchingVideoReceiveConfigs( + std::vector<VideoReceiveStreamInterface::Config>* receive_configs, + const VideoSendStream::Config& video_send_config, + Transport* rtcp_send_transport, + VideoDecoderFactory* decoder_factory, + absl::optional<size_t> decode_sub_stream, + bool receiver_reference_time_report, + int rtp_history_ms) { + RTC_DCHECK(!video_send_config.rtp.ssrcs.empty()); + VideoReceiveStreamInterface::Config default_config(rtcp_send_transport); + default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc; + for (const RtpExtension& extension : video_send_config.rtp.extensions) + default_config.rtp.extensions.push_back(extension); + default_config.rtp.nack.rtp_history_ms = rtp_history_ms; + // Enable RTT calculation so NTP time estimator will work. + default_config.rtp.rtcp_xr.receiver_reference_time_report = + receiver_reference_time_report; + default_config.renderer = &fake_renderer_; + + for (size_t i = 0; i < video_send_config.rtp.ssrcs.size(); ++i) { + VideoReceiveStreamInterface::Config video_recv_config( + default_config.Copy()); + video_recv_config.decoders.clear(); + if (!video_send_config.rtp.rtx.ssrcs.empty()) { + video_recv_config.rtp.rtx_ssrc = video_send_config.rtp.rtx.ssrcs[i]; + video_recv_config.rtp.rtx_associated_payload_types[kSendRtxPayloadType] = + video_send_config.rtp.payload_type; + } + video_recv_config.rtp.remote_ssrc = video_send_config.rtp.ssrcs[i]; + VideoReceiveStreamInterface::Decoder decoder; + + decoder.payload_type = video_send_config.rtp.payload_type; + decoder.video_format = SdpVideoFormat(video_send_config.rtp.payload_name); + // Force fake decoders on non-selected simulcast streams. + if (!decode_sub_stream || i == *decode_sub_stream) { + video_recv_config.decoder_factory = decoder_factory; + } else { + video_recv_config.decoder_factory = &fake_decoder_factory_; + } + video_recv_config.decoders.push_back(decoder); + receive_configs->emplace_back(std::move(video_recv_config)); + } +} + +void CallTest::CreateMatchingAudioAndFecConfigs( + Transport* rtcp_send_transport) { + RTC_DCHECK_GE(1, num_audio_streams_); + if (num_audio_streams_ == 1) { + CreateMatchingAudioConfigs(rtcp_send_transport, ""); + } + + // TODO(brandtr): Update this when we support multistream protection. + RTC_DCHECK(num_flexfec_streams_ <= 1); + if (num_flexfec_streams_ == 1) { + CreateMatchingFecConfig(rtcp_send_transport, *GetVideoSendConfig()); + for (const RtpExtension& extension : GetVideoSendConfig()->rtp.extensions) + GetFlexFecConfig()->rtp.extensions.push_back(extension); + } +} + +void CallTest::CreateMatchingAudioConfigs(Transport* transport, + std::string sync_group) { + audio_receive_configs_.push_back(CreateMatchingAudioConfig( + audio_send_config_, audio_decoder_factory_, transport, sync_group)); +} + +AudioReceiveStreamInterface::Config CallTest::CreateMatchingAudioConfig( + const AudioSendStream::Config& send_config, + rtc::scoped_refptr<AudioDecoderFactory> audio_decoder_factory, + Transport* transport, + std::string sync_group) { + AudioReceiveStreamInterface::Config audio_config; + audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc; + audio_config.rtcp_send_transport = transport; + audio_config.rtp.remote_ssrc = send_config.rtp.ssrc; + audio_config.rtp.extensions = send_config.rtp.extensions; + audio_config.decoder_factory = audio_decoder_factory; + audio_config.decoder_map = {{kAudioSendPayloadType, {"opus", 48000, 2}}}; + audio_config.sync_group = sync_group; + return audio_config; +} + +void CallTest::CreateMatchingFecConfig( + Transport* transport, + const VideoSendStream::Config& send_config) { + FlexfecReceiveStream::Config config(transport); + config.payload_type = send_config.rtp.flexfec.payload_type; + config.rtp.remote_ssrc = send_config.rtp.flexfec.ssrc; + config.protected_media_ssrcs = send_config.rtp.flexfec.protected_media_ssrcs; + config.rtp.local_ssrc = kReceiverLocalVideoSsrc; + if (!video_receive_configs_.empty()) { + video_receive_configs_[0].rtp.protected_by_flexfec = true; + video_receive_configs_[0].rtp.packet_sink_ = this; + } + flexfec_receive_configs_.push_back(config); +} + +void CallTest::CreateMatchingReceiveConfigs(Transport* rtcp_send_transport) { + video_receive_configs_.clear(); + for (VideoSendStream::Config& video_send_config : video_send_configs_) { + CreateMatchingVideoReceiveConfigs(video_send_config, rtcp_send_transport); + } + CreateMatchingAudioAndFecConfigs(rtcp_send_transport); +} + +void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock, + float speed, + int framerate, + int width, + int height) { + video_sources_.clear(); + auto frame_generator_capturer = + std::make_unique<test::FrameGeneratorCapturer>( + clock, + test::CreateSquareFrameGenerator(width, height, absl::nullopt, + absl::nullopt), + framerate * speed, *task_queue_factory_); + frame_generator_capturer_ = frame_generator_capturer.get(); + frame_generator_capturer->Init(); + video_sources_.push_back(std::move(frame_generator_capturer)); + ConnectVideoSourcesToStreams(); +} + +void CallTest::CreateFrameGeneratorCapturer(int framerate, + int width, + int height) { + video_sources_.clear(); + auto frame_generator_capturer = + std::make_unique<test::FrameGeneratorCapturer>( + clock_, + test::CreateSquareFrameGenerator(width, height, absl::nullopt, + absl::nullopt), + framerate, *task_queue_factory_); + frame_generator_capturer_ = frame_generator_capturer.get(); + frame_generator_capturer->Init(); + video_sources_.push_back(std::move(frame_generator_capturer)); + ConnectVideoSourcesToStreams(); +} + +void CallTest::CreateFakeAudioDevices( + std::unique_ptr<TestAudioDeviceModule::Capturer> capturer, + std::unique_ptr<TestAudioDeviceModule::Renderer> renderer) { + fake_send_audio_device_ = TestAudioDeviceModule::Create( + task_queue_factory_.get(), std::move(capturer), nullptr, 1.f); + fake_recv_audio_device_ = TestAudioDeviceModule::Create( + task_queue_factory_.get(), nullptr, std::move(renderer), 1.f); +} + +void CallTest::CreateVideoStreams() { + RTC_DCHECK(video_receive_streams_.empty()); + CreateVideoSendStreams(); + for (size_t i = 0; i < video_receive_configs_.size(); ++i) { + video_receive_streams_.push_back(receiver_call_->CreateVideoReceiveStream( + video_receive_configs_[i].Copy())); + } +} + +void CallTest::CreateVideoSendStreams() { + RTC_DCHECK(video_send_streams_.empty()); + + // We currently only support testing external fec controllers with a single + // VideoSendStream. + if (fec_controller_factory_.get()) { + RTC_DCHECK_LE(video_send_configs_.size(), 1); + } + + // TODO(http://crbug/818127): + // Remove this workaround when ALR is not screenshare-specific. + std::list<size_t> streams_creation_order; + for (size_t i = 0; i < video_send_configs_.size(); ++i) { + // If dual streams are created, add the screenshare stream last. + if (video_encoder_configs_[i].content_type == + VideoEncoderConfig::ContentType::kScreen) { + streams_creation_order.push_back(i); + } else { + streams_creation_order.push_front(i); + } + } + + video_send_streams_.resize(video_send_configs_.size(), nullptr); + + for (size_t i : streams_creation_order) { + if (fec_controller_factory_.get()) { + video_send_streams_[i] = sender_call_->CreateVideoSendStream( + video_send_configs_[i].Copy(), video_encoder_configs_[i].Copy(), + fec_controller_factory_->CreateFecController()); + } else { + video_send_streams_[i] = sender_call_->CreateVideoSendStream( + video_send_configs_[i].Copy(), video_encoder_configs_[i].Copy()); + } + } +} + +void CallTest::CreateVideoSendStream(const VideoEncoderConfig& encoder_config) { + RTC_DCHECK(video_send_streams_.empty()); + video_send_streams_.push_back(sender_call_->CreateVideoSendStream( + GetVideoSendConfig()->Copy(), encoder_config.Copy())); +} + +void CallTest::CreateAudioStreams() { + RTC_DCHECK(audio_send_stream_ == nullptr); + RTC_DCHECK(audio_receive_streams_.empty()); + audio_send_stream_ = sender_call_->CreateAudioSendStream(audio_send_config_); + for (size_t i = 0; i < audio_receive_configs_.size(); ++i) { + audio_receive_streams_.push_back( + receiver_call_->CreateAudioReceiveStream(audio_receive_configs_[i])); + } +} + +void CallTest::CreateFlexfecStreams() { + for (size_t i = 0; i < flexfec_receive_configs_.size(); ++i) { + flexfec_receive_streams_.push_back( + receiver_call_->CreateFlexfecReceiveStream( + flexfec_receive_configs_[i])); + } +} + +void CallTest::CreateSendTransport(const BuiltInNetworkBehaviorConfig& config, + RtpRtcpObserver* observer) { + PacketReceiver* receiver = + receiver_call_ ? receiver_call_->Receiver() : nullptr; + + auto network = std::make_unique<SimulatedNetwork>(config); + send_simulated_network_ = network.get(); + send_transport_ = std::make_unique<PacketTransport>( + task_queue(), sender_call_.get(), observer, + test::PacketTransport::kSender, payload_type_map_, + std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(), + std::move(network), receiver), + rtp_extensions_, rtp_extensions_); +} + +void CallTest::CreateReceiveTransport( + const BuiltInNetworkBehaviorConfig& config, + RtpRtcpObserver* observer) { + auto network = std::make_unique<SimulatedNetwork>(config); + receive_simulated_network_ = network.get(); + receive_transport_ = std::make_unique<PacketTransport>( + task_queue(), nullptr, observer, test::PacketTransport::kReceiver, + payload_type_map_, + std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(), + std::move(network), + sender_call_->Receiver()), + rtp_extensions_, rtp_extensions_); +} + +void CallTest::ConnectVideoSourcesToStreams() { + for (size_t i = 0; i < video_sources_.size(); ++i) + video_send_streams_[i]->SetSource(video_sources_[i].get(), + degradation_preference_); +} + +void CallTest::Start() { + StartVideoStreams(); + if (audio_send_stream_) { + audio_send_stream_->Start(); + } + for (AudioReceiveStreamInterface* audio_recv_stream : audio_receive_streams_) + audio_recv_stream->Start(); +} + +void CallTest::StartVideoStreams() { + for (size_t i = 0; i < video_send_streams_.size(); ++i) { + std::vector<bool> active_rtp_streams( + video_send_configs_[i].rtp.ssrcs.size(), true); + video_send_streams_[i]->StartPerRtpStream(active_rtp_streams); + } + for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_) + video_recv_stream->Start(); +} + +void CallTest::Stop() { + for (AudioReceiveStreamInterface* audio_recv_stream : audio_receive_streams_) + audio_recv_stream->Stop(); + if (audio_send_stream_) { + audio_send_stream_->Stop(); + } + StopVideoStreams(); +} + +void CallTest::StopVideoStreams() { + for (VideoSendStream* video_send_stream : video_send_streams_) + video_send_stream->Stop(); + for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_) + video_recv_stream->Stop(); +} + +void CallTest::DestroyStreams() { + if (audio_send_stream_) + sender_call_->DestroyAudioSendStream(audio_send_stream_); + audio_send_stream_ = nullptr; + for (AudioReceiveStreamInterface* audio_recv_stream : audio_receive_streams_) + receiver_call_->DestroyAudioReceiveStream(audio_recv_stream); + + DestroyVideoSendStreams(); + + for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_) + receiver_call_->DestroyVideoReceiveStream(video_recv_stream); + + for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_) + receiver_call_->DestroyFlexfecReceiveStream(flexfec_recv_stream); + + video_receive_streams_.clear(); + video_sources_.clear(); +} + +void CallTest::DestroyVideoSendStreams() { + for (VideoSendStream* video_send_stream : video_send_streams_) + sender_call_->DestroyVideoSendStream(video_send_stream); + video_send_streams_.clear(); +} + +void CallTest::SetFakeVideoCaptureRotation(VideoRotation rotation) { + frame_generator_capturer_->SetFakeRotation(rotation); +} + +void CallTest::SetVideoDegradation(DegradationPreference preference) { + GetVideoSendStream()->SetSource(frame_generator_capturer_, preference); +} + +VideoSendStream::Config* CallTest::GetVideoSendConfig() { + return &video_send_configs_[0]; +} + +void CallTest::SetVideoSendConfig(const VideoSendStream::Config& config) { + video_send_configs_.clear(); + video_send_configs_.push_back(config.Copy()); +} + +VideoEncoderConfig* CallTest::GetVideoEncoderConfig() { + return &video_encoder_configs_[0]; +} + +void CallTest::SetVideoEncoderConfig(const VideoEncoderConfig& config) { + video_encoder_configs_.clear(); + video_encoder_configs_.push_back(config.Copy()); +} + +VideoSendStream* CallTest::GetVideoSendStream() { + return video_send_streams_[0]; +} +FlexfecReceiveStream::Config* CallTest::GetFlexFecConfig() { + return &flexfec_receive_configs_[0]; +} + +void CallTest::OnRtpPacket(const RtpPacketReceived& packet) { + // All FlexFEC streams protect all of the video streams. + for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_) + flexfec_recv_stream->OnRtpPacket(packet); +} + +absl::optional<RtpExtension> CallTest::GetRtpExtensionByUri( + const std::string& uri) const { + for (const auto& extension : rtp_extensions_) { + if (extension.uri == uri) { + return extension; + } + } + return absl::nullopt; +} + +void CallTest::AddRtpExtensionByUri( + const std::string& uri, + std::vector<RtpExtension>* extensions) const { + const absl::optional<RtpExtension> extension = GetRtpExtensionByUri(uri); + if (extension) { + extensions->push_back(*extension); + } +} + +constexpr size_t CallTest::kNumSsrcs; +const int CallTest::kDefaultWidth; +const int CallTest::kDefaultHeight; +const int CallTest::kDefaultFramerate; +const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = { + 0xBADCAFD, 0xBADCAFE, 0xBADCAFF, 0xBADCB00, 0xBADCB01, 0xBADCB02}; +const uint32_t CallTest::kVideoSendSsrcs[kNumSsrcs] = { + 0xC0FFED, 0xC0FFEE, 0xC0FFEF, 0xC0FFF0, 0xC0FFF1, 0xC0FFF2}; +const uint32_t CallTest::kAudioSendSsrc = 0xDEADBEEF; +const uint32_t CallTest::kFlexfecSendSsrc = 0xBADBEEF; +const uint32_t CallTest::kReceiverLocalVideoSsrc = 0x123456; +const uint32_t CallTest::kReceiverLocalAudioSsrc = 0x1234567; +const int CallTest::kNackRtpHistoryMs = 1000; + +const std::map<uint8_t, MediaType> CallTest::payload_type_map_ = { + {CallTest::kVideoSendPayloadType, MediaType::VIDEO}, + {CallTest::kFakeVideoSendPayloadType, MediaType::VIDEO}, + {CallTest::kSendRtxPayloadType, MediaType::VIDEO}, + {CallTest::kPayloadTypeVP8, MediaType::VIDEO}, + {CallTest::kPayloadTypeVP9, MediaType::VIDEO}, + {CallTest::kPayloadTypeH264, MediaType::VIDEO}, + {CallTest::kPayloadTypeGeneric, MediaType::VIDEO}, + {CallTest::kRedPayloadType, MediaType::VIDEO}, + {CallTest::kRtxRedPayloadType, MediaType::VIDEO}, + {CallTest::kUlpfecPayloadType, MediaType::VIDEO}, + {CallTest::kFlexfecPayloadType, MediaType::VIDEO}, + {CallTest::kAudioSendPayloadType, MediaType::AUDIO}}; + +BaseTest::BaseTest() {} + +BaseTest::BaseTest(TimeDelta timeout) : RtpRtcpObserver(timeout) {} + +BaseTest::~BaseTest() {} + +std::unique_ptr<TestAudioDeviceModule::Capturer> BaseTest::CreateCapturer() { + return TestAudioDeviceModule::CreatePulsedNoiseCapturer(256, 48000); +} + +std::unique_ptr<TestAudioDeviceModule::Renderer> BaseTest::CreateRenderer() { + return TestAudioDeviceModule::CreateDiscardRenderer(48000); +} + +void BaseTest::OnFakeAudioDevicesCreated( + TestAudioDeviceModule* send_audio_device, + TestAudioDeviceModule* recv_audio_device) {} + +void BaseTest::ModifySenderBitrateConfig(BitrateConstraints* bitrate_config) {} + +void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) { +} + +void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {} + +void BaseTest::OnTransportCreated(PacketTransport* to_receiver, + SimulatedNetworkInterface* sender_network, + PacketTransport* to_sender, + SimulatedNetworkInterface* receiver_network) { +} + +BuiltInNetworkBehaviorConfig BaseTest::GetSendTransportConfig() const { + return BuiltInNetworkBehaviorConfig(); +} +BuiltInNetworkBehaviorConfig BaseTest::GetReceiveTransportConfig() const { + return BuiltInNetworkBehaviorConfig(); +} +size_t BaseTest::GetNumVideoStreams() const { + return 1; +} + +size_t BaseTest::GetNumAudioStreams() const { + return 0; +} + +size_t BaseTest::GetNumFlexfecStreams() const { + return 0; +} + +void BaseTest::ModifyVideoConfigs( + VideoSendStream::Config* send_config, + std::vector<VideoReceiveStreamInterface::Config>* receive_configs, + VideoEncoderConfig* encoder_config) {} + +void BaseTest::ModifyVideoCaptureStartResolution(int* width, + int* heigt, + int* frame_rate) {} + +void BaseTest::ModifyVideoDegradationPreference( + DegradationPreference* degradation_preference) {} + +void BaseTest::OnVideoStreamsCreated( + VideoSendStream* send_stream, + const std::vector<VideoReceiveStreamInterface*>& receive_streams) {} + +void BaseTest::ModifyAudioConfigs( + AudioSendStream::Config* send_config, + std::vector<AudioReceiveStreamInterface::Config>* receive_configs) {} + +void BaseTest::OnAudioStreamsCreated( + AudioSendStream* send_stream, + const std::vector<AudioReceiveStreamInterface*>& receive_streams) {} + +void BaseTest::ModifyFlexfecConfigs( + std::vector<FlexfecReceiveStream::Config>* receive_configs) {} + +void BaseTest::OnFlexfecStreamsCreated( + const std::vector<FlexfecReceiveStream*>& receive_streams) {} + +void BaseTest::OnFrameGeneratorCapturerCreated( + FrameGeneratorCapturer* frame_generator_capturer) {} + +void BaseTest::OnStreamsStopped() {} + +SendTest::SendTest(TimeDelta timeout) : BaseTest(timeout) {} + +bool SendTest::ShouldCreateReceivers() const { + return false; +} + +EndToEndTest::EndToEndTest() {} + +EndToEndTest::EndToEndTest(TimeDelta timeout) : BaseTest(timeout) {} + +bool EndToEndTest::ShouldCreateReceivers() const { + return true; +} + +} // namespace test +} // namespace webrtc |