From 504fc192d09c51c21777eeefe883827b9f6ed8ab Mon Sep 17 00:00:00 2001 From: Vojin Ilic Date: Mon, 31 May 2021 14:02:28 +0200 Subject: Add ability to pass factory for RtpTransportControllerSend to PeerConnectionFactoryDependencies. This way we can have custom implementation of RtpTransportControllerSendInterface and pass it properly to Call. Call relies on RtpTransportControllerSendInterface already so this is natural way to customize RTP related classes. If there is custom factory present in dependencies it will be used, otherwise default factory will be used. Intention behind this change is to have ability to have custom QoS with custom parameters. Bug: webrtc:12778 Change-Id: I5b88957025621ef4bcd63eaa98c218ad213da9c8 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/217769 Reviewed-by: Harald Alvestrand Reviewed-by: Niels Moller Commit-Queue: Philipp Hancke Cr-Commit-Position: refs/heads/master@{#34181} --- api/BUILD.gn | 7 ++- api/DEPS | 6 +++ api/peer_connection_interface.h | 3 ++ api/test/create_time_controller.cc | 9 +++- call/BUILD.gn | 8 ++++ call/call.cc | 27 ++++++++---- call/call.h | 7 ++- call/call_config.cc | 13 ++++++ call/call_config.h | 6 +++ call/call_factory.cc | 22 ++++++++-- call/rtp_transport_config.h | 51 ++++++++++++++++++++++ call/rtp_transport_controller_send_factory.h | 37 ++++++++++++++++ ...p_transport_controller_send_factory_interface.h | 32 ++++++++++++++ pc/BUILD.gn | 2 + pc/peer_connection_factory.cc | 10 ++++- pc/peer_connection_factory.h | 4 ++ 16 files changed, 225 insertions(+), 19 deletions(-) create mode 100644 call/rtp_transport_config.h create mode 100644 call/rtp_transport_controller_send_factory.h create mode 100644 call/rtp_transport_controller_send_factory_interface.h diff --git a/api/BUILD.gn b/api/BUILD.gn index 6a04f4fcf3..e1c45e2032 100644 --- a/api/BUILD.gn +++ b/api/BUILD.gn @@ -29,7 +29,10 @@ rtc_source_set("call_api") { rtc_source_set("callfactory_api") { visibility = [ "*" ] sources = [ "call/call_factory_interface.h" ] - deps = [ "../rtc_base/system:rtc_export" ] + deps = [ + "../call:rtp_interfaces", + "../rtc_base/system:rtc_export", + ] } if (!build_with_chromium) { @@ -172,6 +175,7 @@ rtc_library("libjingle_peerconnection_api") { ":rtp_transceiver_direction", ":scoped_refptr", ":sequence_checker", + "../call:rtp_interfaces", "../rtc_base:network_constants", "adaptation:resource_adaptation_api", "audio:audio_mixer_api", @@ -1053,6 +1057,7 @@ if (rtc_include_tests) { ":time_controller", "../call", "../call:call_interfaces", + "../call:rtp_interfaces", "../test/time_controller", ] } diff --git a/api/DEPS b/api/DEPS index afec84d8ec..bfa989f85f 100644 --- a/api/DEPS +++ b/api/DEPS @@ -42,6 +42,11 @@ include_rules = [ specific_include_rules = { # Some internal headers are allowed even in API headers: + + "call_factory_interface\.h": [ + "+call/rtp_transport_controller_send_factory_interface.h", + ], + ".*\.h": [ "+rtc_base/checks.h", "+rtc_base/system/rtc_export.h", @@ -126,6 +131,7 @@ specific_include_rules = { ], "peer_connection_interface\.h": [ + "+call/rtp_transport_controller_send_factory_interface.h", "+media/base/media_config.h", "+media/base/media_engine.h", "+p2p/base/port.h", diff --git a/api/peer_connection_interface.h b/api/peer_connection_interface.h index e815f19518..ad3f70c323 100644 --- a/api/peer_connection_interface.h +++ b/api/peer_connection_interface.h @@ -118,6 +118,7 @@ #include "api/transport/webrtc_key_value_config.h" #include "api/turn_customizer.h" #include "api/video/video_bitrate_allocator_factory.h" +#include "call/rtp_transport_controller_send_factory_interface.h" #include "media/base/media_config.h" #include "media/base/media_engine.h" // TODO(bugs.webrtc.org/7447): We plan to provide a way to let applications @@ -1402,6 +1403,8 @@ struct RTC_EXPORT PeerConnectionFactoryDependencies final { std::unique_ptr neteq_factory; std::unique_ptr sctp_factory; std::unique_ptr trials; + std::unique_ptr + transport_controller_send_factory; }; // PeerConnectionFactoryInterface is the factory interface used for creating diff --git a/api/test/create_time_controller.cc b/api/test/create_time_controller.cc index a2c0cb713f..f7faeaab42 100644 --- a/api/test/create_time_controller.cc +++ b/api/test/create_time_controller.cc @@ -13,6 +13,8 @@ #include #include "call/call.h" +#include "call/rtp_transport_config.h" +#include "call/rtp_transport_controller_send_factory_interface.h" #include "test/time_controller/external_time_controller.h" #include "test/time_controller/simulated_time_controller.h" @@ -40,8 +42,13 @@ std::unique_ptr CreateTimeControllerBasedCallFactory( time_controller_->CreateProcessThread("CallModules"), [this]() { module_thread_ = nullptr; }); } + + RtpTransportConfig transportConfig = config.ExtractTransportConfig(); + return Call::Create(config, time_controller_->GetClock(), module_thread_, - time_controller_->CreateProcessThread("Pacer")); + config.rtp_transport_controller_send_factory->Create( + transportConfig, time_controller_->GetClock(), + time_controller_->CreateProcessThread("Pacer"))); } private: diff --git a/call/BUILD.gn b/call/BUILD.gn index 9f0cd037f3..ffe3da5820 100644 --- a/call/BUILD.gn +++ b/call/BUILD.gn @@ -98,22 +98,29 @@ rtc_library("rtp_interfaces") { "rtp_config.h", "rtp_packet_sink_interface.h", "rtp_stream_receiver_controller_interface.h", + "rtp_transport_config.h", + "rtp_transport_controller_send_factory_interface.h", "rtp_transport_controller_send_interface.h", ] deps = [ "../api:array_view", "../api:fec_controller_api", "../api:frame_transformer_interface", + "../api:network_state_predictor_api", "../api:rtp_headers", "../api:rtp_parameters", "../api/crypto:options", "../api/rtc_event_log", "../api/transport:bitrate_settings", + "../api/transport:network_control", + "../api/transport:webrtc_key_value_config", "../api/units:timestamp", "../common_video:frame_counts", "../modules/rtp_rtcp:rtp_rtcp_format", + "../modules/utility", "../rtc_base:checks", "../rtc_base:rtc_base_approved", + "../rtc_base:rtc_task_queue", ] absl_deps = [ "//third_party/abseil-cpp/absl/algorithm:container", @@ -150,6 +157,7 @@ rtc_library("rtp_sender") { "rtp_payload_params.h", "rtp_transport_controller_send.cc", "rtp_transport_controller_send.h", + "rtp_transport_controller_send_factory.h", "rtp_video_sender.cc", "rtp_video_sender.h", "rtp_video_sender_interface.h", diff --git a/call/call.cc b/call/call.cc index b8eafdc923..aea03af8d3 100644 --- a/call/call.cc +++ b/call/call.cc @@ -33,6 +33,7 @@ #include "call/receive_time_calculator.h" #include "call/rtp_stream_receiver_controller.h" #include "call/rtp_transport_controller_send.h" +#include "call/rtp_transport_controller_send_factory.h" #include "call/version.h" #include "logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h" #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_incoming.h" @@ -519,11 +520,6 @@ Call* Call::Create(const Call::Config& config) { rtc::scoped_refptr call_thread = SharedModuleThread::Create(ProcessThread::Create("ModuleProcessThread"), nullptr); - return Create(config, std::move(call_thread)); -} - -Call* Call::Create(const Call::Config& config, - rtc::scoped_refptr call_thread) { return Create(config, Clock::GetRealTimeClock(), std::move(call_thread), ProcessThread::Create("PacerThread")); } @@ -533,15 +529,28 @@ Call* Call::Create(const Call::Config& config, rtc::scoped_refptr call_thread, std::unique_ptr pacer_thread) { RTC_DCHECK(config.task_queue_factory); + + RtpTransportControllerSendFactory transport_controller_factory_; + + RtpTransportConfig transportConfig = config.ExtractTransportConfig(); + return new internal::Call( clock, config, - std::make_unique( - clock, config.event_log, config.network_state_predictor_factory, - config.network_controller_factory, config.bitrate_config, - std::move(pacer_thread), config.task_queue_factory, config.trials), + transport_controller_factory_.Create(transportConfig, clock, + std::move(pacer_thread)), std::move(call_thread), config.task_queue_factory); } +Call* Call::Create(const Call::Config& config, + Clock* clock, + rtc::scoped_refptr call_thread, + std::unique_ptr + transportControllerSend) { + RTC_DCHECK(config.task_queue_factory); + return new internal::Call(clock, config, std::move(transportControllerSend), + std::move(call_thread), config.task_queue_factory); +} + class SharedModuleThread::Impl { public: Impl(std::unique_ptr process_thread, diff --git a/call/call.h b/call/call.h index 37d784f726..86d0620e62 100644 --- a/call/call.h +++ b/call/call.h @@ -83,12 +83,15 @@ class Call { }; static Call* Create(const Call::Config& config); - static Call* Create(const Call::Config& config, - rtc::scoped_refptr call_thread); static Call* Create(const Call::Config& config, Clock* clock, rtc::scoped_refptr call_thread, std::unique_ptr pacer_thread); + static Call* Create(const Call::Config& config, + Clock* clock, + rtc::scoped_refptr call_thread, + std::unique_ptr + transportControllerSend); virtual AudioSendStream* CreateAudioSendStream( const AudioSendStream::Config& config) = 0; diff --git a/call/call_config.cc b/call/call_config.cc index 8b3c91222e..23b60ce436 100644 --- a/call/call_config.cc +++ b/call/call_config.cc @@ -22,6 +22,19 @@ CallConfig::CallConfig(RtcEventLog* event_log, CallConfig::CallConfig(const CallConfig& config) = default; +RtpTransportConfig CallConfig::ExtractTransportConfig() const { + RtpTransportConfig transportConfig; + transportConfig.bitrate_config = bitrate_config; + transportConfig.event_log = event_log; + transportConfig.network_controller_factory = network_controller_factory; + transportConfig.network_state_predictor_factory = + network_state_predictor_factory; + transportConfig.task_queue_factory = task_queue_factory; + transportConfig.trials = trials; + + return transportConfig; +} + CallConfig::~CallConfig() = default; } // namespace webrtc diff --git a/call/call_config.h b/call/call_config.h index 95dad36002..ba6dec3ad6 100644 --- a/call/call_config.h +++ b/call/call_config.h @@ -19,6 +19,8 @@ #include "api/transport/network_control.h" #include "api/transport/webrtc_key_value_config.h" #include "call/audio_state.h" +#include "call/rtp_transport_config.h" +#include "call/rtp_transport_controller_send_factory_interface.h" namespace webrtc { @@ -32,6 +34,7 @@ struct CallConfig { explicit CallConfig(RtcEventLog* event_log, TaskQueueBase* network_task_queue = nullptr); CallConfig(const CallConfig&); + RtpTransportConfig ExtractTransportConfig() const; ~CallConfig(); // Bitrate config used until valid bitrate estimates are calculated. Also @@ -69,6 +72,9 @@ struct CallConfig { const WebRtcKeyValueConfig* trials = nullptr; TaskQueueBase* const network_task_queue_ = nullptr; + // RtpTransportControllerSend to use for this call. + RtpTransportControllerSendFactoryInterface* + rtp_transport_controller_send_factory = nullptr; }; } // namespace webrtc diff --git a/call/call_factory.cc b/call/call_factory.cc index cc02c02835..aeb3cbdaa7 100644 --- a/call/call_factory.cc +++ b/call/call_factory.cc @@ -14,11 +14,13 @@ #include #include +#include #include "absl/types/optional.h" #include "api/test/simulated_network.h" #include "call/call.h" #include "call/degraded_call.h" +#include "call/rtp_transport_config.h" #include "rtc_base/checks.h" #include "system_wrappers/include/field_trial.h" @@ -81,10 +83,19 @@ Call* CallFactory::CreateCall(const Call::Config& config) { absl::optional receive_degradation_config = ParseDegradationConfig(false); + RtpTransportConfig transportConfig = config.ExtractTransportConfig(); + if (send_degradation_config || receive_degradation_config) { - return new DegradedCall(std::unique_ptr(Call::Create(config)), - send_degradation_config, receive_degradation_config, - config.task_queue_factory); + return new DegradedCall( + std::unique_ptr(Call::Create( + config, Clock::GetRealTimeClock(), + SharedModuleThread::Create( + ProcessThread::Create("ModuleProcessThread"), nullptr), + config.rtp_transport_controller_send_factory->Create( + transportConfig, Clock::GetRealTimeClock(), + ProcessThread::Create("PacerThread")))), + send_degradation_config, receive_degradation_config, + config.task_queue_factory); } if (!module_thread_) { @@ -95,7 +106,10 @@ Call* CallFactory::CreateCall(const Call::Config& config) { }); } - return Call::Create(config, module_thread_); + return Call::Create(config, Clock::GetRealTimeClock(), module_thread_, + config.rtp_transport_controller_send_factory->Create( + transportConfig, Clock::GetRealTimeClock(), + ProcessThread::Create("PacerThread"))); } std::unique_ptr CreateCallFactory() { diff --git a/call/rtp_transport_config.h b/call/rtp_transport_config.h new file mode 100644 index 0000000000..9aa9f14c16 --- /dev/null +++ b/call/rtp_transport_config.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef CALL_RTP_TRANSPORT_CONFIG_H_ +#define CALL_RTP_TRANSPORT_CONFIG_H_ + +#include + +#include "api/network_state_predictor.h" +#include "api/rtc_event_log/rtc_event_log.h" +#include "api/transport/bitrate_settings.h" +#include "api/transport/network_control.h" +#include "api/transport/webrtc_key_value_config.h" +#include "modules/utility/include/process_thread.h" +#include "rtc_base/task_queue.h" + +namespace webrtc { + +struct RtpTransportConfig { + // Bitrate config used until valid bitrate estimates are calculated. Also + // used to cap total bitrate used. This comes from the remote connection. + BitrateConstraints bitrate_config; + + // RtcEventLog to use for this call. Required. + // Use webrtc::RtcEventLog::CreateNull() for a null implementation. + RtcEventLog* event_log = nullptr; + + // Task Queue Factory to be used in this call. Required. + TaskQueueFactory* task_queue_factory = nullptr; + + // NetworkStatePredictor to use for this call. + NetworkStatePredictorFactoryInterface* network_state_predictor_factory = + nullptr; + + // Network controller factory to use for this call. + NetworkControllerFactoryInterface* network_controller_factory = nullptr; + + // Key-value mapping of internal configurations to apply, + // e.g. field trials. + const WebRtcKeyValueConfig* trials = nullptr; +}; +} // namespace webrtc + +#endif // CALL_RTP_TRANSPORT_CONFIG_H_ diff --git a/call/rtp_transport_controller_send_factory.h b/call/rtp_transport_controller_send_factory.h new file mode 100644 index 0000000000..a857ca7e6f --- /dev/null +++ b/call/rtp_transport_controller_send_factory.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 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. + */ + +#ifndef CALL_RTP_TRANSPORT_CONTROLLER_SEND_FACTORY_H_ +#define CALL_RTP_TRANSPORT_CONTROLLER_SEND_FACTORY_H_ + +#include +#include + +#include "call/rtp_transport_controller_send.h" +#include "call/rtp_transport_controller_send_factory_interface.h" + +namespace webrtc { +class RtpTransportControllerSendFactory + : public RtpTransportControllerSendFactoryInterface { + public: + std::unique_ptr Create( + const RtpTransportConfig& config, + Clock* clock, + std::unique_ptr process_thread) override { + return std::make_unique( + clock, config.event_log, config.network_state_predictor_factory, + config.network_controller_factory, config.bitrate_config, + std::move(process_thread), config.task_queue_factory, config.trials); + } + + virtual ~RtpTransportControllerSendFactory() {} +}; +} // namespace webrtc +#endif // CALL_RTP_TRANSPORT_CONTROLLER_SEND_FACTORY_H_ diff --git a/call/rtp_transport_controller_send_factory_interface.h b/call/rtp_transport_controller_send_factory_interface.h new file mode 100644 index 0000000000..a0218532a1 --- /dev/null +++ b/call/rtp_transport_controller_send_factory_interface.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2021 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. + */ +#ifndef CALL_RTP_TRANSPORT_CONTROLLER_SEND_FACTORY_INTERFACE_H_ +#define CALL_RTP_TRANSPORT_CONTROLLER_SEND_FACTORY_INTERFACE_H_ + +#include + +#include "call/rtp_transport_config.h" +#include "call/rtp_transport_controller_send_interface.h" +#include "modules/utility/include/process_thread.h" + +namespace webrtc { +// A factory used for dependency injection on the send side of the transport +// controller. +class RtpTransportControllerSendFactoryInterface { + public: + virtual std::unique_ptr Create( + const RtpTransportConfig& config, + Clock* clock, + std::unique_ptr process_thread) = 0; + + virtual ~RtpTransportControllerSendFactoryInterface() {} +}; +} // namespace webrtc +#endif // CALL_RTP_TRANSPORT_CONTROLLER_SEND_FACTORY_INTERFACE_H_ diff --git a/pc/BUILD.gn b/pc/BUILD.gn index a6eae1604b..f66ec07250 100644 --- a/pc/BUILD.gn +++ b/pc/BUILD.gn @@ -301,6 +301,8 @@ rtc_library("peerconnection") { "../api/video:video_rtp_headers", "../api/video_codecs:video_codecs_api", "../call:call_interfaces", + "../call:rtp_interfaces", + "../call:rtp_sender", "../common_video", "../logging:ice_log", "../media:rtc_data_sctp_transport_internal", diff --git a/pc/peer_connection_factory.cc b/pc/peer_connection_factory.cc index d4e199cbe2..50755a38c7 100644 --- a/pc/peer_connection_factory.cc +++ b/pc/peer_connection_factory.cc @@ -25,6 +25,7 @@ #include "api/transport/bitrate_settings.h" #include "api/units/data_rate.h" #include "call/audio_state.h" +#include "call/rtp_transport_controller_send_factory.h" #include "media/base/media_engine.h" #include "p2p/base/basic_async_resolver_factory.h" #include "p2p/base/basic_packet_socket_factory.h" @@ -100,7 +101,11 @@ PeerConnectionFactory::PeerConnectionFactory( std::move(dependencies->network_state_predictor_factory)), injected_network_controller_factory_( std::move(dependencies->network_controller_factory)), - neteq_factory_(std::move(dependencies->neteq_factory)) {} + neteq_factory_(std::move(dependencies->neteq_factory)), + transport_controller_send_factory_( + (dependencies->transport_controller_send_factory) + ? std::move(dependencies->transport_controller_send_factory) + : std::make_unique()) {} PeerConnectionFactory::PeerConnectionFactory( PeerConnectionFactoryDependencies dependencies) @@ -334,7 +339,8 @@ std::unique_ptr PeerConnectionFactory::CreateCall_w( } call_config.trials = &trials(); - + call_config.rtp_transport_controller_send_factory = + transport_controller_send_factory_.get(); return std::unique_ptr( context_->call_factory()->CreateCall(call_config)); } diff --git a/pc/peer_connection_factory.h b/pc/peer_connection_factory.h index bd2efe457e..4946ec6ea2 100644 --- a/pc/peer_connection_factory.h +++ b/pc/peer_connection_factory.h @@ -14,6 +14,7 @@ #include #include + #include #include @@ -36,6 +37,7 @@ #include "api/transport/sctp_transport_factory_interface.h" #include "api/transport/webrtc_key_value_config.h" #include "call/call.h" +#include "call/rtp_transport_controller_send_factory_interface.h" #include "p2p/base/port_allocator.h" #include "pc/channel_manager.h" #include "pc/connection_context.h" @@ -148,6 +150,8 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface { std::unique_ptr injected_network_controller_factory_; std::unique_ptr neteq_factory_; + const std::unique_ptr + transport_controller_send_factory_; }; } // namespace webrtc -- cgit v1.2.3