Line data Source code
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 "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
12 :
13 : #include <algorithm>
14 : #include <utility>
15 :
16 : #include "webrtc/base/checks.h"
17 : #include "webrtc/base/logging.h"
18 : #include "webrtc/base/rate_limiter.h"
19 : #include "webrtc/base/trace_event.h"
20 : #include "webrtc/base/timeutils.h"
21 : #include "webrtc/call/call.h"
22 : #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
23 : #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h"
24 : #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
25 : #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
26 : #include "webrtc/modules/rtp_rtcp/source/playout_delay_oracle.h"
27 : #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
28 : #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h"
29 : #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h"
30 : #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
31 : #include "webrtc/modules/rtp_rtcp/source/time_util.h"
32 : #include "webrtc/system_wrappers/include/field_trial.h"
33 :
34 : namespace webrtc {
35 :
36 : namespace {
37 : // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
38 : constexpr size_t kMaxPaddingLength = 224;
39 : constexpr int kSendSideDelayWindowMs = 1000;
40 : constexpr size_t kRtpHeaderLength = 12;
41 : constexpr uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1.
42 : constexpr uint32_t kTimestampTicksPerMs = 90;
43 : constexpr int kBitrateStatisticsWindowMs = 1000;
44 :
45 : constexpr size_t kMinFlexfecPacketsToStoreForPacing = 50;
46 :
47 0 : const char* FrameTypeToString(FrameType frame_type) {
48 0 : switch (frame_type) {
49 : case kEmptyFrame:
50 0 : return "empty";
51 0 : case kAudioFrameSpeech: return "audio_speech";
52 0 : case kAudioFrameCN: return "audio_cn";
53 0 : case kVideoFrameKey: return "video_key";
54 0 : case kVideoFrameDelta: return "video_delta";
55 : }
56 0 : return "";
57 : }
58 :
59 0 : void CountPacket(RtpPacketCounter* counter, const RtpPacketToSend& packet) {
60 0 : ++counter->packets;
61 0 : counter->header_bytes += packet.headers_size();
62 0 : counter->padding_bytes += packet.padding_size();
63 0 : counter->payload_bytes += packet.payload_size();
64 0 : }
65 :
66 : } // namespace
67 :
68 0 : RTPSender::RTPSender(
69 : bool audio,
70 : Clock* clock,
71 : Transport* transport,
72 : RtpPacketSender* paced_sender,
73 : FlexfecSender* flexfec_sender,
74 : TransportSequenceNumberAllocator* sequence_number_allocator,
75 : TransportFeedbackObserver* transport_feedback_observer,
76 : BitrateStatisticsObserver* bitrate_callback,
77 : FrameCountObserver* frame_count_observer,
78 : SendSideDelayObserver* send_side_delay_observer,
79 : RtcEventLog* event_log,
80 : SendPacketObserver* send_packet_observer,
81 : RateLimiter* retransmission_rate_limiter,
82 0 : OverheadObserver* overhead_observer)
83 : : clock_(clock),
84 : // TODO(holmer): Remove this conversion?
85 0 : clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()),
86 0 : random_(clock_->TimeInMicroseconds()),
87 : audio_configured_(audio),
88 0 : audio_(audio ? new RTPSenderAudio(clock, this) : nullptr),
89 0 : video_(audio ? nullptr : new RTPSenderVideo(clock, this, flexfec_sender)),
90 : paced_sender_(paced_sender),
91 : transport_sequence_number_allocator_(sequence_number_allocator),
92 : transport_feedback_observer_(transport_feedback_observer),
93 : last_capture_time_ms_sent_(0),
94 : transport_(transport),
95 : sending_media_(true), // Default to sending media.
96 : max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
97 : payload_type_(-1),
98 : payload_type_map_(),
99 : rtp_header_extension_map_(),
100 : rid_{0},
101 : packet_history_(clock),
102 : flexfec_packet_history_(clock),
103 : // Statistics
104 : rtp_stats_callback_(nullptr),
105 : total_bitrate_sent_(kBitrateStatisticsWindowMs,
106 : RateStatistics::kBpsScale),
107 : nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
108 : frame_count_observer_(frame_count_observer),
109 : send_side_delay_observer_(send_side_delay_observer),
110 : event_log_(event_log),
111 : send_packet_observer_(send_packet_observer),
112 : bitrate_callback_(bitrate_callback),
113 : // RTP variables
114 0 : ssrc_db_(SSRCDatabase::GetSSRCDatabase()),
115 : remote_ssrc_(0),
116 : sequence_number_forced_(false),
117 : ssrc_forced_(false),
118 : last_rtp_timestamp_(0),
119 : capture_time_ms_(0),
120 : last_timestamp_time_ms_(0),
121 : media_has_been_sent_(false),
122 : last_packet_marker_bit_(false),
123 : csrcs_(),
124 : rtx_(kRtxOff),
125 : rtp_overhead_bytes_per_packet_(0),
126 : retransmission_rate_limiter_(retransmission_rate_limiter),
127 0 : overhead_observer_(overhead_observer) {
128 0 : ssrc_ = ssrc_db_->CreateSSRC();
129 0 : RTC_DCHECK(ssrc_ != 0);
130 0 : ssrc_rtx_ = ssrc_db_->CreateSSRC();
131 0 : RTC_DCHECK(ssrc_rtx_ != 0);
132 :
133 : // This random initialization is not intended to be cryptographic strong.
134 0 : timestamp_offset_ = random_.Rand<uint32_t>();
135 : // Random start, 16 bits. Can't be 0.
136 0 : sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
137 0 : sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
138 :
139 : // Store FlexFEC packets in the packet history data structure, so they can
140 : // be found when paced.
141 0 : if (flexfec_sender) {
142 0 : flexfec_packet_history_.SetStorePacketsStatus(
143 0 : true, kMinFlexfecPacketsToStoreForPacing);
144 : }
145 0 : }
146 :
147 0 : RTPSender::~RTPSender() {
148 : // TODO(tommi): Use a thread checker to ensure the object is created and
149 : // deleted on the same thread. At the moment this isn't possible due to
150 : // voe::ChannelOwner in voice engine. To reproduce, run:
151 : // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
152 :
153 : // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
154 : // variables but we grab them in all other methods. (what's the design?)
155 : // Start documenting what thread we're on in what method so that it's easier
156 : // to understand performance attributes and possibly remove locks.
157 0 : if (remote_ssrc_ != 0) {
158 0 : ssrc_db_->ReturnSSRC(remote_ssrc_);
159 : }
160 0 : ssrc_db_->ReturnSSRC(ssrc_);
161 :
162 0 : SSRCDatabase::ReturnSSRCDatabase();
163 0 : while (!payload_type_map_.empty()) {
164 : std::map<int8_t, RtpUtility::Payload*>::iterator it =
165 0 : payload_type_map_.begin();
166 0 : delete it->second;
167 0 : payload_type_map_.erase(it);
168 : }
169 0 : }
170 :
171 0 : uint16_t RTPSender::ActualSendBitrateKbit() const {
172 0 : rtc::CritScope cs(&statistics_crit_);
173 : return static_cast<uint16_t>(
174 0 : total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0) /
175 0 : 1000);
176 : }
177 :
178 0 : uint32_t RTPSender::VideoBitrateSent() const {
179 0 : if (video_) {
180 0 : return video_->VideoBitrateSent();
181 : }
182 0 : return 0;
183 : }
184 :
185 0 : uint32_t RTPSender::FecOverheadRate() const {
186 0 : if (video_) {
187 0 : return video_->FecOverheadRate();
188 : }
189 0 : return 0;
190 : }
191 :
192 0 : uint32_t RTPSender::NackOverheadRate() const {
193 0 : rtc::CritScope cs(&statistics_crit_);
194 0 : return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
195 : }
196 :
197 0 : int32_t RTPSender::SetRID(const char* rid) {
198 0 : rtc::CritScope lock(&send_critsect_);
199 0 : const size_t len = rid ? strlen(rid) : 0;
200 0 : if (!len || len >= sizeof(rid_)) {
201 0 : rid_[0] = '\0';
202 : } else {
203 0 : memmove(&rid_[0], rid, len + 1);
204 : }
205 0 : return 0;
206 : }
207 :
208 0 : int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
209 : uint8_t id) {
210 0 : rtc::CritScope lock(&send_critsect_);
211 0 : switch (type) {
212 : case kRtpExtensionVideoRotation:
213 : case kRtpExtensionPlayoutDelay:
214 : case kRtpExtensionTransmissionTimeOffset:
215 : case kRtpExtensionAbsoluteSendTime:
216 : case kRtpExtensionAudioLevel:
217 : case kRtpExtensionTransportSequenceNumber:
218 : case kRtpExtensionRtpStreamId:
219 0 : return rtp_header_extension_map_.Register(type, id);
220 : case kRtpExtensionNone:
221 : case kRtpExtensionNumberOfExtensions:
222 0 : LOG(LS_ERROR) << "Invalid RTP extension type for registration";
223 0 : return -1;
224 : }
225 0 : return -1;
226 : }
227 :
228 0 : bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) {
229 0 : rtc::CritScope lock(&send_critsect_);
230 0 : return rtp_header_extension_map_.IsRegistered(type);
231 : }
232 :
233 0 : int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
234 0 : rtc::CritScope lock(&send_critsect_);
235 0 : return rtp_header_extension_map_.Deregister(type);
236 : }
237 :
238 0 : int32_t RTPSender::RegisterPayload(
239 : const char payload_name[RTP_PAYLOAD_NAME_SIZE],
240 : int8_t payload_number,
241 : uint32_t frequency,
242 : size_t channels,
243 : uint32_t rate) {
244 0 : RTC_DCHECK_LT(strlen(payload_name), RTP_PAYLOAD_NAME_SIZE);
245 0 : rtc::CritScope lock(&send_critsect_);
246 :
247 : std::map<int8_t, RtpUtility::Payload*>::iterator it =
248 0 : payload_type_map_.find(payload_number);
249 :
250 0 : if (payload_type_map_.end() != it) {
251 : // We already use this payload type.
252 0 : RtpUtility::Payload* payload = it->second;
253 0 : assert(payload);
254 :
255 : // Check if it's the same as we already have.
256 0 : if (RtpUtility::StringCompare(
257 : payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1)) {
258 0 : if (audio_configured_ && payload->audio &&
259 0 : payload->typeSpecific.Audio.frequency == frequency &&
260 0 : (payload->typeSpecific.Audio.rate == rate ||
261 0 : payload->typeSpecific.Audio.rate == 0 || rate == 0)) {
262 0 : payload->typeSpecific.Audio.rate = rate;
263 : // Ensure that we update the rate if new or old is zero.
264 0 : return 0;
265 : }
266 0 : if (!audio_configured_ && !payload->audio) {
267 0 : return 0;
268 : }
269 : }
270 0 : return -1;
271 : }
272 0 : int32_t ret_val = 0;
273 0 : RtpUtility::Payload* payload = nullptr;
274 0 : if (audio_configured_) {
275 : // TODO(mflodman): Change to CreateAudioPayload and make static.
276 0 : ret_val = audio_->RegisterAudioPayload(payload_name, payload_number,
277 0 : frequency, channels, rate, &payload);
278 : } else {
279 0 : payload = video_->CreateVideoPayload(payload_name, payload_number);
280 : }
281 0 : if (payload) {
282 0 : payload_type_map_[payload_number] = payload;
283 : }
284 0 : return ret_val;
285 : }
286 :
287 0 : int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) {
288 0 : rtc::CritScope lock(&send_critsect_);
289 :
290 : std::map<int8_t, RtpUtility::Payload*>::iterator it =
291 0 : payload_type_map_.find(payload_type);
292 :
293 0 : if (payload_type_map_.end() == it) {
294 0 : return -1;
295 : }
296 0 : RtpUtility::Payload* payload = it->second;
297 : delete payload;
298 0 : payload_type_map_.erase(it);
299 0 : return 0;
300 : }
301 :
302 0 : void RTPSender::SetSendPayloadType(int8_t payload_type) {
303 0 : rtc::CritScope lock(&send_critsect_);
304 0 : payload_type_ = payload_type;
305 0 : }
306 :
307 0 : int8_t RTPSender::SendPayloadType() const {
308 0 : rtc::CritScope lock(&send_critsect_);
309 0 : return payload_type_;
310 : }
311 :
312 0 : void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
313 : // Sanity check.
314 0 : RTC_DCHECK(max_packet_size >= 100 && max_packet_size <= IP_PACKET_SIZE)
315 0 : << "Invalid max payload length: " << max_packet_size;
316 0 : rtc::CritScope lock(&send_critsect_);
317 0 : max_packet_size_ = max_packet_size;
318 0 : }
319 :
320 0 : size_t RTPSender::MaxPayloadSize() const {
321 0 : if (audio_configured_) {
322 0 : return max_packet_size_ - RtpHeaderLength();
323 : } else {
324 0 : return max_packet_size_ - RtpHeaderLength() // RTP overhead.
325 0 : - video_->FecPacketOverhead() // FEC/ULP/RED overhead.
326 0 : - (RtxStatus() ? kRtxHeaderSize : 0); // RTX overhead.
327 : }
328 : }
329 :
330 0 : size_t RTPSender::MaxRtpPacketSize() const {
331 0 : return max_packet_size_;
332 : }
333 :
334 0 : void RTPSender::SetRtxStatus(int mode) {
335 0 : rtc::CritScope lock(&send_critsect_);
336 0 : rtx_ = mode;
337 0 : }
338 :
339 0 : int RTPSender::RtxStatus() const {
340 0 : rtc::CritScope lock(&send_critsect_);
341 0 : return rtx_;
342 : }
343 :
344 0 : void RTPSender::SetRtxSsrc(uint32_t ssrc) {
345 0 : rtc::CritScope lock(&send_critsect_);
346 0 : ssrc_rtx_ = ssrc;
347 0 : }
348 :
349 0 : uint32_t RTPSender::RtxSsrc() const {
350 0 : rtc::CritScope lock(&send_critsect_);
351 0 : return ssrc_rtx_;
352 : }
353 :
354 0 : void RTPSender::SetRtxPayloadType(int payload_type,
355 : int associated_payload_type) {
356 0 : rtc::CritScope lock(&send_critsect_);
357 0 : RTC_DCHECK_LE(payload_type, 127);
358 0 : RTC_DCHECK_LE(associated_payload_type, 127);
359 0 : if (payload_type < 0) {
360 0 : LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type;
361 0 : return;
362 : }
363 :
364 0 : rtx_payload_type_map_[associated_payload_type] = payload_type;
365 : }
366 :
367 0 : int32_t RTPSender::CheckPayloadType(int8_t payload_type,
368 : RtpVideoCodecTypes* video_type) {
369 0 : rtc::CritScope lock(&send_critsect_);
370 :
371 0 : if (payload_type < 0) {
372 0 : LOG(LS_ERROR) << "Invalid payload_type " << payload_type;
373 0 : return -1;
374 : }
375 0 : if (payload_type_ == payload_type) {
376 0 : if (!audio_configured_) {
377 0 : *video_type = video_->VideoCodecType();
378 : }
379 0 : return 0;
380 : }
381 : std::map<int8_t, RtpUtility::Payload*>::iterator it =
382 0 : payload_type_map_.find(payload_type);
383 0 : if (it == payload_type_map_.end()) {
384 0 : LOG(LS_WARNING) << "Payload type " << static_cast<int>(payload_type)
385 0 : << " not registered.";
386 0 : return -1;
387 : }
388 0 : SetSendPayloadType(payload_type);
389 0 : RtpUtility::Payload* payload = it->second;
390 0 : assert(payload);
391 0 : if (!payload->audio && !audio_configured_) {
392 0 : video_->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType);
393 0 : *video_type = payload->typeSpecific.Video.videoCodecType;
394 : }
395 0 : return 0;
396 : }
397 :
398 0 : bool RTPSender::SendOutgoingData(FrameType frame_type,
399 : int8_t payload_type,
400 : uint32_t capture_timestamp,
401 : int64_t capture_time_ms,
402 : const uint8_t* payload_data,
403 : size_t payload_size,
404 : const RTPFragmentationHeader* fragmentation,
405 : const RTPVideoHeader* rtp_header,
406 : uint32_t* transport_frame_id_out) {
407 : uint32_t ssrc;
408 : uint16_t sequence_number;
409 : uint32_t rtp_timestamp;
410 : {
411 : // Drop this packet if we're not sending media packets.
412 0 : rtc::CritScope lock(&send_critsect_);
413 0 : ssrc = ssrc_;
414 0 : sequence_number = sequence_number_;
415 0 : rtp_timestamp = timestamp_offset_ + capture_timestamp;
416 0 : if (transport_frame_id_out)
417 0 : *transport_frame_id_out = rtp_timestamp;
418 0 : if (!sending_media_)
419 0 : return true;
420 : }
421 0 : RtpVideoCodecTypes video_type = kRtpVideoGeneric;
422 0 : if (CheckPayloadType(payload_type, &video_type) != 0) {
423 0 : LOG(LS_ERROR) << "Don't send data with unknown payload type: "
424 0 : << static_cast<int>(payload_type) << ".";
425 0 : return false;
426 : }
427 :
428 : bool result;
429 0 : if (audio_configured_) {
430 0 : TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", rtp_timestamp, "Send", "type",
431 : FrameTypeToString(frame_type));
432 0 : assert(frame_type == kAudioFrameSpeech || frame_type == kAudioFrameCN ||
433 : frame_type == kEmptyFrame);
434 :
435 0 : result = audio_->SendAudio(frame_type, payload_type, rtp_timestamp,
436 0 : payload_data, payload_size, fragmentation);
437 : } else {
438 0 : TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms,
439 : "Send", "type", FrameTypeToString(frame_type));
440 0 : assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN);
441 :
442 0 : if (frame_type == kEmptyFrame)
443 0 : return true;
444 :
445 0 : if (rtp_header) {
446 0 : playout_delay_oracle_.UpdateRequest(ssrc, rtp_header->playout_delay,
447 0 : sequence_number);
448 : }
449 :
450 0 : result = video_->SendVideo(video_type, frame_type, payload_type,
451 : rtp_timestamp, capture_time_ms, payload_data,
452 : payload_size, fragmentation, rtp_header,
453 0 : &rid_[0]);
454 : }
455 :
456 0 : rtc::CritScope cs(&statistics_crit_);
457 : // Note: This is currently only counting for video.
458 0 : if (frame_type == kVideoFrameKey) {
459 0 : ++frame_counts_.key_frames;
460 0 : } else if (frame_type == kVideoFrameDelta) {
461 0 : ++frame_counts_.delta_frames;
462 : }
463 0 : if (frame_count_observer_) {
464 0 : frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
465 : }
466 :
467 0 : return result;
468 : }
469 :
470 0 : size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
471 : int probe_cluster_id) {
472 : {
473 0 : rtc::CritScope lock(&send_critsect_);
474 0 : if (!sending_media_)
475 0 : return 0;
476 0 : if ((rtx_ & kRtxRedundantPayloads) == 0)
477 0 : return 0;
478 : }
479 :
480 0 : int bytes_left = static_cast<int>(bytes_to_send);
481 0 : while (bytes_left > 0) {
482 : std::unique_ptr<RtpPacketToSend> packet =
483 0 : packet_history_.GetBestFittingPacket(bytes_left);
484 0 : if (!packet)
485 0 : break;
486 0 : size_t payload_size = packet->payload_size();
487 0 : if (!PrepareAndSendPacket(std::move(packet), true, false, probe_cluster_id))
488 0 : break;
489 0 : bytes_left -= payload_size;
490 : }
491 0 : return bytes_to_send - bytes_left;
492 : }
493 :
494 0 : size_t RTPSender::SendPadData(size_t bytes, int probe_cluster_id) {
495 : // Always send full padding packets. This is accounted for by the
496 : // RtpPacketSender, which will make sure we don't send too much padding even
497 : // if a single packet is larger than requested.
498 : size_t padding_bytes_in_packet =
499 0 : std::min(MaxPayloadSize(), kMaxPaddingLength);
500 0 : size_t bytes_sent = 0;
501 0 : while (bytes_sent < bytes) {
502 0 : int64_t now_ms = clock_->TimeInMilliseconds();
503 : uint32_t ssrc;
504 : uint32_t timestamp;
505 : int64_t capture_time_ms;
506 : uint16_t sequence_number;
507 : int payload_type;
508 : bool over_rtx;
509 : {
510 0 : rtc::CritScope lock(&send_critsect_);
511 0 : if (!sending_media_)
512 0 : break;
513 0 : timestamp = last_rtp_timestamp_;
514 0 : capture_time_ms = capture_time_ms_;
515 0 : if (rtx_ == kRtxOff) {
516 : // Without RTX we can't send padding in the middle of frames.
517 0 : if (!last_packet_marker_bit_)
518 0 : break;
519 0 : ssrc = ssrc_;
520 0 : sequence_number = sequence_number_;
521 0 : ++sequence_number_;
522 0 : payload_type = payload_type_;
523 0 : over_rtx = false;
524 : } else {
525 : // Without abs-send-time or transport sequence number a media packet
526 : // must be sent before padding so that the timestamps used for
527 : // estimation are correct.
528 0 : if (!media_has_been_sent_ &&
529 0 : !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
530 0 : (rtp_header_extension_map_.IsRegistered(
531 0 : TransportSequenceNumber::kId) &&
532 0 : transport_sequence_number_allocator_))) {
533 0 : break;
534 : }
535 : // Only change change the timestamp of padding packets sent over RTX.
536 : // Padding only packets over RTP has to be sent as part of a media
537 : // frame (and therefore the same timestamp).
538 0 : if (last_timestamp_time_ms_ > 0) {
539 0 : timestamp +=
540 0 : (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
541 0 : capture_time_ms += (now_ms - last_timestamp_time_ms_);
542 : }
543 0 : ssrc = ssrc_rtx_;
544 0 : sequence_number = sequence_number_rtx_;
545 0 : ++sequence_number_rtx_;
546 0 : payload_type = rtx_payload_type_map_.begin()->second;
547 0 : over_rtx = true;
548 : }
549 : }
550 :
551 0 : std::unique_ptr<RtpPacketToSend> padding_packet(new RtpPacketToSend(&rtp_header_extension_map_));
552 0 : padding_packet->SetPayloadType(payload_type);
553 0 : padding_packet->SetMarker(false);
554 0 : padding_packet->SetSequenceNumber(sequence_number);
555 0 : padding_packet->SetTimestamp(timestamp);
556 0 : padding_packet->SetSsrc(ssrc);
557 :
558 0 : if (capture_time_ms > 0) {
559 0 : padding_packet->SetExtension<TransmissionOffset>(
560 0 : (now_ms - capture_time_ms) * kTimestampTicksPerMs);
561 : }
562 0 : padding_packet->SetExtension<AbsoluteSendTime>(now_ms);
563 0 : PacketOptions options;
564 : bool has_transport_seq_num =
565 0 : UpdateTransportSequenceNumber(padding_packet.get(), &options.packet_id);
566 0 : padding_packet->SetPadding(padding_bytes_in_packet, &random_);
567 :
568 0 : if (has_transport_seq_num) {
569 0 : AddPacketToTransportFeedback(options.packet_id, *padding_packet,
570 0 : probe_cluster_id);
571 : }
572 :
573 0 : if (!SendPacketToNetwork(*padding_packet, options))
574 0 : break;
575 0 : UpdateRtpStats(*padding_packet, over_rtx, false);
576 :
577 0 : packet_history_.PutRtpPacket(std::move(padding_packet),
578 : kAllowRetransmission,
579 0 : true);
580 :
581 0 : bytes_sent += padding_bytes_in_packet;
582 : }
583 :
584 0 : return bytes_sent;
585 : }
586 :
587 0 : void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
588 0 : packet_history_.SetStorePacketsStatus(enable, number_to_store);
589 0 : }
590 :
591 0 : bool RTPSender::StorePackets() const {
592 0 : return packet_history_.StorePackets();
593 : }
594 :
595 0 : int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) {
596 : std::unique_ptr<RtpPacketToSend> packet =
597 0 : packet_history_.GetPacketAndSetSendTime(packet_id, min_resend_time, true);
598 0 : if (!packet) {
599 : // Packet not found.
600 0 : return 0;
601 : }
602 :
603 : // Check if we're overusing retransmission bitrate.
604 : // TODO(sprang): Add histograms for nack success or failure reasons.
605 0 : RTC_DCHECK(retransmission_rate_limiter_);
606 0 : if (!retransmission_rate_limiter_->TryUseRate(packet->size()))
607 0 : return -1;
608 :
609 0 : if (paced_sender_) {
610 : // Convert from TickTime to Clock since capture_time_ms is based on
611 : // TickTime.
612 : int64_t corrected_capture_tims_ms =
613 0 : packet->capture_time_ms() + clock_delta_ms_;
614 0 : paced_sender_->InsertPacket(RtpPacketSender::kNormalPriority,
615 0 : packet->Ssrc(), packet->SequenceNumber(),
616 : corrected_capture_tims_ms,
617 0 : packet->payload_size(), true);
618 :
619 0 : return packet->size();
620 : }
621 0 : bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
622 0 : int32_t packet_size = static_cast<int32_t>(packet->size());
623 0 : if (!PrepareAndSendPacket(std::move(packet), rtx, true,
624 : PacketInfo::kNotAProbe))
625 0 : return -1;
626 0 : return packet_size;
627 : }
628 :
629 0 : bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
630 : const PacketOptions& options) {
631 0 : int bytes_sent = -1;
632 0 : if (transport_) {
633 0 : UpdateRtpOverhead(packet);
634 0 : bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
635 0 : ? static_cast<int>(packet.size())
636 : : -1;
637 0 : if (event_log_ && bytes_sent > 0) {
638 0 : event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet.data(),
639 0 : packet.size());
640 : }
641 : }
642 0 : TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
643 : "RTPSender::SendPacketToNetwork", "size", packet.size(),
644 : "sent", bytes_sent);
645 : // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
646 0 : if (bytes_sent <= 0) {
647 0 : LOG(LS_WARNING) << "Transport failed to send packet";
648 0 : return false;
649 : }
650 0 : return true;
651 : }
652 :
653 0 : int RTPSender::SelectiveRetransmissions() const {
654 0 : if (!video_)
655 0 : return -1;
656 0 : return video_->SelectiveRetransmissions();
657 : }
658 :
659 0 : int RTPSender::SetSelectiveRetransmissions(uint8_t settings) {
660 0 : if (!video_)
661 0 : return -1;
662 0 : video_->SetSelectiveRetransmissions(settings);
663 0 : return 0;
664 : }
665 :
666 0 : void RTPSender::OnReceivedNack(
667 : const std::vector<uint16_t>& nack_sequence_numbers,
668 : int64_t avg_rtt) {
669 0 : TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
670 : "RTPSender::OnReceivedNACK", "num_seqnum",
671 : nack_sequence_numbers.size(), "avg_rtt", avg_rtt);
672 0 : for (uint16_t seq_no : nack_sequence_numbers) {
673 0 : const int32_t bytes_sent = ReSendPacket(seq_no, 5 + avg_rtt);
674 0 : if (bytes_sent < 0) {
675 : // Failed to send one Sequence number. Give up the rest in this nack.
676 0 : LOG(LS_WARNING) << "Failed resending RTP packet " << seq_no
677 0 : << ", Discard rest of packets";
678 0 : break;
679 : }
680 : }
681 0 : }
682 :
683 0 : void RTPSender::OnReceivedRtcpReportBlocks(
684 : const ReportBlockList& report_blocks) {
685 0 : playout_delay_oracle_.OnReceivedRtcpReportBlocks(report_blocks);
686 0 : }
687 :
688 : // Called from pacer when we can send the packet.
689 0 : bool RTPSender::TimeToSendPacket(uint32_t ssrc,
690 : uint16_t sequence_number,
691 : int64_t capture_time_ms,
692 : bool retransmission,
693 : int probe_cluster_id) {
694 0 : if (!SendingMedia())
695 0 : return true;
696 :
697 0 : std::unique_ptr<RtpPacketToSend> packet;
698 0 : if (ssrc == SSRC()) {
699 0 : packet = packet_history_.GetPacketAndSetSendTime(sequence_number, 0,
700 0 : retransmission);
701 0 : } else if (ssrc == FlexfecSsrc()) {
702 0 : packet = flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number, 0,
703 0 : retransmission);
704 : }
705 :
706 0 : if (!packet) {
707 : // Packet cannot be found.
708 0 : return true;
709 : }
710 :
711 0 : return PrepareAndSendPacket(
712 0 : std::move(packet),
713 0 : retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission,
714 0 : probe_cluster_id);
715 : }
716 :
717 0 : bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
718 : bool send_over_rtx,
719 : bool is_retransmit,
720 : int probe_cluster_id) {
721 0 : RTC_DCHECK(packet);
722 0 : int64_t capture_time_ms = packet->capture_time_ms();
723 0 : RtpPacketToSend* packet_to_send = packet.get();
724 :
725 0 : if (!is_retransmit && packet->Marker()) {
726 0 : TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
727 : capture_time_ms);
728 : }
729 :
730 0 : TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
731 : "PrepareAndSendPacket", "timestamp", packet->Timestamp(),
732 : "seqnum", packet->SequenceNumber());
733 :
734 0 : std::unique_ptr<RtpPacketToSend> packet_rtx;
735 0 : if (send_over_rtx) {
736 0 : packet_rtx = BuildRtxPacket(*packet);
737 0 : if (!packet_rtx)
738 0 : return false;
739 0 : packet_to_send = packet_rtx.get();
740 : }
741 :
742 0 : int64_t now_ms = clock_->TimeInMilliseconds();
743 0 : int64_t diff_ms = now_ms - capture_time_ms;
744 0 : packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
745 0 : diff_ms);
746 0 : packet_to_send->SetExtension<AbsoluteSendTime>(now_ms);
747 :
748 0 : PacketOptions options;
749 0 : if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id)) {
750 0 : AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
751 0 : probe_cluster_id);
752 : }
753 :
754 0 : if (!is_retransmit && !send_over_rtx) {
755 0 : UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
756 0 : UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
757 0 : packet->Ssrc());
758 : }
759 :
760 0 : if (!SendPacketToNetwork(*packet_to_send, options))
761 0 : return false;
762 :
763 : {
764 0 : rtc::CritScope lock(&send_critsect_);
765 0 : media_has_been_sent_ = true;
766 : }
767 0 : UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit);
768 0 : return true;
769 : }
770 :
771 0 : void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet,
772 : bool is_rtx,
773 : bool is_retransmit) {
774 0 : int64_t now_ms = clock_->TimeInMilliseconds();
775 :
776 0 : rtc::CritScope lock(&statistics_crit_);
777 0 : StreamDataCounters* counters = is_rtx ? &rtx_rtp_stats_ : &rtp_stats_;
778 :
779 0 : total_bitrate_sent_.Update(packet.size(), now_ms);
780 :
781 0 : if (counters->first_packet_time_ms == -1)
782 0 : counters->first_packet_time_ms = now_ms;
783 :
784 0 : if (IsFecPacket(packet))
785 0 : CountPacket(&counters->fec, packet);
786 :
787 0 : if (is_retransmit) {
788 0 : CountPacket(&counters->retransmitted, packet);
789 0 : nack_bitrate_sent_.Update(packet.size(), now_ms);
790 : }
791 0 : CountPacket(&counters->transmitted, packet);
792 :
793 0 : if (rtp_stats_callback_)
794 0 : rtp_stats_callback_->DataCountersUpdated(*counters, packet.Ssrc());
795 0 : }
796 :
797 0 : bool RTPSender::IsFecPacket(const RtpPacketToSend& packet) const {
798 0 : if (!video_)
799 0 : return false;
800 :
801 : // FlexFEC.
802 0 : if (packet.Ssrc() == FlexfecSsrc())
803 0 : return true;
804 :
805 : // RED+ULPFEC.
806 : int pt_red;
807 : int pt_fec;
808 0 : video_->GetUlpfecConfig(&pt_red, &pt_fec);
809 0 : return static_cast<int>(packet.PayloadType()) == pt_red &&
810 0 : static_cast<int>(packet.payload()[0]) == pt_fec;
811 : }
812 :
813 0 : size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) {
814 0 : if (audio_configured_ || bytes == 0)
815 0 : return 0;
816 0 : size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id);
817 0 : if (bytes_sent < bytes)
818 0 : bytes_sent += SendPadData(bytes - bytes_sent, probe_cluster_id);
819 0 : return bytes_sent;
820 : }
821 :
822 0 : bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
823 : StorageType storage,
824 : RtpPacketSender::Priority priority) {
825 0 : RTC_DCHECK(packet);
826 0 : int64_t now_ms = clock_->TimeInMilliseconds();
827 :
828 : // |capture_time_ms| <= 0 is considered invalid.
829 : // TODO(holmer): This should be changed all over Video Engine so that negative
830 : // time is consider invalid, while 0 is considered a valid time.
831 0 : if (packet->capture_time_ms() > 0) {
832 0 : packet->SetExtension<TransmissionOffset>(
833 0 : kTimestampTicksPerMs * (now_ms - packet->capture_time_ms()));
834 : }
835 0 : packet->SetExtension<AbsoluteSendTime>(now_ms);
836 :
837 0 : if (video_) {
838 : BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoTotBitrate_kbps", now_ms,
839 : ActualSendBitrateKbit(), packet->Ssrc());
840 : BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoFecBitrate_kbps", now_ms,
841 : FecOverheadRate() / 1000, packet->Ssrc());
842 : BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoNackBitrate_kbps", now_ms,
843 : NackOverheadRate() / 1000, packet->Ssrc());
844 : } else {
845 : BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioTotBitrate_kbps", now_ms,
846 : ActualSendBitrateKbit(), packet->Ssrc());
847 : BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioNackBitrate_kbps", now_ms,
848 : NackOverheadRate() / 1000, packet->Ssrc());
849 : }
850 :
851 0 : uint32_t ssrc = packet->Ssrc();
852 0 : rtc::Optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
853 0 : if (paced_sender_) {
854 0 : uint16_t seq_no = packet->SequenceNumber();
855 : // Correct offset between implementations of millisecond time stamps in
856 : // TickTime and Clock.
857 0 : int64_t corrected_time_ms = packet->capture_time_ms() + clock_delta_ms_;
858 0 : size_t payload_length = packet->payload_size();
859 0 : if (ssrc == flexfec_ssrc) {
860 : // Store FlexFEC packets in the history here, so they can be found
861 : // when the pacer calls TimeToSendPacket.
862 0 : flexfec_packet_history_.PutRtpPacket(std::move(packet), storage, false);
863 : } else {
864 0 : packet_history_.PutRtpPacket(std::move(packet), storage, false);
865 : }
866 :
867 0 : paced_sender_->InsertPacket(priority, ssrc, seq_no, corrected_time_ms,
868 0 : payload_length, false);
869 0 : if (last_capture_time_ms_sent_ == 0 ||
870 0 : corrected_time_ms > last_capture_time_ms_sent_) {
871 0 : last_capture_time_ms_sent_ = corrected_time_ms;
872 0 : TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
873 : "PacedSend", corrected_time_ms,
874 : "capture_time_ms", corrected_time_ms);
875 : }
876 0 : return true;
877 : }
878 :
879 0 : PacketOptions options;
880 0 : if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id)) {
881 0 : AddPacketToTransportFeedback(options.packet_id, *packet.get(),
882 0 : PacketInfo::kNotAProbe);
883 : }
884 :
885 0 : UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
886 0 : UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
887 0 : packet->Ssrc());
888 :
889 0 : bool sent = SendPacketToNetwork(*packet, options);
890 :
891 0 : if (sent) {
892 : {
893 0 : rtc::CritScope lock(&send_critsect_);
894 0 : media_has_been_sent_ = true;
895 : }
896 0 : UpdateRtpStats(*packet, false, false);
897 : }
898 :
899 : // To support retransmissions, we store the media packet as sent in the
900 : // packet history (even if send failed).
901 0 : if (storage == kAllowRetransmission) {
902 : // TODO(brandtr): Uncomment the DCHECK line below when |ssrc_| cannot
903 : // change after the first packet has been sent. For more details, see
904 : // https://bugs.chromium.org/p/webrtc/issues/detail?id=6887.
905 : // RTC_DCHECK_EQ(ssrc, SSRC());
906 0 : packet_history_.PutRtpPacket(std::move(packet), storage, true);
907 : }
908 :
909 0 : return sent;
910 : }
911 :
912 0 : void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
913 0 : if (!send_side_delay_observer_ || capture_time_ms <= 0)
914 0 : return;
915 :
916 : uint32_t ssrc;
917 0 : int avg_delay_ms = 0;
918 0 : int max_delay_ms = 0;
919 : {
920 0 : rtc::CritScope lock(&send_critsect_);
921 0 : ssrc = ssrc_;
922 : }
923 : {
924 0 : rtc::CritScope cs(&statistics_crit_);
925 : // TODO(holmer): Compute this iteratively instead.
926 0 : send_delays_[now_ms] = now_ms - capture_time_ms;
927 0 : send_delays_.erase(send_delays_.begin(),
928 0 : send_delays_.lower_bound(now_ms -
929 0 : kSendSideDelayWindowMs));
930 0 : int num_delays = 0;
931 0 : for (auto it = send_delays_.upper_bound(now_ms - kSendSideDelayWindowMs);
932 0 : it != send_delays_.end(); ++it) {
933 0 : max_delay_ms = std::max(max_delay_ms, it->second);
934 0 : avg_delay_ms += it->second;
935 0 : ++num_delays;
936 : }
937 0 : if (num_delays == 0)
938 0 : return;
939 0 : avg_delay_ms = (avg_delay_ms + num_delays / 2) / num_delays;
940 : }
941 0 : send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
942 0 : ssrc);
943 : }
944 :
945 0 : void RTPSender::UpdateOnSendPacket(int packet_id,
946 : int64_t capture_time_ms,
947 : uint32_t ssrc) {
948 0 : if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
949 0 : return;
950 :
951 0 : send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
952 : }
953 :
954 0 : void RTPSender::ProcessBitrate() {
955 0 : if (!bitrate_callback_)
956 0 : return;
957 0 : int64_t now_ms = clock_->TimeInMilliseconds();
958 : uint32_t ssrc;
959 : {
960 0 : rtc::CritScope lock(&send_critsect_);
961 0 : ssrc = ssrc_;
962 : }
963 :
964 0 : rtc::CritScope lock(&statistics_crit_);
965 0 : bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0),
966 0 : nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc);
967 : }
968 :
969 0 : size_t RTPSender::RtpHeaderLength() const {
970 0 : rtc::CritScope lock(&send_critsect_);
971 0 : size_t rtp_header_length = kRtpHeaderLength;
972 0 : rtp_header_length += sizeof(uint32_t) * csrcs_.size();
973 0 : rtp_header_length += rtp_header_extension_map_.GetTotalLengthInBytes();
974 0 : return rtp_header_length;
975 : }
976 :
977 0 : uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
978 0 : rtc::CritScope lock(&send_critsect_);
979 0 : uint16_t first_allocated_sequence_number = sequence_number_;
980 0 : sequence_number_ += packets_to_send;
981 0 : return first_allocated_sequence_number;
982 : }
983 :
984 0 : void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
985 : StreamDataCounters* rtx_stats) const {
986 0 : rtc::CritScope lock(&statistics_crit_);
987 0 : *rtp_stats = rtp_stats_;
988 0 : *rtx_stats = rtx_rtp_stats_;
989 0 : }
990 :
991 0 : std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
992 0 : rtc::CritScope lock(&send_critsect_);
993 : std::unique_ptr<RtpPacketToSend> packet(
994 0 : new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_));
995 0 : packet->SetSsrc(ssrc_);
996 0 : packet->SetCsrcs(csrcs_);
997 : // Reserve extensions, if registered, RtpSender set in SendToNetwork.
998 0 : packet->ReserveExtension<AbsoluteSendTime>();
999 0 : packet->ReserveExtension<TransmissionOffset>();
1000 0 : packet->ReserveExtension<TransportSequenceNumber>();
1001 0 : if (playout_delay_oracle_.send_playout_delay()) {
1002 0 : packet->SetExtension<PlayoutDelayLimits>(
1003 0 : playout_delay_oracle_.playout_delay());
1004 : }
1005 0 : return packet;
1006 : }
1007 :
1008 0 : bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) {
1009 0 : rtc::CritScope lock(&send_critsect_);
1010 0 : if (!sending_media_)
1011 0 : return false;
1012 0 : RTC_DCHECK_EQ(packet->Ssrc(), ssrc_);
1013 0 : packet->SetSequenceNumber(sequence_number_++);
1014 :
1015 : // Remember marker bit to determine if padding can be inserted with
1016 : // sequence number following |packet|.
1017 0 : last_packet_marker_bit_ = packet->Marker();
1018 : // Save timestamps to generate timestamp field and extensions for the padding.
1019 0 : last_rtp_timestamp_ = packet->Timestamp();
1020 0 : last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
1021 0 : capture_time_ms_ = packet->capture_time_ms();
1022 0 : return true;
1023 : }
1024 :
1025 0 : bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet,
1026 : int* packet_id) const {
1027 0 : RTC_DCHECK(packet);
1028 0 : RTC_DCHECK(packet_id);
1029 0 : rtc::CritScope lock(&send_critsect_);
1030 0 : if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId))
1031 0 : return false;
1032 :
1033 0 : if (!transport_sequence_number_allocator_)
1034 0 : return false;
1035 :
1036 0 : *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
1037 :
1038 0 : if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
1039 0 : return false;
1040 :
1041 0 : return true;
1042 : }
1043 :
1044 0 : void RTPSender::SetSendingStatus(bool enabled) {
1045 0 : if (!enabled) {
1046 0 : rtc::CritScope lock(&send_critsect_);
1047 0 : if (!ssrc_forced_) {
1048 : // Generate a new SSRC.
1049 0 : ssrc_db_->ReturnSSRC(ssrc_);
1050 0 : ssrc_ = ssrc_db_->CreateSSRC();
1051 0 : RTC_DCHECK(ssrc_ != 0);
1052 : }
1053 : // Don't initialize seq number if SSRC passed externally.
1054 0 : if (!sequence_number_forced_ && !ssrc_forced_) {
1055 : // Generate a new sequence number.
1056 0 : sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
1057 : }
1058 : }
1059 0 : }
1060 :
1061 0 : void RTPSender::SetSendingMediaStatus(bool enabled) {
1062 0 : rtc::CritScope lock(&send_critsect_);
1063 0 : sending_media_ = enabled;
1064 0 : }
1065 :
1066 0 : bool RTPSender::SendingMedia() const {
1067 0 : rtc::CritScope lock(&send_critsect_);
1068 0 : return sending_media_;
1069 : }
1070 :
1071 0 : void RTPSender::SetTimestampOffset(uint32_t timestamp) {
1072 0 : rtc::CritScope lock(&send_critsect_);
1073 0 : timestamp_offset_ = timestamp;
1074 0 : }
1075 :
1076 0 : uint32_t RTPSender::TimestampOffset() const {
1077 0 : rtc::CritScope lock(&send_critsect_);
1078 0 : return timestamp_offset_;
1079 : }
1080 :
1081 0 : uint32_t RTPSender::GenerateNewSSRC() {
1082 : // If configured via API, return 0.
1083 0 : rtc::CritScope lock(&send_critsect_);
1084 :
1085 0 : if (ssrc_forced_) {
1086 0 : return 0;
1087 : }
1088 0 : ssrc_ = ssrc_db_->CreateSSRC();
1089 0 : RTC_DCHECK(ssrc_ != 0);
1090 0 : return ssrc_;
1091 : }
1092 :
1093 0 : void RTPSender::SetSSRC(uint32_t ssrc) {
1094 : // This is configured via the API.
1095 0 : rtc::CritScope lock(&send_critsect_);
1096 :
1097 0 : if (ssrc_ == ssrc && ssrc_forced_) {
1098 0 : return; // Since it's same ssrc, don't reset anything.
1099 : }
1100 0 : ssrc_forced_ = true;
1101 0 : ssrc_db_->ReturnSSRC(ssrc_);
1102 0 : ssrc_db_->RegisterSSRC(ssrc);
1103 0 : ssrc_ = ssrc;
1104 0 : if (!sequence_number_forced_) {
1105 0 : sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
1106 : }
1107 : }
1108 :
1109 0 : uint32_t RTPSender::SSRC() const {
1110 0 : rtc::CritScope lock(&send_critsect_);
1111 0 : return ssrc_;
1112 : }
1113 :
1114 0 : rtc::Optional<uint32_t> RTPSender::FlexfecSsrc() const {
1115 0 : if (video_) {
1116 0 : return video_->FlexfecSsrc();
1117 : }
1118 0 : return rtc::Optional<uint32_t>();
1119 : }
1120 :
1121 0 : void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
1122 0 : assert(csrcs.size() <= kRtpCsrcSize);
1123 0 : rtc::CritScope lock(&send_critsect_);
1124 0 : csrcs_ = csrcs;
1125 0 : }
1126 :
1127 0 : void RTPSender::SetSequenceNumber(uint16_t seq) {
1128 0 : rtc::CritScope lock(&send_critsect_);
1129 0 : sequence_number_forced_ = true;
1130 0 : sequence_number_ = seq;
1131 0 : }
1132 :
1133 0 : uint16_t RTPSender::SequenceNumber() const {
1134 0 : rtc::CritScope lock(&send_critsect_);
1135 0 : return sequence_number_;
1136 : }
1137 :
1138 : // Audio.
1139 0 : int32_t RTPSender::SendTelephoneEvent(uint8_t key,
1140 : uint16_t time_ms,
1141 : uint8_t level) {
1142 0 : if (!audio_configured_) {
1143 0 : return -1;
1144 : }
1145 0 : return audio_->SendTelephoneEvent(key, time_ms, level);
1146 : }
1147 :
1148 0 : int32_t RTPSender::SetAudioPacketSize(uint16_t packet_size_samples) {
1149 0 : if (!audio_configured_) {
1150 0 : return -1;
1151 : }
1152 0 : return 0;
1153 : }
1154 :
1155 0 : int32_t RTPSender::SetAudioLevel(uint8_t level_d_bov) {
1156 0 : return audio_->SetAudioLevel(level_d_bov);
1157 : }
1158 :
1159 0 : RtpVideoCodecTypes RTPSender::VideoCodecType() const {
1160 0 : assert(!audio_configured_ && "Sender is an audio stream!");
1161 0 : return video_->VideoCodecType();
1162 : }
1163 :
1164 0 : void RTPSender::SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type) {
1165 0 : RTC_DCHECK(!audio_configured_);
1166 0 : video_->SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
1167 0 : }
1168 :
1169 0 : bool RTPSender::SetFecParameters(const FecProtectionParams& delta_params,
1170 : const FecProtectionParams& key_params) {
1171 0 : if (audio_configured_) {
1172 0 : return false;
1173 : }
1174 0 : video_->SetFecParameters(delta_params, key_params);
1175 0 : return true;
1176 : }
1177 :
1178 0 : std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
1179 : const RtpPacketToSend& packet) {
1180 : // TODO(danilchap): Create rtx packet with extra capacity for SRTP
1181 : // when transport interface would be updated to take buffer class.
1182 : std::unique_ptr<RtpPacketToSend> rtx_packet(new RtpPacketToSend(
1183 0 : &rtp_header_extension_map_, packet.size() + kRtxHeaderSize));
1184 : // Add original RTP header.
1185 0 : rtx_packet->CopyHeaderFrom(packet);
1186 : {
1187 0 : rtc::CritScope lock(&send_critsect_);
1188 0 : if (!sending_media_)
1189 0 : return nullptr;
1190 :
1191 : // Replace payload type.
1192 0 : auto kv = rtx_payload_type_map_.find(packet.PayloadType());
1193 0 : if (kv == rtx_payload_type_map_.end())
1194 0 : return nullptr;
1195 0 : rtx_packet->SetPayloadType(kv->second);
1196 :
1197 : // Replace sequence number.
1198 0 : rtx_packet->SetSequenceNumber(sequence_number_rtx_++);
1199 :
1200 : // Replace SSRC.
1201 0 : rtx_packet->SetSsrc(ssrc_rtx_);
1202 : }
1203 :
1204 : uint8_t* rtx_payload =
1205 0 : rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize);
1206 0 : RTC_DCHECK(rtx_payload);
1207 : // Add OSN (original sequence number).
1208 0 : ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber());
1209 :
1210 : // Add original payload data.
1211 0 : auto payload = packet.payload();
1212 0 : memcpy(rtx_payload + kRtxHeaderSize, payload.data(), payload.size());
1213 :
1214 0 : return rtx_packet;
1215 : }
1216 :
1217 0 : void RTPSender::RegisterRtpStatisticsCallback(
1218 : StreamDataCountersCallback* callback) {
1219 0 : rtc::CritScope cs(&statistics_crit_);
1220 0 : rtp_stats_callback_ = callback;
1221 0 : }
1222 :
1223 0 : StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
1224 0 : rtc::CritScope cs(&statistics_crit_);
1225 0 : return rtp_stats_callback_;
1226 : }
1227 :
1228 0 : uint32_t RTPSender::BitrateSent() const {
1229 0 : rtc::CritScope cs(&statistics_crit_);
1230 0 : return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
1231 : }
1232 :
1233 0 : void RTPSender::SetRtpState(const RtpState& rtp_state) {
1234 0 : rtc::CritScope lock(&send_critsect_);
1235 0 : sequence_number_ = rtp_state.sequence_number;
1236 0 : sequence_number_forced_ = true;
1237 0 : timestamp_offset_ = rtp_state.start_timestamp;
1238 0 : last_rtp_timestamp_ = rtp_state.timestamp;
1239 0 : capture_time_ms_ = rtp_state.capture_time_ms;
1240 0 : last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
1241 0 : media_has_been_sent_ = rtp_state.media_has_been_sent;
1242 0 : }
1243 :
1244 0 : RtpState RTPSender::GetRtpState() const {
1245 0 : rtc::CritScope lock(&send_critsect_);
1246 :
1247 0 : RtpState state;
1248 0 : state.sequence_number = sequence_number_;
1249 0 : state.start_timestamp = timestamp_offset_;
1250 0 : state.timestamp = last_rtp_timestamp_;
1251 0 : state.capture_time_ms = capture_time_ms_;
1252 0 : state.last_timestamp_time_ms = last_timestamp_time_ms_;
1253 0 : state.media_has_been_sent = media_has_been_sent_;
1254 :
1255 0 : return state;
1256 : }
1257 :
1258 0 : void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
1259 0 : rtc::CritScope lock(&send_critsect_);
1260 0 : sequence_number_rtx_ = rtp_state.sequence_number;
1261 0 : }
1262 :
1263 0 : RtpState RTPSender::GetRtxRtpState() const {
1264 0 : rtc::CritScope lock(&send_critsect_);
1265 :
1266 0 : RtpState state;
1267 0 : state.sequence_number = sequence_number_rtx_;
1268 0 : state.start_timestamp = timestamp_offset_;
1269 :
1270 0 : return state;
1271 : }
1272 :
1273 0 : void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id,
1274 : const RtpPacketToSend& packet,
1275 : int probe_cluster_id) {
1276 0 : size_t packet_size = packet.payload_size() + packet.padding_size();
1277 0 : if (webrtc::field_trial::FindFullName("WebRTC-SendSideBwe-WithOverhead") ==
1278 : "Enabled") {
1279 0 : packet_size = packet.size();
1280 : }
1281 :
1282 0 : if (transport_feedback_observer_) {
1283 0 : transport_feedback_observer_->AddPacket(packet_id, packet_size,
1284 0 : probe_cluster_id);
1285 : }
1286 0 : }
1287 :
1288 0 : void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
1289 0 : if (!overhead_observer_)
1290 0 : return;
1291 : size_t overhead_bytes_per_packet;
1292 : {
1293 0 : rtc::CritScope lock(&send_critsect_);
1294 0 : if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
1295 0 : return;
1296 : }
1297 0 : rtp_overhead_bytes_per_packet_ = packet.headers_size();
1298 0 : overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
1299 : }
1300 0 : overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
1301 : }
1302 :
1303 : } // namespace webrtc
|
