1 /*
2 * Copyright (c) 2012 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 #include "modules/rtp_rtcp/source/rtcp_sender.h"
12
13 #include <string.h> // memcpy
14
15 #include <algorithm> // std::min
16 #include <memory>
17 #include <utility>
18
19 #include "api/rtc_event_log/rtc_event_log.h"
20 #include "api/units/timestamp.h"
21 #include "logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h"
22 #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
23 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
24 #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
25 #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
26 #include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
27 #include "modules/rtp_rtcp/source/rtcp_packet/loss_notification.h"
28 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
29 #include "modules/rtp_rtcp/source/rtcp_packet/pli.h"
30 #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
31 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
32 #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
33 #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
34 #include "modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
35 #include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
36 #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
37 #include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h"
38 #include "modules/rtp_rtcp/source/time_util.h"
39 #include "modules/rtp_rtcp/source/tmmbr_help.h"
40 #include "rtc_base/checks.h"
41 #include "rtc_base/constructor_magic.h"
42 #include "rtc_base/logging.h"
43 #include "rtc_base/numerics/safe_conversions.h"
44 #include "rtc_base/trace_event.h"
45
46 namespace webrtc {
47
48 namespace {
49 const uint32_t kRtcpAnyExtendedReports = kRtcpXrReceiverReferenceTime |
50 kRtcpXrDlrrReportBlock |
51 kRtcpXrTargetBitrate;
52 constexpr int32_t kDefaultVideoReportInterval = 1000;
53 constexpr int32_t kDefaultAudioReportInterval = 5000;
54
55 class PacketContainer : public rtcp::CompoundPacket {
56 public:
PacketContainer(Transport * transport,RtcEventLog * event_log)57 PacketContainer(Transport* transport, RtcEventLog* event_log)
58 : transport_(transport), event_log_(event_log) {}
59
SendPackets(size_t max_payload_length)60 size_t SendPackets(size_t max_payload_length) {
61 size_t bytes_sent = 0;
62 Build(max_payload_length, [&](rtc::ArrayView<const uint8_t> packet) {
63 if (transport_->SendRtcp(packet.data(), packet.size())) {
64 bytes_sent += packet.size();
65 if (event_log_) {
66 event_log_->Log(std::make_unique<RtcEventRtcpPacketOutgoing>(packet));
67 }
68 }
69 });
70 return bytes_sent;
71 }
72
73 private:
74 Transport* transport_;
75 RtcEventLog* const event_log_;
76
77 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(PacketContainer);
78 };
79
80 // Helper to put several RTCP packets into lower layer datagram RTCP packet.
81 // Prefer to use this class instead of PacketContainer.
82 class PacketSender {
83 public:
PacketSender(rtcp::RtcpPacket::PacketReadyCallback callback,size_t max_packet_size)84 PacketSender(rtcp::RtcpPacket::PacketReadyCallback callback,
85 size_t max_packet_size)
86 : callback_(callback), max_packet_size_(max_packet_size) {
87 RTC_CHECK_LE(max_packet_size, IP_PACKET_SIZE);
88 }
~PacketSender()89 ~PacketSender() { RTC_DCHECK_EQ(index_, 0) << "Unsent rtcp packet."; }
90
91 // Appends a packet to pending compound packet.
92 // Sends rtcp packet if buffer is full and resets the buffer.
AppendPacket(const rtcp::RtcpPacket & packet)93 void AppendPacket(const rtcp::RtcpPacket& packet) {
94 packet.Create(buffer_, &index_, max_packet_size_, callback_);
95 }
96
97 // Sends pending rtcp packet.
Send()98 void Send() {
99 if (index_ > 0) {
100 callback_(rtc::ArrayView<const uint8_t>(buffer_, index_));
101 index_ = 0;
102 }
103 }
104
IsEmpty() const105 bool IsEmpty() const { return index_ == 0; }
106
107 private:
108 const rtcp::RtcpPacket::PacketReadyCallback callback_;
109 const size_t max_packet_size_;
110 size_t index_ = 0;
111 uint8_t buffer_[IP_PACKET_SIZE];
112 };
113
114 } // namespace
115
FeedbackState()116 RTCPSender::FeedbackState::FeedbackState()
117 : packets_sent(0),
118 media_bytes_sent(0),
119 send_bitrate(0),
120 last_rr_ntp_secs(0),
121 last_rr_ntp_frac(0),
122 remote_sr(0),
123 receiver(nullptr) {}
124
125 RTCPSender::FeedbackState::FeedbackState(const FeedbackState&) = default;
126
127 RTCPSender::FeedbackState::FeedbackState(FeedbackState&&) = default;
128
129 RTCPSender::FeedbackState::~FeedbackState() = default;
130
131 class RTCPSender::RtcpContext {
132 public:
RtcpContext(const FeedbackState & feedback_state,int32_t nack_size,const uint16_t * nack_list,Timestamp now)133 RtcpContext(const FeedbackState& feedback_state,
134 int32_t nack_size,
135 const uint16_t* nack_list,
136 Timestamp now)
137 : feedback_state_(feedback_state),
138 nack_size_(nack_size),
139 nack_list_(nack_list),
140 now_(now) {}
141
142 const FeedbackState& feedback_state_;
143 const int32_t nack_size_;
144 const uint16_t* nack_list_;
145 const Timestamp now_;
146 };
147
RTCPSender(const RtpRtcpInterface::Configuration & config)148 RTCPSender::RTCPSender(const RtpRtcpInterface::Configuration& config)
149 : audio_(config.audio),
150 ssrc_(config.local_media_ssrc),
151 clock_(config.clock),
152 random_(clock_->TimeInMicroseconds()),
153 method_(RtcpMode::kOff),
154 event_log_(config.event_log),
155 transport_(config.outgoing_transport),
156 report_interval_ms_(config.rtcp_report_interval_ms > 0
157 ? config.rtcp_report_interval_ms
158 : (config.audio ? kDefaultAudioReportInterval
159 : kDefaultVideoReportInterval)),
160 sending_(false),
161 next_time_to_send_rtcp_(clock_->TimeInMilliseconds()),
162 timestamp_offset_(0),
163 last_rtp_timestamp_(0),
164 last_frame_capture_time_ms_(-1),
165 remote_ssrc_(0),
166 receive_statistics_(config.receive_statistics),
167
168 sequence_number_fir_(0),
169
170 remb_bitrate_(0),
171
172 tmmbr_send_bps_(0),
173 packet_oh_send_(0),
174 max_packet_size_(IP_PACKET_SIZE - 28), // IPv4 + UDP by default.
175
176 xr_send_receiver_reference_time_enabled_(false),
177 packet_type_counter_observer_(config.rtcp_packet_type_counter_observer),
178 send_video_bitrate_allocation_(false),
179 last_payload_type_(-1) {
180 RTC_DCHECK(transport_ != nullptr);
181
182 builders_[kRtcpSr] = &RTCPSender::BuildSR;
183 builders_[kRtcpRr] = &RTCPSender::BuildRR;
184 builders_[kRtcpSdes] = &RTCPSender::BuildSDES;
185 builders_[kRtcpPli] = &RTCPSender::BuildPLI;
186 builders_[kRtcpFir] = &RTCPSender::BuildFIR;
187 builders_[kRtcpRemb] = &RTCPSender::BuildREMB;
188 builders_[kRtcpBye] = &RTCPSender::BuildBYE;
189 builders_[kRtcpLossNotification] = &RTCPSender::BuildLossNotification;
190 builders_[kRtcpTmmbr] = &RTCPSender::BuildTMMBR;
191 builders_[kRtcpTmmbn] = &RTCPSender::BuildTMMBN;
192 builders_[kRtcpNack] = &RTCPSender::BuildNACK;
193 builders_[kRtcpAnyExtendedReports] = &RTCPSender::BuildExtendedReports;
194 }
195
~RTCPSender()196 RTCPSender::~RTCPSender() {}
197
Status() const198 RtcpMode RTCPSender::Status() const {
199 MutexLock lock(&mutex_rtcp_sender_);
200 return method_;
201 }
202
SetRTCPStatus(RtcpMode new_method)203 void RTCPSender::SetRTCPStatus(RtcpMode new_method) {
204 MutexLock lock(&mutex_rtcp_sender_);
205
206 if (method_ == RtcpMode::kOff && new_method != RtcpMode::kOff) {
207 // When switching on, reschedule the next packet
208 next_time_to_send_rtcp_ =
209 clock_->TimeInMilliseconds() + RTCP_INTERVAL_RAPID_SYNC_MS / 2;
210 }
211 method_ = new_method;
212 }
213
Sending() const214 bool RTCPSender::Sending() const {
215 MutexLock lock(&mutex_rtcp_sender_);
216 return sending_;
217 }
218
SetSendingStatus(const FeedbackState & feedback_state,bool sending)219 int32_t RTCPSender::SetSendingStatus(const FeedbackState& feedback_state,
220 bool sending) {
221 bool sendRTCPBye = false;
222 {
223 MutexLock lock(&mutex_rtcp_sender_);
224
225 if (method_ != RtcpMode::kOff) {
226 if (sending == false && sending_ == true) {
227 // Trigger RTCP bye
228 sendRTCPBye = true;
229 }
230 }
231 sending_ = sending;
232 }
233 if (sendRTCPBye)
234 return SendRTCP(feedback_state, kRtcpBye);
235 return 0;
236 }
237
SendLossNotification(const FeedbackState & feedback_state,uint16_t last_decoded_seq_num,uint16_t last_received_seq_num,bool decodability_flag,bool buffering_allowed)238 int32_t RTCPSender::SendLossNotification(const FeedbackState& feedback_state,
239 uint16_t last_decoded_seq_num,
240 uint16_t last_received_seq_num,
241 bool decodability_flag,
242 bool buffering_allowed) {
243 MutexLock lock(&mutex_rtcp_sender_);
244
245 loss_notification_state_.last_decoded_seq_num = last_decoded_seq_num;
246 loss_notification_state_.last_received_seq_num = last_received_seq_num;
247 loss_notification_state_.decodability_flag = decodability_flag;
248
249 SetFlag(kRtcpLossNotification, /*is_volatile=*/true);
250
251 if (buffering_allowed) {
252 // The loss notification will be batched with additional feedback messages.
253 return 0;
254 }
255
256 return SendCompoundRTCPLocked(
257 feedback_state, {RTCPPacketType::kRtcpLossNotification}, 0, nullptr);
258 }
259
SetRemb(int64_t bitrate_bps,std::vector<uint32_t> ssrcs)260 void RTCPSender::SetRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs) {
261 RTC_CHECK_GE(bitrate_bps, 0);
262 MutexLock lock(&mutex_rtcp_sender_);
263 remb_bitrate_ = bitrate_bps;
264 remb_ssrcs_ = std::move(ssrcs);
265
266 SetFlag(kRtcpRemb, /*is_volatile=*/false);
267 // Send a REMB immediately if we have a new REMB. The frequency of REMBs is
268 // throttled by the caller.
269 next_time_to_send_rtcp_ = clock_->TimeInMilliseconds();
270 }
271
UnsetRemb()272 void RTCPSender::UnsetRemb() {
273 MutexLock lock(&mutex_rtcp_sender_);
274 // Stop sending REMB each report until it is reenabled and REMB data set.
275 ConsumeFlag(kRtcpRemb, /*forced=*/true);
276 }
277
TMMBR() const278 bool RTCPSender::TMMBR() const {
279 MutexLock lock(&mutex_rtcp_sender_);
280 return IsFlagPresent(RTCPPacketType::kRtcpTmmbr);
281 }
282
SetTMMBRStatus(bool enable)283 void RTCPSender::SetTMMBRStatus(bool enable) {
284 MutexLock lock(&mutex_rtcp_sender_);
285 if (enable) {
286 SetFlag(RTCPPacketType::kRtcpTmmbr, false);
287 } else {
288 ConsumeFlag(RTCPPacketType::kRtcpTmmbr, true);
289 }
290 }
291
SetMaxRtpPacketSize(size_t max_packet_size)292 void RTCPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
293 MutexLock lock(&mutex_rtcp_sender_);
294 max_packet_size_ = max_packet_size;
295 }
296
SetTimestampOffset(uint32_t timestamp_offset)297 void RTCPSender::SetTimestampOffset(uint32_t timestamp_offset) {
298 MutexLock lock(&mutex_rtcp_sender_);
299 timestamp_offset_ = timestamp_offset;
300 }
301
SetLastRtpTime(uint32_t rtp_timestamp,int64_t capture_time_ms,int8_t payload_type)302 void RTCPSender::SetLastRtpTime(uint32_t rtp_timestamp,
303 int64_t capture_time_ms,
304 int8_t payload_type) {
305 MutexLock lock(&mutex_rtcp_sender_);
306 // For compatibility with clients who don't set payload type correctly on all
307 // calls.
308 if (payload_type != -1) {
309 last_payload_type_ = payload_type;
310 }
311 last_rtp_timestamp_ = rtp_timestamp;
312 if (capture_time_ms <= 0) {
313 // We don't currently get a capture time from VoiceEngine.
314 last_frame_capture_time_ms_ = clock_->TimeInMilliseconds();
315 } else {
316 last_frame_capture_time_ms_ = capture_time_ms;
317 }
318 }
319
SetRtpClockRate(int8_t payload_type,int rtp_clock_rate_hz)320 void RTCPSender::SetRtpClockRate(int8_t payload_type, int rtp_clock_rate_hz) {
321 MutexLock lock(&mutex_rtcp_sender_);
322 rtp_clock_rates_khz_[payload_type] = rtp_clock_rate_hz / 1000;
323 }
324
SetRemoteSSRC(uint32_t ssrc)325 void RTCPSender::SetRemoteSSRC(uint32_t ssrc) {
326 MutexLock lock(&mutex_rtcp_sender_);
327 remote_ssrc_ = ssrc;
328 }
329
SetCNAME(const char * c_name)330 int32_t RTCPSender::SetCNAME(const char* c_name) {
331 if (!c_name)
332 return -1;
333
334 RTC_DCHECK_LT(strlen(c_name), RTCP_CNAME_SIZE);
335 MutexLock lock(&mutex_rtcp_sender_);
336 cname_ = c_name;
337 return 0;
338 }
339
AddMixedCNAME(uint32_t SSRC,const char * c_name)340 int32_t RTCPSender::AddMixedCNAME(uint32_t SSRC, const char* c_name) {
341 RTC_DCHECK(c_name);
342 RTC_DCHECK_LT(strlen(c_name), RTCP_CNAME_SIZE);
343 MutexLock lock(&mutex_rtcp_sender_);
344 // One spot is reserved for ssrc_/cname_.
345 // TODO(danilchap): Add support for more than 30 contributes by sending
346 // several sdes packets.
347 if (csrc_cnames_.size() >= rtcp::Sdes::kMaxNumberOfChunks - 1)
348 return -1;
349
350 csrc_cnames_[SSRC] = c_name;
351 return 0;
352 }
353
RemoveMixedCNAME(uint32_t SSRC)354 int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) {
355 MutexLock lock(&mutex_rtcp_sender_);
356 auto it = csrc_cnames_.find(SSRC);
357
358 if (it == csrc_cnames_.end())
359 return -1;
360
361 csrc_cnames_.erase(it);
362 return 0;
363 }
364
TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const365 bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const {
366 /*
367 For audio we use a configurable interval (default: 5 seconds)
368
369 For video we use a configurable interval (default: 1 second) for a BW
370 smaller than 360 kbit/s, technicaly we break the max 5% RTCP BW for
371 video below 10 kbit/s but that should be extremely rare
372
373
374 From RFC 3550
375
376 MAX RTCP BW is 5% if the session BW
377 A send report is approximately 65 bytes inc CNAME
378 A receiver report is approximately 28 bytes
379
380 The RECOMMENDED value for the reduced minimum in seconds is 360
381 divided by the session bandwidth in kilobits/second. This minimum
382 is smaller than 5 seconds for bandwidths greater than 72 kb/s.
383
384 If the participant has not yet sent an RTCP packet (the variable
385 initial is true), the constant Tmin is set to half of the configured
386 interval.
387
388 The interval between RTCP packets is varied randomly over the
389 range [0.5,1.5] times the calculated interval to avoid unintended
390 synchronization of all participants
391
392 if we send
393 If the participant is a sender (we_sent true), the constant C is
394 set to the average RTCP packet size (avg_rtcp_size) divided by 25%
395 of the RTCP bandwidth (rtcp_bw), and the constant n is set to the
396 number of senders.
397
398 if we receive only
399 If we_sent is not true, the constant C is set
400 to the average RTCP packet size divided by 75% of the RTCP
401 bandwidth. The constant n is set to the number of receivers
402 (members - senders). If the number of senders is greater than
403 25%, senders and receivers are treated together.
404
405 reconsideration NOT required for peer-to-peer
406 "timer reconsideration" is
407 employed. This algorithm implements a simple back-off mechanism
408 which causes users to hold back RTCP packet transmission if the
409 group sizes are increasing.
410
411 n = number of members
412 C = avg_size/(rtcpBW/4)
413
414 3. The deterministic calculated interval Td is set to max(Tmin, n*C).
415
416 4. The calculated interval T is set to a number uniformly distributed
417 between 0.5 and 1.5 times the deterministic calculated interval.
418
419 5. The resulting value of T is divided by e-3/2=1.21828 to compensate
420 for the fact that the timer reconsideration algorithm converges to
421 a value of the RTCP bandwidth below the intended average
422 */
423
424 int64_t now = clock_->TimeInMilliseconds();
425
426 MutexLock lock(&mutex_rtcp_sender_);
427
428 if (method_ == RtcpMode::kOff)
429 return false;
430
431 if (!audio_ && sendKeyframeBeforeRTP) {
432 // for video key-frames we want to send the RTCP before the large key-frame
433 // if we have a 100 ms margin
434 now += RTCP_SEND_BEFORE_KEY_FRAME_MS;
435 }
436
437 if (now >= next_time_to_send_rtcp_) {
438 return true;
439 } else if (now < 0x0000ffff &&
440 next_time_to_send_rtcp_ > 0xffff0000) { // 65 sec margin
441 // wrap
442 return true;
443 }
444 return false;
445 }
446
BuildSR(const RtcpContext & ctx)447 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSR(const RtcpContext& ctx) {
448 // Timestamp shouldn't be estimated before first media frame.
449 RTC_DCHECK_GE(last_frame_capture_time_ms_, 0);
450 // The timestamp of this RTCP packet should be estimated as the timestamp of
451 // the frame being captured at this moment. We are calculating that
452 // timestamp as the last frame's timestamp + the time since the last frame
453 // was captured.
454 int rtp_rate = rtp_clock_rates_khz_[last_payload_type_];
455 if (rtp_rate <= 0) {
456 rtp_rate =
457 (audio_ ? kBogusRtpRateForAudioRtcp : kVideoPayloadTypeFrequency) /
458 1000;
459 }
460 // Round now_us_ to the closest millisecond, because Ntp time is rounded
461 // when converted to milliseconds,
462 uint32_t rtp_timestamp =
463 timestamp_offset_ + last_rtp_timestamp_ +
464 ((ctx.now_.us() + 500) / 1000 - last_frame_capture_time_ms_) * rtp_rate;
465
466 rtcp::SenderReport* report = new rtcp::SenderReport();
467 report->SetSenderSsrc(ssrc_);
468 report->SetNtp(clock_->ConvertTimestampToNtpTime(ctx.now_));
469 report->SetRtpTimestamp(rtp_timestamp);
470 report->SetPacketCount(ctx.feedback_state_.packets_sent);
471 report->SetOctetCount(ctx.feedback_state_.media_bytes_sent);
472 report->SetReportBlocks(CreateReportBlocks(ctx.feedback_state_));
473
474 return std::unique_ptr<rtcp::RtcpPacket>(report);
475 }
476
BuildSDES(const RtcpContext & ctx)477 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES(
478 const RtcpContext& ctx) {
479 size_t length_cname = cname_.length();
480 RTC_CHECK_LT(length_cname, RTCP_CNAME_SIZE);
481
482 rtcp::Sdes* sdes = new rtcp::Sdes();
483 sdes->AddCName(ssrc_, cname_);
484
485 for (const auto& it : csrc_cnames_)
486 RTC_CHECK(sdes->AddCName(it.first, it.second));
487
488 return std::unique_ptr<rtcp::RtcpPacket>(sdes);
489 }
490
BuildRR(const RtcpContext & ctx)491 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) {
492 rtcp::ReceiverReport* report = new rtcp::ReceiverReport();
493 report->SetSenderSsrc(ssrc_);
494 report->SetReportBlocks(CreateReportBlocks(ctx.feedback_state_));
495
496 return std::unique_ptr<rtcp::RtcpPacket>(report);
497 }
498
BuildPLI(const RtcpContext & ctx)499 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) {
500 rtcp::Pli* pli = new rtcp::Pli();
501 pli->SetSenderSsrc(ssrc_);
502 pli->SetMediaSsrc(remote_ssrc_);
503
504 ++packet_type_counter_.pli_packets;
505
506 return std::unique_ptr<rtcp::RtcpPacket>(pli);
507 }
508
BuildFIR(const RtcpContext & ctx)509 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
510 ++sequence_number_fir_;
511
512 rtcp::Fir* fir = new rtcp::Fir();
513 fir->SetSenderSsrc(ssrc_);
514 fir->AddRequestTo(remote_ssrc_, sequence_number_fir_);
515
516 ++packet_type_counter_.fir_packets;
517
518 return std::unique_ptr<rtcp::RtcpPacket>(fir);
519 }
520
BuildREMB(const RtcpContext & ctx)521 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
522 const RtcpContext& ctx) {
523 rtcp::Remb* remb = new rtcp::Remb();
524 remb->SetSenderSsrc(ssrc_);
525 remb->SetBitrateBps(remb_bitrate_);
526 remb->SetSsrcs(remb_ssrcs_);
527
528 return std::unique_ptr<rtcp::RtcpPacket>(remb);
529 }
530
SetTargetBitrate(unsigned int target_bitrate)531 void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) {
532 MutexLock lock(&mutex_rtcp_sender_);
533 tmmbr_send_bps_ = target_bitrate;
534 }
535
BuildTMMBR(const RtcpContext & ctx)536 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBR(
537 const RtcpContext& ctx) {
538 if (ctx.feedback_state_.receiver == nullptr)
539 return nullptr;
540 // Before sending the TMMBR check the received TMMBN, only an owner is
541 // allowed to raise the bitrate:
542 // * If the sender is an owner of the TMMBN -> send TMMBR
543 // * If not an owner but the TMMBR would enter the TMMBN -> send TMMBR
544
545 // get current bounding set from RTCP receiver
546 bool tmmbr_owner = false;
547
548 // holding mutex_rtcp_sender_ while calling RTCPreceiver which
549 // will accuire criticalSectionRTCPReceiver_ is a potental deadlock but
550 // since RTCPreceiver is not doing the reverse we should be fine
551 std::vector<rtcp::TmmbItem> candidates =
552 ctx.feedback_state_.receiver->BoundingSet(&tmmbr_owner);
553
554 if (!candidates.empty()) {
555 for (const auto& candidate : candidates) {
556 if (candidate.bitrate_bps() == tmmbr_send_bps_ &&
557 candidate.packet_overhead() == packet_oh_send_) {
558 // Do not send the same tuple.
559 return nullptr;
560 }
561 }
562 if (!tmmbr_owner) {
563 // Use received bounding set as candidate set.
564 // Add current tuple.
565 candidates.emplace_back(ssrc_, tmmbr_send_bps_, packet_oh_send_);
566
567 // Find bounding set.
568 std::vector<rtcp::TmmbItem> bounding =
569 TMMBRHelp::FindBoundingSet(std::move(candidates));
570 tmmbr_owner = TMMBRHelp::IsOwner(bounding, ssrc_);
571 if (!tmmbr_owner) {
572 // Did not enter bounding set, no meaning to send this request.
573 return nullptr;
574 }
575 }
576 }
577
578 if (!tmmbr_send_bps_)
579 return nullptr;
580
581 rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr();
582 tmmbr->SetSenderSsrc(ssrc_);
583 rtcp::TmmbItem request;
584 request.set_ssrc(remote_ssrc_);
585 request.set_bitrate_bps(tmmbr_send_bps_);
586 request.set_packet_overhead(packet_oh_send_);
587 tmmbr->AddTmmbr(request);
588
589 return std::unique_ptr<rtcp::RtcpPacket>(tmmbr);
590 }
591
BuildTMMBN(const RtcpContext & ctx)592 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN(
593 const RtcpContext& ctx) {
594 rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn();
595 tmmbn->SetSenderSsrc(ssrc_);
596 for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) {
597 if (tmmbr.bitrate_bps() > 0) {
598 tmmbn->AddTmmbr(tmmbr);
599 }
600 }
601
602 return std::unique_ptr<rtcp::RtcpPacket>(tmmbn);
603 }
604
BuildAPP(const RtcpContext & ctx)605 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
606 rtcp::App* app = new rtcp::App();
607 app->SetSenderSsrc(ssrc_);
608
609 return std::unique_ptr<rtcp::RtcpPacket>(app);
610 }
611
BuildLossNotification(const RtcpContext & ctx)612 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildLossNotification(
613 const RtcpContext& ctx) {
614 auto loss_notification = std::make_unique<rtcp::LossNotification>(
615 loss_notification_state_.last_decoded_seq_num,
616 loss_notification_state_.last_received_seq_num,
617 loss_notification_state_.decodability_flag);
618 loss_notification->SetSenderSsrc(ssrc_);
619 loss_notification->SetMediaSsrc(remote_ssrc_);
620 return std::move(loss_notification);
621 }
622
BuildNACK(const RtcpContext & ctx)623 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK(
624 const RtcpContext& ctx) {
625 rtcp::Nack* nack = new rtcp::Nack();
626 nack->SetSenderSsrc(ssrc_);
627 nack->SetMediaSsrc(remote_ssrc_);
628 nack->SetPacketIds(ctx.nack_list_, ctx.nack_size_);
629
630 // Report stats.
631 for (int idx = 0; idx < ctx.nack_size_; ++idx) {
632 nack_stats_.ReportRequest(ctx.nack_list_[idx]);
633 }
634 packet_type_counter_.nack_requests = nack_stats_.requests();
635 packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
636
637 ++packet_type_counter_.nack_packets;
638
639 return std::unique_ptr<rtcp::RtcpPacket>(nack);
640 }
641
BuildBYE(const RtcpContext & ctx)642 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) {
643 rtcp::Bye* bye = new rtcp::Bye();
644 bye->SetSenderSsrc(ssrc_);
645 bye->SetCsrcs(csrcs_);
646
647 return std::unique_ptr<rtcp::RtcpPacket>(bye);
648 }
649
BuildExtendedReports(const RtcpContext & ctx)650 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildExtendedReports(
651 const RtcpContext& ctx) {
652 std::unique_ptr<rtcp::ExtendedReports> xr(new rtcp::ExtendedReports());
653 xr->SetSenderSsrc(ssrc_);
654
655 if (!sending_ && xr_send_receiver_reference_time_enabled_) {
656 rtcp::Rrtr rrtr;
657 rrtr.SetNtp(clock_->ConvertTimestampToNtpTime(ctx.now_));
658 xr->SetRrtr(rrtr);
659 }
660
661 for (const rtcp::ReceiveTimeInfo& rti : ctx.feedback_state_.last_xr_rtis) {
662 xr->AddDlrrItem(rti);
663 }
664
665 if (send_video_bitrate_allocation_) {
666 rtcp::TargetBitrate target_bitrate;
667
668 for (int sl = 0; sl < kMaxSpatialLayers; ++sl) {
669 for (int tl = 0; tl < kMaxTemporalStreams; ++tl) {
670 if (video_bitrate_allocation_.HasBitrate(sl, tl)) {
671 target_bitrate.AddTargetBitrate(
672 sl, tl, video_bitrate_allocation_.GetBitrate(sl, tl) / 1000);
673 }
674 }
675 }
676
677 xr->SetTargetBitrate(target_bitrate);
678 send_video_bitrate_allocation_ = false;
679 }
680
681 return std::move(xr);
682 }
683
SendRTCP(const FeedbackState & feedback_state,RTCPPacketType packetType,int32_t nack_size,const uint16_t * nack_list)684 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state,
685 RTCPPacketType packetType,
686 int32_t nack_size,
687 const uint16_t* nack_list) {
688 return SendCompoundRTCP(
689 feedback_state, std::set<RTCPPacketType>(&packetType, &packetType + 1),
690 nack_size, nack_list);
691 }
692
SendCompoundRTCP(const FeedbackState & feedback_state,const std::set<RTCPPacketType> & packet_types,int32_t nack_size,const uint16_t * nack_list)693 int32_t RTCPSender::SendCompoundRTCP(
694 const FeedbackState& feedback_state,
695 const std::set<RTCPPacketType>& packet_types,
696 int32_t nack_size,
697 const uint16_t* nack_list) {
698 PacketContainer container(transport_, event_log_);
699 size_t max_packet_size;
700
701 {
702 MutexLock lock(&mutex_rtcp_sender_);
703 auto result = ComputeCompoundRTCPPacket(feedback_state, packet_types,
704 nack_size, nack_list, &container);
705 if (result) {
706 return *result;
707 }
708 max_packet_size = max_packet_size_;
709 }
710
711 size_t bytes_sent = container.SendPackets(max_packet_size);
712 return bytes_sent == 0 ? -1 : 0;
713 }
714
SendCompoundRTCPLocked(const FeedbackState & feedback_state,const std::set<RTCPPacketType> & packet_types,int32_t nack_size,const uint16_t * nack_list)715 int32_t RTCPSender::SendCompoundRTCPLocked(
716 const FeedbackState& feedback_state,
717 const std::set<RTCPPacketType>& packet_types,
718 int32_t nack_size,
719 const uint16_t* nack_list) {
720 PacketContainer container(transport_, event_log_);
721 auto result = ComputeCompoundRTCPPacket(feedback_state, packet_types,
722 nack_size, nack_list, &container);
723 if (result) {
724 return *result;
725 }
726 size_t bytes_sent = container.SendPackets(max_packet_size_);
727 return bytes_sent == 0 ? -1 : 0;
728 }
729
ComputeCompoundRTCPPacket(const FeedbackState & feedback_state,const std::set<RTCPPacketType> & packet_types,int32_t nack_size,const uint16_t * nack_list,rtcp::CompoundPacket * out_packet)730 absl::optional<int32_t> RTCPSender::ComputeCompoundRTCPPacket(
731 const FeedbackState& feedback_state,
732 const std::set<RTCPPacketType>& packet_types,
733 int32_t nack_size,
734 const uint16_t* nack_list,
735 rtcp::CompoundPacket* out_packet) {
736 if (method_ == RtcpMode::kOff) {
737 RTC_LOG(LS_WARNING) << "Can't send rtcp if it is disabled.";
738 return -1;
739 }
740 // Add all flags as volatile. Non volatile entries will not be overwritten.
741 // All new volatile flags added will be consumed by the end of this call.
742 SetFlags(packet_types, true);
743
744 // Prevent sending streams to send SR before any media has been sent.
745 const bool can_calculate_rtp_timestamp = (last_frame_capture_time_ms_ >= 0);
746 if (!can_calculate_rtp_timestamp) {
747 bool consumed_sr_flag = ConsumeFlag(kRtcpSr);
748 bool consumed_report_flag = sending_ && ConsumeFlag(kRtcpReport);
749 bool sender_report = consumed_report_flag || consumed_sr_flag;
750 if (sender_report && AllVolatileFlagsConsumed()) {
751 // This call was for Sender Report and nothing else.
752 return 0;
753 }
754 if (sending_ && method_ == RtcpMode::kCompound) {
755 // Not allowed to send any RTCP packet without sender report.
756 return -1;
757 }
758 }
759
760 if (packet_type_counter_.first_packet_time_ms == -1)
761 packet_type_counter_.first_packet_time_ms = clock_->TimeInMilliseconds();
762
763 // We need to send our NTP even if we haven't received any reports.
764 RtcpContext context(feedback_state, nack_size, nack_list,
765 clock_->CurrentTime());
766
767 PrepareReport(feedback_state);
768
769 std::unique_ptr<rtcp::RtcpPacket> packet_bye;
770
771 auto it = report_flags_.begin();
772 while (it != report_flags_.end()) {
773 auto builder_it = builders_.find(it->type);
774 if (it->is_volatile) {
775 report_flags_.erase(it++);
776 } else {
777 ++it;
778 }
779
780 if (builder_it == builders_.end()) {
781 RTC_NOTREACHED() << "Could not find builder for packet type " << it->type;
782 } else {
783 BuilderFunc func = builder_it->second;
784 std::unique_ptr<rtcp::RtcpPacket> packet = (this->*func)(context);
785 if (packet == nullptr)
786 return -1;
787 // If there is a BYE, don't append now - save it and append it
788 // at the end later.
789 if (builder_it->first == kRtcpBye) {
790 packet_bye = std::move(packet);
791 } else {
792 out_packet->Append(std::move(packet));
793 }
794 }
795 }
796
797 // Append the BYE now at the end
798 if (packet_bye) {
799 out_packet->Append(std::move(packet_bye));
800 }
801
802 if (packet_type_counter_observer_ != nullptr) {
803 packet_type_counter_observer_->RtcpPacketTypesCounterUpdated(
804 remote_ssrc_, packet_type_counter_);
805 }
806
807 RTC_DCHECK(AllVolatileFlagsConsumed());
808 return absl::nullopt;
809 }
810
PrepareReport(const FeedbackState & feedback_state)811 void RTCPSender::PrepareReport(const FeedbackState& feedback_state) {
812 bool generate_report;
813 if (IsFlagPresent(kRtcpSr) || IsFlagPresent(kRtcpRr)) {
814 // Report type already explicitly set, don't automatically populate.
815 generate_report = true;
816 RTC_DCHECK(ConsumeFlag(kRtcpReport) == false);
817 } else {
818 generate_report =
819 (ConsumeFlag(kRtcpReport) && method_ == RtcpMode::kReducedSize) ||
820 method_ == RtcpMode::kCompound;
821 if (generate_report)
822 SetFlag(sending_ ? kRtcpSr : kRtcpRr, true);
823 }
824
825 if (IsFlagPresent(kRtcpSr) || (IsFlagPresent(kRtcpRr) && !cname_.empty()))
826 SetFlag(kRtcpSdes, true);
827
828 if (generate_report) {
829 if ((!sending_ && xr_send_receiver_reference_time_enabled_) ||
830 !feedback_state.last_xr_rtis.empty() ||
831 send_video_bitrate_allocation_) {
832 SetFlag(kRtcpAnyExtendedReports, true);
833 }
834
835 // generate next time to send an RTCP report
836 int min_interval_ms = report_interval_ms_;
837
838 if (!audio_ && sending_) {
839 // Calculate bandwidth for video; 360 / send bandwidth in kbit/s.
840 int send_bitrate_kbit = feedback_state.send_bitrate / 1000;
841 if (send_bitrate_kbit != 0) {
842 min_interval_ms = 360000 / send_bitrate_kbit;
843 min_interval_ms = std::min(min_interval_ms, report_interval_ms_);
844 }
845 }
846
847 // The interval between RTCP packets is varied randomly over the
848 // range [1/2,3/2] times the calculated interval.
849 int time_to_next =
850 random_.Rand(min_interval_ms * 1 / 2, min_interval_ms * 3 / 2);
851
852 RTC_DCHECK_GT(time_to_next, 0);
853 next_time_to_send_rtcp_ = clock_->TimeInMilliseconds() + time_to_next;
854
855 // RtcpSender expected to be used for sending either just sender reports
856 // or just receiver reports.
857 RTC_DCHECK(!(IsFlagPresent(kRtcpSr) && IsFlagPresent(kRtcpRr)));
858 }
859 }
860
CreateReportBlocks(const FeedbackState & feedback_state)861 std::vector<rtcp::ReportBlock> RTCPSender::CreateReportBlocks(
862 const FeedbackState& feedback_state) {
863 std::vector<rtcp::ReportBlock> result;
864 if (!receive_statistics_)
865 return result;
866
867 // TODO(danilchap): Support sending more than |RTCP_MAX_REPORT_BLOCKS| per
868 // compound rtcp packet when single rtcp module is used for multiple media
869 // streams.
870 result = receive_statistics_->RtcpReportBlocks(RTCP_MAX_REPORT_BLOCKS);
871
872 if (!result.empty() && ((feedback_state.last_rr_ntp_secs != 0) ||
873 (feedback_state.last_rr_ntp_frac != 0))) {
874 // Get our NTP as late as possible to avoid a race.
875 uint32_t now = CompactNtp(clock_->CurrentNtpTime());
876
877 uint32_t receive_time = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
878 receive_time <<= 16;
879 receive_time += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
880
881 uint32_t delay_since_last_sr = now - receive_time;
882 // TODO(danilchap): Instead of setting same value on all report blocks,
883 // set only when media_ssrc match sender ssrc of the sender report
884 // remote times were taken from.
885 for (auto& report_block : result) {
886 report_block.SetLastSr(feedback_state.remote_sr);
887 report_block.SetDelayLastSr(delay_since_last_sr);
888 }
889 }
890 return result;
891 }
892
SetCsrcs(const std::vector<uint32_t> & csrcs)893 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
894 RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
895 MutexLock lock(&mutex_rtcp_sender_);
896 csrcs_ = csrcs;
897 }
898
SendRtcpXrReceiverReferenceTime(bool enable)899 void RTCPSender::SendRtcpXrReceiverReferenceTime(bool enable) {
900 MutexLock lock(&mutex_rtcp_sender_);
901 xr_send_receiver_reference_time_enabled_ = enable;
902 }
903
RtcpXrReceiverReferenceTime() const904 bool RTCPSender::RtcpXrReceiverReferenceTime() const {
905 MutexLock lock(&mutex_rtcp_sender_);
906 return xr_send_receiver_reference_time_enabled_;
907 }
908
SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set)909 void RTCPSender::SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) {
910 MutexLock lock(&mutex_rtcp_sender_);
911 tmmbn_to_send_ = std::move(bounding_set);
912 SetFlag(kRtcpTmmbn, true);
913 }
914
SetFlag(uint32_t type,bool is_volatile)915 void RTCPSender::SetFlag(uint32_t type, bool is_volatile) {
916 if (type & kRtcpAnyExtendedReports) {
917 report_flags_.insert(ReportFlag(kRtcpAnyExtendedReports, is_volatile));
918 } else {
919 report_flags_.insert(ReportFlag(type, is_volatile));
920 }
921 }
922
SetFlags(const std::set<RTCPPacketType> & types,bool is_volatile)923 void RTCPSender::SetFlags(const std::set<RTCPPacketType>& types,
924 bool is_volatile) {
925 for (RTCPPacketType type : types)
926 SetFlag(type, is_volatile);
927 }
928
IsFlagPresent(uint32_t type) const929 bool RTCPSender::IsFlagPresent(uint32_t type) const {
930 return report_flags_.find(ReportFlag(type, false)) != report_flags_.end();
931 }
932
ConsumeFlag(uint32_t type,bool forced)933 bool RTCPSender::ConsumeFlag(uint32_t type, bool forced) {
934 auto it = report_flags_.find(ReportFlag(type, false));
935 if (it == report_flags_.end())
936 return false;
937 if (it->is_volatile || forced)
938 report_flags_.erase((it));
939 return true;
940 }
941
AllVolatileFlagsConsumed() const942 bool RTCPSender::AllVolatileFlagsConsumed() const {
943 for (const ReportFlag& flag : report_flags_) {
944 if (flag.is_volatile)
945 return false;
946 }
947 return true;
948 }
949
SetVideoBitrateAllocation(const VideoBitrateAllocation & bitrate)950 void RTCPSender::SetVideoBitrateAllocation(
951 const VideoBitrateAllocation& bitrate) {
952 MutexLock lock(&mutex_rtcp_sender_);
953 // Check if this allocation is first ever, or has a different set of
954 // spatial/temporal layers signaled and enabled, if so trigger an rtcp report
955 // as soon as possible.
956 absl::optional<VideoBitrateAllocation> new_bitrate =
957 CheckAndUpdateLayerStructure(bitrate);
958 if (new_bitrate) {
959 video_bitrate_allocation_ = *new_bitrate;
960 RTC_LOG(LS_INFO) << "Emitting TargetBitrate XR for SSRC " << ssrc_
961 << " with new layers enabled/disabled: "
962 << video_bitrate_allocation_.ToString();
963 next_time_to_send_rtcp_ = clock_->TimeInMilliseconds();
964 } else {
965 video_bitrate_allocation_ = bitrate;
966 }
967
968 send_video_bitrate_allocation_ = true;
969 SetFlag(kRtcpAnyExtendedReports, true);
970 }
971
CheckAndUpdateLayerStructure(const VideoBitrateAllocation & bitrate) const972 absl::optional<VideoBitrateAllocation> RTCPSender::CheckAndUpdateLayerStructure(
973 const VideoBitrateAllocation& bitrate) const {
974 absl::optional<VideoBitrateAllocation> updated_bitrate;
975 for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
976 for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
977 if (!updated_bitrate &&
978 (bitrate.HasBitrate(si, ti) !=
979 video_bitrate_allocation_.HasBitrate(si, ti) ||
980 (bitrate.GetBitrate(si, ti) == 0) !=
981 (video_bitrate_allocation_.GetBitrate(si, ti) == 0))) {
982 updated_bitrate = bitrate;
983 }
984 if (video_bitrate_allocation_.GetBitrate(si, ti) > 0 &&
985 bitrate.GetBitrate(si, ti) == 0) {
986 // Make sure this stream disabling is explicitly signaled.
987 updated_bitrate->SetBitrate(si, ti, 0);
988 }
989 }
990 }
991
992 return updated_bitrate;
993 }
994
SendCombinedRtcpPacket(std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets)995 void RTCPSender::SendCombinedRtcpPacket(
996 std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) {
997 size_t max_packet_size;
998 uint32_t ssrc;
999 {
1000 MutexLock lock(&mutex_rtcp_sender_);
1001 if (method_ == RtcpMode::kOff) {
1002 RTC_LOG(LS_WARNING) << "Can't send rtcp if it is disabled.";
1003 return;
1004 }
1005
1006 max_packet_size = max_packet_size_;
1007 ssrc = ssrc_;
1008 }
1009 RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
1010 auto callback = [&](rtc::ArrayView<const uint8_t> packet) {
1011 if (transport_->SendRtcp(packet.data(), packet.size())) {
1012 if (event_log_)
1013 event_log_->Log(std::make_unique<RtcEventRtcpPacketOutgoing>(packet));
1014 }
1015 };
1016 PacketSender sender(callback, max_packet_size);
1017 for (auto& rtcp_packet : rtcp_packets) {
1018 rtcp_packet->SetSenderSsrc(ssrc);
1019 sender.AppendPacket(*rtcp_packet);
1020 }
1021 sender.Send();
1022 }
1023
1024 } // namespace webrtc
1025