blob: acc2f15b366dc4e1befe1d36ad23f4c756c39c0f [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"
Elad Alon4a87e1c2017-10-03 16:11:34 +020021#include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "logging/rtc_event_log/rtc_event_log.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020023#include "modules/rtp_rtcp/include/rtp_cvo.h"
24#include "modules/rtp_rtcp/source/byte_io.h"
philipel569397f2018-09-26 12:25:31 +020025#include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020026#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
27#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020028#include "modules/rtp_rtcp/source/time_util.h"
29#include "rtc_base/arraysize.h"
30#include "rtc_base/checks.h"
31#include "rtc_base/logging.h"
Karl Wiberge40468b2017-11-22 10:42:26 +010032#include "rtc_base/numerics/safe_minmax.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020033#include "rtc_base/rate_limiter.h"
Steve Anton10542f22019-01-11 09:11:00 -080034#include "rtc_base/time_utils.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000035
36namespace webrtc {
niklase@google.com470e71d2011-07-07 08:21:25 +000037
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000038namespace {
Danil Chapovalov31e4e802016-08-03 18:27:40 +020039// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
40constexpr size_t kMaxPaddingLength = 224;
stefan53b6cc32017-02-03 08:13:57 -080041constexpr size_t kMinAudioPaddingLength = 50;
Danil Chapovalov31e4e802016-08-03 18:27:40 +020042constexpr int kSendSideDelayWindowMs = 1000;
43constexpr size_t kRtpHeaderLength = 12;
44constexpr uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1.
45constexpr uint32_t kTimestampTicksPerMs = 90;
46constexpr int kBitrateStatisticsWindowMs = 1000;
guoweis@webrtc.org45362892015-03-04 22:55:15 +000047
brandtr9dfff292016-11-14 05:14:50 -080048constexpr size_t kMinFlexfecPacketsToStoreForPacing = 50;
49
erikvarga27883732017-05-17 05:08:38 -070050template <typename Extension>
51constexpr RtpExtensionSize CreateExtensionSize() {
52 return {Extension::kId, Extension::kValueSizeBytes};
53}
54
Amit Hilbuch77938e62018-12-21 09:23:38 -080055template <typename Extension>
56constexpr RtpExtensionSize CreateMaxExtensionSize() {
57 return {Extension::kId, Extension::kMaxValueSizeBytes};
58}
59
erikvarga27883732017-05-17 05:08:38 -070060// Size info for header extensions that might be used in padding or FEC packets.
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010061constexpr RtpExtensionSize kFecOrPaddingExtensionSizes[] = {
erikvarga27883732017-05-17 05:08:38 -070062 CreateExtensionSize<AbsoluteSendTime>(),
63 CreateExtensionSize<TransmissionOffset>(),
64 CreateExtensionSize<TransportSequenceNumber>(),
65 CreateExtensionSize<PlayoutDelayLimits>(),
Amit Hilbuch77938e62018-12-21 09:23:38 -080066 CreateMaxExtensionSize<RtpMid>(),
erikvarga27883732017-05-17 05:08:38 -070067};
68
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010069// Size info for header extensions that might be used in video packets.
70constexpr RtpExtensionSize kVideoExtensionSizes[] = {
71 CreateExtensionSize<AbsoluteSendTime>(),
72 CreateExtensionSize<TransmissionOffset>(),
73 CreateExtensionSize<TransportSequenceNumber>(),
74 CreateExtensionSize<PlayoutDelayLimits>(),
75 CreateExtensionSize<VideoOrientation>(),
76 CreateExtensionSize<VideoContentTypeExtension>(),
77 CreateExtensionSize<VideoTimingExtension>(),
Amit Hilbuch77938e62018-12-21 09:23:38 -080078 CreateMaxExtensionSize<RtpStreamId>(),
79 CreateMaxExtensionSize<RepairedRtpStreamId>(),
80 CreateMaxExtensionSize<RtpMid>(),
Elad Alonccb9b752019-02-19 13:01:31 +010081 {RtpGenericFrameDescriptorExtension00::kId,
82 RtpGenericFrameDescriptorExtension00::kMaxSizeBytes},
83 {RtpGenericFrameDescriptorExtension01::kId,
84 RtpGenericFrameDescriptorExtension01::kMaxSizeBytes},
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010085};
86
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000087} // namespace
88
sprangebbf8a82015-09-21 15:11:14 -070089RTPSender::RTPSender(
90 bool audio,
91 Clock* clock,
92 Transport* transport,
sprangebbf8a82015-09-21 15:11:14 -070093 RtpPacketSender* paced_sender,
Niels Möller59ab1cf2019-02-06 22:48:11 +010094 absl::optional<uint32_t> flexfec_ssrc,
sprangebbf8a82015-09-21 15:11:14 -070095 TransportSequenceNumberAllocator* sequence_number_allocator,
96 TransportFeedbackObserver* transport_feedback_observer,
97 BitrateStatisticsObserver* bitrate_callback,
terelius429c3452016-01-21 05:42:04 -080098 SendSideDelayObserver* send_side_delay_observer,
asapersson35151f32016-05-02 23:44:01 -070099 RtcEventLog* event_log,
sprangcd349d92016-07-13 09:11:28 -0700100 SendPacketObserver* send_packet_observer,
michaelt4da30442016-11-17 01:38:43 -0800101 RateLimiter* retransmission_rate_limiter,
Erik Språng7b52f102018-02-07 14:37:37 +0100102 OverheadObserver* overhead_observer,
Benjamin Wright192eeec2018-10-17 17:27:25 -0700103 bool populate_network2_timestamp,
104 FrameEncryptorInterface* frame_encryptor,
Johannes Kron9190b822018-10-29 11:22:05 +0100105 bool require_frame_encryption,
Per Kjellandere11b7d22019-02-21 07:55:59 +0100106 bool extmap_allow_mixed,
107 const WebRtcKeyValueConfig& field_trials)
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000108 : clock_(clock),
Niels Möllerd28db7f2016-05-10 16:31:47 +0200109 // TODO(holmer): Remove this conversion?
110 clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()),
danilchap47a740b2015-12-15 00:30:07 -0800111 random_(clock_->TimeInMicroseconds()),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000112 audio_configured_(audio),
Niels Möller59ab1cf2019-02-06 22:48:11 +0100113 flexfec_ssrc_(flexfec_ssrc),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000114 paced_sender_(paced_sender),
sprangebbf8a82015-09-21 15:11:14 -0700115 transport_sequence_number_allocator_(sequence_number_allocator),
sprang5e023eb2015-09-14 06:42:43 -0700116 transport_feedback_observer_(transport_feedback_observer),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000117 transport_(transport),
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200118 sending_media_(true), // Default to sending media.
119 force_part_of_allocation_(false),
nisse284542b2017-01-10 08:58:32 -0800120 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100121 last_payload_type_(-1),
Johannes Kron9190b822018-10-29 11:22:05 +0100122 rtp_header_extension_map_(extmap_allow_mixed),
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000123 packet_history_(clock),
brandtr9dfff292016-11-14 05:14:50 -0800124 flexfec_packet_history_(clock),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000125 // Statistics
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200126 send_delays_(),
127 max_delay_it_(send_delays_.end()),
128 sum_delays_ms_(0),
sprangcd349d92016-07-13 09:11:28 -0700129 rtp_stats_callback_(nullptr),
130 total_bitrate_sent_(kBitrateStatisticsWindowMs,
131 RateStatistics::kBpsScale),
132 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000133 send_side_delay_observer_(send_side_delay_observer),
terelius429c3452016-01-21 05:42:04 -0800134 event_log_(event_log),
asapersson35151f32016-05-02 23:44:01 -0700135 send_packet_observer_(send_packet_observer),
sprangcd349d92016-07-13 09:11:28 -0700136 bitrate_callback_(bitrate_callback),
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000137 // RTP variables
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000138 sequence_number_forced_(false),
danilchape5b41412016-08-22 03:39:23 -0700139 last_rtp_timestamp_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000140 capture_time_ms_(0),
141 last_timestamp_time_ms_(0),
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000142 media_has_been_sent_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000143 last_packet_marker_bit_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000144 csrcs_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000145 rtx_(kRtxOff),
michaelt4da30442016-11-17 01:38:43 -0800146 rtp_overhead_bytes_per_packet_(0),
147 retransmission_rate_limiter_(retransmission_rate_limiter),
elad.alonc3dfff32017-01-26 02:46:55 -0800148 overhead_observer_(overhead_observer),
Erik Språng7b52f102018-02-07 14:37:37 +0100149 populate_network2_timestamp_(populate_network2_timestamp),
elad.alonc3dfff32017-01-26 02:46:55 -0800150 send_side_bwe_with_overhead_(
Per Kjellandere11b7d22019-02-21 07:55:59 +0100151 field_trials.Lookup("WebRTC-SendSideBwe-WithOverhead")
Erik Språngd2a63442019-05-03 10:58:50 -0400152 .find("Enabled") == 0),
153 legacy_packet_history_storage_mode_(
154 field_trials.Lookup("WebRTC-UseRtpPacketHistoryLegacyStorageMode")
Per Kjellandere11b7d22019-02-21 07:55:59 +0100155 .find("Enabled") == 0) {
danilchap71fead22016-08-18 02:01:49 -0700156 // This random initialization is not intended to be cryptographic strong.
157 timestamp_offset_ = random_.Rand<uint32_t>();
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000158 // Random start, 16 bits. Can't be 0.
danilchap47a740b2015-12-15 00:30:07 -0800159 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
160 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
brandtr9dfff292016-11-14 05:14:50 -0800161
162 // Store FlexFEC packets in the packet history data structure, so they can
163 // be found when paced.
Niels Möller59ab1cf2019-02-06 22:48:11 +0100164 if (flexfec_ssrc_) {
Erik Språngd2a63442019-05-03 10:58:50 -0400165 RtpPacketHistory::StorageMode storage_mode =
166 legacy_packet_history_storage_mode_
167 ? RtpPacketHistory::StorageMode::kStore
168 : RtpPacketHistory::StorageMode::kStoreAndCull;
169
brandtr9dfff292016-11-14 05:14:50 -0800170 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språngd2a63442019-05-03 10:58:50 -0400171 storage_mode, kMinFlexfecPacketsToStoreForPacing);
brandtr9dfff292016-11-14 05:14:50 -0800172 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000173}
174
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000175RTPSender::~RTPSender() {
tommiae695e92016-02-02 08:31:45 -0800176 // TODO(tommi): Use a thread checker to ensure the object is created and
177 // deleted on the same thread. At the moment this isn't possible due to
178 // voe::ChannelOwner in voice engine. To reproduce, run:
179 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
180
181 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
182 // variables but we grab them in all other methods. (what's the design?)
183 // Start documenting what thread we're on in what method so that it's easier
184 // to understand performance attributes and possibly remove locks.
niklase@google.com470e71d2011-07-07 08:21:25 +0000185}
niklase@google.com470e71d2011-07-07 08:21:25 +0000186
erikvarga27883732017-05-17 05:08:38 -0700187rtc::ArrayView<const RtpExtensionSize> RTPSender::FecExtensionSizes() {
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +0100188 return rtc::MakeArrayView(kFecOrPaddingExtensionSizes,
189 arraysize(kFecOrPaddingExtensionSizes));
190}
191
192rtc::ArrayView<const RtpExtensionSize> RTPSender::VideoExtensionSizes() {
193 return rtc::MakeArrayView(kVideoExtensionSizes,
194 arraysize(kVideoExtensionSizes));
erikvarga27883732017-05-17 05:08:38 -0700195}
196
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000197uint16_t RTPSender::ActualSendBitrateKbit() const {
sprangcd349d92016-07-13 09:11:28 -0700198 rtc::CritScope cs(&statistics_crit_);
199 return static_cast<uint16_t>(
200 total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0) /
201 1000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000202}
203
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000204uint32_t RTPSender::NackOverheadRate() const {
sprangcd349d92016-07-13 09:11:28 -0700205 rtc::CritScope cs(&statistics_crit_);
206 return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000207}
208
Johannes Kron9190b822018-10-29 11:22:05 +0100209void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) {
210 rtc::CritScope lock(&send_critsect_);
211 rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed);
212}
213
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000214int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
215 uint8_t id) {
tommiae695e92016-02-02 08:31:45 -0800216 rtc::CritScope lock(&send_critsect_);
danilchapfab482b2017-04-04 02:33:48 -0700217 return rtp_header_extension_map_.RegisterByType(id, type) ? 0 : -1;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000218}
219
Danil Chapovalov585d1aa2018-09-14 18:29:32 +0200220bool RTPSender::RegisterRtpHeaderExtension(const std::string& uri, int id) {
221 rtc::CritScope lock(&send_critsect_);
222 return rtp_header_extension_map_.RegisterByUri(id, uri);
223}
224
stefan53b6cc32017-02-03 08:13:57 -0800225bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) const {
tommiae695e92016-02-02 08:31:45 -0800226 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000227 return rtp_header_extension_map_.IsRegistered(type);
228}
229
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000230int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800231 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000232 return rtp_header_extension_map_.Deregister(type);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000233}
234
nisse284542b2017-01-10 08:58:32 -0800235void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
kwibergee89e782017-08-09 17:22:01 -0700236 RTC_DCHECK_GE(max_packet_size, 100);
237 RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
tommiae695e92016-02-02 08:31:45 -0800238 rtc::CritScope lock(&send_critsect_);
nisse284542b2017-01-10 08:58:32 -0800239 max_packet_size_ = max_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25 +0000240}
241
nisse284542b2017-01-10 08:58:32 -0800242size_t RTPSender::MaxRtpPacketSize() const {
243 return max_packet_size_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000244}
245
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000246void RTPSender::SetRtxStatus(int mode) {
tommiae695e92016-02-02 08:31:45 -0800247 rtc::CritScope lock(&send_critsect_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000248 rtx_ = mode;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000249}
250
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000251int RTPSender::RtxStatus() const {
tommiae695e92016-02-02 08:31:45 -0800252 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000253 return rtx_;
254}
255
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000256void RTPSender::SetRtxSsrc(uint32_t ssrc) {
tommiae695e92016-02-02 08:31:45 -0800257 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800258 ssrc_rtx_.emplace(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000259}
260
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000261uint32_t RTPSender::RtxSsrc() const {
tommiae695e92016-02-02 08:31:45 -0800262 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800263 RTC_DCHECK(ssrc_rtx_);
264 return *ssrc_rtx_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000265}
266
Shao Changbine62202f2015-04-21 20:24:50 +0800267void RTPSender::SetRtxPayloadType(int payload_type,
268 int associated_payload_type) {
tommiae695e92016-02-02 08:31:45 -0800269 rtc::CritScope lock(&send_critsect_);
henrikg91d6ede2015-09-17 00:24:34 -0700270 RTC_DCHECK_LE(payload_type, 127);
271 RTC_DCHECK_LE(associated_payload_type, 127);
Shao Changbine62202f2015-04-21 20:24:50 +0800272 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100273 RTC_LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type << ".";
Shao Changbine62202f2015-04-21 20:24:50 +0800274 return;
275 }
276
277 rtx_payload_type_map_[associated_payload_type] = payload_type;
Åsa Persson6ae25722015-04-13 17:48:08 +0200278}
279
philipela1ed0b32016-06-01 06:31:17 -0700280size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
philipel8aadd502017-02-23 02:56:13 -0800281 const PacedPacketInfo& pacing_info) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000282 {
tommiae695e92016-02-02 08:31:45 -0800283 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100284 if (!sending_media_)
285 return 0;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000286 if ((rtx_ & kRtxRedundantPayloads) == 0)
287 return 0;
288 }
289
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000290 int bytes_left = static_cast<int>(bytes_to_send);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000291 while (bytes_left > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200292 std::unique_ptr<RtpPacketToSend> packet =
293 packet_history_.GetBestFittingPacket(bytes_left);
294 if (!packet)
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000295 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200296 size_t payload_size = packet->payload_size();
philipel8aadd502017-02-23 02:56:13 -0800297 if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000298 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200299 bytes_left -= payload_size;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000300 }
301 return bytes_to_send - bytes_left;
302}
303
philipel8aadd502017-02-23 02:56:13 -0800304size_t RTPSender::SendPadData(size_t bytes,
305 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800306 size_t padding_bytes_in_packet;
erikvarga76a55932017-05-17 07:50:17 -0700307 size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
erikvarga27883732017-05-17 05:08:38 -0700308
stefan53b6cc32017-02-03 08:13:57 -0800309 if (audio_configured_) {
310 // Allow smaller padding packets for audio.
kwiberg07038562017-06-12 11:40:47 -0700311 padding_bytes_in_packet = rtc::SafeClamp<size_t>(
312 bytes, kMinAudioPaddingLength,
313 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
stefan53b6cc32017-02-03 08:13:57 -0800314 } else {
315 // Always send full padding packets. This is accounted for by the
316 // RtpPacketSender, which will make sure we don't send too much padding even
317 // if a single packet is larger than requested.
318 // We do this to avoid frequently sending small packets on higher bitrates.
kwiberg07038562017-06-12 11:40:47 -0700319 padding_bytes_in_packet =
320 rtc::SafeMin<size_t>(max_payload_size, kMaxPaddingLength);
stefan53b6cc32017-02-03 08:13:57 -0800321 }
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000322 size_t bytes_sent = 0;
danilchap90069872016-12-14 06:16:33 -0800323 while (bytes_sent < bytes) {
324 int64_t now_ms = clock_->TimeInMilliseconds();
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000325 uint32_t ssrc;
danilchap90069872016-12-14 06:16:33 -0800326 uint32_t timestamp;
327 int64_t capture_time_ms;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000328 uint16_t sequence_number;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000329 int payload_type;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000330 bool over_rtx;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000331 {
tommiae695e92016-02-02 08:31:45 -0800332 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100333 if (!sending_media_)
danilchap90069872016-12-14 06:16:33 -0800334 break;
335 timestamp = last_rtp_timestamp_;
336 capture_time_ms = capture_time_ms_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000337 if (rtx_ == kRtxOff) {
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100338 if (last_payload_type_ == -1)
stefane35f89a2017-02-01 09:06:25 -0800339 break;
stefan53b6cc32017-02-03 08:13:57 -0800340 // Without RTX we can't send padding in the middle of frames.
341 // For audio marker bits doesn't mark the end of a frame and frames
342 // are usually a single packet, so for now we don't apply this rule
343 // for audio.
344 if (!audio_configured_ && !last_packet_marker_bit_) {
345 break;
346 }
nisse7d59f6b2017-02-21 03:40:24 -0800347 if (!ssrc_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100348 RTC_LOG(LS_ERROR) << "SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800349 return 0;
350 }
351
352 RTC_DCHECK(ssrc_);
353 ssrc = *ssrc_;
354
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000355 sequence_number = sequence_number_;
356 ++sequence_number_;
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100357 payload_type = last_payload_type_;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000358 over_rtx = false;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000359 } else {
Stefan Holmerf5dca482016-01-27 12:58:51 +0100360 // Without abs-send-time or transport sequence number a media packet
361 // must be sent before padding so that the timestamps used for
362 // estimation are correct.
363 if (!media_has_been_sent_ &&
danilchap90069872016-12-14 06:16:33 -0800364 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
365 (rtp_header_extension_map_.IsRegistered(
366 TransportSequenceNumber::kId) &&
367 transport_sequence_number_allocator_))) {
368 break;
Stefan Holmerf5dca482016-01-27 12:58:51 +0100369 }
Stefan Holmer586b19b2015-09-18 11:14:31 +0200370 // Only change change the timestamp of padding packets sent over RTX.
371 // Padding only packets over RTP has to be sent as part of a media
372 // frame (and therefore the same timestamp).
373 if (last_timestamp_time_ms_ > 0) {
374 timestamp +=
danilchap90069872016-12-14 06:16:33 -0800375 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
376 capture_time_ms += (now_ms - last_timestamp_time_ms_);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200377 }
nisse7d59f6b2017-02-21 03:40:24 -0800378 if (!ssrc_rtx_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100379 RTC_LOG(LS_ERROR) << "RTX SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800380 return 0;
381 }
382 RTC_DCHECK(ssrc_rtx_);
383 ssrc = *ssrc_rtx_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000384 sequence_number = sequence_number_rtx_;
385 ++sequence_number_rtx_;
Stefan Holmer10880012016-02-03 13:29:59 +0100386 payload_type = rtx_payload_type_map_.begin()->second;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000387 over_rtx = true;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000388 }
389 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000390
danilchap90069872016-12-14 06:16:33 -0800391 RtpPacketToSend padding_packet(&rtp_header_extension_map_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200392 padding_packet.SetPayloadType(payload_type);
393 padding_packet.SetMarker(false);
394 padding_packet.SetSequenceNumber(sequence_number);
395 padding_packet.SetTimestamp(timestamp);
396 padding_packet.SetSsrc(ssrc);
397
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000398 if (capture_time_ms > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200399 padding_packet.SetExtension<TransmissionOffset>(
danilchap90069872016-12-14 06:16:33 -0800400 (now_ms - capture_time_ms) * kTimestampTicksPerMs);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000401 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200402 padding_packet.SetExtension<AbsoluteSendTime>(
403 AbsoluteSendTime::MsTo24Bits(now_ms));
stefan1d8a5062015-10-02 03:39:33 -0700404 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200405 // Padding packets are never retransmissions.
406 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200407 bool has_transport_seq_num;
408 {
409 rtc::CritScope lock(&send_critsect_);
410 has_transport_seq_num =
411 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200412 options.included_in_allocation =
413 has_transport_seq_num || force_part_of_allocation_;
414 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200415 }
Danil Chapovalovf7fcaf02018-10-10 14:56:01 +0200416 padding_packet.SetPadding(padding_bytes_in_packet);
michaelt4da30442016-11-17 01:38:43 -0800417 if (has_transport_seq_num) {
418 AddPacketToTransportFeedback(options.packet_id, padding_packet,
philipel8aadd502017-02-23 02:56:13 -0800419 pacing_info);
michaelt4da30442016-11-17 01:38:43 -0800420 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200421
philipel32d00102017-02-27 02:18:46 -0800422 if (!SendPacketToNetwork(padding_packet, options, pacing_info))
stefanf116bd02015-10-27 08:29:42 -0700423 break;
424
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000425 bytes_sent += padding_bytes_in_packet;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200426 UpdateRtpStats(padding_packet, over_rtx, false);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000427 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000428
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000429 return bytes_sent;
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000430}
431
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000432void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
Erik Språngd2a63442019-05-03 10:58:50 -0400433 RtpPacketHistory::StorageMode mode;
434 if (enable) {
435 mode = legacy_packet_history_storage_mode_
436 ? RtpPacketHistory::StorageMode::kStore
437 : RtpPacketHistory::StorageMode::kStoreAndCull;
438 } else {
439 mode = RtpPacketHistory::StorageMode::kDisabled;
440 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100441 packet_history_.SetStorePacketsStatus(mode, number_to_store);
niklase@google.com470e71d2011-07-07 08:21:25 +0000442}
443
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000444bool RTPSender::StorePackets() const {
Erik Språnga12b1d62018-03-14 12:39:24 +0100445 return packet_history_.GetStorageMode() !=
446 RtpPacketHistory::StorageMode::kDisabled;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000447}
niklase@google.com470e71d2011-07-07 08:21:25 +0000448
Erik Språnga12b1d62018-03-14 12:39:24 +0100449int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
450 // Try to find packet in RTP packet history. Also verify RTT here, so that we
451 // don't retransmit too often.
Danil Chapovalovd264df52018-06-14 12:59:38 +0200452 absl::optional<RtpPacketHistory::PacketState> stored_packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200453 packet_history_.GetPacketState(packet_id);
Erik Språng0f4f0552019-05-08 10:15:05 -0700454 if (!stored_packet || stored_packet->pending_transmission) {
455 // Packet not found or already queued for retransmission, ignore.
asapersson@webrtc.org83ed0a42012-04-23 12:43:05 +0000456 return 0;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000457 }
Oleh Prypin5a980492018-03-09 12:27:24 +0000458
Per Kjellander252725d2019-02-20 13:14:34 +0100459 const int32_t packet_size = static_cast<int32_t>(stored_packet->packet_size);
Erik Språnga12b1d62018-03-14 12:39:24 +0100460
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200461 // Skip retransmission rate check if not configured.
462 if (retransmission_rate_limiter_) {
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200463 // Check if we're overusing retransmission bitrate.
464 // TODO(sprang): Add histograms for nack success or failure reasons.
Ilya Nikolaevskiy23b2a252018-10-10 15:17:39 +0200465 if (!retransmission_rate_limiter_->TryUseRate(packet_size)) {
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200466 return -1;
467 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100468 }
Erik Språng7bb37b82018-03-09 09:52:59 +0100469
Oleh Prypin5a980492018-03-09 12:27:24 +0000470 if (paced_sender_) {
Erik Språng0f4f0552019-05-08 10:15:05 -0700471 // Mark packet as being in pacer queue again, to prevent duplicates.
472 if (!packet_history_.SetPendingTransmission(packet_id)) {
473 // Packet has already been removed from history, return early.
474 return 0;
475 }
476
Oleh Prypin5a980492018-03-09 12:27:24 +0000477 // Convert from TickTime to Clock since capture_time_ms is based on
478 // TickTime.
479 int64_t corrected_capture_tims_ms =
Erik Språnga12b1d62018-03-14 12:39:24 +0100480 stored_packet->capture_time_ms + clock_delta_ms_;
481 paced_sender_->InsertPacket(
482 RtpPacketSender::kNormalPriority, stored_packet->ssrc,
483 stored_packet->rtp_sequence_number, corrected_capture_tims_ms,
Per Kjellander252725d2019-02-20 13:14:34 +0100484 stored_packet->packet_size, true);
Oleh Prypin5a980492018-03-09 12:27:24 +0000485
Erik Språnga12b1d62018-03-14 12:39:24 +0100486 return packet_size;
Oleh Prypin5a980492018-03-09 12:27:24 +0000487 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100488
489 std::unique_ptr<RtpPacketToSend> packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200490 packet_history_.GetPacketAndSetSendTime(packet_id);
Erik Språnga12b1d62018-03-14 12:39:24 +0100491 if (!packet) {
492 // Packet could theoretically time out between the first check and this one.
493 return 0;
494 }
495
496 const bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
philipel8aadd502017-02-23 02:56:13 -0800497 if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
sprang867fb522015-08-03 04:38:41 -0700498 return -1;
Erik Språnga12b1d62018-03-14 12:39:24 +0100499
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200500 return packet_size;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000501}
502
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200503bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
philipel32d00102017-02-27 02:18:46 -0800504 const PacketOptions& options,
505 const PacedPacketInfo& pacing_info) {
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000506 int bytes_sent = -1;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000507 if (transport_) {
michaelt4da30442016-11-17 01:38:43 -0800508 UpdateRtpOverhead(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200509 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
510 ? static_cast<int>(packet.size())
stefan1d8a5062015-10-02 03:39:33 -0700511 : -1;
terelius429c3452016-01-21 05:42:04 -0800512 if (event_log_ && bytes_sent > 0) {
Karl Wiberg918f50c2018-07-05 11:40:33 +0200513 event_log_->Log(absl::make_unique<RtcEventRtpPacketOutgoing>(
Elad Alon4a87e1c2017-10-03 16:11:34 +0200514 packet, pacing_info.probe_cluster_id));
terelius429c3452016-01-21 05:42:04 -0800515 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000516 }
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000517 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000518 if (bytes_sent <= 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100519 RTC_LOG(LS_WARNING) << "Transport failed to send packet.";
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000520 return false;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000521 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000522 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000523}
524
Danil Chapovalov2800d742016-08-26 18:48:46 +0200525void RTPSender::OnReceivedNack(
526 const std::vector<uint16_t>& nack_sequence_numbers,
527 int64_t avg_rtt) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100528 packet_history_.SetRtt(5 + avg_rtt);
sprangcd349d92016-07-13 09:11:28 -0700529 for (uint16_t seq_no : nack_sequence_numbers) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100530 const int32_t bytes_sent = ReSendPacket(seq_no);
sprangcd349d92016-07-13 09:11:28 -0700531 if (bytes_sent < 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000532 // Failed to send one Sequence number. Give up the rest in this nack.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100533 RTC_LOG(LS_WARNING) << "Failed resending RTP packet " << seq_no
534 << ", Discard rest of packets.";
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000535 break;
niklase@google.com470e71d2011-07-07 08:21:25 +0000536 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000537 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000538}
539
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000540// Called from pacer when we can send the packet.
Erik Språngd2879622019-05-10 08:29:01 -0700541RtpPacketSendResult RTPSender::TimeToSendPacket(
542 uint32_t ssrc,
543 uint16_t sequence_number,
544 int64_t capture_time_ms,
545 bool retransmission,
546 const PacedPacketInfo& pacing_info) {
547 if (!SendingMedia()) {
548 return RtpPacketSendResult::kPacketNotFound;
549 }
brandtr9dfff292016-11-14 05:14:50 -0800550
551 std::unique_ptr<RtpPacketToSend> packet;
552 if (ssrc == SSRC()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200553 packet = packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800554 } else if (ssrc == FlexfecSsrc()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200555 packet = flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800556 }
557
Stefan Holmera246cfb2016-08-23 17:51:42 +0200558 if (!packet) {
Erik Språngd2879622019-05-10 08:29:01 -0700559 // Packet cannot be found or was resent too recently.
560 return RtpPacketSendResult::kPacketNotFound;
Stefan Holmera246cfb2016-08-23 17:51:42 +0200561 }
asapersson35151f32016-05-02 23:44:01 -0700562
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200563 return PrepareAndSendPacket(
Erik Språngd2879622019-05-10 08:29:01 -0700564 std::move(packet),
565 retransmission && (RtxStatus() & kRtxRetransmitted) > 0,
566 retransmission, pacing_info)
567 ? RtpPacketSendResult::kSuccess
568 : RtpPacketSendResult::kTransportUnavailable;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000569}
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000570
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200571bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000572 bool send_over_rtx,
philipela1ed0b32016-06-01 06:31:17 -0700573 bool is_retransmit,
philipel8aadd502017-02-23 02:56:13 -0800574 const PacedPacketInfo& pacing_info) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200575 RTC_DCHECK(packet);
576 int64_t capture_time_ms = packet->capture_time_ms();
577 RtpPacketToSend* packet_to_send = packet.get();
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000578
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200579 std::unique_ptr<RtpPacketToSend> packet_rtx;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000580 if (send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200581 packet_rtx = BuildRtxPacket(*packet);
582 if (!packet_rtx)
danilchap32cd2c42016-08-01 06:58:34 -0700583 return false;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200584 packet_to_send = packet_rtx.get();
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000585 }
586
ilnik10894992017-06-21 08:23:19 -0700587 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
588 // the pacer, these modifications of the header below are happening after the
589 // FEC protection packets are calculated. This will corrupt recovered packets
590 // at the same place. It's not an issue for extensions, which are present in
591 // all the packets (their content just may be incorrect on recovered packets).
592 // In case of VideoTimingExtension, since it's present not in every packet,
593 // data after rtp header may be corrupted if these packets are protected by
594 // the FEC.
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000595 int64_t now_ms = clock_->TimeInMilliseconds();
596 int64_t diff_ms = now_ms - capture_time_ms;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200597 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
598 diff_ms);
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200599 packet_to_send->SetExtension<AbsoluteSendTime>(
600 AbsoluteSendTime::MsTo24Bits(now_ms));
sprang867fb522015-08-03 04:38:41 -0700601
Erik Språng7b52f102018-02-07 14:37:37 +0100602 if (packet_to_send->HasExtension<VideoTimingExtension>()) {
603 if (populate_network2_timestamp_) {
604 packet_to_send->set_network2_time_ms(now_ms);
605 } else {
606 packet_to_send->set_pacer_exit_time_ms(now_ms);
607 }
608 }
ilnik04f4d122017-06-19 07:18:55 -0700609
stefan1d8a5062015-10-02 03:39:33 -0700610 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200611 // If we are sending over RTX, it also means this is a retransmission.
612 // E.g. RTPSender::TrySendRedundantPayloads calls PrepareAndSendPacket with
613 // send_over_rtx = true but is_retransmit = false.
614 options.is_retransmit = is_retransmit || send_over_rtx;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200615 bool has_transport_seq_num;
616 {
617 rtc::CritScope lock(&send_critsect_);
618 has_transport_seq_num =
619 UpdateTransportSequenceNumber(packet_to_send, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200620 options.included_in_allocation =
621 has_transport_seq_num || force_part_of_allocation_;
622 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200623 }
624 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -0800625 AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
philipel8aadd502017-02-23 02:56:13 -0800626 pacing_info);
sprang867fb522015-08-03 04:38:41 -0700627 }
Dino Radaković1807d572018-02-22 14:18:06 +0100628 options.application_data.assign(packet_to_send->application_data().begin(),
629 packet_to_send->application_data().end());
sprang867fb522015-08-03 04:38:41 -0700630
asapersson35151f32016-05-02 23:44:01 -0700631 if (!is_retransmit && !send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200632 UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
633 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
634 packet->Ssrc());
stefanf116bd02015-10-27 08:29:42 -0700635 }
636
philipel32d00102017-02-27 02:18:46 -0800637 if (!SendPacketToNetwork(*packet_to_send, options, pacing_info))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200638 return false;
639
640 {
tommiae695e92016-02-02 08:31:45 -0800641 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000642 media_has_been_sent_ = true;
643 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200644 UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit);
645 return true;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000646}
647
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200648void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet,
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000649 bool is_rtx,
650 bool is_retransmit) {
sprangcd349d92016-07-13 09:11:28 -0700651 int64_t now_ms = clock_->TimeInMilliseconds();
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000652
danilchap7c9426c2016-04-14 03:05:31 -0700653 rtc::CritScope lock(&statistics_crit_);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200654 StreamDataCounters* counters = is_rtx ? &rtx_rtp_stats_ : &rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000655
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200656 total_bitrate_sent_.Update(packet.size(), now_ms);
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000657
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200658 if (counters->first_packet_time_ms == -1)
659 counters->first_packet_time_ms = now_ms;
660
Niels Möller435ea0a2019-01-28 12:52:43 +0100661 if (packet.is_fec())
Niels Möllerdbb988b2018-11-15 08:05:16 +0100662 counters->fec.AddPacket(packet);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200663
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200664 if (is_retransmit) {
Niels Möllerdbb988b2018-11-15 08:05:16 +0100665 counters->retransmitted.AddPacket(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200666 nack_bitrate_sent_.Update(packet.size(), now_ms);
667 }
Niels Möllerdbb988b2018-11-15 08:05:16 +0100668 counters->transmitted.AddPacket(packet);
sprangcd349d92016-07-13 09:11:28 -0700669
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200670 if (rtp_stats_callback_)
671 rtp_stats_callback_->DataCountersUpdated(*counters, packet.Ssrc());
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000672}
673
philipel8aadd502017-02-23 02:56:13 -0800674size_t RTPSender::TimeToSendPadding(size_t bytes,
675 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800676 if (bytes == 0)
pbos545727e2015-07-01 06:31:06 -0700677 return 0;
philipel8aadd502017-02-23 02:56:13 -0800678 size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000679 if (bytes_sent < bytes)
philipel8aadd502017-02-23 02:56:13 -0800680 bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000681 return bytes_sent;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000682}
683
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200684bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
685 StorageType storage,
686 RtpPacketSender::Priority priority) {
687 RTC_DCHECK(packet);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000688 int64_t now_ms = clock_->TimeInMilliseconds();
689
brandtr9dfff292016-11-14 05:14:50 -0800690 uint32_t ssrc = packet->Ssrc();
Peter Boströme23e7372015-10-08 11:44:14 +0200691 if (paced_sender_) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200692 uint16_t seq_no = packet->SequenceNumber();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000693 // Correct offset between implementations of millisecond time stamps in
694 // TickTime and Clock.
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200695 int64_t corrected_time_ms = packet->capture_time_ms() + clock_delta_ms_;
Per Kjellander17c147c2019-02-20 12:06:17 +0100696 size_t packet_size =
697 send_side_bwe_with_overhead_ ? packet->size() : packet->payload_size();
Niels Möller59ab1cf2019-02-06 22:48:11 +0100698 if (ssrc == FlexfecSsrc()) {
brandtr9dfff292016-11-14 05:14:50 -0800699 // Store FlexFEC packets in the history here, so they can be found
700 // when the pacer calls TimeToSendPacket.
Erik Språnga12b1d62018-03-14 12:39:24 +0100701 flexfec_packet_history_.PutRtpPacket(std::move(packet), storage,
Danil Chapovalovd264df52018-06-14 12:59:38 +0200702 absl::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800703 } else {
Danil Chapovalovd264df52018-06-14 12:59:38 +0200704 packet_history_.PutRtpPacket(std::move(packet), storage, absl::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800705 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200706
707 paced_sender_->InsertPacket(priority, ssrc, seq_no, corrected_time_ms,
Per Kjellander17c147c2019-02-20 12:06:17 +0100708 packet_size, false);
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700709 return true;
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +0000710 }
Stefan Holmerf5dca482016-01-27 12:58:51 +0100711
712 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200713 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200714
Danil Chapovalovaf52b682018-11-27 10:48:27 +0100715 // |capture_time_ms| <= 0 is considered invalid.
716 // TODO(holmer): This should be changed all over Video Engine so that negative
717 // time is consider invalid, while 0 is considered a valid time.
718 if (packet->capture_time_ms() > 0) {
719 packet->SetExtension<TransmissionOffset>(
720 kTimestampTicksPerMs * (now_ms - packet->capture_time_ms()));
721
722 if (populate_network2_timestamp_ &&
723 packet->HasExtension<VideoTimingExtension>()) {
724 packet->set_network2_time_ms(now_ms);
725 }
726 }
727 packet->SetExtension<AbsoluteSendTime>(AbsoluteSendTime::MsTo24Bits(now_ms));
728
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200729 bool has_transport_seq_num;
730 {
731 rtc::CritScope lock(&send_critsect_);
732 has_transport_seq_num =
733 UpdateTransportSequenceNumber(packet.get(), &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200734 options.included_in_allocation =
735 has_transport_seq_num || force_part_of_allocation_;
736 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200737 }
738 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -0800739 AddPacketToTransportFeedback(options.packet_id, *packet.get(),
philipel8aadd502017-02-23 02:56:13 -0800740 PacedPacketInfo());
Stefan Holmerf5dca482016-01-27 12:58:51 +0100741 }
Dino Radaković1807d572018-02-22 14:18:06 +0100742 options.application_data.assign(packet->application_data().begin(),
743 packet->application_data().end());
Stefan Holmerf5dca482016-01-27 12:58:51 +0100744
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200745 UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
746 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
747 packet->Ssrc());
748
philipel32d00102017-02-27 02:18:46 -0800749 bool sent = SendPacketToNetwork(*packet, options, PacedPacketInfo());
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200750
751 if (sent) {
752 {
753 rtc::CritScope lock(&send_critsect_);
754 media_has_been_sent_ = true;
755 }
756 UpdateRtpStats(*packet, false, false);
757 }
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +0000758
brandtr9dfff292016-11-14 05:14:50 -0800759 // To support retransmissions, we store the media packet as sent in the
760 // packet history (even if send failed).
761 if (storage == kAllowRetransmission) {
Danil Chapovalov603ce982017-12-27 11:32:50 +0100762 RTC_DCHECK_EQ(ssrc, SSRC());
Erik Språnga12b1d62018-03-14 12:39:24 +0100763 packet_history_.PutRtpPacket(std::move(packet), storage, now_ms);
brandtr9dfff292016-11-14 05:14:50 -0800764 }
Peter Boströme23e7372015-10-08 11:44:14 +0200765
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200766 return sent;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000767}
768
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200769void RTPSender::RecomputeMaxSendDelay() {
770 max_delay_it_ = send_delays_.begin();
771 for (auto it = send_delays_.begin(); it != send_delays_.end(); ++it) {
772 if (it->second >= max_delay_it_->second) {
773 max_delay_it_ = it;
774 }
775 }
776}
777
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +0000778void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
asapersson35151f32016-05-02 23:44:01 -0700779 if (!send_side_delay_observer_ || capture_time_ms <= 0)
Peter Boström71861a02015-05-28 14:45:36 +0200780 return;
781
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000782 uint32_t ssrc;
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200783 int avg_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000784 int max_delay_ms = 0;
785 {
tommiae695e92016-02-02 08:31:45 -0800786 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800787 if (!ssrc_)
788 return;
789 ssrc = *ssrc_;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000790 }
791 {
danilchap7c9426c2016-04-14 03:05:31 -0700792 rtc::CritScope cs(&statistics_crit_);
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200793 // Compute the max and average of the recent capture-to-send delays.
794 // The time complexity of the current approach depends on the distribution
795 // of the delay values. This could be done more efficiently.
796
797 // Remove elements older than kSendSideDelayWindowMs.
798 auto lower_bound =
799 send_delays_.lower_bound(now_ms - kSendSideDelayWindowMs);
800 for (auto it = send_delays_.begin(); it != lower_bound; ++it) {
801 if (max_delay_it_ == it) {
802 max_delay_it_ = send_delays_.end();
803 }
804 sum_delays_ms_ -= it->second;
805 }
806 send_delays_.erase(send_delays_.begin(), lower_bound);
807 if (max_delay_it_ == send_delays_.end()) {
808 // Removed the previous max. Need to recompute.
809 RecomputeMaxSendDelay();
810 }
811
812 // Add the new element.
Johannes Kron965e7942018-09-13 15:36:20 +0200813 RTC_DCHECK_GE(now_ms, static_cast<int64_t>(0));
814 RTC_DCHECK_LE(now_ms, std::numeric_limits<int64_t>::max() / 2);
815 RTC_DCHECK_GE(capture_time_ms, static_cast<int64_t>(0));
816 RTC_DCHECK_LE(capture_time_ms, std::numeric_limits<int64_t>::max() / 2);
817 int64_t diff_ms = now_ms - capture_time_ms;
818 RTC_DCHECK_GE(diff_ms, static_cast<int64_t>(0));
819 RTC_DCHECK_LE(diff_ms,
820 static_cast<int64_t>(std::numeric_limits<int>::max()));
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200821 int new_send_delay = rtc::dchecked_cast<int>(now_ms - capture_time_ms);
822 SendDelayMap::iterator it;
823 bool inserted;
824 std::tie(it, inserted) =
825 send_delays_.insert(std::make_pair(now_ms, new_send_delay));
826 if (!inserted) {
827 // TODO(terelius): If we have multiple delay measurements during the same
828 // millisecond then we keep the most recent one. It is not clear that this
829 // is the right decision, but it preserves an earlier behavior.
830 int previous_send_delay = it->second;
831 sum_delays_ms_ -= previous_send_delay;
832 it->second = new_send_delay;
833 if (max_delay_it_ == it && new_send_delay < previous_send_delay) {
834 RecomputeMaxSendDelay();
835 }
Peter Boström71861a02015-05-28 14:45:36 +0200836 }
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200837 if (max_delay_it_ == send_delays_.end() ||
838 it->second >= max_delay_it_->second) {
839 max_delay_it_ = it;
840 }
841 sum_delays_ms_ += new_send_delay;
842
843 size_t num_delays = send_delays_.size();
844 RTC_DCHECK(max_delay_it_ != send_delays_.end());
845 max_delay_ms = rtc::dchecked_cast<int>(max_delay_it_->second);
846 int64_t avg_ms = (sum_delays_ms_ + num_delays / 2) / num_delays;
847 RTC_DCHECK_GE(avg_ms, static_cast<int64_t>(0));
848 RTC_DCHECK_LE(avg_ms,
849 static_cast<int64_t>(std::numeric_limits<int>::max()));
850 avg_delay_ms =
851 rtc::dchecked_cast<int>((sum_delays_ms_ + num_delays / 2) / num_delays);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000852 }
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200853 send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
854 ssrc);
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +0000855}
856
asapersson35151f32016-05-02 23:44:01 -0700857void RTPSender::UpdateOnSendPacket(int packet_id,
858 int64_t capture_time_ms,
859 uint32_t ssrc) {
860 if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
861 return;
862
863 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
864}
865
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000866void RTPSender::ProcessBitrate() {
sprangcd349d92016-07-13 09:11:28 -0700867 if (!bitrate_callback_)
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000868 return;
sprangcd349d92016-07-13 09:11:28 -0700869 int64_t now_ms = clock_->TimeInMilliseconds();
870 uint32_t ssrc;
871 {
872 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800873 if (!ssrc_)
874 return;
875 ssrc = *ssrc_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000876 }
sprangcd349d92016-07-13 09:11:28 -0700877
878 rtc::CritScope lock(&statistics_crit_);
879 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0),
880 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +0000881}
882
isheriff6b4b5f32016-06-08 00:24:21 -0700883size_t RTPSender::RtpHeaderLength() const {
tommiae695e92016-02-02 08:31:45 -0800884 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000885 size_t rtp_header_length = kRtpHeaderLength;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +0000886 rtp_header_length += sizeof(uint32_t) * csrcs_.size();
Danil Chapovalov7b189922018-10-03 10:15:36 +0200887 rtp_header_length += RtpHeaderExtensionSize(kFecOrPaddingExtensionSizes,
888 rtp_header_extension_map_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000889 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +0000890}
891
mflodmanfcf54bd2015-04-14 21:28:08 +0200892uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
tommiae695e92016-02-02 08:31:45 -0800893 rtc::CritScope lock(&send_critsect_);
mflodmanfcf54bd2015-04-14 21:28:08 +0200894 uint16_t first_allocated_sequence_number = sequence_number_;
895 sequence_number_ += packets_to_send;
896 return first_allocated_sequence_number;
niklase@google.com470e71d2011-07-07 08:21:25 +0000897}
898
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000899void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
900 StreamDataCounters* rtx_stats) const {
danilchap7c9426c2016-04-14 03:05:31 -0700901 rtc::CritScope lock(&statistics_crit_);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000902 *rtp_stats = rtp_stats_;
903 *rtx_stats = rtx_rtp_stats_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000904}
905
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200906std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
907 rtc::CritScope lock(&send_critsect_);
Danil Chapovalov3b4b4f52018-10-12 12:50:43 +0200908 // TODO(danilchap): Find better motivator and value for extra capacity.
909 // RtpPacketizer might slightly miscalulate needed size,
910 // SRTP may benefit from extra space in the buffer and do encryption in place
911 // saving reallocation.
912 // While sending slightly oversized packet increase chance of dropped packet,
913 // it is better than crash on drop packet without trying to send it.
914 static constexpr int kExtraCapacity = 16;
915 auto packet = absl::make_unique<RtpPacketToSend>(
916 &rtp_header_extension_map_, max_packet_size_ + kExtraCapacity);
nisse7d59f6b2017-02-21 03:40:24 -0800917 RTC_DCHECK(ssrc_);
918 packet->SetSsrc(*ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200919 packet->SetCsrcs(csrcs_);
920 // Reserve extensions, if registered, RtpSender set in SendToNetwork.
921 packet->ReserveExtension<AbsoluteSendTime>();
922 packet->ReserveExtension<TransmissionOffset>();
923 packet->ReserveExtension<TransportSequenceNumber>();
Niels Möller6893f3c2019-01-31 08:56:26 +0100924
Steve Anton4af95842018-04-06 11:09:46 -0700925 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -0700926 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -0700927 packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -0700928 }
Amit Hilbuch77938e62018-12-21 09:23:38 -0800929 if (!rid_.empty()) {
930 // This is a no-op if the RID header extension is not registered.
931 packet->SetExtension<RtpStreamId>(rid_);
932 }
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200933 return packet;
934}
935
936bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) {
937 rtc::CritScope lock(&send_critsect_);
938 if (!sending_media_)
939 return false;
nisse7d59f6b2017-02-21 03:40:24 -0800940 RTC_DCHECK(packet->Ssrc() == ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200941 packet->SetSequenceNumber(sequence_number_++);
942
943 // Remember marker bit to determine if padding can be inserted with
944 // sequence number following |packet|.
945 last_packet_marker_bit_ = packet->Marker();
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100946 // Remember payload type to use in the padding packet if rtx is disabled.
947 last_payload_type_ = packet->PayloadType();
Danil Chapovalov5e57b172016-09-02 19:15:59 +0200948 // Save timestamps to generate timestamp field and extensions for the padding.
949 last_rtp_timestamp_ = packet->Timestamp();
950 last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
951 capture_time_ms_ = packet->capture_time_ms();
952 return true;
953}
954
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200955bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet,
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200956 int* packet_id) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200957 RTC_DCHECK(packet);
958 RTC_DCHECK(packet_id);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200959 if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId))
stefana23fc622016-07-28 07:56:38 -0700960 return false;
961
asapersson35151f32016-05-02 23:44:01 -0700962 if (!transport_sequence_number_allocator_)
963 return false;
964
965 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200966
967 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
968 return false;
969
asapersson35151f32016-05-02 23:44:01 -0700970 return true;
sprang867fb522015-08-03 04:38:41 -0700971}
972
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000973void RTPSender::SetSendingMediaStatus(bool enabled) {
tommiae695e92016-02-02 08:31:45 -0800974 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000975 sending_media_ = enabled;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000976}
977
978bool RTPSender::SendingMedia() const {
tommiae695e92016-02-02 08:31:45 -0800979 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000980 return sending_media_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000981}
982
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200983void RTPSender::SetAsPartOfAllocation(bool part_of_allocation) {
984 rtc::CritScope lock(&send_critsect_);
985 force_part_of_allocation_ = part_of_allocation;
986}
987
danilchap71fead22016-08-18 02:01:49 -0700988void RTPSender::SetTimestampOffset(uint32_t timestamp) {
tommiae695e92016-02-02 08:31:45 -0800989 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -0700990 timestamp_offset_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000991}
992
danilchap71fead22016-08-18 02:01:49 -0700993uint32_t RTPSender::TimestampOffset() const {
tommiae695e92016-02-02 08:31:45 -0800994 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -0700995 return timestamp_offset_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000996}
997
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000998void RTPSender::SetSSRC(uint32_t ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000999 // This is configured via the API.
tommiae695e92016-02-02 08:31:45 -08001000 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +00001001
nisse7d59f6b2017-02-21 03:40:24 -08001002 if (ssrc_ == ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001003 return; // Since it's same ssrc, don't reset anything.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001004 }
nisse7d59f6b2017-02-21 03:40:24 -08001005 ssrc_.emplace(ssrc);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001006 if (!sequence_number_forced_) {
danilchap47a740b2015-12-15 00:30:07 -08001007 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001008 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001009}
1010
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001011uint32_t RTPSender::SSRC() const {
tommiae695e92016-02-02 08:31:45 -08001012 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001013 RTC_DCHECK(ssrc_);
1014 return *ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001015}
1016
Amit Hilbuch77938e62018-12-21 09:23:38 -08001017void RTPSender::SetRid(const std::string& rid) {
1018 // RID is used in simulcast scenario when multiple layers share the same mid.
1019 rtc::CritScope lock(&send_critsect_);
1020 RTC_DCHECK_LE(rid.length(), RtpStreamId::kMaxValueSizeBytes);
1021 rid_ = rid;
1022}
1023
Steve Anton296a0ce2018-03-22 15:17:27 -07001024void RTPSender::SetMid(const std::string& mid) {
1025 // This is configured via the API.
1026 rtc::CritScope lock(&send_critsect_);
Steve Anton4af95842018-04-06 11:09:46 -07001027 mid_ = mid;
Steve Anton296a0ce2018-03-22 15:17:27 -07001028}
1029
Danil Chapovalovd264df52018-06-14 12:59:38 +02001030absl::optional<uint32_t> RTPSender::FlexfecSsrc() const {
Niels Möller59ab1cf2019-02-06 22:48:11 +01001031 return flexfec_ssrc_;
brandtr9dfff292016-11-14 05:14:50 -08001032}
1033
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001034void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
spranga8ae6f22017-09-04 07:23:56 -07001035 RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
tommiae695e92016-02-02 08:31:45 -08001036 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001037 csrcs_ = csrcs;
niklase@google.com470e71d2011-07-07 08:21:25 +00001038}
1039
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001040void RTPSender::SetSequenceNumber(uint16_t seq) {
tommiae695e92016-02-02 08:31:45 -08001041 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001042 sequence_number_forced_ = true;
1043 sequence_number_ = seq;
niklase@google.com470e71d2011-07-07 08:21:25 +00001044}
1045
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001046uint16_t RTPSender::SequenceNumber() const {
tommiae695e92016-02-02 08:31:45 -08001047 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001048 return sequence_number_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001049}
1050
Danil Chapovalov271195f2019-02-11 11:30:03 +01001051static void CopyHeaderAndExtensionsToRtxPacket(const RtpPacketToSend& packet,
1052 RtpPacketToSend* rtx_packet) {
Amit Hilbuch77938e62018-12-21 09:23:38 -08001053 // Set the relevant fixed packet headers. The following are not set:
1054 // * Payload type - it is replaced in rtx packets.
1055 // * Sequence number - RTX has a separate sequence numbering.
1056 // * SSRC - RTX stream has its own SSRC.
1057 rtx_packet->SetMarker(packet.Marker());
1058 rtx_packet->SetTimestamp(packet.Timestamp());
1059
1060 // Set the variable fields in the packet header:
1061 // * CSRCs - must be set before header extensions.
1062 // * Header extensions - replace Rid header with RepairedRid header.
1063 const std::vector<uint32_t> csrcs = packet.Csrcs();
1064 rtx_packet->SetCsrcs(csrcs);
1065 for (int extension = kRtpExtensionNone + 1;
1066 extension < kRtpExtensionNumberOfExtensions; ++extension) {
1067 RTPExtensionType source_extension =
1068 static_cast<RTPExtensionType>(extension);
1069 // Rid header should be replaced with RepairedRid header
1070 RTPExtensionType destination_extension =
1071 source_extension == kRtpExtensionRtpStreamId
1072 ? kRtpExtensionRepairedRtpStreamId
1073 : source_extension;
1074
1075 // Empty extensions should be supported, so not checking |source.empty()|.
1076 if (!packet.HasExtension(source_extension)) {
1077 continue;
1078 }
1079
1080 rtc::ArrayView<const uint8_t> source =
1081 packet.FindExtension(source_extension);
1082
1083 rtc::ArrayView<uint8_t> destination =
1084 rtx_packet->AllocateExtension(destination_extension, source.size());
1085
1086 // Could happen if any:
1087 // 1. Extension has 0 length.
1088 // 2. Extension is not registered in destination.
1089 // 3. Allocating extension in destination failed.
1090 if (destination.empty() || source.size() != destination.size()) {
1091 continue;
1092 }
1093
1094 std::memcpy(destination.begin(), source.begin(), destination.size());
1095 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001096}
1097
1098std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
1099 const RtpPacketToSend& packet) {
Danil Chapovalov271195f2019-02-11 11:30:03 +01001100 std::unique_ptr<RtpPacketToSend> rtx_packet;
Amit Hilbuch77938e62018-12-21 09:23:38 -08001101
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001102 // Add original RTP header.
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001103 {
1104 rtc::CritScope lock(&send_critsect_);
1105 if (!sending_media_)
1106 return nullptr;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001107
nisse7d59f6b2017-02-21 03:40:24 -08001108 RTC_DCHECK(ssrc_rtx_);
1109
brandtre6f98c72016-11-11 03:28:30 -08001110 // Replace payload type.
1111 auto kv = rtx_payload_type_map_.find(packet.PayloadType());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001112 if (kv == rtx_payload_type_map_.end())
brandtre6f98c72016-11-11 03:28:30 -08001113 return nullptr;
Danil Chapovalov271195f2019-02-11 11:30:03 +01001114
1115 rtx_packet = absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_,
1116 max_packet_size_);
1117
brandtre6f98c72016-11-11 03:28:30 -08001118 rtx_packet->SetPayloadType(kv->second);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +00001119
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001120 // Replace sequence number.
1121 rtx_packet->SetSequenceNumber(sequence_number_rtx_++);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001122
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001123 // Replace SSRC.
nisse7d59f6b2017-02-21 03:40:24 -08001124 rtx_packet->SetSsrc(*ssrc_rtx_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001125
Danil Chapovalov271195f2019-02-11 11:30:03 +01001126 CopyHeaderAndExtensionsToRtxPacket(packet, rtx_packet.get());
1127
Amit Hilbuch77938e62018-12-21 09:23:38 -08001128 // The spec indicates that it is possible for a sender to stop sending mids
1129 // once the SSRCs have been bound on the receiver. As a result the source
1130 // rtp packet might not have the MID header extension set.
1131 // However, the SSRC of the RTX stream might not have been bound on the
1132 // receiver. This means that we should include it here.
1133 // The same argument goes for the Repaired RID extension.
Steve Anton4af95842018-04-06 11:09:46 -07001134 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001135 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001136 rtx_packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001137 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001138 if (!rid_.empty()) {
1139 // This is a no-op if the Repaired-RID header extension is not registered.
1140 // rtx_packet->SetExtension<RepairedRtpStreamId>(rid_);
1141 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001142 }
Danil Chapovalov271195f2019-02-11 11:30:03 +01001143 RTC_DCHECK(rtx_packet);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001144
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001145 uint8_t* rtx_payload =
1146 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize);
Danil Chapovalov271195f2019-02-11 11:30:03 +01001147 if (rtx_payload == nullptr)
1148 return nullptr;
1149
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001150 // Add OSN (original sequence number).
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001151 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber());
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001152
1153 // Add original payload data.
danilchap96c15872016-11-21 01:35:29 -08001154 auto payload = packet.payload();
1155 memcpy(rtx_payload + kRtxHeaderSize, payload.data(), payload.size());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001156
Dino Radaković1807d572018-02-22 14:18:06 +01001157 // Add original application data.
1158 rtx_packet->set_application_data(packet.application_data());
1159
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001160 return rtx_packet;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001161}
1162
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001163void RTPSender::RegisterRtpStatisticsCallback(
1164 StreamDataCountersCallback* callback) {
danilchap7c9426c2016-04-14 03:05:31 -07001165 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001166 rtp_stats_callback_ = callback;
1167}
1168
1169StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
danilchap7c9426c2016-04-14 03:05:31 -07001170 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001171 return rtp_stats_callback_;
1172}
1173
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001174uint32_t RTPSender::BitrateSent() const {
sprangcd349d92016-07-13 09:11:28 -07001175 rtc::CritScope cs(&statistics_crit_);
1176 return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001177}
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001178
1179void RTPSender::SetRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001180 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001181 sequence_number_ = rtp_state.sequence_number;
1182 sequence_number_forced_ = true;
danilchap71fead22016-08-18 02:01:49 -07001183 timestamp_offset_ = rtp_state.start_timestamp;
danilchape5b41412016-08-22 03:39:23 -07001184 last_rtp_timestamp_ = rtp_state.timestamp;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001185 capture_time_ms_ = rtp_state.capture_time_ms;
1186 last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001187 media_has_been_sent_ = rtp_state.media_has_been_sent;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001188}
1189
1190RtpState RTPSender::GetRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001191 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001192
1193 RtpState state;
1194 state.sequence_number = sequence_number_;
danilchap71fead22016-08-18 02:01:49 -07001195 state.start_timestamp = timestamp_offset_;
danilchape5b41412016-08-22 03:39:23 -07001196 state.timestamp = last_rtp_timestamp_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001197 state.capture_time_ms = capture_time_ms_;
1198 state.last_timestamp_time_ms = last_timestamp_time_ms_;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001199 state.media_has_been_sent = media_has_been_sent_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001200
1201 return state;
1202}
1203
1204void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001205 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001206 sequence_number_rtx_ = rtp_state.sequence_number;
1207}
1208
1209RtpState RTPSender::GetRtxRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001210 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001211
1212 RtpState state;
1213 state.sequence_number = sequence_number_rtx_;
danilchap71fead22016-08-18 02:01:49 -07001214 state.start_timestamp = timestamp_offset_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001215
1216 return state;
1217}
1218
philipel8aadd502017-02-23 02:56:13 -08001219void RTPSender::AddPacketToTransportFeedback(
1220 uint16_t packet_id,
1221 const RtpPacketToSend& packet,
1222 const PacedPacketInfo& pacing_info) {
michaelt4da30442016-11-17 01:38:43 -08001223 if (transport_feedback_observer_) {
Erik Språng30a276b2019-04-23 12:00:11 +02001224 size_t packet_size = packet.payload_size() + packet.padding_size();
1225 if (send_side_bwe_with_overhead_) {
1226 packet_size = packet.size();
1227 }
1228
1229 RtpPacketSendInfo packet_info;
1230 packet_info.ssrc = SSRC();
1231 packet_info.transport_sequence_number = packet_id;
Erik Språng490d76c2019-05-07 09:29:15 -07001232 packet_info.has_rtp_sequence_number = true;
Erik Språng30a276b2019-04-23 12:00:11 +02001233 packet_info.rtp_sequence_number = packet.SequenceNumber();
1234 packet_info.length = packet_size;
1235 packet_info.pacing_info = pacing_info;
1236 transport_feedback_observer_->OnAddPacket(packet_info);
michaelt4da30442016-11-17 01:38:43 -08001237 }
1238}
1239
1240void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
1241 if (!overhead_observer_)
1242 return;
nisse284542b2017-01-10 08:58:32 -08001243 size_t overhead_bytes_per_packet;
michaelt4da30442016-11-17 01:38:43 -08001244 {
1245 rtc::CritScope lock(&send_critsect_);
1246 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
1247 return;
1248 }
1249 rtp_overhead_bytes_per_packet_ = packet.headers_size();
nisse284542b2017-01-10 08:58:32 -08001250 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
michaelt4da30442016-11-17 01:38:43 -08001251 }
1252 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
1253}
1254
sprang168794c2017-07-06 04:38:06 -07001255int64_t RTPSender::LastTimestampTimeMs() const {
1256 rtc::CritScope lock(&send_critsect_);
1257 return last_timestamp_time_ms_;
1258}
1259
Erik Språng8b101922018-01-18 11:58:05 -08001260void RTPSender::SetRtt(int64_t rtt_ms) {
1261 packet_history_.SetRtt(rtt_ms);
1262 flexfec_packet_history_.SetRtt(rtt_ms);
1263}
Erik Språng490d76c2019-05-07 09:29:15 -07001264
1265void RTPSender::OnPacketsAcknowledged(
1266 rtc::ArrayView<const uint16_t> sequence_numbers) {
1267 packet_history_.CullAcknowledgedPackets(sequence_numbers);
1268}
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001269} // namespace webrtc