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