blob: e88305a41e4c8408e0205dc89c89b21d06fd08c2 [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>
Shao Changbine62202f2015-04-21 20:24:50 +080014#include <utility>
niklase@google.com470e71d2011-07-07 08:21:25 +000015
Elad Alon4a87e1c2017-10-03 16:11:34 +020016#include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020017#include "logging/rtc_event_log/rtc_event_log.h"
18#include "modules/remote_bitrate_estimator/test/bwe_test_logging.h"
19#include "modules/rtp_rtcp/include/rtp_cvo.h"
20#include "modules/rtp_rtcp/source/byte_io.h"
21#include "modules/rtp_rtcp/source/playout_delay_oracle.h"
22#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
23#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
24#include "modules/rtp_rtcp/source/rtp_sender_audio.h"
25#include "modules/rtp_rtcp/source/rtp_sender_video.h"
26#include "modules/rtp_rtcp/source/time_util.h"
27#include "rtc_base/arraysize.h"
28#include "rtc_base/checks.h"
29#include "rtc_base/logging.h"
Karl Wiberge40468b2017-11-22 10:42:26 +010030#include "rtc_base/numerics/safe_minmax.h"
Elad Alon4a87e1c2017-10-03 16:11:34 +020031#include "rtc_base/ptr_util.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020032#include "rtc_base/rate_limiter.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020033#include "rtc_base/timeutils.h"
34#include "rtc_base/trace_event.h"
35#include "system_wrappers/include/field_trial.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000036
37namespace webrtc {
niklase@google.com470e71d2011-07-07 08:21:25 +000038
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000039namespace {
Danil Chapovalov31e4e802016-08-03 18:27:40 +020040// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
41constexpr size_t kMaxPaddingLength = 224;
stefan53b6cc32017-02-03 08:13:57 -080042constexpr size_t kMinAudioPaddingLength = 50;
Danil Chapovalov31e4e802016-08-03 18:27:40 +020043constexpr int kSendSideDelayWindowMs = 1000;
44constexpr size_t kRtpHeaderLength = 12;
45constexpr uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1.
46constexpr uint32_t kTimestampTicksPerMs = 90;
47constexpr int kBitrateStatisticsWindowMs = 1000;
guoweis@webrtc.org45362892015-03-04 22:55:15 +000048
brandtr9dfff292016-11-14 05:14:50 -080049constexpr size_t kMinFlexfecPacketsToStoreForPacing = 50;
50
erikvarga27883732017-05-17 05:08:38 -070051template <typename Extension>
52constexpr RtpExtensionSize CreateExtensionSize() {
53 return {Extension::kId, Extension::kValueSizeBytes};
54}
55
56// Size info for header extensions that might be used in padding or FEC packets.
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010057constexpr RtpExtensionSize kFecOrPaddingExtensionSizes[] = {
erikvarga27883732017-05-17 05:08:38 -070058 CreateExtensionSize<AbsoluteSendTime>(),
59 CreateExtensionSize<TransmissionOffset>(),
60 CreateExtensionSize<TransportSequenceNumber>(),
61 CreateExtensionSize<PlayoutDelayLimits>(),
62};
63
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +010064// Size info for header extensions that might be used in video packets.
65constexpr RtpExtensionSize kVideoExtensionSizes[] = {
66 CreateExtensionSize<AbsoluteSendTime>(),
67 CreateExtensionSize<TransmissionOffset>(),
68 CreateExtensionSize<TransportSequenceNumber>(),
69 CreateExtensionSize<PlayoutDelayLimits>(),
70 CreateExtensionSize<VideoOrientation>(),
71 CreateExtensionSize<VideoContentTypeExtension>(),
72 CreateExtensionSize<VideoTimingExtension>(),
73};
74
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +000075const char* FrameTypeToString(FrameType frame_type) {
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000076 switch (frame_type) {
pbos22993e12015-10-19 02:39:06 -070077 case kEmptyFrame:
78 return "empty";
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000079 case kAudioFrameSpeech: return "audio_speech";
80 case kAudioFrameCN: return "audio_cn";
81 case kVideoFrameKey: return "video_key";
82 case kVideoFrameDelta: return "video_delta";
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000083 }
84 return "";
85}
86
Danil Chapovalov31e4e802016-08-03 18:27:40 +020087void CountPacket(RtpPacketCounter* counter, const RtpPacketToSend& packet) {
88 ++counter->packets;
89 counter->header_bytes += packet.headers_size();
90 counter->padding_bytes += packet.padding_size();
91 counter->payload_bytes += packet.payload_size();
Stefan Holmer0a87ffc2015-10-21 13:41:48 +020092}
Danil Chapovalov31e4e802016-08-03 18:27:40 +020093
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000094} // namespace
95
sprangebbf8a82015-09-21 15:11:14 -070096RTPSender::RTPSender(
97 bool audio,
98 Clock* clock,
99 Transport* transport,
sprangebbf8a82015-09-21 15:11:14 -0700100 RtpPacketSender* paced_sender,
brandtrdbdb3f12016-11-10 05:04:48 -0800101 FlexfecSender* flexfec_sender,
sprangebbf8a82015-09-21 15:11:14 -0700102 TransportSequenceNumberAllocator* sequence_number_allocator,
103 TransportFeedbackObserver* transport_feedback_observer,
104 BitrateStatisticsObserver* bitrate_callback,
105 FrameCountObserver* frame_count_observer,
terelius429c3452016-01-21 05:42:04 -0800106 SendSideDelayObserver* send_side_delay_observer,
asapersson35151f32016-05-02 23:44:01 -0700107 RtcEventLog* event_log,
sprangcd349d92016-07-13 09:11:28 -0700108 SendPacketObserver* send_packet_observer,
michaelt4da30442016-11-17 01:38:43 -0800109 RateLimiter* retransmission_rate_limiter,
Erik Språng7b52f102018-02-07 14:37:37 +0100110 OverheadObserver* overhead_observer,
111 bool populate_network2_timestamp)
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000112 : clock_(clock),
Niels Möllerd28db7f2016-05-10 16:31:47 +0200113 // TODO(holmer): Remove this conversion?
114 clock_delta_ms_(clock_->TimeInMilliseconds() - rtc::TimeMillis()),
danilchap47a740b2015-12-15 00:30:07 -0800115 random_(clock_->TimeInMicroseconds()),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000116 audio_configured_(audio),
solenberg6021fe22016-03-15 11:41:53 -0700117 audio_(audio ? new RTPSenderAudio(clock, this) : nullptr),
brandtrdbdb3f12016-11-10 05:04:48 -0800118 video_(audio ? nullptr : new RTPSenderVideo(clock, this, flexfec_sender)),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000119 paced_sender_(paced_sender),
sprangebbf8a82015-09-21 15:11:14 -0700120 transport_sequence_number_allocator_(sequence_number_allocator),
sprang5e023eb2015-09-14 06:42:43 -0700121 transport_feedback_observer_(transport_feedback_observer),
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000122 last_capture_time_ms_sent_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000123 transport_(transport),
nisse284542b2017-01-10 08:58:32 -0800124 sending_media_(true), // Default to sending media.
125 max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000126 payload_type_(-1),
127 payload_type_map_(),
128 rtp_header_extension_map_(),
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000129 packet_history_(clock),
brandtr9dfff292016-11-14 05:14:50 -0800130 flexfec_packet_history_(clock),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000131 // Statistics
sprangcd349d92016-07-13 09:11:28 -0700132 rtp_stats_callback_(nullptr),
133 total_bitrate_sent_(kBitrateStatisticsWindowMs,
134 RateStatistics::kBpsScale),
135 nack_bitrate_sent_(kBitrateStatisticsWindowMs, RateStatistics::kBpsScale),
andresp@webrtc.org8f151212014-07-10 09:39:23 +0000136 frame_count_observer_(frame_count_observer),
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000137 send_side_delay_observer_(send_side_delay_observer),
terelius429c3452016-01-21 05:42:04 -0800138 event_log_(event_log),
asapersson35151f32016-05-02 23:44:01 -0700139 send_packet_observer_(send_packet_observer),
sprangcd349d92016-07-13 09:11:28 -0700140 bitrate_callback_(bitrate_callback),
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000141 // RTP variables
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000142 remote_ssrc_(0),
143 sequence_number_forced_(false),
danilchape5b41412016-08-22 03:39:23 -0700144 last_rtp_timestamp_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000145 capture_time_ms_(0),
146 last_timestamp_time_ms_(0),
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000147 media_has_been_sent_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000148 last_packet_marker_bit_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000149 csrcs_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000150 rtx_(kRtxOff),
michaelt4da30442016-11-17 01:38:43 -0800151 rtp_overhead_bytes_per_packet_(0),
152 retransmission_rate_limiter_(retransmission_rate_limiter),
elad.alonc3dfff32017-01-26 02:46:55 -0800153 overhead_observer_(overhead_observer),
Erik Språng7b52f102018-02-07 14:37:37 +0100154 populate_network2_timestamp_(populate_network2_timestamp),
elad.alonc3dfff32017-01-26 02:46:55 -0800155 send_side_bwe_with_overhead_(
sprangc1b57a12017-02-28 08:50:47 -0800156 webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")) {
danilchap71fead22016-08-18 02:01:49 -0700157 // This random initialization is not intended to be cryptographic strong.
158 timestamp_offset_ = random_.Rand<uint32_t>();
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000159 // Random start, 16 bits. Can't be 0.
danilchap47a740b2015-12-15 00:30:07 -0800160 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
161 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
brandtr9dfff292016-11-14 05:14:50 -0800162
163 // Store FlexFEC packets in the packet history data structure, so they can
164 // be found when paced.
165 if (flexfec_sender) {
166 flexfec_packet_history_.SetStorePacketsStatus(
Erik Språnga12b1d62018-03-14 12:39:24 +0100167 RtpPacketHistory::StorageMode::kStore,
168 kMinFlexfecPacketsToStoreForPacing);
brandtr9dfff292016-11-14 05:14:50 -0800169 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000170}
171
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000172RTPSender::~RTPSender() {
tommiae695e92016-02-02 08:31:45 -0800173 // TODO(tommi): Use a thread checker to ensure the object is created and
174 // deleted on the same thread. At the moment this isn't possible due to
175 // voe::ChannelOwner in voice engine. To reproduce, run:
176 // voe_auto_test --automated --gtest_filter=*MixManyChannelsForStressOpus
177
178 // TODO(tommi,holmer): We don't grab locks in the dtor before accessing member
179 // variables but we grab them in all other methods. (what's the design?)
180 // Start documenting what thread we're on in what method so that it's easier
181 // to understand performance attributes and possibly remove locks.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000182 while (!payload_type_map_.empty()) {
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000183 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000184 payload_type_map_.begin();
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000185 delete it->second;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000186 payload_type_map_.erase(it);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000187 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000188}
niklase@google.com470e71d2011-07-07 08:21:25 +0000189
erikvarga27883732017-05-17 05:08:38 -0700190rtc::ArrayView<const RtpExtensionSize> RTPSender::FecExtensionSizes() {
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +0100191 return rtc::MakeArrayView(kFecOrPaddingExtensionSizes,
192 arraysize(kFecOrPaddingExtensionSizes));
193}
194
195rtc::ArrayView<const RtpExtensionSize> RTPSender::VideoExtensionSizes() {
196 return rtc::MakeArrayView(kVideoExtensionSizes,
197 arraysize(kVideoExtensionSizes));
erikvarga27883732017-05-17 05:08:38 -0700198}
199
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000200uint16_t RTPSender::ActualSendBitrateKbit() const {
sprangcd349d92016-07-13 09:11:28 -0700201 rtc::CritScope cs(&statistics_crit_);
202 return static_cast<uint16_t>(
203 total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0) /
204 1000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000205}
206
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000207uint32_t RTPSender::VideoBitrateSent() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000208 if (video_) {
209 return video_->VideoBitrateSent();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000210 }
211 return 0;
stefan@webrtc.orgfbea4e52011-10-27 16:08:29 +0000212}
213
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000214uint32_t RTPSender::FecOverheadRate() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000215 if (video_) {
216 return video_->FecOverheadRate();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000217 }
218 return 0;
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000219}
220
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000221uint32_t RTPSender::NackOverheadRate() const {
sprangcd349d92016-07-13 09:11:28 -0700222 rtc::CritScope cs(&statistics_crit_);
223 return nack_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000224}
225
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000226int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
227 uint8_t id) {
tommiae695e92016-02-02 08:31:45 -0800228 rtc::CritScope lock(&send_critsect_);
danilchapfab482b2017-04-04 02:33:48 -0700229 return rtp_header_extension_map_.RegisterByType(id, type) ? 0 : -1;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000230}
231
stefan53b6cc32017-02-03 08:13:57 -0800232bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) const {
tommiae695e92016-02-02 08:31:45 -0800233 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000234 return rtp_header_extension_map_.IsRegistered(type);
235}
236
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000237int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800238 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000239 return rtp_header_extension_map_.Deregister(type);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000240}
241
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000242int32_t RTPSender::RegisterPayload(
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000243 const char payload_name[RTP_PAYLOAD_NAME_SIZE],
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000244 int8_t payload_number,
245 uint32_t frequency,
Peter Kasting69558702016-01-12 16:26:35 -0800246 size_t channels,
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000247 uint32_t rate) {
Peter Boström8b79b072016-02-26 16:31:37 +0100248 RTC_DCHECK_LT(strlen(payload_name), RTP_PAYLOAD_NAME_SIZE);
tommiae695e92016-02-02 08:31:45 -0800249 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000250
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000251 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000252 payload_type_map_.find(payload_number);
niklase@google.com470e71d2011-07-07 08:21:25 +0000253
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000254 if (payload_type_map_.end() != it) {
255 // We already use this payload type.
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000256 RtpUtility::Payload* payload = it->second;
spranga8ae6f22017-09-04 07:23:56 -0700257 RTC_DCHECK(payload);
niklase@google.com470e71d2011-07-07 08:21:25 +0000258
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000259 // Check if it's the same as we already have.
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000260 if (RtpUtility::StringCompare(
261 payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1)) {
Karl Wibergc856dc22017-09-28 20:13:59 +0200262 if (audio_configured_ && payload->typeSpecific.is_audio()) {
263 auto& p = payload->typeSpecific.audio_payload();
Karl Wibergc62f6c72017-10-04 12:38:53 +0200264 if (rtc::SafeEq(p.format.clockrate_hz, frequency) &&
Karl Wibergc856dc22017-09-28 20:13:59 +0200265 (p.rate == rate || p.rate == 0 || rate == 0)) {
266 p.rate = rate;
267 // Ensure that we update the rate if new or old is zero.
268 return 0;
269 }
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000270 }
Karl Wibergc856dc22017-09-28 20:13:59 +0200271 if (!audio_configured_ && !payload->typeSpecific.is_audio()) {
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000272 return 0;
273 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000274 }
275 return -1;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000276 }
mflodmanfcf54bd2015-04-14 21:28:08 +0200277 int32_t ret_val = 0;
danilchap6db6cdc2015-12-15 02:54:47 -0800278 RtpUtility::Payload* payload = nullptr;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000279 if (audio_configured_) {
mflodmanfcf54bd2015-04-14 21:28:08 +0200280 // TODO(mflodman): Change to CreateAudioPayload and make static.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000281 ret_val = audio_->RegisterAudioPayload(payload_name, payload_number,
danilchap6db6cdc2015-12-15 02:54:47 -0800282 frequency, channels, rate, &payload);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000283 } else {
Peter Boström9d0c4322016-02-16 17:59:27 +0100284 payload = video_->CreateVideoPayload(payload_name, payload_number);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000285 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000286 if (payload) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000287 payload_type_map_[payload_number] = payload;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000288 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000289 return ret_val;
niklase@google.com470e71d2011-07-07 08:21:25 +0000290}
291
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000292int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) {
tommiae695e92016-02-02 08:31:45 -0800293 rtc::CritScope lock(&send_critsect_);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000294
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000295 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000296 payload_type_map_.find(payload_type);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000297
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000298 if (payload_type_map_.end() == it) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000299 return -1;
300 }
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000301 RtpUtility::Payload* payload = it->second;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000302 delete payload;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000303 payload_type_map_.erase(it);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000304 return 0;
305}
niklase@google.com470e71d2011-07-07 08:21:25 +0000306
nisse40ba3ad2017-03-17 07:04:00 -0700307// TODO(nisse): Delete this method, only used internally and by test code.
andresp@webrtc.orgc3c29112014-08-27 09:39:43 +0000308void RTPSender::SetSendPayloadType(int8_t payload_type) {
tommiae695e92016-02-02 08:31:45 -0800309 rtc::CritScope lock(&send_critsect_);
andresp@webrtc.orgc3c29112014-08-27 09:39:43 +0000310 payload_type_ = payload_type;
311}
312
nisse284542b2017-01-10 08:58:32 -0800313void RTPSender::SetMaxRtpPacketSize(size_t max_packet_size) {
kwibergee89e782017-08-09 17:22:01 -0700314 RTC_DCHECK_GE(max_packet_size, 100);
315 RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
tommiae695e92016-02-02 08:31:45 -0800316 rtc::CritScope lock(&send_critsect_);
nisse284542b2017-01-10 08:58:32 -0800317 max_packet_size_ = max_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25 +0000318}
319
nisse284542b2017-01-10 08:58:32 -0800320size_t RTPSender::MaxRtpPacketSize() const {
321 return max_packet_size_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000322}
323
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000324void RTPSender::SetRtxStatus(int mode) {
tommiae695e92016-02-02 08:31:45 -0800325 rtc::CritScope lock(&send_critsect_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000326 rtx_ = mode;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000327}
328
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000329int RTPSender::RtxStatus() const {
tommiae695e92016-02-02 08:31:45 -0800330 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000331 return rtx_;
332}
333
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000334void RTPSender::SetRtxSsrc(uint32_t ssrc) {
tommiae695e92016-02-02 08:31:45 -0800335 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800336 ssrc_rtx_.emplace(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000337}
338
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000339uint32_t RTPSender::RtxSsrc() const {
tommiae695e92016-02-02 08:31:45 -0800340 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800341 RTC_DCHECK(ssrc_rtx_);
342 return *ssrc_rtx_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000343}
344
Shao Changbine62202f2015-04-21 20:24:50 +0800345void RTPSender::SetRtxPayloadType(int payload_type,
346 int associated_payload_type) {
tommiae695e92016-02-02 08:31:45 -0800347 rtc::CritScope lock(&send_critsect_);
henrikg91d6ede2015-09-17 00:24:34 -0700348 RTC_DCHECK_LE(payload_type, 127);
349 RTC_DCHECK_LE(associated_payload_type, 127);
Shao Changbine62202f2015-04-21 20:24:50 +0800350 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100351 RTC_LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type << ".";
Shao Changbine62202f2015-04-21 20:24:50 +0800352 return;
353 }
354
355 rtx_payload_type_map_[associated_payload_type] = payload_type;
Ã…sa Persson6ae25722015-04-13 17:48:08 +0200356}
357
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000358int32_t RTPSender::CheckPayloadType(int8_t payload_type,
359 RtpVideoCodecTypes* video_type) {
tommiae695e92016-02-02 08:31:45 -0800360 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000361
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000362 if (payload_type < 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100363 RTC_LOG(LS_ERROR) << "Invalid payload_type " << payload_type << ".";
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000364 return -1;
365 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000366 if (payload_type_ == payload_type) {
367 if (!audio_configured_) {
368 *video_type = video_->VideoCodecType();
niklase@google.com470e71d2011-07-07 08:21:25 +0000369 }
370 return 0;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000371 }
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000372 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000373 payload_type_map_.find(payload_type);
374 if (it == payload_type_map_.end()) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100375 RTC_LOG(LS_WARNING) << "Payload type " << static_cast<int>(payload_type)
376 << " not registered.";
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000377 return -1;
378 }
andresp@webrtc.orgc3c29112014-08-27 09:39:43 +0000379 SetSendPayloadType(payload_type);
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000380 RtpUtility::Payload* payload = it->second;
spranga8ae6f22017-09-04 07:23:56 -0700381 RTC_DCHECK(payload);
Karl Wibergc856dc22017-09-28 20:13:59 +0200382 if (payload->typeSpecific.is_video() && !audio_configured_) {
383 video_->SetVideoCodecType(
384 payload->typeSpecific.video_payload().videoCodecType);
385 *video_type = payload->typeSpecific.video_payload().videoCodecType;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000386 }
387 return 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000388}
389
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700390bool RTPSender::SendOutgoingData(FrameType frame_type,
391 int8_t payload_type,
392 uint32_t capture_timestamp,
393 int64_t capture_time_ms,
394 const uint8_t* payload_data,
395 size_t payload_size,
396 const RTPFragmentationHeader* fragmentation,
397 const RTPVideoHeader* rtp_header,
spranga8ae6f22017-09-04 07:23:56 -0700398 uint32_t* transport_frame_id_out,
399 int64_t expected_retransmission_time_ms) {
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000400 uint32_t ssrc;
isheriff6b4b5f32016-06-08 00:24:21 -0700401 uint16_t sequence_number;
danilchape5b41412016-08-22 03:39:23 -0700402 uint32_t rtp_timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000403 {
404 // Drop this packet if we're not sending media packets.
tommiae695e92016-02-02 08:31:45 -0800405 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800406 RTC_DCHECK(ssrc_);
407
408 ssrc = *ssrc_;
isheriff6b4b5f32016-06-08 00:24:21 -0700409 sequence_number = sequence_number_;
danilchape5b41412016-08-22 03:39:23 -0700410 rtp_timestamp = timestamp_offset_ + capture_timestamp;
411 if (transport_frame_id_out)
412 *transport_frame_id_out = rtp_timestamp;
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700413 if (!sending_media_)
414 return true;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000415 }
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000416 RtpVideoCodecTypes video_type = kRtpVideoGeneric;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000417 if (CheckPayloadType(payload_type, &video_type) != 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100418 RTC_LOG(LS_ERROR) << "Don't send data with unknown payload type: "
419 << static_cast<int>(payload_type) << ".";
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700420 return false;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000421 }
422
spranga8ae6f22017-09-04 07:23:56 -0700423 switch (frame_type) {
424 case kAudioFrameSpeech:
425 case kAudioFrameCN:
426 RTC_CHECK(audio_configured_);
427 break;
428 case kVideoFrameKey:
429 case kVideoFrameDelta:
430 RTC_CHECK(!audio_configured_);
431 break;
432 case kEmptyFrame:
433 break;
434 }
435
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700436 bool result;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000437 if (audio_configured_) {
danilchape5b41412016-08-22 03:39:23 -0700438 TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", rtp_timestamp, "Send", "type",
439 FrameTypeToString(frame_type));
Niels Möller90397d92017-10-27 10:51:20 +0200440 // The only known way to produce of RTPFragmentationHeader for audio is
441 // to use the AudioCodingModule directly.
442 RTC_DCHECK(fragmentation == nullptr);
danilchape5b41412016-08-22 03:39:23 -0700443 result = audio_->SendAudio(frame_type, payload_type, rtp_timestamp,
Niels Möller90397d92017-10-27 10:51:20 +0200444 payload_data, payload_size);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000445 } else {
hclam@chromium.org1a7b9b92013-07-08 21:31:18 +0000446 TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms,
447 "Send", "type", FrameTypeToString(frame_type));
pbos22993e12015-10-19 02:39:06 -0700448 if (frame_type == kEmptyFrame)
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700449 return true;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000450
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700451 if (rtp_header) {
452 playout_delay_oracle_.UpdateRequest(ssrc, rtp_header->playout_delay,
isheriff6b4b5f32016-06-08 00:24:21 -0700453 sequence_number);
454 }
455
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700456 result = video_->SendVideo(video_type, frame_type, payload_type,
danilchape5b41412016-08-22 03:39:23 -0700457 rtp_timestamp, capture_time_ms, payload_data,
spranga8ae6f22017-09-04 07:23:56 -0700458 payload_size, fragmentation, rtp_header,
459 expected_retransmission_time_ms);
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700460 }
461
danilchap7c9426c2016-04-14 03:05:31 -0700462 rtc::CritScope cs(&statistics_crit_);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000463 // Note: This is currently only counting for video.
464 if (frame_type == kVideoFrameKey) {
465 ++frame_counts_.key_frames;
466 } else if (frame_type == kVideoFrameDelta) {
467 ++frame_counts_.delta_frames;
468 }
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000469 if (frame_count_observer_) {
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000470 frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000471 }
472
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700473 return result;
niklase@google.com470e71d2011-07-07 08:21:25 +0000474}
475
philipela1ed0b32016-06-01 06:31:17 -0700476size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
philipel8aadd502017-02-23 02:56:13 -0800477 const PacedPacketInfo& pacing_info) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000478 {
tommiae695e92016-02-02 08:31:45 -0800479 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100480 if (!sending_media_)
481 return 0;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000482 if ((rtx_ & kRtxRedundantPayloads) == 0)
483 return 0;
484 }
485
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000486 int bytes_left = static_cast<int>(bytes_to_send);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000487 while (bytes_left > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200488 std::unique_ptr<RtpPacketToSend> packet =
489 packet_history_.GetBestFittingPacket(bytes_left);
490 if (!packet)
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000491 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200492 size_t payload_size = packet->payload_size();
philipel8aadd502017-02-23 02:56:13 -0800493 if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000494 break;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200495 bytes_left -= payload_size;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000496 }
497 return bytes_to_send - bytes_left;
498}
499
philipel8aadd502017-02-23 02:56:13 -0800500size_t RTPSender::SendPadData(size_t bytes,
501 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800502 size_t padding_bytes_in_packet;
erikvarga76a55932017-05-17 07:50:17 -0700503 size_t max_payload_size = max_packet_size_ - RtpHeaderLength();
erikvarga27883732017-05-17 05:08:38 -0700504
stefan53b6cc32017-02-03 08:13:57 -0800505 if (audio_configured_) {
506 // Allow smaller padding packets for audio.
kwiberg07038562017-06-12 11:40:47 -0700507 padding_bytes_in_packet = rtc::SafeClamp<size_t>(
508 bytes, kMinAudioPaddingLength,
509 rtc::SafeMin(max_payload_size, kMaxPaddingLength));
stefan53b6cc32017-02-03 08:13:57 -0800510 } else {
511 // Always send full padding packets. This is accounted for by the
512 // RtpPacketSender, which will make sure we don't send too much padding even
513 // if a single packet is larger than requested.
514 // We do this to avoid frequently sending small packets on higher bitrates.
kwiberg07038562017-06-12 11:40:47 -0700515 padding_bytes_in_packet =
516 rtc::SafeMin<size_t>(max_payload_size, kMaxPaddingLength);
stefan53b6cc32017-02-03 08:13:57 -0800517 }
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000518 size_t bytes_sent = 0;
danilchap90069872016-12-14 06:16:33 -0800519 while (bytes_sent < bytes) {
520 int64_t now_ms = clock_->TimeInMilliseconds();
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000521 uint32_t ssrc;
danilchap90069872016-12-14 06:16:33 -0800522 uint32_t timestamp;
523 int64_t capture_time_ms;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000524 uint16_t sequence_number;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000525 int payload_type;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000526 bool over_rtx;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000527 {
tommiae695e92016-02-02 08:31:45 -0800528 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100529 if (!sending_media_)
danilchap90069872016-12-14 06:16:33 -0800530 break;
531 timestamp = last_rtp_timestamp_;
532 capture_time_ms = capture_time_ms_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000533 if (rtx_ == kRtxOff) {
stefan53b6cc32017-02-03 08:13:57 -0800534 if (payload_type_ == -1)
stefane35f89a2017-02-01 09:06:25 -0800535 break;
stefan53b6cc32017-02-03 08:13:57 -0800536 // Without RTX we can't send padding in the middle of frames.
537 // For audio marker bits doesn't mark the end of a frame and frames
538 // are usually a single packet, so for now we don't apply this rule
539 // for audio.
540 if (!audio_configured_ && !last_packet_marker_bit_) {
541 break;
542 }
nisse7d59f6b2017-02-21 03:40:24 -0800543 if (!ssrc_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100544 RTC_LOG(LS_ERROR) << "SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800545 return 0;
546 }
547
548 RTC_DCHECK(ssrc_);
549 ssrc = *ssrc_;
550
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000551 sequence_number = sequence_number_;
552 ++sequence_number_;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000553 payload_type = payload_type_;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000554 over_rtx = false;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000555 } else {
Stefan Holmerf5dca482016-01-27 12:58:51 +0100556 // Without abs-send-time or transport sequence number a media packet
557 // must be sent before padding so that the timestamps used for
558 // estimation are correct.
559 if (!media_has_been_sent_ &&
danilchap90069872016-12-14 06:16:33 -0800560 !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) ||
561 (rtp_header_extension_map_.IsRegistered(
562 TransportSequenceNumber::kId) &&
563 transport_sequence_number_allocator_))) {
564 break;
Stefan Holmerf5dca482016-01-27 12:58:51 +0100565 }
Stefan Holmer586b19b2015-09-18 11:14:31 +0200566 // Only change change the timestamp of padding packets sent over RTX.
567 // Padding only packets over RTP has to be sent as part of a media
568 // frame (and therefore the same timestamp).
569 if (last_timestamp_time_ms_ > 0) {
570 timestamp +=
danilchap90069872016-12-14 06:16:33 -0800571 (now_ms - last_timestamp_time_ms_) * kTimestampTicksPerMs;
572 capture_time_ms += (now_ms - last_timestamp_time_ms_);
Stefan Holmer586b19b2015-09-18 11:14:31 +0200573 }
nisse7d59f6b2017-02-21 03:40:24 -0800574 if (!ssrc_rtx_) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100575 RTC_LOG(LS_ERROR) << "RTX SSRC unset.";
nisse7d59f6b2017-02-21 03:40:24 -0800576 return 0;
577 }
578 RTC_DCHECK(ssrc_rtx_);
579 ssrc = *ssrc_rtx_;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000580 sequence_number = sequence_number_rtx_;
581 ++sequence_number_rtx_;
Stefan Holmer10880012016-02-03 13:29:59 +0100582 payload_type = rtx_payload_type_map_.begin()->second;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000583 over_rtx = true;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000584 }
585 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000586
danilchap90069872016-12-14 06:16:33 -0800587 RtpPacketToSend padding_packet(&rtp_header_extension_map_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200588 padding_packet.SetPayloadType(payload_type);
589 padding_packet.SetMarker(false);
590 padding_packet.SetSequenceNumber(sequence_number);
591 padding_packet.SetTimestamp(timestamp);
592 padding_packet.SetSsrc(ssrc);
593
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000594 if (capture_time_ms > 0) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200595 padding_packet.SetExtension<TransmissionOffset>(
danilchap90069872016-12-14 06:16:33 -0800596 (now_ms - capture_time_ms) * kTimestampTicksPerMs);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000597 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200598 padding_packet.SetExtension<AbsoluteSendTime>(
599 AbsoluteSendTime::MsTo24Bits(now_ms));
stefan1d8a5062015-10-02 03:39:33 -0700600 PacketOptions options;
michaelt4da30442016-11-17 01:38:43 -0800601 bool has_transport_seq_num =
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200602 UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200603 padding_packet.SetPadding(padding_bytes_in_packet, &random_);
604
michaelt4da30442016-11-17 01:38:43 -0800605 if (has_transport_seq_num) {
606 AddPacketToTransportFeedback(options.packet_id, padding_packet,
philipel8aadd502017-02-23 02:56:13 -0800607 pacing_info);
michaelt4da30442016-11-17 01:38:43 -0800608 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200609
philipel32d00102017-02-27 02:18:46 -0800610 if (!SendPacketToNetwork(padding_packet, options, pacing_info))
stefanf116bd02015-10-27 08:29:42 -0700611 break;
612
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000613 bytes_sent += padding_bytes_in_packet;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200614 UpdateRtpStats(padding_packet, over_rtx, false);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000615 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000616
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000617 return bytes_sent;
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000618}
619
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000620void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100621 RtpPacketHistory::StorageMode mode =
622 enable ? RtpPacketHistory::StorageMode::kStore
623 : RtpPacketHistory::StorageMode::kDisabled;
624 packet_history_.SetStorePacketsStatus(mode, number_to_store);
niklase@google.com470e71d2011-07-07 08:21:25 +0000625}
626
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000627bool RTPSender::StorePackets() const {
Erik Språnga12b1d62018-03-14 12:39:24 +0100628 return packet_history_.GetStorageMode() !=
629 RtpPacketHistory::StorageMode::kDisabled;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000630}
niklase@google.com470e71d2011-07-07 08:21:25 +0000631
Erik Språnga12b1d62018-03-14 12:39:24 +0100632int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
633 // Try to find packet in RTP packet history. Also verify RTT here, so that we
634 // don't retransmit too often.
635 rtc::Optional<RtpPacketHistory::PacketState> stored_packet =
636 packet_history_.GetPacketState(packet_id, true);
637 if (!stored_packet) {
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000638 // Packet not found.
asapersson@webrtc.org83ed0a42012-04-23 12:43:05 +0000639 return 0;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000640 }
Oleh Prypin5a980492018-03-09 12:27:24 +0000641
Erik Språnga12b1d62018-03-14 12:39:24 +0100642 const int32_t packet_size = static_cast<int32_t>(stored_packet->payload_size);
643
644 RTC_DCHECK(retransmission_rate_limiter_);
sprangcd349d92016-07-13 09:11:28 -0700645 // Check if we're overusing retransmission bitrate.
646 // TODO(sprang): Add histograms for nack success or failure reasons.
Erik Språnga12b1d62018-03-14 12:39:24 +0100647 if (!retransmission_rate_limiter_->TryUseRate(packet_size)) {
sprangcd349d92016-07-13 09:11:28 -0700648 return -1;
Erik Språnga12b1d62018-03-14 12:39:24 +0100649 }
Erik Språng7bb37b82018-03-09 09:52:59 +0100650
Oleh Prypin5a980492018-03-09 12:27:24 +0000651 if (paced_sender_) {
652 // Convert from TickTime to Clock since capture_time_ms is based on
653 // TickTime.
654 int64_t corrected_capture_tims_ms =
Erik Språnga12b1d62018-03-14 12:39:24 +0100655 stored_packet->capture_time_ms + clock_delta_ms_;
656 paced_sender_->InsertPacket(
657 RtpPacketSender::kNormalPriority, stored_packet->ssrc,
658 stored_packet->rtp_sequence_number, corrected_capture_tims_ms,
659 stored_packet->payload_size, true);
Oleh Prypin5a980492018-03-09 12:27:24 +0000660
Erik Språnga12b1d62018-03-14 12:39:24 +0100661 return packet_size;
Oleh Prypin5a980492018-03-09 12:27:24 +0000662 }
Erik Språnga12b1d62018-03-14 12:39:24 +0100663
664 std::unique_ptr<RtpPacketToSend> packet =
665 packet_history_.GetPacketAndSetSendTime(packet_id, true);
666 if (!packet) {
667 // Packet could theoretically time out between the first check and this one.
668 return 0;
669 }
670
671 const bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
philipel8aadd502017-02-23 02:56:13 -0800672 if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
sprang867fb522015-08-03 04:38:41 -0700673 return -1;
Erik Språnga12b1d62018-03-14 12:39:24 +0100674
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200675 return packet_size;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000676}
677
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200678bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
philipel32d00102017-02-27 02:18:46 -0800679 const PacketOptions& options,
680 const PacedPacketInfo& pacing_info) {
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000681 int bytes_sent = -1;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000682 if (transport_) {
michaelt4da30442016-11-17 01:38:43 -0800683 UpdateRtpOverhead(packet);
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200684 bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
685 ? static_cast<int>(packet.size())
stefan1d8a5062015-10-02 03:39:33 -0700686 : -1;
terelius429c3452016-01-21 05:42:04 -0800687 if (event_log_ && bytes_sent > 0) {
Elad Alon4a87e1c2017-10-03 16:11:34 +0200688 event_log_->Log(rtc::MakeUnique<RtcEventRtpPacketOutgoing>(
689 packet, pacing_info.probe_cluster_id));
terelius429c3452016-01-21 05:42:04 -0800690 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000691 }
sprang@webrtc.org0200f702015-02-16 12:06:00 +0000692 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200693 "RTPSender::SendPacketToNetwork", "size", packet.size(),
694 "sent", bytes_sent);
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000695 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000696 if (bytes_sent <= 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100697 RTC_LOG(LS_WARNING) << "Transport failed to send packet.";
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000698 return false;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000699 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000700 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000701}
702
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000703int RTPSender::SelectiveRetransmissions() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000704 if (!video_)
705 return -1;
706 return video_->SelectiveRetransmissions();
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000707}
708
709int RTPSender::SetSelectiveRetransmissions(uint8_t settings) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000710 if (!video_)
711 return -1;
mflodmanfcf54bd2015-04-14 21:28:08 +0200712 video_->SetSelectiveRetransmissions(settings);
713 return 0;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000714}
715
Danil Chapovalov2800d742016-08-26 18:48:46 +0200716void RTPSender::OnReceivedNack(
717 const std::vector<uint16_t>& nack_sequence_numbers,
718 int64_t avg_rtt) {
sprang@webrtc.org0200f702015-02-16 12:06:00 +0000719 TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
720 "RTPSender::OnReceivedNACK", "num_seqnum",
721 nack_sequence_numbers.size(), "avg_rtt", avg_rtt);
Erik Språnga12b1d62018-03-14 12:39:24 +0100722 packet_history_.SetRtt(5 + avg_rtt);
sprangcd349d92016-07-13 09:11:28 -0700723 for (uint16_t seq_no : nack_sequence_numbers) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100724 const int32_t bytes_sent = ReSendPacket(seq_no);
sprangcd349d92016-07-13 09:11:28 -0700725 if (bytes_sent < 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000726 // Failed to send one Sequence number. Give up the rest in this nack.
Mirko Bonadei675513b2017-11-09 11:09:25 +0100727 RTC_LOG(LS_WARNING) << "Failed resending RTP packet " << seq_no
728 << ", Discard rest of packets.";
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000729 break;
niklase@google.com470e71d2011-07-07 08:21:25 +0000730 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000731 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000732}
733
isheriff6b4b5f32016-06-08 00:24:21 -0700734void RTPSender::OnReceivedRtcpReportBlocks(
735 const ReportBlockList& report_blocks) {
736 playout_delay_oracle_.OnReceivedRtcpReportBlocks(report_blocks);
737}
738
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000739// Called from pacer when we can send the packet.
brandtr9dfff292016-11-14 05:14:50 -0800740bool RTPSender::TimeToSendPacket(uint32_t ssrc,
741 uint16_t sequence_number,
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000742 int64_t capture_time_ms,
philipela1ed0b32016-06-01 06:31:17 -0700743 bool retransmission,
philipel8aadd502017-02-23 02:56:13 -0800744 const PacedPacketInfo& pacing_info) {
brandtr9dfff292016-11-14 05:14:50 -0800745 if (!SendingMedia())
746 return true;
747
748 std::unique_ptr<RtpPacketToSend> packet;
Erik Språnga12b1d62018-03-14 12:39:24 +0100749 // No need to verify RTT here, it has already been checked before putting the
750 // packet into the pacer. But _do_ update the send time.
brandtr9dfff292016-11-14 05:14:50 -0800751 if (ssrc == SSRC()) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100752 packet = packet_history_.GetPacketAndSetSendTime(sequence_number, false);
brandtr9dfff292016-11-14 05:14:50 -0800753 } else if (ssrc == FlexfecSsrc()) {
Erik Språnga12b1d62018-03-14 12:39:24 +0100754 packet =
755 flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number, false);
brandtr9dfff292016-11-14 05:14:50 -0800756 }
757
Stefan Holmera246cfb2016-08-23 17:51:42 +0200758 if (!packet) {
brandtr9dfff292016-11-14 05:14:50 -0800759 // Packet cannot be found.
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000760 return true;
Stefan Holmera246cfb2016-08-23 17:51:42 +0200761 }
asapersson35151f32016-05-02 23:44:01 -0700762
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200763 return PrepareAndSendPacket(
764 std::move(packet),
765 retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission,
philipel8aadd502017-02-23 02:56:13 -0800766 pacing_info);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000767}
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000768
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200769bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000770 bool send_over_rtx,
philipela1ed0b32016-06-01 06:31:17 -0700771 bool is_retransmit,
philipel8aadd502017-02-23 02:56:13 -0800772 const PacedPacketInfo& pacing_info) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200773 RTC_DCHECK(packet);
774 int64_t capture_time_ms = packet->capture_time_ms();
775 RtpPacketToSend* packet_to_send = packet.get();
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000776
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200777 if (!is_retransmit && packet->Marker()) {
sprang@webrtc.org0200f702015-02-16 12:06:00 +0000778 TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
779 capture_time_ms);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000780 }
781
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200782 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
783 "PrepareAndSendPacket", "timestamp", packet->Timestamp(),
784 "seqnum", packet->SequenceNumber());
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000785
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200786 std::unique_ptr<RtpPacketToSend> packet_rtx;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000787 if (send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200788 packet_rtx = BuildRtxPacket(*packet);
789 if (!packet_rtx)
danilchap32cd2c42016-08-01 06:58:34 -0700790 return false;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200791 packet_to_send = packet_rtx.get();
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000792 }
793
ilnik10894992017-06-21 08:23:19 -0700794 // Bug webrtc:7859. While FEC is invoked from rtp_sender_video, and not after
795 // the pacer, these modifications of the header below are happening after the
796 // FEC protection packets are calculated. This will corrupt recovered packets
797 // at the same place. It's not an issue for extensions, which are present in
798 // all the packets (their content just may be incorrect on recovered packets).
799 // In case of VideoTimingExtension, since it's present not in every packet,
800 // data after rtp header may be corrupted if these packets are protected by
801 // the FEC.
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000802 int64_t now_ms = clock_->TimeInMilliseconds();
803 int64_t diff_ms = now_ms - capture_time_ms;
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200804 packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
805 diff_ms);
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200806 packet_to_send->SetExtension<AbsoluteSendTime>(
807 AbsoluteSendTime::MsTo24Bits(now_ms));
sprang867fb522015-08-03 04:38:41 -0700808
Erik Språng7b52f102018-02-07 14:37:37 +0100809 if (packet_to_send->HasExtension<VideoTimingExtension>()) {
810 if (populate_network2_timestamp_) {
811 packet_to_send->set_network2_time_ms(now_ms);
812 } else {
813 packet_to_send->set_pacer_exit_time_ms(now_ms);
814 }
815 }
ilnik04f4d122017-06-19 07:18:55 -0700816
stefan1d8a5062015-10-02 03:39:33 -0700817 PacketOptions options;
michaelt4da30442016-11-17 01:38:43 -0800818 if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id)) {
819 AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
philipel8aadd502017-02-23 02:56:13 -0800820 pacing_info);
sprang867fb522015-08-03 04:38:41 -0700821 }
Dino Radaković1807d572018-02-22 14:18:06 +0100822 options.application_data.assign(packet_to_send->application_data().begin(),
823 packet_to_send->application_data().end());
sprang867fb522015-08-03 04:38:41 -0700824
asapersson35151f32016-05-02 23:44:01 -0700825 if (!is_retransmit && !send_over_rtx) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200826 UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
827 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
828 packet->Ssrc());
stefanf116bd02015-10-27 08:29:42 -0700829 }
830
philipel32d00102017-02-27 02:18:46 -0800831 if (!SendPacketToNetwork(*packet_to_send, options, pacing_info))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200832 return false;
833
834 {
tommiae695e92016-02-02 08:31:45 -0800835 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000836 media_has_been_sent_ = true;
837 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200838 UpdateRtpStats(*packet_to_send, send_over_rtx, is_retransmit);
839 return true;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000840}
841
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200842void RTPSender::UpdateRtpStats(const RtpPacketToSend& packet,
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000843 bool is_rtx,
844 bool is_retransmit) {
sprangcd349d92016-07-13 09:11:28 -0700845 int64_t now_ms = clock_->TimeInMilliseconds();
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000846
danilchap7c9426c2016-04-14 03:05:31 -0700847 rtc::CritScope lock(&statistics_crit_);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200848 StreamDataCounters* counters = is_rtx ? &rtx_rtp_stats_ : &rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000849
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200850 total_bitrate_sent_.Update(packet.size(), now_ms);
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000851
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200852 if (counters->first_packet_time_ms == -1)
853 counters->first_packet_time_ms = now_ms;
854
855 if (IsFecPacket(packet))
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200856 CountPacket(&counters->fec, packet);
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200857
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200858 if (is_retransmit) {
859 CountPacket(&counters->retransmitted, packet);
860 nack_bitrate_sent_.Update(packet.size(), now_ms);
861 }
862 CountPacket(&counters->transmitted, packet);
sprangcd349d92016-07-13 09:11:28 -0700863
Danil Chapovalovd69e5262016-09-20 15:48:09 +0200864 if (rtp_stats_callback_)
865 rtp_stats_callback_->DataCountersUpdated(*counters, packet.Ssrc());
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000866}
867
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200868bool RTPSender::IsFecPacket(const RtpPacketToSend& packet) const {
brandtr9e795c62016-11-14 05:37:16 -0800869 if (!video_)
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000870 return false;
brandtr9e795c62016-11-14 05:37:16 -0800871
872 // FlexFEC.
873 if (packet.Ssrc() == FlexfecSsrc())
874 return true;
875
876 // RED+ULPFEC.
brandtrd8048952016-11-07 02:08:51 -0800877 int pt_red;
878 int pt_fec;
brandtrf1bb4762016-11-07 03:05:06 -0800879 video_->GetUlpfecConfig(&pt_red, &pt_fec);
brandtr9e795c62016-11-14 05:37:16 -0800880 return static_cast<int>(packet.PayloadType()) == pt_red &&
brandtrd8048952016-11-07 02:08:51 -0800881 static_cast<int>(packet.payload()[0]) == pt_fec;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000882}
883
philipel8aadd502017-02-23 02:56:13 -0800884size_t RTPSender::TimeToSendPadding(size_t bytes,
885 const PacedPacketInfo& pacing_info) {
stefan53b6cc32017-02-03 08:13:57 -0800886 if (bytes == 0)
pbos545727e2015-07-01 06:31:06 -0700887 return 0;
philipel8aadd502017-02-23 02:56:13 -0800888 size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000889 if (bytes_sent < bytes)
philipel8aadd502017-02-23 02:56:13 -0800890 bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000891 return bytes_sent;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000892}
893
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200894bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
895 StorageType storage,
896 RtpPacketSender::Priority priority) {
897 RTC_DCHECK(packet);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000898 int64_t now_ms = clock_->TimeInMilliseconds();
899
stefan@webrtc.org715faaf2012-08-28 15:20:39 +0000900 // |capture_time_ms| <= 0 is considered invalid.
901 // TODO(holmer): This should be changed all over Video Engine so that negative
902 // time is consider invalid, while 0 is considered a valid time.
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200903 if (packet->capture_time_ms() > 0) {
904 packet->SetExtension<TransmissionOffset>(
905 kTimestampTicksPerMs * (now_ms - packet->capture_time_ms()));
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +0000906 }
Danil Chapovalovf3ba6482017-06-12 15:43:55 +0200907 packet->SetExtension<AbsoluteSendTime>(AbsoluteSendTime::MsTo24Bits(now_ms));
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000908
gaetano.carlucci52a57032016-09-14 05:04:36 -0700909 if (video_) {
gaetano.carlucci61050f62016-09-30 06:29:54 -0700910 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoTotBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700911 ActualSendBitrateKbit(), packet->Ssrc());
gaetano.carlucci61050f62016-09-30 06:29:54 -0700912 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoFecBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700913 FecOverheadRate() / 1000, packet->Ssrc());
gaetano.carlucci61050f62016-09-30 06:29:54 -0700914 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoNackBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700915 NackOverheadRate() / 1000, packet->Ssrc());
916 } else {
gaetano.carlucci61050f62016-09-30 06:29:54 -0700917 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioTotBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700918 ActualSendBitrateKbit(), packet->Ssrc());
gaetano.carlucci61050f62016-09-30 06:29:54 -0700919 BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioNackBitrate_kbps", now_ms,
gaetano.carlucci52a57032016-09-14 05:04:36 -0700920 NackOverheadRate() / 1000, packet->Ssrc());
921 }
922
brandtr9dfff292016-11-14 05:14:50 -0800923 uint32_t ssrc = packet->Ssrc();
924 rtc::Optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
Peter Boströme23e7372015-10-08 11:44:14 +0200925 if (paced_sender_) {
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200926 uint16_t seq_no = packet->SequenceNumber();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000927 // Correct offset between implementations of millisecond time stamps in
928 // TickTime and Clock.
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200929 int64_t corrected_time_ms = packet->capture_time_ms() + clock_delta_ms_;
930 size_t payload_length = packet->payload_size();
brandtr9dfff292016-11-14 05:14:50 -0800931 if (ssrc == flexfec_ssrc) {
932 // Store FlexFEC packets in the history here, so they can be found
933 // when the pacer calls TimeToSendPacket.
Erik Språnga12b1d62018-03-14 12:39:24 +0100934 flexfec_packet_history_.PutRtpPacket(std::move(packet), storage,
935 rtc::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800936 } else {
Erik Språnga12b1d62018-03-14 12:39:24 +0100937 packet_history_.PutRtpPacket(std::move(packet), storage, rtc::nullopt);
brandtr9dfff292016-11-14 05:14:50 -0800938 }
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200939
940 paced_sender_->InsertPacket(priority, ssrc, seq_no, corrected_time_ms,
Peter Boströme23e7372015-10-08 11:44:14 +0200941 payload_length, false);
942 if (last_capture_time_ms_sent_ == 0 ||
943 corrected_time_ms > last_capture_time_ms_sent_) {
944 last_capture_time_ms_sent_ = corrected_time_ms;
945 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
946 "PacedSend", corrected_time_ms,
947 "capture_time_ms", corrected_time_ms);
asapersson@webrtc.orge5b49a02012-11-06 13:09:39 +0000948 }
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700949 return true;
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +0000950 }
Stefan Holmerf5dca482016-01-27 12:58:51 +0100951
952 PacketOptions options;
michaelt4da30442016-11-17 01:38:43 -0800953 if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id)) {
954 AddPacketToTransportFeedback(options.packet_id, *packet.get(),
philipel8aadd502017-02-23 02:56:13 -0800955 PacedPacketInfo());
Stefan Holmerf5dca482016-01-27 12:58:51 +0100956 }
Dino Radaković1807d572018-02-22 14:18:06 +0100957 options.application_data.assign(packet->application_data().begin(),
958 packet->application_data().end());
Stefan Holmerf5dca482016-01-27 12:58:51 +0100959
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200960 UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
961 UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
962 packet->Ssrc());
963
philipel32d00102017-02-27 02:18:46 -0800964 bool sent = SendPacketToNetwork(*packet, options, PacedPacketInfo());
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200965
966 if (sent) {
967 {
968 rtc::CritScope lock(&send_critsect_);
969 media_has_been_sent_ = true;
970 }
971 UpdateRtpStats(*packet, false, false);
972 }
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +0000973
brandtr9dfff292016-11-14 05:14:50 -0800974 // To support retransmissions, we store the media packet as sent in the
975 // packet history (even if send failed).
976 if (storage == kAllowRetransmission) {
Danil Chapovalov603ce982017-12-27 11:32:50 +0100977 RTC_DCHECK_EQ(ssrc, SSRC());
Erik Språnga12b1d62018-03-14 12:39:24 +0100978 packet_history_.PutRtpPacket(std::move(packet), storage, now_ms);
brandtr9dfff292016-11-14 05:14:50 -0800979 }
Peter Boströme23e7372015-10-08 11:44:14 +0200980
Danil Chapovalov31e4e802016-08-03 18:27:40 +0200981 return sent;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000982}
983
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +0000984void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
asapersson35151f32016-05-02 23:44:01 -0700985 if (!send_side_delay_observer_ || capture_time_ms <= 0)
Peter Boström71861a02015-05-28 14:45:36 +0200986 return;
987
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000988 uint32_t ssrc;
oprypinba09f792017-09-04 08:32:43 -0700989 int64_t avg_delay_ms = 0;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000990 int max_delay_ms = 0;
991 {
tommiae695e92016-02-02 08:31:45 -0800992 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -0800993 if (!ssrc_)
994 return;
995 ssrc = *ssrc_;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000996 }
997 {
danilchap7c9426c2016-04-14 03:05:31 -0700998 rtc::CritScope cs(&statistics_crit_);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000999 // TODO(holmer): Compute this iteratively instead.
1000 send_delays_[now_ms] = now_ms - capture_time_ms;
1001 send_delays_.erase(send_delays_.begin(),
1002 send_delays_.lower_bound(now_ms -
1003 kSendSideDelayWindowMs));
Peter Boström71861a02015-05-28 14:45:36 +02001004 int num_delays = 0;
1005 for (auto it = send_delays_.upper_bound(now_ms - kSendSideDelayWindowMs);
1006 it != send_delays_.end(); ++it) {
1007 max_delay_ms = std::max(max_delay_ms, it->second);
1008 avg_delay_ms += it->second;
1009 ++num_delays;
1010 }
1011 if (num_delays == 0)
1012 return;
1013 avg_delay_ms = (avg_delay_ms + num_delays / 2) / num_delays;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001014 }
oprypinba09f792017-09-04 08:32:43 -07001015 send_side_delay_observer_->SendSideDelayUpdated(
1016 rtc::dchecked_cast<int>(avg_delay_ms), max_delay_ms, ssrc);
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001017}
1018
asapersson35151f32016-05-02 23:44:01 -07001019void RTPSender::UpdateOnSendPacket(int packet_id,
1020 int64_t capture_time_ms,
1021 uint32_t ssrc) {
1022 if (!send_packet_observer_ || capture_time_ms <= 0 || packet_id == -1)
1023 return;
1024
1025 send_packet_observer_->OnSendPacket(packet_id, capture_time_ms, ssrc);
1026}
1027
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001028void RTPSender::ProcessBitrate() {
sprangcd349d92016-07-13 09:11:28 -07001029 if (!bitrate_callback_)
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001030 return;
sprangcd349d92016-07-13 09:11:28 -07001031 int64_t now_ms = clock_->TimeInMilliseconds();
1032 uint32_t ssrc;
1033 {
1034 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001035 if (!ssrc_)
1036 return;
1037 ssrc = *ssrc_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001038 }
sprangcd349d92016-07-13 09:11:28 -07001039
1040 rtc::CritScope lock(&statistics_crit_);
1041 bitrate_callback_->Notify(total_bitrate_sent_.Rate(now_ms).value_or(0),
1042 nack_bitrate_sent_.Rate(now_ms).value_or(0), ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +00001043}
1044
isheriff6b4b5f32016-06-08 00:24:21 -07001045size_t RTPSender::RtpHeaderLength() const {
tommiae695e92016-02-02 08:31:45 -08001046 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001047 size_t rtp_header_length = kRtpHeaderLength;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001048 rtp_header_length += sizeof(uint32_t) * csrcs_.size();
Ilya Nikolaevskiy1d037ae2018-03-15 15:46:17 +01001049 rtp_header_length += rtp_header_extension_map_.GetTotalLengthInBytes(
1050 kFecOrPaddingExtensionSizes);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001051 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +00001052}
1053
mflodmanfcf54bd2015-04-14 21:28:08 +02001054uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
tommiae695e92016-02-02 08:31:45 -08001055 rtc::CritScope lock(&send_critsect_);
mflodmanfcf54bd2015-04-14 21:28:08 +02001056 uint16_t first_allocated_sequence_number = sequence_number_;
1057 sequence_number_ += packets_to_send;
1058 return first_allocated_sequence_number;
niklase@google.com470e71d2011-07-07 08:21:25 +00001059}
1060
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001061void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
1062 StreamDataCounters* rtx_stats) const {
danilchap7c9426c2016-04-14 03:05:31 -07001063 rtc::CritScope lock(&statistics_crit_);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001064 *rtp_stats = rtp_stats_;
1065 *rtx_stats = rtx_rtp_stats_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001066}
1067
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001068std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
1069 rtc::CritScope lock(&send_critsect_);
1070 std::unique_ptr<RtpPacketToSend> packet(
nisse284542b2017-01-10 08:58:32 -08001071 new RtpPacketToSend(&rtp_header_extension_map_, max_packet_size_));
nisse7d59f6b2017-02-21 03:40:24 -08001072 RTC_DCHECK(ssrc_);
1073 packet->SetSsrc(*ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001074 packet->SetCsrcs(csrcs_);
1075 // Reserve extensions, if registered, RtpSender set in SendToNetwork.
1076 packet->ReserveExtension<AbsoluteSendTime>();
1077 packet->ReserveExtension<TransmissionOffset>();
1078 packet->ReserveExtension<TransportSequenceNumber>();
danilchap74110612016-10-02 10:54:29 -07001079 if (playout_delay_oracle_.send_playout_delay()) {
1080 packet->SetExtension<PlayoutDelayLimits>(
1081 playout_delay_oracle_.playout_delay());
1082 }
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001083 return packet;
1084}
1085
1086bool RTPSender::AssignSequenceNumber(RtpPacketToSend* packet) {
1087 rtc::CritScope lock(&send_critsect_);
1088 if (!sending_media_)
1089 return false;
nisse7d59f6b2017-02-21 03:40:24 -08001090 RTC_DCHECK(packet->Ssrc() == ssrc_);
Danil Chapovalov5e57b172016-09-02 19:15:59 +02001091 packet->SetSequenceNumber(sequence_number_++);
1092
1093 // Remember marker bit to determine if padding can be inserted with
1094 // sequence number following |packet|.
1095 last_packet_marker_bit_ = packet->Marker();
1096 // Save timestamps to generate timestamp field and extensions for the padding.
1097 last_rtp_timestamp_ = packet->Timestamp();
1098 last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
1099 capture_time_ms_ = packet->capture_time_ms();
1100 return true;
1101}
1102
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001103bool RTPSender::UpdateTransportSequenceNumber(RtpPacketToSend* packet,
1104 int* packet_id) const {
1105 RTC_DCHECK(packet);
1106 RTC_DCHECK(packet_id);
tommiae695e92016-02-02 08:31:45 -08001107 rtc::CritScope lock(&send_critsect_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001108 if (!rtp_header_extension_map_.IsRegistered(TransportSequenceNumber::kId))
stefana23fc622016-07-28 07:56:38 -07001109 return false;
1110
asapersson35151f32016-05-02 23:44:01 -07001111 if (!transport_sequence_number_allocator_)
1112 return false;
1113
1114 *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001115
1116 if (!packet->SetExtension<TransportSequenceNumber>(*packet_id))
1117 return false;
1118
asapersson35151f32016-05-02 23:44:01 -07001119 return true;
sprang867fb522015-08-03 04:38:41 -07001120}
1121
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001122void RTPSender::SetSendingMediaStatus(bool enabled) {
tommiae695e92016-02-02 08:31:45 -08001123 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001124 sending_media_ = enabled;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001125}
1126
1127bool RTPSender::SendingMedia() const {
tommiae695e92016-02-02 08:31:45 -08001128 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001129 return sending_media_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001130}
1131
danilchap71fead22016-08-18 02:01:49 -07001132void RTPSender::SetTimestampOffset(uint32_t timestamp) {
tommiae695e92016-02-02 08:31:45 -08001133 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001134 timestamp_offset_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001135}
1136
danilchap71fead22016-08-18 02:01:49 -07001137uint32_t RTPSender::TimestampOffset() const {
tommiae695e92016-02-02 08:31:45 -08001138 rtc::CritScope lock(&send_critsect_);
danilchap71fead22016-08-18 02:01:49 -07001139 return timestamp_offset_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001140}
1141
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001142void RTPSender::SetSSRC(uint32_t ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001143 // This is configured via the API.
tommiae695e92016-02-02 08:31:45 -08001144 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +00001145
nisse7d59f6b2017-02-21 03:40:24 -08001146 if (ssrc_ == ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001147 return; // Since it's same ssrc, don't reset anything.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001148 }
nisse7d59f6b2017-02-21 03:40:24 -08001149 ssrc_.emplace(ssrc);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001150 if (!sequence_number_forced_) {
danilchap47a740b2015-12-15 00:30:07 -08001151 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001152 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001153}
1154
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001155uint32_t RTPSender::SSRC() const {
tommiae695e92016-02-02 08:31:45 -08001156 rtc::CritScope lock(&send_critsect_);
nisse7d59f6b2017-02-21 03:40:24 -08001157 RTC_DCHECK(ssrc_);
1158 return *ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001159}
1160
brandtr9dfff292016-11-14 05:14:50 -08001161rtc::Optional<uint32_t> RTPSender::FlexfecSsrc() const {
1162 if (video_) {
1163 return video_->FlexfecSsrc();
1164 }
Oskar Sundbom3419cf92017-11-16 10:55:48 +01001165 return rtc::nullopt;
brandtr9dfff292016-11-14 05:14:50 -08001166}
1167
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001168void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
spranga8ae6f22017-09-04 07:23:56 -07001169 RTC_DCHECK_LE(csrcs.size(), kRtpCsrcSize);
tommiae695e92016-02-02 08:31:45 -08001170 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001171 csrcs_ = csrcs;
niklase@google.com470e71d2011-07-07 08:21:25 +00001172}
1173
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001174void RTPSender::SetSequenceNumber(uint16_t seq) {
tommiae695e92016-02-02 08:31:45 -08001175 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001176 sequence_number_forced_ = true;
1177 sequence_number_ = seq;
niklase@google.com470e71d2011-07-07 08:21:25 +00001178}
1179
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001180uint16_t RTPSender::SequenceNumber() const {
tommiae695e92016-02-02 08:31:45 -08001181 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001182 return sequence_number_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001183}
1184
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001185// Audio.
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001186int32_t RTPSender::SendTelephoneEvent(uint8_t key,
1187 uint16_t time_ms,
1188 uint8_t level) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001189 if (!audio_configured_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001190 return -1;
1191 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001192 return audio_->SendTelephoneEvent(key, time_ms, level);
niklase@google.com470e71d2011-07-07 08:21:25 +00001193}
1194
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001195int32_t RTPSender::SetAudioLevel(uint8_t level_d_bov) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001196 return audio_->SetAudioLevel(level_d_bov);
niklase@google.com470e71d2011-07-07 08:21:25 +00001197}
1198
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001199RtpVideoCodecTypes RTPSender::VideoCodecType() const {
spranga8ae6f22017-09-04 07:23:56 -07001200 RTC_DCHECK(!audio_configured_) << "Sender is an audio stream!";
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001201 return video_->VideoCodecType();
niklase@google.com470e71d2011-07-07 08:21:25 +00001202}
1203
brandtrf1bb4762016-11-07 03:05:06 -08001204void RTPSender::SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type) {
henrikg91d6ede2015-09-17 00:24:34 -07001205 RTC_DCHECK(!audio_configured_);
brandtrf1bb4762016-11-07 03:05:06 -08001206 video_->SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
niklase@google.com470e71d2011-07-07 08:21:25 +00001207}
1208
brandtr1743a192016-11-07 03:36:05 -08001209bool RTPSender::SetFecParameters(const FecProtectionParams& delta_params,
1210 const FecProtectionParams& key_params) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001211 if (audio_configured_) {
brandtr1743a192016-11-07 03:36:05 -08001212 return false;
stefan@webrtc.orge0d6fa42012-03-20 22:10:56 +00001213 }
mflodmanfcf54bd2015-04-14 21:28:08 +02001214 video_->SetFecParameters(delta_params, key_params);
brandtr1743a192016-11-07 03:36:05 -08001215 return true;
marpan@google.com80c5d7a2011-07-15 21:32:40 +00001216}
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001217
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001218std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
1219 const RtpPacketToSend& packet) {
1220 // TODO(danilchap): Create rtx packet with extra capacity for SRTP
1221 // when transport interface would be updated to take buffer class.
1222 std::unique_ptr<RtpPacketToSend> rtx_packet(new RtpPacketToSend(
1223 &rtp_header_extension_map_, packet.size() + kRtxHeaderSize));
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001224 // Add original RTP header.
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001225 rtx_packet->CopyHeaderFrom(packet);
1226 {
1227 rtc::CritScope lock(&send_critsect_);
1228 if (!sending_media_)
1229 return nullptr;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001230
nisse7d59f6b2017-02-21 03:40:24 -08001231 RTC_DCHECK(ssrc_rtx_);
1232
brandtre6f98c72016-11-11 03:28:30 -08001233 // Replace payload type.
1234 auto kv = rtx_payload_type_map_.find(packet.PayloadType());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001235 if (kv == rtx_payload_type_map_.end())
brandtre6f98c72016-11-11 03:28:30 -08001236 return nullptr;
1237 rtx_packet->SetPayloadType(kv->second);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +00001238
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001239 // Replace sequence number.
1240 rtx_packet->SetSequenceNumber(sequence_number_rtx_++);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001241
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001242 // Replace SSRC.
nisse7d59f6b2017-02-21 03:40:24 -08001243 rtx_packet->SetSsrc(*ssrc_rtx_);
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001244 }
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001245
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001246 uint8_t* rtx_payload =
1247 rtx_packet->AllocatePayload(packet.payload_size() + kRtxHeaderSize);
1248 RTC_DCHECK(rtx_payload);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001249 // Add OSN (original sequence number).
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001250 ByteWriter<uint16_t>::WriteBigEndian(rtx_payload, packet.SequenceNumber());
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001251
1252 // Add original payload data.
danilchap96c15872016-11-21 01:35:29 -08001253 auto payload = packet.payload();
1254 memcpy(rtx_payload + kRtxHeaderSize, payload.data(), payload.size());
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001255
Dino Radaković1807d572018-02-22 14:18:06 +01001256 // Add original application data.
1257 rtx_packet->set_application_data(packet.application_data());
1258
Danil Chapovalov31e4e802016-08-03 18:27:40 +02001259 return rtx_packet;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001260}
1261
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001262void RTPSender::RegisterRtpStatisticsCallback(
1263 StreamDataCountersCallback* callback) {
danilchap7c9426c2016-04-14 03:05:31 -07001264 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001265 rtp_stats_callback_ = callback;
1266}
1267
1268StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
danilchap7c9426c2016-04-14 03:05:31 -07001269 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001270 return rtp_stats_callback_;
1271}
1272
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001273uint32_t RTPSender::BitrateSent() const {
sprangcd349d92016-07-13 09:11:28 -07001274 rtc::CritScope cs(&statistics_crit_);
1275 return total_bitrate_sent_.Rate(clock_->TimeInMilliseconds()).value_or(0);
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001276}
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001277
1278void RTPSender::SetRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001279 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001280 sequence_number_ = rtp_state.sequence_number;
1281 sequence_number_forced_ = true;
danilchap71fead22016-08-18 02:01:49 -07001282 timestamp_offset_ = rtp_state.start_timestamp;
danilchape5b41412016-08-22 03:39:23 -07001283 last_rtp_timestamp_ = rtp_state.timestamp;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001284 capture_time_ms_ = rtp_state.capture_time_ms;
1285 last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001286 media_has_been_sent_ = rtp_state.media_has_been_sent;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001287}
1288
1289RtpState RTPSender::GetRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001290 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001291
1292 RtpState state;
1293 state.sequence_number = sequence_number_;
danilchap71fead22016-08-18 02:01:49 -07001294 state.start_timestamp = timestamp_offset_;
danilchape5b41412016-08-22 03:39:23 -07001295 state.timestamp = last_rtp_timestamp_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001296 state.capture_time_ms = capture_time_ms_;
1297 state.last_timestamp_time_ms = last_timestamp_time_ms_;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001298 state.media_has_been_sent = media_has_been_sent_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001299
1300 return state;
1301}
1302
1303void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001304 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001305 sequence_number_rtx_ = rtp_state.sequence_number;
1306}
1307
1308RtpState RTPSender::GetRtxRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001309 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001310
1311 RtpState state;
1312 state.sequence_number = sequence_number_rtx_;
danilchap71fead22016-08-18 02:01:49 -07001313 state.start_timestamp = timestamp_offset_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001314
1315 return state;
1316}
1317
philipel8aadd502017-02-23 02:56:13 -08001318void RTPSender::AddPacketToTransportFeedback(
1319 uint16_t packet_id,
1320 const RtpPacketToSend& packet,
1321 const PacedPacketInfo& pacing_info) {
michaelt668eb3b2016-11-29 02:24:18 -08001322 size_t packet_size = packet.payload_size() + packet.padding_size();
elad.alonc3dfff32017-01-26 02:46:55 -08001323 if (send_side_bwe_with_overhead_) {
nisse284542b2017-01-10 08:58:32 -08001324 packet_size = packet.size();
michaelt668eb3b2016-11-29 02:24:18 -08001325 }
1326
michaelt4da30442016-11-17 01:38:43 -08001327 if (transport_feedback_observer_) {
elad.alond12a8e12017-03-23 11:04:48 -07001328 transport_feedback_observer_->AddPacket(SSRC(), packet_id, packet_size,
philipel8aadd502017-02-23 02:56:13 -08001329 pacing_info);
michaelt4da30442016-11-17 01:38:43 -08001330 }
1331}
1332
1333void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
1334 if (!overhead_observer_)
1335 return;
nisse284542b2017-01-10 08:58:32 -08001336 size_t overhead_bytes_per_packet;
michaelt4da30442016-11-17 01:38:43 -08001337 {
1338 rtc::CritScope lock(&send_critsect_);
1339 if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
1340 return;
1341 }
1342 rtp_overhead_bytes_per_packet_ = packet.headers_size();
nisse284542b2017-01-10 08:58:32 -08001343 overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
michaelt4da30442016-11-17 01:38:43 -08001344 }
1345 overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
1346}
1347
sprang168794c2017-07-06 04:38:06 -07001348int64_t RTPSender::LastTimestampTimeMs() const {
1349 rtc::CritScope lock(&send_critsect_);
1350 return last_timestamp_time_ms_;
1351}
1352
1353void RTPSender::SendKeepAlive(uint8_t payload_type) {
1354 std::unique_ptr<RtpPacketToSend> packet = AllocatePacket();
1355 packet->SetPayloadType(payload_type);
1356 // Set marker bit and timestamps in the same manner as plain padding packets.
1357 packet->SetMarker(false);
1358 {
1359 rtc::CritScope lock(&send_critsect_);
1360 packet->SetTimestamp(last_rtp_timestamp_);
1361 packet->set_capture_time_ms(capture_time_ms_);
1362 }
1363 AssignSequenceNumber(packet.get());
1364 SendToNetwork(std::move(packet), StorageType::kDontRetransmit,
1365 RtpPacketSender::Priority::kLowPriority);
1366}
1367
Erik Språng8b101922018-01-18 11:58:05 -08001368void RTPSender::SetRtt(int64_t rtt_ms) {
1369 packet_history_.SetRtt(rtt_ms);
1370 flexfec_packet_history_.SetRtt(rtt_ms);
1371}
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001372} // namespace webrtc