rtp_transport_controller_send.h (10810B)
1 /* 2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #ifndef CALL_RTP_TRANSPORT_CONTROLLER_SEND_H_ 12 #define CALL_RTP_TRANSPORT_CONTROLLER_SEND_H_ 13 14 #include <cstddef> 15 #include <cstdint> 16 #include <map> 17 #include <memory> 18 #include <optional> 19 #include <string> 20 #include <vector> 21 22 #include "absl/strings/string_view.h" 23 #include "api/array_view.h" 24 #include "api/environment/environment.h" 25 #include "api/fec_controller.h" 26 #include "api/frame_transformer_interface.h" 27 #include "api/scoped_refptr.h" 28 #include "api/sequence_checker.h" 29 #include "api/task_queue/pending_task_safety_flag.h" 30 #include "api/task_queue/task_queue_base.h" 31 #include "api/transport/bandwidth_estimation_settings.h" 32 #include "api/transport/bitrate_settings.h" 33 #include "api/transport/network_control.h" 34 #include "api/transport/network_types.h" 35 #include "api/units/data_rate.h" 36 #include "api/units/data_size.h" 37 #include "api/units/time_delta.h" 38 #include "api/units/timestamp.h" 39 #include "call/rtp_bitrate_configurator.h" 40 #include "call/rtp_config.h" 41 #include "call/rtp_transport_config.h" 42 #include "call/rtp_transport_controller_send_interface.h" 43 #include "call/rtp_video_sender.h" 44 #include "modules/congestion_controller/rtp/control_handler.h" 45 #include "modules/congestion_controller/rtp/transport_feedback_adapter.h" 46 #include "modules/congestion_controller/rtp/transport_feedback_demuxer.h" 47 #include "modules/pacing/packet_router.h" 48 #include "modules/pacing/task_queue_paced_sender.h" 49 #include "modules/rtp_rtcp/include/report_block_data.h" 50 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" 51 #include "modules/rtp_rtcp/source/rtcp_packet/congestion_control_feedback.h" 52 #include "rtc_base/experiments/field_trial_parser.h" 53 #include "rtc_base/network_route.h" 54 #include "rtc_base/rate_limiter.h" 55 #include "rtc_base/task_utils/repeating_task.h" 56 #include "rtc_base/thread_annotations.h" 57 58 namespace webrtc { 59 class FrameEncryptorInterface; 60 61 class RtpTransportControllerSend final 62 : public RtpTransportControllerSendInterface, 63 public NetworkLinkRtcpObserver, 64 public NetworkStateEstimateObserver { 65 public: 66 explicit RtpTransportControllerSend(const RtpTransportConfig& config); 67 ~RtpTransportControllerSend() override; 68 69 RtpTransportControllerSend(const RtpTransportControllerSend&) = delete; 70 RtpTransportControllerSend& operator=(const RtpTransportControllerSend&) = 71 delete; 72 73 // TODO(tommi): Change to std::unique_ptr<>. 74 RtpVideoSenderInterface* CreateRtpVideoSender( 75 const std::map<uint32_t, RtpState>& suspended_ssrcs, 76 const std::map<uint32_t, RtpPayloadState>& 77 states, // move states into RtpTransportControllerSend 78 const RtpConfig& rtp_config, 79 int rtcp_report_interval_ms, 80 Transport* send_transport, 81 const RtpSenderObservers& observers, 82 std::unique_ptr<FecController> fec_controller, 83 const RtpSenderFrameEncryptionConfig& frame_encryption_config, 84 scoped_refptr<FrameTransformerInterface> frame_transformer) override; 85 void DestroyRtpVideoSender( 86 RtpVideoSenderInterface* rtp_video_sender) override; 87 88 // Implements RtpTransportControllerSendInterface 89 void RegisterSendingRtpStream(RtpRtcpInterface& rtp_module) override; 90 void DeRegisterSendingRtpStream(RtpRtcpInterface& rtp_module) override; 91 PacketRouter* packet_router() override; 92 93 NetworkStateEstimateObserver* network_state_estimate_observer() override; 94 RtpPacketSender* packet_sender() override; 95 96 void SetAllocatedSendBitrateLimits(BitrateAllocationLimits limits) override; 97 void ReconfigureBandwidthEstimation( 98 const BandwidthEstimationSettings& settings) override; 99 100 void SetPacingFactor(float pacing_factor) override; 101 void SetQueueTimeLimit(int limit_ms) override; 102 StreamFeedbackProvider* GetStreamFeedbackProvider() override; 103 void RegisterTargetTransferRateObserver( 104 TargetTransferRateObserver* observer) override; 105 void OnNetworkRouteChanged(absl::string_view transport_name, 106 const NetworkRoute& network_route) override; 107 void OnNetworkAvailability(bool network_available) override; 108 NetworkLinkRtcpObserver* GetRtcpObserver() override; 109 int64_t GetPacerQueuingDelayMs() const override; 110 std::optional<Timestamp> GetFirstPacketTime() const override; 111 void EnablePeriodicAlrProbing(bool enable) override; 112 void OnSentPacket(const SentPacketInfo& sent_packet) override; 113 void OnReceivedPacket(const ReceivedPacket& packet_msg) override; 114 115 void SetSdpBitrateParameters(const BitrateConstraints& constraints) override; 116 void SetClientBitratePreferences(const BitrateSettings& preferences) override; 117 118 void OnTransportOverheadChanged( 119 size_t transport_overhead_bytes_per_packet) override; 120 121 void AccountForAudioPacketsInPacedSender(bool account_for_audio) override; 122 void IncludeOverheadInPacedSender() override; 123 void EnsureStarted() override; 124 125 // Implements NetworkLinkRtcpObserver interface 126 void OnReceiverEstimatedMaxBitrate(Timestamp receive_time, 127 DataRate bitrate) override; 128 void OnReport(Timestamp receive_time, 129 ArrayView<const ReportBlockData> report_blocks) override; 130 void OnRttUpdate(Timestamp receive_time, TimeDelta rtt) override; 131 void OnTransportFeedback(Timestamp receive_time, 132 const rtcp::TransportFeedback& feedback) override; 133 void OnCongestionControlFeedback( 134 Timestamp receive_time, 135 const rtcp::CongestionControlFeedback& feedback) override; 136 137 // Implements NetworkStateEstimateObserver interface 138 void OnRemoteNetworkEstimate(NetworkStateEstimate estimate) override; 139 140 NetworkControllerInterface* GetNetworkController() override { 141 RTC_DCHECK_RUN_ON(&sequence_checker_); 142 return controller_.get(); 143 } 144 145 // Called once it's known that the remote end supports RFC 8888. 146 void EnableCongestionControlFeedbackAccordingToRfc8888() override; 147 148 std::optional<int> ReceivedCongestionControlFeedbackCount() const override; 149 std::optional<int> ReceivedTransportCcFeedbackCount() const override; 150 151 private: 152 void MaybeCreateControllers() RTC_RUN_ON(sequence_checker_); 153 void HandleTransportPacketsFeedback(const TransportPacketsFeedback& feedback) 154 RTC_RUN_ON(sequence_checker_); 155 void UpdateNetworkAvailability() RTC_RUN_ON(sequence_checker_); 156 void UpdateInitialConstraints(TargetRateConstraints new_contraints) 157 RTC_RUN_ON(sequence_checker_); 158 159 void StartProcessPeriodicTasks() RTC_RUN_ON(sequence_checker_); 160 void UpdateControllerWithTimeInterval() RTC_RUN_ON(sequence_checker_); 161 162 std::optional<BitrateConstraints> ApplyOrLiftRelayCap(bool is_relayed); 163 bool IsRelevantRouteChange(const NetworkRoute& old_route, 164 const NetworkRoute& new_route) const; 165 void UpdateBitrateConstraints(const BitrateConstraints& updated); 166 void UpdateStreamsConfig() RTC_RUN_ON(sequence_checker_); 167 void PostUpdates(NetworkControlUpdate update) RTC_RUN_ON(sequence_checker_); 168 void UpdateControlState() RTC_RUN_ON(sequence_checker_); 169 void UpdateCongestedState() RTC_RUN_ON(sequence_checker_); 170 std::optional<bool> GetCongestedStateUpdate() const 171 RTC_RUN_ON(sequence_checker_); 172 173 // Called by packet router just before packet is sent to the RTP modules. 174 void NotifyBweOfPacedSentPacket(const RtpPacketToSend& packet, 175 const PacedPacketInfo& pacing_info); 176 void ProcessSentPacket(const SentPacketInfo& sent_packet) 177 RTC_RUN_ON(sequence_checker_); 178 void ProcessSentPacketUpdates(NetworkControlUpdate updates) 179 RTC_RUN_ON(sequence_checker_); 180 181 const Environment env_; 182 SequenceChecker sequence_checker_; 183 TaskQueueBase* task_queue_; 184 PacketRouter packet_router_; 185 186 std::vector<std::unique_ptr<RtpVideoSenderInterface>> video_rtp_senders_ 187 RTC_GUARDED_BY(&sequence_checker_); 188 RtpBitrateConfigurator bitrate_configurator_; 189 std::map<std::string, NetworkRoute> network_routes_ 190 RTC_GUARDED_BY(sequence_checker_); 191 BandwidthEstimationSettings bwe_settings_ RTC_GUARDED_BY(sequence_checker_); 192 bool pacer_started_ RTC_GUARDED_BY(sequence_checker_); 193 TaskQueuePacedSender pacer_; 194 195 TargetTransferRateObserver* observer_ RTC_GUARDED_BY(sequence_checker_); 196 TransportFeedbackDemuxer feedback_demuxer_; 197 198 TransportFeedbackAdapter transport_feedback_adapter_ 199 RTC_GUARDED_BY(sequence_checker_); 200 201 NetworkControllerFactoryInterface* const controller_factory_override_ 202 RTC_PT_GUARDED_BY(sequence_checker_); 203 const std::unique_ptr<NetworkControllerFactoryInterface> 204 controller_factory_fallback_ RTC_PT_GUARDED_BY(sequence_checker_); 205 206 std::unique_ptr<CongestionControlHandler> control_handler_ 207 RTC_GUARDED_BY(sequence_checker_) RTC_PT_GUARDED_BY(sequence_checker_); 208 209 std::unique_ptr<NetworkControllerInterface> controller_ 210 RTC_GUARDED_BY(sequence_checker_) RTC_PT_GUARDED_BY(sequence_checker_); 211 212 TimeDelta process_interval_ RTC_GUARDED_BY(sequence_checker_); 213 214 struct LossReport { 215 uint32_t extended_highest_sequence_number = 0; 216 int cumulative_lost = 0; 217 }; 218 std::map<uint32_t, LossReport> last_report_blocks_ 219 RTC_GUARDED_BY(sequence_checker_); 220 Timestamp last_report_block_time_ RTC_GUARDED_BY(sequence_checker_); 221 222 NetworkControllerConfig initial_config_ RTC_GUARDED_BY(sequence_checker_); 223 StreamsConfig streams_config_ RTC_GUARDED_BY(sequence_checker_); 224 225 const bool reset_feedback_on_route_change_; 226 const bool add_pacing_to_cwin_; 227 const bool reset_bwe_on_adapter_id_change_; 228 229 FieldTrialParameter<DataRate> relay_bandwidth_cap_; 230 231 size_t transport_overhead_bytes_per_packet_ RTC_GUARDED_BY(sequence_checker_); 232 bool network_available_ RTC_GUARDED_BY(sequence_checker_); 233 RepeatingTaskHandle pacer_queue_update_task_ 234 RTC_GUARDED_BY(sequence_checker_); 235 RepeatingTaskHandle controller_task_ RTC_GUARDED_BY(sequence_checker_); 236 237 DataSize congestion_window_size_ RTC_GUARDED_BY(sequence_checker_); 238 bool is_congested_ RTC_GUARDED_BY(sequence_checker_); 239 bool transport_maybe_support_ecn_ = 240 false; // True if RFC8888 has been negotiated. 241 bool sending_packets_as_ect1_ = false; 242 // Count of feedback messages received. 243 int feedback_count_ RTC_GUARDED_BY(sequence_checker_) = 0; 244 int transport_cc_feedback_count_ RTC_GUARDED_BY(sequence_checker_) = 0; 245 246 // Protected by internal locks. 247 RateLimiter retransmission_rate_limiter_; 248 249 ScopedTaskSafety safety_; 250 }; 251 252 } // namespace webrtc 253 254 #endif // CALL_RTP_TRANSPORT_CONTROLLER_SEND_H_