blob: 66d6b71984f74c25e1bd5cd3c0507ea8235b16b1 [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:25 +00001/*
pwestin@webrtc.orgf6bb77a2012-01-24 17:16:59 +00002 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
niklase@google.com470e71d2011-07-07 08:21:25 +00003 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/rtp_rtcp/source/rtp_sender.h"
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +000012
danilchapb8b6fbb2015-12-10 05:05:27 -080013#include <algorithm>
Johannes Kron965e7942018-09-13 15:36:20 +020014#include <limits>
Steve Anton296a0ce2018-03-22 15:17:27 -070015#include <string>
Shao Changbine62202f2015-04-21 20:24:50 +080016#include <utility>
niklase@google.com470e71d2011-07-07 08:21:25 +000017
Karl Wiberg918f50c2018-07-05 11:40:33 +020018#include "absl/memory/memory.h"
Niels Mölleraa3c1cc2018-11-02 10:54:56 +010019#include "absl/strings/match.h"
Amit Hilbuch77938e62018-12-21 09:23:38 -080020#include "api/array_view.h"
Erik Språng4580ca22019-07-04 10:38:43 +020021#include "api/transport/field_trial_based_config.h"
Elad Alon4a87e1c2017-10-03 16:11:34 +020022#include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020023#include "logging/rtc_event_log/rtc_event_log.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020024#include "modules/rtp_rtcp/include/rtp_cvo.h"
25#include "modules/rtp_rtcp/source/byte_io.h"
philipel569397f2018-09-26 12:25:31 +020026#include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020027#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
28#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020029#include "modules/rtp_rtcp/source/time_util.h"
30#include "rtc_base/arraysize.h"
31#include "rtc_base/checks.h"
32#include "rtc_base/logging.h"
Karl Wiberge40468b2017-11-22 10:42:26 +010033#include "rtc_base/numerics/safe_minmax.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020034#include "rtc_base/rate_limiter.h"
Steve Anton10542f22019-01-11 09:11:00 -080035#include "rtc_base/time_utils.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000036
37namespace webrtc {
niklase@google.com470e71d2011-07-07 08:21:25 +000038
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000039namespace {
Danil Chapovalov31e4e802016-08-03 18:27:40 +020040// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
41constexpr size_t kMaxPaddingLength = 224;
stefan53b6cc32017-02-03 08:13:57 -080042constexpr size_t kMinAudioPaddingLength = 50;
Danil Chapovalov31e4e802016-08-03 18:27:40 +020043constexpr int kSendSideDelayWindowMs = 1000;
44constexpr size_t kRtpHeaderLength = 12;
45constexpr uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1.
46constexpr uint32_t kTimestampTicksPerMs = 90;
47constexpr int kBitrateStatisticsWindowMs = 1000;
guoweis@webrtc.org45362892015-03-04 22:55:15 +000048
brandtr9dfff292016-11-14 05:14:50 -080049constexpr size_t kMinFlexfecPacketsToStoreForPacing = 50;
50
Erik Språng214f5432019-06-20 15:09:58 +020051// Min size needed to get payload padding from packet history.
52constexpr int kMinPayloadPaddingBytes = 50;
53
erikvarga27883732017-05-17 05:08:38 -070054template <typename Extension>
55constexpr RtpExtensionSize CreateExtensionSize() {
56 return {Extension::kId, Extension::kValueSizeBytes};
57}
58
Amit Hilbuch77938e62018-12-21 09:23:38 -080059template <typename Extension>
60constexpr RtpExtensionSize CreateMaxExtensionSize() {
61 return {Extension::kId, Extension::kMaxValueSizeBytes};
62}
63
erikvarga27883732017-05-17 05:08:38 -070064// Size info for header extensions that might be used in padding or FEC packets.
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010065constexpr RtpExtensionSize kFecOrPaddingExtensionSizes[] = {
erikvarga27883732017-05-17 05:08:38 -070066 CreateExtensionSize<AbsoluteSendTime>(),
67 CreateExtensionSize<TransmissionOffset>(),
68 CreateExtensionSize<TransportSequenceNumber>(),
69 CreateExtensionSize<PlayoutDelayLimits>(),
Amit Hilbuch77938e62018-12-21 09:23:38 -080070 CreateMaxExtensionSize<RtpMid>(),
erikvarga27883732017-05-17 05:08:38 -070071};
72
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010073// Size info for header extensions that might be used in video packets.
74constexpr RtpExtensionSize kVideoExtensionSizes[] = {
75 CreateExtensionSize<AbsoluteSendTime>(),
Chen Xingcd8a6e22019-07-01 10:56:51 +020076 CreateExtensionSize<AbsoluteCaptureTimeExtension>(),
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010077 CreateExtensionSize<TransmissionOffset>(),
78 CreateExtensionSize<TransportSequenceNumber>(),
79 CreateExtensionSize<PlayoutDelayLimits>(),
80 CreateExtensionSize<VideoOrientation>(),
81 CreateExtensionSize<VideoContentTypeExtension>(),
82 CreateExtensionSize<VideoTimingExtension>(),
Amit Hilbuch77938e62018-12-21 09:23:38 -080083 CreateMaxExtensionSize<RtpStreamId>(),
84 CreateMaxExtensionSize<RepairedRtpStreamId>(),
85 CreateMaxExtensionSize<RtpMid>(),
Elad Alonccb9b752019-02-19 13:01:31 +010086 {RtpGenericFrameDescriptorExtension00::kId,
87 RtpGenericFrameDescriptorExtension00::kMaxSizeBytes},
88 {RtpGenericFrameDescriptorExtension01::kId,
89 RtpGenericFrameDescriptorExtension01::kMaxSizeBytes},
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010090};
91
Erik Språng13eb7642019-06-24 10:58:48 +020092// TODO(bugs.webrtc.org/10633): Remove when downstream code stops using
93// priority. At the time of writing, the priority can be directly mapped to a
94// packet type. This is only for a transition period.
95RtpPacketToSend::Type PacketPriorityToType(RtpPacketSender::Priority priority) {
96 switch (priority) {
97 case RtpPacketSender::Priority::kLowPriority:
98 return RtpPacketToSend::Type::kVideo;
99 case RtpPacketSender::Priority::kNormalPriority:
100 return RtpPacketToSend::Type::kRetransmission;
101 case RtpPacketSender::Priority::kHighPriority:
102 return RtpPacketToSend::Type::kAudio;
103 default:
104 RTC_NOTREACHED() << "Unexpected priority: " << priority;
105 return RtpPacketToSend::Type::kVideo;
106 }
107}
108
109// TODO(bugs.webrtc.org/10633): Remove when packets are always owned by pacer.
110RtpPacketSender::Priority PacketTypeToPriority(RtpPacketToSend::Type type) {
111 switch (type) {
112 case RtpPacketToSend::Type::kAudio:
113 return RtpPacketSender::Priority::kHighPriority;
114 case RtpPacketToSend::Type::kVideo:
115 return RtpPacketSender::Priority::kLowPriority;
116 case RtpPacketToSend::Type::kRetransmission:
117 return RtpPacketSender::Priority::kNormalPriority;
118 case RtpPacketToSend::Type::kForwardErrorCorrection:
119 return RtpPacketSender::Priority::kLowPriority;
120 break;
121 case RtpPacketToSend::Type::kPadding:
122 RTC_NOTREACHED() << "Unexpected type for legacy path: kPadding";
123 break;
124 }
125 return RtpPacketSender::Priority::kLowPriority;
126}
127
Erik Språng4580ca22019-07-04 10:38:43 +0200128bool IsEnabled(absl::string_view name,
129 const WebRtcKeyValueConfig* field_trials) {
130 FieldTrialBasedConfig default_trials;
131 auto& trials = field_trials ? *field_trials : default_trials;
132 return trials.Lookup(name).find("Enabled") == 0;
133}
134
135bool IsDisabled(absl::string_view name,
136 const WebRtcKeyValueConfig* field_trials) {
137 FieldTrialBasedConfig default_trials;
138 auto& trials = field_trials ? *field_trials : default_trials;
139 return trials.Lookup(name).find("Disabled") == 0;
140}
141
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000142bool HasBweExtension(const RtpHeaderExtensionMap& extensions_map) {
143 return extensions_map.IsRegistered(kRtpExtensionTransportSequenceNumber) ||
144 extensions_map.IsRegistered(kRtpExtensionTransportSequenceNumber02) ||
145 extensions_map.IsRegistered(kRtpExtensionAbsoluteSendTime) ||
146 extensions_map.IsRegistered(kRtpExtensionTransmissionTimeOffset);
147}
148
hclam@chromium.org806dc3b2013-04-09 19:54:10 +0000149} // namespace
150
Erik Språng4580ca22019-07-04 10:38:43 +0200151RTPSender::RTPSender(const RtpRtcp::Configuration& config)
152 : clock_(config.clock),
153 random_(clock_->TimeInMicroseconds()),
154 audio_configured_(config.audio),
155 flexfec_ssrc_(config.flexfec_sender
156 ? absl::make_optional(config.flexfec_sender->ssrc())
157 : absl::nullopt),
158 paced_sender_(config.paced_sender),
159 transport_sequence_number_allocator_(
160 config.transport_sequence_number_allocator),
161 transport_feedback_observer_(config.transport_feedback_callback),
162 transport_(config.outgoing_transport),
163 sending_media_(true), // Default to sending media.
164 force_part_of_allocation_(false),
165 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
166 last_payload_type_(-1),
167 rtp_header_extension_map_(config.extmap_allow_mixed),
168 packet_history_(clock_),
169 flexfec_packet_history_(clock_),
170 // Statistics
171 send_delays_(),
172 max_delay_it_(send_delays_.end()),
173 sum_delays_ms_(0),
174 total_packet_send_delay_ms_(0),
175 rtp_stats_callback_(nullptr),
176 total_bitrate_sent_(kBitrateStatisticsWindowMs,
177 RateStatistics::kBpsScale),
178 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
179 send_side_delay_observer_(config.send_side_delay_observer),
180 event_log_(config.event_log),
181 send_packet_observer_(config.send_packet_observer),
182 bitrate_callback_(config.send_bitrate_observer),
183 // RTP variables
184 sequence_number_forced_(false),
185 ssrc_(config.media_send_ssrc),
186 last_rtp_timestamp_(0),
187 capture_time_ms_(0),
188 last_timestamp_time_ms_(0),
189 media_has_been_sent_(false),
190 last_packet_marker_bit_(false),
191 csrcs_(),
192 rtx_(kRtxOff),
193 ssrc_rtx_(config.rtx_send_ssrc),
194 rtp_overhead_bytes_per_packet_(0),
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000195 supports_bwe_extension_(false),
Erik Språng4580ca22019-07-04 10:38:43 +0200196 retransmission_rate_limiter_(config.retransmission_rate_limiter),
197 overhead_observer_(config.overhead_observer),
198 populate_network2_timestamp_(config.populate_network2_timestamp),
199 send_side_bwe_with_overhead_(
200 IsEnabled("WebRTC-SendSideBwe-WithOverhead", config.field_trials)),
Erik Språngf6468d22019-07-05 16:53:43 +0200201 pacer_legacy_packet_referencing_(
202 !IsDisabled("WebRTC-Pacer-LegacyPacketReferencing",
Erik Språng4580ca22019-07-04 10:38:43 +0200203 config.field_trials)) {
204 // This random initialization is not intended to be cryptographic strong.
205 timestamp_offset_ = random_.Rand<uint32_t>();
206 // Random start, 16 bits. Can't be 0.
207 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
208 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
209
210 // Store FlexFEC packets in the packet history data structure, so they can
211 // be found when paced.
212 if (flexfec_ssrc_) {
Erik Språng4580ca22019-07-04 10:38:43 +0200213 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språngb9f59892019-07-19 13:52:13 +0200214 RtpPacketHistory::StorageMode::kStoreAndCull,
215 kMinFlexfecPacketsToStoreForPacing);
Erik Språng4580ca22019-07-04 10:38:43 +0200216 }
217}
218
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000219RTPSender::RTPSender(
220 bool audio,
221 Clock* clock,
222 Transport* transport,
223 RtpPacketPacer* paced_sender,
224 absl::optional<uint32_t> flexfec_ssrc,
225 TransportSequenceNumberAllocator* sequence_number_allocator,
226 TransportFeedbackObserver* transport_feedback_observer,
227 BitrateStatisticsObserver* bitrate_callback,
228 SendSideDelayObserver* send_side_delay_observer,
229 RtcEventLog* event_log,
230 SendPacketObserver* send_packet_observer,
231 RateLimiter* retransmission_rate_limiter,
232 OverheadObserver* overhead_observer,
233 bool populate_network2_timestamp,
234 FrameEncryptorInterface* frame_encryptor,
235 bool require_frame_encryption,
236 bool extmap_allow_mixed,
237 const WebRtcKeyValueConfig& field_trials)
238 : clock_(clock),
danilchap47a740b2015-12-15 00:30:07 -0800239 random_(clock_->TimeInMicroseconds()),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000240 audio_configured_(audio),
241 flexfec_ssrc_(flexfec_ssrc),
242 paced_sender_(paced_sender),
243 transport_sequence_number_allocator_(sequence_number_allocator),
244 transport_feedback_observer_(transport_feedback_observer),
245 transport_(transport),
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200246 sending_media_(true), // Default to sending media.
247 force_part_of_allocation_(false),
nisse284542b2017-01-10 08:58:32 -0800248 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100249 last_payload_type_(-1),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000250 rtp_header_extension_map_(extmap_allow_mixed),
251 packet_history_(clock),
252 flexfec_packet_history_(clock),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000253 // Statistics
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200254 send_delays_(),
255 max_delay_it_(send_delays_.end()),
256 sum_delays_ms_(0),
Henrik Boström9fe18342019-05-16 18:38:20 +0200257 total_packet_send_delay_ms_(0),
sprangcd349d92016-07-13 09:11:28 -0700258 rtp_stats_callback_(nullptr),
259 total_bitrate_sent_(kBitrateStatisticsWindowMs,
260 RateStatistics::kBpsScale),
261 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000262 send_side_delay_observer_(send_side_delay_observer),
263 event_log_(event_log),
264 send_packet_observer_(send_packet_observer),
265 bitrate_callback_(bitrate_callback),
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000266 // RTP variables
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000267 sequence_number_forced_(false),
danilchape5b41412016-08-22 03:39:23 -0700268 last_rtp_timestamp_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000269 capture_time_ms_(0),
270 last_timestamp_time_ms_(0),
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000271 media_has_been_sent_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000272 last_packet_marker_bit_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000273 csrcs_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000274 rtx_(kRtxOff),
michaelt4da30442016-11-17 01:38:43 -0800275 rtp_overhead_bytes_per_packet_(0),
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000276 supports_bwe_extension_(false),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000277 retransmission_rate_limiter_(retransmission_rate_limiter),
278 overhead_observer_(overhead_observer),
279 populate_network2_timestamp_(populate_network2_timestamp),
elad.alonc3dfff32017-01-26 02:46:55 -0800280 send_side_bwe_with_overhead_(
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000281 field_trials.Lookup("WebRTC-SendSideBwe-WithOverhead")
282 .find("Enabled") == 0),
Erik Språngf6468d22019-07-05 16:53:43 +0200283 pacer_legacy_packet_referencing_(
284 field_trials.Lookup("WebRTC-Pacer-LegacyPacketReferencing")
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000285 .find("Disabled") != 0) {
danilchap71fead22016-08-18 02:01:49 -0700286 // This random initialization is not intended to be cryptographic strong.
287 timestamp_offset_ = random_.Rand<uint32_t>();
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000288 // Random start, 16 bits. Can't be 0.
danilchap47a740b2015-12-15 00:30:07 -0800289 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
290 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
brandtr9dfff292016-11-14 05:14:50 -0800291
292 // Store FlexFEC packets in the packet history data structure, so they can
293 // be found when paced.
Niels Möller59ab1cf2019-02-06 22:48:11 +0100294 if (flexfec_ssrc_) {
brandtr9dfff292016-11-14 05:14:50 -0800295 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språngb9f59892019-07-19 13:52:13 +0200296 RtpPacketHistory::StorageMode::kStoreAndCull,
297 kMinFlexfecPacketsToStoreForPacing);
brandtr9dfff292016-11-14 05:14:50 -0800298 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000299}
300
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000301RTPSender::~RTPSender() {
tommiae695e92016-02-02 08:31:45 -0800302 // TODO(tommi): Use a thread checker to ensure the object is created and
303 // deleted on the same thread. At the moment this isn't possible due to
304 // voe::ChannelOwner in voice engine. To reproduce, run:
305 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
306
307 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
308 // variables but we grab them in all other methods. (what's the design?)
309 // Start documenting what thread we're on in what method so that it's easier
310 // to understand performance attributes and possibly remove locks.
niklase@google.com470e71d2011-07-07 08:21:25 +0000311}
niklase@google.com470e71d2011-07-07 08:21:25 +0000312
erikvarga27883732017-05-17 05:08:38 -0700313rtc::ArrayView<const RtpExtensionSize> RTPSender::FecExtensionSizes() {
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +0100314 return rtc::MakeArrayView(kFecOrPaddingExtensionSizes,
315 arraysize(kFecOrPaddingExtensionSizes));
316}
317
318rtc::ArrayView<const RtpExtensionSize> RTPSender::VideoExtensionSizes() {
319 return rtc::MakeArrayView(kVideoExtensionSizes,
320 arraysize(kVideoExtensionSizes));
erikvarga27883732017-05-17 05:08:38 -0700321}
322
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000323uint16_t RTPSender::ActualSendBitrateKbit() const {
sprangcd349d92016-07-13 09:11:28 -0700324 rtc::CritScope cs(&statistics_crit_);
325 return static_cast<uint16_t>(
326 total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0) /
327 1000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000328}
329
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000330uint32_t RTPSender::NackOverheadRate() const {
sprangcd349d92016-07-13 09:11:28 -0700331 rtc::CritScope cs(&statistics_crit_);
332 return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000333}
334
Johannes Kron9190b822018-10-29 11:22:05 +0100335void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) {
336 rtc::CritScope lock(&send_critsect_);
337 rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed);
338}
339
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000340int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
341 uint8_t id) {
tommiae695e92016-02-02 08:31:45 -0800342 rtc::CritScope lock(&send_critsect_);
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000343 bool registered = rtp_header_extension_map_.RegisterByType(id, type);
344 supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
345 return registered ? 0 : -1;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000346}
347
Danil Chapovalov585d1aa2018-09-14 18:29:32 +0200348bool RTPSender::RegisterRtpHeaderExtension(const std::string& uri, int id) {
349 rtc::CritScope lock(&send_critsect_);
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000350 bool registered = rtp_header_extension_map_.RegisterByUri(id, uri);
351 supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
352 return registered;
Danil Chapovalov585d1aa2018-09-14 18:29:32 +0200353}
354
stefan53b6cc32017-02-03 08:13:57 -0800355bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) const {
tommiae695e92016-02-02 08:31:45 -0800356 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000357 return rtp_header_extension_map_.IsRegistered(type);
358}
359
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000360int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800361 rtc::CritScope lock(&send_critsect_);
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000362 int32_t deregistered = rtp_header_extension_map_.Deregister(type);
363 supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
364 return deregistered;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000365}
366
nisse284542b2017-01-10 08:58:32 -0800367void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
kwibergee89e782017-08-09 17:22:01 -0700368 RTC_DCHECK_GE(max_packet_size, 100);
369 RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
tommiae695e92016-02-02 08:31:45 -0800370 rtc::CritScope lock(&send_critsect_);
nisse284542b2017-01-10 08:58:32 -0800371 max_packet_size_ = max_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25 +0000372}
373
nisse284542b2017-01-10 08:58:32 -0800374size_t RTPSender::MaxRtpPacketSize() const {
375 return max_packet_size_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000376}
377
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000378void RTPSender::SetRtxStatus(int mode) {
tommiae695e92016-02-02 08:31:45 -0800379 rtc::CritScope lock(&send_critsect_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000380 rtx_ = mode;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000381}
382
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000383int RTPSender::RtxStatus() const {
tommiae695e92016-02-02 08:31:45 -0800384 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000385 return rtx_;
386}
387
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000388void RTPSender::SetRtxSsrc(uint32_t ssrc) {
tommiae695e92016-02-02 08:31:45 -0800389 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800390 ssrc_rtx_.emplace(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000391}
392
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000393uint32_t RTPSender::RtxSsrc() const {
tommiae695e92016-02-02 08:31:45 -0800394 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800395 RTC_DCHECK(ssrc_rtx_);
396 return *ssrc_rtx_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000397}
398
Shao Changbine62202f2015-04-21 20:24:50 +0800399void RTPSender::SetRtxPayloadType(int payload_type,
400 int associated_payload_type) {
tommiae695e92016-02-02 08:31:45 -0800401 rtc::CritScope lock(&send_critsect_);
henrikg91d6ede2015-09-17 00:24:34 -0700402 RTC_DCHECK_LE(payload_type, 127);
403 RTC_DCHECK_LE(associated_payload_type, 127);
Shao Changbine62202f2015-04-21 20:24:50 +0800404 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100405 RTC_LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type << ".";
Shao Changbine62202f2015-04-21 20:24:50 +0800406 return;
407 }
408
409 rtx_payload_type_map_[associated_payload_type] = payload_type;
Åsa Persson6ae25722015-04-13 17:48:08 +0200410}
411
philipela1ed0b32016-06-01 06:31:17 -0700412size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
philipel8aadd502017-02-23 02:56:13 -0800413 const PacedPacketInfo& pacing_info) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000414 {
tommiae695e92016-02-02 08:31:45 -0800415 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100416 if (!sending_media_)
417 return 0;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000418 if ((rtx_ & kRtxRedundantPayloads) == 0)
419 return 0;
420 }
421
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000422 int bytes_left = static_cast<int>(bytes_to_send);
Erik Språng214f5432019-06-20 15:09:58 +0200423 while (bytes_left >= kMinPayloadPaddingBytes) {
Erik Språng21f2fc92019-07-16 21:09:14 +0200424 std::unique_ptr<RtpPacketToSend> packet =
425 packet_history_.GetPayloadPaddingPacket();
Erik Språng4ffed7c2019-05-28 11:18:04 +0200426
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200427 if (!packet)
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000428 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200429 size_t payload_size = packet->payload_size();
philipel8aadd502017-02-23 02:56:13 -0800430 if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000431 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200432 bytes_left -= payload_size;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000433 }
434 return bytes_to_send - bytes_left;
435}
436
philipel8aadd502017-02-23 02:56:13 -0800437size_t RTPSender::SendPadData(size_t bytes,
438 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800439 size_t padding_bytes_in_packet;
erikvarga76a55932017-05-17 07:50:17 -0700440 size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
erikvarga27883732017-05-17 05:08:38 -0700441
stefan53b6cc32017-02-03 08:13:57 -0800442 if (audio_configured_) {
443 // Allow smaller padding packets for audio.
Erik Språng478cb462019-06-26 15:49:27 +0200444 padding_bytes_in_packet =
445 rtc::SafeClamp(bytes, kMinAudioPaddingLength,
446 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
stefan53b6cc32017-02-03 08:13:57 -0800447 } else {
448 // Always send full padding packets. This is accounted for by the
449 // RtpPacketSender, which will make sure we don't send too much padding even
450 // if a single packet is larger than requested.
451 // We do this to avoid frequently sending small packets on higher bitrates.
Erik Språng478cb462019-06-26 15:49:27 +0200452 padding_bytes_in_packet = rtc::SafeMin(max_payload_size, kMaxPaddingLength);
stefan53b6cc32017-02-03 08:13:57 -0800453 }
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000454 size_t bytes_sent = 0;
danilchap90069872016-12-14 06:16:33 -0800455 while (bytes_sent < bytes) {
456 int64_t now_ms = clock_->TimeInMilliseconds();
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000457 uint32_t ssrc;
danilchap90069872016-12-14 06:16:33 -0800458 uint32_t timestamp;
459 int64_t capture_time_ms;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000460 uint16_t sequence_number;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000461 int payload_type;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000462 bool over_rtx;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000463 {
tommiae695e92016-02-02 08:31:45 -0800464 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100465 if (!sending_media_)
danilchap90069872016-12-14 06:16:33 -0800466 break;
467 timestamp = last_rtp_timestamp_;
468 capture_time_ms = capture_time_ms_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000469 if (rtx_ == kRtxOff) {
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100470 if (last_payload_type_ == -1)
stefane35f89a2017-02-01 09:06:25 -0800471 break;
stefan53b6cc32017-02-03 08:13:57 -0800472 // Without RTX we can't send padding in the middle of frames.
473 // For audio marker bits doesn't mark the end of a frame and frames
474 // are usually a single packet, so for now we don't apply this rule
475 // for audio.
476 if (!audio_configured_ && !last_packet_marker_bit_) {
477 break;
478 }
nisse7d59f6b2017-02-21 03:40:24 -0800479 if (!ssrc_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100480 RTC_LOG(LS_ERROR) << "SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800481 return 0;
482 }
483
484 RTC_DCHECK(ssrc_);
485 ssrc = *ssrc_;
486
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000487 sequence_number = sequence_number_;
488 ++sequence_number_;
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100489 payload_type = last_payload_type_;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000490 over_rtx = false;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000491 } else {
Stefan Holmerf5dca482016-01-27 12:58:51 +0100492 // Without abs-send-time or transport sequence number a media packet
493 // must be sent before padding so that the timestamps used for
494 // estimation are correct.
495 if (!media_has_been_sent_ &&
danilchap90069872016-12-14 06:16:33 -0800496 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
497 (rtp_header_extension_map_.IsRegistered(
498 TransportSequenceNumber::kId) &&
499 transport_sequence_number_allocator_))) {
500 break;
Stefan Holmerf5dca482016-01-27 12:58:51 +0100501 }
Stefan Holmer586b19b2015-09-18 11:14:31 +0200502 // Only change change the timestamp of padding packets sent over RTX.
503 // Padding only packets over RTP has to be sent as part of a media
504 // frame (and therefore the same timestamp).
505 if (last_timestamp_time_ms_ > 0) {
506 timestamp +=
danilchap90069872016-12-14 06:16:33 -0800507 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
508 capture_time_ms += (now_ms - last_timestamp_time_ms_);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200509 }
nisse7d59f6b2017-02-21 03:40:24 -0800510 if (!ssrc_rtx_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100511 RTC_LOG(LS_ERROR) << "RTX SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800512 return 0;
513 }
514 RTC_DCHECK(ssrc_rtx_);
515 ssrc = *ssrc_rtx_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000516 sequence_number = sequence_number_rtx_;
517 ++sequence_number_rtx_;
Stefan Holmer10880012016-02-03 13:29:59 +0100518 payload_type = rtx_payload_type_map_.begin()->second;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000519 over_rtx = true;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000520 }
521 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000522
danilchap90069872016-12-14 06:16:33 -0800523 RtpPacketToSend padding_packet(&rtp_header_extension_map_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200524 padding_packet.SetPayloadType(payload_type);
525 padding_packet.SetMarker(false);
526 padding_packet.SetSequenceNumber(sequence_number);
527 padding_packet.SetTimestamp(timestamp);
528 padding_packet.SetSsrc(ssrc);
529
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000530 if (capture_time_ms > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200531 padding_packet.SetExtension<TransmissionOffset>(
danilchap90069872016-12-14 06:16:33 -0800532 (now_ms - capture_time_ms) * kTimestampTicksPerMs);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000533 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200534 padding_packet.SetExtension<AbsoluteSendTime>(
535 AbsoluteSendTime::MsTo24Bits(now_ms));
stefan1d8a5062015-10-02 03:39:33 -0700536 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200537 // Padding packets are never retransmissions.
538 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200539 bool has_transport_seq_num;
540 {
541 rtc::CritScope lock(&send_critsect_);
542 has_transport_seq_num =
543 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200544 options.included_in_allocation =
545 has_transport_seq_num || force_part_of_allocation_;
546 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200547 }
Danil Chapovalovf7fcaf02018-10-10 14:56:01 +0200548 padding_packet.SetPadding(padding_bytes_in_packet);
michaelt4da30442016-11-17 01:38:43 -0800549 if (has_transport_seq_num) {
550 AddPacketToTransportFeedback(options.packet_id, padding_packet,
philipel8aadd502017-02-23 02:56:13 -0800551 pacing_info);
michaelt4da30442016-11-17 01:38:43 -0800552 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200553
philipel32d00102017-02-27 02:18:46 -0800554 if (!SendPacketToNetwork(padding_packet, options, pacing_info))
stefanf116bd02015-10-27 08:29:42 -0700555 break;
556
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000557 bytes_sent += padding_bytes_in_packet;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200558 UpdateRtpStats(padding_packet, over_rtx, false);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000559 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000560
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000561 return bytes_sent;
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000562}
563
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000564void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
Erik Språngb9f59892019-07-19 13:52:13 +0200565 packet_history_.SetStorePacketsStatus(
566 enable ? RtpPacketHistory::StorageMode::kStoreAndCull
567 : RtpPacketHistory::StorageMode::kDisabled,
568 number_to_store);
niklase@google.com470e71d2011-07-07 08:21:25 +0000569}
570
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000571bool RTPSender::StorePackets() const {
Erik Språnga12b1d62018-03-14 12:39:24 +0100572 return packet_history_.GetStorageMode() !=
573 RtpPacketHistory::StorageMode::kDisabled;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000574}
niklase@google.com470e71d2011-07-07 08:21:25 +0000575
Erik Språnga12b1d62018-03-14 12:39:24 +0100576int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
577 // Try to find packet in RTP packet history. Also verify RTT here, so that we
578 // don't retransmit too often.
Danil Chapovalovd264df52018-06-14 12:59:38 +0200579 absl::optional<RtpPacketHistory::PacketState> stored_packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200580 packet_history_.GetPacketState(packet_id);
Erik Språng0f4f0552019-05-08 10:15:05 -0700581 if (!stored_packet || stored_packet->pending_transmission) {
582 // Packet not found or already queued for retransmission, ignore.
asapersson@webrtc.org83ed0a42012-04-23 12:43:05 +0000583 return 0;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000584 }
Oleh Prypin5a980492018-03-09 12:27:24 +0000585
Per Kjellander252725d2019-02-20 13:14:34 +0100586 const int32_t packet_size = static_cast<int32_t>(stored_packet->packet_size);
Erik Språngf6468d22019-07-05 16:53:43 +0200587 const bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
Erik Språng7bb37b82018-03-09 09:52:59 +0100588
Oleh Prypin5a980492018-03-09 12:27:24 +0000589 if (paced_sender_) {
Erik Språngf6468d22019-07-05 16:53:43 +0200590 if (pacer_legacy_packet_referencing_) {
591 // Check if we're overusing retransmission bitrate.
592 // TODO(sprang): Add histograms for nack success or failure reasons.
593 if (retransmission_rate_limiter_ &&
594 !retransmission_rate_limiter_->TryUseRate(packet_size)) {
595 return -1;
596 }
597
598 // Mark packet as being in pacer queue again, to prevent duplicates.
599 if (!packet_history_.SetPendingTransmission(packet_id)) {
600 // Packet has already been removed from history, return early.
601 return 0;
602 }
603
604 paced_sender_->InsertPacket(
605 RtpPacketSender::kNormalPriority, stored_packet->ssrc,
606 stored_packet->rtp_sequence_number, stored_packet->capture_time_ms,
607 stored_packet->packet_size, true);
608 } else {
609 std::unique_ptr<RtpPacketToSend> packet =
610 packet_history_.GetPacketAndMarkAsPending(
611 packet_id, [&](const RtpPacketToSend& stored_packet) {
612 // Check if we're overusing retransmission bitrate.
613 // TODO(sprang): Add histograms for nack success or failure
614 // reasons.
615 std::unique_ptr<RtpPacketToSend> retransmit_packet;
616 if (retransmission_rate_limiter_ &&
617 !retransmission_rate_limiter_->TryUseRate(packet_size)) {
618 return retransmit_packet;
619 }
620 if (rtx) {
621 retransmit_packet = BuildRtxPacket(stored_packet);
622 } else {
623 retransmit_packet =
624 absl::make_unique<RtpPacketToSend>(stored_packet);
625 }
626 retransmit_packet->set_retransmitted_sequence_number(
627 stored_packet.SequenceNumber());
628 return retransmit_packet;
629 });
630 if (!packet) {
631 return -1;
632 }
633 packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
634 paced_sender_->EnqueuePacket(std::move(packet));
Erik Språng0f4f0552019-05-08 10:15:05 -0700635 }
636
Erik Språnga12b1d62018-03-14 12:39:24 +0100637 return packet_size;
Oleh Prypin5a980492018-03-09 12:27:24 +0000638 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100639
Erik Språngf6468d22019-07-05 16:53:43 +0200640 // TODO(sprang): Replace this whole code-path with a pass-through pacer.
641 // Check if we're overusing retransmission bitrate.
642 // TODO(sprang): Add histograms for nack success or failure reasons.
643 if (retransmission_rate_limiter_ &&
644 !retransmission_rate_limiter_->TryUseRate(packet_size)) {
645 return -1;
646 }
647
Erik Språnga12b1d62018-03-14 12:39:24 +0100648 std::unique_ptr<RtpPacketToSend> packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200649 packet_history_.GetPacketAndSetSendTime(packet_id);
Erik Språnga12b1d62018-03-14 12:39:24 +0100650 if (!packet) {
651 // Packet could theoretically time out between the first check and this one.
652 return 0;
653 }
654
philipel8aadd502017-02-23 02:56:13 -0800655 if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
sprang867fb522015-08-03 04:38:41 -0700656 return -1;
Erik Språnga12b1d62018-03-14 12:39:24 +0100657
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200658 return packet_size;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000659}
660
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200661bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
philipel32d00102017-02-27 02:18:46 -0800662 const PacketOptions& options,
663 const PacedPacketInfo& pacing_info) {
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000664 int bytes_sent = -1;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000665 if (transport_) {
michaelt4da30442016-11-17 01:38:43 -0800666 UpdateRtpOverhead(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200667 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
668 ? static_cast<int>(packet.size())
stefan1d8a5062015-10-02 03:39:33 -0700669 : -1;
terelius429c3452016-01-21 05:42:04 -0800670 if (event_log_ && bytes_sent > 0) {
Karl Wiberg918f50c2018-07-05 11:40:33 +0200671 event_log_->Log(absl::make_unique<RtcEventRtpPacketOutgoing>(
Elad Alon4a87e1c2017-10-03 16:11:34 +0200672 packet, pacing_info.probe_cluster_id));
terelius429c3452016-01-21 05:42:04 -0800673 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000674 }
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000675 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000676 if (bytes_sent <= 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100677 RTC_LOG(LS_WARNING) << "Transport failed to send packet.";
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000678 return false;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000679 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000680 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000681}
682
Danil Chapovalov2800d742016-08-26 18:48:46 +0200683void RTPSender::OnReceivedNack(
684 const std::vector<uint16_t>& nack_sequence_numbers,
685 int64_t avg_rtt) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100686 packet_history_.SetRtt(5 + avg_rtt);
sprangcd349d92016-07-13 09:11:28 -0700687 for (uint16_t seq_no : nack_sequence_numbers) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100688 const int32_t bytes_sent = ReSendPacket(seq_no);
sprangcd349d92016-07-13 09:11:28 -0700689 if (bytes_sent < 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000690 // Failed to send one Sequence number. Give up the rest in this nack.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100691 RTC_LOG(LS_WARNING) << "Failed resending RTP packet " << seq_no
692 << ", Discard rest of packets.";
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000693 break;
niklase@google.com470e71d2011-07-07 08:21:25 +0000694 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000695 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000696}
697
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000698// Called from pacer when we can send the packet.
Erik Språngd2879622019-05-10 08:29:01 -0700699RtpPacketSendResult RTPSender::TimeToSendPacket(
700 uint32_t ssrc,
701 uint16_t sequence_number,
702 int64_t capture_time_ms,
703 bool retransmission,
704 const PacedPacketInfo& pacing_info) {
705 if (!SendingMedia()) {
706 return RtpPacketSendResult::kPacketNotFound;
707 }
brandtr9dfff292016-11-14 05:14:50 -0800708
709 std::unique_ptr<RtpPacketToSend> packet;
710 if (ssrc == SSRC()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200711 packet = packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800712 } else if (ssrc == FlexfecSsrc()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200713 packet = flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800714 }
715
Stefan Holmera246cfb2016-08-23 17:51:42 +0200716 if (!packet) {
Erik Språngd2879622019-05-10 08:29:01 -0700717 // Packet cannot be found or was resent too recently.
718 return RtpPacketSendResult::kPacketNotFound;
Stefan Holmera246cfb2016-08-23 17:51:42 +0200719 }
asapersson35151f32016-05-02 23:44:01 -0700720
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200721 return PrepareAndSendPacket(
Erik Språngd2879622019-05-10 08:29:01 -0700722 std::move(packet),
723 retransmission && (RtxStatus() & kRtxRetransmitted) > 0,
724 retransmission, pacing_info)
725 ? RtpPacketSendResult::kSuccess
726 : RtpPacketSendResult::kTransportUnavailable;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000727}
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000728
Erik Språng9c771c22019-06-17 16:31:53 +0200729// Called from pacer when we can send the packet.
730bool RTPSender::TrySendPacket(RtpPacketToSend* packet,
731 const PacedPacketInfo& pacing_info) {
732 RTC_DCHECK(packet);
733
734 const uint32_t packet_ssrc = packet->Ssrc();
735 const auto packet_type = packet->packet_type();
736 RTC_DCHECK(packet_type.has_value());
737
738 PacketOptions options;
739 bool is_media = false;
740 bool is_rtx = false;
741 {
742 rtc::CritScope lock(&send_critsect_);
743 if (!sending_media_) {
744 return false;
745 }
746
747 switch (*packet_type) {
748 case RtpPacketToSend::Type::kAudio:
749 case RtpPacketToSend::Type::kVideo:
750 if (packet_ssrc != ssrc_) {
751 return false;
752 }
753 is_media = true;
754 break;
755 case RtpPacketToSend::Type::kRetransmission:
756 case RtpPacketToSend::Type::kPadding:
757 // Both padding and retransmission must be on either the media or the
758 // RTX stream.
759 if (packet_ssrc == ssrc_rtx_) {
760 is_rtx = true;
761 } else if (packet_ssrc != ssrc_) {
762 return false;
763 }
764 break;
765 case RtpPacketToSend::Type::kForwardErrorCorrection:
766 // FlexFEC is on separate SSRC, ULPFEC uses media SSRC.
767 if (packet_ssrc != ssrc_ && packet_ssrc != flexfec_ssrc_) {
768 return false;
769 }
770 break;
771 }
772
773 options.included_in_allocation = force_part_of_allocation_;
774 }
775
776 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
777 // the pacer, these modifications of the header below are happening after the
778 // FEC protection packets are calculated. This will corrupt recovered packets
779 // at the same place. It's not an issue for extensions, which are present in
780 // all the packets (their content just may be incorrect on recovered packets).
781 // In case of VideoTimingExtension, since it's present not in every packet,
782 // data after rtp header may be corrupted if these packets are protected by
783 // the FEC.
784 int64_t now_ms = clock_->TimeInMilliseconds();
785 int64_t diff_ms = now_ms - packet->capture_time_ms();
Erik Språng0f6191d2019-07-15 20:33:40 +0200786 if (packet->IsExtensionReserved<TransmissionOffset>()) {
787 packet->SetExtension<TransmissionOffset>(kTimestampTicksPerMs * diff_ms);
788 }
789 if (packet->IsExtensionReserved<AbsoluteSendTime>()) {
790 packet->SetExtension<AbsoluteSendTime>(
791 AbsoluteSendTime::MsTo24Bits(now_ms));
792 }
Erik Språng9c771c22019-06-17 16:31:53 +0200793
794 if (packet->HasExtension<VideoTimingExtension>()) {
795 if (populate_network2_timestamp_) {
796 packet->set_network2_time_ms(now_ms);
797 } else {
798 packet->set_pacer_exit_time_ms(now_ms);
799 }
800 }
801
802 // Downstream code actually uses this flag to distinguish between media and
803 // everything else.
804 options.is_retransmit = !is_media;
805 if (auto packet_id = packet->GetExtension<TransportSequenceNumber>()) {
806 options.packet_id = *packet_id;
807 options.included_in_feedback = true;
808 options.included_in_allocation = true;
809 AddPacketToTransportFeedback(*packet_id, *packet, pacing_info);
810 }
811
812 options.application_data.assign(packet->application_data().begin(),
813 packet->application_data().end());
814
815 if (packet->packet_type() != RtpPacketToSend::Type::kPadding &&
816 packet->packet_type() != RtpPacketToSend::Type::kRetransmission) {
817 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet_ssrc);
818 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
819 packet_ssrc);
820 }
821
822 const bool send_success = SendPacketToNetwork(*packet, options, pacing_info);
823
824 // Put packet in retransmission history or update pending status even if
825 // actual sending fails.
826 if (is_media && packet->allow_retransmission()) {
827 packet_history_.PutRtpPacket(absl::make_unique<RtpPacketToSend>(*packet),
828 StorageType::kAllowRetransmission, now_ms);
829 } else if (packet->retransmitted_sequence_number()) {
830 packet_history_.MarkPacketAsSent(*packet->retransmitted_sequence_number());
831 }
832
833 if (send_success) {
834 UpdateRtpStats(*packet, is_rtx,
835 packet_type == RtpPacketToSend::Type::kRetransmission);
836
837 rtc::CritScope lock(&send_critsect_);
838 media_has_been_sent_ = true;
839 }
840
841 // Return true even if transport failed (will be handled by retransmissions
842 // instead in that case), so that PacketRouter does not have to iterate over
843 // all other RTP modules and fail to send there too.
844 return true;
845}
846
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000847bool RTPSender::SupportsPadding() const {
848 rtc::CritScope lock(&send_critsect_);
849 return sending_media_ && supports_bwe_extension_;
850}
851
852bool RTPSender::SupportsRtxPayloadPadding() const {
853 rtc::CritScope lock(&send_critsect_);
854 return sending_media_ && supports_bwe_extension_ &&
855 (rtx_ & kRtxRedundantPayloads);
856}
857
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200858bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000859 bool send_over_rtx,
philipela1ed0b32016-06-01 06:31:17 -0700860 bool is_retransmit,
philipel8aadd502017-02-23 02:56:13 -0800861 const PacedPacketInfo& pacing_info) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200862 RTC_DCHECK(packet);
863 int64_t capture_time_ms = packet->capture_time_ms();
864 RtpPacketToSend* packet_to_send = packet.get();
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000865
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200866 std::unique_ptr<RtpPacketToSend> packet_rtx;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000867 if (send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200868 packet_rtx = BuildRtxPacket(*packet);
869 if (!packet_rtx)
danilchap32cd2c42016-08-01 06:58:34 -0700870 return false;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200871 packet_to_send = packet_rtx.get();
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000872 }
873
ilnik10894992017-06-21 08:23:19 -0700874 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
875 // the pacer, these modifications of the header below are happening after the
876 // FEC protection packets are calculated. This will corrupt recovered packets
877 // at the same place. It's not an issue for extensions, which are present in
878 // all the packets (their content just may be incorrect on recovered packets).
879 // In case of VideoTimingExtension, since it's present not in every packet,
880 // data after rtp header may be corrupted if these packets are protected by
881 // the FEC.
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000882 int64_t now_ms = clock_->TimeInMilliseconds();
883 int64_t diff_ms = now_ms - capture_time_ms;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200884 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
885 diff_ms);
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200886 packet_to_send->SetExtension<AbsoluteSendTime>(
887 AbsoluteSendTime::MsTo24Bits(now_ms));
sprang867fb522015-08-03 04:38:41 -0700888
Erik Språng7b52f102018-02-07 14:37:37 +0100889 if (packet_to_send->HasExtension<VideoTimingExtension>()) {
890 if (populate_network2_timestamp_) {
891 packet_to_send->set_network2_time_ms(now_ms);
892 } else {
893 packet_to_send->set_pacer_exit_time_ms(now_ms);
894 }
895 }
ilnik04f4d122017-06-19 07:18:55 -0700896
stefan1d8a5062015-10-02 03:39:33 -0700897 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200898 // If we are sending over RTX, it also means this is a retransmission.
899 // E.g. RTPSender::TrySendRedundantPayloads calls PrepareAndSendPacket with
900 // send_over_rtx = true but is_retransmit = false.
901 options.is_retransmit = is_retransmit || send_over_rtx;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200902 bool has_transport_seq_num;
903 {
904 rtc::CritScope lock(&send_critsect_);
905 has_transport_seq_num =
906 UpdateTransportSequenceNumber(packet_to_send, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200907 options.included_in_allocation =
908 has_transport_seq_num || force_part_of_allocation_;
909 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200910 }
911 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -0800912 AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
philipel8aadd502017-02-23 02:56:13 -0800913 pacing_info);
sprang867fb522015-08-03 04:38:41 -0700914 }
Dino Radaković1807d572018-02-22 14:18:06 +0100915 options.application_data.assign(packet_to_send->application_data().begin(),
916 packet_to_send->application_data().end());
sprang867fb522015-08-03 04:38:41 -0700917
asapersson35151f32016-05-02 23:44:01 -0700918 if (!is_retransmit && !send_over_rtx) {
Erik Språng9c771c22019-06-17 16:31:53 +0200919 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet->Ssrc());
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200920 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
921 packet->Ssrc());
stefanf116bd02015-10-27 08:29:42 -0700922 }
923
philipel32d00102017-02-27 02:18:46 -0800924 if (!SendPacketToNetwork(*packet_to_send, options, pacing_info))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200925 return false;
926
927 {
tommiae695e92016-02-02 08:31:45 -0800928 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000929 media_has_been_sent_ = true;
930 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200931 UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit);
932 return true;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000933}
934
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200935void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet,
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000936 bool is_rtx,
937 bool is_retransmit) {
sprangcd349d92016-07-13 09:11:28 -0700938 int64_t now_ms = clock_->TimeInMilliseconds();
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000939
danilchap7c9426c2016-04-14 03:05:31 -0700940 rtc::CritScope lock(&statistics_crit_);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200941 StreamDataCounters* counters = is_rtx ? &rtx_rtp_stats_ : &rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000942
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200943 total_bitrate_sent_.Update(packet.size(), now_ms);
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000944
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200945 if (counters->first_packet_time_ms == -1)
946 counters->first_packet_time_ms = now_ms;
947
Erik Språngf53cfa92019-06-12 13:58:17 +0200948 if (packet.packet_type() == RtpPacketToSend::Type::kForwardErrorCorrection) {
Niels Möllerdbb988b2018-11-15 08:05:16 +0100949 counters->fec.AddPacket(packet);
Erik Språngf53cfa92019-06-12 13:58:17 +0200950 }
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200951
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200952 if (is_retransmit) {
Niels Möllerdbb988b2018-11-15 08:05:16 +0100953 counters->retransmitted.AddPacket(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200954 nack_bitrate_sent_.Update(packet.size(), now_ms);
955 }
Niels Möllerdbb988b2018-11-15 08:05:16 +0100956 counters->transmitted.AddPacket(packet);
sprangcd349d92016-07-13 09:11:28 -0700957
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200958 if (rtp_stats_callback_)
959 rtp_stats_callback_->DataCountersUpdated(*counters, packet.Ssrc());
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000960}
961
philipel8aadd502017-02-23 02:56:13 -0800962size_t RTPSender::TimeToSendPadding(size_t bytes,
963 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800964 if (bytes == 0)
pbos545727e2015-07-01 06:31:06 -0700965 return 0;
philipel8aadd502017-02-23 02:56:13 -0800966 size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000967 if (bytes_sent < bytes)
philipel8aadd502017-02-23 02:56:13 -0800968 bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000969 return bytes_sent;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000970}
971
Erik Språngf6468d22019-07-05 16:53:43 +0200972std::vector<std::unique_ptr<RtpPacketToSend>> RTPSender::GeneratePadding(
973 size_t target_size_bytes) {
Erik Språng478cb462019-06-26 15:49:27 +0200974 // This method does not actually send packets, it just generates
975 // them and puts them in the pacer queue. Since this should incur
976 // low overhead, keep the lock for the scope of the method in order
977 // to make the code more readable.
Erik Språng478cb462019-06-26 15:49:27 +0200978
Erik Språngf6468d22019-07-05 16:53:43 +0200979 std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets;
Erik Språng478cb462019-06-26 15:49:27 +0200980 size_t bytes_left = target_size_bytes;
Erik Språng0f6191d2019-07-15 20:33:40 +0200981 if (SupportsRtxPayloadPadding()) {
Mirko Bonadeia7e3bce2019-07-12 17:35:56 +0000982 while (bytes_left >= kMinPayloadPaddingBytes) {
Erik Språng478cb462019-06-26 15:49:27 +0200983 std::unique_ptr<RtpPacketToSend> packet =
984 packet_history_.GetPayloadPaddingPacket(
985 [&](const RtpPacketToSend& packet)
986 -> std::unique_ptr<RtpPacketToSend> {
Erik Språng478cb462019-06-26 15:49:27 +0200987 return BuildRtxPacket(packet);
988 });
989 if (!packet) {
990 break;
991 }
992
993 bytes_left -= std::min(bytes_left, packet->payload_size());
994 packet->set_packet_type(RtpPacketToSend::Type::kPadding);
Erik Språngf6468d22019-07-05 16:53:43 +0200995 padding_packets.push_back(std::move(packet));
Erik Språng478cb462019-06-26 15:49:27 +0200996 }
997 }
998
Erik Språng0f6191d2019-07-15 20:33:40 +0200999 rtc::CritScope lock(&send_critsect_);
1000 if (!sending_media_) {
1001 return {};
1002 }
1003
Erik Språng478cb462019-06-26 15:49:27 +02001004 size_t padding_bytes_in_packet;
1005 const size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
1006 if (audio_configured_) {
1007 // Allow smaller padding packets for audio.
1008 padding_bytes_in_packet = rtc::SafeClamp<size_t>(
1009 bytes_left, kMinAudioPaddingLength,
1010 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
1011 } else {
1012 // Always send full padding packets. This is accounted for by the
1013 // RtpPacketSender, which will make sure we don't send too much padding even
1014 // if a single packet is larger than requested.
1015 // We do this to avoid frequently sending small packets on higher bitrates.
1016 padding_bytes_in_packet = rtc::SafeMin(max_payload_size, kMaxPaddingLength);
1017 }
1018
1019 while (bytes_left > 0) {
1020 auto padding_packet =
1021 absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_);
1022 padding_packet->set_packet_type(RtpPacketToSend::Type::kPadding);
1023 padding_packet->SetMarker(false);
1024 padding_packet->SetTimestamp(last_rtp_timestamp_);
1025 padding_packet->set_capture_time_ms(capture_time_ms_);
1026 if (rtx_ == kRtxOff) {
1027 if (last_payload_type_ == -1) {
1028 break;
1029 }
1030 // Without RTX we can't send padding in the middle of frames.
1031 // For audio marker bits doesn't mark the end of a frame and frames
1032 // are usually a single packet, so for now we don't apply this rule
1033 // for audio.
1034 if (!audio_configured_ && !last_packet_marker_bit_) {
1035 break;
1036 }
1037
1038 RTC_DCHECK(ssrc_);
1039 padding_packet->SetSsrc(*ssrc_);
1040 padding_packet->SetPayloadType(last_payload_type_);
1041 padding_packet->SetSequenceNumber(sequence_number_++);
1042 } else {
1043 // Without abs-send-time or transport sequence number a media packet
1044 // must be sent before padding so that the timestamps used for
1045 // estimation are correct.
1046 if (!media_has_been_sent_ &&
1047 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
1048 rtp_header_extension_map_.IsRegistered(
1049 TransportSequenceNumber::kId))) {
1050 break;
1051 }
1052 // Only change the timestamp of padding packets sent over RTX.
1053 // Padding only packets over RTP has to be sent as part of a media
1054 // frame (and therefore the same timestamp).
1055 int64_t now_ms = clock_->TimeInMilliseconds();
1056 if (last_timestamp_time_ms_ > 0) {
1057 padding_packet->SetTimestamp(padding_packet->Timestamp() +
1058 (now_ms - last_timestamp_time_ms_) *
1059 kTimestampTicksPerMs);
1060 padding_packet->set_capture_time_ms(padding_packet->capture_time_ms() +
1061 (now_ms - last_timestamp_time_ms_));
1062 }
1063 RTC_DCHECK(ssrc_rtx_);
1064 padding_packet->SetSsrc(*ssrc_rtx_);
1065 padding_packet->SetSequenceNumber(sequence_number_rtx_++);
1066 padding_packet->SetPayloadType(rtx_payload_type_map_.begin()->second);
1067 }
1068
Erik Språngf6468d22019-07-05 16:53:43 +02001069 if (rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId)) {
1070 padding_packet->ReserveExtension<TransportSequenceNumber>();
1071 }
Erik Språng0f6191d2019-07-15 20:33:40 +02001072 if (rtp_header_extension_map_.IsRegistered(TransmissionOffset::kId)) {
1073 padding_packet->ReserveExtension<TransmissionOffset>();
1074 }
1075 if (rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId)) {
1076 padding_packet->ReserveExtension<AbsoluteSendTime>();
1077 }
1078
Erik Språng478cb462019-06-26 15:49:27 +02001079 padding_packet->SetPadding(padding_bytes_in_packet);
1080 bytes_left -= std::min(bytes_left, padding_bytes_in_packet);
Erik Språngf6468d22019-07-05 16:53:43 +02001081 padding_packets.push_back(std::move(padding_packet));
Erik Språng478cb462019-06-26 15:49:27 +02001082 }
Erik Språngf6468d22019-07-05 16:53:43 +02001083
1084 return padding_packets;
Erik Språng478cb462019-06-26 15:49:27 +02001085}
1086
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001087bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
Erik Språng13eb7642019-06-24 10:58:48 +02001088 StorageType storage) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001089 RTC_DCHECK(packet);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001090 int64_t now_ms = clock_->TimeInMilliseconds();
1091
brandtr9dfff292016-11-14 05:14:50 -08001092 uint32_t ssrc = packet->Ssrc();
Peter Boströme23e7372015-10-08 11:44:14 +02001093 if (paced_sender_) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001094 uint16_t seq_no = packet->SequenceNumber();
Erik Språng83afeeb2019-05-14 15:57:19 +02001095 int64_t capture_time_ms = packet->capture_time_ms();
Per Kjellander17c147c2019-02-20 12:06:17 +01001096 size_t packet_size =
1097 send_side_bwe_with_overhead_ ? packet->size() : packet->payload_size();
Erik Språng13eb7642019-06-24 10:58:48 +02001098 auto packet_type = packet->packet_type();
Erik Språngf6468d22019-07-05 16:53:43 +02001099 RTC_CHECK(packet_type) << "Packet type must be set before sending.";
1100
1101 if (pacer_legacy_packet_referencing_) {
1102 // If |pacer_reference_packets_| then pacer needs to find the packet in
1103 // the history when it is time to send, so move packet there.
1104 if (ssrc == FlexfecSsrc()) {
1105 // Store FlexFEC packets in a separate history since they are on a
1106 // separate SSRC.
1107 flexfec_packet_history_.PutRtpPacket(std::move(packet), storage,
1108 absl::nullopt);
1109 } else {
1110 packet_history_.PutRtpPacket(std::move(packet), storage, absl::nullopt);
1111 }
1112
1113 paced_sender_->InsertPacket(PacketTypeToPriority(*packet_type), ssrc,
1114 seq_no, capture_time_ms, packet_size, false);
brandtr9dfff292016-11-14 05:14:50 -08001115 } else {
Erik Språngf6468d22019-07-05 16:53:43 +02001116 packet->set_allow_retransmission(storage ==
1117 StorageType::kAllowRetransmission);
1118 paced_sender_->EnqueuePacket(std::move(packet));
brandtr9dfff292016-11-14 05:14:50 -08001119 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001120
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001121 return true;
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +00001122 }
Stefan Holmerf5dca482016-01-27 12:58:51 +01001123
1124 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +02001125 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001126
Danil Chapovalovaf52b682018-11-27 10:48:27 +01001127 // |capture_time_ms| <= 0 is considered invalid.
1128 // TODO(holmer): This should be changed all over Video Engine so that negative
1129 // time is consider invalid, while 0 is considered a valid time.
1130 if (packet->capture_time_ms() > 0) {
1131 packet->SetExtension<TransmissionOffset>(
1132 kTimestampTicksPerMs * (now_ms - packet->capture_time_ms()));
1133
1134 if (populate_network2_timestamp_ &&
1135 packet->HasExtension<VideoTimingExtension>()) {
1136 packet->set_network2_time_ms(now_ms);
1137 }
1138 }
1139 packet->SetExtension<AbsoluteSendTime>(AbsoluteSendTime::MsTo24Bits(now_ms));
1140
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001141 bool has_transport_seq_num;
1142 {
1143 rtc::CritScope lock(&send_critsect_);
1144 has_transport_seq_num =
1145 UpdateTransportSequenceNumber(packet.get(), &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +02001146 options.included_in_allocation =
1147 has_transport_seq_num || force_part_of_allocation_;
1148 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001149 }
1150 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -08001151 AddPacketToTransportFeedback(options.packet_id, *packet.get(),
philipel8aadd502017-02-23 02:56:13 -08001152 PacedPacketInfo());
Stefan Holmerf5dca482016-01-27 12:58:51 +01001153 }
Dino Radaković1807d572018-02-22 14:18:06 +01001154 options.application_data.assign(packet->application_data().begin(),
1155 packet->application_data().end());
Stefan Holmerf5dca482016-01-27 12:58:51 +01001156
Erik Språng9c771c22019-06-17 16:31:53 +02001157 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet->Ssrc());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001158 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
1159 packet->Ssrc());
1160
philipel32d00102017-02-27 02:18:46 -08001161 bool sent = SendPacketToNetwork(*packet, options, PacedPacketInfo());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001162
1163 if (sent) {
1164 {
1165 rtc::CritScope lock(&send_critsect_);
1166 media_has_been_sent_ = true;
1167 }
1168 UpdateRtpStats(*packet, false, false);
1169 }
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +00001170
brandtr9dfff292016-11-14 05:14:50 -08001171 // To support retransmissions, we store the media packet as sent in the
1172 // packet history (even if send failed).
1173 if (storage == kAllowRetransmission) {
Danil Chapovalov603ce982017-12-27 11:32:50 +01001174 RTC_DCHECK_EQ(ssrc, SSRC());
Erik Språnga12b1d62018-03-14 12:39:24 +01001175 packet_history_.PutRtpPacket(std::move(packet), storage, now_ms);
brandtr9dfff292016-11-14 05:14:50 -08001176 }
Peter Boströme23e7372015-10-08 11:44:14 +02001177
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001178 return sent;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +00001179}
1180
Erik Språng13eb7642019-06-24 10:58:48 +02001181bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
1182 StorageType storage,
1183 RtpPacketSender::Priority priority) {
1184 packet->set_packet_type(PacketPriorityToType(priority));
1185 return SendToNetwork(std::move(packet), storage);
1186}
1187
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001188void RTPSender::RecomputeMaxSendDelay() {
1189 max_delay_it_ = send_delays_.begin();
1190 for (auto it = send_delays_.begin(); it != send_delays_.end(); ++it) {
1191 if (it->second >= max_delay_it_->second) {
1192 max_delay_it_ = it;
1193 }
1194 }
1195}
1196
Erik Språng9c771c22019-06-17 16:31:53 +02001197void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms,
1198 int64_t now_ms,
1199 uint32_t ssrc) {
asapersson35151f32016-05-02 23:44:01 -07001200 if (!send_side_delay_observer_ || capture_time_ms <= 0)
Peter Boström71861a02015-05-28 14:45:36 +02001201 return;
1202
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001203 int avg_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001204 int max_delay_ms = 0;
Henrik Boström9fe18342019-05-16 18:38:20 +02001205 uint64_t total_packet_send_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001206 {
danilchap7c9426c2016-04-14 03:05:31 -07001207 rtc::CritScope cs(&statistics_crit_);
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001208 // Compute the max and average of the recent capture-to-send delays.
1209 // The time complexity of the current approach depends on the distribution
1210 // of the delay values. This could be done more efficiently.
1211
1212 // Remove elements older than kSendSideDelayWindowMs.
1213 auto lower_bound =
1214 send_delays_.lower_bound(now_ms - kSendSideDelayWindowMs);
1215 for (auto it = send_delays_.begin(); it != lower_bound; ++it) {
1216 if (max_delay_it_ == it) {
1217 max_delay_it_ = send_delays_.end();
1218 }
1219 sum_delays_ms_ -= it->second;
1220 }
1221 send_delays_.erase(send_delays_.begin(), lower_bound);
1222 if (max_delay_it_ == send_delays_.end()) {
1223 // Removed the previous max. Need to recompute.
1224 RecomputeMaxSendDelay();
1225 }
1226
1227 // Add the new element.
Johannes Kron965e7942018-09-13 15:36:20 +02001228 RTC_DCHECK_GE(now_ms, static_cast<int64_t>(0));
1229 RTC_DCHECK_LE(now_ms, std::numeric_limits<int64_t>::max() / 2);
1230 RTC_DCHECK_GE(capture_time_ms, static_cast<int64_t>(0));
1231 RTC_DCHECK_LE(capture_time_ms, std::numeric_limits<int64_t>::max() / 2);
1232 int64_t diff_ms = now_ms - capture_time_ms;
1233 RTC_DCHECK_GE(diff_ms, static_cast<int64_t>(0));
1234 RTC_DCHECK_LE(diff_ms,
1235 static_cast<int64_t>(std::numeric_limits<int>::max()));
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001236 int new_send_delay = rtc::dchecked_cast<int>(now_ms - capture_time_ms);
1237 SendDelayMap::iterator it;
1238 bool inserted;
1239 std::tie(it, inserted) =
1240 send_delays_.insert(std::make_pair(now_ms, new_send_delay));
1241 if (!inserted) {
1242 // TODO(terelius): If we have multiple delay measurements during the same
1243 // millisecond then we keep the most recent one. It is not clear that this
1244 // is the right decision, but it preserves an earlier behavior.
1245 int previous_send_delay = it->second;
1246 sum_delays_ms_ -= previous_send_delay;
1247 it->second = new_send_delay;
1248 if (max_delay_it_ == it && new_send_delay < previous_send_delay) {
1249 RecomputeMaxSendDelay();
1250 }
Peter Boström71861a02015-05-28 14:45:36 +02001251 }
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001252 if (max_delay_it_ == send_delays_.end() ||
1253 it->second >= max_delay_it_->second) {
1254 max_delay_it_ = it;
1255 }
1256 sum_delays_ms_ += new_send_delay;
Henrik Boström9fe18342019-05-16 18:38:20 +02001257 total_packet_send_delay_ms_ += new_send_delay;
1258 total_packet_send_delay_ms = total_packet_send_delay_ms_;
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001259
1260 size_t num_delays = send_delays_.size();
1261 RTC_DCHECK(max_delay_it_ != send_delays_.end());
1262 max_delay_ms = rtc::dchecked_cast<int>(max_delay_it_->second);
1263 int64_t avg_ms = (sum_delays_ms_ + num_delays / 2) / num_delays;
1264 RTC_DCHECK_GE(avg_ms, static_cast<int64_t>(0));
1265 RTC_DCHECK_LE(avg_ms,
1266 static_cast<int64_t>(std::numeric_limits<int>::max()));
1267 avg_delay_ms =
1268 rtc::dchecked_cast<int>((sum_delays_ms_ + num_delays / 2) / num_delays);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001269 }
Henrik Boström9fe18342019-05-16 18:38:20 +02001270 send_side_delay_observer_->SendSideDelayUpdated(
1271 avg_delay_ms, max_delay_ms, total_packet_send_delay_ms, ssrc);
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001272}
1273
asapersson35151f32016-05-02 23:44:01 -07001274void RTPSender::UpdateOnSendPacket(int packet_id,
1275 int64_t capture_time_ms,
1276 uint32_t ssrc) {
1277 if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
1278 return;
1279
1280 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
1281}
1282
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001283void RTPSender::ProcessBitrate() {
sprangcd349d92016-07-13 09:11:28 -07001284 if (!bitrate_callback_)
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001285 return;
sprangcd349d92016-07-13 09:11:28 -07001286 int64_t now_ms = clock_->TimeInMilliseconds();
1287 uint32_t ssrc;
1288 {
1289 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001290 if (!ssrc_)
1291 return;
1292 ssrc = *ssrc_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001293 }
sprangcd349d92016-07-13 09:11:28 -07001294
1295 rtc::CritScope lock(&statistics_crit_);
1296 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0),
1297 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +00001298}
1299
isheriff6b4b5f32016-06-08 00:24:21 -07001300size_t RTPSender::RtpHeaderLength() const {
tommiae695e92016-02-02 08:31:45 -08001301 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001302 size_t rtp_header_length = kRtpHeaderLength;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001303 rtp_header_length += sizeof(uint32_t) * csrcs_.size();
Danil Chapovalov7b189922018-10-03 10:15:36 +02001304 rtp_header_length += RtpHeaderExtensionSize(kFecOrPaddingExtensionSizes,
1305 rtp_header_extension_map_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001306 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +00001307}
1308
mflodmanfcf54bd2015-04-14 21:28:08 +02001309uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
tommiae695e92016-02-02 08:31:45 -08001310 rtc::CritScope lock(&send_critsect_);
mflodmanfcf54bd2015-04-14 21:28:08 +02001311 uint16_t first_allocated_sequence_number = sequence_number_;
1312 sequence_number_ += packets_to_send;
1313 return first_allocated_sequence_number;
niklase@google.com470e71d2011-07-07 08:21:25 +00001314}
1315
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001316void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
1317 StreamDataCounters* rtx_stats) const {
danilchap7c9426c2016-04-14 03:05:31 -07001318 rtc::CritScope lock(&statistics_crit_);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001319 *rtp_stats = rtp_stats_;
1320 *rtx_stats = rtx_rtp_stats_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001321}
1322
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001323std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
1324 rtc::CritScope lock(&send_critsect_);
Danil Chapovalov3b4b4f52018-10-12 12:50:43 +02001325 // TODO(danilchap): Find better motivator and value for extra capacity.
1326 // RtpPacketizer might slightly miscalulate needed size,
1327 // SRTP may benefit from extra space in the buffer and do encryption in place
1328 // saving reallocation.
1329 // While sending slightly oversized packet increase chance of dropped packet,
1330 // it is better than crash on drop packet without trying to send it.
1331 static constexpr int kExtraCapacity = 16;
1332 auto packet = absl::make_unique<RtpPacketToSend>(
1333 &rtp_header_extension_map_, max_packet_size_ + kExtraCapacity);
nisse7d59f6b2017-02-21 03:40:24 -08001334 RTC_DCHECK(ssrc_);
1335 packet->SetSsrc(*ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001336 packet->SetCsrcs(csrcs_);
1337 // Reserve extensions, if registered, RtpSender set in SendToNetwork.
1338 packet->ReserveExtension<AbsoluteSendTime>();
1339 packet->ReserveExtension<TransmissionOffset>();
1340 packet->ReserveExtension<TransportSequenceNumber>();
Niels Möller6893f3c2019-01-31 08:56:26 +01001341
Steve Anton4af95842018-04-06 11:09:46 -07001342 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001343 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001344 packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001345 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001346 if (!rid_.empty()) {
1347 // This is a no-op if the RID header extension is not registered.
1348 packet->SetExtension<RtpStreamId>(rid_);
1349 }
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001350 return packet;
1351}
1352
1353bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) {
1354 rtc::CritScope lock(&send_critsect_);
1355 if (!sending_media_)
1356 return false;
nisse7d59f6b2017-02-21 03:40:24 -08001357 RTC_DCHECK(packet->Ssrc() == ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001358 packet->SetSequenceNumber(sequence_number_++);
1359
1360 // Remember marker bit to determine if padding can be inserted with
1361 // sequence number following |packet|.
1362 last_packet_marker_bit_ = packet->Marker();
Danil Chapovalovb3179c72018-03-22 10:13:07 +01001363 // Remember payload type to use in the padding packet if rtx is disabled.
1364 last_payload_type_ = packet->PayloadType();
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001365 // Save timestamps to generate timestamp field and extensions for the padding.
1366 last_rtp_timestamp_ = packet->Timestamp();
1367 last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
1368 capture_time_ms_ = packet->capture_time_ms();
1369 return true;
1370}
1371
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001372bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet,
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001373 int* packet_id) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001374 RTC_DCHECK(packet);
1375 RTC_DCHECK(packet_id);
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001376 if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId))
stefana23fc622016-07-28 07:56:38 -07001377 return false;
1378
asapersson35151f32016-05-02 23:44:01 -07001379 if (!transport_sequence_number_allocator_)
1380 return false;
1381
1382 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001383
1384 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
1385 return false;
1386
asapersson35151f32016-05-02 23:44:01 -07001387 return true;
sprang867fb522015-08-03 04:38:41 -07001388}
1389
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001390void RTPSender::SetSendingMediaStatus(bool enabled) {
tommiae695e92016-02-02 08:31:45 -08001391 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001392 sending_media_ = enabled;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001393}
1394
1395bool RTPSender::SendingMedia() const {
tommiae695e92016-02-02 08:31:45 -08001396 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001397 return sending_media_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001398}
1399
Sebastian Jansson1bca65b2018-10-10 09:58:08 +02001400void RTPSender::SetAsPartOfAllocation(bool part_of_allocation) {
1401 rtc::CritScope lock(&send_critsect_);
1402 force_part_of_allocation_ = part_of_allocation;
1403}
1404
danilchap71fead22016-08-18 02:01:49 -07001405void RTPSender::SetTimestampOffset(uint32_t timestamp) {
tommiae695e92016-02-02 08:31:45 -08001406 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001407 timestamp_offset_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001408}
1409
danilchap71fead22016-08-18 02:01:49 -07001410uint32_t RTPSender::TimestampOffset() const {
tommiae695e92016-02-02 08:31:45 -08001411 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001412 return timestamp_offset_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001413}
1414
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001415void RTPSender::SetSSRC(uint32_t ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001416 // This is configured via the API.
tommiae695e92016-02-02 08:31:45 -08001417 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +00001418
nisse7d59f6b2017-02-21 03:40:24 -08001419 if (ssrc_ == ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001420 return; // Since it's same ssrc, don't reset anything.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001421 }
nisse7d59f6b2017-02-21 03:40:24 -08001422 ssrc_.emplace(ssrc);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001423 if (!sequence_number_forced_) {
danilchap47a740b2015-12-15 00:30:07 -08001424 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001425 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001426}
1427
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001428uint32_t RTPSender::SSRC() const {
tommiae695e92016-02-02 08:31:45 -08001429 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001430 RTC_DCHECK(ssrc_);
1431 return *ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001432}
1433
Amit Hilbuch77938e62018-12-21 09:23:38 -08001434void RTPSender::SetRid(const std::string& rid) {
1435 // RID is used in simulcast scenario when multiple layers share the same mid.
1436 rtc::CritScope lock(&send_critsect_);
1437 RTC_DCHECK_LE(rid.length(), RtpStreamId::kMaxValueSizeBytes);
1438 rid_ = rid;
1439}
1440
Steve Anton296a0ce2018-03-22 15:17:27 -07001441void RTPSender::SetMid(const std::string& mid) {
1442 // This is configured via the API.
1443 rtc::CritScope lock(&send_critsect_);
Steve Anton4af95842018-04-06 11:09:46 -07001444 mid_ = mid;
Steve Anton296a0ce2018-03-22 15:17:27 -07001445}
1446
Danil Chapovalovd264df52018-06-14 12:59:38 +02001447absl::optional<uint32_t> RTPSender::FlexfecSsrc() const {
Niels Möller59ab1cf2019-02-06 22:48:11 +01001448 return flexfec_ssrc_;
brandtr9dfff292016-11-14 05:14:50 -08001449}
1450
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001451void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
spranga8ae6f22017-09-04 07:23:56 -07001452 RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
tommiae695e92016-02-02 08:31:45 -08001453 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001454 csrcs_ = csrcs;
niklase@google.com470e71d2011-07-07 08:21:25 +00001455}
1456
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001457void RTPSender::SetSequenceNumber(uint16_t seq) {
tommiae695e92016-02-02 08:31:45 -08001458 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001459 sequence_number_forced_ = true;
1460 sequence_number_ = seq;
niklase@google.com470e71d2011-07-07 08:21:25 +00001461}
1462
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001463uint16_t RTPSender::SequenceNumber() const {
tommiae695e92016-02-02 08:31:45 -08001464 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001465 return sequence_number_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001466}
1467
Danil Chapovalov271195f2019-02-11 11:30:03 +01001468static void CopyHeaderAndExtensionsToRtxPacket(const RtpPacketToSend& packet,
1469 RtpPacketToSend* rtx_packet) {
Amit Hilbuch77938e62018-12-21 09:23:38 -08001470 // Set the relevant fixed packet headers. The following are not set:
1471 // * Payload type - it is replaced in rtx packets.
1472 // * Sequence number - RTX has a separate sequence numbering.
1473 // * SSRC - RTX stream has its own SSRC.
1474 rtx_packet->SetMarker(packet.Marker());
1475 rtx_packet->SetTimestamp(packet.Timestamp());
1476
1477 // Set the variable fields in the packet header:
1478 // * CSRCs - must be set before header extensions.
1479 // * Header extensions - replace Rid header with RepairedRid header.
1480 const std::vector<uint32_t> csrcs = packet.Csrcs();
1481 rtx_packet->SetCsrcs(csrcs);
1482 for (int extension = kRtpExtensionNone + 1;
1483 extension < kRtpExtensionNumberOfExtensions; ++extension) {
1484 RTPExtensionType source_extension =
1485 static_cast<RTPExtensionType>(extension);
1486 // Rid header should be replaced with RepairedRid header
1487 RTPExtensionType destination_extension =
1488 source_extension == kRtpExtensionRtpStreamId
1489 ? kRtpExtensionRepairedRtpStreamId
1490 : source_extension;
1491
1492 // Empty extensions should be supported, so not checking |source.empty()|.
1493 if (!packet.HasExtension(source_extension)) {
1494 continue;
1495 }
1496
1497 rtc::ArrayView<const uint8_t> source =
1498 packet.FindExtension(source_extension);
1499
1500 rtc::ArrayView<uint8_t> destination =
1501 rtx_packet->AllocateExtension(destination_extension, source.size());
1502
1503 // Could happen if any:
1504 // 1. Extension has 0 length.
1505 // 2. Extension is not registered in destination.
1506 // 3. Allocating extension in destination failed.
1507 if (destination.empty() || source.size() != destination.size()) {
1508 continue;
1509 }
1510
1511 std::memcpy(destination.begin(), source.begin(), destination.size());
1512 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001513}
1514
1515std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
1516 const RtpPacketToSend& packet) {
Danil Chapovalov271195f2019-02-11 11:30:03 +01001517 std::unique_ptr<RtpPacketToSend> rtx_packet;
Amit Hilbuch77938e62018-12-21 09:23:38 -08001518
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001519 // Add original RTP header.
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001520 {
1521 rtc::CritScope lock(&send_critsect_);
1522 if (!sending_media_)
1523 return nullptr;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001524
nisse7d59f6b2017-02-21 03:40:24 -08001525 RTC_DCHECK(ssrc_rtx_);
1526
brandtre6f98c72016-11-11 03:28:30 -08001527 // Replace payload type.
1528 auto kv = rtx_payload_type_map_.find(packet.PayloadType());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001529 if (kv == rtx_payload_type_map_.end())
brandtre6f98c72016-11-11 03:28:30 -08001530 return nullptr;
Danil Chapovalov271195f2019-02-11 11:30:03 +01001531
1532 rtx_packet = absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_,
1533 max_packet_size_);
1534
brandtre6f98c72016-11-11 03:28:30 -08001535 rtx_packet->SetPayloadType(kv->second);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +00001536
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001537 // Replace sequence number.
1538 rtx_packet->SetSequenceNumber(sequence_number_rtx_++);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001539
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001540 // Replace SSRC.
nisse7d59f6b2017-02-21 03:40:24 -08001541 rtx_packet->SetSsrc(*ssrc_rtx_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001542
Danil Chapovalov271195f2019-02-11 11:30:03 +01001543 CopyHeaderAndExtensionsToRtxPacket(packet, rtx_packet.get());
1544
Amit Hilbuch77938e62018-12-21 09:23:38 -08001545 // The spec indicates that it is possible for a sender to stop sending mids
1546 // once the SSRCs have been bound on the receiver. As a result the source
1547 // rtp packet might not have the MID header extension set.
1548 // However, the SSRC of the RTX stream might not have been bound on the
1549 // receiver. This means that we should include it here.
1550 // The same argument goes for the Repaired RID extension.
Steve Anton4af95842018-04-06 11:09:46 -07001551 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001552 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001553 rtx_packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001554 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001555 if (!rid_.empty()) {
1556 // This is a no-op if the Repaired-RID header extension is not registered.
1557 // rtx_packet->SetExtension<RepairedRtpStreamId>(rid_);
1558 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001559 }
Danil Chapovalov271195f2019-02-11 11:30:03 +01001560 RTC_DCHECK(rtx_packet);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001561
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001562 uint8_t* rtx_payload =
1563 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize);
Danil Chapovalov271195f2019-02-11 11:30:03 +01001564 if (rtx_payload == nullptr)
1565 return nullptr;
1566
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001567 // Add OSN (original sequence number).
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001568 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber());
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001569
1570 // Add original payload data.
danilchap96c15872016-11-21 01:35:29 -08001571 auto payload = packet.payload();
1572 memcpy(rtx_payload + kRtxHeaderSize, payload.data(), payload.size());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001573
Dino Radaković1807d572018-02-22 14:18:06 +01001574 // Add original application data.
1575 rtx_packet->set_application_data(packet.application_data());
1576
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001577 return rtx_packet;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001578}
1579
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001580void RTPSender::RegisterRtpStatisticsCallback(
1581 StreamDataCountersCallback* callback) {
danilchap7c9426c2016-04-14 03:05:31 -07001582 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001583 rtp_stats_callback_ = callback;
1584}
1585
1586StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
danilchap7c9426c2016-04-14 03:05:31 -07001587 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001588 return rtp_stats_callback_;
1589}
1590
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001591uint32_t RTPSender::BitrateSent() const {
sprangcd349d92016-07-13 09:11:28 -07001592 rtc::CritScope cs(&statistics_crit_);
1593 return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001594}
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001595
1596void RTPSender::SetRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001597 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001598 sequence_number_ = rtp_state.sequence_number;
1599 sequence_number_forced_ = true;
danilchap71fead22016-08-18 02:01:49 -07001600 timestamp_offset_ = rtp_state.start_timestamp;
danilchape5b41412016-08-22 03:39:23 -07001601 last_rtp_timestamp_ = rtp_state.timestamp;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001602 capture_time_ms_ = rtp_state.capture_time_ms;
1603 last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001604 media_has_been_sent_ = rtp_state.media_has_been_sent;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001605}
1606
1607RtpState RTPSender::GetRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001608 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001609
1610 RtpState state;
1611 state.sequence_number = sequence_number_;
danilchap71fead22016-08-18 02:01:49 -07001612 state.start_timestamp = timestamp_offset_;
danilchape5b41412016-08-22 03:39:23 -07001613 state.timestamp = last_rtp_timestamp_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001614 state.capture_time_ms = capture_time_ms_;
1615 state.last_timestamp_time_ms = last_timestamp_time_ms_;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001616 state.media_has_been_sent = media_has_been_sent_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001617
1618 return state;
1619}
1620
1621void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001622 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001623 sequence_number_rtx_ = rtp_state.sequence_number;
1624}
1625
1626RtpState RTPSender::GetRtxRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001627 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001628
1629 RtpState state;
1630 state.sequence_number = sequence_number_rtx_;
danilchap71fead22016-08-18 02:01:49 -07001631 state.start_timestamp = timestamp_offset_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001632
1633 return state;
1634}
1635
philipel8aadd502017-02-23 02:56:13 -08001636void RTPSender::AddPacketToTransportFeedback(
1637 uint16_t packet_id,
1638 const RtpPacketToSend& packet,
1639 const PacedPacketInfo& pacing_info) {
michaelt4da30442016-11-17 01:38:43 -08001640 if (transport_feedback_observer_) {
Erik Språng30a276b2019-04-23 12:00:11 +02001641 size_t packet_size = packet.payload_size() + packet.padding_size();
1642 if (send_side_bwe_with_overhead_) {
1643 packet_size = packet.size();
1644 }
1645
1646 RtpPacketSendInfo packet_info;
1647 packet_info.ssrc = SSRC();
1648 packet_info.transport_sequence_number = packet_id;
Erik Språng490d76c2019-05-07 09:29:15 -07001649 packet_info.has_rtp_sequence_number = true;
Erik Språng30a276b2019-04-23 12:00:11 +02001650 packet_info.rtp_sequence_number = packet.SequenceNumber();
1651 packet_info.length = packet_size;
1652 packet_info.pacing_info = pacing_info;
1653 transport_feedback_observer_->OnAddPacket(packet_info);
michaelt4da30442016-11-17 01:38:43 -08001654 }
1655}
1656
1657void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
1658 if (!overhead_observer_)
1659 return;
nisse284542b2017-01-10 08:58:32 -08001660 size_t overhead_bytes_per_packet;
michaelt4da30442016-11-17 01:38:43 -08001661 {
1662 rtc::CritScope lock(&send_critsect_);
1663 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
1664 return;
1665 }
1666 rtp_overhead_bytes_per_packet_ = packet.headers_size();
nisse284542b2017-01-10 08:58:32 -08001667 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
michaelt4da30442016-11-17 01:38:43 -08001668 }
1669 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
1670}
1671
sprang168794c2017-07-06 04:38:06 -07001672int64_t RTPSender::LastTimestampTimeMs() const {
1673 rtc::CritScope lock(&send_critsect_);
1674 return last_timestamp_time_ms_;
1675}
1676
Erik Språng8b101922018-01-18 11:58:05 -08001677void RTPSender::SetRtt(int64_t rtt_ms) {
1678 packet_history_.SetRtt(rtt_ms);
1679 flexfec_packet_history_.SetRtt(rtt_ms);
1680}
Erik Språng490d76c2019-05-07 09:29:15 -07001681
1682void RTPSender::OnPacketsAcknowledged(
1683 rtc::ArrayView<const uint16_t> sequence_numbers) {
1684 packet_history_.CullAcknowledgedPackets(sequence_numbers);
1685}
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001686} // namespace webrtc