blob: 90ad9e9a9f438700b2be5595c348de7621c1b66a [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"
Elad Alon4a87e1c2017-10-03 16:11:34 +020019#include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020020#include "logging/rtc_event_log/rtc_event_log.h"
21#include "modules/remote_bitrate_estimator/test/bwe_test_logging.h"
22#include "modules/rtp_rtcp/include/rtp_cvo.h"
23#include "modules/rtp_rtcp/source/byte_io.h"
24#include "modules/rtp_rtcp/source/playout_delay_oracle.h"
25#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
26#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
27#include "modules/rtp_rtcp/source/rtp_sender_audio.h"
28#include "modules/rtp_rtcp/source/rtp_sender_video.h"
29#include "modules/rtp_rtcp/source/time_util.h"
30#include "rtc_base/arraysize.h"
31#include "rtc_base/checks.h"
32#include "rtc_base/logging.h"
Karl Wiberge40468b2017-11-22 10:42:26 +010033#include "rtc_base/numerics/safe_minmax.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020034#include "rtc_base/rate_limiter.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020035#include "rtc_base/timeutils.h"
36#include "rtc_base/trace_event.h"
37#include "system_wrappers/include/field_trial.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000038
39namespace webrtc {
niklase@google.com470e71d2011-07-07 08:21:25 +000040
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000041namespace {
Danil Chapovalov31e4e802016-08-03 18:27:40 +020042// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
43constexpr size_t kMaxPaddingLength = 224;
stefan53b6cc32017-02-03 08:13:57 -080044constexpr size_t kMinAudioPaddingLength = 50;
Danil Chapovalov31e4e802016-08-03 18:27:40 +020045constexpr int kSendSideDelayWindowMs = 1000;
46constexpr size_t kRtpHeaderLength = 12;
47constexpr uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1.
48constexpr uint32_t kTimestampTicksPerMs = 90;
49constexpr int kBitrateStatisticsWindowMs = 1000;
guoweis@webrtc.org45362892015-03-04 22:55:15 +000050
brandtr9dfff292016-11-14 05:14:50 -080051constexpr size_t kMinFlexfecPacketsToStoreForPacing = 50;
52
erikvarga27883732017-05-17 05:08:38 -070053template <typename Extension>
54constexpr RtpExtensionSize CreateExtensionSize() {
55 return {Extension::kId, Extension::kValueSizeBytes};
56}
57
58// Size info for header extensions that might be used in padding or FEC packets.
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010059constexpr RtpExtensionSize kFecOrPaddingExtensionSizes[] = {
erikvarga27883732017-05-17 05:08:38 -070060 CreateExtensionSize<AbsoluteSendTime>(),
61 CreateExtensionSize<TransmissionOffset>(),
62 CreateExtensionSize<TransportSequenceNumber>(),
63 CreateExtensionSize<PlayoutDelayLimits>(),
Steve Antonf0482ea2018-04-09 13:33:52 -070064 {RtpMid::kId, RtpMid::kMaxValueSizeBytes},
erikvarga27883732017-05-17 05:08:38 -070065};
66
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010067// Size info for header extensions that might be used in video packets.
68constexpr RtpExtensionSize kVideoExtensionSizes[] = {
69 CreateExtensionSize<AbsoluteSendTime>(),
70 CreateExtensionSize<TransmissionOffset>(),
71 CreateExtensionSize<TransportSequenceNumber>(),
72 CreateExtensionSize<PlayoutDelayLimits>(),
73 CreateExtensionSize<VideoOrientation>(),
74 CreateExtensionSize<VideoContentTypeExtension>(),
75 CreateExtensionSize<VideoTimingExtension>(),
Steve Antonf0482ea2018-04-09 13:33:52 -070076 {RtpMid::kId, RtpMid::kMaxValueSizeBytes},
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010077};
78
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +000079const char* FrameTypeToString(FrameType frame_type) {
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000080 switch (frame_type) {
pbos22993e12015-10-19 02:39:06 -070081 case kEmptyFrame:
82 return "empty";
Yves Gerey665174f2018-06-19 15:03:05 +020083 case kAudioFrameSpeech:
84 return "audio_speech";
85 case kAudioFrameCN:
86 return "audio_cn";
87 case kVideoFrameKey:
88 return "video_key";
89 case kVideoFrameDelta:
90 return "video_delta";
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000091 }
92 return "";
93}
94
Danil Chapovalov31e4e802016-08-03 18:27:40 +020095void CountPacket(RtpPacketCounter* counter, const RtpPacketToSend& packet) {
96 ++counter->packets;
97 counter->header_bytes += packet.headers_size();
98 counter->padding_bytes += packet.padding_size();
99 counter->payload_bytes += packet.payload_size();
Stefan Holmer0a87ffc2015-10-21 13:41:48 +0200100}
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200101
hclam@chromium.org806dc3b2013-04-09 19:54:10 +0000102} // namespace
103
sprangebbf8a82015-09-21 15:11:14 -0700104RTPSender::RTPSender(
105 bool audio,
106 Clock* clock,
107 Transport* transport,
sprangebbf8a82015-09-21 15:11:14 -0700108 RtpPacketSender* paced_sender,
brandtrdbdb3f12016-11-10 05:04:48 -0800109 FlexfecSender* flexfec_sender,
sprangebbf8a82015-09-21 15:11:14 -0700110 TransportSequenceNumberAllocator* sequence_number_allocator,
111 TransportFeedbackObserver* transport_feedback_observer,
112 BitrateStatisticsObserver* bitrate_callback,
113 FrameCountObserver* frame_count_observer,
terelius429c3452016-01-21 05:42:04 -0800114 SendSideDelayObserver* send_side_delay_observer,
asapersson35151f32016-05-02 23:44:01 -0700115 RtcEventLog* event_log,
sprangcd349d92016-07-13 09:11:28 -0700116 SendPacketObserver* send_packet_observer,
michaelt4da30442016-11-17 01:38:43 -0800117 RateLimiter* retransmission_rate_limiter,
Erik Språng7b52f102018-02-07 14:37:37 +0100118 OverheadObserver* overhead_observer,
119 bool populate_network2_timestamp)
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000120 : clock_(clock),
Niels Möllerd28db7f2016-05-10 16:31:47 +0200121 // TODO(holmer): Remove this conversion?
122 clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()),
danilchap47a740b2015-12-15 00:30:07 -0800123 random_(clock_->TimeInMicroseconds()),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000124 audio_configured_(audio),
solenberg6021fe22016-03-15 11:41:53 -0700125 audio_(audio ? new RTPSenderAudio(clock, this) : nullptr),
brandtrdbdb3f12016-11-10 05:04:48 -0800126 video_(audio ? nullptr : new RTPSenderVideo(clock, this, flexfec_sender)),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000127 paced_sender_(paced_sender),
sprangebbf8a82015-09-21 15:11:14 -0700128 transport_sequence_number_allocator_(sequence_number_allocator),
sprang5e023eb2015-09-14 06:42:43 -0700129 transport_feedback_observer_(transport_feedback_observer),
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000130 last_capture_time_ms_sent_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000131 transport_(transport),
nisse284542b2017-01-10 08:58:32 -0800132 sending_media_(true), // Default to sending media.
133 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100134 last_payload_type_(-1),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000135 payload_type_map_(),
136 rtp_header_extension_map_(),
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000137 packet_history_(clock),
brandtr9dfff292016-11-14 05:14:50 -0800138 flexfec_packet_history_(clock),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000139 // Statistics
Johannes Kron4a8a5e72018-09-26 09:57:48 +0200140 send_delays_(),
141 max_delay_it_(send_delays_.end()),
142 sum_delays_ms_(0),
sprangcd349d92016-07-13 09:11:28 -0700143 rtp_stats_callback_(nullptr),
144 total_bitrate_sent_(kBitrateStatisticsWindowMs,
145 RateStatistics::kBpsScale),
146 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
andresp@webrtc.org8f151212014-07-10 09:39:23 +0000147 frame_count_observer_(frame_count_observer),
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000148 send_side_delay_observer_(send_side_delay_observer),
terelius429c3452016-01-21 05:42:04 -0800149 event_log_(event_log),
asapersson35151f32016-05-02 23:44:01 -0700150 send_packet_observer_(send_packet_observer),
sprangcd349d92016-07-13 09:11:28 -0700151 bitrate_callback_(bitrate_callback),
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000152 // RTP variables
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000153 remote_ssrc_(0),
154 sequence_number_forced_(false),
danilchape5b41412016-08-22 03:39:23 -0700155 last_rtp_timestamp_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000156 capture_time_ms_(0),
157 last_timestamp_time_ms_(0),
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000158 media_has_been_sent_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000159 last_packet_marker_bit_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000160 csrcs_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000161 rtx_(kRtxOff),
michaelt4da30442016-11-17 01:38:43 -0800162 rtp_overhead_bytes_per_packet_(0),
163 retransmission_rate_limiter_(retransmission_rate_limiter),
elad.alonc3dfff32017-01-26 02:46:55 -0800164 overhead_observer_(overhead_observer),
Erik Språng7b52f102018-02-07 14:37:37 +0100165 populate_network2_timestamp_(populate_network2_timestamp),
elad.alonc3dfff32017-01-26 02:46:55 -0800166 send_side_bwe_with_overhead_(
Ilya Nikolaevskiy523b4c42018-08-23 17:07:29 +0200167 webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")),
168 unlimited_retransmission_experiment_(
169 field_trial::IsEnabled("WebRTC-UnlimitedScreenshareRetransmission")) {
danilchap71fead22016-08-18 02:01:49 -0700170 // This random initialization is not intended to be cryptographic strong.
171 timestamp_offset_ = random_.Rand<uint32_t>();
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000172 // Random start, 16 bits. Can't be 0.
danilchap47a740b2015-12-15 00:30:07 -0800173 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
174 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
brandtr9dfff292016-11-14 05:14:50 -0800175
176 // Store FlexFEC packets in the packet history data structure, so they can
177 // be found when paced.
178 if (flexfec_sender) {
179 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språnga12b1d62018-03-14 12:39:24 +0100180 RtpPacketHistory::StorageMode::kStore,
181 kMinFlexfecPacketsToStoreForPacing);
brandtr9dfff292016-11-14 05:14:50 -0800182 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000183}
184
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000185RTPSender::~RTPSender() {
tommiae695e92016-02-02 08:31:45 -0800186 // TODO(tommi): Use a thread checker to ensure the object is created and
187 // deleted on the same thread. At the moment this isn't possible due to
188 // voe::ChannelOwner in voice engine. To reproduce, run:
189 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
190
191 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
192 // variables but we grab them in all other methods. (what's the design?)
193 // Start documenting what thread we're on in what method so that it's easier
194 // to understand performance attributes and possibly remove locks.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000195 while (!payload_type_map_.empty()) {
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000196 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000197 payload_type_map_.begin();
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000198 delete it->second;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000199 payload_type_map_.erase(it);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000200 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000201}
niklase@google.com470e71d2011-07-07 08:21:25 +0000202
erikvarga27883732017-05-17 05:08:38 -0700203rtc::ArrayView<const RtpExtensionSize> RTPSender::FecExtensionSizes() {
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +0100204 return rtc::MakeArrayView(kFecOrPaddingExtensionSizes,
205 arraysize(kFecOrPaddingExtensionSizes));
206}
207
208rtc::ArrayView<const RtpExtensionSize> RTPSender::VideoExtensionSizes() {
209 return rtc::MakeArrayView(kVideoExtensionSizes,
210 arraysize(kVideoExtensionSizes));
erikvarga27883732017-05-17 05:08:38 -0700211}
212
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000213uint16_t RTPSender::ActualSendBitrateKbit() const {
sprangcd349d92016-07-13 09:11:28 -0700214 rtc::CritScope cs(&statistics_crit_);
215 return static_cast<uint16_t>(
216 total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0) /
217 1000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000218}
219
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000220uint32_t RTPSender::VideoBitrateSent() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000221 if (video_) {
222 return video_->VideoBitrateSent();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000223 }
224 return 0;
stefan@webrtc.orgfbea4e52011-10-27 16:08:29 +0000225}
226
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000227uint32_t RTPSender::FecOverheadRate() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000228 if (video_) {
229 return video_->FecOverheadRate();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000230 }
231 return 0;
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000232}
233
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000234uint32_t RTPSender::NackOverheadRate() const {
sprangcd349d92016-07-13 09:11:28 -0700235 rtc::CritScope cs(&statistics_crit_);
236 return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000237}
238
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000239int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
240 uint8_t id) {
tommiae695e92016-02-02 08:31:45 -0800241 rtc::CritScope lock(&send_critsect_);
danilchapfab482b2017-04-04 02:33:48 -0700242 return rtp_header_extension_map_.RegisterByType(id, type) ? 0 : -1;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000243}
244
Danil Chapovalov585d1aa2018-09-14 18:29:32 +0200245bool RTPSender::RegisterRtpHeaderExtension(const std::string& uri, int id) {
246 rtc::CritScope lock(&send_critsect_);
247 return rtp_header_extension_map_.RegisterByUri(id, uri);
248}
249
stefan53b6cc32017-02-03 08:13:57 -0800250bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) const {
tommiae695e92016-02-02 08:31:45 -0800251 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000252 return rtp_header_extension_map_.IsRegistered(type);
253}
254
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000255int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800256 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000257 return rtp_header_extension_map_.Deregister(type);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000258}
259
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000260int32_t RTPSender::RegisterPayload(
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000261 const char payload_name[RTP_PAYLOAD_NAME_SIZE],
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000262 int8_t payload_number,
263 uint32_t frequency,
Peter Kasting69558702016-01-12 16:26:35 -0800264 size_t channels,
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000265 uint32_t rate) {
Peter Boström8b79b072016-02-26 16:31:37 +0100266 RTC_DCHECK_LT(strlen(payload_name), RTP_PAYLOAD_NAME_SIZE);
tommiae695e92016-02-02 08:31:45 -0800267 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000268
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000269 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000270 payload_type_map_.find(payload_number);
niklase@google.com470e71d2011-07-07 08:21:25 +0000271
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000272 if (payload_type_map_.end() != it) {
273 // We already use this payload type.
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000274 RtpUtility::Payload* payload = it->second;
spranga8ae6f22017-09-04 07:23:56 -0700275 RTC_DCHECK(payload);
niklase@google.com470e71d2011-07-07 08:21:25 +0000276
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000277 // Check if it's the same as we already have.
Yves Gerey665174f2018-06-19 15:03:05 +0200278 if (RtpUtility::StringCompare(payload->name, payload_name,
279 RTP_PAYLOAD_NAME_SIZE - 1)) {
Karl Wibergc856dc22017-09-28 20:13:59 +0200280 if (audio_configured_ && payload->typeSpecific.is_audio()) {
281 auto& p = payload->typeSpecific.audio_payload();
Karl Wibergc62f6c72017-10-04 12:38:53 +0200282 if (rtc::SafeEq(p.format.clockrate_hz, frequency) &&
Karl Wibergc856dc22017-09-28 20:13:59 +0200283 (p.rate == rate || p.rate == 0 || rate == 0)) {
284 p.rate = rate;
285 // Ensure that we update the rate if new or old is zero.
286 return 0;
287 }
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000288 }
Karl Wibergc856dc22017-09-28 20:13:59 +0200289 if (!audio_configured_ && !payload->typeSpecific.is_audio()) {
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000290 return 0;
291 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000292 }
293 return -1;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000294 }
mflodmanfcf54bd2015-04-14 21:28:08 +0200295 int32_t ret_val = 0;
danilchap6db6cdc2015-12-15 02:54:47 -0800296 RtpUtility::Payload* payload = nullptr;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000297 if (audio_configured_) {
mflodmanfcf54bd2015-04-14 21:28:08 +0200298 // TODO(mflodman): Change to CreateAudioPayload and make static.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000299 ret_val = audio_->RegisterAudioPayload(payload_name, payload_number,
danilchap6db6cdc2015-12-15 02:54:47 -0800300 frequency, channels, rate, &payload);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000301 } else {
Peter Boström9d0c4322016-02-16 17:59:27 +0100302 payload = video_->CreateVideoPayload(payload_name, payload_number);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000303 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000304 if (payload) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000305 payload_type_map_[payload_number] = payload;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000306 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000307 return ret_val;
niklase@google.com470e71d2011-07-07 08:21:25 +0000308}
309
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000310int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) {
tommiae695e92016-02-02 08:31:45 -0800311 rtc::CritScope lock(&send_critsect_);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000312
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000313 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000314 payload_type_map_.find(payload_type);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000315
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000316 if (payload_type_map_.end() == it) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000317 return -1;
318 }
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000319 RtpUtility::Payload* payload = it->second;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000320 delete payload;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000321 payload_type_map_.erase(it);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000322 return 0;
323}
niklase@google.com470e71d2011-07-07 08:21:25 +0000324
nisse284542b2017-01-10 08:58:32 -0800325void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
kwibergee89e782017-08-09 17:22:01 -0700326 RTC_DCHECK_GE(max_packet_size, 100);
327 RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
tommiae695e92016-02-02 08:31:45 -0800328 rtc::CritScope lock(&send_critsect_);
nisse284542b2017-01-10 08:58:32 -0800329 max_packet_size_ = max_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25 +0000330}
331
nisse284542b2017-01-10 08:58:32 -0800332size_t RTPSender::MaxRtpPacketSize() const {
333 return max_packet_size_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000334}
335
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000336void RTPSender::SetRtxStatus(int mode) {
tommiae695e92016-02-02 08:31:45 -0800337 rtc::CritScope lock(&send_critsect_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000338 rtx_ = mode;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000339}
340
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000341int RTPSender::RtxStatus() const {
tommiae695e92016-02-02 08:31:45 -0800342 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000343 return rtx_;
344}
345
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000346void RTPSender::SetRtxSsrc(uint32_t ssrc) {
tommiae695e92016-02-02 08:31:45 -0800347 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800348 ssrc_rtx_.emplace(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000349}
350
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000351uint32_t RTPSender::RtxSsrc() const {
tommiae695e92016-02-02 08:31:45 -0800352 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800353 RTC_DCHECK(ssrc_rtx_);
354 return *ssrc_rtx_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000355}
356
Shao Changbine62202f2015-04-21 20:24:50 +0800357void RTPSender::SetRtxPayloadType(int payload_type,
358 int associated_payload_type) {
tommiae695e92016-02-02 08:31:45 -0800359 rtc::CritScope lock(&send_critsect_);
henrikg91d6ede2015-09-17 00:24:34 -0700360 RTC_DCHECK_LE(payload_type, 127);
361 RTC_DCHECK_LE(associated_payload_type, 127);
Shao Changbine62202f2015-04-21 20:24:50 +0800362 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100363 RTC_LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type << ".";
Shao Changbine62202f2015-04-21 20:24:50 +0800364 return;
365 }
366
367 rtx_payload_type_map_[associated_payload_type] = payload_type;
Ã…sa Persson6ae25722015-04-13 17:48:08 +0200368}
369
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000370int32_t RTPSender::CheckPayloadType(int8_t payload_type,
Niels Möller520ca4e2018-06-04 11:14:38 +0200371 VideoCodecType* video_type) {
tommiae695e92016-02-02 08:31:45 -0800372 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000373
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000374 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100375 RTC_LOG(LS_ERROR) << "Invalid payload_type " << payload_type << ".";
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000376 return -1;
377 }
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100378 if (last_payload_type_ == payload_type) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000379 if (!audio_configured_) {
380 *video_type = video_->VideoCodecType();
niklase@google.com470e71d2011-07-07 08:21:25 +0000381 }
382 return 0;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000383 }
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000384 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000385 payload_type_map_.find(payload_type);
386 if (it == payload_type_map_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100387 RTC_LOG(LS_WARNING) << "Payload type " << static_cast<int>(payload_type)
388 << " not registered.";
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000389 return -1;
390 }
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000391 RtpUtility::Payload* payload = it->second;
spranga8ae6f22017-09-04 07:23:56 -0700392 RTC_DCHECK(payload);
Karl Wibergc856dc22017-09-28 20:13:59 +0200393 if (payload->typeSpecific.is_video() && !audio_configured_) {
394 video_->SetVideoCodecType(
395 payload->typeSpecific.video_payload().videoCodecType);
396 *video_type = payload->typeSpecific.video_payload().videoCodecType;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000397 }
398 return 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000399}
400
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700401bool RTPSender::SendOutgoingData(FrameType frame_type,
402 int8_t payload_type,
403 uint32_t capture_timestamp,
404 int64_t capture_time_ms,
405 const uint8_t* payload_data,
406 size_t payload_size,
407 const RTPFragmentationHeader* fragmentation,
408 const RTPVideoHeader* rtp_header,
spranga8ae6f22017-09-04 07:23:56 -0700409 uint32_t* transport_frame_id_out,
410 int64_t expected_retransmission_time_ms) {
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000411 uint32_t ssrc;
isheriff6b4b5f32016-06-08 00:24:21 -0700412 uint16_t sequence_number;
danilchape5b41412016-08-22 03:39:23 -0700413 uint32_t rtp_timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000414 {
415 // Drop this packet if we're not sending media packets.
tommiae695e92016-02-02 08:31:45 -0800416 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800417 RTC_DCHECK(ssrc_);
418
419 ssrc = *ssrc_;
isheriff6b4b5f32016-06-08 00:24:21 -0700420 sequence_number = sequence_number_;
danilchape5b41412016-08-22 03:39:23 -0700421 rtp_timestamp = timestamp_offset_ + capture_timestamp;
422 if (transport_frame_id_out)
423 *transport_frame_id_out = rtp_timestamp;
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700424 if (!sending_media_)
425 return true;
Ilya Nikolaevskiy523b4c42018-08-23 17:07:29 +0200426
427 // Cache video content type.
428 if (!audio_configured_ && rtp_header) {
429 video_content_type_ = rtp_header->content_type;
430 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000431 }
Niels Möller520ca4e2018-06-04 11:14:38 +0200432 VideoCodecType video_type = kVideoCodecGeneric;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000433 if (CheckPayloadType(payload_type, &video_type) != 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100434 RTC_LOG(LS_ERROR) << "Don't send data with unknown payload type: "
435 << static_cast<int>(payload_type) << ".";
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700436 return false;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000437 }
438
spranga8ae6f22017-09-04 07:23:56 -0700439 switch (frame_type) {
440 case kAudioFrameSpeech:
441 case kAudioFrameCN:
442 RTC_CHECK(audio_configured_);
443 break;
444 case kVideoFrameKey:
445 case kVideoFrameDelta:
446 RTC_CHECK(!audio_configured_);
447 break;
448 case kEmptyFrame:
449 break;
450 }
451
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700452 bool result;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000453 if (audio_configured_) {
danilchape5b41412016-08-22 03:39:23 -0700454 TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", rtp_timestamp, "Send", "type",
455 FrameTypeToString(frame_type));
Niels Möller90397d92017-10-27 10:51:20 +0200456 // The only known way to produce of RTPFragmentationHeader for audio is
457 // to use the AudioCodingModule directly.
458 RTC_DCHECK(fragmentation == nullptr);
danilchape5b41412016-08-22 03:39:23 -0700459 result = audio_->SendAudio(frame_type, payload_type, rtp_timestamp,
Niels Möller90397d92017-10-27 10:51:20 +0200460 payload_data, payload_size);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000461 } else {
Yves Gerey665174f2018-06-19 15:03:05 +0200462 TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms, "Send", "type",
463 FrameTypeToString(frame_type));
pbos22993e12015-10-19 02:39:06 -0700464 if (frame_type == kEmptyFrame)
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700465 return true;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000466
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700467 if (rtp_header) {
468 playout_delay_oracle_.UpdateRequest(ssrc, rtp_header->playout_delay,
isheriff6b4b5f32016-06-08 00:24:21 -0700469 sequence_number);
470 }
471
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700472 result = video_->SendVideo(video_type, frame_type, payload_type,
danilchape5b41412016-08-22 03:39:23 -0700473 rtp_timestamp, capture_time_ms, payload_data,
spranga8ae6f22017-09-04 07:23:56 -0700474 payload_size, fragmentation, rtp_header,
475 expected_retransmission_time_ms);
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700476 }
477
danilchap7c9426c2016-04-14 03:05:31 -0700478 rtc::CritScope cs(&statistics_crit_);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000479 // Note: This is currently only counting for video.
480 if (frame_type == kVideoFrameKey) {
481 ++frame_counts_.key_frames;
482 } else if (frame_type == kVideoFrameDelta) {
483 ++frame_counts_.delta_frames;
484 }
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000485 if (frame_count_observer_) {
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000486 frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000487 }
488
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700489 return result;
niklase@google.com470e71d2011-07-07 08:21:25 +0000490}
491
philipela1ed0b32016-06-01 06:31:17 -0700492size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
philipel8aadd502017-02-23 02:56:13 -0800493 const PacedPacketInfo& pacing_info) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000494 {
tommiae695e92016-02-02 08:31:45 -0800495 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100496 if (!sending_media_)
497 return 0;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000498 if ((rtx_ & kRtxRedundantPayloads) == 0)
499 return 0;
500 }
501
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000502 int bytes_left = static_cast<int>(bytes_to_send);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000503 while (bytes_left > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200504 std::unique_ptr<RtpPacketToSend> packet =
505 packet_history_.GetBestFittingPacket(bytes_left);
506 if (!packet)
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000507 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200508 size_t payload_size = packet->payload_size();
philipel8aadd502017-02-23 02:56:13 -0800509 if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000510 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200511 bytes_left -= payload_size;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000512 }
513 return bytes_to_send - bytes_left;
514}
515
philipel8aadd502017-02-23 02:56:13 -0800516size_t RTPSender::SendPadData(size_t bytes,
517 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800518 size_t padding_bytes_in_packet;
erikvarga76a55932017-05-17 07:50:17 -0700519 size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
erikvarga27883732017-05-17 05:08:38 -0700520
stefan53b6cc32017-02-03 08:13:57 -0800521 if (audio_configured_) {
522 // Allow smaller padding packets for audio.
kwiberg07038562017-06-12 11:40:47 -0700523 padding_bytes_in_packet = rtc::SafeClamp<size_t>(
524 bytes, kMinAudioPaddingLength,
525 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
stefan53b6cc32017-02-03 08:13:57 -0800526 } else {
527 // Always send full padding packets. This is accounted for by the
528 // RtpPacketSender, which will make sure we don't send too much padding even
529 // if a single packet is larger than requested.
530 // We do this to avoid frequently sending small packets on higher bitrates.
kwiberg07038562017-06-12 11:40:47 -0700531 padding_bytes_in_packet =
532 rtc::SafeMin<size_t>(max_payload_size, kMaxPaddingLength);
stefan53b6cc32017-02-03 08:13:57 -0800533 }
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000534 size_t bytes_sent = 0;
danilchap90069872016-12-14 06:16:33 -0800535 while (bytes_sent < bytes) {
536 int64_t now_ms = clock_->TimeInMilliseconds();
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000537 uint32_t ssrc;
danilchap90069872016-12-14 06:16:33 -0800538 uint32_t timestamp;
539 int64_t capture_time_ms;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000540 uint16_t sequence_number;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000541 int payload_type;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000542 bool over_rtx;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000543 {
tommiae695e92016-02-02 08:31:45 -0800544 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100545 if (!sending_media_)
danilchap90069872016-12-14 06:16:33 -0800546 break;
547 timestamp = last_rtp_timestamp_;
548 capture_time_ms = capture_time_ms_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000549 if (rtx_ == kRtxOff) {
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100550 if (last_payload_type_ == -1)
stefane35f89a2017-02-01 09:06:25 -0800551 break;
stefan53b6cc32017-02-03 08:13:57 -0800552 // Without RTX we can't send padding in the middle of frames.
553 // For audio marker bits doesn't mark the end of a frame and frames
554 // are usually a single packet, so for now we don't apply this rule
555 // for audio.
556 if (!audio_configured_ && !last_packet_marker_bit_) {
557 break;
558 }
nisse7d59f6b2017-02-21 03:40:24 -0800559 if (!ssrc_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100560 RTC_LOG(LS_ERROR) << "SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800561 return 0;
562 }
563
564 RTC_DCHECK(ssrc_);
565 ssrc = *ssrc_;
566
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000567 sequence_number = sequence_number_;
568 ++sequence_number_;
Danil Chapovalovb3179c72018-03-22 10:13:07 +0100569 payload_type = last_payload_type_;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000570 over_rtx = false;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000571 } else {
Stefan Holmerf5dca482016-01-27 12:58:51 +0100572 // Without abs-send-time or transport sequence number a media packet
573 // must be sent before padding so that the timestamps used for
574 // estimation are correct.
575 if (!media_has_been_sent_ &&
danilchap90069872016-12-14 06:16:33 -0800576 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
577 (rtp_header_extension_map_.IsRegistered(
578 TransportSequenceNumber::kId) &&
579 transport_sequence_number_allocator_))) {
580 break;
Stefan Holmerf5dca482016-01-27 12:58:51 +0100581 }
Stefan Holmer586b19b2015-09-18 11:14:31 +0200582 // Only change change the timestamp of padding packets sent over RTX.
583 // Padding only packets over RTP has to be sent as part of a media
584 // frame (and therefore the same timestamp).
585 if (last_timestamp_time_ms_ > 0) {
586 timestamp +=
danilchap90069872016-12-14 06:16:33 -0800587 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
588 capture_time_ms += (now_ms - last_timestamp_time_ms_);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200589 }
nisse7d59f6b2017-02-21 03:40:24 -0800590 if (!ssrc_rtx_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100591 RTC_LOG(LS_ERROR) << "RTX SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800592 return 0;
593 }
594 RTC_DCHECK(ssrc_rtx_);
595 ssrc = *ssrc_rtx_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000596 sequence_number = sequence_number_rtx_;
597 ++sequence_number_rtx_;
Stefan Holmer10880012016-02-03 13:29:59 +0100598 payload_type = rtx_payload_type_map_.begin()->second;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000599 over_rtx = true;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000600 }
601 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000602
danilchap90069872016-12-14 06:16:33 -0800603 RtpPacketToSend padding_packet(&rtp_header_extension_map_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200604 padding_packet.SetPayloadType(payload_type);
605 padding_packet.SetMarker(false);
606 padding_packet.SetSequenceNumber(sequence_number);
607 padding_packet.SetTimestamp(timestamp);
608 padding_packet.SetSsrc(ssrc);
609
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000610 if (capture_time_ms > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200611 padding_packet.SetExtension<TransmissionOffset>(
danilchap90069872016-12-14 06:16:33 -0800612 (now_ms - capture_time_ms) * kTimestampTicksPerMs);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000613 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200614 padding_packet.SetExtension<AbsoluteSendTime>(
615 AbsoluteSendTime::MsTo24Bits(now_ms));
stefan1d8a5062015-10-02 03:39:33 -0700616 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200617 // Padding packets are never retransmissions.
618 options.is_retransmit = false;
michaelt4da30442016-11-17 01:38:43 -0800619 bool has_transport_seq_num =
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200620 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200621 padding_packet.SetPadding(padding_bytes_in_packet, &random_);
622
michaelt4da30442016-11-17 01:38:43 -0800623 if (has_transport_seq_num) {
624 AddPacketToTransportFeedback(options.packet_id, padding_packet,
philipel8aadd502017-02-23 02:56:13 -0800625 pacing_info);
michaelt4da30442016-11-17 01:38:43 -0800626 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200627
philipel32d00102017-02-27 02:18:46 -0800628 if (!SendPacketToNetwork(padding_packet, options, pacing_info))
stefanf116bd02015-10-27 08:29:42 -0700629 break;
630
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000631 bytes_sent += padding_bytes_in_packet;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200632 UpdateRtpStats(padding_packet, over_rtx, false);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000633 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000634
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000635 return bytes_sent;
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000636}
637
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000638void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100639 RtpPacketHistory::StorageMode mode =
640 enable ? RtpPacketHistory::StorageMode::kStore
641 : RtpPacketHistory::StorageMode::kDisabled;
642 packet_history_.SetStorePacketsStatus(mode, number_to_store);
niklase@google.com470e71d2011-07-07 08:21:25 +0000643}
644
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000645bool RTPSender::StorePackets() const {
Erik Språnga12b1d62018-03-14 12:39:24 +0100646 return packet_history_.GetStorageMode() !=
647 RtpPacketHistory::StorageMode::kDisabled;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000648}
niklase@google.com470e71d2011-07-07 08:21:25 +0000649
Erik Språnga12b1d62018-03-14 12:39:24 +0100650int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
651 // Try to find packet in RTP packet history. Also verify RTT here, so that we
652 // don't retransmit too often.
Danil Chapovalovd264df52018-06-14 12:59:38 +0200653 absl::optional<RtpPacketHistory::PacketState> stored_packet =
Erik Språnga12b1d62018-03-14 12:39:24 +0100654 packet_history_.GetPacketState(packet_id, true);
655 if (!stored_packet) {
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000656 // Packet not found.
asapersson@webrtc.org83ed0a42012-04-23 12:43:05 +0000657 return 0;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000658 }
Oleh Prypin5a980492018-03-09 12:27:24 +0000659
Erik Språnga12b1d62018-03-14 12:39:24 +0100660 const int32_t packet_size = static_cast<int32_t>(stored_packet->payload_size);
661
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200662 // Skip retransmission rate check if not configured.
663 if (retransmission_rate_limiter_) {
664 // Skip retransmission rate check if sending screenshare and the experiment
665 // is on.
666 bool skip_retransmission_rate_limit = false;
667 if (unlimited_retransmission_experiment_) {
668 rtc::CritScope lock(&send_critsect_);
669 skip_retransmission_rate_limit =
670 video_content_type_ &&
671 videocontenttypehelpers::IsScreenshare(*video_content_type_);
672 }
Ilya Nikolaevskiy523b4c42018-08-23 17:07:29 +0200673
Danil Chapovalovc7fff582018-09-11 14:28:19 +0200674 // Check if we're overusing retransmission bitrate.
675 // TODO(sprang): Add histograms for nack success or failure reasons.
676 if (!skip_retransmission_rate_limit &&
677 !retransmission_rate_limiter_->TryUseRate(packet_size)) {
678 return -1;
679 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100680 }
Erik Språng7bb37b82018-03-09 09:52:59 +0100681
Oleh Prypin5a980492018-03-09 12:27:24 +0000682 if (paced_sender_) {
683 // Convert from TickTime to Clock since capture_time_ms is based on
684 // TickTime.
685 int64_t corrected_capture_tims_ms =
Erik Språnga12b1d62018-03-14 12:39:24 +0100686 stored_packet->capture_time_ms + clock_delta_ms_;
687 paced_sender_->InsertPacket(
688 RtpPacketSender::kNormalPriority, stored_packet->ssrc,
689 stored_packet->rtp_sequence_number, corrected_capture_tims_ms,
690 stored_packet->payload_size, true);
Oleh Prypin5a980492018-03-09 12:27:24 +0000691
Erik Språnga12b1d62018-03-14 12:39:24 +0100692 return packet_size;
Oleh Prypin5a980492018-03-09 12:27:24 +0000693 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100694
695 std::unique_ptr<RtpPacketToSend> packet =
696 packet_history_.GetPacketAndSetSendTime(packet_id, true);
697 if (!packet) {
698 // Packet could theoretically time out between the first check and this one.
699 return 0;
700 }
701
702 const bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
philipel8aadd502017-02-23 02:56:13 -0800703 if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
sprang867fb522015-08-03 04:38:41 -0700704 return -1;
Erik Språnga12b1d62018-03-14 12:39:24 +0100705
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200706 return packet_size;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000707}
708
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200709bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
philipel32d00102017-02-27 02:18:46 -0800710 const PacketOptions& options,
711 const PacedPacketInfo& pacing_info) {
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000712 int bytes_sent = -1;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000713 if (transport_) {
michaelt4da30442016-11-17 01:38:43 -0800714 UpdateRtpOverhead(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200715 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
716 ? static_cast<int>(packet.size())
stefan1d8a5062015-10-02 03:39:33 -0700717 : -1;
terelius429c3452016-01-21 05:42:04 -0800718 if (event_log_ && bytes_sent > 0) {
Karl Wiberg918f50c2018-07-05 11:40:33 +0200719 event_log_->Log(absl::make_unique<RtcEventRtpPacketOutgoing>(
Elad Alon4a87e1c2017-10-03 16:11:34 +0200720 packet, pacing_info.probe_cluster_id));
terelius429c3452016-01-21 05:42:04 -0800721 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000722 }
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000723 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000724 if (bytes_sent <= 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100725 RTC_LOG(LS_WARNING) << "Transport failed to send packet.";
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000726 return false;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000727 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000728 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000729}
730
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000731int RTPSender::SelectiveRetransmissions() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000732 if (!video_)
733 return -1;
734 return video_->SelectiveRetransmissions();
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000735}
736
737int RTPSender::SetSelectiveRetransmissions(uint8_t settings) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000738 if (!video_)
739 return -1;
mflodmanfcf54bd2015-04-14 21:28:08 +0200740 video_->SetSelectiveRetransmissions(settings);
741 return 0;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000742}
743
Danil Chapovalov2800d742016-08-26 18:48:46 +0200744void RTPSender::OnReceivedNack(
745 const std::vector<uint16_t>& nack_sequence_numbers,
746 int64_t avg_rtt) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100747 packet_history_.SetRtt(5 + avg_rtt);
sprangcd349d92016-07-13 09:11:28 -0700748 for (uint16_t seq_no : nack_sequence_numbers) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100749 const int32_t bytes_sent = ReSendPacket(seq_no);
sprangcd349d92016-07-13 09:11:28 -0700750 if (bytes_sent < 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000751 // Failed to send one Sequence number. Give up the rest in this nack.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100752 RTC_LOG(LS_WARNING) << "Failed resending RTP packet " << seq_no
753 << ", Discard rest of packets.";
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000754 break;
niklase@google.com470e71d2011-07-07 08:21:25 +0000755 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000756 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000757}
758
isheriff6b4b5f32016-06-08 00:24:21 -0700759void RTPSender::OnReceivedRtcpReportBlocks(
760 const ReportBlockList& report_blocks) {
761 playout_delay_oracle_.OnReceivedRtcpReportBlocks(report_blocks);
762}
763
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000764// Called from pacer when we can send the packet.
brandtr9dfff292016-11-14 05:14:50 -0800765bool RTPSender::TimeToSendPacket(uint32_t ssrc,
766 uint16_t sequence_number,
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000767 int64_t capture_time_ms,
philipela1ed0b32016-06-01 06:31:17 -0700768 bool retransmission,
philipel8aadd502017-02-23 02:56:13 -0800769 const PacedPacketInfo& pacing_info) {
brandtr9dfff292016-11-14 05:14:50 -0800770 if (!SendingMedia())
771 return true;
772
773 std::unique_ptr<RtpPacketToSend> packet;
Erik Språnga12b1d62018-03-14 12:39:24 +0100774 // No need to verify RTT here, it has already been checked before putting the
775 // packet into the pacer. But _do_ update the send time.
brandtr9dfff292016-11-14 05:14:50 -0800776 if (ssrc == SSRC()) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100777 packet = packet_history_.GetPacketAndSetSendTime(sequence_number, false);
brandtr9dfff292016-11-14 05:14:50 -0800778 } else if (ssrc == FlexfecSsrc()) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100779 packet =
780 flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number, false);
brandtr9dfff292016-11-14 05:14:50 -0800781 }
782
Stefan Holmera246cfb2016-08-23 17:51:42 +0200783 if (!packet) {
brandtr9dfff292016-11-14 05:14:50 -0800784 // Packet cannot be found.
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000785 return true;
Stefan Holmera246cfb2016-08-23 17:51:42 +0200786 }
asapersson35151f32016-05-02 23:44:01 -0700787
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200788 return PrepareAndSendPacket(
789 std::move(packet),
790 retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission,
philipel8aadd502017-02-23 02:56:13 -0800791 pacing_info);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000792}
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000793
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200794bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000795 bool send_over_rtx,
philipela1ed0b32016-06-01 06:31:17 -0700796 bool is_retransmit,
philipel8aadd502017-02-23 02:56:13 -0800797 const PacedPacketInfo& pacing_info) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200798 RTC_DCHECK(packet);
799 int64_t capture_time_ms = packet->capture_time_ms();
800 RtpPacketToSend* packet_to_send = packet.get();
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000801
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200802 std::unique_ptr<RtpPacketToSend> packet_rtx;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000803 if (send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200804 packet_rtx = BuildRtxPacket(*packet);
805 if (!packet_rtx)
danilchap32cd2c42016-08-01 06:58:34 -0700806 return false;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200807 packet_to_send = packet_rtx.get();
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000808 }
809
ilnik10894992017-06-21 08:23:19 -0700810 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
811 // the pacer, these modifications of the header below are happening after the
812 // FEC protection packets are calculated. This will corrupt recovered packets
813 // at the same place. It's not an issue for extensions, which are present in
814 // all the packets (their content just may be incorrect on recovered packets).
815 // In case of VideoTimingExtension, since it's present not in every packet,
816 // data after rtp header may be corrupted if these packets are protected by
817 // the FEC.
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000818 int64_t now_ms = clock_->TimeInMilliseconds();
819 int64_t diff_ms = now_ms - capture_time_ms;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200820 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
821 diff_ms);
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200822 packet_to_send->SetExtension<AbsoluteSendTime>(
823 AbsoluteSendTime::MsTo24Bits(now_ms));
sprang867fb522015-08-03 04:38:41 -0700824
Erik Språng7b52f102018-02-07 14:37:37 +0100825 if (packet_to_send->HasExtension<VideoTimingExtension>()) {
826 if (populate_network2_timestamp_) {
827 packet_to_send->set_network2_time_ms(now_ms);
828 } else {
829 packet_to_send->set_pacer_exit_time_ms(now_ms);
830 }
831 }
ilnik04f4d122017-06-19 07:18:55 -0700832
stefan1d8a5062015-10-02 03:39:33 -0700833 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200834 // If we are sending over RTX, it also means this is a retransmission.
835 // E.g. RTPSender::TrySendRedundantPayloads calls PrepareAndSendPacket with
836 // send_over_rtx = true but is_retransmit = false.
837 options.is_retransmit = is_retransmit || send_over_rtx;
michaelt4da30442016-11-17 01:38:43 -0800838 if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id)) {
839 AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
philipel8aadd502017-02-23 02:56:13 -0800840 pacing_info);
sprang867fb522015-08-03 04:38:41 -0700841 }
Dino Radaković1807d572018-02-22 14:18:06 +0100842 options.application_data.assign(packet_to_send->application_data().begin(),
843 packet_to_send->application_data().end());
sprang867fb522015-08-03 04:38:41 -0700844
asapersson35151f32016-05-02 23:44:01 -0700845 if (!is_retransmit && !send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200846 UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
847 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
848 packet->Ssrc());
stefanf116bd02015-10-27 08:29:42 -0700849 }
850
philipel32d00102017-02-27 02:18:46 -0800851 if (!SendPacketToNetwork(*packet_to_send, options, pacing_info))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200852 return false;
853
854 {
tommiae695e92016-02-02 08:31:45 -0800855 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000856 media_has_been_sent_ = true;
857 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200858 UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit);
859 return true;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000860}
861
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200862void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet,
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000863 bool is_rtx,
864 bool is_retransmit) {
sprangcd349d92016-07-13 09:11:28 -0700865 int64_t now_ms = clock_->TimeInMilliseconds();
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000866
danilchap7c9426c2016-04-14 03:05:31 -0700867 rtc::CritScope lock(&statistics_crit_);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200868 StreamDataCounters* counters = is_rtx ? &rtx_rtp_stats_ : &rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000869
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200870 total_bitrate_sent_.Update(packet.size(), now_ms);
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000871
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200872 if (counters->first_packet_time_ms == -1)
873 counters->first_packet_time_ms = now_ms;
874
875 if (IsFecPacket(packet))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200876 CountPacket(&counters->fec, packet);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200877
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200878 if (is_retransmit) {
879 CountPacket(&counters->retransmitted, packet);
880 nack_bitrate_sent_.Update(packet.size(), now_ms);
881 }
882 CountPacket(&counters->transmitted, packet);
sprangcd349d92016-07-13 09:11:28 -0700883
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200884 if (rtp_stats_callback_)
885 rtp_stats_callback_->DataCountersUpdated(*counters, packet.Ssrc());
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000886}
887
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200888bool RTPSender::IsFecPacket(const RtpPacketToSend& packet) const {
brandtr9e795c62016-11-14 05:37:16 -0800889 if (!video_)
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000890 return false;
brandtr9e795c62016-11-14 05:37:16 -0800891
892 // FlexFEC.
893 if (packet.Ssrc() == FlexfecSsrc())
894 return true;
895
896 // RED+ULPFEC.
brandtrd8048952016-11-07 02:08:51 -0800897 int pt_red;
898 int pt_fec;
brandtrf1bb4762016-11-07 03:05:06 -0800899 video_->GetUlpfecConfig(&pt_red, &pt_fec);
brandtr9e795c62016-11-14 05:37:16 -0800900 return static_cast<int>(packet.PayloadType()) == pt_red &&
brandtrd8048952016-11-07 02:08:51 -0800901 static_cast<int>(packet.payload()[0]) == pt_fec;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000902}
903
philipel8aadd502017-02-23 02:56:13 -0800904size_t RTPSender::TimeToSendPadding(size_t bytes,
905 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800906 if (bytes == 0)
pbos545727e2015-07-01 06:31:06 -0700907 return 0;
philipel8aadd502017-02-23 02:56:13 -0800908 size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000909 if (bytes_sent < bytes)
philipel8aadd502017-02-23 02:56:13 -0800910 bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000911 return bytes_sent;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000912}
913
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200914bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
915 StorageType storage,
916 RtpPacketSender::Priority priority) {
917 RTC_DCHECK(packet);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000918 int64_t now_ms = clock_->TimeInMilliseconds();
919
stefan@webrtc.org715faaf2012-08-28 15:20:39 +0000920 // |capture_time_ms| <= 0 is considered invalid.
921 // TODO(holmer): This should be changed all over Video Engine so that negative
922 // time is consider invalid, while 0 is considered a valid time.
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200923 if (packet->capture_time_ms() > 0) {
924 packet->SetExtension<TransmissionOffset>(
925 kTimestampTicksPerMs * (now_ms - packet->capture_time_ms()));
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +0000926 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200927 packet->SetExtension<AbsoluteSendTime>(AbsoluteSendTime::MsTo24Bits(now_ms));
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000928
gaetano.carlucci52a57032016-09-14 05:04:36 -0700929 if (video_) {
gaetano.carlucci61050f62016-09-30 06:29:54 -0700930 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoTotBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700931 ActualSendBitrateKbit(), packet->Ssrc());
gaetano.carlucci61050f62016-09-30 06:29:54 -0700932 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoFecBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700933 FecOverheadRate() / 1000, packet->Ssrc());
gaetano.carlucci61050f62016-09-30 06:29:54 -0700934 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoNackBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700935 NackOverheadRate() / 1000, packet->Ssrc());
936 } else {
gaetano.carlucci61050f62016-09-30 06:29:54 -0700937 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioTotBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700938 ActualSendBitrateKbit(), packet->Ssrc());
gaetano.carlucci61050f62016-09-30 06:29:54 -0700939 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioNackBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700940 NackOverheadRate() / 1000, packet->Ssrc());
941 }
942
brandtr9dfff292016-11-14 05:14:50 -0800943 uint32_t ssrc = packet->Ssrc();
Danil Chapovalovd264df52018-06-14 12:59:38 +0200944 absl::optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
Peter Boströme23e7372015-10-08 11:44:14 +0200945 if (paced_sender_) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200946 uint16_t seq_no = packet->SequenceNumber();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000947 // Correct offset between implementations of millisecond time stamps in
948 // TickTime and Clock.
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200949 int64_t corrected_time_ms = packet->capture_time_ms() + clock_delta_ms_;
950 size_t payload_length = packet->payload_size();
brandtr9dfff292016-11-14 05:14:50 -0800951 if (ssrc == flexfec_ssrc) {
952 // Store FlexFEC packets in the history here, so they can be found
953 // when the pacer calls TimeToSendPacket.
Erik Språnga12b1d62018-03-14 12:39:24 +0100954 flexfec_packet_history_.PutRtpPacket(std::move(packet), storage,
Danil Chapovalovd264df52018-06-14 12:59:38 +0200955 absl::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800956 } else {
Danil Chapovalovd264df52018-06-14 12:59:38 +0200957 packet_history_.PutRtpPacket(std::move(packet), storage, absl::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800958 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200959
960 paced_sender_->InsertPacket(priority, ssrc, seq_no, corrected_time_ms,
Peter Boströme23e7372015-10-08 11:44:14 +0200961 payload_length, false);
962 if (last_capture_time_ms_sent_ == 0 ||
963 corrected_time_ms > last_capture_time_ms_sent_) {
964 last_capture_time_ms_sent_ = corrected_time_ms;
asapersson@webrtc.orge5b49a02012-11-06 13:09:39 +0000965 }
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700966 return true;
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +0000967 }
Stefan Holmerf5dca482016-01-27 12:58:51 +0100968
969 PacketOptions options;
Petter Strandmark26bc6692018-05-29 08:43:35 +0200970 options.is_retransmit = false;
michaelt4da30442016-11-17 01:38:43 -0800971 if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id)) {
972 AddPacketToTransportFeedback(options.packet_id, *packet.get(),
philipel8aadd502017-02-23 02:56:13 -0800973 PacedPacketInfo());
Stefan Holmerf5dca482016-01-27 12:58:51 +0100974 }
Dino Radaković1807d572018-02-22 14:18:06 +0100975 options.application_data.assign(packet->application_data().begin(),
976 packet->application_data().end());
Stefan Holmerf5dca482016-01-27 12:58:51 +0100977
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200978 UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
979 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
980 packet->Ssrc());
981
philipel32d00102017-02-27 02:18:46 -0800982 bool sent = SendPacketToNetwork(*packet, options, PacedPacketInfo());
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200983
984 if (sent) {
985 {
986 rtc::CritScope lock(&send_critsect_);
987 media_has_been_sent_ = true;
988 }
989 UpdateRtpStats(*packet, false, false);
990 }
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +0000991
brandtr9dfff292016-11-14 05:14:50 -0800992 // To support retransmissions, we store the media packet as sent in the
993 // packet history (even if send failed).
994 if (storage == kAllowRetransmission) {
Danil Chapovalov603ce982017-12-27 11:32:50 +0100995 RTC_DCHECK_EQ(ssrc, SSRC());
Erik Språnga12b1d62018-03-14 12:39:24 +0100996 packet_history_.PutRtpPacket(std::move(packet), storage, now_ms);
brandtr9dfff292016-11-14 05:14:50 -0800997 }
Peter Boströme23e7372015-10-08 11:44:14 +0200998
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200999 return sent;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +00001000}
1001
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001002void RTPSender::RecomputeMaxSendDelay() {
1003 max_delay_it_ = send_delays_.begin();
1004 for (auto it = send_delays_.begin(); it != send_delays_.end(); ++it) {
1005 if (it->second >= max_delay_it_->second) {
1006 max_delay_it_ = it;
1007 }
1008 }
1009}
1010
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001011void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
asapersson35151f32016-05-02 23:44:01 -07001012 if (!send_side_delay_observer_ || capture_time_ms <= 0)
Peter Boström71861a02015-05-28 14:45:36 +02001013 return;
1014
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001015 uint32_t ssrc;
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001016 int avg_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001017 int max_delay_ms = 0;
1018 {
tommiae695e92016-02-02 08:31:45 -08001019 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001020 if (!ssrc_)
1021 return;
1022 ssrc = *ssrc_;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001023 }
1024 {
danilchap7c9426c2016-04-14 03:05:31 -07001025 rtc::CritScope cs(&statistics_crit_);
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001026 // Compute the max and average of the recent capture-to-send delays.
1027 // The time complexity of the current approach depends on the distribution
1028 // of the delay values. This could be done more efficiently.
1029
1030 // Remove elements older than kSendSideDelayWindowMs.
1031 auto lower_bound =
1032 send_delays_.lower_bound(now_ms - kSendSideDelayWindowMs);
1033 for (auto it = send_delays_.begin(); it != lower_bound; ++it) {
1034 if (max_delay_it_ == it) {
1035 max_delay_it_ = send_delays_.end();
1036 }
1037 sum_delays_ms_ -= it->second;
1038 }
1039 send_delays_.erase(send_delays_.begin(), lower_bound);
1040 if (max_delay_it_ == send_delays_.end()) {
1041 // Removed the previous max. Need to recompute.
1042 RecomputeMaxSendDelay();
1043 }
1044
1045 // Add the new element.
Johannes Kron965e7942018-09-13 15:36:20 +02001046 RTC_DCHECK_GE(now_ms, static_cast<int64_t>(0));
1047 RTC_DCHECK_LE(now_ms, std::numeric_limits<int64_t>::max() / 2);
1048 RTC_DCHECK_GE(capture_time_ms, static_cast<int64_t>(0));
1049 RTC_DCHECK_LE(capture_time_ms, std::numeric_limits<int64_t>::max() / 2);
1050 int64_t diff_ms = now_ms - capture_time_ms;
1051 RTC_DCHECK_GE(diff_ms, static_cast<int64_t>(0));
1052 RTC_DCHECK_LE(diff_ms,
1053 static_cast<int64_t>(std::numeric_limits<int>::max()));
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001054 int new_send_delay = rtc::dchecked_cast<int>(now_ms - capture_time_ms);
1055 SendDelayMap::iterator it;
1056 bool inserted;
1057 std::tie(it, inserted) =
1058 send_delays_.insert(std::make_pair(now_ms, new_send_delay));
1059 if (!inserted) {
1060 // TODO(terelius): If we have multiple delay measurements during the same
1061 // millisecond then we keep the most recent one. It is not clear that this
1062 // is the right decision, but it preserves an earlier behavior.
1063 int previous_send_delay = it->second;
1064 sum_delays_ms_ -= previous_send_delay;
1065 it->second = new_send_delay;
1066 if (max_delay_it_ == it && new_send_delay < previous_send_delay) {
1067 RecomputeMaxSendDelay();
1068 }
Peter Boström71861a02015-05-28 14:45:36 +02001069 }
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001070 if (max_delay_it_ == send_delays_.end() ||
1071 it->second >= max_delay_it_->second) {
1072 max_delay_it_ = it;
1073 }
1074 sum_delays_ms_ += new_send_delay;
1075
1076 size_t num_delays = send_delays_.size();
1077 RTC_DCHECK(max_delay_it_ != send_delays_.end());
1078 max_delay_ms = rtc::dchecked_cast<int>(max_delay_it_->second);
1079 int64_t avg_ms = (sum_delays_ms_ + num_delays / 2) / num_delays;
1080 RTC_DCHECK_GE(avg_ms, static_cast<int64_t>(0));
1081 RTC_DCHECK_LE(avg_ms,
1082 static_cast<int64_t>(std::numeric_limits<int>::max()));
1083 avg_delay_ms =
1084 rtc::dchecked_cast<int>((sum_delays_ms_ + num_delays / 2) / num_delays);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001085 }
Johannes Kron4a8a5e72018-09-26 09:57:48 +02001086 send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
1087 ssrc);
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001088}
1089
asapersson35151f32016-05-02 23:44:01 -07001090void RTPSender::UpdateOnSendPacket(int packet_id,
1091 int64_t capture_time_ms,
1092 uint32_t ssrc) {
1093 if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
1094 return;
1095
1096 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
1097}
1098
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001099void RTPSender::ProcessBitrate() {
sprangcd349d92016-07-13 09:11:28 -07001100 if (!bitrate_callback_)
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001101 return;
sprangcd349d92016-07-13 09:11:28 -07001102 int64_t now_ms = clock_->TimeInMilliseconds();
1103 uint32_t ssrc;
1104 {
1105 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001106 if (!ssrc_)
1107 return;
1108 ssrc = *ssrc_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001109 }
sprangcd349d92016-07-13 09:11:28 -07001110
1111 rtc::CritScope lock(&statistics_crit_);
1112 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0),
1113 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +00001114}
1115
isheriff6b4b5f32016-06-08 00:24:21 -07001116size_t RTPSender::RtpHeaderLength() const {
tommiae695e92016-02-02 08:31:45 -08001117 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001118 size_t rtp_header_length = kRtpHeaderLength;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001119 rtp_header_length += sizeof(uint32_t) * csrcs_.size();
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +01001120 rtp_header_length += rtp_header_extension_map_.GetTotalLengthInBytes(
1121 kFecOrPaddingExtensionSizes);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001122 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +00001123}
1124
mflodmanfcf54bd2015-04-14 21:28:08 +02001125uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
tommiae695e92016-02-02 08:31:45 -08001126 rtc::CritScope lock(&send_critsect_);
mflodmanfcf54bd2015-04-14 21:28:08 +02001127 uint16_t first_allocated_sequence_number = sequence_number_;
1128 sequence_number_ += packets_to_send;
1129 return first_allocated_sequence_number;
niklase@google.com470e71d2011-07-07 08:21:25 +00001130}
1131
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001132void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
1133 StreamDataCounters* rtx_stats) const {
danilchap7c9426c2016-04-14 03:05:31 -07001134 rtc::CritScope lock(&statistics_crit_);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001135 *rtp_stats = rtp_stats_;
1136 *rtx_stats = rtx_rtp_stats_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001137}
1138
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001139std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
1140 rtc::CritScope lock(&send_critsect_);
1141 std::unique_ptr<RtpPacketToSend> packet(
nisse284542b2017-01-10 08:58:32 -08001142 new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_));
nisse7d59f6b2017-02-21 03:40:24 -08001143 RTC_DCHECK(ssrc_);
1144 packet->SetSsrc(*ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001145 packet->SetCsrcs(csrcs_);
1146 // Reserve extensions, if registered, RtpSender set in SendToNetwork.
1147 packet->ReserveExtension<AbsoluteSendTime>();
1148 packet->ReserveExtension<TransmissionOffset>();
1149 packet->ReserveExtension<TransportSequenceNumber>();
danilchap74110612016-10-02 10:54:29 -07001150 if (playout_delay_oracle_.send_playout_delay()) {
1151 packet->SetExtension<PlayoutDelayLimits>(
1152 playout_delay_oracle_.playout_delay());
1153 }
Steve Anton4af95842018-04-06 11:09:46 -07001154 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001155 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001156 packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001157 }
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001158 return packet;
1159}
1160
1161bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) {
1162 rtc::CritScope lock(&send_critsect_);
1163 if (!sending_media_)
1164 return false;
nisse7d59f6b2017-02-21 03:40:24 -08001165 RTC_DCHECK(packet->Ssrc() == ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001166 packet->SetSequenceNumber(sequence_number_++);
1167
1168 // Remember marker bit to determine if padding can be inserted with
1169 // sequence number following |packet|.
1170 last_packet_marker_bit_ = packet->Marker();
Danil Chapovalovb3179c72018-03-22 10:13:07 +01001171 // Remember payload type to use in the padding packet if rtx is disabled.
1172 last_payload_type_ = packet->PayloadType();
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001173 // Save timestamps to generate timestamp field and extensions for the padding.
1174 last_rtp_timestamp_ = packet->Timestamp();
1175 last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
1176 capture_time_ms_ = packet->capture_time_ms();
1177 return true;
1178}
1179
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001180bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet,
1181 int* packet_id) const {
1182 RTC_DCHECK(packet);
1183 RTC_DCHECK(packet_id);
tommiae695e92016-02-02 08:31:45 -08001184 rtc::CritScope lock(&send_critsect_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001185 if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId))
stefana23fc622016-07-28 07:56:38 -07001186 return false;
1187
asapersson35151f32016-05-02 23:44:01 -07001188 if (!transport_sequence_number_allocator_)
1189 return false;
1190
1191 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001192
1193 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
1194 return false;
1195
asapersson35151f32016-05-02 23:44:01 -07001196 return true;
sprang867fb522015-08-03 04:38:41 -07001197}
1198
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001199void RTPSender::SetSendingMediaStatus(bool enabled) {
tommiae695e92016-02-02 08:31:45 -08001200 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001201 sending_media_ = enabled;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001202}
1203
1204bool RTPSender::SendingMedia() const {
tommiae695e92016-02-02 08:31:45 -08001205 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001206 return sending_media_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001207}
1208
danilchap71fead22016-08-18 02:01:49 -07001209void RTPSender::SetTimestampOffset(uint32_t timestamp) {
tommiae695e92016-02-02 08:31:45 -08001210 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001211 timestamp_offset_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001212}
1213
danilchap71fead22016-08-18 02:01:49 -07001214uint32_t RTPSender::TimestampOffset() const {
tommiae695e92016-02-02 08:31:45 -08001215 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001216 return timestamp_offset_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001217}
1218
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001219void RTPSender::SetSSRC(uint32_t ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001220 // This is configured via the API.
tommiae695e92016-02-02 08:31:45 -08001221 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +00001222
nisse7d59f6b2017-02-21 03:40:24 -08001223 if (ssrc_ == ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001224 return; // Since it's same ssrc, don't reset anything.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001225 }
nisse7d59f6b2017-02-21 03:40:24 -08001226 ssrc_.emplace(ssrc);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001227 if (!sequence_number_forced_) {
danilchap47a740b2015-12-15 00:30:07 -08001228 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001229 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001230}
1231
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001232uint32_t RTPSender::SSRC() const {
tommiae695e92016-02-02 08:31:45 -08001233 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001234 RTC_DCHECK(ssrc_);
1235 return *ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001236}
1237
Steve Anton296a0ce2018-03-22 15:17:27 -07001238void RTPSender::SetMid(const std::string& mid) {
1239 // This is configured via the API.
1240 rtc::CritScope lock(&send_critsect_);
Steve Anton4af95842018-04-06 11:09:46 -07001241 mid_ = mid;
Steve Anton296a0ce2018-03-22 15:17:27 -07001242}
1243
Danil Chapovalovd264df52018-06-14 12:59:38 +02001244absl::optional<uint32_t> RTPSender::FlexfecSsrc() const {
brandtr9dfff292016-11-14 05:14:50 -08001245 if (video_) {
1246 return video_->FlexfecSsrc();
1247 }
Danil Chapovalovd264df52018-06-14 12:59:38 +02001248 return absl::nullopt;
brandtr9dfff292016-11-14 05:14:50 -08001249}
1250
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001251void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
spranga8ae6f22017-09-04 07:23:56 -07001252 RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
tommiae695e92016-02-02 08:31:45 -08001253 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001254 csrcs_ = csrcs;
niklase@google.com470e71d2011-07-07 08:21:25 +00001255}
1256
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001257void RTPSender::SetSequenceNumber(uint16_t seq) {
tommiae695e92016-02-02 08:31:45 -08001258 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001259 sequence_number_forced_ = true;
1260 sequence_number_ = seq;
niklase@google.com470e71d2011-07-07 08:21:25 +00001261}
1262
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001263uint16_t RTPSender::SequenceNumber() const {
tommiae695e92016-02-02 08:31:45 -08001264 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001265 return sequence_number_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001266}
1267
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001268// Audio.
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001269int32_t RTPSender::SendTelephoneEvent(uint8_t key,
1270 uint16_t time_ms,
1271 uint8_t level) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001272 if (!audio_configured_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001273 return -1;
1274 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001275 return audio_->SendTelephoneEvent(key, time_ms, level);
niklase@google.com470e71d2011-07-07 08:21:25 +00001276}
1277
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001278int32_t RTPSender::SetAudioLevel(uint8_t level_d_bov) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001279 return audio_->SetAudioLevel(level_d_bov);
niklase@google.com470e71d2011-07-07 08:21:25 +00001280}
1281
brandtrf1bb4762016-11-07 03:05:06 -08001282void RTPSender::SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type) {
henrikg91d6ede2015-09-17 00:24:34 -07001283 RTC_DCHECK(!audio_configured_);
brandtrf1bb4762016-11-07 03:05:06 -08001284 video_->SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
niklase@google.com470e71d2011-07-07 08:21:25 +00001285}
1286
brandtr1743a192016-11-07 03:36:05 -08001287bool RTPSender::SetFecParameters(const FecProtectionParams& delta_params,
1288 const FecProtectionParams& key_params) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001289 if (audio_configured_) {
brandtr1743a192016-11-07 03:36:05 -08001290 return false;
stefan@webrtc.orge0d6fa42012-03-20 22:10:56 +00001291 }
mflodmanfcf54bd2015-04-14 21:28:08 +02001292 video_->SetFecParameters(delta_params, key_params);
brandtr1743a192016-11-07 03:36:05 -08001293 return true;
marpan@google.com80c5d7a2011-07-15 21:32:40 +00001294}
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001295
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001296std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
1297 const RtpPacketToSend& packet) {
1298 // TODO(danilchap): Create rtx packet with extra capacity for SRTP
1299 // when transport interface would be updated to take buffer class.
1300 std::unique_ptr<RtpPacketToSend> rtx_packet(new RtpPacketToSend(
1301 &rtp_header_extension_map_, packet.size() + kRtxHeaderSize));
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001302 // Add original RTP header.
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001303 rtx_packet->CopyHeaderFrom(packet);
1304 {
1305 rtc::CritScope lock(&send_critsect_);
1306 if (!sending_media_)
1307 return nullptr;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001308
nisse7d59f6b2017-02-21 03:40:24 -08001309 RTC_DCHECK(ssrc_rtx_);
1310
brandtre6f98c72016-11-11 03:28:30 -08001311 // Replace payload type.
1312 auto kv = rtx_payload_type_map_.find(packet.PayloadType());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001313 if (kv == rtx_payload_type_map_.end())
brandtre6f98c72016-11-11 03:28:30 -08001314 return nullptr;
1315 rtx_packet->SetPayloadType(kv->second);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +00001316
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001317 // Replace sequence number.
1318 rtx_packet->SetSequenceNumber(sequence_number_rtx_++);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001319
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001320 // Replace SSRC.
nisse7d59f6b2017-02-21 03:40:24 -08001321 rtx_packet->SetSsrc(*ssrc_rtx_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001322
1323 // Possibly include the MID header extension.
Steve Anton4af95842018-04-06 11:09:46 -07001324 if (!mid_.empty()) {
Steve Anton296a0ce2018-03-22 15:17:27 -07001325 // This is a no-op if the MID header extension is not registered.
Steve Anton4af95842018-04-06 11:09:46 -07001326 rtx_packet->SetExtension<RtpMid>(mid_);
Steve Anton296a0ce2018-03-22 15:17:27 -07001327 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001328 }
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001329
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001330 uint8_t* rtx_payload =
1331 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize);
1332 RTC_DCHECK(rtx_payload);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001333 // Add OSN (original sequence number).
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001334 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber());
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001335
1336 // Add original payload data.
danilchap96c15872016-11-21 01:35:29 -08001337 auto payload = packet.payload();
1338 memcpy(rtx_payload + kRtxHeaderSize, payload.data(), payload.size());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001339
Dino Radaković1807d572018-02-22 14:18:06 +01001340 // Add original application data.
1341 rtx_packet->set_application_data(packet.application_data());
1342
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001343 return rtx_packet;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001344}
1345
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001346void RTPSender::RegisterRtpStatisticsCallback(
1347 StreamDataCountersCallback* callback) {
danilchap7c9426c2016-04-14 03:05:31 -07001348 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001349 rtp_stats_callback_ = callback;
1350}
1351
1352StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
danilchap7c9426c2016-04-14 03:05:31 -07001353 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001354 return rtp_stats_callback_;
1355}
1356
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001357uint32_t RTPSender::BitrateSent() const {
sprangcd349d92016-07-13 09:11:28 -07001358 rtc::CritScope cs(&statistics_crit_);
1359 return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001360}
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001361
1362void RTPSender::SetRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001363 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001364 sequence_number_ = rtp_state.sequence_number;
1365 sequence_number_forced_ = true;
danilchap71fead22016-08-18 02:01:49 -07001366 timestamp_offset_ = rtp_state.start_timestamp;
danilchape5b41412016-08-22 03:39:23 -07001367 last_rtp_timestamp_ = rtp_state.timestamp;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001368 capture_time_ms_ = rtp_state.capture_time_ms;
1369 last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001370 media_has_been_sent_ = rtp_state.media_has_been_sent;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001371}
1372
1373RtpState RTPSender::GetRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001374 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001375
1376 RtpState state;
1377 state.sequence_number = sequence_number_;
danilchap71fead22016-08-18 02:01:49 -07001378 state.start_timestamp = timestamp_offset_;
danilchape5b41412016-08-22 03:39:23 -07001379 state.timestamp = last_rtp_timestamp_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001380 state.capture_time_ms = capture_time_ms_;
1381 state.last_timestamp_time_ms = last_timestamp_time_ms_;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001382 state.media_has_been_sent = media_has_been_sent_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001383
1384 return state;
1385}
1386
1387void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001388 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001389 sequence_number_rtx_ = rtp_state.sequence_number;
1390}
1391
1392RtpState RTPSender::GetRtxRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001393 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001394
1395 RtpState state;
1396 state.sequence_number = sequence_number_rtx_;
danilchap71fead22016-08-18 02:01:49 -07001397 state.start_timestamp = timestamp_offset_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001398
1399 return state;
1400}
1401
philipel8aadd502017-02-23 02:56:13 -08001402void RTPSender::AddPacketToTransportFeedback(
1403 uint16_t packet_id,
1404 const RtpPacketToSend& packet,
1405 const PacedPacketInfo& pacing_info) {
michaelt668eb3b2016-11-29 02:24:18 -08001406 size_t packet_size = packet.payload_size() + packet.padding_size();
elad.alonc3dfff32017-01-26 02:46:55 -08001407 if (send_side_bwe_with_overhead_) {
nisse284542b2017-01-10 08:58:32 -08001408 packet_size = packet.size();
michaelt668eb3b2016-11-29 02:24:18 -08001409 }
1410
michaelt4da30442016-11-17 01:38:43 -08001411 if (transport_feedback_observer_) {
elad.alond12a8e12017-03-23 11:04:48 -07001412 transport_feedback_observer_->AddPacket(SSRC(), packet_id, packet_size,
philipel8aadd502017-02-23 02:56:13 -08001413 pacing_info);
michaelt4da30442016-11-17 01:38:43 -08001414 }
1415}
1416
1417void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
1418 if (!overhead_observer_)
1419 return;
nisse284542b2017-01-10 08:58:32 -08001420 size_t overhead_bytes_per_packet;
michaelt4da30442016-11-17 01:38:43 -08001421 {
1422 rtc::CritScope lock(&send_critsect_);
1423 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
1424 return;
1425 }
1426 rtp_overhead_bytes_per_packet_ = packet.headers_size();
nisse284542b2017-01-10 08:58:32 -08001427 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
michaelt4da30442016-11-17 01:38:43 -08001428 }
1429 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
1430}
1431
sprang168794c2017-07-06 04:38:06 -07001432int64_t RTPSender::LastTimestampTimeMs() const {
1433 rtc::CritScope lock(&send_critsect_);
1434 return last_timestamp_time_ms_;
1435}
1436
1437void RTPSender::SendKeepAlive(uint8_t payload_type) {
1438 std::unique_ptr<RtpPacketToSend> packet = AllocatePacket();
1439 packet->SetPayloadType(payload_type);
1440 // Set marker bit and timestamps in the same manner as plain padding packets.
1441 packet->SetMarker(false);
1442 {
1443 rtc::CritScope lock(&send_critsect_);
1444 packet->SetTimestamp(last_rtp_timestamp_);
1445 packet->set_capture_time_ms(capture_time_ms_);
1446 }
1447 AssignSequenceNumber(packet.get());
1448 SendToNetwork(std::move(packet), StorageType::kDontRetransmit,
1449 RtpPacketSender::Priority::kLowPriority);
1450}
1451
Erik Språng8b101922018-01-18 11:58:05 -08001452void RTPSender::SetRtt(int64_t rtt_ms) {
1453 packet_history_.SetRtt(rtt_ms);
1454 flexfec_packet_history_.SetRtt(rtt_ms);
1455}
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001456} // namespace webrtc