blob: ac82262928d74c51116ca8eec27cca75b4c5ee53 [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
Erik Språng214f5432019-06-20 15:09:58 +020050// Min size needed to get payload padding from packet history.
51constexpr int kMinPayloadPaddingBytes = 50;
52
erikvarga27883732017-05-17 05:08:38 -070053template <typename Extension>
54constexpr RtpExtensionSize CreateExtensionSize() {
55 return {Extension::kId, Extension::kValueSizeBytes};
56}
57
Amit Hilbuch77938e62018-12-21 09:23:38 -080058template <typename Extension>
59constexpr RtpExtensionSize CreateMaxExtensionSize() {
60 return {Extension::kId, Extension::kMaxValueSizeBytes};
61}
62
erikvarga27883732017-05-17 05:08:38 -070063// Size info for header extensions that might be used in padding or FEC packets.
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010064constexpr RtpExtensionSize kFecOrPaddingExtensionSizes[] = {
erikvarga27883732017-05-17 05:08:38 -070065 CreateExtensionSize<AbsoluteSendTime>(),
66 CreateExtensionSize<TransmissionOffset>(),
67 CreateExtensionSize<TransportSequenceNumber>(),
68 CreateExtensionSize<PlayoutDelayLimits>(),
Amit Hilbuch77938e62018-12-21 09:23:38 -080069 CreateMaxExtensionSize<RtpMid>(),
erikvarga27883732017-05-17 05:08:38 -070070};
71
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010072// Size info for header extensions that might be used in video packets.
73constexpr RtpExtensionSize kVideoExtensionSizes[] = {
74 CreateExtensionSize<AbsoluteSendTime>(),
75 CreateExtensionSize<TransmissionOffset>(),
76 CreateExtensionSize<TransportSequenceNumber>(),
77 CreateExtensionSize<PlayoutDelayLimits>(),
78 CreateExtensionSize<VideoOrientation>(),
79 CreateExtensionSize<VideoContentTypeExtension>(),
80 CreateExtensionSize<VideoTimingExtension>(),
Amit Hilbuch77938e62018-12-21 09:23:38 -080081 CreateMaxExtensionSize<RtpStreamId>(),
82 CreateMaxExtensionSize<RepairedRtpStreamId>(),
83 CreateMaxExtensionSize<RtpMid>(),
Elad Alonccb9b752019-02-19 13:01:31 +010084 {RtpGenericFrameDescriptorExtension00::kId,
85 RtpGenericFrameDescriptorExtension00::kMaxSizeBytes},
86 {RtpGenericFrameDescriptorExtension01::kId,
87 RtpGenericFrameDescriptorExtension01::kMaxSizeBytes},
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010088};
89
Erik Språng13eb7642019-06-24 10:58:48 +020090// TODO(bugs.webrtc.org/10633): Remove when downstream code stops using
91// priority. At the time of writing, the priority can be directly mapped to a
92// packet type. This is only for a transition period.
93RtpPacketToSend::Type PacketPriorityToType(RtpPacketSender::Priority priority) {
94 switch (priority) {
95 case RtpPacketSender::Priority::kLowPriority:
96 return RtpPacketToSend::Type::kVideo;
97 case RtpPacketSender::Priority::kNormalPriority:
98 return RtpPacketToSend::Type::kRetransmission;
99 case RtpPacketSender::Priority::kHighPriority:
100 return RtpPacketToSend::Type::kAudio;
101 default:
102 RTC_NOTREACHED() << "Unexpected priority: " << priority;
103 return RtpPacketToSend::Type::kVideo;
104 }
105}
106
107// TODO(bugs.webrtc.org/10633): Remove when packets are always owned by pacer.
108RtpPacketSender::Priority PacketTypeToPriority(RtpPacketToSend::Type type) {
109 switch (type) {
110 case RtpPacketToSend::Type::kAudio:
111 return RtpPacketSender::Priority::kHighPriority;
112 case RtpPacketToSend::Type::kVideo:
113 return RtpPacketSender::Priority::kLowPriority;
114 case RtpPacketToSend::Type::kRetransmission:
115 return RtpPacketSender::Priority::kNormalPriority;
116 case RtpPacketToSend::Type::kForwardErrorCorrection:
117 return RtpPacketSender::Priority::kLowPriority;
118 break;
119 case RtpPacketToSend::Type::kPadding:
120 RTC_NOTREACHED() << "Unexpected type for legacy path: kPadding";
121 break;
122 }
123 return RtpPacketSender::Priority::kLowPriority;
124}
125
hclam@chromium.org806dc3b2013-04-09 19:54:10 +0000126} // namespace
127
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000128RTPSender::RTPSender(
129 bool audio,
130 Clock* clock,
131 Transport* transport,
132 RtpPacketPacer* paced_sender,
133 absl::optional<uint32_t> flexfec_ssrc,
134 TransportSequenceNumberAllocator* sequence_number_allocator,
135 TransportFeedbackObserver* transport_feedback_observer,
136 BitrateStatisticsObserver* bitrate_callback,
137 SendSideDelayObserver* send_side_delay_observer,
138 RtcEventLog* event_log,
139 SendPacketObserver* send_packet_observer,
140 RateLimiter* retransmission_rate_limiter,
141 OverheadObserver* overhead_observer,
142 bool populate_network2_timestamp,
143 FrameEncryptorInterface* frame_encryptor,
144 bool require_frame_encryption,
145 bool extmap_allow_mixed,
146 const WebRtcKeyValueConfig& field_trials)
147 : clock_(clock),
danilchap47a740b2015-12-15 00:30:07 -0800148 random_(clock_->TimeInMicroseconds()),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000149 audio_configured_(audio),
150 flexfec_ssrc_(flexfec_ssrc),
151 paced_sender_(paced_sender),
152 transport_sequence_number_allocator_(sequence_number_allocator),
153 transport_feedback_observer_(transport_feedback_observer),
154 transport_(transport),
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200155 sending_media_(true), // Default to sending media.
156 force_part_of_allocation_(false),
nisse284542b2017-01-10 08:58:32 -0800157 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100158 last_payload_type_(-1),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000159 rtp_header_extension_map_(extmap_allow_mixed),
160 packet_history_(clock),
161 flexfec_packet_history_(clock),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000162 // Statistics
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200163 send_delays_(),
164 max_delay_it_(send_delays_.end()),
165 sum_delays_ms_(0),
Henrik Boström9fe18342019-05-16 18:38:20 +0200166 total_packet_send_delay_ms_(0),
sprangcd349d92016-07-13 09:11:28 -0700167 rtp_stats_callback_(nullptr),
168 total_bitrate_sent_(kBitrateStatisticsWindowMs,
169 RateStatistics::kBpsScale),
170 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000171 send_side_delay_observer_(send_side_delay_observer),
172 event_log_(event_log),
173 send_packet_observer_(send_packet_observer),
174 bitrate_callback_(bitrate_callback),
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000175 // RTP variables
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000176 sequence_number_forced_(false),
danilchape5b41412016-08-22 03:39:23 -0700177 last_rtp_timestamp_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000178 capture_time_ms_(0),
179 last_timestamp_time_ms_(0),
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000180 media_has_been_sent_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000181 last_packet_marker_bit_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000182 csrcs_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000183 rtx_(kRtxOff),
michaelt4da30442016-11-17 01:38:43 -0800184 rtp_overhead_bytes_per_packet_(0),
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000185 retransmission_rate_limiter_(retransmission_rate_limiter),
186 overhead_observer_(overhead_observer),
187 populate_network2_timestamp_(populate_network2_timestamp),
elad.alonc3dfff32017-01-26 02:46:55 -0800188 send_side_bwe_with_overhead_(
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000189 field_trials.Lookup("WebRTC-SendSideBwe-WithOverhead")
190 .find("Enabled") == 0),
Erik Språngd2a63442019-05-03 10:58:50 -0400191 legacy_packet_history_storage_mode_(
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000192 field_trials.Lookup("WebRTC-UseRtpPacketHistoryLegacyStorageMode")
193 .find("Enabled") == 0),
Erik Språng4ffed7c2019-05-28 11:18:04 +0200194 payload_padding_prefer_useful_packets_(
Amit Hilbuch02d7d352019-07-02 21:04:57 +0000195 field_trials.Lookup("WebRTC-PayloadPadding-UseMostUsefulPacket")
196 .find("Disabled") != 0) {
danilchap71fead22016-08-18 02:01:49 -0700197 // This random initialization is not intended to be cryptographic strong.
198 timestamp_offset_ = random_.Rand<uint32_t>();
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000199 // Random start, 16 bits. Can't be 0.
danilchap47a740b2015-12-15 00:30:07 -0800200 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
201 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
brandtr9dfff292016-11-14 05:14:50 -0800202
203 // Store FlexFEC packets in the packet history data structure, so they can
204 // be found when paced.
Niels Möller59ab1cf2019-02-06 22:48:11 +0100205 if (flexfec_ssrc_) {
Erik Språngd2a63442019-05-03 10:58:50 -0400206 RtpPacketHistory::StorageMode storage_mode =
207 legacy_packet_history_storage_mode_
208 ? RtpPacketHistory::StorageMode::kStore
209 : RtpPacketHistory::StorageMode::kStoreAndCull;
210
brandtr9dfff292016-11-14 05:14:50 -0800211 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språngd2a63442019-05-03 10:58:50 -0400212 storage_mode, kMinFlexfecPacketsToStoreForPacing);
brandtr9dfff292016-11-14 05:14:50 -0800213 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000214}
215
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000216RTPSender::~RTPSender() {
tommiae695e92016-02-02 08:31:45 -0800217 // TODO(tommi): Use a thread checker to ensure the object is created and
218 // deleted on the same thread. At the moment this isn't possible due to
219 // voe::ChannelOwner in voice engine. To reproduce, run:
220 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
221
222 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
223 // variables but we grab them in all other methods. (what's the design?)
224 // Start documenting what thread we're on in what method so that it's easier
225 // to understand performance attributes and possibly remove locks.
niklase@google.com470e71d2011-07-07 08:21:25 +0000226}
niklase@google.com470e71d2011-07-07 08:21:25 +0000227
erikvarga27883732017-05-17 05:08:38 -0700228rtc::ArrayView<const RtpExtensionSize> RTPSender::FecExtensionSizes() {
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +0100229 return rtc::MakeArrayView(kFecOrPaddingExtensionSizes,
230 arraysize(kFecOrPaddingExtensionSizes));
231}
232
233rtc::ArrayView<const RtpExtensionSize> RTPSender::VideoExtensionSizes() {
234 return rtc::MakeArrayView(kVideoExtensionSizes,
235 arraysize(kVideoExtensionSizes));
erikvarga27883732017-05-17 05:08:38 -0700236}
237
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000238uint16_t RTPSender::ActualSendBitrateKbit() const {
sprangcd349d92016-07-13 09:11:28 -0700239 rtc::CritScope cs(&statistics_crit_);
240 return static_cast<uint16_t>(
241 total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0) /
242 1000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000243}
244
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000245uint32_t RTPSender::NackOverheadRate() const {
sprangcd349d92016-07-13 09:11:28 -0700246 rtc::CritScope cs(&statistics_crit_);
247 return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000248}
249
Johannes Kron9190b822018-10-29 11:22:05 +0100250void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) {
251 rtc::CritScope lock(&send_critsect_);
252 rtp_header_extension_map_.SetExtmapAllowMixed(extmap_allow_mixed);
253}
254
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000255int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
256 uint8_t id) {
tommiae695e92016-02-02 08:31:45 -0800257 rtc::CritScope lock(&send_critsect_);
danilchapfab482b2017-04-04 02:33:48 -0700258 return rtp_header_extension_map_.RegisterByType(id, type) ? 0 : -1;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000259}
260
Danil Chapovalov585d1aa2018-09-14 18:29:32 +0200261bool RTPSender::RegisterRtpHeaderExtension(const std::string& uri, int id) {
262 rtc::CritScope lock(&send_critsect_);
263 return rtp_header_extension_map_.RegisterByUri(id, uri);
264}
265
stefan53b6cc32017-02-03 08:13:57 -0800266bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) const {
tommiae695e92016-02-02 08:31:45 -0800267 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000268 return rtp_header_extension_map_.IsRegistered(type);
269}
270
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000271int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800272 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000273 return rtp_header_extension_map_.Deregister(type);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000274}
275
nisse284542b2017-01-10 08:58:32 -0800276void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
kwibergee89e782017-08-09 17:22:01 -0700277 RTC_DCHECK_GE(max_packet_size, 100);
278 RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
tommiae695e92016-02-02 08:31:45 -0800279 rtc::CritScope lock(&send_critsect_);
nisse284542b2017-01-10 08:58:32 -0800280 max_packet_size_ = max_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25 +0000281}
282
nisse284542b2017-01-10 08:58:32 -0800283size_t RTPSender::MaxRtpPacketSize() const {
284 return max_packet_size_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000285}
286
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000287void RTPSender::SetRtxStatus(int mode) {
tommiae695e92016-02-02 08:31:45 -0800288 rtc::CritScope lock(&send_critsect_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000289 rtx_ = mode;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000290}
291
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000292int RTPSender::RtxStatus() const {
tommiae695e92016-02-02 08:31:45 -0800293 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000294 return rtx_;
295}
296
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000297void RTPSender::SetRtxSsrc(uint32_t ssrc) {
tommiae695e92016-02-02 08:31:45 -0800298 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800299 ssrc_rtx_.emplace(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000300}
301
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000302uint32_t RTPSender::RtxSsrc() const {
tommiae695e92016-02-02 08:31:45 -0800303 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800304 RTC_DCHECK(ssrc_rtx_);
305 return *ssrc_rtx_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000306}
307
Shao Changbine62202f2015-04-21 20:24:50 +0800308void RTPSender::SetRtxPayloadType(int payload_type,
309 int associated_payload_type) {
tommiae695e92016-02-02 08:31:45 -0800310 rtc::CritScope lock(&send_critsect_);
henrikg91d6ede2015-09-17 00:24:34 -0700311 RTC_DCHECK_LE(payload_type, 127);
312 RTC_DCHECK_LE(associated_payload_type, 127);
Shao Changbine62202f2015-04-21 20:24:50 +0800313 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100314 RTC_LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type << ".";
Shao Changbine62202f2015-04-21 20:24:50 +0800315 return;
316 }
317
318 rtx_payload_type_map_[associated_payload_type] = payload_type;
Åsa Persson6ae25722015-04-13 17:48:08 +0200319}
320
philipela1ed0b32016-06-01 06:31:17 -0700321size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
philipel8aadd502017-02-23 02:56:13 -0800322 const PacedPacketInfo& pacing_info) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000323 {
tommiae695e92016-02-02 08:31:45 -0800324 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100325 if (!sending_media_)
326 return 0;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000327 if ((rtx_ & kRtxRedundantPayloads) == 0)
328 return 0;
329 }
330
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000331 int bytes_left = static_cast<int>(bytes_to_send);
Erik Språng214f5432019-06-20 15:09:58 +0200332 while (bytes_left >= kMinPayloadPaddingBytes) {
Erik Språng4ffed7c2019-05-28 11:18:04 +0200333 std::unique_ptr<RtpPacketToSend> packet;
334 if (payload_padding_prefer_useful_packets_) {
335 packet = packet_history_.GetPayloadPaddingPacket();
336 } else {
337 packet = packet_history_.GetBestFittingPacket(bytes_left);
338 }
339
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200340 if (!packet)
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000341 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200342 size_t payload_size = packet->payload_size();
philipel8aadd502017-02-23 02:56:13 -0800343 if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000344 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200345 bytes_left -= payload_size;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000346 }
347 return bytes_to_send - bytes_left;
348}
349
philipel8aadd502017-02-23 02:56:13 -0800350size_t RTPSender::SendPadData(size_t bytes,
351 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800352 size_t padding_bytes_in_packet;
erikvarga76a55932017-05-17 07:50:17 -0700353 size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
erikvarga27883732017-05-17 05:08:38 -0700354
stefan53b6cc32017-02-03 08:13:57 -0800355 if (audio_configured_) {
356 // Allow smaller padding packets for audio.
Erik Språng478cb462019-06-26 15:49:27 +0200357 padding_bytes_in_packet =
358 rtc::SafeClamp(bytes, kMinAudioPaddingLength,
359 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
stefan53b6cc32017-02-03 08:13:57 -0800360 } else {
361 // Always send full padding packets. This is accounted for by the
362 // RtpPacketSender, which will make sure we don't send too much padding even
363 // if a single packet is larger than requested.
364 // We do this to avoid frequently sending small packets on higher bitrates.
Erik Språng478cb462019-06-26 15:49:27 +0200365 padding_bytes_in_packet = rtc::SafeMin(max_payload_size, kMaxPaddingLength);
stefan53b6cc32017-02-03 08:13:57 -0800366 }
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000367 size_t bytes_sent = 0;
danilchap90069872016-12-14 06:16:33 -0800368 while (bytes_sent < bytes) {
369 int64_t now_ms = clock_->TimeInMilliseconds();
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000370 uint32_t ssrc;
danilchap90069872016-12-14 06:16:33 -0800371 uint32_t timestamp;
372 int64_t capture_time_ms;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000373 uint16_t sequence_number;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000374 int payload_type;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000375 bool over_rtx;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000376 {
tommiae695e92016-02-02 08:31:45 -0800377 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100378 if (!sending_media_)
danilchap90069872016-12-14 06:16:33 -0800379 break;
380 timestamp = last_rtp_timestamp_;
381 capture_time_ms = capture_time_ms_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000382 if (rtx_ == kRtxOff) {
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100383 if (last_payload_type_ == -1)
stefane35f89a2017-02-01 09:06:25 -0800384 break;
stefan53b6cc32017-02-03 08:13:57 -0800385 // Without RTX we can't send padding in the middle of frames.
386 // For audio marker bits doesn't mark the end of a frame and frames
387 // are usually a single packet, so for now we don't apply this rule
388 // for audio.
389 if (!audio_configured_ && !last_packet_marker_bit_) {
390 break;
391 }
nisse7d59f6b2017-02-21 03:40:24 -0800392 if (!ssrc_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100393 RTC_LOG(LS_ERROR) << "SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800394 return 0;
395 }
396
397 RTC_DCHECK(ssrc_);
398 ssrc = *ssrc_;
399
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000400 sequence_number = sequence_number_;
401 ++sequence_number_;
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100402 payload_type = last_payload_type_;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000403 over_rtx = false;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000404 } else {
Stefan Holmerf5dca482016-01-27 12:58:51 +0100405 // Without abs-send-time or transport sequence number a media packet
406 // must be sent before padding so that the timestamps used for
407 // estimation are correct.
408 if (!media_has_been_sent_ &&
danilchap90069872016-12-14 06:16:33 -0800409 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
410 (rtp_header_extension_map_.IsRegistered(
411 TransportSequenceNumber::kId) &&
412 transport_sequence_number_allocator_))) {
413 break;
Stefan Holmerf5dca482016-01-27 12:58:51 +0100414 }
Stefan Holmer586b19b2015-09-18 11:14:31 +0200415 // Only change change the timestamp of padding packets sent over RTX.
416 // Padding only packets over RTP has to be sent as part of a media
417 // frame (and therefore the same timestamp).
418 if (last_timestamp_time_ms_ > 0) {
419 timestamp +=
danilchap90069872016-12-14 06:16:33 -0800420 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
421 capture_time_ms += (now_ms - last_timestamp_time_ms_);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200422 }
nisse7d59f6b2017-02-21 03:40:24 -0800423 if (!ssrc_rtx_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100424 RTC_LOG(LS_ERROR) << "RTX SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800425 return 0;
426 }
427 RTC_DCHECK(ssrc_rtx_);
428 ssrc = *ssrc_rtx_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000429 sequence_number = sequence_number_rtx_;
430 ++sequence_number_rtx_;
Stefan Holmer10880012016-02-03 13:29:59 +0100431 payload_type = rtx_payload_type_map_.begin()->second;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000432 over_rtx = true;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000433 }
434 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000435
danilchap90069872016-12-14 06:16:33 -0800436 RtpPacketToSend padding_packet(&rtp_header_extension_map_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200437 padding_packet.SetPayloadType(payload_type);
438 padding_packet.SetMarker(false);
439 padding_packet.SetSequenceNumber(sequence_number);
440 padding_packet.SetTimestamp(timestamp);
441 padding_packet.SetSsrc(ssrc);
442
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000443 if (capture_time_ms > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200444 padding_packet.SetExtension<TransmissionOffset>(
danilchap90069872016-12-14 06:16:33 -0800445 (now_ms - capture_time_ms) * kTimestampTicksPerMs);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000446 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200447 padding_packet.SetExtension<AbsoluteSendTime>(
448 AbsoluteSendTime::MsTo24Bits(now_ms));
stefan1d8a5062015-10-02 03:39:33 -0700449 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200450 // Padding packets are never retransmissions.
451 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200452 bool has_transport_seq_num;
453 {
454 rtc::CritScope lock(&send_critsect_);
455 has_transport_seq_num =
456 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200457 options.included_in_allocation =
458 has_transport_seq_num || force_part_of_allocation_;
459 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200460 }
Danil Chapovalovf7fcaf02018-10-10 14:56:01 +0200461 padding_packet.SetPadding(padding_bytes_in_packet);
michaelt4da30442016-11-17 01:38:43 -0800462 if (has_transport_seq_num) {
463 AddPacketToTransportFeedback(options.packet_id, padding_packet,
philipel8aadd502017-02-23 02:56:13 -0800464 pacing_info);
michaelt4da30442016-11-17 01:38:43 -0800465 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200466
philipel32d00102017-02-27 02:18:46 -0800467 if (!SendPacketToNetwork(padding_packet, options, pacing_info))
stefanf116bd02015-10-27 08:29:42 -0700468 break;
469
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000470 bytes_sent += padding_bytes_in_packet;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200471 UpdateRtpStats(padding_packet, over_rtx, false);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000472 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000473
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000474 return bytes_sent;
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000475}
476
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000477void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
Erik Språngd2a63442019-05-03 10:58:50 -0400478 RtpPacketHistory::StorageMode mode;
479 if (enable) {
480 mode = legacy_packet_history_storage_mode_
481 ? RtpPacketHistory::StorageMode::kStore
482 : RtpPacketHistory::StorageMode::kStoreAndCull;
483 } else {
484 mode = RtpPacketHistory::StorageMode::kDisabled;
485 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100486 packet_history_.SetStorePacketsStatus(mode, number_to_store);
niklase@google.com470e71d2011-07-07 08:21:25 +0000487}
488
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000489bool RTPSender::StorePackets() const {
Erik Språnga12b1d62018-03-14 12:39:24 +0100490 return packet_history_.GetStorageMode() !=
491 RtpPacketHistory::StorageMode::kDisabled;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000492}
niklase@google.com470e71d2011-07-07 08:21:25 +0000493
Erik Språnga12b1d62018-03-14 12:39:24 +0100494int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
495 // Try to find packet in RTP packet history. Also verify RTT here, so that we
496 // don't retransmit too often.
Danil Chapovalovd264df52018-06-14 12:59:38 +0200497 absl::optional<RtpPacketHistory::PacketState> stored_packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200498 packet_history_.GetPacketState(packet_id);
Erik Språng0f4f0552019-05-08 10:15:05 -0700499 if (!stored_packet || stored_packet->pending_transmission) {
500 // Packet not found or already queued for retransmission, ignore.
asapersson@webrtc.org83ed0a42012-04-23 12:43:05 +0000501 return 0;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000502 }
Oleh Prypin5a980492018-03-09 12:27:24 +0000503
Per Kjellander252725d2019-02-20 13:14:34 +0100504 const int32_t packet_size = static_cast<int32_t>(stored_packet->packet_size);
Erik Språnga12b1d62018-03-14 12:39:24 +0100505
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200506 // Skip retransmission rate check if not configured.
507 if (retransmission_rate_limiter_) {
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200508 // Check if we're overusing retransmission bitrate.
509 // TODO(sprang): Add histograms for nack success or failure reasons.
Ilya Nikolaevskiy23b2a252018-10-10 15:17:39 +0200510 if (!retransmission_rate_limiter_->TryUseRate(packet_size)) {
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200511 return -1;
512 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100513 }
Erik Språng7bb37b82018-03-09 09:52:59 +0100514
Oleh Prypin5a980492018-03-09 12:27:24 +0000515 if (paced_sender_) {
Erik Språng0f4f0552019-05-08 10:15:05 -0700516 // Mark packet as being in pacer queue again, to prevent duplicates.
517 if (!packet_history_.SetPendingTransmission(packet_id)) {
518 // Packet has already been removed from history, return early.
519 return 0;
520 }
521
Erik Språnga12b1d62018-03-14 12:39:24 +0100522 paced_sender_->InsertPacket(
523 RtpPacketSender::kNormalPriority, stored_packet->ssrc,
Erik Språng83afeeb2019-05-14 15:57:19 +0200524 stored_packet->rtp_sequence_number, stored_packet->capture_time_ms,
Per Kjellander252725d2019-02-20 13:14:34 +0100525 stored_packet->packet_size, true);
Oleh Prypin5a980492018-03-09 12:27:24 +0000526
Erik Språnga12b1d62018-03-14 12:39:24 +0100527 return packet_size;
Oleh Prypin5a980492018-03-09 12:27:24 +0000528 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100529
530 std::unique_ptr<RtpPacketToSend> packet =
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200531 packet_history_.GetPacketAndSetSendTime(packet_id);
Erik Språnga12b1d62018-03-14 12:39:24 +0100532 if (!packet) {
533 // Packet could theoretically time out between the first check and this one.
534 return 0;
535 }
536
537 const bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
philipel8aadd502017-02-23 02:56:13 -0800538 if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
sprang867fb522015-08-03 04:38:41 -0700539 return -1;
Erik Språnga12b1d62018-03-14 12:39:24 +0100540
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200541 return packet_size;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000542}
543
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200544bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
philipel32d00102017-02-27 02:18:46 -0800545 const PacketOptions& options,
546 const PacedPacketInfo& pacing_info) {
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000547 int bytes_sent = -1;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000548 if (transport_) {
michaelt4da30442016-11-17 01:38:43 -0800549 UpdateRtpOverhead(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200550 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
551 ? static_cast<int>(packet.size())
stefan1d8a5062015-10-02 03:39:33 -0700552 : -1;
terelius429c3452016-01-21 05:42:04 -0800553 if (event_log_ && bytes_sent > 0) {
Karl Wiberg918f50c2018-07-05 11:40:33 +0200554 event_log_->Log(absl::make_unique<RtcEventRtpPacketOutgoing>(
Elad Alon4a87e1c2017-10-03 16:11:34 +0200555 packet, pacing_info.probe_cluster_id));
terelius429c3452016-01-21 05:42:04 -0800556 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000557 }
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000558 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000559 if (bytes_sent <= 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100560 RTC_LOG(LS_WARNING) << "Transport failed to send packet.";
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000561 return false;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000562 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000563 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000564}
565
Danil Chapovalov2800d742016-08-26 18:48:46 +0200566void RTPSender::OnReceivedNack(
567 const std::vector<uint16_t>& nack_sequence_numbers,
568 int64_t avg_rtt) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100569 packet_history_.SetRtt(5 + avg_rtt);
sprangcd349d92016-07-13 09:11:28 -0700570 for (uint16_t seq_no : nack_sequence_numbers) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100571 const int32_t bytes_sent = ReSendPacket(seq_no);
sprangcd349d92016-07-13 09:11:28 -0700572 if (bytes_sent < 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000573 // Failed to send one Sequence number. Give up the rest in this nack.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100574 RTC_LOG(LS_WARNING) << "Failed resending RTP packet " << seq_no
575 << ", Discard rest of packets.";
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000576 break;
niklase@google.com470e71d2011-07-07 08:21:25 +0000577 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000578 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000579}
580
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000581// Called from pacer when we can send the packet.
Erik Språngd2879622019-05-10 08:29:01 -0700582RtpPacketSendResult RTPSender::TimeToSendPacket(
583 uint32_t ssrc,
584 uint16_t sequence_number,
585 int64_t capture_time_ms,
586 bool retransmission,
587 const PacedPacketInfo& pacing_info) {
588 if (!SendingMedia()) {
589 return RtpPacketSendResult::kPacketNotFound;
590 }
brandtr9dfff292016-11-14 05:14:50 -0800591
592 std::unique_ptr<RtpPacketToSend> packet;
593 if (ssrc == SSRC()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200594 packet = packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800595 } else if (ssrc == FlexfecSsrc()) {
Danil Chapovalov6c78ff42018-10-16 11:01:05 +0200596 packet = flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number);
brandtr9dfff292016-11-14 05:14:50 -0800597 }
598
Stefan Holmera246cfb2016-08-23 17:51:42 +0200599 if (!packet) {
Erik Språngd2879622019-05-10 08:29:01 -0700600 // Packet cannot be found or was resent too recently.
601 return RtpPacketSendResult::kPacketNotFound;
Stefan Holmera246cfb2016-08-23 17:51:42 +0200602 }
asapersson35151f32016-05-02 23:44:01 -0700603
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200604 return PrepareAndSendPacket(
Erik Språngd2879622019-05-10 08:29:01 -0700605 std::move(packet),
606 retransmission && (RtxStatus() & kRtxRetransmitted) > 0,
607 retransmission, pacing_info)
608 ? RtpPacketSendResult::kSuccess
609 : RtpPacketSendResult::kTransportUnavailable;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000610}
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000611
Erik Språng9c771c22019-06-17 16:31:53 +0200612// Called from pacer when we can send the packet.
613bool RTPSender::TrySendPacket(RtpPacketToSend* packet,
614 const PacedPacketInfo& pacing_info) {
615 RTC_DCHECK(packet);
616
617 const uint32_t packet_ssrc = packet->Ssrc();
618 const auto packet_type = packet->packet_type();
619 RTC_DCHECK(packet_type.has_value());
620
621 PacketOptions options;
622 bool is_media = false;
623 bool is_rtx = false;
624 {
625 rtc::CritScope lock(&send_critsect_);
626 if (!sending_media_) {
627 return false;
628 }
629
630 switch (*packet_type) {
631 case RtpPacketToSend::Type::kAudio:
632 case RtpPacketToSend::Type::kVideo:
633 if (packet_ssrc != ssrc_) {
634 return false;
635 }
636 is_media = true;
637 break;
638 case RtpPacketToSend::Type::kRetransmission:
639 case RtpPacketToSend::Type::kPadding:
640 // Both padding and retransmission must be on either the media or the
641 // RTX stream.
642 if (packet_ssrc == ssrc_rtx_) {
643 is_rtx = true;
644 } else if (packet_ssrc != ssrc_) {
645 return false;
646 }
647 break;
648 case RtpPacketToSend::Type::kForwardErrorCorrection:
649 // FlexFEC is on separate SSRC, ULPFEC uses media SSRC.
650 if (packet_ssrc != ssrc_ && packet_ssrc != flexfec_ssrc_) {
651 return false;
652 }
653 break;
654 }
655
656 options.included_in_allocation = force_part_of_allocation_;
657 }
658
659 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
660 // the pacer, these modifications of the header below are happening after the
661 // FEC protection packets are calculated. This will corrupt recovered packets
662 // at the same place. It's not an issue for extensions, which are present in
663 // all the packets (their content just may be incorrect on recovered packets).
664 // In case of VideoTimingExtension, since it's present not in every packet,
665 // data after rtp header may be corrupted if these packets are protected by
666 // the FEC.
667 int64_t now_ms = clock_->TimeInMilliseconds();
668 int64_t diff_ms = now_ms - packet->capture_time_ms();
669 packet->SetExtension<TransmissionOffset>(kTimestampTicksPerMs * diff_ms);
670 packet->SetExtension<AbsoluteSendTime>(AbsoluteSendTime::MsTo24Bits(now_ms));
671
672 if (packet->HasExtension<VideoTimingExtension>()) {
673 if (populate_network2_timestamp_) {
674 packet->set_network2_time_ms(now_ms);
675 } else {
676 packet->set_pacer_exit_time_ms(now_ms);
677 }
678 }
679
680 // Downstream code actually uses this flag to distinguish between media and
681 // everything else.
682 options.is_retransmit = !is_media;
683 if (auto packet_id = packet->GetExtension<TransportSequenceNumber>()) {
684 options.packet_id = *packet_id;
685 options.included_in_feedback = true;
686 options.included_in_allocation = true;
687 AddPacketToTransportFeedback(*packet_id, *packet, pacing_info);
688 }
689
690 options.application_data.assign(packet->application_data().begin(),
691 packet->application_data().end());
692
693 if (packet->packet_type() != RtpPacketToSend::Type::kPadding &&
694 packet->packet_type() != RtpPacketToSend::Type::kRetransmission) {
695 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet_ssrc);
696 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
697 packet_ssrc);
698 }
699
700 const bool send_success = SendPacketToNetwork(*packet, options, pacing_info);
701
702 // Put packet in retransmission history or update pending status even if
703 // actual sending fails.
704 if (is_media && packet->allow_retransmission()) {
705 packet_history_.PutRtpPacket(absl::make_unique<RtpPacketToSend>(*packet),
706 StorageType::kAllowRetransmission, now_ms);
707 } else if (packet->retransmitted_sequence_number()) {
708 packet_history_.MarkPacketAsSent(*packet->retransmitted_sequence_number());
709 }
710
711 if (send_success) {
712 UpdateRtpStats(*packet, is_rtx,
713 packet_type == RtpPacketToSend::Type::kRetransmission);
714
715 rtc::CritScope lock(&send_critsect_);
716 media_has_been_sent_ = true;
717 }
718
719 // Return true even if transport failed (will be handled by retransmissions
720 // instead in that case), so that PacketRouter does not have to iterate over
721 // all other RTP modules and fail to send there too.
722 return true;
723}
724
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200725bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000726 bool send_over_rtx,
philipela1ed0b32016-06-01 06:31:17 -0700727 bool is_retransmit,
philipel8aadd502017-02-23 02:56:13 -0800728 const PacedPacketInfo& pacing_info) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200729 RTC_DCHECK(packet);
730 int64_t capture_time_ms = packet->capture_time_ms();
731 RtpPacketToSend* packet_to_send = packet.get();
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000732
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200733 std::unique_ptr<RtpPacketToSend> packet_rtx;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000734 if (send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200735 packet_rtx = BuildRtxPacket(*packet);
736 if (!packet_rtx)
danilchap32cd2c42016-08-01 06:58:34 -0700737 return false;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200738 packet_to_send = packet_rtx.get();
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000739 }
740
ilnik10894992017-06-21 08:23:19 -0700741 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
742 // the pacer, these modifications of the header below are happening after the
743 // FEC protection packets are calculated. This will corrupt recovered packets
744 // at the same place. It's not an issue for extensions, which are present in
745 // all the packets (their content just may be incorrect on recovered packets).
746 // In case of VideoTimingExtension, since it's present not in every packet,
747 // data after rtp header may be corrupted if these packets are protected by
748 // the FEC.
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000749 int64_t now_ms = clock_->TimeInMilliseconds();
750 int64_t diff_ms = now_ms - capture_time_ms;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200751 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
752 diff_ms);
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200753 packet_to_send->SetExtension<AbsoluteSendTime>(
754 AbsoluteSendTime::MsTo24Bits(now_ms));
sprang867fb522015-08-03 04:38:41 -0700755
Erik Språng7b52f102018-02-07 14:37:37 +0100756 if (packet_to_send->HasExtension<VideoTimingExtension>()) {
757 if (populate_network2_timestamp_) {
758 packet_to_send->set_network2_time_ms(now_ms);
759 } else {
760 packet_to_send->set_pacer_exit_time_ms(now_ms);
761 }
762 }
ilnik04f4d122017-06-19 07:18:55 -0700763
stefan1d8a5062015-10-02 03:39:33 -0700764 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200765 // If we are sending over RTX, it also means this is a retransmission.
766 // E.g. RTPSender::TrySendRedundantPayloads calls PrepareAndSendPacket with
767 // send_over_rtx = true but is_retransmit = false.
768 options.is_retransmit = is_retransmit || send_over_rtx;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200769 bool has_transport_seq_num;
770 {
771 rtc::CritScope lock(&send_critsect_);
772 has_transport_seq_num =
773 UpdateTransportSequenceNumber(packet_to_send, &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200774 options.included_in_allocation =
775 has_transport_seq_num || force_part_of_allocation_;
776 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200777 }
778 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -0800779 AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
philipel8aadd502017-02-23 02:56:13 -0800780 pacing_info);
sprang867fb522015-08-03 04:38:41 -0700781 }
Dino Radaković1807d572018-02-22 14:18:06 +0100782 options.application_data.assign(packet_to_send->application_data().begin(),
783 packet_to_send->application_data().end());
sprang867fb522015-08-03 04:38:41 -0700784
asapersson35151f32016-05-02 23:44:01 -0700785 if (!is_retransmit && !send_over_rtx) {
Erik Språng9c771c22019-06-17 16:31:53 +0200786 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet->Ssrc());
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200787 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
788 packet->Ssrc());
stefanf116bd02015-10-27 08:29:42 -0700789 }
790
philipel32d00102017-02-27 02:18:46 -0800791 if (!SendPacketToNetwork(*packet_to_send, options, pacing_info))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200792 return false;
793
794 {
tommiae695e92016-02-02 08:31:45 -0800795 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000796 media_has_been_sent_ = true;
797 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200798 UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit);
799 return true;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000800}
801
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200802void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet,
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000803 bool is_rtx,
804 bool is_retransmit) {
sprangcd349d92016-07-13 09:11:28 -0700805 int64_t now_ms = clock_->TimeInMilliseconds();
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000806
danilchap7c9426c2016-04-14 03:05:31 -0700807 rtc::CritScope lock(&statistics_crit_);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200808 StreamDataCounters* counters = is_rtx ? &rtx_rtp_stats_ : &rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000809
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200810 total_bitrate_sent_.Update(packet.size(), now_ms);
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000811
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200812 if (counters->first_packet_time_ms == -1)
813 counters->first_packet_time_ms = now_ms;
814
Erik Språngf53cfa92019-06-12 13:58:17 +0200815 if (packet.packet_type() == RtpPacketToSend::Type::kForwardErrorCorrection) {
Niels Möllerdbb988b2018-11-15 08:05:16 +0100816 counters->fec.AddPacket(packet);
Erik Språngf53cfa92019-06-12 13:58:17 +0200817 }
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200818
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200819 if (is_retransmit) {
Niels Möllerdbb988b2018-11-15 08:05:16 +0100820 counters->retransmitted.AddPacket(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200821 nack_bitrate_sent_.Update(packet.size(), now_ms);
822 }
Niels Möllerdbb988b2018-11-15 08:05:16 +0100823 counters->transmitted.AddPacket(packet);
sprangcd349d92016-07-13 09:11:28 -0700824
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200825 if (rtp_stats_callback_)
826 rtp_stats_callback_->DataCountersUpdated(*counters, packet.Ssrc());
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000827}
828
philipel8aadd502017-02-23 02:56:13 -0800829size_t RTPSender::TimeToSendPadding(size_t bytes,
830 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800831 if (bytes == 0)
pbos545727e2015-07-01 06:31:06 -0700832 return 0;
philipel8aadd502017-02-23 02:56:13 -0800833 size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000834 if (bytes_sent < bytes)
philipel8aadd502017-02-23 02:56:13 -0800835 bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000836 return bytes_sent;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000837}
838
Erik Språng478cb462019-06-26 15:49:27 +0200839void RTPSender::GeneratePadding(size_t target_size_bytes) {
840 // This method does not actually send packets, it just generates
841 // them and puts them in the pacer queue. Since this should incur
842 // low overhead, keep the lock for the scope of the method in order
843 // to make the code more readable.
844 rtc::CritScope lock(&send_critsect_);
845 if (!sending_media_)
846 return;
847
848 size_t bytes_left = target_size_bytes;
849 if ((rtx_ & kRtxRedundantPayloads) != 0) {
850 while (bytes_left >= 0) {
851 std::unique_ptr<RtpPacketToSend> packet =
852 packet_history_.GetPayloadPaddingPacket(
853 [&](const RtpPacketToSend& packet)
854 -> std::unique_ptr<RtpPacketToSend> {
855 if (packet.payload_size() + kRtxHeaderSize > bytes_left) {
856 return nullptr;
857 }
858 return BuildRtxPacket(packet);
859 });
860 if (!packet) {
861 break;
862 }
863
864 bytes_left -= std::min(bytes_left, packet->payload_size());
865 packet->set_packet_type(RtpPacketToSend::Type::kPadding);
866 paced_sender_->EnqueuePacket(std::move(packet));
867 }
868 }
869
870 size_t padding_bytes_in_packet;
871 const size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
872 if (audio_configured_) {
873 // Allow smaller padding packets for audio.
874 padding_bytes_in_packet = rtc::SafeClamp<size_t>(
875 bytes_left, kMinAudioPaddingLength,
876 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
877 } else {
878 // Always send full padding packets. This is accounted for by the
879 // RtpPacketSender, which will make sure we don't send too much padding even
880 // if a single packet is larger than requested.
881 // We do this to avoid frequently sending small packets on higher bitrates.
882 padding_bytes_in_packet = rtc::SafeMin(max_payload_size, kMaxPaddingLength);
883 }
884
885 while (bytes_left > 0) {
886 auto padding_packet =
887 absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_);
888 padding_packet->set_packet_type(RtpPacketToSend::Type::kPadding);
889 padding_packet->SetMarker(false);
890 padding_packet->SetTimestamp(last_rtp_timestamp_);
891 padding_packet->set_capture_time_ms(capture_time_ms_);
892 if (rtx_ == kRtxOff) {
893 if (last_payload_type_ == -1) {
894 break;
895 }
896 // Without RTX we can't send padding in the middle of frames.
897 // For audio marker bits doesn't mark the end of a frame and frames
898 // are usually a single packet, so for now we don't apply this rule
899 // for audio.
900 if (!audio_configured_ && !last_packet_marker_bit_) {
901 break;
902 }
903
904 RTC_DCHECK(ssrc_);
905 padding_packet->SetSsrc(*ssrc_);
906 padding_packet->SetPayloadType(last_payload_type_);
907 padding_packet->SetSequenceNumber(sequence_number_++);
908 } else {
909 // Without abs-send-time or transport sequence number a media packet
910 // must be sent before padding so that the timestamps used for
911 // estimation are correct.
912 if (!media_has_been_sent_ &&
913 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
914 rtp_header_extension_map_.IsRegistered(
915 TransportSequenceNumber::kId))) {
916 break;
917 }
918 // Only change the timestamp of padding packets sent over RTX.
919 // Padding only packets over RTP has to be sent as part of a media
920 // frame (and therefore the same timestamp).
921 int64_t now_ms = clock_->TimeInMilliseconds();
922 if (last_timestamp_time_ms_ > 0) {
923 padding_packet->SetTimestamp(padding_packet->Timestamp() +
924 (now_ms - last_timestamp_time_ms_) *
925 kTimestampTicksPerMs);
926 padding_packet->set_capture_time_ms(padding_packet->capture_time_ms() +
927 (now_ms - last_timestamp_time_ms_));
928 }
929 RTC_DCHECK(ssrc_rtx_);
930 padding_packet->SetSsrc(*ssrc_rtx_);
931 padding_packet->SetSequenceNumber(sequence_number_rtx_++);
932 padding_packet->SetPayloadType(rtx_payload_type_map_.begin()->second);
933 }
934
935 padding_packet->SetPadding(padding_bytes_in_packet);
936 bytes_left -= std::min(bytes_left, padding_bytes_in_packet);
937 paced_sender_->EnqueuePacket(std::move(padding_packet));
938 }
939}
940
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200941bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
Erik Språng13eb7642019-06-24 10:58:48 +0200942 StorageType storage) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200943 RTC_DCHECK(packet);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000944 int64_t now_ms = clock_->TimeInMilliseconds();
945
brandtr9dfff292016-11-14 05:14:50 -0800946 uint32_t ssrc = packet->Ssrc();
Peter Boströme23e7372015-10-08 11:44:14 +0200947 if (paced_sender_) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200948 uint16_t seq_no = packet->SequenceNumber();
Erik Språng83afeeb2019-05-14 15:57:19 +0200949 int64_t capture_time_ms = packet->capture_time_ms();
Per Kjellander17c147c2019-02-20 12:06:17 +0100950 size_t packet_size =
951 send_side_bwe_with_overhead_ ? packet->size() : packet->payload_size();
Erik Språng13eb7642019-06-24 10:58:48 +0200952 auto packet_type = packet->packet_type();
953 RTC_DCHECK(packet_type.has_value());
Niels Möller59ab1cf2019-02-06 22:48:11 +0100954 if (ssrc == FlexfecSsrc()) {
brandtr9dfff292016-11-14 05:14:50 -0800955 // Store FlexFEC packets in the history here, so they can be found
956 // when the pacer calls TimeToSendPacket.
Erik Språnga12b1d62018-03-14 12:39:24 +0100957 flexfec_packet_history_.PutRtpPacket(std::move(packet), storage,
Danil Chapovalovd264df52018-06-14 12:59:38 +0200958 absl::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800959 } else {
Danil Chapovalovd264df52018-06-14 12:59:38 +0200960 packet_history_.PutRtpPacket(std::move(packet), storage, absl::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800961 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200962
Erik Språng13eb7642019-06-24 10:58:48 +0200963 paced_sender_->InsertPacket(PacketTypeToPriority(*packet_type), ssrc,
964 seq_no, capture_time_ms, packet_size, false);
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700965 return true;
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +0000966 }
Stefan Holmerf5dca482016-01-27 12:58:51 +0100967
968 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200969 options.is_retransmit = false;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200970
Danil Chapovalovaf52b682018-11-27 10:48:27 +0100971 // |capture_time_ms| <= 0 is considered invalid.
972 // TODO(holmer): This should be changed all over Video Engine so that negative
973 // time is consider invalid, while 0 is considered a valid time.
974 if (packet->capture_time_ms() > 0) {
975 packet->SetExtension<TransmissionOffset>(
976 kTimestampTicksPerMs * (now_ms - packet->capture_time_ms()));
977
978 if (populate_network2_timestamp_ &&
979 packet->HasExtension<VideoTimingExtension>()) {
980 packet->set_network2_time_ms(now_ms);
981 }
982 }
983 packet->SetExtension<AbsoluteSendTime>(AbsoluteSendTime::MsTo24Bits(now_ms));
984
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200985 bool has_transport_seq_num;
986 {
987 rtc::CritScope lock(&send_critsect_);
988 has_transport_seq_num =
989 UpdateTransportSequenceNumber(packet.get(), &options.packet_id);
Sebastian Jansson1bca65b2018-10-10 09:58:08 +0200990 options.included_in_allocation =
991 has_transport_seq_num || force_part_of_allocation_;
992 options.included_in_feedback = has_transport_seq_num;
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +0200993 }
994 if (has_transport_seq_num) {
michaelt4da30442016-11-17 01:38:43 -0800995 AddPacketToTransportFeedback(options.packet_id, *packet.get(),
philipel8aadd502017-02-23 02:56:13 -0800996 PacedPacketInfo());
Stefan Holmerf5dca482016-01-27 12:58:51 +0100997 }
Dino Radaković1807d572018-02-22 14:18:06 +0100998 options.application_data.assign(packet->application_data().begin(),
999 packet->application_data().end());
Stefan Holmerf5dca482016-01-27 12:58:51 +01001000
Erik Språng9c771c22019-06-17 16:31:53 +02001001 UpdateDelayStatistics(packet->capture_time_ms(), now_ms, packet->Ssrc());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001002 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
1003 packet->Ssrc());
1004
philipel32d00102017-02-27 02:18:46 -08001005 bool sent = SendPacketToNetwork(*packet, options, PacedPacketInfo());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001006
1007 if (sent) {
1008 {
1009 rtc::CritScope lock(&send_critsect_);
1010 media_has_been_sent_ = true;
1011 }
1012 UpdateRtpStats(*packet, false, false);
1013 }
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +00001014
brandtr9dfff292016-11-14 05:14:50 -08001015 // To support retransmissions, we store the media packet as sent in the
1016 // packet history (even if send failed).
1017 if (storage == kAllowRetransmission) {
Danil Chapovalov603ce982017-12-27 11:32:50 +01001018 RTC_DCHECK_EQ(ssrc, SSRC());
Erik Språnga12b1d62018-03-14 12:39:24 +01001019 packet_history_.PutRtpPacket(std::move(packet), storage, now_ms);
brandtr9dfff292016-11-14 05:14:50 -08001020 }
Peter Boströme23e7372015-10-08 11:44:14 +02001021
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001022 return sent;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +00001023}
1024
Erik Språng13eb7642019-06-24 10:58:48 +02001025bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
1026 StorageType storage,
1027 RtpPacketSender::Priority priority) {
1028 packet->set_packet_type(PacketPriorityToType(priority));
1029 return SendToNetwork(std::move(packet), storage);
1030}
1031
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001032void RTPSender::RecomputeMaxSendDelay() {
1033 max_delay_it_ = send_delays_.begin();
1034 for (auto it = send_delays_.begin(); it != send_delays_.end(); ++it) {
1035 if (it->second >= max_delay_it_->second) {
1036 max_delay_it_ = it;
1037 }
1038 }
1039}
1040
Erik Språng9c771c22019-06-17 16:31:53 +02001041void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms,
1042 int64_t now_ms,
1043 uint32_t ssrc) {
asapersson35151f32016-05-02 23:44:01 -07001044 if (!send_side_delay_observer_ || capture_time_ms <= 0)
Peter Boström71861a02015-05-28 14:45:36 +02001045 return;
1046
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001047 int avg_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001048 int max_delay_ms = 0;
Henrik Boström9fe18342019-05-16 18:38:20 +02001049 uint64_t total_packet_send_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001050 {
danilchap7c9426c2016-04-14 03:05:31 -07001051 rtc::CritScope cs(&statistics_crit_);
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001052 // Compute the max and average of the recent capture-to-send delays.
1053 // The time complexity of the current approach depends on the distribution
1054 // of the delay values. This could be done more efficiently.
1055
1056 // Remove elements older than kSendSideDelayWindowMs.
1057 auto lower_bound =
1058 send_delays_.lower_bound(now_ms - kSendSideDelayWindowMs);
1059 for (auto it = send_delays_.begin(); it != lower_bound; ++it) {
1060 if (max_delay_it_ == it) {
1061 max_delay_it_ = send_delays_.end();
1062 }
1063 sum_delays_ms_ -= it->second;
1064 }
1065 send_delays_.erase(send_delays_.begin(), lower_bound);
1066 if (max_delay_it_ == send_delays_.end()) {
1067 // Removed the previous max. Need to recompute.
1068 RecomputeMaxSendDelay();
1069 }
1070
1071 // Add the new element.
Johannes Kron965e7942018-09-13 15:36:20 +02001072 RTC_DCHECK_GE(now_ms, static_cast<int64_t>(0));
1073 RTC_DCHECK_LE(now_ms, std::numeric_limits<int64_t>::max() / 2);
1074 RTC_DCHECK_GE(capture_time_ms, static_cast<int64_t>(0));
1075 RTC_DCHECK_LE(capture_time_ms, std::numeric_limits<int64_t>::max() / 2);
1076 int64_t diff_ms = now_ms - capture_time_ms;
1077 RTC_DCHECK_GE(diff_ms, static_cast<int64_t>(0));
1078 RTC_DCHECK_LE(diff_ms,
1079 static_cast<int64_t>(std::numeric_limits<int>::max()));
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001080 int new_send_delay = rtc::dchecked_cast<int>(now_ms - capture_time_ms);
1081 SendDelayMap::iterator it;
1082 bool inserted;
1083 std::tie(it, inserted) =
1084 send_delays_.insert(std::make_pair(now_ms, new_send_delay));
1085 if (!inserted) {
1086 // TODO(terelius): If we have multiple delay measurements during the same
1087 // millisecond then we keep the most recent one. It is not clear that this
1088 // is the right decision, but it preserves an earlier behavior.
1089 int previous_send_delay = it->second;
1090 sum_delays_ms_ -= previous_send_delay;
1091 it->second = new_send_delay;
1092 if (max_delay_it_ == it && new_send_delay < previous_send_delay) {
1093 RecomputeMaxSendDelay();
1094 }
Peter Boström71861a02015-05-28 14:45:36 +02001095 }
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001096 if (max_delay_it_ == send_delays_.end() ||
1097 it->second >= max_delay_it_->second) {
1098 max_delay_it_ = it;
1099 }
1100 sum_delays_ms_ += new_send_delay;
Henrik Boström9fe18342019-05-16 18:38:20 +02001101 total_packet_send_delay_ms_ += new_send_delay;
1102 total_packet_send_delay_ms = total_packet_send_delay_ms_;
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001103
1104 size_t num_delays = send_delays_.size();
1105 RTC_DCHECK(max_delay_it_ != send_delays_.end());
1106 max_delay_ms = rtc::dchecked_cast<int>(max_delay_it_->second);
1107 int64_t avg_ms = (sum_delays_ms_ + num_delays / 2) / num_delays;
1108 RTC_DCHECK_GE(avg_ms, static_cast<int64_t>(0));
1109 RTC_DCHECK_LE(avg_ms,
1110 static_cast<int64_t>(std::numeric_limits<int>::max()));
1111 avg_delay_ms =
1112 rtc::dchecked_cast<int>((sum_delays_ms_ + num_delays / 2) / num_delays);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001113 }
Henrik Boström9fe18342019-05-16 18:38:20 +02001114 send_side_delay_observer_->SendSideDelayUpdated(
1115 avg_delay_ms, max_delay_ms, total_packet_send_delay_ms, ssrc);
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001116}
1117
asapersson35151f32016-05-02 23:44:01 -07001118void RTPSender::UpdateOnSendPacket(int packet_id,
1119 int64_t capture_time_ms,
1120 uint32_t ssrc) {
1121 if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
1122 return;
1123
1124 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
1125}
1126
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001127void RTPSender::ProcessBitrate() {
sprangcd349d92016-07-13 09:11:28 -07001128 if (!bitrate_callback_)
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001129 return;
sprangcd349d92016-07-13 09:11:28 -07001130 int64_t now_ms = clock_->TimeInMilliseconds();
1131 uint32_t ssrc;
1132 {
1133 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001134 if (!ssrc_)
1135 return;
1136 ssrc = *ssrc_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001137 }
sprangcd349d92016-07-13 09:11:28 -07001138
1139 rtc::CritScope lock(&statistics_crit_);
1140 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0),
1141 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +00001142}
1143
isheriff6b4b5f32016-06-08 00:24:21 -07001144size_t RTPSender::RtpHeaderLength() const {
tommiae695e92016-02-02 08:31:45 -08001145 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001146 size_t rtp_header_length = kRtpHeaderLength;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001147 rtp_header_length += sizeof(uint32_t) * csrcs_.size();
Danil Chapovalov7b189922018-10-03 10:15:36 +02001148 rtp_header_length += RtpHeaderExtensionSize(kFecOrPaddingExtensionSizes,
1149 rtp_header_extension_map_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001150 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +00001151}
1152
mflodmanfcf54bd2015-04-14 21:28:08 +02001153uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
tommiae695e92016-02-02 08:31:45 -08001154 rtc::CritScope lock(&send_critsect_);
mflodmanfcf54bd2015-04-14 21:28:08 +02001155 uint16_t first_allocated_sequence_number = sequence_number_;
1156 sequence_number_ += packets_to_send;
1157 return first_allocated_sequence_number;
niklase@google.com470e71d2011-07-07 08:21:25 +00001158}
1159
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001160void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
1161 StreamDataCounters* rtx_stats) const {
danilchap7c9426c2016-04-14 03:05:31 -07001162 rtc::CritScope lock(&statistics_crit_);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001163 *rtp_stats = rtp_stats_;
1164 *rtx_stats = rtx_rtp_stats_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001165}
1166
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001167std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
1168 rtc::CritScope lock(&send_critsect_);
Danil Chapovalov3b4b4f52018-10-12 12:50:43 +02001169 // TODO(danilchap): Find better motivator and value for extra capacity.
1170 // RtpPacketizer might slightly miscalulate needed size,
1171 // SRTP may benefit from extra space in the buffer and do encryption in place
1172 // saving reallocation.
1173 // While sending slightly oversized packet increase chance of dropped packet,
1174 // it is better than crash on drop packet without trying to send it.
1175 static constexpr int kExtraCapacity = 16;
1176 auto packet = absl::make_unique<RtpPacketToSend>(
1177 &rtp_header_extension_map_, max_packet_size_ + kExtraCapacity);
nisse7d59f6b2017-02-21 03:40:24 -08001178 RTC_DCHECK(ssrc_);
1179 packet->SetSsrc(*ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001180 packet->SetCsrcs(csrcs_);
1181 // Reserve extensions, if registered, RtpSender set in SendToNetwork.
1182 packet->ReserveExtension<AbsoluteSendTime>();
1183 packet->ReserveExtension<TransmissionOffset>();
1184 packet->ReserveExtension<TransportSequenceNumber>();
Niels Möller6893f3c2019-01-31 08:56:26 +01001185
Steve Anton4af95842018-04-06 11:09:46 -07001186 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001187 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001188 packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001189 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001190 if (!rid_.empty()) {
1191 // This is a no-op if the RID header extension is not registered.
1192 packet->SetExtension<RtpStreamId>(rid_);
1193 }
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001194 return packet;
1195}
1196
1197bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) {
1198 rtc::CritScope lock(&send_critsect_);
1199 if (!sending_media_)
1200 return false;
nisse7d59f6b2017-02-21 03:40:24 -08001201 RTC_DCHECK(packet->Ssrc() == ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001202 packet->SetSequenceNumber(sequence_number_++);
1203
1204 // Remember marker bit to determine if padding can be inserted with
1205 // sequence number following |packet|.
1206 last_packet_marker_bit_ = packet->Marker();
Danil Chapovalovb3179c72018-03-22 10:13:07 +01001207 // Remember payload type to use in the padding packet if rtx is disabled.
1208 last_payload_type_ = packet->PayloadType();
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001209 // Save timestamps to generate timestamp field and extensions for the padding.
1210 last_rtp_timestamp_ = packet->Timestamp();
1211 last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
1212 capture_time_ms_ = packet->capture_time_ms();
1213 return true;
1214}
1215
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001216bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet,
Sebastian Jansson30e2d6e2018-10-09 18:27:36 +02001217 int* packet_id) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001218 RTC_DCHECK(packet);
1219 RTC_DCHECK(packet_id);
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001220 if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId))
stefana23fc622016-07-28 07:56:38 -07001221 return false;
1222
asapersson35151f32016-05-02 23:44:01 -07001223 if (!transport_sequence_number_allocator_)
1224 return false;
1225
1226 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001227
1228 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
1229 return false;
1230
asapersson35151f32016-05-02 23:44:01 -07001231 return true;
sprang867fb522015-08-03 04:38:41 -07001232}
1233
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001234void RTPSender::SetSendingMediaStatus(bool enabled) {
tommiae695e92016-02-02 08:31:45 -08001235 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001236 sending_media_ = enabled;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001237}
1238
1239bool RTPSender::SendingMedia() const {
tommiae695e92016-02-02 08:31:45 -08001240 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001241 return sending_media_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001242}
1243
Sebastian Jansson1bca65b2018-10-10 09:58:08 +02001244void RTPSender::SetAsPartOfAllocation(bool part_of_allocation) {
1245 rtc::CritScope lock(&send_critsect_);
1246 force_part_of_allocation_ = part_of_allocation;
1247}
1248
danilchap71fead22016-08-18 02:01:49 -07001249void RTPSender::SetTimestampOffset(uint32_t timestamp) {
tommiae695e92016-02-02 08:31:45 -08001250 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001251 timestamp_offset_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001252}
1253
danilchap71fead22016-08-18 02:01:49 -07001254uint32_t RTPSender::TimestampOffset() const {
tommiae695e92016-02-02 08:31:45 -08001255 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001256 return timestamp_offset_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001257}
1258
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001259void RTPSender::SetSSRC(uint32_t ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001260 // This is configured via the API.
tommiae695e92016-02-02 08:31:45 -08001261 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +00001262
nisse7d59f6b2017-02-21 03:40:24 -08001263 if (ssrc_ == ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001264 return; // Since it's same ssrc, don't reset anything.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001265 }
nisse7d59f6b2017-02-21 03:40:24 -08001266 ssrc_.emplace(ssrc);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001267 if (!sequence_number_forced_) {
danilchap47a740b2015-12-15 00:30:07 -08001268 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001269 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001270}
1271
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001272uint32_t RTPSender::SSRC() const {
tommiae695e92016-02-02 08:31:45 -08001273 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001274 RTC_DCHECK(ssrc_);
1275 return *ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001276}
1277
Amit Hilbuch77938e62018-12-21 09:23:38 -08001278void RTPSender::SetRid(const std::string& rid) {
1279 // RID is used in simulcast scenario when multiple layers share the same mid.
1280 rtc::CritScope lock(&send_critsect_);
1281 RTC_DCHECK_LE(rid.length(), RtpStreamId::kMaxValueSizeBytes);
1282 rid_ = rid;
1283}
1284
Steve Anton296a0ce2018-03-22 15:17:27 -07001285void RTPSender::SetMid(const std::string& mid) {
1286 // This is configured via the API.
1287 rtc::CritScope lock(&send_critsect_);
Steve Anton4af95842018-04-06 11:09:46 -07001288 mid_ = mid;
Steve Anton296a0ce2018-03-22 15:17:27 -07001289}
1290
Danil Chapovalovd264df52018-06-14 12:59:38 +02001291absl::optional<uint32_t> RTPSender::FlexfecSsrc() const {
Niels Möller59ab1cf2019-02-06 22:48:11 +01001292 return flexfec_ssrc_;
brandtr9dfff292016-11-14 05:14:50 -08001293}
1294
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001295void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
spranga8ae6f22017-09-04 07:23:56 -07001296 RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
tommiae695e92016-02-02 08:31:45 -08001297 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001298 csrcs_ = csrcs;
niklase@google.com470e71d2011-07-07 08:21:25 +00001299}
1300
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001301void RTPSender::SetSequenceNumber(uint16_t seq) {
tommiae695e92016-02-02 08:31:45 -08001302 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001303 sequence_number_forced_ = true;
1304 sequence_number_ = seq;
niklase@google.com470e71d2011-07-07 08:21:25 +00001305}
1306
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001307uint16_t RTPSender::SequenceNumber() const {
tommiae695e92016-02-02 08:31:45 -08001308 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001309 return sequence_number_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001310}
1311
Danil Chapovalov271195f2019-02-11 11:30:03 +01001312static void CopyHeaderAndExtensionsToRtxPacket(const RtpPacketToSend& packet,
1313 RtpPacketToSend* rtx_packet) {
Amit Hilbuch77938e62018-12-21 09:23:38 -08001314 // Set the relevant fixed packet headers. The following are not set:
1315 // * Payload type - it is replaced in rtx packets.
1316 // * Sequence number - RTX has a separate sequence numbering.
1317 // * SSRC - RTX stream has its own SSRC.
1318 rtx_packet->SetMarker(packet.Marker());
1319 rtx_packet->SetTimestamp(packet.Timestamp());
1320
1321 // Set the variable fields in the packet header:
1322 // * CSRCs - must be set before header extensions.
1323 // * Header extensions - replace Rid header with RepairedRid header.
1324 const std::vector<uint32_t> csrcs = packet.Csrcs();
1325 rtx_packet->SetCsrcs(csrcs);
1326 for (int extension = kRtpExtensionNone + 1;
1327 extension < kRtpExtensionNumberOfExtensions; ++extension) {
1328 RTPExtensionType source_extension =
1329 static_cast<RTPExtensionType>(extension);
1330 // Rid header should be replaced with RepairedRid header
1331 RTPExtensionType destination_extension =
1332 source_extension == kRtpExtensionRtpStreamId
1333 ? kRtpExtensionRepairedRtpStreamId
1334 : source_extension;
1335
1336 // Empty extensions should be supported, so not checking |source.empty()|.
1337 if (!packet.HasExtension(source_extension)) {
1338 continue;
1339 }
1340
1341 rtc::ArrayView<const uint8_t> source =
1342 packet.FindExtension(source_extension);
1343
1344 rtc::ArrayView<uint8_t> destination =
1345 rtx_packet->AllocateExtension(destination_extension, source.size());
1346
1347 // Could happen if any:
1348 // 1. Extension has 0 length.
1349 // 2. Extension is not registered in destination.
1350 // 3. Allocating extension in destination failed.
1351 if (destination.empty() || source.size() != destination.size()) {
1352 continue;
1353 }
1354
1355 std::memcpy(destination.begin(), source.begin(), destination.size());
1356 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001357}
1358
1359std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
1360 const RtpPacketToSend& packet) {
Danil Chapovalov271195f2019-02-11 11:30:03 +01001361 std::unique_ptr<RtpPacketToSend> rtx_packet;
Amit Hilbuch77938e62018-12-21 09:23:38 -08001362
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001363 // Add original RTP header.
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001364 {
1365 rtc::CritScope lock(&send_critsect_);
1366 if (!sending_media_)
1367 return nullptr;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001368
nisse7d59f6b2017-02-21 03:40:24 -08001369 RTC_DCHECK(ssrc_rtx_);
1370
brandtre6f98c72016-11-11 03:28:30 -08001371 // Replace payload type.
1372 auto kv = rtx_payload_type_map_.find(packet.PayloadType());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001373 if (kv == rtx_payload_type_map_.end())
brandtre6f98c72016-11-11 03:28:30 -08001374 return nullptr;
Danil Chapovalov271195f2019-02-11 11:30:03 +01001375
1376 rtx_packet = absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_,
1377 max_packet_size_);
1378
brandtre6f98c72016-11-11 03:28:30 -08001379 rtx_packet->SetPayloadType(kv->second);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +00001380
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001381 // Replace sequence number.
1382 rtx_packet->SetSequenceNumber(sequence_number_rtx_++);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001383
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001384 // Replace SSRC.
nisse7d59f6b2017-02-21 03:40:24 -08001385 rtx_packet->SetSsrc(*ssrc_rtx_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001386
Danil Chapovalov271195f2019-02-11 11:30:03 +01001387 CopyHeaderAndExtensionsToRtxPacket(packet, rtx_packet.get());
1388
Amit Hilbuch77938e62018-12-21 09:23:38 -08001389 // The spec indicates that it is possible for a sender to stop sending mids
1390 // once the SSRCs have been bound on the receiver. As a result the source
1391 // rtp packet might not have the MID header extension set.
1392 // However, the SSRC of the RTX stream might not have been bound on the
1393 // receiver. This means that we should include it here.
1394 // The same argument goes for the Repaired RID extension.
Steve Anton4af95842018-04-06 11:09:46 -07001395 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001396 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001397 rtx_packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001398 }
Amit Hilbuch77938e62018-12-21 09:23:38 -08001399 if (!rid_.empty()) {
1400 // This is a no-op if the Repaired-RID header extension is not registered.
1401 // rtx_packet->SetExtension<RepairedRtpStreamId>(rid_);
1402 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001403 }
Danil Chapovalov271195f2019-02-11 11:30:03 +01001404 RTC_DCHECK(rtx_packet);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001405
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001406 uint8_t* rtx_payload =
1407 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize);
Danil Chapovalov271195f2019-02-11 11:30:03 +01001408 if (rtx_payload == nullptr)
1409 return nullptr;
1410
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001411 // Add OSN (original sequence number).
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001412 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber());
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001413
1414 // Add original payload data.
danilchap96c15872016-11-21 01:35:29 -08001415 auto payload = packet.payload();
1416 memcpy(rtx_payload + kRtxHeaderSize, payload.data(), payload.size());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001417
Dino Radaković1807d572018-02-22 14:18:06 +01001418 // Add original application data.
1419 rtx_packet->set_application_data(packet.application_data());
1420
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001421 return rtx_packet;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001422}
1423
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001424void RTPSender::RegisterRtpStatisticsCallback(
1425 StreamDataCountersCallback* callback) {
danilchap7c9426c2016-04-14 03:05:31 -07001426 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001427 rtp_stats_callback_ = callback;
1428}
1429
1430StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
danilchap7c9426c2016-04-14 03:05:31 -07001431 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001432 return rtp_stats_callback_;
1433}
1434
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001435uint32_t RTPSender::BitrateSent() const {
sprangcd349d92016-07-13 09:11:28 -07001436 rtc::CritScope cs(&statistics_crit_);
1437 return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001438}
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001439
1440void RTPSender::SetRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001441 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001442 sequence_number_ = rtp_state.sequence_number;
1443 sequence_number_forced_ = true;
danilchap71fead22016-08-18 02:01:49 -07001444 timestamp_offset_ = rtp_state.start_timestamp;
danilchape5b41412016-08-22 03:39:23 -07001445 last_rtp_timestamp_ = rtp_state.timestamp;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001446 capture_time_ms_ = rtp_state.capture_time_ms;
1447 last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001448 media_has_been_sent_ = rtp_state.media_has_been_sent;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001449}
1450
1451RtpState RTPSender::GetRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001452 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001453
1454 RtpState state;
1455 state.sequence_number = sequence_number_;
danilchap71fead22016-08-18 02:01:49 -07001456 state.start_timestamp = timestamp_offset_;
danilchape5b41412016-08-22 03:39:23 -07001457 state.timestamp = last_rtp_timestamp_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001458 state.capture_time_ms = capture_time_ms_;
1459 state.last_timestamp_time_ms = last_timestamp_time_ms_;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001460 state.media_has_been_sent = media_has_been_sent_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001461
1462 return state;
1463}
1464
1465void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001466 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001467 sequence_number_rtx_ = rtp_state.sequence_number;
1468}
1469
1470RtpState RTPSender::GetRtxRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001471 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001472
1473 RtpState state;
1474 state.sequence_number = sequence_number_rtx_;
danilchap71fead22016-08-18 02:01:49 -07001475 state.start_timestamp = timestamp_offset_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001476
1477 return state;
1478}
1479
philipel8aadd502017-02-23 02:56:13 -08001480void RTPSender::AddPacketToTransportFeedback(
1481 uint16_t packet_id,
1482 const RtpPacketToSend& packet,
1483 const PacedPacketInfo& pacing_info) {
michaelt4da30442016-11-17 01:38:43 -08001484 if (transport_feedback_observer_) {
Erik Språng30a276b2019-04-23 12:00:11 +02001485 size_t packet_size = packet.payload_size() + packet.padding_size();
1486 if (send_side_bwe_with_overhead_) {
1487 packet_size = packet.size();
1488 }
1489
1490 RtpPacketSendInfo packet_info;
1491 packet_info.ssrc = SSRC();
1492 packet_info.transport_sequence_number = packet_id;
Erik Språng490d76c2019-05-07 09:29:15 -07001493 packet_info.has_rtp_sequence_number = true;
Erik Språng30a276b2019-04-23 12:00:11 +02001494 packet_info.rtp_sequence_number = packet.SequenceNumber();
1495 packet_info.length = packet_size;
1496 packet_info.pacing_info = pacing_info;
1497 transport_feedback_observer_->OnAddPacket(packet_info);
michaelt4da30442016-11-17 01:38:43 -08001498 }
1499}
1500
1501void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
1502 if (!overhead_observer_)
1503 return;
nisse284542b2017-01-10 08:58:32 -08001504 size_t overhead_bytes_per_packet;
michaelt4da30442016-11-17 01:38:43 -08001505 {
1506 rtc::CritScope lock(&send_critsect_);
1507 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
1508 return;
1509 }
1510 rtp_overhead_bytes_per_packet_ = packet.headers_size();
nisse284542b2017-01-10 08:58:32 -08001511 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
michaelt4da30442016-11-17 01:38:43 -08001512 }
1513 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
1514}
1515
sprang168794c2017-07-06 04:38:06 -07001516int64_t RTPSender::LastTimestampTimeMs() const {
1517 rtc::CritScope lock(&send_critsect_);
1518 return last_timestamp_time_ms_;
1519}
1520
Erik Språng8b101922018-01-18 11:58:05 -08001521void RTPSender::SetRtt(int64_t rtt_ms) {
1522 packet_history_.SetRtt(rtt_ms);
1523 flexfec_packet_history_.SetRtt(rtt_ms);
1524}
Erik Språng490d76c2019-05-07 09:29:15 -07001525
1526void RTPSender::OnPacketsAcknowledged(
1527 rtc::ArrayView<const uint16_t> sequence_numbers) {
1528 packet_history_.CullAcknowledgedPackets(sequence_numbers);
1529}
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001530} // namespace webrtc