From 3b96f2c770df7691df90c2cc1be40509a76ae425 Mon Sep 17 00:00:00 2001 From: Per K Date: Wed, 18 Jan 2023 14:06:19 +0100 Subject: [PATCH] Change CallTests to use new PacketReceiver::DeliverRtp and PacketReceiver::DeliverRtcp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PacketReceiver::DeliverRtp requires delivered packets to have extensions already mapped. Therefore DirectTransport is provided with the extension mapping. CallTests and tests derived from CallTest create transports in different ways, this cl change CallTest to create tests in only one way to simplify how extensions are provided to the transport but at the same time still allows different network behaviour. Change-Id: Ie8b3ad947c170be61e62c02dadf4adedbb3841f1 Bug: webrtc:7135, webrtc:14795 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/290980 Reviewed-by: Jakob Ivarsson‎ Commit-Queue: Per Kjellander Reviewed-by: Erik Språng Cr-Commit-Position: refs/heads/main@{#39137} --- audio/test/audio_bwe_integration_test.cc | 21 ---- audio/test/audio_bwe_integration_test.h | 6 - audio/test/audio_end_to_end_test.cc | 27 +---- audio/test/audio_end_to_end_test.h | 8 -- audio/test/audio_stats_test.cc | 2 +- audio/test/low_bandwidth_audio_test.cc | 2 +- audio/test/nack_test.cc | 2 +- audio/test/non_sender_rtt_test.cc | 2 +- call/bitrate_estimator_tests.cc | 26 +---- call/call_perf_tests.cc | 77 +++++-------- call/rampup_tests.cc | 25 +++-- call/rampup_tests.h | 10 +- test/BUILD.gn | 2 + test/call_test.cc | 77 ++++++++----- test/call_test.h | 44 +++++++- test/direct_transport.cc | 66 +++++++++-- test/direct_transport.h | 17 ++- test/layer_filtering_transport.cc | 19 +++- test/layer_filtering_transport.h | 8 +- test/rtp_rtcp_observer.h | 16 ++- video/end_to_end_tests/bandwidth_tests.cc | 44 ++++---- .../end_to_end_tests/call_operation_tests.cc | 62 +++-------- .../extended_reports_tests.cc | 23 ++-- video/end_to_end_tests/fec_tests.cc | 22 +--- .../multi_codec_receive_tests.cc | 26 +---- video/end_to_end_tests/multi_stream_tester.cc | 7 +- video/end_to_end_tests/network_state_tests.cc | 36 +++--- .../end_to_end_tests/retransmission_tests.cc | 14 +-- video/end_to_end_tests/rtp_rtcp_tests.cc | 104 ++++++------------ video/end_to_end_tests/ssrc_tests.cc | 48 +++++--- video/end_to_end_tests/stats_tests.cc | 75 ++++--------- .../transport_feedback_tests.cc | 16 ++- video/picture_id_tests.cc | 10 +- video/video_analyzer.cc | 33 +++--- video/video_analyzer.h | 8 +- video/video_quality_test.cc | 35 +++--- video/video_quality_test.h | 2 - video/video_send_stream_tests.cc | 46 ++------ 38 files changed, 477 insertions(+), 591 deletions(-) diff --git a/audio/test/audio_bwe_integration_test.cc b/audio/test/audio_bwe_integration_test.cc index 50a4b6759c..fd68cbd627 100644 --- a/audio/test/audio_bwe_integration_test.cc +++ b/audio/test/audio_bwe_integration_test.cc @@ -58,27 +58,6 @@ void AudioBweTest::OnFakeAudioDevicesCreated( send_audio_device_ = send_audio_device; } -std::unique_ptr AudioBweTest::CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) { - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - test::CallTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(GetNetworkPipeConfig()))); -} - -std::unique_ptr AudioBweTest::CreateReceiveTransport( - TaskQueueBase* task_queue) { - return std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - test::CallTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(GetNetworkPipeConfig()))); -} - void AudioBweTest::PerformTest() { send_audio_device_->WaitForRecordingEnd(); SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraProcessTimeMs); diff --git a/audio/test/audio_bwe_integration_test.h b/audio/test/audio_bwe_integration_test.h index 613efcc1dd..132ab0a3a5 100644 --- a/audio/test/audio_bwe_integration_test.h +++ b/audio/test/audio_bwe_integration_test.h @@ -39,12 +39,6 @@ class AudioBweTest : public test::EndToEndTest { TestAudioDeviceModule* send_audio_device, TestAudioDeviceModule* recv_audio_device) override; - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override; - std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue) override; - void PerformTest() override; private: diff --git a/audio/test/audio_end_to_end_test.cc b/audio/test/audio_end_to_end_test.cc index de9cf7d56f..b7dfdb89f6 100644 --- a/audio/test/audio_end_to_end_test.cc +++ b/audio/test/audio_end_to_end_test.cc @@ -31,10 +31,6 @@ constexpr int kSampleRate = 48000; AudioEndToEndTest::AudioEndToEndTest() : EndToEndTest(CallTest::kDefaultTimeout) {} -BuiltInNetworkBehaviorConfig AudioEndToEndTest::GetNetworkPipeConfig() const { - return BuiltInNetworkBehaviorConfig(); -} - size_t AudioEndToEndTest::GetNumVideoStreams() const { return 0; } @@ -63,27 +59,6 @@ void AudioEndToEndTest::OnFakeAudioDevicesCreated( send_audio_device_ = send_audio_device; } -std::unique_ptr AudioEndToEndTest::CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) { - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - test::CallTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(GetNetworkPipeConfig()))); -} - -std::unique_ptr -AudioEndToEndTest::CreateReceiveTransport(TaskQueueBase* task_queue) { - return std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - test::CallTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(GetNetworkPipeConfig()))); -} - void AudioEndToEndTest::ModifyAudioConfigs( AudioSendStream::Config* send_config, std::vector* receive_configs) { @@ -110,7 +85,7 @@ void AudioEndToEndTest::PerformTest() { // Wait until the input audio file is done... send_audio_device_->WaitForRecordingEnd(); // and some extra time to account for network delay. - SleepMs(GetNetworkPipeConfig().queue_delay_ms + kExtraRecordTimeMs); + SleepMs(GetSendTransportConfig().queue_delay_ms + kExtraRecordTimeMs); } } // namespace test } // namespace webrtc diff --git a/audio/test/audio_end_to_end_test.h b/audio/test/audio_end_to_end_test.h index 6afa0baea3..607fe692be 100644 --- a/audio/test/audio_end_to_end_test.h +++ b/audio/test/audio_end_to_end_test.h @@ -32,8 +32,6 @@ class AudioEndToEndTest : public test::EndToEndTest { return receive_stream_; } - virtual BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const; - size_t GetNumVideoStreams() const override; size_t GetNumAudioStreams() const override; size_t GetNumFlexfecStreams() const override; @@ -45,12 +43,6 @@ class AudioEndToEndTest : public test::EndToEndTest { TestAudioDeviceModule* send_audio_device, TestAudioDeviceModule* recv_audio_device) override; - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override; - std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue) override; - void ModifyAudioConfigs(AudioSendStream::Config* send_config, std::vector* receive_configs) override; diff --git a/audio/test/audio_stats_test.cc b/audio/test/audio_stats_test.cc index c637bff94e..1c81432574 100644 --- a/audio/test/audio_stats_test.cc +++ b/audio/test/audio_stats_test.cc @@ -32,7 +32,7 @@ class NoLossTest : public AudioEndToEndTest { NoLossTest() = default; - BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { BuiltInNetworkBehaviorConfig pipe_config; pipe_config.queue_delay_ms = kRttMs / 2; return pipe_config; diff --git a/audio/test/low_bandwidth_audio_test.cc b/audio/test/low_bandwidth_audio_test.cc index 948dcbc8f2..f385eb9dcc 100644 --- a/audio/test/low_bandwidth_audio_test.cc +++ b/audio/test/low_bandwidth_audio_test.cc @@ -84,7 +84,7 @@ class Mobile2GNetworkTest : public AudioQualityTest { {{"maxaveragebitrate", "6000"}, {"ptime", "60"}, {"stereo", "1"}}}); } - BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { BuiltInNetworkBehaviorConfig pipe_config; pipe_config.link_capacity_kbps = 12; pipe_config.queue_length_packets = 1500; diff --git a/audio/test/nack_test.cc b/audio/test/nack_test.cc index f383627dbe..c4bfe8306f 100644 --- a/audio/test/nack_test.cc +++ b/audio/test/nack_test.cc @@ -25,7 +25,7 @@ TEST_F(NackTest, ShouldNackInLossyNetwork) { const int64_t kLossPercent = 30; const int kNackHistoryMs = 1000; - BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { BuiltInNetworkBehaviorConfig pipe_config; pipe_config.queue_delay_ms = kRttMs / 2; pipe_config.loss_percent = kLossPercent; diff --git a/audio/test/non_sender_rtt_test.cc b/audio/test/non_sender_rtt_test.cc index 07de99ac37..0c7dc6cbee 100644 --- a/audio/test/non_sender_rtt_test.cc +++ b/audio/test/non_sender_rtt_test.cc @@ -23,7 +23,7 @@ TEST_F(NonSenderRttTest, NonSenderRttStats) { const int kTestDurationMs = 10000; const int64_t kRttMs = 30; - BuiltInNetworkBehaviorConfig GetNetworkPipeConfig() const override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { BuiltInNetworkBehaviorConfig pipe_config; pipe_config.queue_delay_ms = kRttMs / 2; return pipe_config; diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc index 5fb05e59d9..afa3136e0a 100644 --- a/call/bitrate_estimator_tests.cc +++ b/call/bitrate_estimator_tests.cc @@ -7,6 +7,7 @@ * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ +#include #include #include #include @@ -15,7 +16,6 @@ #include "absl/strings/string_view.h" #include "api/test/create_frame_generator.h" #include "call/call.h" -#include "call/fake_network_pipe.h" #include "call/simulated_network.h" #include "rtc_base/checks.h" #include "rtc_base/event.h" @@ -24,7 +24,6 @@ #include "rtc_base/task_queue_for_test.h" #include "rtc_base/thread_annotations.h" #include "test/call_test.h" -#include "test/direct_transport.h" #include "test/encoder_settings.h" #include "test/fake_decoder.h" #include "test/fake_encoder.h" @@ -113,20 +112,9 @@ class BitrateEstimatorTest : public test::CallTest { SendTask(task_queue(), [this]() { CreateCalls(); - send_transport_.reset(new test::DirectTransport( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())), - sender_call_.get(), payload_type_map_)); - send_transport_->SetReceiver(receiver_call_->Receiver()); - receive_transport_.reset(new test::DirectTransport( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())), - receiver_call_.get(), payload_type_map_)); - receive_transport_->SetReceiver(sender_call_->Receiver()); + CreateSendTransport(BuiltInNetworkBehaviorConfig(), /*observer=*/nullptr); + CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), + /*observer=*/nullptr); VideoSendStream::Config video_send_config(send_transport_.get()); video_send_config.rtp.ssrcs.push_back(kVideoSendSsrcs[0]); @@ -160,10 +148,6 @@ class BitrateEstimatorTest : public test::CallTest { delete stream; } streams_.clear(); - - send_transport_.reset(); - receive_transport_.reset(); - DestroyCalls(); }); } @@ -245,8 +229,6 @@ class BitrateEstimatorTest : public test::CallTest { }; LogObserver receiver_log_; - std::unique_ptr send_transport_; - std::unique_ptr receive_transport_; VideoReceiveStreamInterface::Config receive_config_; std::vector streams_; }; diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc index 218ab7c9a8..a50f5ee605 100644 --- a/call/call_perf_tests.cc +++ b/call/call_perf_tests.cc @@ -243,23 +243,26 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec, test::PacketTransport::kSender, audio_pt_map, std::make_unique( Clock::GetRealTimeClock(), - std::make_unique(audio_net_config))); + std::make_unique(audio_net_config)), + GetRegisteredExtensions(), GetRegisteredExtensions()); audio_send_transport->SetReceiver(receiver_call_->Receiver()); video_send_transport = std::make_unique( task_queue(), sender_call_.get(), observer.get(), test::PacketTransport::kSender, video_pt_map, - std::make_unique(Clock::GetRealTimeClock(), - std::make_unique( - BuiltInNetworkBehaviorConfig()))); + std::make_unique( + Clock::GetRealTimeClock(), + std::make_unique(BuiltInNetworkBehaviorConfig())), + GetRegisteredExtensions(), GetRegisteredExtensions()); video_send_transport->SetReceiver(receiver_call_->Receiver()); receive_transport = std::make_unique( task_queue(), receiver_call_.get(), observer.get(), test::PacketTransport::kReceiver, payload_type_map_, - std::make_unique(Clock::GetRealTimeClock(), - std::make_unique( - BuiltInNetworkBehaviorConfig()))); + std::make_unique( + Clock::GetRealTimeClock(), + std::make_unique(BuiltInNetworkBehaviorConfig())), + GetRegisteredExtensions(), GetRegisteredExtensions()); receive_transport->SetReceiver(sender_call_->Receiver()); CreateSendConfig(1, 0, 0, video_send_transport.get()); @@ -412,25 +415,12 @@ void CallPerfTest::TestCaptureNtpTime( rtp_start_timestamp_(0) {} private: - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(net_config_))); + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { + return net_config_; } - std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue) override { - return std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(net_config_))); + BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const override { + return net_config_; } void OnFrame(const VideoFrame& video_frame) override { @@ -946,35 +936,26 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from, task_queue_(task_queue) {} protected: - BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() { + BuiltInNetworkBehaviorConfig GetFakeNetworkPipeConfig() const { BuiltInNetworkBehaviorConfig pipe_config; pipe_config.link_capacity_kbps = test_bitrate_from_; return pipe_config; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { - auto network = - std::make_unique(GetFakeNetworkPipeConfig()); - send_simulated_network_ = network.get(); - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - test::CallTest::payload_type_map_, - std::make_unique(Clock::GetRealTimeClock(), - std::move(network))); + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { + return GetFakeNetworkPipeConfig(); + } + BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const override { + return GetFakeNetworkPipeConfig(); } - std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue) override { - auto network = - std::make_unique(GetFakeNetworkPipeConfig()); - receive_simulated_network_ = network.get(); - return std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - test::CallTest::payload_type_map_, - std::make_unique(Clock::GetRealTimeClock(), - std::move(network))); + void OnTransportCreated( + test::PacketTransport* to_receiver, + SimulatedNetworkInterface* sender_network, + test::PacketTransport* to_sender, + SimulatedNetworkInterface* receiver_network) override { + send_simulated_network_ = sender_network; + receive_simulated_network_ = receiver_network; } void PerformTest() override { @@ -1048,8 +1029,8 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from, const int min_bwe_; const int start_bwe_; const int max_bwe_; - SimulatedNetwork* send_simulated_network_; - SimulatedNetwork* receive_simulated_network_; + SimulatedNetworkInterface* send_simulated_network_; + SimulatedNetworkInterface* receive_simulated_network_; Call* sender_call_; TaskQueueBase* const task_queue_; } test(test_bitrate_from, test_bitrate_to, test_bitrate_step, min_bwe, diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc index 4c4d56fc3c..c2848b47a2 100644 --- a/call/rampup_tests.cc +++ b/call/rampup_tests.cc @@ -113,18 +113,8 @@ void RampUpTester::OnVideoStreamsCreated( send_stream_ = send_stream; } -std::unique_ptr RampUpTester::CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) { - auto network = std::make_unique(forward_transport_config_); - send_simulated_network_ = network.get(); - auto send_transport = std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - test::CallTest::payload_type_map_, - std::make_unique(Clock::GetRealTimeClock(), - std::move(network))); - send_transport_ = send_transport.get(); - return send_transport; +BuiltInNetworkBehaviorConfig RampUpTester::GetSendTransportConfig() const { + return forward_transport_config_; } size_t RampUpTester::GetNumVideoStreams() const { @@ -310,6 +300,17 @@ void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) { }); } +void RampUpTester::OnTransportCreated( + test::PacketTransport* to_receiver, + SimulatedNetworkInterface* sender_network, + test::PacketTransport* to_sender, + SimulatedNetworkInterface* receiver_network) { + RTC_DCHECK_RUN_ON(task_queue_); + + send_transport_ = to_receiver; + send_simulated_network_ = sender_network; +} + void RampUpTester::PollStats() { RTC_DCHECK_RUN_ON(task_queue_); diff --git a/call/rampup_tests.h b/call/rampup_tests.h index de0022c994..952ae6f7f8 100644 --- a/call/rampup_tests.h +++ b/call/rampup_tests.h @@ -83,7 +83,7 @@ class RampUpTester : public test::EndToEndTest { Call* sender_call_; VideoSendStream* send_stream_; test::PacketTransport* send_transport_; - SimulatedNetwork* send_simulated_network_; + SimulatedNetworkInterface* send_simulated_network_; private: typedef std::map SsrcMap; @@ -93,9 +93,7 @@ class RampUpTester : public test::EndToEndTest { void OnVideoStreamsCreated(VideoSendStream* send_stream, const std::vector& receive_streams) override; - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override; + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override; void ModifyVideoConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, @@ -106,6 +104,10 @@ class RampUpTester : public test::EndToEndTest { void ModifyFlexfecConfigs( std::vector* receive_configs) override; void OnCallsCreated(Call* sender_call, Call* receiver_call) override; + void OnTransportCreated(test::PacketTransport* to_receiver, + SimulatedNetworkInterface* sender_network, + test::PacketTransport* to_sender, + SimulatedNetworkInterface* receiver_network) override; const int start_bitrate_bps_; const int64_t min_run_time_ms_; diff --git a/test/BUILD.gn b/test/BUILD.gn index 86ab7cc9b7..0c71115f0d 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -863,6 +863,7 @@ rtc_library("direct_transport") { "direct_transport.h", ] deps = [ + "../api:rtp_parameters", "../api:sequence_checker", "../api:simulated_network_api", "../api:transport_api", @@ -871,6 +872,7 @@ rtc_library("direct_transport") { "../call:call_interfaces", "../call:simulated_packet_receiver", "../modules/rtp_rtcp:rtp_rtcp_format", + "../rtc_base:checks", "../rtc_base:macromagic", "../rtc_base:timeutils", "../rtc_base/synchronization:mutex", diff --git a/test/call_test.cc b/test/call_test.cc index 60b415d87f..92f8d7de71 100644 --- a/test/call_test.cc +++ b/test/call_test.cc @@ -20,12 +20,14 @@ #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" @@ -126,13 +128,12 @@ void CallTest::RunBaseTest(BaseTest* test) { CreateReceiverCall(recv_config); } test->OnCallsCreated(sender_call_.get(), receiver_call_.get()); - receive_transport_ = test->CreateReceiveTransport(task_queue()); - send_transport_ = - test->CreateSendTransport(task_queue(), sender_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()) { - send_transport_->SetReceiver(receiver_call_->Receiver()); - receive_transport_->SetReceiver(sender_call_->Receiver()); if (num_video_streams_ > 0) receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); if (num_audio_streams_ > 0) @@ -146,7 +147,7 @@ void CallTest::RunBaseTest(BaseTest* test) { CreateSendConfig(num_video_streams_, num_audio_streams_, num_flexfec_streams_, send_transport_.get()); if (test->ShouldCreateReceivers()) { - CreateMatchingReceiveConfigs(receive_transport_.get()); + CreateMatchingReceiveConfigs(); } if (num_video_streams_ > 0) { test->ModifyVideoConfigs(GetVideoSendConfig(), &video_receive_configs_, @@ -235,6 +236,8 @@ void CallTest::CreateReceiverCall(const Call::Config& config) { } void CallTest::DestroyCalls() { + send_transport_.reset(); + receive_transport_.reset(); sender_call_.reset(); receiver_call_.reset(); } @@ -568,6 +571,35 @@ void CallTest::CreateFlexfecStreams() { } } +void CallTest::CreateSendTransport(const BuiltInNetworkBehaviorConfig& config, + RtpRtcpObserver* observer) { + PacketReceiver* receiver = + receiver_call_ ? receiver_call_->Receiver() : nullptr; + + auto network = std::make_unique(config); + send_simulated_network_ = network.get(); + send_transport_ = std::make_unique( + task_queue(), sender_call_.get(), observer, + test::PacketTransport::kSender, payload_type_map_, + std::make_unique(Clock::GetRealTimeClock(), + std::move(network), receiver), + rtp_extensions_, rtp_extensions_); +} + +void CallTest::CreateReceiveTransport( + const BuiltInNetworkBehaviorConfig& config, + RtpRtcpObserver* observer) { + auto network = std::make_unique(config); + receive_simulated_network_ = network.get(); + receive_transport_ = std::make_unique( + task_queue(), nullptr, observer, test::PacketTransport::kReceiver, + payload_type_map_, + std::make_unique(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(), @@ -710,6 +742,10 @@ const std::map 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}, @@ -741,27 +777,18 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) { void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {} -std::unique_ptr BaseTest::CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) { - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - CallTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(BuiltInNetworkBehaviorConfig()))); +void BaseTest::OnTransportCreated(PacketTransport* to_receiver, + SimulatedNetworkInterface* sender_network, + PacketTransport* to_sender, + SimulatedNetworkInterface* receiver_network) { } -std::unique_ptr BaseTest::CreateReceiveTransport( - TaskQueueBase* task_queue) { - return std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - CallTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(BuiltInNetworkBehaviorConfig()))); +BuiltInNetworkBehaviorConfig BaseTest::GetSendTransportConfig() const { + return BuiltInNetworkBehaviorConfig(); +} +BuiltInNetworkBehaviorConfig BaseTest::GetReceiveTransportConfig() const { + return BuiltInNetworkBehaviorConfig(); } - size_t BaseTest::GetNumVideoStreams() const { return 1; } diff --git a/test/call_test.h b/test/call_test.h index 1fd4cd310f..3324bc4b5e 100644 --- a/test/call_test.h +++ b/test/call_test.h @@ -16,9 +16,11 @@ #include #include "absl/types/optional.h" +#include "api/array_view.h" #include "api/rtc_event_log/rtc_event_log.h" #include "api/task_queue/task_queue_base.h" #include "api/task_queue/task_queue_factory.h" +#include "api/test/simulated_network.h" #include "api/test/video/function_video_decoder_factory.h" #include "api/test/video/function_video_encoder_factory.h" #include "api/units/time_delta.h" @@ -76,6 +78,10 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface { protected: void RegisterRtpExtension(const RtpExtension& extension); + // Returns header extensions that can be parsed by the transport. + rtc::ArrayView GetRegisteredExtensions() { + return rtp_extensions_; + } // RunBaseTest overwrites the audio_state of the send and receive Call configs // to simplify test code. @@ -102,11 +108,23 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface { void SetSendUlpFecConfig(VideoSendStream::Config* send_config); void SetReceiveUlpFecConfig( VideoReceiveStreamInterface::Config* receive_config); + + void CreateSendConfig(size_t num_video_streams, + size_t num_audio_streams, + size_t num_flexfec_streams) { + CreateSendConfig(num_video_streams, num_audio_streams, num_flexfec_streams, + send_transport_.get()); + } void CreateSendConfig(size_t num_video_streams, size_t num_audio_streams, size_t num_flexfec_streams, Transport* send_transport); + void CreateMatchingVideoReceiveConfigs( + const VideoSendStream::Config& video_send_config) { + CreateMatchingVideoReceiveConfigs(video_send_config, + receive_transport_.get()); + } void CreateMatchingVideoReceiveConfigs( const VideoSendStream::Config& video_send_config, Transport* rtcp_send_transport); @@ -136,6 +154,9 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface { void CreateMatchingFecConfig( Transport* transport, const VideoSendStream::Config& video_send_config); + void CreateMatchingReceiveConfigs() { + CreateMatchingReceiveConfigs(receive_transport_.get()); + } void CreateMatchingReceiveConfigs(Transport* rtcp_send_transport); void CreateFrameGeneratorCapturerWithDrift(Clock* drift_clock, @@ -154,6 +175,16 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface { void CreateAudioStreams(); void CreateFlexfecStreams(); + // Receiver call must be created before calling CreateSendTransport in order + // to set a receiver. + // Rtp header extensions must be registered (RegisterRtpExtension(..)) before + // the transport is created in order for the receiving call object receive RTP + // packets with extensions. + void CreateSendTransport(const BuiltInNetworkBehaviorConfig& config, + RtpRtcpObserver* observer); + void CreateReceiveTransport(const BuiltInNetworkBehaviorConfig& config, + RtpRtcpObserver* observer); + void ConnectVideoSourcesToStreams(); void Start(); @@ -187,6 +218,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface { std::unique_ptr recv_event_log_; std::unique_ptr sender_call_; std::unique_ptr send_transport_; + SimulatedNetworkInterface* send_simulated_network_ = nullptr; std::vector video_send_configs_; std::vector video_encoder_configs_; std::vector video_send_streams_; @@ -195,6 +227,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface { std::unique_ptr receiver_call_; std::unique_ptr receive_transport_; + SimulatedNetworkInterface* receive_simulated_network_ = nullptr; std::vector video_receive_configs_; std::vector video_receive_streams_; std::vector audio_receive_configs_; @@ -265,12 +298,13 @@ class BaseTest : public RtpRtcpObserver { virtual void ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config); virtual void OnCallsCreated(Call* sender_call, Call* receiver_call); + virtual void OnTransportCreated(PacketTransport* to_receiver, + SimulatedNetworkInterface* sender_network, + PacketTransport* to_sender, + SimulatedNetworkInterface* receiver_network); - virtual std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call); - virtual std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue); + virtual BuiltInNetworkBehaviorConfig GetSendTransportConfig() const; + virtual BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const; virtual void ModifyVideoConfigs( VideoSendStream::Config* send_config, diff --git a/test/direct_transport.cc b/test/direct_transport.cc index 7e9c5aefeb..3ae0216186 100644 --- a/test/direct_transport.cc +++ b/test/direct_transport.cc @@ -9,12 +9,14 @@ */ #include "test/direct_transport.h" -#include "absl/memory/memory.h" +#include "api/media_types.h" #include "api/task_queue/task_queue_base.h" #include "api/units/time_delta.h" #include "call/call.h" #include "call/fake_network_pipe.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/rtp_util.h" +#include "rtc_base/checks.h" #include "rtc_base/task_utils/repeating_task.h" #include "rtc_base/time_utils.h" @@ -43,10 +45,27 @@ DirectTransport::DirectTransport( std::unique_ptr pipe, Call* send_call, const std::map& payload_type_map) + : DirectTransport(task_queue, + std::move(pipe), + send_call, + payload_type_map, + {}, + {}) {} + +DirectTransport::DirectTransport( + TaskQueueBase* task_queue, + std::unique_ptr pipe, + Call* send_call, + const std::map& payload_type_map, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions) : send_call_(send_call), task_queue_(task_queue), demuxer_(payload_type_map), - fake_network_(std::move(pipe)) { + fake_network_(std::move(pipe)), + use_legacy_send_(audio_extensions.empty() && video_extensions.empty()), + audio_extensions_(audio_extensions), + video_extensions_(video_extensions) { Start(); } @@ -69,23 +88,54 @@ bool DirectTransport::SendRtp(const uint8_t* data, sent_packet.info.packet_type = rtc::PacketType::kData; send_call_->OnSentPacket(sent_packet); } - SendPacket(data, length); + + if (use_legacy_send_) { + LegacySendPacket(data, length); + } else { + const RtpHeaderExtensionMap* extensions = nullptr; + MediaType media_type = demuxer_.GetMediaType(data, length); + switch (demuxer_.GetMediaType(data, length)) { + case webrtc::MediaType::AUDIO: + extensions = &audio_extensions_; + break; + case webrtc::MediaType::VIDEO: + extensions = &video_extensions_; + break; + default: + RTC_CHECK_NOTREACHED(); + } + RtpPacketReceived packet(extensions, Timestamp::Micros(rtc::TimeMicros())); + if (media_type == MediaType::VIDEO) { + packet.set_payload_type_frequency(kVideoPayloadTypeFrequency); + } + RTC_CHECK(packet.Parse(rtc::CopyOnWriteBuffer(data, length))); + fake_network_->DeliverRtpPacket( + media_type, std::move(packet), + [](const RtpPacketReceived& packet) { return false; }); + } + MutexLock lock(&process_lock_); + if (!next_process_task_.Running()) + ProcessPackets(); return true; } bool DirectTransport::SendRtcp(const uint8_t* data, size_t length) { - SendPacket(data, length); + if (use_legacy_send_) { + LegacySendPacket(data, length); + } else { + fake_network_->DeliverRtcpPacket(rtc::CopyOnWriteBuffer(data, length)); + } + MutexLock lock(&process_lock_); + if (!next_process_task_.Running()) + ProcessPackets(); return true; } -void DirectTransport::SendPacket(const uint8_t* data, size_t length) { +void DirectTransport::LegacySendPacket(const uint8_t* data, size_t length) { MediaType media_type = demuxer_.GetMediaType(data, length); int64_t send_time_us = rtc::TimeMicros(); fake_network_->DeliverPacket(media_type, rtc::CopyOnWriteBuffer(data, length), send_time_us); - MutexLock lock(&process_lock_); - if (!next_process_task_.Running()) - ProcessPackets(); } int DirectTransport::GetAverageDelayMs() { diff --git a/test/direct_transport.h b/test/direct_transport.h index d67f9ead69..4776084ae2 100644 --- a/test/direct_transport.h +++ b/test/direct_transport.h @@ -44,10 +44,20 @@ class Demuxer { // same task-queue - the one that's passed in via the constructor. class DirectTransport : public Transport { public: + // TODO(perkj, https://bugs.webrtc.org/7135): Remove header once downstream + // projects have been updated. + [[deprecated("Use ctor that provide header extensions.")]] DirectTransport( + TaskQueueBase* task_queue, + std::unique_ptr pipe, + Call* send_call, + const std::map& payload_type_map); + DirectTransport(TaskQueueBase* task_queue, std::unique_ptr pipe, Call* send_call, - const std::map& payload_type_map); + const std::map& payload_type_map, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions); ~DirectTransport() override; @@ -63,7 +73,7 @@ class DirectTransport : public Transport { private: void ProcessPackets() RTC_EXCLUSIVE_LOCKS_REQUIRED(&process_lock_); - void SendPacket(const uint8_t* data, size_t length); + void LegacySendPacket(const uint8_t* data, size_t length); void Start(); Call* const send_call_; @@ -75,6 +85,9 @@ class DirectTransport : public Transport { const Demuxer demuxer_; const std::unique_ptr fake_network_; + const bool use_legacy_send_; + const RtpHeaderExtensionMap audio_extensions_; + const RtpHeaderExtensionMap video_extensions_; }; } // namespace test } // namespace webrtc diff --git a/test/layer_filtering_transport.cc b/test/layer_filtering_transport.cc index 08c90f77a9..f5e5ee3002 100644 --- a/test/layer_filtering_transport.cc +++ b/test/layer_filtering_transport.cc @@ -39,8 +39,15 @@ LayerFilteringTransport::LayerFilteringTransport( int selected_sl, const std::map& payload_type_map, uint32_t ssrc_to_filter_min, - uint32_t ssrc_to_filter_max) - : DirectTransport(task_queue, std::move(pipe), send_call, payload_type_map), + uint32_t ssrc_to_filter_max, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions) + : DirectTransport(task_queue, + std::move(pipe), + send_call, + payload_type_map, + audio_extensions, + video_extensions), vp8_video_payload_type_(vp8_video_payload_type), vp9_video_payload_type_(vp9_video_payload_type), vp8_depacketizer_(CreateVideoRtpDepacketizer(kVideoCodecVP8)), @@ -59,7 +66,9 @@ LayerFilteringTransport::LayerFilteringTransport( uint8_t vp9_video_payload_type, int selected_tl, int selected_sl, - const std::map& payload_type_map) + const std::map& payload_type_map, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions) : LayerFilteringTransport(task_queue, std::move(pipe), send_call, @@ -69,7 +78,9 @@ LayerFilteringTransport::LayerFilteringTransport( selected_sl, payload_type_map, /*ssrc_to_filter_min=*/0, - /*ssrc_to_filter_max=*/0xFFFFFFFF) {} + /*ssrc_to_filter_max=*/0xFFFFFFFF, + audio_extensions, + video_extensions) {} bool LayerFilteringTransport::DiscardedLastPacket() const { return discarded_last_packet_; diff --git a/test/layer_filtering_transport.h b/test/layer_filtering_transport.h index 4606da5f7f..3aefd7159b 100644 --- a/test/layer_filtering_transport.h +++ b/test/layer_filtering_transport.h @@ -39,7 +39,9 @@ class LayerFilteringTransport : public test::DirectTransport { int selected_sl, const std::map& payload_type_map, uint32_t ssrc_to_filter_min, - uint32_t ssrc_to_filter_max); + uint32_t ssrc_to_filter_max, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions); LayerFilteringTransport( TaskQueueBase* task_queue, std::unique_ptr pipe, @@ -48,7 +50,9 @@ class LayerFilteringTransport : public test::DirectTransport { uint8_t vp9_video_payload_type, int selected_tl, int selected_sl, - const std::map& payload_type_map); + const std::map& payload_type_map, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions); bool DiscardedLastPacket() const; bool SendRtp(const uint8_t* data, size_t length, diff --git a/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h index 0c6fd4bf00..06a438e712 100644 --- a/test/rtp_rtcp_observer.h +++ b/test/rtp_rtcp_observer.h @@ -87,11 +87,15 @@ class PacketTransport : public test::DirectTransport { RtpRtcpObserver* observer, TransportType transport_type, const std::map& payload_type_map, - std::unique_ptr nw_pipe) + std::unique_ptr nw_pipe, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions) : test::DirectTransport(task_queue, std::move(nw_pipe), send_call, - payload_type_map), + payload_type_map, + audio_extensions, + video_extensions), observer_(observer), transport_type_(transport_type) {} @@ -100,8 +104,8 @@ class PacketTransport : public test::DirectTransport { size_t length, const PacketOptions& options) override { EXPECT_TRUE(IsRtpPacket(rtc::MakeArrayView(packet, length))); - RtpRtcpObserver::Action action; - { + RtpRtcpObserver::Action action = RtpRtcpObserver::SEND_PACKET; + if (observer_) { if (transport_type_ == kSender) { action = observer_->OnSendRtp(packet, length); } else { @@ -120,8 +124,8 @@ class PacketTransport : public test::DirectTransport { bool SendRtcp(const uint8_t* packet, size_t length) override { EXPECT_TRUE(IsRtcpPacket(rtc::MakeArrayView(packet, length))); - RtpRtcpObserver::Action action; - { + RtpRtcpObserver::Action action = RtpRtcpObserver::SEND_PACKET; + if (observer_) { if (transport_type_ == kSender) { action = observer_->OnSendRtcp(packet, length); } else { diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc index 200b6fc4bd..d6610a8ec2 100644 --- a/video/end_to_end_tests/bandwidth_tests.cc +++ b/video/end_to_end_tests/bandwidth_tests.cc @@ -196,25 +196,12 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) { clock_(Clock::GetRealTimeClock()), sender_ssrc_(0), remb_bitrate_bps_(1000000), - receive_transport_(nullptr), state_(kWaitForFirstRampUp), retransmission_rate_limiter_(clock_, 1000), task_queue_(task_queue) {} void OnStreamsStopped() override { rtp_rtcp_ = nullptr; } - std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue) override { - auto receive_transport = std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig()))); - receive_transport_ = receive_transport.get(); - return receive_transport; - } - void ModifySenderBitrateConfig( BitrateConstraints* bitrate_config) override { // Set a high start bitrate to reduce the test completion time. @@ -231,15 +218,8 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) { encoder_config->max_bitrate_bps = 2000000; ASSERT_EQ(1u, receive_configs->size()); - RtpRtcpInterface::Configuration config; - config.receiver_only = true; - config.clock = clock_; - config.outgoing_transport = receive_transport_; - config.retransmission_rate_limiter = &retransmission_rate_limiter_; - config.local_media_ssrc = (*receive_configs)[0].rtp.local_ssrc; - rtp_rtcp_ = ModuleRtpRtcpImpl2::Create(config); - rtp_rtcp_->SetRemoteSSRC((*receive_configs)[0].rtp.remote_ssrc); - rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize); + remb_sender_local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc; + remb_sender_remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc; } void OnCallsCreated(Call* sender_call, Call* receiver_call) override { @@ -248,6 +228,23 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) { task_queue_->PostTask([this]() { PollStats(); }); } + void OnTransportCreated( + test::PacketTransport* /*to_receiver*/, + SimulatedNetworkInterface* /*sender_network*/, + test::PacketTransport* to_sender, + SimulatedNetworkInterface* /*receiver_network*/) override { + RtpRtcpInterface::Configuration config; + config.receiver_only = true; + config.clock = clock_; + config.outgoing_transport = to_sender; + config.retransmission_rate_limiter = &retransmission_rate_limiter_; + config.local_media_ssrc = remb_sender_local_ssrc_; + + rtp_rtcp_ = ModuleRtpRtcpImpl2::Create(config); + rtp_rtcp_->SetRemoteSSRC(remb_sender_remote_ssrc_); + rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize); + } + void PollStats() { Call::Stats stats = sender_call_->GetStats(); switch (state_) { @@ -296,9 +293,10 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) { Call* sender_call_; Clock* const clock_; uint32_t sender_ssrc_; + uint32_t remb_sender_local_ssrc_ = 0; + uint32_t remb_sender_remote_ssrc_ = 0; int remb_bitrate_bps_; std::unique_ptr rtp_rtcp_; - test::PacketTransport* receive_transport_; TestState state_; RateLimiter retransmission_rate_limiter_; TaskQueueBase* const task_queue_; diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc index 41331e972c..f5b32388b1 100644 --- a/video/end_to_end_tests/call_operation_tests.cc +++ b/video/end_to_end_tests/call_operation_tests.cc @@ -94,31 +94,17 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) { } renderer; test::FrameForwarder frame_forwarder; - std::unique_ptr sender_transport; - std::unique_ptr receiver_transport; SendTask( - task_queue(), [this, &renderer, &frame_forwarder, &sender_transport, - &receiver_transport]() { + task_queue(), [this, &renderer, &frame_forwarder]() { CreateCalls(); + CreateSendTransport(BuiltInNetworkBehaviorConfig(), + /*observer=*/nullptr); - sender_transport = std::make_unique( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())), - sender_call_.get(), payload_type_map_); - receiver_transport = std::make_unique( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())), - receiver_call_.get(), payload_type_map_); - sender_transport->SetReceiver(receiver_call_->Receiver()); - receiver_transport->SetReceiver(sender_call_->Receiver()); - - CreateSendConfig(1, 0, 0, sender_transport.get()); - CreateMatchingReceiveConfigs(receiver_transport.get()); + CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), + /*observer=*/nullptr); + CreateSendConfig(1, 0, 0); + CreateMatchingReceiveConfigs(); video_receive_configs_[0].renderer = &renderer; @@ -145,11 +131,9 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) { EXPECT_TRUE(renderer.Wait()) << "Timed out while waiting for the frame to render."; - SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() { + SendTask(task_queue(), [this]() { Stop(); DestroyStreams(); - sender_transport.reset(); - receiver_transport.reset(); DestroyCalls(); }); } @@ -171,27 +155,15 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) { std::unique_ptr receiver_transport; SendTask( - task_queue(), [this, &renderer, &frame_generator, &frame_forwarder, - &sender_transport, &receiver_transport]() { + task_queue(), [this, &renderer, &frame_generator, &frame_forwarder]() { CreateCalls(); + CreateSendTransport(BuiltInNetworkBehaviorConfig(), + /*observer=*/nullptr); + CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), + /*observer=*/nullptr); - sender_transport = std::make_unique( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())), - sender_call_.get(), payload_type_map_); - receiver_transport = std::make_unique( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())), - receiver_call_.get(), payload_type_map_); - sender_transport->SetReceiver(receiver_call_->Receiver()); - receiver_transport->SetReceiver(sender_call_->Receiver()); - - CreateSendConfig(1, 0, 0, sender_transport.get()); - CreateMatchingReceiveConfigs(receiver_transport.get()); + CreateSendConfig(1, 0, 0); + CreateMatchingReceiveConfigs(); video_receive_configs_[0].renderer = &renderer; CreateVideoStreams(); @@ -213,11 +185,9 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) { EXPECT_TRUE(renderer.Wait()) << "Timed out while waiting for the frame to render."; - SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() { + SendTask(task_queue(), [this]() { Stop(); DestroyStreams(); - sender_transport.reset(); - receiver_transport.reset(); DestroyCalls(); }); } diff --git a/video/end_to_end_tests/extended_reports_tests.cc b/video/end_to_end_tests/extended_reports_tests.cc index ee37bf96ce..2897212e0b 100644 --- a/video/end_to_end_tests/extended_reports_tests.cc +++ b/video/end_to_end_tests/extended_reports_tests.cc @@ -158,17 +158,16 @@ class RtcpXrObserver : public test::EndToEndTest { return enable_zero_target_bitrate_ ? 2 : 1; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) { - auto network = - std::make_unique(forward_transport_config_); - send_simulated_network_ = network.get(); - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - test::CallTest::payload_type_map_, - std::make_unique(Clock::GetRealTimeClock(), - std::move(network))); + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { + return forward_transport_config_; + } + + void OnTransportCreated( + test::PacketTransport* to_receiver, + SimulatedNetworkInterface* sender_network, + test::PacketTransport* to_sender, + SimulatedNetworkInterface* receiver_network) override { + send_simulated_network_ = sender_network; } void ModifyVideoConfigs( @@ -210,7 +209,7 @@ class RtcpXrObserver : public test::EndToEndTest { bool sent_zero_rtcp_target_bitrate_ RTC_GUARDED_BY(&mutex_); int sent_rtcp_dlrr_; BuiltInNetworkBehaviorConfig forward_transport_config_; - SimulatedNetwork* send_simulated_network_; + SimulatedNetworkInterface* send_simulated_network_ = nullptr; }; TEST_F(ExtendedReportsEndToEndTest, diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc index ff85dde53b..bf3ad0b22d 100644 --- a/video/end_to_end_tests/fec_tests.cc +++ b/video/end_to_end_tests/fec_tests.cc @@ -256,19 +256,12 @@ class FlexfecRenderObserver : public test::EndToEndTest, return SEND_PACKET; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. const int kNetworkDelayMs = 100; BuiltInNetworkBehaviorConfig config; config.queue_delay_ms = kNetworkDelayMs; - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - test::CallTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config))); + return config; } void OnFrame(const VideoFrame& video_frame) override { @@ -439,20 +432,13 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) { return SEND_PACKET; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. // Configure some network delay. const int kNetworkDelayMs = 50; BuiltInNetworkBehaviorConfig config; config.queue_delay_ms = kNetworkDelayMs; - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config))); + return config; } // TODO(holmer): Investigate why we don't send FEC packets when the bitrate diff --git a/video/end_to_end_tests/multi_codec_receive_tests.cc b/video/end_to_end_tests/multi_codec_receive_tests.cc index 811b96d322..d8ac606bfd 100644 --- a/video/end_to_end_tests/multi_codec_receive_tests.cc +++ b/video/end_to_end_tests/multi_codec_receive_tests.cc @@ -131,22 +131,8 @@ class MultiCodecReceiveTest : public test::CallTest { MultiCodecReceiveTest() { SendTask(task_queue(), [this]() { CreateCalls(); - - send_transport_.reset(new test::PacketTransport( - task_queue(), sender_call_.get(), &observer_, - test::PacketTransport::kSender, kPayloadTypeMap, - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())))); - send_transport_->SetReceiver(receiver_call_->Receiver()); - - receive_transport_.reset(new test::PacketTransport( - task_queue(), receiver_call_.get(), &observer_, - test::PacketTransport::kReceiver, kPayloadTypeMap, - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())))); - receive_transport_->SetReceiver(sender_call_->Receiver()); + CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer_); + CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer_); }); } @@ -170,10 +156,6 @@ class MultiCodecReceiveTest : public test::CallTest { void RunTestWithCodecs(const std::vector& configs); private: - const std::map kPayloadTypeMap = { - {CallTest::kPayloadTypeVP8, MediaType::VIDEO}, - {CallTest::kPayloadTypeVP9, MediaType::VIDEO}, - {CallTest::kPayloadTypeH264, MediaType::VIDEO}}; FrameObserver observer_; }; @@ -245,9 +227,9 @@ void MultiCodecReceiveTest::RunTestWithCodecs( // Create and start call. SendTask(task_queue(), [this, &configs, &encoder_factory, &decoder_factory]() { - CreateSendConfig(1, 0, 0, send_transport_.get()); + CreateSendConfig(1, 0, 0); ConfigureEncoder(configs[0], &encoder_factory); - CreateMatchingReceiveConfigs(receive_transport_.get()); + CreateMatchingReceiveConfigs(); video_receive_configs_[0].renderer = &observer_; // Disable to avoid post-decode frame dropping in // VideoRenderFrames. diff --git a/video/end_to_end_tests/multi_stream_tester.cc b/video/end_to_end_tests/multi_stream_tester.cc index b455672de0..82e9eb9417 100644 --- a/video/end_to_end_tests/multi_stream_tester.cc +++ b/video/end_to_end_tests/multi_stream_tester.cc @@ -73,7 +73,6 @@ void MultiStreamTester::RunTest() { sender_transport = CreateSendTransport(task_queue.get(), sender_call.get()); receiver_transport = CreateReceiveTransport(task_queue.get(), receiver_call.get()); - sender_transport->SetReceiver(receiver_call->Receiver()); receiver_transport->SetReceiver(sender_call->Receiver()); @@ -158,22 +157,24 @@ void MultiStreamTester::UpdateReceiveConfig( std::unique_ptr MultiStreamTester::CreateSendTransport( TaskQueueBase* task_queue, Call* sender_call) { + std::vector extensions = {}; return std::make_unique( task_queue, std::make_unique( Clock::GetRealTimeClock(), std::make_unique(BuiltInNetworkBehaviorConfig())), - sender_call, payload_type_map_); + sender_call, payload_type_map_, extensions, extensions); } std::unique_ptr MultiStreamTester::CreateReceiveTransport(TaskQueueBase* task_queue, Call* receiver_call) { + std::vector extensions = {}; return std::make_unique( task_queue, std::make_unique( Clock::GetRealTimeClock(), std::make_unique(BuiltInNetworkBehaviorConfig())), - receiver_call, payload_type_map_); + receiver_call, payload_type_map_, extensions, extensions); } } // namespace webrtc diff --git a/video/end_to_end_tests/network_state_tests.cc b/video/end_to_end_tests/network_state_tests.cc index 290848f17c..a39f9fe9e3 100644 --- a/video/end_to_end_tests/network_state_tests.cc +++ b/video/end_to_end_tests/network_state_tests.cc @@ -122,35 +122,25 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState( void NetworkStateEndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState( MediaType network_to_bring_up, Transport* transport) { - std::unique_ptr sender_transport; + SendTask(task_queue(), [this, network_to_bring_up, transport]() { + CreateCalls(); + receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp); + CreateSendTransport(BuiltInNetworkBehaviorConfig(), + /*observer=*/nullptr); - SendTask( - task_queue(), - [this, &sender_transport, network_to_bring_up, transport]() { - CreateCalls(); - receiver_call_->SignalChannelNetworkState(network_to_bring_up, - kNetworkUp); - sender_transport = std::make_unique( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig())), - sender_call_.get(), payload_type_map_); - sender_transport->SetReceiver(receiver_call_->Receiver()); - CreateSendConfig(1, 0, 0, sender_transport.get()); - CreateMatchingReceiveConfigs(transport); - CreateVideoStreams(); - CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, - kDefaultHeight); - Start(); - }); + CreateSendConfig(1, 0, 0); + CreateMatchingReceiveConfigs(transport); + CreateVideoStreams(); + CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, + kDefaultHeight); + Start(); + }); SleepMs(kSilenceTimeoutMs); - SendTask(task_queue(), [this, &sender_transport]() { + SendTask(task_queue(), [this]() { Stop(); DestroyStreams(); - sender_transport.reset(); DestroyCalls(); }); } diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc index 99f6c917b4..45a9dae1e8 100644 --- a/video/end_to_end_tests/retransmission_tests.cc +++ b/video/end_to_end_tests/retransmission_tests.cc @@ -142,24 +142,13 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) { size_t GetNumVideoStreams() const override { return 0; } size_t GetNumAudioStreams() const override { return 1; } - std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue) override { - auto receive_transport = std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), std::make_unique( - BuiltInNetworkBehaviorConfig()))); - receive_transport_ = receive_transport.get(); - return receive_transport; - } - Action OnSendRtp(const uint8_t* packet, size_t length) override { RtpPacket rtp_packet; EXPECT_TRUE(rtp_packet.Parse(packet, length)); if (!sequence_number_to_retransmit_) { sequence_number_to_retransmit_ = rtp_packet.SequenceNumber(); + return DROP_PACKET; // Don't ask for retransmission straight away, may be deduped in pacer. } else if (rtp_packet.SequenceNumber() == @@ -186,6 +175,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) { (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc; remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc; + receive_transport_ = (*receive_configs)[0].rtcp_send_transport; } void PerformTest() override { diff --git a/video/end_to_end_tests/rtp_rtcp_tests.cc b/video/end_to_end_tests/rtp_rtcp_tests.cc index 1ac83c3c36..32d7cd50ef 100644 --- a/video/end_to_end_tests/rtp_rtcp_tests.cc +++ b/video/end_to_end_tests/rtp_rtcp_tests.cc @@ -279,56 +279,35 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation( std::map ssrc_observed_ RTC_GUARDED_BY(mutex_); } observer(use_rtx); - std::unique_ptr send_transport; - std::unique_ptr receive_transport; - VideoEncoderConfig one_stream; - SendTask( - task_queue(), [this, &observer, &send_transport, &receive_transport, - &one_stream, use_rtx]() { - CreateCalls(); + SendTask(task_queue(), [this, &observer, &one_stream, use_rtx]() { + CreateCalls(); + CreateSendTransport(BuiltInNetworkBehaviorConfig(), &observer); + CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer); + CreateSendConfig(kNumSimulcastStreams, 0, 0); - send_transport = std::make_unique( - task_queue(), sender_call_.get(), &observer, - test::PacketTransport::kSender, payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique( - BuiltInNetworkBehaviorConfig()))); - receive_transport = std::make_unique( - task_queue(), nullptr, &observer, test::PacketTransport::kReceiver, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique( - BuiltInNetworkBehaviorConfig()))); - send_transport->SetReceiver(receiver_call_->Receiver()); - receive_transport->SetReceiver(sender_call_->Receiver()); + if (use_rtx) { + for (size_t i = 0; i < kNumSimulcastStreams; ++i) { + GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); + } + GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType; + } - CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport.get()); + GetVideoEncoderConfig()->video_stream_factory = + rtc::make_ref_counted(); + // Use the same total bitrates when sending a single stream to avoid + // lowering the bitrate estimate and requiring a subsequent rampup. + one_stream = GetVideoEncoderConfig()->Copy(); + // one_stream.streams.resize(1); + one_stream.number_of_streams = 1; + CreateMatchingReceiveConfigs(); - if (use_rtx) { - for (size_t i = 0; i < kNumSimulcastStreams; ++i) { - GetVideoSendConfig()->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]); - } - GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType; - } + CreateVideoStreams(); + CreateFrameGeneratorCapturer(30, 1280, 720); - GetVideoEncoderConfig()->video_stream_factory = - rtc::make_ref_counted(); - // Use the same total bitrates when sending a single stream to avoid - // lowering the bitrate estimate and requiring a subsequent rampup. - one_stream = GetVideoEncoderConfig()->Copy(); - // one_stream.streams.resize(1); - one_stream.number_of_streams = 1; - CreateMatchingReceiveConfigs(receive_transport.get()); - - CreateVideoStreams(); - CreateFrameGeneratorCapturer(30, 1280, 720); - - Start(); - }); + Start(); + }); EXPECT_TRUE(observer.Wait()) << "Timed out waiting for all SSRCs to send packets."; @@ -348,7 +327,7 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation( // to wait for a second for periodic Sender Report. rtcp::RapidResyncRequest force_send_sr_back_request; rtc::Buffer packet = force_send_sr_back_request.Build(); - static_cast(receive_transport.get()) + static_cast(receive_transport_.get()) ->SendRtcp(packet.data(), packet.size()); } CreateFrameGeneratorCapturer(30, 1280, 720); @@ -383,11 +362,9 @@ void RtpRtcpEndToEndTest::TestRtpStatePreservation( << "Timed out waiting for all SSRCs to send packets."; } - SendTask(task_queue(), [this, &send_transport, &receive_transport]() { + SendTask(task_queue(), [this]() { Stop(); DestroyStreams(); - send_transport.reset(); - receive_transport.reset(); DestroyCalls(); }); } @@ -478,8 +455,6 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) { static constexpr int kFrameMaxHeight = 180; static constexpr int kFrameRate = 15; - std::unique_ptr send_transport; - std::unique_ptr receive_transport; test::FunctionVideoEncoderFactory encoder_factory( []() { return VP8Encoder::Create(); }); @@ -490,29 +465,14 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) { lossy_delayed_link.loss_percent = 2; lossy_delayed_link.queue_delay_ms = 50; - send_transport = std::make_unique( - task_queue(), sender_call_.get(), &observer, - test::PacketTransport::kSender, payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(lossy_delayed_link))); - send_transport->SetReceiver(receiver_call_->Receiver()); - - BuiltInNetworkBehaviorConfig flawless_link; - receive_transport = std::make_unique( - task_queue(), nullptr, &observer, test::PacketTransport::kReceiver, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(flawless_link))); - receive_transport->SetReceiver(sender_call_->Receiver()); + CreateSendTransport(lossy_delayed_link, &observer); + CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), &observer); // For reduced flakyness, we use a real VP8 encoder together with NACK // and RTX. const int kNumVideoStreams = 1; const int kNumFlexfecStreams = 1; - CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams, - send_transport.get()); + CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams); GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory; GetVideoSendConfig()->rtp.payload_name = "VP8"; @@ -522,7 +482,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) { GetVideoSendConfig()->rtp.rtx.payload_type = kSendRtxPayloadType; GetVideoEncoderConfig()->codec_type = kVideoCodecVP8; - CreateMatchingReceiveConfigs(receive_transport.get()); + CreateMatchingReceiveConfigs(); video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs; video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0]; video_receive_configs_[0] @@ -533,7 +493,7 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) { // CreateMatchingReceiveConfigs since this is not a test::BaseTest. // Set up the receive config manually instead. FlexfecReceiveStream::Config flexfec_receive_config( - receive_transport.get()); + receive_transport_.get()); flexfec_receive_config.payload_type = GetVideoSendConfig()->rtp.flexfec.payload_type; flexfec_receive_config.rtp.remote_ssrc = @@ -582,11 +542,9 @@ TEST_F(RtpRtcpEndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) { EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets."; // Cleanup. - SendTask(task_queue(), [this, &send_transport, &receive_transport]() { + SendTask(task_queue(), [this]() { Stop(); DestroyStreams(); - send_transport.reset(); - receive_transport.reset(); DestroyCalls(); }); } diff --git a/video/end_to_end_tests/ssrc_tests.cc b/video/end_to_end_tests/ssrc_tests.cc index 970a568566..a3bce40fd2 100644 --- a/video/end_to_end_tests/ssrc_tests.cc +++ b/video/end_to_end_tests/ssrc_tests.cc @@ -12,8 +12,10 @@ #include "api/test/simulated_network.h" #include "call/fake_network_pipe.h" +#include "call/packet_receiver.h" #include "call/simulated_network.h" #include "modules/rtp_rtcp/source/rtp_packet.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" #include "modules/rtp_rtcp/source/rtp_util.h" #include "rtc_base/task_queue_for_test.h" #include "test/call_test.h" @@ -22,6 +24,12 @@ namespace webrtc { class SsrcEndToEndTest : public test::CallTest { + public: + SsrcEndToEndTest() { + RegisterRtpExtension( + RtpExtension(RtpExtension::kTransportSequenceNumberUri, 1)); + } + protected: void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first); }; @@ -49,31 +57,34 @@ TEST_F(SsrcEndToEndTest, ReceiverUsesLocalSsrc) { RunBaseTest(&test); } -TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) { +TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) { class PacketInputObserver : public PacketReceiver { public: explicit PacketInputObserver(PacketReceiver* receiver) : receiver_(receiver) {} - bool Wait() { return delivered_packet_.Wait(kDefaultTimeout); } - - private: - DeliveryStatus DeliverPacket(MediaType media_type, - rtc::CopyOnWriteBuffer packet, - int64_t packet_time_us) override { - if (IsRtcpPacket(packet)) { - return receiver_->DeliverPacket(media_type, std::move(packet), - packet_time_us); - } - DeliveryStatus delivery_status = receiver_->DeliverPacket( - media_type, std::move(packet), packet_time_us); - EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status); - delivered_packet_.Set(); - return delivery_status; + bool Wait() { + return undemuxable_packet_handler_triggered_.Wait(kDefaultTimeout); } + private: + void DeliverRtpPacket( + MediaType media_type, + RtpPacketReceived packet, + OnUndemuxablePacketHandler undemuxable_packet_handler) override { + PacketReceiver::OnUndemuxablePacketHandler handler = + [this](const RtpPacketReceived& packet) { + undemuxable_packet_handler_triggered_.Set(); + // No need to re-attempt deliver the packet. + return false; + }; + receiver_->DeliverRtpPacket(media_type, std::move(packet), + std::move(handler)); + } + void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override {} + PacketReceiver* receiver_; - rtc::Event delivered_packet_; + rtc::Event undemuxable_packet_handler_triggered_; }; std::unique_ptr send_transport; @@ -90,7 +101,8 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) { std::make_unique( Clock::GetRealTimeClock(), std::make_unique( BuiltInNetworkBehaviorConfig())), - sender_call_.get(), payload_type_map_); + sender_call_.get(), payload_type_map_, GetRegisteredExtensions(), + GetRegisteredExtensions()); receive_transport = std::make_unique( task_queue(), std::make_unique( diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc index 2166916cad..62acca3b5f 100644 --- a/video/end_to_end_tests/stats_tests.cc +++ b/video/end_to_end_tests/stats_tests.cc @@ -228,17 +228,10 @@ TEST_F(StatsEndToEndTest, GetStats) { return true; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { BuiltInNetworkBehaviorConfig network_config; network_config.loss_percent = 5; - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(network_config))); + return network_config; } void ModifySenderBitrateConfig( @@ -349,6 +342,8 @@ TEST_F(StatsEndToEndTest, GetStats) { TEST_F(StatsEndToEndTest, TimingFramesAreReported) { static const int kExtensionId = 5; + RegisterRtpExtension( + RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId)); class StatsObserver : public test::EndToEndTest { public: @@ -514,16 +509,12 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) { &encoder_config_with_screenshare]() { CreateSenderCall(send_config); CreateReceiverCall(recv_config); - - receive_transport_ = test.CreateReceiveTransport(task_queue()); - send_transport_ = - test.CreateSendTransport(task_queue(), sender_call_.get()); - send_transport_->SetReceiver(receiver_call_->Receiver()); - receive_transport_->SetReceiver(sender_call_->Receiver()); + CreateReceiveTransport(test.GetReceiveTransportConfig(), &test); + CreateSendTransport(test.GetReceiveTransportConfig(), &test); receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); - CreateSendConfig(1, 0, 0, send_transport_.get()); - CreateMatchingReceiveConfigs(receive_transport_.get()); + CreateSendConfig(1, 0, 0); + CreateMatchingReceiveConfigs(); // Modify send and receive configs. GetVideoSendConfig()->rtp.nack.rtp_history_ms = kNackRtpHistoryMs; @@ -562,8 +553,6 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) { SendTask(task_queue(), [this]() { Stop(); DestroyStreams(); - send_transport_.reset(); - receive_transport_.reset(); DestroyCalls(); }); @@ -698,38 +687,24 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) { static const int kSendDelayMs = 30; static const int kReceiveDelayMs = 70; - std::unique_ptr sender_transport; - std::unique_ptr receiver_transport; + SendTask(task_queue(), [this]() { + BuiltInNetworkBehaviorConfig config; + config.queue_delay_ms = kSendDelayMs; + CreateCalls(); + CreateSendTransport(config, /*observer*/ nullptr); - SendTask(task_queue(), - [this, &sender_transport, &receiver_transport]() { - BuiltInNetworkBehaviorConfig config; - config.queue_delay_ms = kSendDelayMs; - CreateCalls(); - sender_transport = std::make_unique( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config)), - sender_call_.get(), payload_type_map_); - config.queue_delay_ms = kReceiveDelayMs; - receiver_transport = std::make_unique( - task_queue(), - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config)), - receiver_call_.get(), payload_type_map_); - sender_transport->SetReceiver(receiver_call_->Receiver()); - receiver_transport->SetReceiver(sender_call_->Receiver()); + config.queue_delay_ms = kReceiveDelayMs; + CreateReceiveTransport(config, /*observer*/ nullptr); - CreateSendConfig(1, 0, 0, sender_transport.get()); - CreateMatchingReceiveConfigs(receiver_transport.get()); + CreateSendConfig(1, 0, 0); + CreateMatchingReceiveConfigs(); - CreateVideoStreams(); - CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, - kDefaultHeight); - Start(); - }); + CreateVideoStreams(); + CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth, + kDefaultHeight); + receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); + Start(); + }); int64_t start_time_ms = clock_->TimeInMilliseconds(); while (true) { @@ -749,11 +724,9 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) { SleepMs(10); } - SendTask(task_queue(), [this, &sender_transport, &receiver_transport]() { + SendTask(task_queue(), [this]() { Stop(); DestroyStreams(); - sender_transport.reset(); - receiver_transport.reset(); DestroyCalls(); }); } diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc index ffcf1c1020..f6e20498e3 100644 --- a/video/end_to_end_tests/transport_feedback_tests.cc +++ b/video/end_to_end_tests/transport_feedback_tests.cc @@ -9,7 +9,9 @@ */ #include +#include +#include "api/rtp_parameters.h" #include "api/task_queue/task_queue_base.h" #include "api/units/time_delta.h" #include "call/call.h" @@ -46,14 +48,18 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) { TaskQueueBase* task_queue, Call* sender_call, const std::map& ssrc_map, - const std::map& payload_type_map) + const std::map& payload_type_map, + rtc::ArrayView audio_extensions, + rtc::ArrayView video_extensions) : DirectTransport(task_queue, std::make_unique( Clock::GetRealTimeClock(), std::make_unique( BuiltInNetworkBehaviorConfig())), sender_call, - payload_type_map), + payload_type_map, + audio_extensions, + video_extensions), rtx_to_media_ssrcs_(ssrc_map), rtx_padding_observed_(false), retransmit_observed_(false), @@ -219,8 +225,12 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) { RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) == payload_type_map.end()); payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO; + std::vector extensions = { + RtpExtension(RtpExtension::kTransportSequenceNumberUri, + kTransportSequenceNumberExtensionId)}; auto observer = std::make_unique( - task_queue, sender_call, rtx_to_media_ssrcs_, payload_type_map); + task_queue, sender_call, rtx_to_media_ssrcs_, payload_type_map, + extensions, extensions); observer_ = observer.get(); return observer; } diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc index 8ea9078c5d..06491b924a 100644 --- a/video/picture_id_tests.cc +++ b/video/picture_id_tests.cc @@ -256,15 +256,7 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory, SendTask( task_queue(), [this, encoder_factory, payload_name]() { CreateCalls(); - - send_transport_.reset(new test::PacketTransport( - task_queue(), sender_call_.get(), observer_.get(), - test::PacketTransport::kSender, payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique( - BuiltInNetworkBehaviorConfig())))); - + CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get()); CreateSendConfig(kNumSimulcastStreams, 0, 0, send_transport_.get()); GetVideoSendConfig()->encoder_settings.encoder_factory = encoder_factory; diff --git a/video/video_analyzer.cc b/video/video_analyzer.cc index 030c60593f..6d70762f34 100644 --- a/video/video_analyzer.cc +++ b/video/video_analyzer.cc @@ -218,43 +218,38 @@ rtc::VideoSourceInterface* VideoAnalyzer::OutputInterface() { return &captured_frame_forwarder_; } -PacketReceiver::DeliveryStatus VideoAnalyzer::DeliverPacket( - MediaType media_type, - rtc::CopyOnWriteBuffer packet, - int64_t packet_time_us) { - // Ignore timestamps of RTCP packets. They're not synchronized with - // RTP packet timestamps and so they would confuse wrap_handler_. - if (IsRtcpPacket(packet)) { - return receiver_->DeliverPacket(media_type, std::move(packet), - packet_time_us); - } +void VideoAnalyzer::DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) { + return receiver_->DeliverRtcpPacket(std::move(packet)); +} +void VideoAnalyzer::DeliverRtpPacket( + MediaType media_type, + RtpPacketReceived packet, + PacketReceiver::OnUndemuxablePacketHandler undemuxable_packet_handler) { if (rtp_file_writer_) { test::RtpPacket p; - memcpy(p.data, packet.cdata(), packet.size()); + memcpy(p.data, packet.Buffer().data(), packet.size()); p.length = packet.size(); p.original_length = packet.size(); p.time_ms = clock_->TimeInMilliseconds() - start_ms_; rtp_file_writer_->WritePacket(&p); } - RtpPacket rtp_packet; - rtp_packet.Parse(packet); - if (!IsFlexfec(rtp_packet.PayloadType()) && - (rtp_packet.Ssrc() == ssrc_to_analyze_ || - rtp_packet.Ssrc() == rtx_ssrc_to_analyze_)) { + if (!IsFlexfec(packet.PayloadType()) && + (packet.Ssrc() == ssrc_to_analyze_ || + packet.Ssrc() == rtx_ssrc_to_analyze_)) { // Ignore FlexFEC timestamps, to avoid collisions with media timestamps. // (FlexFEC and media are sent on different SSRCs, which have different // timestamps spaces.) // Also ignore packets from wrong SSRC, but include retransmits. MutexLock lock(&lock_); int64_t timestamp = - wrap_handler_.Unwrap(rtp_packet.Timestamp() - rtp_timestamp_delta_); + wrap_handler_.Unwrap(packet.Timestamp() - rtp_timestamp_delta_); recv_times_[timestamp] = clock_->CurrentNtpInMilliseconds(); } - return receiver_->DeliverPacket(media_type, std::move(packet), - packet_time_us); + return receiver_->DeliverRtpPacket(media_type, std::move(packet), + std::move(undemuxable_packet_handler)); } void VideoAnalyzer::PreEncodeOnFrame(const VideoFrame& video_frame) { diff --git a/video/video_analyzer.h b/video/video_analyzer.h index bf4de5f8b1..448af7ebb7 100644 --- a/video/video_analyzer.h +++ b/video/video_analyzer.h @@ -67,9 +67,11 @@ class VideoAnalyzer : public PacketReceiver, rtc::VideoSinkInterface* InputInterface(); rtc::VideoSourceInterface* OutputInterface(); - DeliveryStatus DeliverPacket(MediaType media_type, - rtc::CopyOnWriteBuffer packet, - int64_t packet_time_us) override; + void DeliverRtcpPacket(rtc::CopyOnWriteBuffer packet) override; + void DeliverRtpPacket(MediaType media_type, + RtpPacketReceived packet, + PacketReceiver::OnUndemuxablePacketHandler + undemuxable_packet_handler) override; void PreEncodeOnFrame(const VideoFrame& video_frame); void PostEncodeOnFrame(size_t stream_id, uint32_t timestamp); diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc index d05a2017c5..5d179178f2 100644 --- a/video/video_quality_test.cc +++ b/video/video_quality_test.cc @@ -411,26 +411,27 @@ VideoQualityTest::VideoQualityTest( encoder_factory_ = std::make_unique(); } - payload_type_map_ = test::CallTest::payload_type_map_; - RTC_DCHECK(payload_type_map_.find(kPayloadTypeH264) == - payload_type_map_.end()); - RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) == - payload_type_map_.end()); - RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) == - payload_type_map_.end()); - RTC_DCHECK(payload_type_map_.find(kPayloadTypeGeneric) == - payload_type_map_.end()); - payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO; - payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO; - payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO; - payload_type_map_[kPayloadTypeGeneric] = webrtc::MediaType::VIDEO; - fec_controller_factory_ = std::move(injection_components_->fec_controller_factory); network_state_predictor_factory_ = std::move(injection_components_->network_state_predictor_factory); network_controller_factory_ = std::move(injection_components_->network_controller_factory); + + // Register header extensions that are used by transport to identify + // extensions when parsing incomig packets. + RegisterRtpExtension(RtpExtension(RtpExtension::kTransportSequenceNumberUri, + kTransportSequenceNumberExtensionId)); + RegisterRtpExtension( + RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId)); + RegisterRtpExtension(RtpExtension(RtpExtension::kGenericFrameDescriptorUri00, + kGenericFrameDescriptorExtensionId00)); + RegisterRtpExtension(RtpExtension(RtpExtension::kDependencyDescriptorUri, + kRtpExtensionDependencyDescriptor)); + RegisterRtpExtension(RtpExtension(RtpExtension::kVideoContentTypeUri, + kVideoContentTypeExtensionId)); + RegisterRtpExtension( + RtpExtension(RtpExtension::kVideoTimingUri, kVideoTimingExtensionId)); } VideoQualityTest::InjectionComponents::InjectionComponents() = default; @@ -1185,7 +1186,8 @@ VideoQualityTest::CreateSendTransport() { params_.video[0].selected_tl, params_.ss[0].selected_sl, payload_type_map_, kVideoSendSsrcs[0], static_cast(kVideoSendSsrcs[0] + params_.ss[0].streams.size() - - 1)); + 1), + GetRegisteredExtensions(), GetRegisteredExtensions()); } std::unique_ptr @@ -1199,7 +1201,8 @@ VideoQualityTest::CreateReceiveTransport() { return std::make_unique( task_queue(), std::make_unique(clock_, std::move(network_behavior)), - receiver_call_.get(), payload_type_map_); + receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(), + GetRegisteredExtensions()); } void VideoQualityTest::RunWithAnalyzer(const Params& params) { diff --git a/video/video_quality_test.h b/video/video_quality_test.h index d1f630557e..f66256e94c 100644 --- a/video/video_quality_test.h +++ b/video/video_quality_test.h @@ -65,8 +65,6 @@ class VideoQualityTest : public test::CallTest, static std::vector ParseCSV(const std::string& str); protected: - std::map payload_type_map_; - // No-op implementation to be able to instantiate this class from non-TEST_F // locations. void TestBody() override; diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc index d4da883ce9..f0563569ee 100644 --- a/video/video_send_stream_tests.cc +++ b/video/video_send_stream_tests.cc @@ -19,6 +19,7 @@ #include "api/test/metrics/global_metrics_logger_and_exporter.h" #include "api/test/metrics/metric.h" #include "api/test/simulated_network.h" +#include "api/units/time_delta.h" #include "api/video/builtin_video_bitrate_allocator_factory.h" #include "api/video/encoded_image.h" #include "api/video/video_bitrate_allocation.h" @@ -68,6 +69,7 @@ #include "test/gtest.h" #include "test/null_transport.h" #include "test/rtcp_packet_parser.h" +#include "test/rtp_rtcp_observer.h" #include "test/video_encoder_proxy_factory.h" #include "video/config/encoder_stream_factory.h" #include "video/send_statistics_proxy.h" @@ -600,21 +602,14 @@ class UlpfecObserver : public test::EndToEndTest { return SEND_PACKET; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. // Configure some network delay. const int kNetworkDelayMs = 100; BuiltInNetworkBehaviorConfig config; config.loss_percent = 5; config.queue_delay_ms = kNetworkDelayMs; - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - VideoSendStreamTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config))); + return config; } void ModifyVideoConfigs( @@ -799,36 +794,23 @@ class FlexfecObserver : public test::EndToEndTest { return SEND_PACKET; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const { // At low RTT (< kLowRttNackMs) -> NACK only, no FEC. // Therefore we need some network delay. const int kNetworkDelayMs = 100; BuiltInNetworkBehaviorConfig config; config.loss_percent = 5; config.queue_delay_ms = kNetworkDelayMs; - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - VideoSendStreamTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config))); + return config; } - std::unique_ptr CreateReceiveTransport( - TaskQueueBase* task_queue) override { + BuiltInNetworkBehaviorConfig GetReceiveTransportConfig() const { // We need the RTT to be >200 ms to send FEC and the network delay for the // send transport is 100 ms, so add 100 ms (but no loss) on the return link. BuiltInNetworkBehaviorConfig config; config.loss_percent = 0; config.queue_delay_ms = 100; - return std::make_unique( - task_queue, nullptr, this, test::PacketTransport::kReceiver, - VideoSendStreamTest::payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config))); + return config; } void ModifyVideoConfigs( @@ -1017,6 +999,7 @@ void VideoSendStreamTest::TestNackRetransmission( sequence_numbers_pending_retransmission_.size() < kRetransmitTarget) { sequence_numbers_pending_retransmission_.insert(sequence_number); + return DROP_PACKET; } } else { // Packet is a retransmission, remove it from queue and check if done. @@ -1431,20 +1414,13 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) { return SEND_PACKET; } - std::unique_ptr CreateSendTransport( - TaskQueueBase* task_queue, - Call* sender_call) override { + BuiltInNetworkBehaviorConfig GetSendTransportConfig() const override { const int kNetworkDelayMs = 50; BuiltInNetworkBehaviorConfig config; config.loss_percent = 10; config.link_capacity_kbps = kCapacityKbps; config.queue_delay_ms = kNetworkDelayMs; - return std::make_unique( - task_queue, sender_call, this, test::PacketTransport::kSender, - payload_type_map_, - std::make_unique( - Clock::GetRealTimeClock(), - std::make_unique(config))); + return config; } void ModifyVideoConfigs(