blob: d674e22d57bbb94d625589c2f2ecb0bdf1f50fbc [file] [log] [blame]
Stefan Holmere5904162015-03-26 11:11:06 +01001/*
2 * Copyright (c) 2015 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
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/pacing/packet_router.h"
Stefan Holmere5904162015-03-26 11:11:06 +010012
danilchap47085372017-08-10 06:03:57 -070013#include <algorithm>
Yves Gerey988cc082018-10-23 12:03:01 +020014#include <cstdint>
danilchap47085372017-08-10 06:03:57 -070015#include <limits>
16
Yves Gerey988cc082018-10-23 12:03:01 +020017#include "absl/types/optional.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020018#include "modules/rtp_rtcp/include/rtp_rtcp.h"
19#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
20#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
Steve Anton10542f22019-01-11 09:11:00 -080021#include "rtc_base/atomic_ops.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "rtc_base/checks.h"
Steve Anton10542f22019-01-11 09:11:00 -080023#include "rtc_base/time_utils.h"
Stefan Holmere5904162015-03-26 11:11:06 +010024
25namespace webrtc {
danilchap47085372017-08-10 06:03:57 -070026namespace {
27
28constexpr int kRembSendIntervalMs = 200;
29
30} // namespace
Stefan Holmere5904162015-03-26 11:11:06 +010031
nisse05843312017-04-18 23:38:35 -070032PacketRouter::PacketRouter()
Erik Språng8b7ca4a2018-05-17 13:43:35 +020033 : last_send_module_(nullptr),
34 last_remb_time_ms_(rtc::TimeMillis()),
nisse05843312017-04-18 23:38:35 -070035 last_send_bitrate_bps_(0),
danilchap47085372017-08-10 06:03:57 -070036 bitrate_bps_(0),
37 max_bitrate_bps_(std::numeric_limits<decltype(max_bitrate_bps_)>::max()),
eladalon822ff2b2017-08-01 06:30:28 -070038 active_remb_module_(nullptr),
erikvargabf5a2fc2017-06-16 05:02:05 -070039 transport_seq_(0) {}
Stefan Holmere5904162015-03-26 11:11:06 +010040
41PacketRouter::~PacketRouter() {
nissefdbfdc92017-03-31 05:44:52 -070042 RTC_DCHECK(rtp_send_modules_.empty());
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010043 RTC_DCHECK(rtcp_feedback_senders_.empty());
eladalon822ff2b2017-08-01 06:30:28 -070044 RTC_DCHECK(sender_remb_candidates_.empty());
45 RTC_DCHECK(receiver_remb_candidates_.empty());
46 RTC_DCHECK(active_remb_module_ == nullptr);
Stefan Holmere5904162015-03-26 11:11:06 +010047}
48
eladalon822ff2b2017-08-01 06:30:28 -070049void PacketRouter::AddSendRtpModule(RtpRtcp* rtp_module, bool remb_candidate) {
stefanbba9dec2016-02-01 04:39:55 -080050 rtc::CritScope cs(&modules_crit_);
nissefdbfdc92017-03-31 05:44:52 -070051 RTC_DCHECK(std::find(rtp_send_modules_.begin(), rtp_send_modules_.end(),
52 rtp_module) == rtp_send_modules_.end());
stefan16b02212017-01-27 07:12:16 -080053 // Put modules which can use regular payload packets (over rtx) instead of
54 // padding first as it's less of a waste
55 if ((rtp_module->RtxSendStatus() & kRtxRedundantPayloads) > 0) {
nissefdbfdc92017-03-31 05:44:52 -070056 rtp_send_modules_.push_front(rtp_module);
stefan16b02212017-01-27 07:12:16 -080057 } else {
nissefdbfdc92017-03-31 05:44:52 -070058 rtp_send_modules_.push_back(rtp_module);
stefan16b02212017-01-27 07:12:16 -080059 }
eladalon822ff2b2017-08-01 06:30:28 -070060
61 if (remb_candidate) {
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010062 AddRembModuleCandidate(rtp_module, /* media_sender = */ true);
eladalon822ff2b2017-08-01 06:30:28 -070063 }
Stefan Holmere5904162015-03-26 11:11:06 +010064}
65
nissefdbfdc92017-03-31 05:44:52 -070066void PacketRouter::RemoveSendRtpModule(RtpRtcp* rtp_module) {
stefanbba9dec2016-02-01 04:39:55 -080067 rtc::CritScope cs(&modules_crit_);
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010068 MaybeRemoveRembModuleCandidate(rtp_module, /* media_sender = */ true);
eladalon822ff2b2017-08-01 06:30:28 -070069 auto it =
70 std::find(rtp_send_modules_.begin(), rtp_send_modules_.end(), rtp_module);
71 RTC_DCHECK(it != rtp_send_modules_.end());
72 rtp_send_modules_.erase(it);
Erik Språng8b7ca4a2018-05-17 13:43:35 +020073 if (last_send_module_ == rtp_module) {
74 last_send_module_ = nullptr;
75 }
nissefdbfdc92017-03-31 05:44:52 -070076}
77
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010078void PacketRouter::AddReceiveRtpModule(RtcpFeedbackSenderInterface* rtcp_sender,
eladalon822ff2b2017-08-01 06:30:28 -070079 bool remb_candidate) {
nissefdbfdc92017-03-31 05:44:52 -070080 rtc::CritScope cs(&modules_crit_);
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010081 RTC_DCHECK(std::find(rtcp_feedback_senders_.begin(),
82 rtcp_feedback_senders_.end(),
83 rtcp_sender) == rtcp_feedback_senders_.end());
eladalon822ff2b2017-08-01 06:30:28 -070084
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010085 rtcp_feedback_senders_.push_back(rtcp_sender);
eladalon822ff2b2017-08-01 06:30:28 -070086
87 if (remb_candidate) {
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010088 AddRembModuleCandidate(rtcp_sender, /* media_sender = */ false);
eladalon822ff2b2017-08-01 06:30:28 -070089 }
nissefdbfdc92017-03-31 05:44:52 -070090}
91
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010092void PacketRouter::RemoveReceiveRtpModule(
93 RtcpFeedbackSenderInterface* rtcp_sender) {
nissefdbfdc92017-03-31 05:44:52 -070094 rtc::CritScope cs(&modules_crit_);
Danil Chapovaloveb0edd82017-12-14 16:02:31 +010095 MaybeRemoveRembModuleCandidate(rtcp_sender, /* media_sender = */ false);
96 auto it = std::find(rtcp_feedback_senders_.begin(),
97 rtcp_feedback_senders_.end(), rtcp_sender);
98 RTC_DCHECK(it != rtcp_feedback_senders_.end());
99 rtcp_feedback_senders_.erase(it);
Stefan Holmere5904162015-03-26 11:11:06 +0100100}
101
102bool PacketRouter::TimeToSendPacket(uint32_t ssrc,
103 uint16_t sequence_number,
104 int64_t capture_timestamp,
philipel29dca2c2016-05-13 11:13:05 +0200105 bool retransmission,
philipelc7bf32a2017-02-17 03:59:43 -0800106 const PacedPacketInfo& pacing_info) {
stefanbba9dec2016-02-01 04:39:55 -0800107 rtc::CritScope cs(&modules_crit_);
nissefdbfdc92017-03-31 05:44:52 -0700108 for (auto* rtp_module : rtp_send_modules_) {
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200109 if (!rtp_module->SendingMedia()) {
brandtr9dfff292016-11-14 05:14:50 -0800110 continue;
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200111 }
brandtr9dfff292016-11-14 05:14:50 -0800112 if (ssrc == rtp_module->SSRC() || ssrc == rtp_module->FlexfecSsrc()) {
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200113 if ((rtp_module->RtxSendStatus() & kRtxRedundantPayloads) &&
114 rtp_module->HasBweExtensions()) {
115 // This is now the last module to send media, and has the desired
116 // properties needed for payload based padding. Cache it for later use.
117 last_send_module_ = rtp_module;
118 }
Stefan Holmere5904162015-03-26 11:11:06 +0100119 return rtp_module->TimeToSendPacket(ssrc, sequence_number,
philipela1ed0b32016-06-01 06:31:17 -0700120 capture_timestamp, retransmission,
philipelc7bf32a2017-02-17 03:59:43 -0800121 pacing_info);
Stefan Holmere5904162015-03-26 11:11:06 +0100122 }
123 }
124 return true;
125}
126
philipela1ed0b32016-06-01 06:31:17 -0700127size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send,
philipelc7bf32a2017-02-17 03:59:43 -0800128 const PacedPacketInfo& pacing_info) {
sprang867fb522015-08-03 04:38:41 -0700129 size_t total_bytes_sent = 0;
stefanbba9dec2016-02-01 04:39:55 -0800130 rtc::CritScope cs(&modules_crit_);
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200131 // First try on the last rtp module to have sent media. This increases the
132 // the chance that any payload based padding will be useful as it will be
133 // somewhat distributed over modules according the packet rate, even if it
134 // will be more skewed towards the highest bitrate stream. At the very least
135 // this prevents sending payload padding on a disabled stream where it's
136 // guaranteed not to be useful.
137 if (last_send_module_ != nullptr) {
138 RTC_DCHECK(std::find(rtp_send_modules_.begin(), rtp_send_modules_.end(),
139 last_send_module_) != rtp_send_modules_.end());
140 RTC_DCHECK(last_send_module_->HasBweExtensions());
141 total_bytes_sent += last_send_module_->TimeToSendPadding(
142 bytes_to_send - total_bytes_sent, pacing_info);
143 if (total_bytes_sent >= bytes_to_send) {
144 return total_bytes_sent;
145 }
146 }
147
stefan16b02212017-01-27 07:12:16 -0800148 // Rtp modules are ordered by which stream can most benefit from padding.
nissefdbfdc92017-03-31 05:44:52 -0700149 for (RtpRtcp* module : rtp_send_modules_) {
stefan53b6cc32017-02-03 08:13:57 -0800150 if (module->SendingMedia() && module->HasBweExtensions()) {
philipela1ed0b32016-06-01 06:31:17 -0700151 size_t bytes_sent = module->TimeToSendPadding(
philipelc7bf32a2017-02-17 03:59:43 -0800152 bytes_to_send - total_bytes_sent, pacing_info);
sprang867fb522015-08-03 04:38:41 -0700153 total_bytes_sent += bytes_sent;
154 if (total_bytes_sent >= bytes_to_send)
155 break;
156 }
Stefan Holmere5904162015-03-26 11:11:06 +0100157 }
sprang867fb522015-08-03 04:38:41 -0700158 return total_bytes_sent;
Stefan Holmere5904162015-03-26 11:11:06 +0100159}
sprang867fb522015-08-03 04:38:41 -0700160
161void PacketRouter::SetTransportWideSequenceNumber(uint16_t sequence_number) {
pbos46ad5422015-12-07 14:29:14 -0800162 rtc::AtomicOps::ReleaseStore(&transport_seq_, sequence_number);
sprang867fb522015-08-03 04:38:41 -0700163}
164
165uint16_t PacketRouter::AllocateSequenceNumber() {
pbos46ad5422015-12-07 14:29:14 -0800166 int prev_seq = rtc::AtomicOps::AcquireLoad(&transport_seq_);
sprang867fb522015-08-03 04:38:41 -0700167 int desired_prev_seq;
168 int new_seq;
169 do {
170 desired_prev_seq = prev_seq;
171 new_seq = (desired_prev_seq + 1) & 0xFFFF;
172 // Note: CompareAndSwap returns the actual value of transport_seq at the
173 // time the CAS operation was executed. Thus, if prev_seq is returned, the
174 // operation was successful - otherwise we need to retry. Saving the
175 // return value saves us a load on retry.
pbos46ad5422015-12-07 14:29:14 -0800176 prev_seq = rtc::AtomicOps::CompareAndSwap(&transport_seq_, desired_prev_seq,
sprang867fb522015-08-03 04:38:41 -0700177 new_seq);
178 } while (prev_seq != desired_prev_seq);
179
180 return new_seq;
181}
182
nisse05843312017-04-18 23:38:35 -0700183void PacketRouter::OnReceiveBitrateChanged(const std::vector<uint32_t>& ssrcs,
184 uint32_t bitrate_bps) {
nisse05843312017-04-18 23:38:35 -0700185 // % threshold for if we should send a new REMB asap.
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100186 const int64_t kSendThresholdPercent = 97;
187 // TODO(danilchap): Remove receive_bitrate_bps variable and the cast
188 // when OnReceiveBitrateChanged takes bitrate as int64_t.
189 int64_t receive_bitrate_bps = static_cast<int64_t>(bitrate_bps);
nisse05843312017-04-18 23:38:35 -0700190
191 int64_t now_ms = rtc::TimeMillis();
192 {
193 rtc::CritScope lock(&remb_crit_);
194
195 // If we already have an estimate, check if the new total estimate is below
196 // kSendThresholdPercent of the previous estimate.
197 if (last_send_bitrate_bps_ > 0) {
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100198 int64_t new_remb_bitrate_bps =
199 last_send_bitrate_bps_ - bitrate_bps_ + receive_bitrate_bps;
nisse05843312017-04-18 23:38:35 -0700200
201 if (new_remb_bitrate_bps <
202 kSendThresholdPercent * last_send_bitrate_bps_ / 100) {
203 // The new bitrate estimate is less than kSendThresholdPercent % of the
204 // last report. Send a REMB asap.
205 last_remb_time_ms_ = now_ms - kRembSendIntervalMs;
206 }
207 }
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100208 bitrate_bps_ = receive_bitrate_bps;
nisse05843312017-04-18 23:38:35 -0700209
210 if (now_ms - last_remb_time_ms_ < kRembSendIntervalMs) {
211 return;
212 }
213 // NOTE: Updated if we intend to send the data; we might not have
214 // a module to actually send it.
215 last_remb_time_ms_ = now_ms;
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100216 last_send_bitrate_bps_ = receive_bitrate_bps;
danilchap47085372017-08-10 06:03:57 -0700217 // Cap the value to send in remb with configured value.
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100218 receive_bitrate_bps = std::min(receive_bitrate_bps, max_bitrate_bps_);
nisse05843312017-04-18 23:38:35 -0700219 }
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100220 SendRemb(receive_bitrate_bps, ssrcs);
nisse05843312017-04-18 23:38:35 -0700221}
222
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100223void PacketRouter::SetMaxDesiredReceiveBitrate(int64_t bitrate_bps) {
224 RTC_DCHECK_GE(bitrate_bps, 0);
danilchap47085372017-08-10 06:03:57 -0700225 {
226 rtc::CritScope lock(&remb_crit_);
227 max_bitrate_bps_ = bitrate_bps;
228 if (rtc::TimeMillis() - last_remb_time_ms_ < kRembSendIntervalMs &&
229 last_send_bitrate_bps_ > 0 &&
230 last_send_bitrate_bps_ <= max_bitrate_bps_) {
231 // Recent measured bitrate is already below the cap.
232 return;
233 }
234 }
235 SendRemb(bitrate_bps, /*ssrcs=*/{});
236}
237
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100238bool PacketRouter::SendRemb(int64_t bitrate_bps,
nisse05843312017-04-18 23:38:35 -0700239 const std::vector<uint32_t>& ssrcs) {
240 rtc::CritScope lock(&modules_crit_);
eladalon822ff2b2017-08-01 06:30:28 -0700241
242 if (!active_remb_module_) {
nisse05843312017-04-18 23:38:35 -0700243 return false;
eladalon822ff2b2017-08-01 06:30:28 -0700244 }
245
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200246 // The Add* and Remove* methods above ensure that REMB is disabled on all
247 // other modules, because otherwise, they will send REMB with stale info.
248 active_remb_module_->SetRemb(bitrate_bps, ssrcs);
eladalon822ff2b2017-08-01 06:30:28 -0700249
nisse05843312017-04-18 23:38:35 -0700250 return true;
251}
252
253bool PacketRouter::SendTransportFeedback(rtcp::TransportFeedback* packet) {
stefanbba9dec2016-02-01 04:39:55 -0800254 rtc::CritScope cs(&modules_crit_);
nissefdbfdc92017-03-31 05:44:52 -0700255 // Prefer send modules.
256 for (auto* rtp_module : rtp_send_modules_) {
257 packet->SetSenderSsrc(rtp_module->SSRC());
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200258 if (rtp_module->SendFeedbackPacket(*packet)) {
nissefdbfdc92017-03-31 05:44:52 -0700259 return true;
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200260 }
nissefdbfdc92017-03-31 05:44:52 -0700261 }
Danil Chapovaloveb0edd82017-12-14 16:02:31 +0100262 for (auto* rtcp_sender : rtcp_feedback_senders_) {
263 packet->SetSenderSsrc(rtcp_sender->SSRC());
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200264 if (rtcp_sender->SendFeedbackPacket(*packet)) {
Peter Boström3dd5d1d2016-02-25 16:56:48 +0100265 return true;
Erik Språng8b7ca4a2018-05-17 13:43:35 +0200266 }
Peter Boström3dd5d1d2016-02-25 16:56:48 +0100267 }
sprang233bd872015-09-08 13:25:16 -0700268 return false;
269}
270
Danil Chapovaloveb0edd82017-12-14 16:02:31 +0100271void PacketRouter::AddRembModuleCandidate(
272 RtcpFeedbackSenderInterface* candidate_module,
273 bool media_sender) {
eladalon822ff2b2017-08-01 06:30:28 -0700274 RTC_DCHECK(candidate_module);
Danil Chapovaloveb0edd82017-12-14 16:02:31 +0100275 std::vector<RtcpFeedbackSenderInterface*>& candidates =
276 media_sender ? sender_remb_candidates_ : receiver_remb_candidates_;
eladalon822ff2b2017-08-01 06:30:28 -0700277 RTC_DCHECK(std::find(candidates.cbegin(), candidates.cend(),
278 candidate_module) == candidates.cend());
279 candidates.push_back(candidate_module);
280 DetermineActiveRembModule();
281}
282
Danil Chapovaloveb0edd82017-12-14 16:02:31 +0100283void PacketRouter::MaybeRemoveRembModuleCandidate(
284 RtcpFeedbackSenderInterface* candidate_module,
285 bool media_sender) {
eladalon822ff2b2017-08-01 06:30:28 -0700286 RTC_DCHECK(candidate_module);
Danil Chapovaloveb0edd82017-12-14 16:02:31 +0100287 std::vector<RtcpFeedbackSenderInterface*>& candidates =
288 media_sender ? sender_remb_candidates_ : receiver_remb_candidates_;
eladalon822ff2b2017-08-01 06:30:28 -0700289 auto it = std::find(candidates.begin(), candidates.end(), candidate_module);
290
291 if (it == candidates.end()) {
292 return; // Function called due to removal of non-REMB-candidate module.
293 }
294
295 if (*it == active_remb_module_) {
296 UnsetActiveRembModule();
297 }
298 candidates.erase(it);
299 DetermineActiveRembModule();
300}
301
302void PacketRouter::UnsetActiveRembModule() {
303 RTC_CHECK(active_remb_module_);
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200304 active_remb_module_->UnsetRemb();
eladalon822ff2b2017-08-01 06:30:28 -0700305 active_remb_module_ = nullptr;
306}
307
308void PacketRouter::DetermineActiveRembModule() {
309 // Sender modules take precedence over receiver modules, because SRs (sender
310 // reports) are sent more frequently than RR (receiver reports).
311 // When adding the first sender module, we should change the active REMB
312 // module to be that. Otherwise, we remain with the current active module.
313
Danil Chapovaloveb0edd82017-12-14 16:02:31 +0100314 RtcpFeedbackSenderInterface* new_active_remb_module;
eladalon822ff2b2017-08-01 06:30:28 -0700315
316 if (!sender_remb_candidates_.empty()) {
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200317 new_active_remb_module = sender_remb_candidates_.front();
eladalon822ff2b2017-08-01 06:30:28 -0700318 } else if (!receiver_remb_candidates_.empty()) {
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200319 new_active_remb_module = receiver_remb_candidates_.front();
eladalon822ff2b2017-08-01 06:30:28 -0700320 } else {
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200321 new_active_remb_module = nullptr;
eladalon822ff2b2017-08-01 06:30:28 -0700322 }
323
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200324 if (new_active_remb_module != active_remb_module_ && active_remb_module_) {
325 UnsetActiveRembModule();
eladalon822ff2b2017-08-01 06:30:28 -0700326 }
327
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200328 active_remb_module_ = new_active_remb_module;
eladalon822ff2b2017-08-01 06:30:28 -0700329}
330
Stefan Holmere5904162015-03-26 11:11:06 +0100331} // namespace webrtc