blob: e08e0f143df82a62d43316954f25cf5778f895d2 [file] [log] [blame]
nissecae45d02017-04-24 05:53:20 -07001/*
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 */
Jonas Olssona4d87372019-07-05 19:08:33 +020010#include "call/rtp_transport_controller_send.h"
11
Sebastian Jansson91bb6672018-02-21 13:02:51 +010012#include <utility>
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020013#include <vector>
nissecae45d02017-04-24 05:53:20 -070014
Karl Wiberg918f50c2018-07-05 11:40:33 +020015#include "absl/memory/memory.h"
Yves Gerey3e707812018-11-28 16:47:49 +010016#include "absl/types/optional.h"
Sebastian Jansson87609be2018-12-05 17:35:35 +010017#include "api/transport/goog_cc_factory.h"
Yves Gerey3e707812018-11-28 16:47:49 +010018#include "api/transport/network_types.h"
19#include "api/units/data_rate.h"
20#include "api/units/time_delta.h"
21#include "api/units/timestamp.h"
Yves Gerey3e707812018-11-28 16:47:49 +010022#include "call/rtp_video_sender.h"
Sebastian Jansson166b45d2019-05-13 11:57:42 +020023#include "logging/rtc_event_log/events/rtc_event_route_change.h"
Yves Gerey3e707812018-11-28 16:47:49 +010024#include "rtc_base/checks.h"
Sebastian Janssonc33c0fc2018-02-22 11:10:18 +010025#include "rtc_base/location.h"
Sebastian Jansson97f61ea2018-02-21 13:01:55 +010026#include "rtc_base/logging.h"
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020027#include "rtc_base/rate_limiter.h"
Sebastian Jansson19bea512018-03-13 19:07:46 +010028#include "system_wrappers/include/field_trial.h"
nissecae45d02017-04-24 05:53:20 -070029
30namespace webrtc {
Sebastian Jansson19bea512018-03-13 19:07:46 +010031namespace {
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020032static const int64_t kRetransmitWindowSizeMs = 500;
Stefan Holmer64be7fa2018-10-04 15:21:55 +020033static const size_t kMaxOverheadBytes = 500;
Sebastian Jansson19bea512018-03-13 19:07:46 +010034
Sebastian Janssonecb68972019-01-18 10:30:54 +010035constexpr TimeDelta kPacerQueueUpdateInterval = TimeDelta::Millis<25>();
Sebastian Jansson87609be2018-12-05 17:35:35 +010036
37TargetRateConstraints ConvertConstraints(int min_bitrate_bps,
38 int max_bitrate_bps,
39 int start_bitrate_bps,
Sebastian Janssonaa01f272019-01-30 11:28:59 +010040 Clock* clock) {
Sebastian Jansson87609be2018-12-05 17:35:35 +010041 TargetRateConstraints msg;
42 msg.at_time = Timestamp::ms(clock->TimeInMilliseconds());
43 msg.min_data_rate =
44 min_bitrate_bps >= 0 ? DataRate::bps(min_bitrate_bps) : DataRate::Zero();
45 msg.max_data_rate = max_bitrate_bps > 0 ? DataRate::bps(max_bitrate_bps)
46 : DataRate::Infinity();
47 if (start_bitrate_bps > 0)
48 msg.starting_rate = DataRate::bps(start_bitrate_bps);
49 return msg;
50}
51
52TargetRateConstraints ConvertConstraints(const BitrateConstraints& contraints,
Sebastian Janssonaa01f272019-01-30 11:28:59 +010053 Clock* clock) {
Sebastian Jansson87609be2018-12-05 17:35:35 +010054 return ConvertConstraints(contraints.min_bitrate_bps,
55 contraints.max_bitrate_bps,
56 contraints.start_bitrate_bps, clock);
57}
Sebastian Jansson19bea512018-03-13 19:07:46 +010058} // namespace
nissecae45d02017-04-24 05:53:20 -070059
60RtpTransportControllerSend::RtpTransportControllerSend(
61 Clock* clock,
Sebastian Jansson97f61ea2018-02-21 13:01:55 +010062 webrtc::RtcEventLog* event_log,
Ying Wang0810a7c2019-04-10 13:48:24 +020063 NetworkStatePredictorFactoryInterface* predictor_factory,
Sebastian Janssondfce03a2018-05-18 18:05:10 +020064 NetworkControllerFactoryInterface* controller_factory,
Sebastian Janssoned50e6c2019-03-01 14:45:21 +010065 const BitrateConstraints& bitrate_config,
66 std::unique_ptr<ProcessThread> process_thread,
67 TaskQueueFactory* task_queue_factory)
Sebastian Jansson19704ec2018-03-12 15:59:12 +010068 : clock_(clock),
Sebastian Jansson166b45d2019-05-13 11:57:42 +020069 event_log_(event_log),
Sebastian Jansson19704ec2018-03-12 15:59:12 +010070 pacer_(clock, &packet_router_, event_log),
Sebastian Jansson317a5222018-03-16 15:36:37 +010071 bitrate_configurator_(bitrate_config),
Sebastian Janssoned50e6c2019-03-01 14:45:21 +010072 process_thread_(std::move(process_thread)),
Sebastian Jansson317a5222018-03-16 15:36:37 +010073 observer_(nullptr),
Sebastian Jansson87609be2018-12-05 17:35:35 +010074 controller_factory_override_(controller_factory),
75 controller_factory_fallback_(
Sebastian Janssondf88cc02019-04-15 15:42:25 +020076 absl::make_unique<GoogCcNetworkControllerFactory>(predictor_factory)),
Sebastian Jansson87609be2018-12-05 17:35:35 +010077 process_interval_(controller_factory_fallback_->GetProcessInterval()),
78 last_report_block_time_(Timestamp::ms(clock_->TimeInMilliseconds())),
79 reset_feedback_on_route_change_(
80 !field_trial::IsEnabled("WebRTC-Bwe-NoFeedbackReset")),
81 send_side_bwe_with_overhead_(
82 webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")),
Christoffer Rodbroc610e262019-01-08 10:49:19 +010083 add_pacing_to_cwin_(
84 field_trial::IsEnabled("WebRTC-AddPacingToCongestionWindowPushback")),
Sebastian Jansson87609be2018-12-05 17:35:35 +010085 transport_overhead_bytes_per_packet_(0),
86 network_available_(false),
Stefan Holmerdbdb3a02018-07-17 16:03:46 +020087 retransmission_rate_limiter_(clock, kRetransmitWindowSizeMs),
Sebastian Janssoned50e6c2019-03-01 14:45:21 +010088 task_queue_(task_queue_factory->CreateTaskQueue(
89 "rtp_send_controller",
90 TaskQueueFactory::Priority::NORMAL)) {
Sebastian Jansson87609be2018-12-05 17:35:35 +010091 initial_config_.constraints = ConvertConstraints(bitrate_config, clock_);
Sebastian Janssondf88cc02019-04-15 15:42:25 +020092 initial_config_.event_log = event_log;
93 initial_config_.key_value_config = &trial_based_config_;
Sebastian Jansson87609be2018-12-05 17:35:35 +010094 RTC_DCHECK(bitrate_config.start_bitrate_bps > 0);
95
Sebastian Jansson02c4f152018-12-20 09:41:03 +010096 pacer_.SetPacingRates(bitrate_config.start_bitrate_bps, 0);
Sebastian Janssonbd9fe092018-05-07 16:33:50 +020097
Sebastian Janssonc33c0fc2018-02-22 11:10:18 +010098 process_thread_->RegisterModule(&pacer_, RTC_FROM_HERE);
Sebastian Janssonc33c0fc2018-02-22 11:10:18 +010099 process_thread_->Start();
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100100}
Sebastian Janssonc33c0fc2018-02-22 11:10:18 +0100101
102RtpTransportControllerSend::~RtpTransportControllerSend() {
103 process_thread_->Stop();
Sebastian Janssonc33c0fc2018-02-22 11:10:18 +0100104 process_thread_->DeRegisterModule(&pacer_);
105}
nissecae45d02017-04-24 05:53:20 -0700106
Stefan Holmer9416ef82018-07-19 10:34:38 +0200107RtpVideoSenderInterface* RtpTransportControllerSend::CreateRtpVideoSender(
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200108 std::map<uint32_t, RtpState> suspended_ssrcs,
109 const std::map<uint32_t, RtpPayloadState>& states,
110 const RtpConfig& rtp_config,
Jiawei Ou55718122018-11-09 13:17:39 -0800111 int rtcp_report_interval_ms,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200112 Transport* send_transport,
113 const RtpSenderObservers& observers,
Stefan Holmer64be7fa2018-10-04 15:21:55 +0200114 RtcEventLog* event_log,
Benjamin Wright192eeec2018-10-17 17:27:25 -0700115 std::unique_ptr<FecController> fec_controller,
116 const RtpSenderFrameEncryptionConfig& frame_encryption_config) {
Stefan Holmer9416ef82018-07-19 10:34:38 +0200117 video_rtp_senders_.push_back(absl::make_unique<RtpVideoSender>(
Sebastian Jansson572c60f2019-03-04 18:30:41 +0100118 clock_, suspended_ssrcs, states, rtp_config, rtcp_report_interval_ms,
Oleh Prypine8964902019-03-29 15:33:01 +0000119 send_transport, observers,
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200120 // TODO(holmer): Remove this circular dependency by injecting
121 // the parts of RtpTransportControllerSendInterface that are really used.
Benjamin Wright192eeec2018-10-17 17:27:25 -0700122 this, event_log, &retransmission_rate_limiter_, std::move(fec_controller),
123 frame_encryption_config.frame_encryptor,
124 frame_encryption_config.crypto_options));
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200125 return video_rtp_senders_.back().get();
126}
127
Stefan Holmer9416ef82018-07-19 10:34:38 +0200128void RtpTransportControllerSend::DestroyRtpVideoSender(
129 RtpVideoSenderInterface* rtp_video_sender) {
130 std::vector<std::unique_ptr<RtpVideoSenderInterface>>::iterator it =
Stefan Holmer5ed25af2018-07-18 15:17:14 +0200131 video_rtp_senders_.end();
132 for (it = video_rtp_senders_.begin(); it != video_rtp_senders_.end(); ++it) {
133 if (it->get() == rtp_video_sender) {
134 break;
135 }
136 }
137 RTC_DCHECK(it != video_rtp_senders_.end());
138 video_rtp_senders_.erase(it);
139}
140
Sebastian Jansson16180952018-12-12 16:49:10 +0100141void RtpTransportControllerSend::UpdateControlState() {
142 absl::optional<TargetTransferRate> update = control_handler_->GetUpdate();
143 if (!update)
144 return;
145 retransmission_rate_limiter_.SetMaxRate(
146 update->network_estimate.bandwidth.bps());
147 // We won't create control_handler_ until we have an observers.
Sebastian Jansson87609be2018-12-05 17:35:35 +0100148 RTC_DCHECK(observer_ != nullptr);
Sebastian Jansson16180952018-12-12 16:49:10 +0100149 observer_->OnTargetTransferRate(*update);
Sebastian Janssone6256052018-05-04 14:08:15 +0200150}
151
152rtc::TaskQueue* RtpTransportControllerSend::GetWorkerQueue() {
153 return &task_queue_;
Sebastian Jansson19704ec2018-03-12 15:59:12 +0100154}
155
nisse76e62b02017-05-31 02:24:52 -0700156PacketRouter* RtpTransportControllerSend::packet_router() {
157 return &packet_router_;
158}
159
Sebastian Janssone1795f42019-07-24 11:38:03 +0200160NetworkStateEstimateObserver*
161RtpTransportControllerSend::network_state_estimate_observer() {
162 return this;
163}
164
nisse76e62b02017-05-31 02:24:52 -0700165TransportFeedbackObserver*
166RtpTransportControllerSend::transport_feedback_observer() {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100167 return this;
nisse76e62b02017-05-31 02:24:52 -0700168}
169
Erik Språngaa59eca2019-07-24 14:52:55 +0200170RtpPacketSender* RtpTransportControllerSend::packet_sender() {
Stefan Holmer5c8942a2017-08-22 16:16:44 +0200171 return &pacer_;
nisse76e62b02017-05-31 02:24:52 -0700172}
173
Stefan Holmer5c8942a2017-08-22 16:16:44 +0200174void RtpTransportControllerSend::SetAllocatedSendBitrateLimits(
175 int min_send_bitrate_bps,
philipel832b1c82018-02-28 17:04:18 +0100176 int max_padding_bitrate_bps,
philipeldb4fa4b2018-03-06 18:29:22 +0100177 int max_total_bitrate_bps) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100178 RTC_DCHECK_RUN_ON(&task_queue_);
Sebastian Jansson11e55ee2019-03-06 16:58:18 +0100179 streams_config_.min_total_allocated_bitrate =
180 DataRate::bps(min_send_bitrate_bps);
Sebastian Jansson87609be2018-12-05 17:35:35 +0100181 streams_config_.max_padding_rate = DataRate::bps(max_padding_bitrate_bps);
182 streams_config_.max_total_allocated_bitrate =
183 DataRate::bps(max_total_bitrate_bps);
184 UpdateStreamsConfig();
Stefan Holmer5c8942a2017-08-22 16:16:44 +0200185}
Sebastian Jansson4c1ffb82018-02-15 16:51:58 +0100186void RtpTransportControllerSend::SetPacingFactor(float pacing_factor) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100187 RTC_DCHECK_RUN_ON(&task_queue_);
188 streams_config_.pacing_factor = pacing_factor;
189 UpdateStreamsConfig();
Sebastian Jansson4c1ffb82018-02-15 16:51:58 +0100190}
191void RtpTransportControllerSend::SetQueueTimeLimit(int limit_ms) {
192 pacer_.SetQueueTimeLimit(limit_ms);
193}
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100194void RtpTransportControllerSend::RegisterPacketFeedbackObserver(
195 PacketFeedbackObserver* observer) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100196 transport_feedback_adapter_.RegisterPacketFeedbackObserver(observer);
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100197}
198void RtpTransportControllerSend::DeRegisterPacketFeedbackObserver(
199 PacketFeedbackObserver* observer) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100200 transport_feedback_adapter_.DeRegisterPacketFeedbackObserver(observer);
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100201}
Sebastian Jansson19704ec2018-03-12 15:59:12 +0100202
203void RtpTransportControllerSend::RegisterTargetTransferRateObserver(
204 TargetTransferRateObserver* observer) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100205 task_queue_.PostTask([this, observer] {
206 RTC_DCHECK_RUN_ON(&task_queue_);
Sebastian Jansson19704ec2018-03-12 15:59:12 +0100207 RTC_DCHECK(observer_ == nullptr);
208 observer_ = observer;
Sebastian Jansson2701bc92018-12-11 15:02:47 +0100209 observer_->OnStartRateUpdate(*initial_config_.constraints.starting_rate);
Sebastian Jansson87609be2018-12-05 17:35:35 +0100210 MaybeCreateControllers();
211 });
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100212}
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100213void RtpTransportControllerSend::OnNetworkRouteChanged(
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100214 const std::string& transport_name,
215 const rtc::NetworkRoute& network_route) {
Sebastian Jansson91bb6672018-02-21 13:02:51 +0100216 // Check if the network route is connected.
217 if (!network_route.connected) {
218 RTC_LOG(LS_INFO) << "Transport " << transport_name << " is disconnected";
219 // TODO(honghaiz): Perhaps handle this in SignalChannelNetworkState and
220 // consider merging these two methods.
221 return;
222 }
223
224 // Check whether the network route has changed on each transport.
225 auto result =
226 network_routes_.insert(std::make_pair(transport_name, network_route));
227 auto kv = result.first;
228 bool inserted = result.second;
229 if (inserted) {
230 // No need to reset BWE if this is the first time the network connects.
231 return;
232 }
Sebastian Janssonaf2adda2018-12-04 11:16:19 +0100233 if (kv->second.connected != network_route.connected ||
234 kv->second.local_network_id != network_route.local_network_id ||
235 kv->second.remote_network_id != network_route.remote_network_id) {
Sebastian Jansson91bb6672018-02-21 13:02:51 +0100236 kv->second = network_route;
237 BitrateConstraints bitrate_config = bitrate_configurator_.GetConfig();
238 RTC_LOG(LS_INFO) << "Network route changed on transport " << transport_name
239 << ": new local network id "
240 << network_route.local_network_id
241 << " new remote network id "
242 << network_route.remote_network_id
243 << " Reset bitrates to min: "
244 << bitrate_config.min_bitrate_bps
245 << " bps, start: " << bitrate_config.start_bitrate_bps
246 << " bps, max: " << bitrate_config.max_bitrate_bps
247 << " bps.";
248 RTC_DCHECK_GT(bitrate_config.start_bitrate_bps, 0);
Sebastian Jansson87609be2018-12-05 17:35:35 +0100249
250 if (reset_feedback_on_route_change_)
251 transport_feedback_adapter_.SetNetworkIds(
252 network_route.local_network_id, network_route.remote_network_id);
253 transport_overhead_bytes_per_packet_ = network_route.packet_overhead;
254
Sebastian Jansson166b45d2019-05-13 11:57:42 +0200255 if (event_log_) {
256 event_log_->Log(absl::make_unique<RtcEventRouteChange>(
257 network_route.connected, network_route.packet_overhead));
258 }
Sebastian Jansson87609be2018-12-05 17:35:35 +0100259 NetworkRouteChange msg;
260 msg.at_time = Timestamp::ms(clock_->TimeInMilliseconds());
261 msg.constraints = ConvertConstraints(bitrate_config, clock_);
262 task_queue_.PostTask([this, msg] {
263 RTC_DCHECK_RUN_ON(&task_queue_);
264 if (controller_) {
Sebastian Jansson16180952018-12-12 16:49:10 +0100265 PostUpdates(controller_->OnNetworkRouteChange(msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100266 } else {
267 UpdateInitialConstraints(msg.constraints);
268 }
269 pacer_.UpdateOutstandingData(0);
270 });
Sebastian Jansson91bb6672018-02-21 13:02:51 +0100271 }
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100272}
273void RtpTransportControllerSend::OnNetworkAvailability(bool network_available) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100274 RTC_LOG(LS_INFO) << "SignalNetworkState "
275 << (network_available ? "Up" : "Down");
276 NetworkAvailability msg;
277 msg.at_time = Timestamp::ms(clock_->TimeInMilliseconds());
278 msg.network_available = network_available;
279 task_queue_.PostTask([this, msg]() {
280 RTC_DCHECK_RUN_ON(&task_queue_);
Sebastian Jansson16180952018-12-12 16:49:10 +0100281 if (network_available_ == msg.network_available)
282 return;
Sebastian Jansson87609be2018-12-05 17:35:35 +0100283 network_available_ = msg.network_available;
Sebastian Jansson16180952018-12-12 16:49:10 +0100284 if (network_available_) {
285 pacer_.Resume();
286 } else {
287 pacer_.Pause();
288 }
289 pacer_.UpdateOutstandingData(0);
290
Sebastian Jansson87609be2018-12-05 17:35:35 +0100291 if (controller_) {
Sebastian Jansson16180952018-12-12 16:49:10 +0100292 control_handler_->SetNetworkAvailability(network_available_);
293 PostUpdates(controller_->OnNetworkAvailability(msg));
294 UpdateControlState();
Sebastian Jansson87609be2018-12-05 17:35:35 +0100295 } else {
296 MaybeCreateControllers();
297 }
298 });
299
Stefan Holmerdbdb3a02018-07-17 16:03:46 +0200300 for (auto& rtp_sender : video_rtp_senders_) {
301 rtp_sender->OnNetworkAvailability(network_available);
302 }
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100303}
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100304RtcpBandwidthObserver* RtpTransportControllerSend::GetBandwidthObserver() {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100305 return this;
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100306}
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100307int64_t RtpTransportControllerSend::GetPacerQueuingDelayMs() const {
Sebastian Janssona06e9192018-03-07 18:49:55 +0100308 return pacer_.QueueInMs();
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100309}
310int64_t RtpTransportControllerSend::GetFirstPacketTimeMs() const {
Sebastian Janssona06e9192018-03-07 18:49:55 +0100311 return pacer_.FirstSentPacketTimeMs();
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100312}
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100313void RtpTransportControllerSend::EnablePeriodicAlrProbing(bool enable) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100314 task_queue_.PostTask([this, enable]() {
315 RTC_DCHECK_RUN_ON(&task_queue_);
316 streams_config_.requests_alr_probing = enable;
317 UpdateStreamsConfig();
318 });
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100319}
320void RtpTransportControllerSend::OnSentPacket(
321 const rtc::SentPacket& sent_packet) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100322 absl::optional<SentPacket> packet_msg =
323 transport_feedback_adapter_.ProcessSentPacket(sent_packet);
324 if (packet_msg) {
325 task_queue_.PostTask([this, packet_msg]() {
326 RTC_DCHECK_RUN_ON(&task_queue_);
327 if (controller_)
Sebastian Jansson16180952018-12-12 16:49:10 +0100328 PostUpdates(controller_->OnSentPacket(*packet_msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100329 });
330 }
Sebastian Jansson16180952018-12-12 16:49:10 +0100331 pacer_.UpdateOutstandingData(
332 transport_feedback_adapter_.GetOutstandingData().bytes());
Sebastian Janssone4be6da2018-02-15 16:51:41 +0100333}
sprangdb2a9fc2017-08-09 06:42:32 -0700334
Ying Wang8b279102019-05-27 17:19:08 +0200335void RtpTransportControllerSend::OnReceivedPacket(
Sebastian Jansson607a6f12019-06-13 17:48:53 +0200336 const ReceivedPacket& packet_msg) {
Ying Wang8b279102019-05-27 17:19:08 +0200337 task_queue_.PostTask([this, packet_msg]() {
338 RTC_DCHECK_RUN_ON(&task_queue_);
339 if (controller_)
340 PostUpdates(controller_->OnReceivedPacket(packet_msg));
341 });
342}
343
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100344void RtpTransportControllerSend::SetSdpBitrateParameters(
345 const BitrateConstraints& constraints) {
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200346 absl::optional<BitrateConstraints> updated =
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100347 bitrate_configurator_.UpdateWithSdpParameters(constraints);
348 if (updated.has_value()) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100349 TargetRateConstraints msg = ConvertConstraints(*updated, clock_);
350 task_queue_.PostTask([this, msg]() {
351 RTC_DCHECK_RUN_ON(&task_queue_);
352 if (controller_) {
Sebastian Jansson16180952018-12-12 16:49:10 +0100353 PostUpdates(controller_->OnTargetRateConstraints(msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100354 } else {
355 UpdateInitialConstraints(msg);
356 }
357 });
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100358 } else {
359 RTC_LOG(LS_VERBOSE)
Sebastian Jansson8f83b422018-02-21 13:07:13 +0100360 << "WebRTC.RtpTransportControllerSend.SetSdpBitrateParameters: "
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100361 << "nothing to update";
362 }
363}
364
365void RtpTransportControllerSend::SetClientBitratePreferences(
Niels Möller0c4f7be2018-05-07 14:01:37 +0200366 const BitrateSettings& preferences) {
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200367 absl::optional<BitrateConstraints> updated =
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100368 bitrate_configurator_.UpdateWithClientPreferences(preferences);
369 if (updated.has_value()) {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100370 TargetRateConstraints msg = ConvertConstraints(*updated, clock_);
371 task_queue_.PostTask([this, msg]() {
372 RTC_DCHECK_RUN_ON(&task_queue_);
373 if (controller_) {
Sebastian Jansson16180952018-12-12 16:49:10 +0100374 PostUpdates(controller_->OnTargetRateConstraints(msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100375 } else {
376 UpdateInitialConstraints(msg);
377 }
378 });
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100379 } else {
380 RTC_LOG(LS_VERBOSE)
Sebastian Jansson8f83b422018-02-21 13:07:13 +0100381 << "WebRTC.RtpTransportControllerSend.SetClientBitratePreferences: "
Sebastian Jansson97f61ea2018-02-21 13:01:55 +0100382 << "nothing to update";
383 }
384}
Alex Narestbcf91802018-06-25 16:08:36 +0200385
Stefan Holmer64be7fa2018-10-04 15:21:55 +0200386void RtpTransportControllerSend::OnTransportOverheadChanged(
387 size_t transport_overhead_bytes_per_packet) {
388 if (transport_overhead_bytes_per_packet >= kMaxOverheadBytes) {
389 RTC_LOG(LS_ERROR) << "Transport overhead exceeds " << kMaxOverheadBytes;
390 return;
391 }
392
393 // TODO(holmer): Call AudioRtpSenders when they have been moved to
394 // RtpTransportControllerSend.
395 for (auto& rtp_video_sender : video_rtp_senders_) {
396 rtp_video_sender->OnTransportOverheadChanged(
397 transport_overhead_bytes_per_packet);
398 }
399}
Sebastian Jansson87609be2018-12-05 17:35:35 +0100400
Erik Språngaa59eca2019-07-24 14:52:55 +0200401void RtpTransportControllerSend::AccountForAudioPacketsInPacedSender(
402 bool account_for_audio) {
403 pacer_.SetAccountForAudioPackets(account_for_audio);
404}
405
Sebastian Jansson87609be2018-12-05 17:35:35 +0100406void RtpTransportControllerSend::OnReceivedEstimatedBitrate(uint32_t bitrate) {
407 RemoteBitrateReport msg;
408 msg.receive_time = Timestamp::ms(clock_->TimeInMilliseconds());
409 msg.bandwidth = DataRate::bps(bitrate);
410 task_queue_.PostTask([this, msg]() {
411 RTC_DCHECK_RUN_ON(&task_queue_);
412 if (controller_)
Sebastian Jansson16180952018-12-12 16:49:10 +0100413 PostUpdates(controller_->OnRemoteBitrateReport(msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100414 });
415}
416
417void RtpTransportControllerSend::OnReceivedRtcpReceiverReport(
418 const ReportBlockList& report_blocks,
419 int64_t rtt_ms,
420 int64_t now_ms) {
421 task_queue_.PostTask([this, report_blocks, now_ms]() {
422 RTC_DCHECK_RUN_ON(&task_queue_);
423 OnReceivedRtcpReceiverReportBlocks(report_blocks, now_ms);
424 });
425
426 task_queue_.PostTask([this, now_ms, rtt_ms]() {
427 RTC_DCHECK_RUN_ON(&task_queue_);
428 RoundTripTimeUpdate report;
429 report.receive_time = Timestamp::ms(now_ms);
430 report.round_trip_time = TimeDelta::ms(rtt_ms);
431 report.smoothed = false;
Christoffer Rodbro4bd31772019-03-27 12:34:21 +0100432 if (controller_ && !report.round_trip_time.IsZero())
Sebastian Jansson16180952018-12-12 16:49:10 +0100433 PostUpdates(controller_->OnRoundTripTimeUpdate(report));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100434 });
435}
436
Erik Språng30a276b2019-04-23 12:00:11 +0200437void RtpTransportControllerSend::OnAddPacket(
438 const RtpPacketSendInfo& packet_info) {
Sebastian Jansson05acd2b2019-01-21 13:07:47 +0100439 transport_feedback_adapter_.AddPacket(
Erik Språng30a276b2019-04-23 12:00:11 +0200440 packet_info,
441 send_side_bwe_with_overhead_ ? transport_overhead_bytes_per_packet_.load()
442 : 0,
Sebastian Jansson05acd2b2019-01-21 13:07:47 +0100443 Timestamp::ms(clock_->TimeInMilliseconds()));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100444}
445
446void RtpTransportControllerSend::OnTransportFeedback(
447 const rtcp::TransportFeedback& feedback) {
448 RTC_DCHECK_RUNS_SERIALIZED(&worker_race_);
449
450 absl::optional<TransportPacketsFeedback> feedback_msg =
Sebastian Jansson05acd2b2019-01-21 13:07:47 +0100451 transport_feedback_adapter_.ProcessTransportFeedback(
452 feedback, Timestamp::ms(clock_->TimeInMilliseconds()));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100453 if (feedback_msg) {
454 task_queue_.PostTask([this, feedback_msg]() {
455 RTC_DCHECK_RUN_ON(&task_queue_);
456 if (controller_)
Sebastian Jansson16180952018-12-12 16:49:10 +0100457 PostUpdates(controller_->OnTransportPacketsFeedback(*feedback_msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100458 });
459 }
Sebastian Jansson16180952018-12-12 16:49:10 +0100460 pacer_.UpdateOutstandingData(
461 transport_feedback_adapter_.GetOutstandingData().bytes());
Sebastian Jansson87609be2018-12-05 17:35:35 +0100462}
463
Sebastian Janssone1795f42019-07-24 11:38:03 +0200464void RtpTransportControllerSend::OnRemoteNetworkEstimate(
465 NetworkStateEstimate estimate) {
466 estimate.update_time = Timestamp::ms(clock_->TimeInMilliseconds());
467 task_queue_.PostTask([this, estimate] {
468 RTC_DCHECK_RUN_ON(&task_queue_);
469 if (controller_)
470 controller_->OnNetworkStateEstimate(estimate);
471 });
472}
473
Sebastian Jansson87609be2018-12-05 17:35:35 +0100474void RtpTransportControllerSend::MaybeCreateControllers() {
475 RTC_DCHECK(!controller_);
476 RTC_DCHECK(!control_handler_);
477
478 if (!network_available_ || !observer_)
479 return;
Sebastian Jansson16180952018-12-12 16:49:10 +0100480 control_handler_ = absl::make_unique<CongestionControlHandler>();
Sebastian Jansson87609be2018-12-05 17:35:35 +0100481
482 initial_config_.constraints.at_time =
483 Timestamp::ms(clock_->TimeInMilliseconds());
484 initial_config_.stream_based_config = streams_config_;
485
486 // TODO(srte): Use fallback controller if no feedback is available.
487 if (controller_factory_override_) {
488 RTC_LOG(LS_INFO) << "Creating overridden congestion controller";
489 controller_ = controller_factory_override_->Create(initial_config_);
490 process_interval_ = controller_factory_override_->GetProcessInterval();
491 } else {
492 RTC_LOG(LS_INFO) << "Creating fallback congestion controller";
493 controller_ = controller_factory_fallback_->Create(initial_config_);
494 process_interval_ = controller_factory_fallback_->GetProcessInterval();
495 }
496 UpdateControllerWithTimeInterval();
497 StartProcessPeriodicTasks();
498}
499
500void RtpTransportControllerSend::UpdateInitialConstraints(
501 TargetRateConstraints new_contraints) {
502 if (!new_contraints.starting_rate)
503 new_contraints.starting_rate = initial_config_.constraints.starting_rate;
504 RTC_DCHECK(new_contraints.starting_rate);
505 initial_config_.constraints = new_contraints;
506}
507
508void RtpTransportControllerSend::StartProcessPeriodicTasks() {
Sebastian Janssonecb68972019-01-18 10:30:54 +0100509 if (!pacer_queue_update_task_.Running()) {
510 pacer_queue_update_task_ = RepeatingTaskHandle::DelayedStart(
Danil Chapovalov4423c362019-03-06 18:41:39 +0100511 task_queue_.Get(), kPacerQueueUpdateInterval, [this]() {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100512 RTC_DCHECK_RUN_ON(&task_queue_);
Sebastian Jansson16180952018-12-12 16:49:10 +0100513 TimeDelta expected_queue_time =
514 TimeDelta::ms(pacer_.ExpectedQueueTimeMs());
515 control_handler_->SetPacerQueue(expected_queue_time);
516 UpdateControlState();
Sebastian Janssonecb68972019-01-18 10:30:54 +0100517 return kPacerQueueUpdateInterval;
Sebastian Jansson87609be2018-12-05 17:35:35 +0100518 });
519 }
Sebastian Janssonecb68972019-01-18 10:30:54 +0100520 controller_task_.Stop();
Sebastian Jansson87609be2018-12-05 17:35:35 +0100521 if (process_interval_.IsFinite()) {
Sebastian Janssonecb68972019-01-18 10:30:54 +0100522 controller_task_ = RepeatingTaskHandle::DelayedStart(
Danil Chapovalov4423c362019-03-06 18:41:39 +0100523 task_queue_.Get(), process_interval_, [this]() {
Sebastian Jansson87609be2018-12-05 17:35:35 +0100524 RTC_DCHECK_RUN_ON(&task_queue_);
525 UpdateControllerWithTimeInterval();
Sebastian Janssonecb68972019-01-18 10:30:54 +0100526 return process_interval_;
Sebastian Jansson87609be2018-12-05 17:35:35 +0100527 });
528 }
529}
530
531void RtpTransportControllerSend::UpdateControllerWithTimeInterval() {
Sebastian Jansson16180952018-12-12 16:49:10 +0100532 RTC_DCHECK(controller_);
533 ProcessInterval msg;
534 msg.at_time = Timestamp::ms(clock_->TimeInMilliseconds());
Christoffer Rodbroc610e262019-01-08 10:49:19 +0100535 if (add_pacing_to_cwin_)
536 msg.pacer_queue = DataSize::bytes(pacer_.QueueSizeBytes());
Sebastian Jansson16180952018-12-12 16:49:10 +0100537 PostUpdates(controller_->OnProcessInterval(msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100538}
539
540void RtpTransportControllerSend::UpdateStreamsConfig() {
541 streams_config_.at_time = Timestamp::ms(clock_->TimeInMilliseconds());
542 if (controller_)
Sebastian Jansson16180952018-12-12 16:49:10 +0100543 PostUpdates(controller_->OnStreamsConfig(streams_config_));
544}
545
546void RtpTransportControllerSend::PostUpdates(NetworkControlUpdate update) {
547 if (update.congestion_window) {
548 if (update.congestion_window->IsFinite())
549 pacer_.SetCongestionWindow(update.congestion_window->bytes());
550 else
551 pacer_.SetCongestionWindow(PacedSender::kNoCongestionWindow);
552 }
553 if (update.pacer_config) {
554 pacer_.SetPacingRates(update.pacer_config->data_rate().bps(),
555 update.pacer_config->pad_rate().bps());
556 }
557 for (const auto& probe : update.probe_cluster_configs) {
558 int64_t bitrate_bps = probe.target_data_rate.bps();
Piotr (Peter) Slatalac39f4622019-02-15 07:38:04 -0800559 pacer_.CreateProbeCluster(bitrate_bps, probe.id);
Sebastian Jansson16180952018-12-12 16:49:10 +0100560 }
561 if (update.target_rate) {
562 control_handler_->SetTargetRate(*update.target_rate);
563 UpdateControlState();
564 }
Sebastian Jansson87609be2018-12-05 17:35:35 +0100565}
566
567void RtpTransportControllerSend::OnReceivedRtcpReceiverReportBlocks(
568 const ReportBlockList& report_blocks,
569 int64_t now_ms) {
570 if (report_blocks.empty())
571 return;
572
573 int total_packets_lost_delta = 0;
574 int total_packets_delta = 0;
575
576 // Compute the packet loss from all report blocks.
577 for (const RTCPReportBlock& report_block : report_blocks) {
578 auto it = last_report_blocks_.find(report_block.source_ssrc);
579 if (it != last_report_blocks_.end()) {
580 auto number_of_packets = report_block.extended_highest_sequence_number -
581 it->second.extended_highest_sequence_number;
582 total_packets_delta += number_of_packets;
583 auto lost_delta = report_block.packets_lost - it->second.packets_lost;
584 total_packets_lost_delta += lost_delta;
585 }
586 last_report_blocks_[report_block.source_ssrc] = report_block;
587 }
588 // Can only compute delta if there has been previous blocks to compare to. If
589 // not, total_packets_delta will be unchanged and there's nothing more to do.
590 if (!total_packets_delta)
591 return;
592 int packets_received_delta = total_packets_delta - total_packets_lost_delta;
593 // To detect lost packets, at least one packet has to be received. This check
594 // is needed to avoid bandwith detection update in
595 // VideoSendStreamTest.SuspendBelowMinBitrate
596
597 if (packets_received_delta < 1)
598 return;
599 Timestamp now = Timestamp::ms(now_ms);
600 TransportLossReport msg;
601 msg.packets_lost_delta = total_packets_lost_delta;
602 msg.packets_received_delta = packets_received_delta;
603 msg.receive_time = now;
604 msg.start_time = last_report_block_time_;
605 msg.end_time = now;
606 if (controller_)
Sebastian Jansson16180952018-12-12 16:49:10 +0100607 PostUpdates(controller_->OnTransportLossReport(msg));
Sebastian Jansson87609be2018-12-05 17:35:35 +0100608 last_report_block_time_ = now;
609}
610
nissecae45d02017-04-24 05:53:20 -0700611} // namespace webrtc