Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 1 | /* |
| 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 Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "modules/pacing/packet_router.h" |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 12 | |
danilchap | 4708537 | 2017-08-10 06:03:57 -0700 | [diff] [blame] | 13 | #include <algorithm> |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 14 | #include <cstdint> |
danilchap | 4708537 | 2017-08-10 06:03:57 -0700 | [diff] [blame] | 15 | #include <limits> |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 16 | #include <memory> |
Erik Språng | 58ee187 | 2019-06-18 16:20:11 +0200 | [diff] [blame] | 17 | #include <utility> |
danilchap | 4708537 | 2017-08-10 06:03:57 -0700 | [diff] [blame] | 18 | |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 19 | #include "absl/types/optional.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 20 | #include "modules/rtp_rtcp/include/rtp_rtcp.h" |
| 21 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 22 | #include "modules/rtp_rtcp/source/rtcp_packet.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 23 | #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "rtc_base/checks.h" |
Erik Språng | 58ee187 | 2019-06-18 16:20:11 +0200 | [diff] [blame] | 25 | #include "rtc_base/logging.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 26 | #include "rtc_base/time_utils.h" |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 27 | |
| 28 | namespace webrtc { |
danilchap | 4708537 | 2017-08-10 06:03:57 -0700 | [diff] [blame] | 29 | namespace { |
| 30 | |
| 31 | constexpr int kRembSendIntervalMs = 200; |
| 32 | |
| 33 | } // namespace |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 34 | |
Erik Språng | 5f01bf6 | 2019-10-16 17:06:34 +0200 | [diff] [blame] | 35 | PacketRouter::PacketRouter() : PacketRouter(0) {} |
| 36 | |
| 37 | PacketRouter::PacketRouter(uint16_t start_transport_seq) |
Erik Språng | 8b7ca4a | 2018-05-17 13:43:35 +0200 | [diff] [blame] | 38 | : last_send_module_(nullptr), |
| 39 | last_remb_time_ms_(rtc::TimeMillis()), |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 40 | last_send_bitrate_bps_(0), |
danilchap | 4708537 | 2017-08-10 06:03:57 -0700 | [diff] [blame] | 41 | bitrate_bps_(0), |
| 42 | max_bitrate_bps_(std::numeric_limits<decltype(max_bitrate_bps_)>::max()), |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 43 | active_remb_module_(nullptr), |
Erik Språng | 5f01bf6 | 2019-10-16 17:06:34 +0200 | [diff] [blame] | 44 | transport_seq_(start_transport_seq) {} |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 45 | |
| 46 | PacketRouter::~PacketRouter() { |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 47 | RTC_DCHECK(rtp_send_modules_.empty()); |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 48 | RTC_DCHECK(rtcp_feedback_senders_.empty()); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 49 | RTC_DCHECK(sender_remb_candidates_.empty()); |
| 50 | RTC_DCHECK(receiver_remb_candidates_.empty()); |
| 51 | RTC_DCHECK(active_remb_module_ == nullptr); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 52 | } |
| 53 | |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 54 | void PacketRouter::AddSendRtpModule(RtpRtcp* rtp_module, bool remb_candidate) { |
stefan | bba9dec | 2016-02-01 04:39:55 -0800 | [diff] [blame] | 55 | rtc::CritScope cs(&modules_crit_); |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 56 | RTC_DCHECK(std::find(rtp_send_modules_.begin(), rtp_send_modules_.end(), |
| 57 | rtp_module) == rtp_send_modules_.end()); |
| 58 | // Put modules which can use regular payload packets (over rtx) instead of |
| 59 | // padding first as it's less of a waste |
Erik Språng | 4208a13 | 2019-08-26 08:58:45 +0200 | [diff] [blame] | 60 | if (rtp_module->SupportsRtxPayloadPadding()) { |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 61 | rtp_send_modules_.push_front(rtp_module); |
| 62 | } else { |
| 63 | rtp_send_modules_.push_back(rtp_module); |
stefan | 16b0221 | 2017-01-27 07:12:16 -0800 | [diff] [blame] | 64 | } |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 65 | |
| 66 | if (remb_candidate) { |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 67 | AddRembModuleCandidate(rtp_module, /* media_sender = */ true); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 68 | } |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 69 | } |
| 70 | |
nisse | fdbfdc9 | 2017-03-31 05:44:52 -0700 | [diff] [blame] | 71 | void PacketRouter::RemoveSendRtpModule(RtpRtcp* rtp_module) { |
stefan | bba9dec | 2016-02-01 04:39:55 -0800 | [diff] [blame] | 72 | rtc::CritScope cs(&modules_crit_); |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 73 | rtp_module_cache_map_.clear(); |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 74 | MaybeRemoveRembModuleCandidate(rtp_module, /* media_sender = */ true); |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 75 | auto it = |
| 76 | std::find(rtp_send_modules_.begin(), rtp_send_modules_.end(), rtp_module); |
| 77 | RTC_DCHECK(it != rtp_send_modules_.end()); |
| 78 | rtp_send_modules_.erase(it); |
Erik Språng | 8b7ca4a | 2018-05-17 13:43:35 +0200 | [diff] [blame] | 79 | if (last_send_module_ == rtp_module) { |
| 80 | last_send_module_ = nullptr; |
| 81 | } |
nisse | fdbfdc9 | 2017-03-31 05:44:52 -0700 | [diff] [blame] | 82 | } |
| 83 | |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 84 | void PacketRouter::AddReceiveRtpModule(RtcpFeedbackSenderInterface* rtcp_sender, |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 85 | bool remb_candidate) { |
nisse | fdbfdc9 | 2017-03-31 05:44:52 -0700 | [diff] [blame] | 86 | rtc::CritScope cs(&modules_crit_); |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 87 | RTC_DCHECK(std::find(rtcp_feedback_senders_.begin(), |
| 88 | rtcp_feedback_senders_.end(), |
| 89 | rtcp_sender) == rtcp_feedback_senders_.end()); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 90 | |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 91 | rtcp_feedback_senders_.push_back(rtcp_sender); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 92 | |
| 93 | if (remb_candidate) { |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 94 | AddRembModuleCandidate(rtcp_sender, /* media_sender = */ false); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 95 | } |
nisse | fdbfdc9 | 2017-03-31 05:44:52 -0700 | [diff] [blame] | 96 | } |
| 97 | |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 98 | void PacketRouter::RemoveReceiveRtpModule( |
| 99 | RtcpFeedbackSenderInterface* rtcp_sender) { |
nisse | fdbfdc9 | 2017-03-31 05:44:52 -0700 | [diff] [blame] | 100 | rtc::CritScope cs(&modules_crit_); |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 101 | MaybeRemoveRembModuleCandidate(rtcp_sender, /* media_sender = */ false); |
| 102 | auto it = std::find(rtcp_feedback_senders_.begin(), |
| 103 | rtcp_feedback_senders_.end(), rtcp_sender); |
| 104 | RTC_DCHECK(it != rtcp_feedback_senders_.end()); |
| 105 | rtcp_feedback_senders_.erase(it); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 106 | } |
| 107 | |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 108 | RtpRtcp* PacketRouter::FindRtpModule(uint32_t ssrc) { |
| 109 | auto it = rtp_module_cache_map_.find(ssrc); |
| 110 | if (it != rtp_module_cache_map_.end()) { |
| 111 | if (ssrc == it->second->SSRC() || ssrc == it->second->FlexfecSsrc()) { |
| 112 | return it->second; |
| 113 | } |
| 114 | // This entry is stale due to a changed ssrc - remove it. |
| 115 | rtp_module_cache_map_.erase(it); |
| 116 | } |
| 117 | // Slow path - find and cache matching module |
| 118 | for (RtpRtcp* rtp_module : rtp_send_modules_) { |
| 119 | if (ssrc == rtp_module->SSRC() || ssrc == rtp_module->FlexfecSsrc()) { |
| 120 | rtp_module_cache_map_[ssrc] = rtp_module; |
| 121 | return rtp_module; |
| 122 | } |
| 123 | } |
| 124 | return nullptr; |
| 125 | } |
| 126 | |
Erik Språng | 58ee187 | 2019-06-18 16:20:11 +0200 | [diff] [blame] | 127 | void PacketRouter::SendPacket(std::unique_ptr<RtpPacketToSend> packet, |
| 128 | const PacedPacketInfo& cluster_info) { |
| 129 | rtc::CritScope cs(&modules_crit_); |
Erik Språng | f6468d2 | 2019-07-05 16:53:43 +0200 | [diff] [blame] | 130 | // With the new pacer code path, transport sequence numbers are only set here, |
| 131 | // on the pacer thread. Therefore we don't need atomics/synchronization. |
Erik Språng | 6cdab46 | 2019-07-15 19:40:13 +0200 | [diff] [blame] | 132 | if (packet->IsExtensionReserved<TransportSequenceNumber>()) { |
Erik Språng | 4208a13 | 2019-08-26 08:58:45 +0200 | [diff] [blame] | 133 | packet->SetExtension<TransportSequenceNumber>(AllocateSequenceNumber()); |
Erik Språng | f6468d2 | 2019-07-05 16:53:43 +0200 | [diff] [blame] | 134 | } |
Mirko Bonadei | 999a72a | 2019-07-12 17:33:46 +0000 | [diff] [blame] | 135 | |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 136 | auto it = rtp_module_cache_map_.find(packet->Ssrc()); |
| 137 | if (it != rtp_module_cache_map_.end()) { |
| 138 | if (TrySendPacket(packet.get(), cluster_info, it->second)) { |
| 139 | return; |
| 140 | } |
| 141 | // Entry is stale, remove it. |
| 142 | rtp_module_cache_map_.erase(it); |
Mirko Bonadei | 999a72a | 2019-07-12 17:33:46 +0000 | [diff] [blame] | 143 | } |
| 144 | |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 145 | // Slow path, find the correct send module. |
| 146 | for (auto* rtp_module : rtp_send_modules_) { |
| 147 | if (TrySendPacket(packet.get(), cluster_info, rtp_module)) { |
| 148 | return; |
| 149 | } |
Erik Språng | 58ee187 | 2019-06-18 16:20:11 +0200 | [diff] [blame] | 150 | } |
| 151 | |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 152 | RTC_LOG(LS_WARNING) << "Failed to send packet, matching RTP module not found " |
| 153 | "or transport error. SSRC = " |
| 154 | << packet->Ssrc() << ", sequence number " |
| 155 | << packet->SequenceNumber(); |
Erik Språng | 58ee187 | 2019-06-18 16:20:11 +0200 | [diff] [blame] | 156 | } |
| 157 | |
Erik Språng | f6468d2 | 2019-07-05 16:53:43 +0200 | [diff] [blame] | 158 | std::vector<std::unique_ptr<RtpPacketToSend>> PacketRouter::GeneratePadding( |
| 159 | size_t target_size_bytes) { |
Erik Språng | 478cb46 | 2019-06-26 15:49:27 +0200 | [diff] [blame] | 160 | rtc::CritScope cs(&modules_crit_); |
| 161 | // First try on the last rtp module to have sent media. This increases the |
| 162 | // the chance that any payload based padding will be useful as it will be |
| 163 | // somewhat distributed over modules according the packet rate, even if it |
| 164 | // will be more skewed towards the highest bitrate stream. At the very least |
| 165 | // this prevents sending payload padding on a disabled stream where it's |
| 166 | // guaranteed not to be useful. |
Mirko Bonadei | 999a72a | 2019-07-12 17:33:46 +0000 | [diff] [blame] | 167 | if (last_send_module_ != nullptr && |
| 168 | last_send_module_->SupportsRtxPayloadPadding()) { |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 169 | RTC_DCHECK(std::find(rtp_send_modules_.begin(), rtp_send_modules_.end(), |
| 170 | last_send_module_) != rtp_send_modules_.end()); |
| 171 | return last_send_module_->GeneratePadding(target_size_bytes); |
| 172 | } |
| 173 | |
| 174 | // Rtp modules are ordered by which stream can most benefit from padding. |
| 175 | for (RtpRtcp* rtp_module : rtp_send_modules_) { |
| 176 | if (rtp_module->SupportsPadding()) { |
| 177 | auto padding_packets = rtp_module->GeneratePadding(target_size_bytes); |
| 178 | if (!padding_packets.empty()) { |
| 179 | last_send_module_ = rtp_module; |
| 180 | } |
Mirko Bonadei | 999a72a | 2019-07-12 17:33:46 +0000 | [diff] [blame] | 181 | return padding_packets; |
Erik Språng | 478cb46 | 2019-06-26 15:49:27 +0200 | [diff] [blame] | 182 | } |
| 183 | } |
Erik Språng | f6468d2 | 2019-07-05 16:53:43 +0200 | [diff] [blame] | 184 | |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 185 | return {}; |
Erik Språng | 478cb46 | 2019-06-26 15:49:27 +0200 | [diff] [blame] | 186 | } |
| 187 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 188 | void PacketRouter::SetTransportWideSequenceNumber(uint16_t sequence_number) { |
Erik Språng | 5f01bf6 | 2019-10-16 17:06:34 +0200 | [diff] [blame] | 189 | rtc::CritScope lock(&modules_crit_); |
| 190 | transport_seq_ = sequence_number; |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 191 | } |
| 192 | |
| 193 | uint16_t PacketRouter::AllocateSequenceNumber() { |
Erik Språng | 5f01bf6 | 2019-10-16 17:06:34 +0200 | [diff] [blame] | 194 | rtc::CritScope lock(&modules_crit_); |
| 195 | transport_seq_ = (transport_seq_ + 1) & 0xFFFF; |
| 196 | return transport_seq_; |
| 197 | } |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 198 | |
Erik Språng | 5f01bf6 | 2019-10-16 17:06:34 +0200 | [diff] [blame] | 199 | uint16_t PacketRouter::CurrentTransportSequenceNumber() const { |
| 200 | rtc::CritScope lock(&modules_crit_); |
| 201 | return transport_seq_; |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 202 | } |
| 203 | |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 204 | void PacketRouter::OnReceiveBitrateChanged(const std::vector<uint32_t>& ssrcs, |
| 205 | uint32_t bitrate_bps) { |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 206 | // % threshold for if we should send a new REMB asap. |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 207 | const int64_t kSendThresholdPercent = 97; |
| 208 | // TODO(danilchap): Remove receive_bitrate_bps variable and the cast |
| 209 | // when OnReceiveBitrateChanged takes bitrate as int64_t. |
| 210 | int64_t receive_bitrate_bps = static_cast<int64_t>(bitrate_bps); |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 211 | |
| 212 | int64_t now_ms = rtc::TimeMillis(); |
| 213 | { |
| 214 | rtc::CritScope lock(&remb_crit_); |
| 215 | |
| 216 | // If we already have an estimate, check if the new total estimate is below |
| 217 | // kSendThresholdPercent of the previous estimate. |
| 218 | if (last_send_bitrate_bps_ > 0) { |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 219 | int64_t new_remb_bitrate_bps = |
| 220 | last_send_bitrate_bps_ - bitrate_bps_ + receive_bitrate_bps; |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 221 | |
| 222 | if (new_remb_bitrate_bps < |
| 223 | kSendThresholdPercent * last_send_bitrate_bps_ / 100) { |
| 224 | // The new bitrate estimate is less than kSendThresholdPercent % of the |
| 225 | // last report. Send a REMB asap. |
| 226 | last_remb_time_ms_ = now_ms - kRembSendIntervalMs; |
| 227 | } |
| 228 | } |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 229 | bitrate_bps_ = receive_bitrate_bps; |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 230 | |
| 231 | if (now_ms - last_remb_time_ms_ < kRembSendIntervalMs) { |
| 232 | return; |
| 233 | } |
| 234 | // NOTE: Updated if we intend to send the data; we might not have |
| 235 | // a module to actually send it. |
| 236 | last_remb_time_ms_ = now_ms; |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 237 | last_send_bitrate_bps_ = receive_bitrate_bps; |
danilchap | 4708537 | 2017-08-10 06:03:57 -0700 | [diff] [blame] | 238 | // Cap the value to send in remb with configured value. |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 239 | receive_bitrate_bps = std::min(receive_bitrate_bps, max_bitrate_bps_); |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 240 | } |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 241 | SendRemb(receive_bitrate_bps, ssrcs); |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 242 | } |
| 243 | |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 244 | void PacketRouter::SetMaxDesiredReceiveBitrate(int64_t bitrate_bps) { |
| 245 | RTC_DCHECK_GE(bitrate_bps, 0); |
danilchap | 4708537 | 2017-08-10 06:03:57 -0700 | [diff] [blame] | 246 | { |
| 247 | rtc::CritScope lock(&remb_crit_); |
| 248 | max_bitrate_bps_ = bitrate_bps; |
| 249 | if (rtc::TimeMillis() - last_remb_time_ms_ < kRembSendIntervalMs && |
| 250 | last_send_bitrate_bps_ > 0 && |
| 251 | last_send_bitrate_bps_ <= max_bitrate_bps_) { |
| 252 | // Recent measured bitrate is already below the cap. |
| 253 | return; |
| 254 | } |
| 255 | } |
| 256 | SendRemb(bitrate_bps, /*ssrcs=*/{}); |
| 257 | } |
| 258 | |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 259 | bool PacketRouter::SendRemb(int64_t bitrate_bps, |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 260 | const std::vector<uint32_t>& ssrcs) { |
| 261 | rtc::CritScope lock(&modules_crit_); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 262 | |
| 263 | if (!active_remb_module_) { |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 264 | return false; |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 265 | } |
| 266 | |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 267 | // The Add* and Remove* methods above ensure that REMB is disabled on all |
| 268 | // other modules, because otherwise, they will send REMB with stale info. |
| 269 | active_remb_module_->SetRemb(bitrate_bps, ssrcs); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 270 | |
nisse | 0584331 | 2017-04-18 23:38:35 -0700 | [diff] [blame] | 271 | return true; |
| 272 | } |
| 273 | |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 274 | bool PacketRouter::SendCombinedRtcpPacket( |
| 275 | std::vector<std::unique_ptr<rtcp::RtcpPacket>> packets) { |
stefan | bba9dec | 2016-02-01 04:39:55 -0800 | [diff] [blame] | 276 | rtc::CritScope cs(&modules_crit_); |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 277 | |
nisse | fdbfdc9 | 2017-03-31 05:44:52 -0700 | [diff] [blame] | 278 | // Prefer send modules. |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 279 | for (auto* rtp_module : rtp_send_modules_) { |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 280 | if (rtp_module->RTCP() == RtcpMode::kOff) { |
| 281 | continue; |
Erik Språng | 8b7ca4a | 2018-05-17 13:43:35 +0200 | [diff] [blame] | 282 | } |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 283 | rtp_module->SendCombinedRtcpPacket(std::move(packets)); |
| 284 | return true; |
nisse | fdbfdc9 | 2017-03-31 05:44:52 -0700 | [diff] [blame] | 285 | } |
sprang | 233bd87 | 2015-09-08 13:25:16 -0700 | [diff] [blame] | 286 | |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 287 | if (rtcp_feedback_senders_.empty()) { |
| 288 | return false; |
Per Kjellander | 52f7ae7 | 2019-09-10 19:28:06 +0200 | [diff] [blame] | 289 | } |
Per Kjellander | ee153c9 | 2019-10-10 16:43:46 +0200 | [diff] [blame] | 290 | auto* rtcp_sender = rtcp_feedback_senders_[0]; |
| 291 | rtcp_sender->SendCombinedRtcpPacket(std::move(packets)); |
| 292 | return true; |
Per Kjellander | 52f7ae7 | 2019-09-10 19:28:06 +0200 | [diff] [blame] | 293 | } |
| 294 | |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 295 | void PacketRouter::AddRembModuleCandidate( |
| 296 | RtcpFeedbackSenderInterface* candidate_module, |
| 297 | bool media_sender) { |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 298 | RTC_DCHECK(candidate_module); |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 299 | std::vector<RtcpFeedbackSenderInterface*>& candidates = |
| 300 | media_sender ? sender_remb_candidates_ : receiver_remb_candidates_; |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 301 | RTC_DCHECK(std::find(candidates.cbegin(), candidates.cend(), |
| 302 | candidate_module) == candidates.cend()); |
| 303 | candidates.push_back(candidate_module); |
| 304 | DetermineActiveRembModule(); |
| 305 | } |
| 306 | |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 307 | void PacketRouter::MaybeRemoveRembModuleCandidate( |
| 308 | RtcpFeedbackSenderInterface* candidate_module, |
| 309 | bool media_sender) { |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 310 | RTC_DCHECK(candidate_module); |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 311 | std::vector<RtcpFeedbackSenderInterface*>& candidates = |
| 312 | media_sender ? sender_remb_candidates_ : receiver_remb_candidates_; |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 313 | auto it = std::find(candidates.begin(), candidates.end(), candidate_module); |
| 314 | |
| 315 | if (it == candidates.end()) { |
| 316 | return; // Function called due to removal of non-REMB-candidate module. |
| 317 | } |
| 318 | |
| 319 | if (*it == active_remb_module_) { |
| 320 | UnsetActiveRembModule(); |
| 321 | } |
| 322 | candidates.erase(it); |
| 323 | DetermineActiveRembModule(); |
| 324 | } |
| 325 | |
| 326 | void PacketRouter::UnsetActiveRembModule() { |
| 327 | RTC_CHECK(active_remb_module_); |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 328 | active_remb_module_->UnsetRemb(); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 329 | active_remb_module_ = nullptr; |
| 330 | } |
| 331 | |
| 332 | void PacketRouter::DetermineActiveRembModule() { |
| 333 | // Sender modules take precedence over receiver modules, because SRs (sender |
| 334 | // reports) are sent more frequently than RR (receiver reports). |
| 335 | // When adding the first sender module, we should change the active REMB |
| 336 | // module to be that. Otherwise, we remain with the current active module. |
| 337 | |
Danil Chapovalov | eb0edd8 | 2017-12-14 16:02:31 +0100 | [diff] [blame] | 338 | RtcpFeedbackSenderInterface* new_active_remb_module; |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 339 | |
| 340 | if (!sender_remb_candidates_.empty()) { |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 341 | new_active_remb_module = sender_remb_candidates_.front(); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 342 | } else if (!receiver_remb_candidates_.empty()) { |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 343 | new_active_remb_module = receiver_remb_candidates_.front(); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 344 | } else { |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 345 | new_active_remb_module = nullptr; |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 346 | } |
| 347 | |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 348 | if (new_active_remb_module != active_remb_module_ && active_remb_module_) { |
| 349 | UnsetActiveRembModule(); |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 350 | } |
| 351 | |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 352 | active_remb_module_ = new_active_remb_module; |
eladalon | 822ff2b | 2017-08-01 06:30:28 -0700 | [diff] [blame] | 353 | } |
| 354 | |
Erik Språng | fbe84ef | 2019-10-17 11:17:06 +0000 | [diff] [blame] | 355 | bool PacketRouter::TrySendPacket(RtpPacketToSend* packet, |
| 356 | const PacedPacketInfo& cluster_info, |
| 357 | RtpRtcp* rtp_module) { |
| 358 | uint32_t ssrc = packet->Ssrc(); |
| 359 | if (rtp_module->TrySendPacket(packet, cluster_info)) { |
| 360 | // Sending succeeded, make sure this SSRC mapping for future use. |
| 361 | rtp_module_cache_map_[ssrc] = rtp_module; |
| 362 | |
| 363 | if (rtp_module->SupportsRtxPayloadPadding()) { |
| 364 | // This is now the last module to send media, and has the desired |
| 365 | // properties needed for payload based padding. Cache it for later use. |
| 366 | last_send_module_ = rtp_module; |
| 367 | } |
| 368 | |
| 369 | return true; |
| 370 | } |
| 371 | return false; |
| 372 | } |
| 373 | |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 374 | } // namespace webrtc |