blob: 62fe25c3a79d1b5a14fa80963e48eff490d5c5f5 [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
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000135bool HasBweExtension(const RtpHeaderExtensionMap& extensions_map) {
136 return extensions_map.IsRegistered(kRtpExtensionTransportSequenceNumber) ||
137 extensions_map.IsRegistered(kRtpExtensionTransportSequenceNumber02) ||
138 extensions_map.IsRegistered(kRtpExtensionAbsoluteSendTime) ||
139 extensions_map.IsRegistered(kRtpExtensionTransmissionTimeOffset);
140}
141
hclam@chromium.org806dc3b2013-04-09 19:54:10 +0000142} // namespace
143
Erik Språng4580ca22019-07-04 10:38:43 +0200144RTPSender::RTPSender(const RtpRtcp::Configuration& config)
145 : clock_(config.clock),
146 random_(clock_->TimeInMicroseconds()),
147 audio_configured_(config.audio),
148 flexfec_ssrc_(config.flexfec_sender
149 ? absl::make_optional(config.flexfec_sender->ssrc())
150 : absl::nullopt),
151 paced_sender_(config.paced_sender),
152 transport_sequence_number_allocator_(
153 config.transport_sequence_number_allocator),
154 transport_feedback_observer_(config.transport_feedback_callback),
155 transport_(config.outgoing_transport),
156 sending_media_(true), // Default to sending media.
157 force_part_of_allocation_(false),
158 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
159 last_payload_type_(-1),
160 rtp_header_extension_map_(config.extmap_allow_mixed),
161 packet_history_(clock_),
162 flexfec_packet_history_(clock_),
163 // Statistics
164 send_delays_(),
165 max_delay_it_(send_delays_.end()),
166 sum_delays_ms_(0),
167 total_packet_send_delay_ms_(0),
168 rtp_stats_callback_(nullptr),
169 total_bitrate_sent_(kBitrateStatisticsWindowMs,
170 RateStatistics::kBpsScale),
171 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
172 send_side_delay_observer_(config.send_side_delay_observer),
173 event_log_(config.event_log),
174 send_packet_observer_(config.send_packet_observer),
175 bitrate_callback_(config.send_bitrate_observer),
176 // RTP variables
177 sequence_number_forced_(false),
178 ssrc_(config.media_send_ssrc),
179 last_rtp_timestamp_(0),
180 capture_time_ms_(0),
181 last_timestamp_time_ms_(0),
182 media_has_been_sent_(false),
183 last_packet_marker_bit_(false),
184 csrcs_(),
185 rtx_(kRtxOff),
186 ssrc_rtx_(config.rtx_send_ssrc),
187 rtp_overhead_bytes_per_packet_(0),
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000188 supports_bwe_extension_(false),
Erik Språng4580ca22019-07-04 10:38:43 +0200189 retransmission_rate_limiter_(config.retransmission_rate_limiter),
190 overhead_observer_(config.overhead_observer),
191 populate_network2_timestamp_(config.populate_network2_timestamp),
192 send_side_bwe_with_overhead_(
193 IsEnabled("WebRTC-SendSideBwe-WithOverhead", config.field_trials)),
Erik Språngf6468d22019-07-05 16:53:43 +0200194 pacer_legacy_packet_referencing_(
Erik Språngc4f047d2019-07-19 13:34:11 +0200195 IsEnabled("WebRTC-Pacer-LegacyPacketReferencing",
196 config.field_trials)) {
Erik Språng4580ca22019-07-04 10:38:43 +0200197 // This random initialization is not intended to be cryptographic strong.
198 timestamp_offset_ = random_.Rand<uint32_t>();
199 // Random start, 16 bits. Can't be 0.
200 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
201 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
202
203 // Store FlexFEC packets in the packet history data structure, so they can
204 // be found when paced.
205 if (flexfec_ssrc_) {
Erik Språng4580ca22019-07-04 10:38:43 +0200206 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språngb9f59892019-07-19 13:52:13 +0200207 RtpPacketHistory::StorageMode::kStoreAndCull,
208 kMinFlexfecPacketsToStoreForPacing);
Erik Språng4580ca22019-07-04 10:38:43 +0200209 }
210}
211
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000212RTPSender::RTPSender(
213 bool audio,
214 Clock* clock,
215 Transport* transport,
Erik Språngaa59eca2019-07-24 14:52:55 +0200216 RtpPacketSender* paced_sender,
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000217 absl::optional<uint32_t> flexfec_ssrc,
218 TransportSequenceNumberAllocator* sequence_number_allocator,
219 TransportFeedbackObserver* transport_feedback_observer,
220 BitrateStatisticsObserver* bitrate_callback,
221 SendSideDelayObserver* send_side_delay_observer,
222 RtcEventLog* event_log,
223 SendPacketObserver* send_packet_observer,
224 RateLimiter* retransmission_rate_limiter,
225 OverheadObserver* overhead_observer,
226 bool populate_network2_timestamp,
227 FrameEncryptorInterface* frame_encryptor,
228 bool require_frame_encryption,
229 bool extmap_allow_mixed,
230 const WebRtcKeyValueConfig& field_trials)
231 : clock_(clock),
danilchap47a740b2015-12-15 00:30:07 -0800232 random_(clock_->TimeInMicroseconds()),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000233 audio_configured_(audio),
234 flexfec_ssrc_(flexfec_ssrc),
235 paced_sender_(paced_sender),
236 transport_sequence_number_allocator_(sequence_number_allocator),
237 transport_feedback_observer_(transport_feedback_observer),
238 transport_(transport),
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200239 sending_media_(true), // Default to sending media.
240 force_part_of_allocation_(false),
nisse284542b2017-01-10 08:58:32 -0800241 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100242 last_payload_type_(-1),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000243 rtp_header_extension_map_(extmap_allow_mixed),
244 packet_history_(clock),
245 flexfec_packet_history_(clock),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000246 // Statistics
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200247 send_delays_(),
248 max_delay_it_(send_delays_.end()),
249 sum_delays_ms_(0),
Henrik Boström9fe18342019-05-16 18:38:20 +0200250 total_packet_send_delay_ms_(0),
sprangcd349d92016-07-13 09:11:28 -0700251 rtp_stats_callback_(nullptr),
252 total_bitrate_sent_(kBitrateStatisticsWindowMs,
253 RateStatistics::kBpsScale),
254 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000255 send_side_delay_observer_(send_side_delay_observer),
256 event_log_(event_log),
257 send_packet_observer_(send_packet_observer),
258 bitrate_callback_(bitrate_callback),
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000259 // RTP variables
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000260 sequence_number_forced_(false),
danilchape5b41412016-08-22 03:39:23 -0700261 last_rtp_timestamp_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000262 capture_time_ms_(0),
263 last_timestamp_time_ms_(0),
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000264 media_has_been_sent_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000265 last_packet_marker_bit_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000266 csrcs_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000267 rtx_(kRtxOff),
michaelt4da30442016-11-17 01:38:43 -0800268 rtp_overhead_bytes_per_packet_(0),
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000269 supports_bwe_extension_(false),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000270 retransmission_rate_limiter_(retransmission_rate_limiter),
271 overhead_observer_(overhead_observer),
272 populate_network2_timestamp_(populate_network2_timestamp),
elad.alonc3dfff32017-01-26 02:46:55 -0800273 send_side_bwe_with_overhead_(
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000274 field_trials.Lookup("WebRTC-SendSideBwe-WithOverhead")
275 .find("Enabled") == 0),
Erik Språngf6468d22019-07-05 16:53:43 +0200276 pacer_legacy_packet_referencing_(
277 field_trials.Lookup("WebRTC-Pacer-LegacyPacketReferencing")
Erik Språngc4f047d2019-07-19 13:34:11 +0200278 .find("Enabled") == 0) {
danilchap71fead22016-08-18 02:01:49 -0700279 // This random initialization is not intended to be cryptographic strong.
280 timestamp_offset_ = random_.Rand<uint32_t>();
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000281 // Random start, 16 bits. Can't be 0.
danilchap47a740b2015-12-15 00:30:07 -0800282 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
283 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
brandtr9dfff292016-11-14 05:14:50 -0800284
285 // Store FlexFEC packets in the packet history data structure, so they can
286 // be found when paced.
Niels Möller59ab1cf2019-02-06 22:48:11 +0100287 if (flexfec_ssrc_) {
brandtr9dfff292016-11-14 05:14:50 -0800288 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språngb9f59892019-07-19 13:52:13 +0200289 RtpPacketHistory::StorageMode::kStoreAndCull,
290 kMinFlexfecPacketsToStoreForPacing);
brandtr9dfff292016-11-14 05:14:50 -0800291 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000292}
293
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000294RTPSender::~RTPSender() {
tommiae695e92016-02-02 08:31:45 -0800295 // TODO(tommi): Use a thread checker to ensure the object is created and
296 // deleted on the same thread. At the moment this isn't possible due to
297 // voe::ChannelOwner in voice engine. To reproduce, run:
298 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
299
300 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
301 // variables but we grab them in all other methods. (what's the design?)
302 // Start documenting what thread we're on in what method so that it's easier
303 // to understand performance attributes and possibly remove locks.
niklase@google.com470e71d2011-07-07 08:21:25 +0000304}
niklase@google.com470e71d2011-07-07 08:21:25 +0000305
erikvarga27883732017-05-17 05:08:38 -0700306rtc::ArrayView<const RtpExtensionSize> RTPSender::FecExtensionSizes() {
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +0100307 return rtc::MakeArrayView(kFecOrPaddingExtensionSizes,
308 arraysize(kFecOrPaddingExtensionSizes));
309}
310
311rtc::ArrayView<const RtpExtensionSize> RTPSender::VideoExtensionSizes() {
312 return rtc::MakeArrayView(kVideoExtensionSizes,
313 arraysize(kVideoExtensionSizes));
erikvarga27883732017-05-17 05:08:38 -0700314}
315
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000316uint16_t RTPSender::ActualSendBitrateKbit() const {
sprangcd349d92016-07-13 09:11:28 -0700317 rtc::CritScope cs(&statistics_crit_);
318 return static_cast<uint16_t>(
319 total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0) /
320 1000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000321}
322
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000323uint32_t RTPSender::NackOverheadRate() const {
sprangcd349d92016-07-13 09:11:28 -0700324 rtc::CritScope cs(&statistics_crit_);
325 return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000326}
327
Johannes Kron9190b822018-10-29 11:22:05 +0100328void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) {
329 rtc::CritScope lock(&send_critsect_);
330 rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed);
331}
332
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000333int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
334 uint8_t id) {
tommiae695e92016-02-02 08:31:45 -0800335 rtc::CritScope lock(&send_critsect_);
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000336 bool registered = rtp_header_extension_map_.RegisterByType(id, type);
337 supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
338 return registered ? 0 : -1;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000339}
340
Danil Chapovalov585d1aa2018-09-14 18:29:32 +0200341bool RTPSender::RegisterRtpHeaderExtension(const std::string& uri, int id) {
342 rtc::CritScope lock(&send_critsect_);
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000343 bool registered = rtp_header_extension_map_.RegisterByUri(id, uri);
344 supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
345 return registered;
Danil Chapovalov585d1aa2018-09-14 18:29:32 +0200346}
347
stefan53b6cc32017-02-03 08:13:57 -0800348bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) const {
tommiae695e92016-02-02 08:31:45 -0800349 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000350 return rtp_header_extension_map_.IsRegistered(type);
351}
352
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000353int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800354 rtc::CritScope lock(&send_critsect_);
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000355 int32_t deregistered = rtp_header_extension_map_.Deregister(type);
356 supports_bwe_extension_ = HasBweExtension(rtp_header_extension_map_);
357 return deregistered;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000358}
359
nisse284542b2017-01-10 08:58:32 -0800360void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
kwibergee89e782017-08-09 17:22:01 -0700361 RTC_DCHECK_GE(max_packet_size, 100);
362 RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
tommiae695e92016-02-02 08:31:45 -0800363 rtc::CritScope lock(&send_critsect_);
nisse284542b2017-01-10 08:58:32 -0800364 max_packet_size_ = max_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25 +0000365}
366
nisse284542b2017-01-10 08:58:32 -0800367size_t RTPSender::MaxRtpPacketSize() const {
368 return max_packet_size_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000369}
370
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000371void RTPSender::SetRtxStatus(int mode) {
tommiae695e92016-02-02 08:31:45 -0800372 rtc::CritScope lock(&send_critsect_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000373 rtx_ = mode;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000374}
375
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000376int RTPSender::RtxStatus() const {
tommiae695e92016-02-02 08:31:45 -0800377 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000378 return rtx_;
379}
380
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000381void RTPSender::SetRtxSsrc(uint32_t ssrc) {
tommiae695e92016-02-02 08:31:45 -0800382 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800383 ssrc_rtx_.emplace(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000384}
385
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000386uint32_t RTPSender::RtxSsrc() const {
tommiae695e92016-02-02 08:31:45 -0800387 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800388 RTC_DCHECK(ssrc_rtx_);
389 return *ssrc_rtx_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000390}
391
Shao Changbine62202f2015-04-21 20:24:50 +0800392void RTPSender::SetRtxPayloadType(int payload_type,
393 int associated_payload_type) {
tommiae695e92016-02-02 08:31:45 -0800394 rtc::CritScope lock(&send_critsect_);
henrikg91d6ede2015-09-17 00:24:34 -0700395 RTC_DCHECK_LE(payload_type, 127);
396 RTC_DCHECK_LE(associated_payload_type, 127);
Shao Changbine62202f2015-04-21 20:24:50 +0800397 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100398 RTC_LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type << ".";
Shao Changbine62202f2015-04-21 20:24:50 +0800399 return;
400 }
401
402 rtx_payload_type_map_[associated_payload_type] = payload_type;
Åsa Persson6ae25722015-04-13 17:48:08 +0200403}
404
philipela1ed0b32016-06-01 06:31:17 -0700405size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
philipel8aadd502017-02-23 02:56:13 -0800406 const PacedPacketInfo& pacing_info) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000407 {
tommiae695e92016-02-02 08:31:45 -0800408 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100409 if (!sending_media_)
410 return 0;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000411 if ((rtx_ & kRtxRedundantPayloads) == 0)
412 return 0;
413 }
414
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000415 int bytes_left = static_cast<int>(bytes_to_send);
Erik Språng214f5432019-06-20 15:09:58 +0200416 while (bytes_left >= kMinPayloadPaddingBytes) {
Erik Språng21f2fc92019-07-16 21:09:14 +0200417 std::unique_ptr<RtpPacketToSend> packet =
418 packet_history_.GetPayloadPaddingPacket();
Erik Språng4ffed7c2019-05-28 11:18:04 +0200419
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200420 if (!packet)
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000421 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200422 size_t payload_size = packet->payload_size();
philipel8aadd502017-02-23 02:56:13 -0800423 if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000424 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200425 bytes_left -= payload_size;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000426 }
427 return bytes_to_send - bytes_left;
428}
429
philipel8aadd502017-02-23 02:56:13 -0800430size_t RTPSender::SendPadData(size_t bytes,
431 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800432 size_t padding_bytes_in_packet;
erikvarga76a55932017-05-17 07:50:17 -0700433 size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
erikvarga27883732017-05-17 05:08:38 -0700434
stefan53b6cc32017-02-03 08:13:57 -0800435 if (audio_configured_) {
436 // Allow smaller padding packets for audio.
Erik Språng478cb462019-06-26 15:49:27 +0200437 padding_bytes_in_packet =
438 rtc::SafeClamp(bytes, kMinAudioPaddingLength,
439 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
stefan53b6cc32017-02-03 08:13:57 -0800440 } else {
441 // Always send full padding packets. This is accounted for by the
442 // RtpPacketSender, which will make sure we don't send too much padding even
443 // if a single packet is larger than requested.
444 // We do this to avoid frequently sending small packets on higher bitrates.
Erik Språng478cb462019-06-26 15:49:27 +0200445 padding_bytes_in_packet = rtc::SafeMin(max_payload_size, kMaxPaddingLength);
stefan53b6cc32017-02-03 08:13:57 -0800446 }
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000447 size_t bytes_sent = 0;
danilchap90069872016-12-14 06:16:33 -0800448 while (bytes_sent < bytes) {
449 int64_t now_ms = clock_->TimeInMilliseconds();
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000450 uint32_t ssrc;
danilchap90069872016-12-14 06:16:33 -0800451 uint32_t timestamp;
452 int64_t capture_time_ms;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000453 uint16_t sequence_number;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000454 int payload_type;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000455 bool over_rtx;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000456 {
tommiae695e92016-02-02 08:31:45 -0800457 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100458 if (!sending_media_)
danilchap90069872016-12-14 06:16:33 -0800459 break;
460 timestamp = last_rtp_timestamp_;
461 capture_time_ms = capture_time_ms_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000462 if (rtx_ == kRtxOff) {
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100463 if (last_payload_type_ == -1)
stefane35f89a2017-02-01 09:06:25 -0800464 break;
stefan53b6cc32017-02-03 08:13:57 -0800465 // Without RTX we can't send padding in the middle of frames.
466 // For audio marker bits doesn't mark the end of a frame and frames
467 // are usually a single packet, so for now we don't apply this rule
468 // for audio.
469 if (!audio_configured_ && !last_packet_marker_bit_) {
470 break;
471 }
nisse7d59f6b2017-02-21 03:40:24 -0800472 if (!ssrc_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100473 RTC_LOG(LS_ERROR) << "SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800474 return 0;
475 }
476
477 RTC_DCHECK(ssrc_);
478 ssrc = *ssrc_;
479
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000480 sequence_number = sequence_number_;
481 ++sequence_number_;
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100482 payload_type = last_payload_type_;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000483 over_rtx = false;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000484 } else {
Stefan Holmerf5dca482016-01-27 12:58:51 +0100485 // Without abs-send-time or transport sequence number a media packet
486 // must be sent before padding so that the timestamps used for
487 // estimation are correct.
488 if (!media_has_been_sent_ &&
danilchap90069872016-12-14 06:16:33 -0800489 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
490 (rtp_header_extension_map_.IsRegistered(
491 TransportSequenceNumber::kId) &&
492 transport_sequence_number_allocator_))) {
493 break;
Stefan Holmerf5dca482016-01-27 12:58:51 +0100494 }
Stefan Holmer586b19b2015-09-18 11:14:31 +0200495 // Only change change the timestamp of padding packets sent over RTX.
496 // Padding only packets over RTP has to be sent as part of a media
497 // frame (and therefore the same timestamp).
498 if (last_timestamp_time_ms_ > 0) {
499 timestamp +=
danilchap90069872016-12-14 06:16:33 -0800500 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
501 capture_time_ms += (now_ms - last_timestamp_time_ms_);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200502 }
nisse7d59f6b2017-02-21 03:40:24 -0800503 if (!ssrc_rtx_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100504 RTC_LOG(LS_ERROR) << "RTX SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800505 return 0;
506 }
507 RTC_DCHECK(ssrc_rtx_);
508 ssrc = *ssrc_rtx_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000509 sequence_number = sequence_number_rtx_;
510 ++sequence_number_rtx_;
Stefan Holmer10880012016-02-03 13:29:59 +0100511 payload_type = rtx_payload_type_map_.begin()->second;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000512 over_rtx = true;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000513 }
514 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000515
danilchap90069872016-12-14 06:16:33 -0800516 RtpPacketToSend padding_packet(&rtp_header_extension_map_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200517 padding_packet.SetPayloadType(payload_type);
518 padding_packet.SetMarker(false);
519 padding_packet.SetSequenceNumber(sequence_number);
520 padding_packet.SetTimestamp(timestamp);
521 padding_packet.SetSsrc(ssrc);
522
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000523 if (capture_time_ms > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200524 padding_packet.SetExtension<TransmissionOffset>(
danilchap90069872016-12-14 06:16:33 -0800525 (now_ms - capture_time_ms) * kTimestampTicksPerMs);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000526 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200527 padding_packet.SetExtension<AbsoluteSendTime>(
528 AbsoluteSendTime::MsTo24Bits(now_ms));
stefan1d8a5062015-10-02 03:39:33 -0700529 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200530 // Padding packets are never retransmissions.
531 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200532 bool has_transport_seq_num;
533 {
534 rtc::CritScope lock(&send_critsect_);
535 has_transport_seq_num =
536 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200537 options.included_in_allocation =
538 has_transport_seq_num || force_part_of_allocation_;
539 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200540 }
Danil Chapovalovf7fcaf02018-10-10 14:56:01 +0200541 padding_packet.SetPadding(padding_bytes_in_packet);
michaelt4da30442016-11-17 01:38:43 -0800542 if (has_transport_seq_num) {
543 AddPacketToTransportFeedback(options.packet_id, padding_packet,
philipel8aadd502017-02-23 02:56:13 -0800544 pacing_info);
michaelt4da30442016-11-17 01:38:43 -0800545 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200546
philipel32d00102017-02-27 02:18:46 -0800547 if (!SendPacketToNetwork(padding_packet, options, pacing_info))
stefanf116bd02015-10-27 08:29:42 -0700548 break;
549
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000550 bytes_sent += padding_bytes_in_packet;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200551 UpdateRtpStats(padding_packet, over_rtx, false);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000552 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000553
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000554 return bytes_sent;
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000555}
556
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000557void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
Erik Språngb9f59892019-07-19 13:52:13 +0200558 packet_history_.SetStorePacketsStatus(
559 enable ? RtpPacketHistory::StorageMode::kStoreAndCull
560 : RtpPacketHistory::StorageMode::kDisabled,
561 number_to_store);
niklase@google.com470e71d2011-07-07 08:21:25 +0000562}
563
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000564bool RTPSender::StorePackets() const {
Erik Språnga12b1d62018-03-14 12:39:24 +0100565 return packet_history_.GetStorageMode() !=
566 RtpPacketHistory::StorageMode::kDisabled;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000567}
niklase@google.com470e71d2011-07-07 08:21:25 +0000568
Erik Språnga12b1d62018-03-14 12:39:24 +0100569int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
570 // Try to find packet in RTP packet history. Also verify RTT here, so that we
571 // don't retransmit too often.
Danil Chapovalovd264df52018-06-14 12:59:38 +0200572 absl::optional<RtpPacketHistory::PacketState> stored_packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200573 packet_history_.GetPacketState(packet_id);
Erik Språng0f4f0552019-05-08 10:15:05 -0700574 if (!stored_packet || stored_packet->pending_transmission) {
575 // Packet not found or already queued for retransmission, ignore.
asapersson@webrtc.org83ed0a42012-04-23 12:43:05 +0000576 return 0;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000577 }
Oleh Prypin5a980492018-03-09 12:27:24 +0000578
Per Kjellander252725d2019-02-20 13:14:34 +0100579 const int32_t packet_size = static_cast<int32_t>(stored_packet->packet_size);
Erik Språngf6468d22019-07-05 16:53:43 +0200580 const bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
Erik Språng7bb37b82018-03-09 09:52:59 +0100581
Oleh Prypin5a980492018-03-09 12:27:24 +0000582 if (paced_sender_) {
Erik Språngf6468d22019-07-05 16:53:43 +0200583 if (pacer_legacy_packet_referencing_) {
584 // Check if we're overusing retransmission bitrate.
585 // TODO(sprang): Add histograms for nack success or failure reasons.
586 if (retransmission_rate_limiter_ &&
587 !retransmission_rate_limiter_->TryUseRate(packet_size)) {
588 return -1;
589 }
590
591 // Mark packet as being in pacer queue again, to prevent duplicates.
592 if (!packet_history_.SetPendingTransmission(packet_id)) {
593 // Packet has already been removed from history, return early.
594 return 0;
595 }
596
597 paced_sender_->InsertPacket(
598 RtpPacketSender::kNormalPriority, stored_packet->ssrc,
599 stored_packet->rtp_sequence_number, stored_packet->capture_time_ms,
600 stored_packet->packet_size, true);
601 } else {
602 std::unique_ptr<RtpPacketToSend> packet =
603 packet_history_.GetPacketAndMarkAsPending(
604 packet_id, [&](const RtpPacketToSend& stored_packet) {
605 // Check if we're overusing retransmission bitrate.
606 // TODO(sprang): Add histograms for nack success or failure
607 // reasons.
608 std::unique_ptr<RtpPacketToSend> retransmit_packet;
609 if (retransmission_rate_limiter_ &&
610 !retransmission_rate_limiter_->TryUseRate(packet_size)) {
611 return retransmit_packet;
612 }
613 if (rtx) {
614 retransmit_packet = BuildRtxPacket(stored_packet);
615 } else {
616 retransmit_packet =
617 absl::make_unique<RtpPacketToSend>(stored_packet);
618 }
619 retransmit_packet->set_retransmitted_sequence_number(
620 stored_packet.SequenceNumber());
621 return retransmit_packet;
622 });
623 if (!packet) {
624 return -1;
625 }
626 packet->set_packet_type(RtpPacketToSend::Type::kRetransmission);
627 paced_sender_->EnqueuePacket(std::move(packet));
Erik Språng0f4f0552019-05-08 10:15:05 -0700628 }
629
Erik Språnga12b1d62018-03-14 12:39:24 +0100630 return packet_size;
Oleh Prypin5a980492018-03-09 12:27:24 +0000631 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100632
Erik Språngf6468d22019-07-05 16:53:43 +0200633 // TODO(sprang): Replace this whole code-path with a pass-through pacer.
634 // Check if we're overusing retransmission bitrate.
635 // TODO(sprang): Add histograms for nack success or failure reasons.
636 if (retransmission_rate_limiter_ &&
637 !retransmission_rate_limiter_->TryUseRate(packet_size)) {
638 return -1;
639 }
640
Erik Språnga12b1d62018-03-14 12:39:24 +0100641 std::unique_ptr<RtpPacketToSend> packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200642 packet_history_.GetPacketAndSetSendTime(packet_id);
Erik Språnga12b1d62018-03-14 12:39:24 +0100643 if (!packet) {
644 // Packet could theoretically time out between the first check and this one.
645 return 0;
646 }
647
philipel8aadd502017-02-23 02:56:13 -0800648 if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
sprang867fb522015-08-03 04:38:41 -0700649 return -1;
Erik Språnga12b1d62018-03-14 12:39:24 +0100650
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200651 return packet_size;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000652}
653
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200654bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
philipel32d00102017-02-27 02:18:46 -0800655 const PacketOptions& options,
656 const PacedPacketInfo& pacing_info) {
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000657 int bytes_sent = -1;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000658 if (transport_) {
michaelt4da30442016-11-17 01:38:43 -0800659 UpdateRtpOverhead(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200660 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
661 ? static_cast<int>(packet.size())
stefan1d8a5062015-10-02 03:39:33 -0700662 : -1;
terelius429c3452016-01-21 05:42:04 -0800663 if (event_log_ && bytes_sent > 0) {
Karl Wiberg918f50c2018-07-05 11:40:33 +0200664 event_log_->Log(absl::make_unique<RtcEventRtpPacketOutgoing>(
Elad Alon4a87e1c2017-10-03 16:11:34 +0200665 packet, pacing_info.probe_cluster_id));
terelius429c3452016-01-21 05:42:04 -0800666 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000667 }
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000668 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000669 if (bytes_sent <= 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100670 RTC_LOG(LS_WARNING) << "Transport failed to send packet.";
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000671 return false;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000672 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000673 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000674}
675
Danil Chapovalov2800d742016-08-26 18:48:46 +0200676void RTPSender::OnReceivedNack(
677 const std::vector<uint16_t>& nack_sequence_numbers,
678 int64_t avg_rtt) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100679 packet_history_.SetRtt(5 + avg_rtt);
sprangcd349d92016-07-13 09:11:28 -0700680 for (uint16_t seq_no : nack_sequence_numbers) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100681 const int32_t bytes_sent = ReSendPacket(seq_no);
sprangcd349d92016-07-13 09:11:28 -0700682 if (bytes_sent < 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000683 // Failed to send one Sequence number. Give up the rest in this nack.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100684 RTC_LOG(LS_WARNING) << "Failed resending RTP packet " << seq_no
685 << ", Discard rest of packets.";
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000686 break;
niklase@google.com470e71d2011-07-07 08:21:25 +0000687 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000688 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000689}
690
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000691// Called from pacer when we can send the packet.
Erik Språngd2879622019-05-10 08:29:01 -0700692RtpPacketSendResult RTPSender::TimeToSendPacket(
693 uint32_t ssrc,
694 uint16_t sequence_number,
695 int64_t capture_time_ms,
696 bool retransmission,
697 const PacedPacketInfo& pacing_info) {
698 if (!SendingMedia()) {
699 return RtpPacketSendResult::kPacketNotFound;
700 }
brandtr9dfff292016-11-14 05:14:50 -0800701
702 std::unique_ptr<RtpPacketToSend> packet;
703 if (ssrc == SSRC()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200704 packet = packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800705 } else if (ssrc == FlexfecSsrc()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200706 packet = flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800707 }
708
Stefan Holmera246cfb2016-08-23 17:51:42 +0200709 if (!packet) {
Erik Språngd2879622019-05-10 08:29:01 -0700710 // Packet cannot be found or was resent too recently.
711 return RtpPacketSendResult::kPacketNotFound;
Stefan Holmera246cfb2016-08-23 17:51:42 +0200712 }
asapersson35151f32016-05-02 23:44:01 -0700713
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200714 return PrepareAndSendPacket(
Erik Språngd2879622019-05-10 08:29:01 -0700715 std::move(packet),
716 retransmission && (RtxStatus() & kRtxRetransmitted) > 0,
717 retransmission, pacing_info)
718 ? RtpPacketSendResult::kSuccess
719 : RtpPacketSendResult::kTransportUnavailable;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000720}
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000721
Erik Språng9c771c22019-06-17 16:31:53 +0200722// Called from pacer when we can send the packet.
723bool RTPSender::TrySendPacket(RtpPacketToSend* packet,
724 const PacedPacketInfo& pacing_info) {
725 RTC_DCHECK(packet);
726
727 const uint32_t packet_ssrc = packet->Ssrc();
728 const auto packet_type = packet->packet_type();
729 RTC_DCHECK(packet_type.has_value());
730
731 PacketOptions options;
732 bool is_media = false;
733 bool is_rtx = false;
734 {
735 rtc::CritScope lock(&send_critsect_);
736 if (!sending_media_) {
737 return false;
738 }
739
740 switch (*packet_type) {
741 case RtpPacketToSend::Type::kAudio:
742 case RtpPacketToSend::Type::kVideo:
743 if (packet_ssrc != ssrc_) {
744 return false;
745 }
746 is_media = true;
747 break;
748 case RtpPacketToSend::Type::kRetransmission:
749 case RtpPacketToSend::Type::kPadding:
750 // Both padding and retransmission must be on either the media or the
751 // RTX stream.
752 if (packet_ssrc == ssrc_rtx_) {
753 is_rtx = true;
754 } else if (packet_ssrc != ssrc_) {
755 return false;
756 }
757 break;
758 case RtpPacketToSend::Type::kForwardErrorCorrection:
759 // FlexFEC is on separate SSRC, ULPFEC uses media SSRC.
760 if (packet_ssrc != ssrc_ && packet_ssrc != flexfec_ssrc_) {
761 return false;
762 }
763 break;
764 }
765
766 options.included_in_allocation = force_part_of_allocation_;
767 }
768
769 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
770 // the pacer, these modifications of the header below are happening after the
771 // FEC protection packets are calculated. This will corrupt recovered packets
772 // at the same place. It's not an issue for extensions, which are present in
773 // all the packets (their content just may be incorrect on recovered packets).
774 // In case of VideoTimingExtension, since it's present not in every packet,
775 // data after rtp header may be corrupted if these packets are protected by
776 // the FEC.
777 int64_t now_ms = clock_->TimeInMilliseconds();
778 int64_t diff_ms = now_ms - packet->capture_time_ms();
Erik Språng0f6191d2019-07-15 20:33:40 +0200779 if (packet->IsExtensionReserved<TransmissionOffset>()) {
780 packet->SetExtension<TransmissionOffset>(kTimestampTicksPerMs * diff_ms);
781 }
782 if (packet->IsExtensionReserved<AbsoluteSendTime>()) {
783 packet->SetExtension<AbsoluteSendTime>(
784 AbsoluteSendTime::MsTo24Bits(now_ms));
785 }
Erik Språng9c771c22019-06-17 16:31:53 +0200786
787 if (packet->HasExtension<VideoTimingExtension>()) {
788 if (populate_network2_timestamp_) {
789 packet->set_network2_time_ms(now_ms);
790 } else {
791 packet->set_pacer_exit_time_ms(now_ms);
792 }
793 }
794
795 // Downstream code actually uses this flag to distinguish between media and
796 // everything else.
797 options.is_retransmit = !is_media;
798 if (auto packet_id = packet->GetExtension<TransportSequenceNumber>()) {
799 options.packet_id = *packet_id;
800 options.included_in_feedback = true;
801 options.included_in_allocation = true;
802 AddPacketToTransportFeedback(*packet_id, *packet, pacing_info);
803 }
804
805 options.application_data.assign(packet->application_data().begin(),
806 packet->application_data().end());
807
808 if (packet->packet_type() != RtpPacketToSend::Type::kPadding &&
809 packet->packet_type() != RtpPacketToSend::Type::kRetransmission) {
810 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet_ssrc);
811 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
812 packet_ssrc);
813 }
814
815 const bool send_success = SendPacketToNetwork(*packet, options, pacing_info);
816
817 // Put packet in retransmission history or update pending status even if
818 // actual sending fails.
819 if (is_media && packet->allow_retransmission()) {
820 packet_history_.PutRtpPacket(absl::make_unique<RtpPacketToSend>(*packet),
821 StorageType::kAllowRetransmission, now_ms);
822 } else if (packet->retransmitted_sequence_number()) {
823 packet_history_.MarkPacketAsSent(*packet->retransmitted_sequence_number());
824 }
825
826 if (send_success) {
827 UpdateRtpStats(*packet, is_rtx,
828 packet_type == RtpPacketToSend::Type::kRetransmission);
829
830 rtc::CritScope lock(&send_critsect_);
831 media_has_been_sent_ = true;
832 }
833
834 // Return true even if transport failed (will be handled by retransmissions
835 // instead in that case), so that PacketRouter does not have to iterate over
836 // all other RTP modules and fail to send there too.
837 return true;
838}
839
Mirko Bonadei999a72a2019-07-12 17:33:46 +0000840bool RTPSender::SupportsPadding() const {
841 rtc::CritScope lock(&send_critsect_);
842 return sending_media_ && supports_bwe_extension_;
843}
844
845bool RTPSender::SupportsRtxPayloadPadding() const {
846 rtc::CritScope lock(&send_critsect_);
847 return sending_media_ && supports_bwe_extension_ &&
848 (rtx_ & kRtxRedundantPayloads);
849}
850
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200851bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000852 bool send_over_rtx,
philipela1ed0b32016-06-01 06:31:17 -0700853 bool is_retransmit,
philipel8aadd502017-02-23 02:56:13 -0800854 const PacedPacketInfo& pacing_info) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200855 RTC_DCHECK(packet);
856 int64_t capture_time_ms = packet->capture_time_ms();
857 RtpPacketToSend* packet_to_send = packet.get();
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000858
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200859 std::unique_ptr<RtpPacketToSend> packet_rtx;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000860 if (send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200861 packet_rtx = BuildRtxPacket(*packet);
862 if (!packet_rtx)
danilchap32cd2c42016-08-01 06:58:34 -0700863 return false;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200864 packet_to_send = packet_rtx.get();
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000865 }
866
ilnik10894992017-06-21 08:23:19 -0700867 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
868 // the pacer, these modifications of the header below are happening after the
869 // FEC protection packets are calculated. This will corrupt recovered packets
870 // at the same place. It's not an issue for extensions, which are present in
871 // all the packets (their content just may be incorrect on recovered packets).
872 // In case of VideoTimingExtension, since it's present not in every packet,
873 // data after rtp header may be corrupted if these packets are protected by
874 // the FEC.
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000875 int64_t now_ms = clock_->TimeInMilliseconds();
876 int64_t diff_ms = now_ms - capture_time_ms;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200877 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
878 diff_ms);
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200879 packet_to_send->SetExtension<AbsoluteSendTime>(
880 AbsoluteSendTime::MsTo24Bits(now_ms));
sprang867fb522015-08-03 04:38:41 -0700881
Erik Språng7b52f102018-02-07 14:37:37 +0100882 if (packet_to_send->HasExtension<VideoTimingExtension>()) {
883 if (populate_network2_timestamp_) {
884 packet_to_send->set_network2_time_ms(now_ms);
885 } else {
886 packet_to_send->set_pacer_exit_time_ms(now_ms);
887 }
888 }
ilnik04f4d122017-06-19 07:18:55 -0700889
stefan1d8a5062015-10-02 03:39:33 -0700890 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200891 // If we are sending over RTX, it also means this is a retransmission.
892 // E.g. RTPSender::TrySendRedundantPayloads calls PrepareAndSendPacket with
893 // send_over_rtx = true but is_retransmit = false.
894 options.is_retransmit = is_retransmit || send_over_rtx;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200895 bool has_transport_seq_num;
896 {
897 rtc::CritScope lock(&send_critsect_);
898 has_transport_seq_num =
899 UpdateTransportSequenceNumber(packet_to_send, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200900 options.included_in_allocation =
901 has_transport_seq_num || force_part_of_allocation_;
902 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200903 }
904 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -0800905 AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
philipel8aadd502017-02-23 02:56:13 -0800906 pacing_info);
sprang867fb522015-08-03 04:38:41 -0700907 }
Dino Radaković1807d572018-02-22 14:18:06 +0100908 options.application_data.assign(packet_to_send->application_data().begin(),
909 packet_to_send->application_data().end());
sprang867fb522015-08-03 04:38:41 -0700910
asapersson35151f32016-05-02 23:44:01 -0700911 if (!is_retransmit && !send_over_rtx) {
Erik Språng9c771c22019-06-17 16:31:53 +0200912 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet->Ssrc());
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200913 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
914 packet->Ssrc());
stefanf116bd02015-10-27 08:29:42 -0700915 }
916
philipel32d00102017-02-27 02:18:46 -0800917 if (!SendPacketToNetwork(*packet_to_send, options, pacing_info))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200918 return false;
919
920 {
tommiae695e92016-02-02 08:31:45 -0800921 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000922 media_has_been_sent_ = true;
923 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200924 UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit);
925 return true;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000926}
927
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200928void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet,
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000929 bool is_rtx,
930 bool is_retransmit) {
sprangcd349d92016-07-13 09:11:28 -0700931 int64_t now_ms = clock_->TimeInMilliseconds();
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000932
danilchap7c9426c2016-04-14 03:05:31 -0700933 rtc::CritScope lock(&statistics_crit_);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200934 StreamDataCounters* counters = is_rtx ? &rtx_rtp_stats_ : &rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000935
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200936 total_bitrate_sent_.Update(packet.size(), now_ms);
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000937
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200938 if (counters->first_packet_time_ms == -1)
939 counters->first_packet_time_ms = now_ms;
940
Erik Språngf53cfa92019-06-12 13:58:17 +0200941 if (packet.packet_type() == RtpPacketToSend::Type::kForwardErrorCorrection) {
Niels Möllerdbb988b2018-11-15 08:05:16 +0100942 counters->fec.AddPacket(packet);
Erik Språngf53cfa92019-06-12 13:58:17 +0200943 }
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200944
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200945 if (is_retransmit) {
Niels Möllerdbb988b2018-11-15 08:05:16 +0100946 counters->retransmitted.AddPacket(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200947 nack_bitrate_sent_.Update(packet.size(), now_ms);
948 }
Niels Möllerdbb988b2018-11-15 08:05:16 +0100949 counters->transmitted.AddPacket(packet);
sprangcd349d92016-07-13 09:11:28 -0700950
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200951 if (rtp_stats_callback_)
952 rtp_stats_callback_->DataCountersUpdated(*counters, packet.Ssrc());
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000953}
954
philipel8aadd502017-02-23 02:56:13 -0800955size_t RTPSender::TimeToSendPadding(size_t bytes,
956 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800957 if (bytes == 0)
pbos545727e2015-07-01 06:31:06 -0700958 return 0;
philipel8aadd502017-02-23 02:56:13 -0800959 size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000960 if (bytes_sent < bytes)
philipel8aadd502017-02-23 02:56:13 -0800961 bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000962 return bytes_sent;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000963}
964
Erik Språngf6468d22019-07-05 16:53:43 +0200965std::vector<std::unique_ptr<RtpPacketToSend>> RTPSender::GeneratePadding(
966 size_t target_size_bytes) {
Erik Språng478cb462019-06-26 15:49:27 +0200967 // This method does not actually send packets, it just generates
968 // them and puts them in the pacer queue. Since this should incur
969 // low overhead, keep the lock for the scope of the method in order
970 // to make the code more readable.
Erik Språng478cb462019-06-26 15:49:27 +0200971
Erik Språngf6468d22019-07-05 16:53:43 +0200972 std::vector<std::unique_ptr<RtpPacketToSend>> padding_packets;
Erik Språng478cb462019-06-26 15:49:27 +0200973 size_t bytes_left = target_size_bytes;
Erik Språng0f6191d2019-07-15 20:33:40 +0200974 if (SupportsRtxPayloadPadding()) {
Mirko Bonadeia7e3bce2019-07-12 17:35:56 +0000975 while (bytes_left >= kMinPayloadPaddingBytes) {
Erik Språng478cb462019-06-26 15:49:27 +0200976 std::unique_ptr<RtpPacketToSend> packet =
977 packet_history_.GetPayloadPaddingPacket(
978 [&](const RtpPacketToSend& packet)
979 -> std::unique_ptr<RtpPacketToSend> {
Erik Språng478cb462019-06-26 15:49:27 +0200980 return BuildRtxPacket(packet);
981 });
982 if (!packet) {
983 break;
984 }
985
986 bytes_left -= std::min(bytes_left, packet->payload_size());
987 packet->set_packet_type(RtpPacketToSend::Type::kPadding);
Erik Språngf6468d22019-07-05 16:53:43 +0200988 padding_packets.push_back(std::move(packet));
Erik Språng478cb462019-06-26 15:49:27 +0200989 }
990 }
991
Erik Språng0f6191d2019-07-15 20:33:40 +0200992 rtc::CritScope lock(&send_critsect_);
993 if (!sending_media_) {
994 return {};
995 }
996
Erik Språng478cb462019-06-26 15:49:27 +0200997 size_t padding_bytes_in_packet;
998 const size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
999 if (audio_configured_) {
1000 // Allow smaller padding packets for audio.
1001 padding_bytes_in_packet = rtc::SafeClamp<size_t>(
1002 bytes_left, kMinAudioPaddingLength,
1003 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
1004 } else {
1005 // Always send full padding packets. This is accounted for by the
1006 // RtpPacketSender, which will make sure we don't send too much padding even
1007 // if a single packet is larger than requested.
1008 // We do this to avoid frequently sending small packets on higher bitrates.
1009 padding_bytes_in_packet = rtc::SafeMin(max_payload_size, kMaxPaddingLength);
1010 }
1011
1012 while (bytes_left > 0) {
1013 auto padding_packet =
1014 absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_);
1015 padding_packet->set_packet_type(RtpPacketToSend::Type::kPadding);
1016 padding_packet->SetMarker(false);
1017 padding_packet->SetTimestamp(last_rtp_timestamp_);
1018 padding_packet->set_capture_time_ms(capture_time_ms_);
1019 if (rtx_ == kRtxOff) {
1020 if (last_payload_type_ == -1) {
1021 break;
1022 }
1023 // Without RTX we can't send padding in the middle of frames.
1024 // For audio marker bits doesn't mark the end of a frame and frames
1025 // are usually a single packet, so for now we don't apply this rule
1026 // for audio.
1027 if (!audio_configured_ && !last_packet_marker_bit_) {
1028 break;
1029 }
1030
1031 RTC_DCHECK(ssrc_);
1032 padding_packet->SetSsrc(*ssrc_);
1033 padding_packet->SetPayloadType(last_payload_type_);
1034 padding_packet->SetSequenceNumber(sequence_number_++);
1035 } else {
1036 // Without abs-send-time or transport sequence number a media packet
1037 // must be sent before padding so that the timestamps used for
1038 // estimation are correct.
1039 if (!media_has_been_sent_ &&
1040 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
1041 rtp_header_extension_map_.IsRegistered(
1042 TransportSequenceNumber::kId))) {
1043 break;
1044 }
1045 // Only change the timestamp of padding packets sent over RTX.
1046 // Padding only packets over RTP has to be sent as part of a media
1047 // frame (and therefore the same timestamp).
1048 int64_t now_ms = clock_->TimeInMilliseconds();
1049 if (last_timestamp_time_ms_ > 0) {
1050 padding_packet->SetTimestamp(padding_packet->Timestamp() +
1051 (now_ms - last_timestamp_time_ms_) *
1052 kTimestampTicksPerMs);
1053 padding_packet->set_capture_time_ms(padding_packet->capture_time_ms() +
1054 (now_ms - last_timestamp_time_ms_));
1055 }
1056 RTC_DCHECK(ssrc_rtx_);
1057 padding_packet->SetSsrc(*ssrc_rtx_);
1058 padding_packet->SetSequenceNumber(sequence_number_rtx_++);
1059 padding_packet->SetPayloadType(rtx_payload_type_map_.begin()->second);
1060 }
1061
Erik Språngf6468d22019-07-05 16:53:43 +02001062 if (rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId)) {
1063 padding_packet->ReserveExtension<TransportSequenceNumber>();
1064 }
Erik Språng0f6191d2019-07-15 20:33:40 +02001065 if (rtp_header_extension_map_.IsRegistered(TransmissionOffset::kId)) {
1066 padding_packet->ReserveExtension<TransmissionOffset>();
1067 }
1068 if (rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId)) {
1069 padding_packet->ReserveExtension<AbsoluteSendTime>();
1070 }
1071
Erik Språng478cb462019-06-26 15:49:27 +02001072 padding_packet->SetPadding(padding_bytes_in_packet);
1073 bytes_left -= std::min(bytes_left, padding_bytes_in_packet);
Erik Språngf6468d22019-07-05 16:53:43 +02001074 padding_packets.push_back(std::move(padding_packet));
Erik Språng478cb462019-06-26 15:49:27 +02001075 }
Erik Språngf6468d22019-07-05 16:53:43 +02001076
1077 return padding_packets;
Erik Språng478cb462019-06-26 15:49:27 +02001078}
1079
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001080bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
Erik Språng13eb7642019-06-24 10:58:48 +02001081 StorageType storage) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001082 RTC_DCHECK(packet);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001083 int64_t now_ms = clock_->TimeInMilliseconds();
1084
brandtr9dfff292016-11-14 05:14:50 -08001085 uint32_t ssrc = packet->Ssrc();
Peter Boströme23e7372015-10-08 11:44:14 +02001086 if (paced_sender_) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001087 uint16_t seq_no = packet->SequenceNumber();
Erik Språng83afeeb2019-05-14 15:57:19 +02001088 int64_t capture_time_ms = packet->capture_time_ms();
Per Kjellander17c147c2019-02-20 12:06:17 +01001089 size_t packet_size =
1090 send_side_bwe_with_overhead_ ? packet->size() : packet->payload_size();
Erik Språng13eb7642019-06-24 10:58:48 +02001091 auto packet_type = packet->packet_type();
Erik Språngf6468d22019-07-05 16:53:43 +02001092 RTC_CHECK(packet_type) << "Packet type must be set before sending.";
1093
Erik Språnga57711c2019-07-24 10:47:20 +02001094 if (packet->capture_time_ms() <= 0) {
1095 packet->set_capture_time_ms(now_ms);
1096 }
1097
Erik Språngf6468d22019-07-05 16:53:43 +02001098 if (pacer_legacy_packet_referencing_) {
1099 // If |pacer_reference_packets_| then pacer needs to find the packet in
1100 // the history when it is time to send, so move packet there.
1101 if (ssrc == FlexfecSsrc()) {
1102 // Store FlexFEC packets in a separate history since they are on a
1103 // separate SSRC.
1104 flexfec_packet_history_.PutRtpPacket(std::move(packet), storage,
1105 absl::nullopt);
1106 } else {
1107 packet_history_.PutRtpPacket(std::move(packet), storage, absl::nullopt);
1108 }
1109
1110 paced_sender_->InsertPacket(PacketTypeToPriority(*packet_type), ssrc,
1111 seq_no, capture_time_ms, packet_size, false);
brandtr9dfff292016-11-14 05:14:50 -08001112 } else {
Erik Språngf6468d22019-07-05 16:53:43 +02001113 packet->set_allow_retransmission(storage ==
1114 StorageType::kAllowRetransmission);
1115 paced_sender_->EnqueuePacket(std::move(packet));
brandtr9dfff292016-11-14 05:14:50 -08001116 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001117
Sergey Ulanov525df3f2016-08-02 17:46:41 -07001118 return true;
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +00001119 }
Stefan Holmerf5dca482016-01-27 12:58:51 +01001120
1121 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +02001122 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001123
Danil Chapovalovaf52b682018-11-27 10:48:27 +01001124 // |capture_time_ms| <= 0 is considered invalid.
1125 // TODO(holmer): This should be changed all over Video Engine so that negative
1126 // time is consider invalid, while 0 is considered a valid time.
1127 if (packet->capture_time_ms() > 0) {
1128 packet->SetExtension<TransmissionOffset>(
1129 kTimestampTicksPerMs * (now_ms - packet->capture_time_ms()));
1130
1131 if (populate_network2_timestamp_ &&
1132 packet->HasExtension<VideoTimingExtension>()) {
1133 packet->set_network2_time_ms(now_ms);
1134 }
1135 }
1136 packet->SetExtension<AbsoluteSendTime>(AbsoluteSendTime::MsTo24Bits(now_ms));
1137
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001138 bool has_transport_seq_num;
1139 {
1140 rtc::CritScope lock(&send_critsect_);
1141 has_transport_seq_num =
1142 UpdateTransportSequenceNumber(packet.get(), &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +02001143 options.included_in_allocation =
1144 has_transport_seq_num || force_part_of_allocation_;
1145 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001146 }
1147 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -08001148 AddPacketToTransportFeedback(options.packet_id, *packet.get(),
philipel8aadd502017-02-23 02:56:13 -08001149 PacedPacketInfo());
Stefan Holmerf5dca482016-01-27 12:58:51 +01001150 }
Dino Radaković1807d572018-02-22 14:18:06 +01001151 options.application_data.assign(packet->application_data().begin(),
1152 packet->application_data().end());
Stefan Holmerf5dca482016-01-27 12:58:51 +01001153
Erik Språng9c771c22019-06-17 16:31:53 +02001154 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet->Ssrc());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001155 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
1156 packet->Ssrc());
1157
philipel32d00102017-02-27 02:18:46 -08001158 bool sent = SendPacketToNetwork(*packet, options, PacedPacketInfo());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001159
1160 if (sent) {
1161 {
1162 rtc::CritScope lock(&send_critsect_);
1163 media_has_been_sent_ = true;
1164 }
1165 UpdateRtpStats(*packet, false, false);
1166 }
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +00001167
brandtr9dfff292016-11-14 05:14:50 -08001168 // To support retransmissions, we store the media packet as sent in the
1169 // packet history (even if send failed).
1170 if (storage == kAllowRetransmission) {
Danil Chapovalov603ce982017-12-27 11:32:50 +01001171 RTC_DCHECK_EQ(ssrc, SSRC());
Erik Språnga12b1d62018-03-14 12:39:24 +01001172 packet_history_.PutRtpPacket(std::move(packet), storage, now_ms);
brandtr9dfff292016-11-14 05:14:50 -08001173 }
Peter Boströme23e7372015-10-08 11:44:14 +02001174
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001175 return sent;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +00001176}
1177
Erik Språng13eb7642019-06-24 10:58:48 +02001178bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
1179 StorageType storage,
1180 RtpPacketSender::Priority priority) {
1181 packet->set_packet_type(PacketPriorityToType(priority));
1182 return SendToNetwork(std::move(packet), storage);
1183}
1184
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001185void RTPSender::RecomputeMaxSendDelay() {
1186 max_delay_it_ = send_delays_.begin();
1187 for (auto it = send_delays_.begin(); it != send_delays_.end(); ++it) {
1188 if (it->second >= max_delay_it_->second) {
1189 max_delay_it_ = it;
1190 }
1191 }
1192}
1193
Erik Språng9c771c22019-06-17 16:31:53 +02001194void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms,
1195 int64_t now_ms,
1196 uint32_t ssrc) {
asapersson35151f32016-05-02 23:44:01 -07001197 if (!send_side_delay_observer_ || capture_time_ms <= 0)
Peter Boström71861a02015-05-28 14:45:36 +02001198 return;
1199
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001200 int avg_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001201 int max_delay_ms = 0;
Henrik Boström9fe18342019-05-16 18:38:20 +02001202 uint64_t total_packet_send_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001203 {
danilchap7c9426c2016-04-14 03:05:31 -07001204 rtc::CritScope cs(&statistics_crit_);
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001205 // Compute the max and average of the recent capture-to-send delays.
1206 // The time complexity of the current approach depends on the distribution
1207 // of the delay values. This could be done more efficiently.
1208
1209 // Remove elements older than kSendSideDelayWindowMs.
1210 auto lower_bound =
1211 send_delays_.lower_bound(now_ms - kSendSideDelayWindowMs);
1212 for (auto it = send_delays_.begin(); it != lower_bound; ++it) {
1213 if (max_delay_it_ == it) {
1214 max_delay_it_ = send_delays_.end();
1215 }
1216 sum_delays_ms_ -= it->second;
1217 }
1218 send_delays_.erase(send_delays_.begin(), lower_bound);
1219 if (max_delay_it_ == send_delays_.end()) {
1220 // Removed the previous max. Need to recompute.
1221 RecomputeMaxSendDelay();
1222 }
1223
1224 // Add the new element.
Johannes Kron965e7942018-09-13 15:36:20 +02001225 RTC_DCHECK_GE(now_ms, static_cast<int64_t>(0));
1226 RTC_DCHECK_LE(now_ms, std::numeric_limits<int64_t>::max() / 2);
1227 RTC_DCHECK_GE(capture_time_ms, static_cast<int64_t>(0));
1228 RTC_DCHECK_LE(capture_time_ms, std::numeric_limits<int64_t>::max() / 2);
1229 int64_t diff_ms = now_ms - capture_time_ms;
1230 RTC_DCHECK_GE(diff_ms, static_cast<int64_t>(0));
1231 RTC_DCHECK_LE(diff_ms,
1232 static_cast<int64_t>(std::numeric_limits<int>::max()));
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001233 int new_send_delay = rtc::dchecked_cast<int>(now_ms - capture_time_ms);
1234 SendDelayMap::iterator it;
1235 bool inserted;
1236 std::tie(it, inserted) =
1237 send_delays_.insert(std::make_pair(now_ms, new_send_delay));
1238 if (!inserted) {
1239 // TODO(terelius): If we have multiple delay measurements during the same
1240 // millisecond then we keep the most recent one. It is not clear that this
1241 // is the right decision, but it preserves an earlier behavior.
1242 int previous_send_delay = it->second;
1243 sum_delays_ms_ -= previous_send_delay;
1244 it->second = new_send_delay;
1245 if (max_delay_it_ == it && new_send_delay < previous_send_delay) {
1246 RecomputeMaxSendDelay();
1247 }
Peter Boström71861a02015-05-28 14:45:36 +02001248 }
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001249 if (max_delay_it_ == send_delays_.end() ||
1250 it->second >= max_delay_it_->second) {
1251 max_delay_it_ = it;
1252 }
1253 sum_delays_ms_ += new_send_delay;
Henrik Boström9fe18342019-05-16 18:38:20 +02001254 total_packet_send_delay_ms_ += new_send_delay;
1255 total_packet_send_delay_ms = total_packet_send_delay_ms_;
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001256
1257 size_t num_delays = send_delays_.size();
1258 RTC_DCHECK(max_delay_it_ != send_delays_.end());
1259 max_delay_ms = rtc::dchecked_cast<int>(max_delay_it_->second);
1260 int64_t avg_ms = (sum_delays_ms_ + num_delays / 2) / num_delays;
1261 RTC_DCHECK_GE(avg_ms, static_cast<int64_t>(0));
1262 RTC_DCHECK_LE(avg_ms,
1263 static_cast<int64_t>(std::numeric_limits<int>::max()));
1264 avg_delay_ms =
1265 rtc::dchecked_cast<int>((sum_delays_ms_ + num_delays / 2) / num_delays);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001266 }
Henrik Boström9fe18342019-05-16 18:38:20 +02001267 send_side_delay_observer_->SendSideDelayUpdated(
1268 avg_delay_ms, max_delay_ms, total_packet_send_delay_ms, ssrc);
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001269}
1270
asapersson35151f32016-05-02 23:44:01 -07001271void RTPSender::UpdateOnSendPacket(int packet_id,
1272 int64_t capture_time_ms,
1273 uint32_t ssrc) {
1274 if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
1275 return;
1276
1277 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
1278}
1279
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001280void RTPSender::ProcessBitrate() {
sprangcd349d92016-07-13 09:11:28 -07001281 if (!bitrate_callback_)
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001282 return;
sprangcd349d92016-07-13 09:11:28 -07001283 int64_t now_ms = clock_->TimeInMilliseconds();
1284 uint32_t ssrc;
1285 {
1286 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001287 if (!ssrc_)
1288 return;
1289 ssrc = *ssrc_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001290 }
sprangcd349d92016-07-13 09:11:28 -07001291
1292 rtc::CritScope lock(&statistics_crit_);
1293 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0),
1294 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +00001295}
1296
isheriff6b4b5f32016-06-08 00:24:21 -07001297size_t RTPSender::RtpHeaderLength() const {
tommiae695e92016-02-02 08:31:45 -08001298 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001299 size_t rtp_header_length = kRtpHeaderLength;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001300 rtp_header_length += sizeof(uint32_t) * csrcs_.size();
Danil Chapovalov7b189922018-10-03 10:15:36 +02001301 rtp_header_length += RtpHeaderExtensionSize(kFecOrPaddingExtensionSizes,
1302 rtp_header_extension_map_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001303 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +00001304}
1305
mflodmanfcf54bd2015-04-14 21:28:08 +02001306uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
tommiae695e92016-02-02 08:31:45 -08001307 rtc::CritScope lock(&send_critsect_);
mflodmanfcf54bd2015-04-14 21:28:08 +02001308 uint16_t first_allocated_sequence_number = sequence_number_;
1309 sequence_number_ += packets_to_send;
1310 return first_allocated_sequence_number;
niklase@google.com470e71d2011-07-07 08:21:25 +00001311}
1312
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001313void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
1314 StreamDataCounters* rtx_stats) const {
danilchap7c9426c2016-04-14 03:05:31 -07001315 rtc::CritScope lock(&statistics_crit_);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001316 *rtp_stats = rtp_stats_;
1317 *rtx_stats = rtx_rtp_stats_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001318}
1319
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001320std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
1321 rtc::CritScope lock(&send_critsect_);
Danil Chapovalov3b4b4f52018-10-12 12:50:43 +02001322 // TODO(danilchap): Find better motivator and value for extra capacity.
1323 // RtpPacketizer might slightly miscalulate needed size,
1324 // SRTP may benefit from extra space in the buffer and do encryption in place
1325 // saving reallocation.
1326 // While sending slightly oversized packet increase chance of dropped packet,
1327 // it is better than crash on drop packet without trying to send it.
1328 static constexpr int kExtraCapacity = 16;
1329 auto packet = absl::make_unique<RtpPacketToSend>(
1330 &rtp_header_extension_map_, max_packet_size_ + kExtraCapacity);
nisse7d59f6b2017-02-21 03:40:24 -08001331 RTC_DCHECK(ssrc_);
1332 packet->SetSsrc(*ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001333 packet->SetCsrcs(csrcs_);
1334 // Reserve extensions, if registered, RtpSender set in SendToNetwork.
1335 packet->ReserveExtension<AbsoluteSendTime>();
1336 packet->ReserveExtension<TransmissionOffset>();
1337 packet->ReserveExtension<TransportSequenceNumber>();
Niels Möller6893f3c2019-01-31 08:56:26 +01001338
Steve Anton4af95842018-04-06 11:09:46 -07001339 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001340 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001341 packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001342 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001343 if (!rid_.empty()) {
1344 // This is a no-op if the RID header extension is not registered.
1345 packet->SetExtension<RtpStreamId>(rid_);
1346 }
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001347 return packet;
1348}
1349
1350bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) {
1351 rtc::CritScope lock(&send_critsect_);
1352 if (!sending_media_)
1353 return false;
nisse7d59f6b2017-02-21 03:40:24 -08001354 RTC_DCHECK(packet->Ssrc() == ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001355 packet->SetSequenceNumber(sequence_number_++);
1356
1357 // Remember marker bit to determine if padding can be inserted with
1358 // sequence number following |packet|.
1359 last_packet_marker_bit_ = packet->Marker();
Danil Chapovalovb3179c72018-03-22 10:13:07 +01001360 // Remember payload type to use in the padding packet if rtx is disabled.
1361 last_payload_type_ = packet->PayloadType();
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001362 // Save timestamps to generate timestamp field and extensions for the padding.
1363 last_rtp_timestamp_ = packet->Timestamp();
1364 last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
1365 capture_time_ms_ = packet->capture_time_ms();
1366 return true;
1367}
1368
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001369bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet,
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001370 int* packet_id) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001371 RTC_DCHECK(packet);
1372 RTC_DCHECK(packet_id);
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001373 if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId))
stefana23fc622016-07-28 07:56:38 -07001374 return false;
1375
asapersson35151f32016-05-02 23:44:01 -07001376 if (!transport_sequence_number_allocator_)
1377 return false;
1378
1379 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001380
1381 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
1382 return false;
1383
asapersson35151f32016-05-02 23:44:01 -07001384 return true;
sprang867fb522015-08-03 04:38:41 -07001385}
1386
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001387void RTPSender::SetSendingMediaStatus(bool enabled) {
tommiae695e92016-02-02 08:31:45 -08001388 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001389 sending_media_ = enabled;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001390}
1391
1392bool RTPSender::SendingMedia() const {
tommiae695e92016-02-02 08:31:45 -08001393 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001394 return sending_media_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001395}
1396
Sebastian Jansson1bca65b2018-10-10 09:58:08 +02001397void RTPSender::SetAsPartOfAllocation(bool part_of_allocation) {
1398 rtc::CritScope lock(&send_critsect_);
1399 force_part_of_allocation_ = part_of_allocation;
1400}
1401
danilchap71fead22016-08-18 02:01:49 -07001402void RTPSender::SetTimestampOffset(uint32_t timestamp) {
tommiae695e92016-02-02 08:31:45 -08001403 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001404 timestamp_offset_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001405}
1406
danilchap71fead22016-08-18 02:01:49 -07001407uint32_t RTPSender::TimestampOffset() const {
tommiae695e92016-02-02 08:31:45 -08001408 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001409 return timestamp_offset_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001410}
1411
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001412void RTPSender::SetSSRC(uint32_t ssrc) {
Erik Språng6cacef22019-07-24 14:15:51 +02001413 {
1414 rtc::CritScope lock(&send_critsect_);
1415 if (ssrc_ == ssrc) {
1416 return; // Since it's the same SSRC, don't reset anything.
1417 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001418
Erik Språng6cacef22019-07-24 14:15:51 +02001419 ssrc_.emplace(ssrc);
1420 if (!sequence_number_forced_) {
1421 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
1422 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001423 }
Erik Språng6cacef22019-07-24 14:15:51 +02001424
1425 // Clear RTP packet history, since any packets there belong to the old SSRC
1426 // and they may conflict with packets from the new one.
1427 packet_history_.Clear();
niklase@google.com470e71d2011-07-07 08:21:25 +00001428}
1429
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001430uint32_t RTPSender::SSRC() const {
tommiae695e92016-02-02 08:31:45 -08001431 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001432 RTC_DCHECK(ssrc_);
1433 return *ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001434}
1435
Amit Hilbuch77938e62018-12-21 09:23:38 -08001436void RTPSender::SetRid(const std::string& rid) {
1437 // RID is used in simulcast scenario when multiple layers share the same mid.
1438 rtc::CritScope lock(&send_critsect_);
1439 RTC_DCHECK_LE(rid.length(), RtpStreamId::kMaxValueSizeBytes);
1440 rid_ = rid;
1441}
1442
Steve Anton296a0ce2018-03-22 15:17:27 -07001443void RTPSender::SetMid(const std::string& mid) {
1444 // This is configured via the API.
1445 rtc::CritScope lock(&send_critsect_);
Steve Anton4af95842018-04-06 11:09:46 -07001446 mid_ = mid;
Steve Anton296a0ce2018-03-22 15:17:27 -07001447}
1448
Danil Chapovalovd264df52018-06-14 12:59:38 +02001449absl::optional<uint32_t> RTPSender::FlexfecSsrc() const {
Niels Möller59ab1cf2019-02-06 22:48:11 +01001450 return flexfec_ssrc_;
brandtr9dfff292016-11-14 05:14:50 -08001451}
1452
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001453void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
spranga8ae6f22017-09-04 07:23:56 -07001454 RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
tommiae695e92016-02-02 08:31:45 -08001455 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001456 csrcs_ = csrcs;
niklase@google.com470e71d2011-07-07 08:21:25 +00001457}
1458
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001459void RTPSender::SetSequenceNumber(uint16_t seq) {
Erik Språng6cacef22019-07-24 14:15:51 +02001460 bool updated_sequence_number = false;
1461 {
1462 rtc::CritScope lock(&send_critsect_);
1463 sequence_number_forced_ = true;
1464 if (sequence_number_ != seq) {
1465 updated_sequence_number = true;
1466 }
1467 sequence_number_ = seq;
1468 }
1469
1470 if (updated_sequence_number) {
1471 // Sequence number series has been reset to a new value, clear RTP packet
1472 // history, since any packets there may conflict with new ones.
1473 packet_history_.Clear();
1474 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001475}
1476
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001477uint16_t RTPSender::SequenceNumber() const {
tommiae695e92016-02-02 08:31:45 -08001478 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001479 return sequence_number_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001480}
1481
Danil Chapovalov271195f2019-02-11 11:30:03 +01001482static void CopyHeaderAndExtensionsToRtxPacket(const RtpPacketToSend& packet,
1483 RtpPacketToSend* rtx_packet) {
Amit Hilbuch77938e62018-12-21 09:23:38 -08001484 // Set the relevant fixed packet headers. The following are not set:
1485 // * Payload type - it is replaced in rtx packets.
1486 // * Sequence number - RTX has a separate sequence numbering.
1487 // * SSRC - RTX stream has its own SSRC.
1488 rtx_packet->SetMarker(packet.Marker());
1489 rtx_packet->SetTimestamp(packet.Timestamp());
1490
1491 // Set the variable fields in the packet header:
1492 // * CSRCs - must be set before header extensions.
1493 // * Header extensions - replace Rid header with RepairedRid header.
1494 const std::vector<uint32_t> csrcs = packet.Csrcs();
1495 rtx_packet->SetCsrcs(csrcs);
1496 for (int extension = kRtpExtensionNone + 1;
1497 extension < kRtpExtensionNumberOfExtensions; ++extension) {
1498 RTPExtensionType source_extension =
1499 static_cast<RTPExtensionType>(extension);
1500 // Rid header should be replaced with RepairedRid header
1501 RTPExtensionType destination_extension =
1502 source_extension == kRtpExtensionRtpStreamId
1503 ? kRtpExtensionRepairedRtpStreamId
1504 : source_extension;
1505
1506 // Empty extensions should be supported, so not checking |source.empty()|.
1507 if (!packet.HasExtension(source_extension)) {
1508 continue;
1509 }
1510
1511 rtc::ArrayView<const uint8_t> source =
1512 packet.FindExtension(source_extension);
1513
1514 rtc::ArrayView<uint8_t> destination =
1515 rtx_packet->AllocateExtension(destination_extension, source.size());
1516
1517 // Could happen if any:
1518 // 1. Extension has 0 length.
1519 // 2. Extension is not registered in destination.
1520 // 3. Allocating extension in destination failed.
1521 if (destination.empty() || source.size() != destination.size()) {
1522 continue;
1523 }
1524
1525 std::memcpy(destination.begin(), source.begin(), destination.size());
1526 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001527}
1528
1529std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
1530 const RtpPacketToSend& packet) {
Danil Chapovalov271195f2019-02-11 11:30:03 +01001531 std::unique_ptr<RtpPacketToSend> rtx_packet;
Amit Hilbuch77938e62018-12-21 09:23:38 -08001532
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001533 // Add original RTP header.
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001534 {
1535 rtc::CritScope lock(&send_critsect_);
1536 if (!sending_media_)
1537 return nullptr;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001538
nisse7d59f6b2017-02-21 03:40:24 -08001539 RTC_DCHECK(ssrc_rtx_);
1540
brandtre6f98c72016-11-11 03:28:30 -08001541 // Replace payload type.
1542 auto kv = rtx_payload_type_map_.find(packet.PayloadType());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001543 if (kv == rtx_payload_type_map_.end())
brandtre6f98c72016-11-11 03:28:30 -08001544 return nullptr;
Danil Chapovalov271195f2019-02-11 11:30:03 +01001545
1546 rtx_packet = absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_,
1547 max_packet_size_);
1548
brandtre6f98c72016-11-11 03:28:30 -08001549 rtx_packet->SetPayloadType(kv->second);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +00001550
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001551 // Replace sequence number.
1552 rtx_packet->SetSequenceNumber(sequence_number_rtx_++);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001553
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001554 // Replace SSRC.
nisse7d59f6b2017-02-21 03:40:24 -08001555 rtx_packet->SetSsrc(*ssrc_rtx_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001556
Danil Chapovalov271195f2019-02-11 11:30:03 +01001557 CopyHeaderAndExtensionsToRtxPacket(packet, rtx_packet.get());
1558
Amit Hilbuch77938e62018-12-21 09:23:38 -08001559 // The spec indicates that it is possible for a sender to stop sending mids
1560 // once the SSRCs have been bound on the receiver. As a result the source
1561 // rtp packet might not have the MID header extension set.
1562 // However, the SSRC of the RTX stream might not have been bound on the
1563 // receiver. This means that we should include it here.
1564 // The same argument goes for the Repaired RID extension.
Steve Anton4af95842018-04-06 11:09:46 -07001565 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001566 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001567 rtx_packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001568 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001569 if (!rid_.empty()) {
1570 // This is a no-op if the Repaired-RID header extension is not registered.
1571 // rtx_packet->SetExtension<RepairedRtpStreamId>(rid_);
1572 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001573 }
Danil Chapovalov271195f2019-02-11 11:30:03 +01001574 RTC_DCHECK(rtx_packet);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001575
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001576 uint8_t* rtx_payload =
1577 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize);
Danil Chapovalov271195f2019-02-11 11:30:03 +01001578 if (rtx_payload == nullptr)
1579 return nullptr;
1580
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001581 // Add OSN (original sequence number).
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001582 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber());
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001583
1584 // Add original payload data.
danilchap96c15872016-11-21 01:35:29 -08001585 auto payload = packet.payload();
1586 memcpy(rtx_payload + kRtxHeaderSize, payload.data(), payload.size());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001587
Dino Radaković1807d572018-02-22 14:18:06 +01001588 // Add original application data.
1589 rtx_packet->set_application_data(packet.application_data());
1590
Erik Språnga57711c2019-07-24 10:47:20 +02001591 // Copy capture time so e.g. TransmissionOffset is correctly set.
1592 rtx_packet->set_capture_time_ms(packet.capture_time_ms());
1593
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001594 return rtx_packet;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001595}
1596
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001597void RTPSender::RegisterRtpStatisticsCallback(
1598 StreamDataCountersCallback* callback) {
danilchap7c9426c2016-04-14 03:05:31 -07001599 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001600 rtp_stats_callback_ = callback;
1601}
1602
1603StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
danilchap7c9426c2016-04-14 03:05:31 -07001604 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001605 return rtp_stats_callback_;
1606}
1607
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001608uint32_t RTPSender::BitrateSent() const {
sprangcd349d92016-07-13 09:11:28 -07001609 rtc::CritScope cs(&statistics_crit_);
1610 return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001611}
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001612
1613void RTPSender::SetRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001614 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001615 sequence_number_ = rtp_state.sequence_number;
1616 sequence_number_forced_ = true;
danilchap71fead22016-08-18 02:01:49 -07001617 timestamp_offset_ = rtp_state.start_timestamp;
danilchape5b41412016-08-22 03:39:23 -07001618 last_rtp_timestamp_ = rtp_state.timestamp;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001619 capture_time_ms_ = rtp_state.capture_time_ms;
1620 last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001621 media_has_been_sent_ = rtp_state.media_has_been_sent;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001622}
1623
1624RtpState RTPSender::GetRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001625 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001626
1627 RtpState state;
1628 state.sequence_number = sequence_number_;
danilchap71fead22016-08-18 02:01:49 -07001629 state.start_timestamp = timestamp_offset_;
danilchape5b41412016-08-22 03:39:23 -07001630 state.timestamp = last_rtp_timestamp_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001631 state.capture_time_ms = capture_time_ms_;
1632 state.last_timestamp_time_ms = last_timestamp_time_ms_;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001633 state.media_has_been_sent = media_has_been_sent_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001634
1635 return state;
1636}
1637
1638void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001639 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001640 sequence_number_rtx_ = rtp_state.sequence_number;
1641}
1642
1643RtpState RTPSender::GetRtxRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001644 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001645
1646 RtpState state;
1647 state.sequence_number = sequence_number_rtx_;
danilchap71fead22016-08-18 02:01:49 -07001648 state.start_timestamp = timestamp_offset_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001649
1650 return state;
1651}
1652
philipel8aadd502017-02-23 02:56:13 -08001653void RTPSender::AddPacketToTransportFeedback(
1654 uint16_t packet_id,
1655 const RtpPacketToSend& packet,
1656 const PacedPacketInfo& pacing_info) {
michaelt4da30442016-11-17 01:38:43 -08001657 if (transport_feedback_observer_) {
Erik Språng30a276b2019-04-23 12:00:11 +02001658 size_t packet_size = packet.payload_size() + packet.padding_size();
1659 if (send_side_bwe_with_overhead_) {
1660 packet_size = packet.size();
1661 }
1662
1663 RtpPacketSendInfo packet_info;
1664 packet_info.ssrc = SSRC();
1665 packet_info.transport_sequence_number = packet_id;
Erik Språng490d76c2019-05-07 09:29:15 -07001666 packet_info.has_rtp_sequence_number = true;
Erik Språng30a276b2019-04-23 12:00:11 +02001667 packet_info.rtp_sequence_number = packet.SequenceNumber();
1668 packet_info.length = packet_size;
1669 packet_info.pacing_info = pacing_info;
1670 transport_feedback_observer_->OnAddPacket(packet_info);
michaelt4da30442016-11-17 01:38:43 -08001671 }
1672}
1673
1674void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
1675 if (!overhead_observer_)
1676 return;
nisse284542b2017-01-10 08:58:32 -08001677 size_t overhead_bytes_per_packet;
michaelt4da30442016-11-17 01:38:43 -08001678 {
1679 rtc::CritScope lock(&send_critsect_);
1680 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
1681 return;
1682 }
1683 rtp_overhead_bytes_per_packet_ = packet.headers_size();
nisse284542b2017-01-10 08:58:32 -08001684 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
michaelt4da30442016-11-17 01:38:43 -08001685 }
1686 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
1687}
1688
sprang168794c2017-07-06 04:38:06 -07001689int64_t RTPSender::LastTimestampTimeMs() const {
1690 rtc::CritScope lock(&send_critsect_);
1691 return last_timestamp_time_ms_;
1692}
1693
Erik Språng8b101922018-01-18 11:58:05 -08001694void RTPSender::SetRtt(int64_t rtt_ms) {
1695 packet_history_.SetRtt(rtt_ms);
1696 flexfec_packet_history_.SetRtt(rtt_ms);
1697}
Erik Språng490d76c2019-05-07 09:29:15 -07001698
1699void RTPSender::OnPacketsAcknowledged(
1700 rtc::ArrayView<const uint16_t> sequence_numbers) {
1701 packet_history_.CullAcknowledgedPackets(sequence_numbers);
1702}
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001703} // namespace webrtc