blob: f7b72b875c785358d42179f333ff2173075c0e99 [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
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +000011#include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
12
pbos@webrtc.org12dc1a32013-08-05 16:22:53 +000013#include <stdlib.h> // srand
danilchapb8b6fbb2015-12-10 05:05:27 -080014#include <algorithm>
Shao Changbine62202f2015-04-21 20:24:50 +080015#include <utility>
niklase@google.com470e71d2011-07-07 08:21:25 +000016
Shao Changbine62202f2015-04-21 20:24:50 +080017#include "webrtc/base/checks.h"
Peter Boströmebc0b4e2015-10-28 16:39:33 +010018#include "webrtc/base/logging.h"
tommie4f96502015-10-20 23:00:48 -070019#include "webrtc/base/trace_event.h"
terelius429c3452016-01-21 05:42:04 -080020#include "webrtc/call.h"
21#include "webrtc/call/rtc_event_log.h"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010022#include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
sprang@webrtc.org779c3d12015-03-17 16:42:49 +000023#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +000024#include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h"
25#include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
danilchap1227e8b2015-12-21 11:06:50 -080026#include "webrtc/modules/rtp_rtcp/source/time_util.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010027#include "webrtc/system_wrappers/include/tick_util.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000028
29namespace webrtc {
niklase@google.com470e71d2011-07-07 08:21:25 +000030
stefan@webrtc.orga8179622013-06-04 13:47:36 +000031// Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP.
Stefan Holmer0a87ffc2015-10-21 13:41:48 +020032static const size_t kMaxPaddingLength = 224;
33static const int kSendSideDelayWindowMs = 1000;
34static const uint32_t kAbsSendTimeFraction = 18;
stefan@webrtc.orga8179622013-06-04 13:47:36 +000035
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000036namespace {
37
guoweis@webrtc.org45362892015-03-04 22:55:15 +000038const size_t kRtpHeaderLength = 12;
danilchap47a740b2015-12-15 00:30:07 -080039const uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1.
guoweis@webrtc.org45362892015-03-04 22:55:15 +000040
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +000041const char* FrameTypeToString(FrameType frame_type) {
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000042 switch (frame_type) {
pbos22993e12015-10-19 02:39:06 -070043 case kEmptyFrame:
44 return "empty";
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000045 case kAudioFrameSpeech: return "audio_speech";
46 case kAudioFrameCN: return "audio_cn";
47 case kVideoFrameKey: return "video_key";
48 case kVideoFrameDelta: return "video_delta";
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000049 }
50 return "";
51}
52
Stefan Holmer0a87ffc2015-10-21 13:41:48 +020053// TODO(holmer): Merge this with the implementation in
54// remote_bitrate_estimator_abs_send_time.cc.
55uint32_t ConvertMsTo24Bits(int64_t time_ms) {
56 uint32_t time_24_bits =
57 static_cast<uint32_t>(
58 ((static_cast<uint64_t>(time_ms) << kAbsSendTimeFraction) + 500) /
59 1000) &
60 0x00FFFFFF;
61 return time_24_bits;
62}
hclam@chromium.org806dc3b2013-04-09 19:54:10 +000063} // namespace
64
tommiae695e92016-02-02 08:31:45 -080065RTPSender::BitrateAggregator::BitrateAggregator(
66 BitrateStatisticsObserver* bitrate_callback)
67 : callback_(bitrate_callback),
68 total_bitrate_observer_(*this),
69 retransmit_bitrate_observer_(*this),
70 ssrc_(0) {}
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000071
tommiae695e92016-02-02 08:31:45 -080072void RTPSender::BitrateAggregator::OnStatsUpdated() const {
73 if (callback_) {
74 callback_->Notify(total_bitrate_observer_.statistics(),
75 retransmit_bitrate_observer_.statistics(), ssrc_);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000076 }
tommiae695e92016-02-02 08:31:45 -080077}
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000078
tommiae695e92016-02-02 08:31:45 -080079Bitrate::Observer* RTPSender::BitrateAggregator::total_bitrate_observer() {
80 return &total_bitrate_observer_;
81}
82Bitrate::Observer* RTPSender::BitrateAggregator::retransmit_bitrate_observer() {
83 return &retransmit_bitrate_observer_;
84}
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000085
tommiae695e92016-02-02 08:31:45 -080086void RTPSender::BitrateAggregator::set_ssrc(uint32_t ssrc) {
87 ssrc_ = ssrc;
88}
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000089
tommiae695e92016-02-02 08:31:45 -080090RTPSender::BitrateAggregator::BitrateObserver::BitrateObserver(
91 const BitrateAggregator& aggregator)
92 : aggregator_(aggregator) {}
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +000093
tommiae695e92016-02-02 08:31:45 -080094// Implements Bitrate::Observer.
95void RTPSender::BitrateAggregator::BitrateObserver::BitrateUpdated(
96 const BitrateStatistics& stats) {
97 statistics_ = stats;
98 aggregator_.OnStatsUpdated();
99}
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000100
tommiae695e92016-02-02 08:31:45 -0800101const BitrateStatistics&
102RTPSender::BitrateAggregator::BitrateObserver::statistics() const {
103 return statistics_;
104}
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000105
sprangebbf8a82015-09-21 15:11:14 -0700106RTPSender::RTPSender(
107 bool audio,
108 Clock* clock,
109 Transport* transport,
sprangebbf8a82015-09-21 15:11:14 -0700110 RtpPacketSender* paced_sender,
111 TransportSequenceNumberAllocator* sequence_number_allocator,
112 TransportFeedbackObserver* transport_feedback_observer,
113 BitrateStatisticsObserver* bitrate_callback,
114 FrameCountObserver* frame_count_observer,
terelius429c3452016-01-21 05:42:04 -0800115 SendSideDelayObserver* send_side_delay_observer,
116 RtcEventLog* event_log)
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000117 : clock_(clock),
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000118 // TODO(holmer): Remove this conversion when we remove the use of
119 // TickTime.
120 clock_delta_ms_(clock_->TimeInMilliseconds() -
121 TickTime::MillisecondTimestamp()),
danilchap47a740b2015-12-15 00:30:07 -0800122 random_(clock_->TimeInMicroseconds()),
tommiae695e92016-02-02 08:31:45 -0800123 bitrates_(bitrate_callback),
124 total_bitrate_sent_(clock, bitrates_.total_bitrate_observer()),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000125 audio_configured_(audio),
solenberg6021fe22016-03-15 11:41:53 -0700126 audio_(audio ? new RTPSenderAudio(clock, this) : nullptr),
pbos@webrtc.org7c4d20f2015-02-12 12:20:08 +0000127 video_(audio ? nullptr : new RTPSenderVideo(clock, this)),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000128 paced_sender_(paced_sender),
sprangebbf8a82015-09-21 15:11:14 -0700129 transport_sequence_number_allocator_(sequence_number_allocator),
sprang5e023eb2015-09-14 06:42:43 -0700130 transport_feedback_observer_(transport_feedback_observer),
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000131 last_capture_time_ms_sent_(0),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000132 transport_(transport),
133 sending_media_(true), // Default to sending media.
134 max_payload_length_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP.
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000135 payload_type_(-1),
136 payload_type_map_(),
137 rtp_header_extension_map_(),
138 transmission_time_offset_(0),
139 absolute_send_time_(0),
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000140 rotation_(kVideoRotation_0),
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700141 cvo_mode_(kCVONone),
sprang@webrtc.org30933902015-03-17 14:33:12 +0000142 transport_sequence_number_(0),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000143 // NACK.
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000144 nack_byte_count_times_(),
145 nack_byte_count_(),
tommiae695e92016-02-02 08:31:45 -0800146 nack_bitrate_(clock, bitrates_.retransmit_bitrate_observer()),
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000147 packet_history_(clock),
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000148 // Statistics
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000149 rtp_stats_callback_(NULL),
andresp@webrtc.org8f151212014-07-10 09:39:23 +0000150 frame_count_observer_(frame_count_observer),
stefan@webrtc.org168f23f2014-07-11 13:44:02 +0000151 send_side_delay_observer_(send_side_delay_observer),
terelius429c3452016-01-21 05:42:04 -0800152 event_log_(event_log),
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000153 // RTP variables
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000154 start_timestamp_forced_(false),
155 start_timestamp_(0),
tommiae695e92016-02-02 08:31:45 -0800156 ssrc_db_(SSRCDatabase::GetSSRCDatabase()),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000157 remote_ssrc_(0),
158 sequence_number_forced_(false),
159 ssrc_forced_(false),
160 timestamp_(0),
161 capture_time_ms_(0),
162 last_timestamp_time_ms_(0),
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000163 media_has_been_sent_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000164 last_packet_marker_bit_(false),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000165 csrcs_(),
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +0000166 rtx_(kRtxOff),
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000167 target_bitrate_(0) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000168 memset(nack_byte_count_times_, 0, sizeof(nack_byte_count_times_));
169 memset(nack_byte_count_, 0, sizeof(nack_byte_count_));
tommiae695e92016-02-02 08:31:45 -0800170 // We need to seed the random generator for BuildPaddingPacket() below.
171 // TODO(holmer,tommi): Note that TimeInMilliseconds might return 0 on Mac
172 // early on in the process.
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000173 srand(static_cast<uint32_t>(clock_->TimeInMilliseconds()));
tommiae695e92016-02-02 08:31:45 -0800174 ssrc_ = ssrc_db_->CreateSSRC();
175 RTC_DCHECK(ssrc_ != 0);
176 ssrc_rtx_ = ssrc_db_->CreateSSRC();
177 RTC_DCHECK(ssrc_rtx_ != 0);
178
179 bitrates_.set_ssrc(ssrc_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000180 // Random start, 16 bits. Can't be 0.
danilchap47a740b2015-12-15 00:30:07 -0800181 sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber);
182 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
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 if (remote_ssrc_ != 0) {
tommiae695e92016-02-02 08:31:45 -0800196 ssrc_db_->ReturnSSRC(remote_ssrc_);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000197 }
tommiae695e92016-02-02 08:31:45 -0800198 ssrc_db_->ReturnSSRC(ssrc_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000199
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000200 SSRCDatabase::ReturnSSRCDatabase();
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000201 while (!payload_type_map_.empty()) {
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000202 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000203 payload_type_map_.begin();
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000204 delete it->second;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000205 payload_type_map_.erase(it);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000206 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000207}
niklase@google.com470e71d2011-07-07 08:21:25 +0000208
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000209void RTPSender::SetTargetBitrate(uint32_t bitrate) {
danilchap7c9426c2016-04-14 03:05:31 -0700210 rtc::CritScope cs(&target_bitrate_critsect_);
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000211 target_bitrate_ = bitrate;
212}
213
214uint32_t RTPSender::GetTargetBitrate() {
danilchap7c9426c2016-04-14 03:05:31 -0700215 rtc::CritScope cs(&target_bitrate_critsect_);
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000216 return target_bitrate_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000217}
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000218
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000219uint16_t RTPSender::ActualSendBitrateKbit() const {
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +0000220 return (uint16_t)(total_bitrate_sent_.BitrateNow() / 1000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000221}
222
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000223uint32_t RTPSender::VideoBitrateSent() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000224 if (video_) {
225 return video_->VideoBitrateSent();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000226 }
227 return 0;
stefan@webrtc.orgfbea4e52011-10-27 16:08:29 +0000228}
229
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000230uint32_t RTPSender::FecOverheadRate() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000231 if (video_) {
232 return video_->FecOverheadRate();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000233 }
234 return 0;
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000235}
236
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000237uint32_t RTPSender::NackOverheadRate() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000238 return nack_bitrate_.BitrateLast();
stefan@webrtc.orgd0bdab02011-10-14 14:24:54 +0000239}
240
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000241int32_t RTPSender::SetTransmissionTimeOffset(int32_t transmission_time_offset) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000242 if (transmission_time_offset > (0x800000 - 1) ||
243 transmission_time_offset < -(0x800000 - 1)) { // Word24.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000244 return -1;
245 }
tommiae695e92016-02-02 08:31:45 -0800246 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000247 transmission_time_offset_ = transmission_time_offset;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000248 return 0;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000249}
250
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000251int32_t RTPSender::SetAbsoluteSendTime(uint32_t absolute_send_time) {
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000252 if (absolute_send_time > 0xffffff) { // UWord24.
253 return -1;
254 }
tommiae695e92016-02-02 08:31:45 -0800255 rtc::CritScope lock(&send_critsect_);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000256 absolute_send_time_ = absolute_send_time;
257 return 0;
258}
259
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000260void RTPSender::SetVideoRotation(VideoRotation rotation) {
tommiae695e92016-02-02 08:31:45 -0800261 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000262 rotation_ = rotation;
263}
264
sprang@webrtc.org30933902015-03-17 14:33:12 +0000265int32_t RTPSender::SetTransportSequenceNumber(uint16_t sequence_number) {
tommiae695e92016-02-02 08:31:45 -0800266 rtc::CritScope lock(&send_critsect_);
sprang@webrtc.org30933902015-03-17 14:33:12 +0000267 transport_sequence_number_ = sequence_number;
268 return 0;
269}
270
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000271int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type,
272 uint8_t id) {
tommiae695e92016-02-02 08:31:45 -0800273 rtc::CritScope lock(&send_critsect_);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700274 if (type == kRtpExtensionVideoRotation) {
275 cvo_mode_ = kCVOInactive;
276 return rtp_header_extension_map_.RegisterInactive(type, id);
277 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000278 return rtp_header_extension_map_.Register(type, id);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000279}
280
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000281bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800282 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000283 return rtp_header_extension_map_.IsRegistered(type);
284}
285
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000286int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) {
tommiae695e92016-02-02 08:31:45 -0800287 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000288 return rtp_header_extension_map_.Deregister(type);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000289}
290
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000291size_t RTPSender::RtpHeaderExtensionTotalLength() const {
tommiae695e92016-02-02 08:31:45 -0800292 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000293 return rtp_header_extension_map_.GetTotalLengthInBytes();
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000294}
295
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000296int32_t RTPSender::RegisterPayload(
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000297 const char payload_name[RTP_PAYLOAD_NAME_SIZE],
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000298 int8_t payload_number,
299 uint32_t frequency,
Peter Kasting69558702016-01-12 16:26:35 -0800300 size_t channels,
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000301 uint32_t rate) {
Peter Boström8b79b072016-02-26 16:31:37 +0100302 RTC_DCHECK_LT(strlen(payload_name), RTP_PAYLOAD_NAME_SIZE);
tommiae695e92016-02-02 08:31:45 -0800303 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000304
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000305 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000306 payload_type_map_.find(payload_number);
niklase@google.com470e71d2011-07-07 08:21:25 +0000307
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000308 if (payload_type_map_.end() != it) {
309 // We already use this payload type.
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000310 RtpUtility::Payload* payload = it->second;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000311 assert(payload);
niklase@google.com470e71d2011-07-07 08:21:25 +0000312
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000313 // Check if it's the same as we already have.
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000314 if (RtpUtility::StringCompare(
315 payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1)) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000316 if (audio_configured_ && payload->audio &&
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000317 payload->typeSpecific.Audio.frequency == frequency &&
318 (payload->typeSpecific.Audio.rate == rate ||
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000319 payload->typeSpecific.Audio.rate == 0 || rate == 0)) {
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000320 payload->typeSpecific.Audio.rate = rate;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000321 // Ensure that we update the rate if new or old is zero.
niklase@google.com470e71d2011-07-07 08:21:25 +0000322 return 0;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000323 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000324 if (!audio_configured_ && !payload->audio) {
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000325 return 0;
326 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000327 }
328 return -1;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000329 }
mflodmanfcf54bd2015-04-14 21:28:08 +0200330 int32_t ret_val = 0;
danilchap6db6cdc2015-12-15 02:54:47 -0800331 RtpUtility::Payload* payload = nullptr;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000332 if (audio_configured_) {
mflodmanfcf54bd2015-04-14 21:28:08 +0200333 // TODO(mflodman): Change to CreateAudioPayload and make static.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000334 ret_val = audio_->RegisterAudioPayload(payload_name, payload_number,
danilchap6db6cdc2015-12-15 02:54:47 -0800335 frequency, channels, rate, &payload);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000336 } else {
Peter Boström9d0c4322016-02-16 17:59:27 +0100337 payload = video_->CreateVideoPayload(payload_name, payload_number);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000338 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000339 if (payload) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000340 payload_type_map_[payload_number] = payload;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000341 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000342 return ret_val;
niklase@google.com470e71d2011-07-07 08:21:25 +0000343}
344
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000345int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) {
tommiae695e92016-02-02 08:31:45 -0800346 rtc::CritScope lock(&send_critsect_);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000347
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000348 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000349 payload_type_map_.find(payload_type);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000350
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000351 if (payload_type_map_.end() == it) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000352 return -1;
353 }
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000354 RtpUtility::Payload* payload = it->second;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000355 delete payload;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000356 payload_type_map_.erase(it);
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000357 return 0;
358}
niklase@google.com470e71d2011-07-07 08:21:25 +0000359
andresp@webrtc.orgc3c29112014-08-27 09:39:43 +0000360void RTPSender::SetSendPayloadType(int8_t payload_type) {
tommiae695e92016-02-02 08:31:45 -0800361 rtc::CritScope lock(&send_critsect_);
andresp@webrtc.orgc3c29112014-08-27 09:39:43 +0000362 payload_type_ = payload_type;
363}
364
sprang@webrtc.orgefcad392014-03-25 16:51:35 +0000365int8_t RTPSender::SendPayloadType() const {
tommiae695e92016-02-02 08:31:45 -0800366 rtc::CritScope lock(&send_critsect_);
sprang@webrtc.orgefcad392014-03-25 16:51:35 +0000367 return payload_type_;
368}
niklase@google.com470e71d2011-07-07 08:21:25 +0000369
pbos@webrtc.org59f20bb2013-09-09 16:02:19 +0000370int RTPSender::SendPayloadFrequency() const {
371 return audio_ != NULL ? audio_->AudioFrequency() : kVideoPayloadTypeFrequency;
372}
niklase@google.com470e71d2011-07-07 08:21:25 +0000373
danilchap41befce2016-03-30 11:11:51 -0700374void RTPSender::SetMaxPayloadLength(size_t max_payload_length) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000375 // Sanity check.
henrikg91d6ede2015-09-17 00:24:34 -0700376 RTC_DCHECK(max_payload_length >= 100 && max_payload_length <= IP_PACKET_SIZE)
Peter Boströmd6f1a382015-07-14 16:08:02 +0200377 << "Invalid max payload length: " << max_payload_length;
tommiae695e92016-02-02 08:31:45 -0800378 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000379 max_payload_length_ = max_payload_length;
niklase@google.com470e71d2011-07-07 08:21:25 +0000380}
381
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000382size_t RTPSender::MaxDataPayloadLength() const {
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000383 int rtx;
384 {
tommiae695e92016-02-02 08:31:45 -0800385 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000386 rtx = rtx_;
387 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000388 if (audio_configured_) {
389 return max_payload_length_ - RTPHeaderLength();
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000390 } else {
sprang@webrtc.org346094c2014-02-18 08:40:33 +0000391 return max_payload_length_ - RTPHeaderLength() // RTP overhead.
392 - video_->FECPacketOverhead() // FEC/ULP/RED overhead.
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000393 - ((rtx) ? 2 : 0); // RTX overhead.
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000394 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000395}
396
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000397size_t RTPSender::MaxPayloadLength() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000398 return max_payload_length_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000399}
400
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000401void RTPSender::SetRtxStatus(int mode) {
tommiae695e92016-02-02 08:31:45 -0800402 rtc::CritScope lock(&send_critsect_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +0000403 rtx_ = mode;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000404}
405
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000406int RTPSender::RtxStatus() const {
tommiae695e92016-02-02 08:31:45 -0800407 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000408 return rtx_;
409}
410
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000411void RTPSender::SetRtxSsrc(uint32_t ssrc) {
tommiae695e92016-02-02 08:31:45 -0800412 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000413 ssrc_rtx_ = ssrc;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000414}
415
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000416uint32_t RTPSender::RtxSsrc() const {
tommiae695e92016-02-02 08:31:45 -0800417 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000418 return ssrc_rtx_;
419}
420
Shao Changbine62202f2015-04-21 20:24:50 +0800421void RTPSender::SetRtxPayloadType(int payload_type,
422 int associated_payload_type) {
tommiae695e92016-02-02 08:31:45 -0800423 rtc::CritScope lock(&send_critsect_);
henrikg91d6ede2015-09-17 00:24:34 -0700424 RTC_DCHECK_LE(payload_type, 127);
425 RTC_DCHECK_LE(associated_payload_type, 127);
Shao Changbine62202f2015-04-21 20:24:50 +0800426 if (payload_type < 0) {
427 LOG(LS_ERROR) << "Invalid RTX payload type: " << payload_type;
428 return;
429 }
430
431 rtx_payload_type_map_[associated_payload_type] = payload_type;
Ă…sa Persson6ae25722015-04-13 17:48:08 +0200432}
433
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000434int32_t RTPSender::CheckPayloadType(int8_t payload_type,
435 RtpVideoCodecTypes* video_type) {
tommiae695e92016-02-02 08:31:45 -0800436 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000437
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000438 if (payload_type < 0) {
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000439 LOG(LS_ERROR) << "Invalid payload_type " << payload_type;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000440 return -1;
441 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000442 if (audio_configured_) {
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000443 int8_t red_pl_type = -1;
danilchap6db6cdc2015-12-15 02:54:47 -0800444 if (audio_->RED(&red_pl_type) == 0) {
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000445 // We have configured RED.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000446 if (red_pl_type == payload_type) {
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000447 // And it's a match...
448 return 0;
449 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000450 }
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000451 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000452 if (payload_type_ == payload_type) {
453 if (!audio_configured_) {
454 *video_type = video_->VideoCodecType();
niklase@google.com470e71d2011-07-07 08:21:25 +0000455 }
456 return 0;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000457 }
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000458 std::map<int8_t, RtpUtility::Payload*>::iterator it =
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000459 payload_type_map_.find(payload_type);
460 if (it == payload_type_map_.end()) {
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100461 LOG(LS_WARNING) << "Payload type " << static_cast<int>(payload_type)
462 << " not registered.";
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000463 return -1;
464 }
andresp@webrtc.orgc3c29112014-08-27 09:39:43 +0000465 SetSendPayloadType(payload_type);
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000466 RtpUtility::Payload* payload = it->second;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000467 assert(payload);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000468 if (!payload->audio && !audio_configured_) {
469 video_->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType);
470 *video_type = payload->typeSpecific.Video.videoCodecType;
pwestin@webrtc.org00741872012-01-19 15:56:10 +0000471 }
472 return 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000473}
474
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700475RTPSenderInterface::CVOMode RTPSender::ActivateCVORtpHeaderExtension() {
476 if (cvo_mode_ == kCVOInactive) {
tommiae695e92016-02-02 08:31:45 -0800477 rtc::CritScope lock(&send_critsect_);
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -0700478 if (rtp_header_extension_map_.SetActive(kRtpExtensionVideoRotation, true)) {
479 cvo_mode_ = kCVOActivated;
480 }
481 }
482 return cvo_mode_;
483}
484
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000485int32_t RTPSender::SendOutgoingData(FrameType frame_type,
486 int8_t payload_type,
487 uint32_t capture_timestamp,
488 int64_t capture_time_ms,
489 const uint8_t* payload_data,
490 size_t payload_size,
491 const RTPFragmentationHeader* fragmentation,
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000492 const RTPVideoHeader* rtp_hdr) {
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000493 uint32_t ssrc;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000494 {
495 // Drop this packet if we're not sending media packets.
tommiae695e92016-02-02 08:31:45 -0800496 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000497 ssrc = ssrc_;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000498 if (!sending_media_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000499 return 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000500 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000501 }
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000502 RtpVideoCodecTypes video_type = kRtpVideoGeneric;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000503 if (CheckPayloadType(payload_type, &video_type) != 0) {
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100504 LOG(LS_ERROR) << "Don't send data with unknown payload type: "
505 << static_cast<int>(payload_type) << ".";
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000506 return -1;
507 }
508
Peter Boströmd6f1a382015-07-14 16:08:02 +0200509 int32_t ret_val;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000510 if (audio_configured_) {
hclam@chromium.org1a7b9b92013-07-08 21:31:18 +0000511 TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", capture_timestamp,
512 "Send", "type", FrameTypeToString(frame_type));
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000513 assert(frame_type == kAudioFrameSpeech || frame_type == kAudioFrameCN ||
pbos22993e12015-10-19 02:39:06 -0700514 frame_type == kEmptyFrame);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000515
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000516 ret_val = audio_->SendAudio(frame_type, payload_type, capture_timestamp,
517 payload_data, payload_size, fragmentation);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000518 } else {
hclam@chromium.org1a7b9b92013-07-08 21:31:18 +0000519 TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms,
520 "Send", "type", FrameTypeToString(frame_type));
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000521 assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000522
pbos22993e12015-10-19 02:39:06 -0700523 if (frame_type == kEmptyFrame)
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000524 return 0;
525
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000526 ret_val =
527 video_->SendVideo(video_type, frame_type, payload_type,
528 capture_timestamp, capture_time_ms, payload_data,
mflodmanfcf54bd2015-04-14 21:28:08 +0200529 payload_size, fragmentation, rtp_hdr);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +0000530 }
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000531
danilchap7c9426c2016-04-14 03:05:31 -0700532 rtc::CritScope cs(&statistics_crit_);
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000533 // Note: This is currently only counting for video.
534 if (frame_type == kVideoFrameKey) {
535 ++frame_counts_.key_frames;
536 } else if (frame_type == kVideoFrameDelta) {
537 ++frame_counts_.delta_frames;
538 }
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000539 if (frame_count_observer_) {
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000540 frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
sprang@webrtc.org71f055f2013-12-04 15:09:27 +0000541 }
542
543 return ret_val;
niklase@google.com470e71d2011-07-07 08:21:25 +0000544}
545
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000546size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000547 {
tommiae695e92016-02-02 08:31:45 -0800548 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100549 if (!sending_media_)
550 return 0;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000551 if ((rtx_ & kRtxRedundantPayloads) == 0)
552 return 0;
553 }
554
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000555 uint8_t buffer[IP_PACKET_SIZE];
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000556 int bytes_left = static_cast<int>(bytes_to_send);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000557 while (bytes_left > 0) {
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000558 size_t length = bytes_left;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000559 int64_t capture_time_ms;
560 if (!packet_history_.GetBestFittingPacket(buffer, &length,
561 &capture_time_ms)) {
562 break;
563 }
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000564 if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false))
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000565 break;
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000566 RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000567 RTPHeader rtp_header;
danilchapf6975f42015-12-28 10:18:46 -0800568 rtp_parser.Parse(&rtp_header);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000569 bytes_left -= static_cast<int>(length - rtp_header.headerLength);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000570 }
571 return bytes_to_send - bytes_left;
572}
573
Stefan Holmer586b19b2015-09-18 11:14:31 +0200574void RTPSender::BuildPaddingPacket(uint8_t* packet,
575 size_t header_length,
576 size_t padding_length) {
stefan@webrtc.orga8179622013-06-04 13:47:36 +0000577 packet[0] |= 0x20; // Set padding bit.
danilchapf6975f42015-12-28 10:18:46 -0800578 int32_t* data = reinterpret_cast<int32_t*>(&(packet[header_length]));
stefan@webrtc.orga8179622013-06-04 13:47:36 +0000579
580 // Fill data buffer with random data.
Stefan Holmer586b19b2015-09-18 11:14:31 +0200581 for (size_t j = 0; j < (padding_length >> 2); ++j) {
stefan@webrtc.orga8179622013-06-04 13:47:36 +0000582 data[j] = rand(); // NOLINT
583 }
584 // Set number of padding bytes in the last byte of the packet.
Stefan Holmer586b19b2015-09-18 11:14:31 +0200585 packet[header_length + padding_length - 1] =
586 static_cast<uint8_t>(padding_length);
stefan@webrtc.orga8179622013-06-04 13:47:36 +0000587}
588
Stefan Holmer586b19b2015-09-18 11:14:31 +0200589size_t RTPSender::SendPadData(size_t bytes,
590 bool timestamp_provided,
591 uint32_t timestamp,
592 int64_t capture_time_ms) {
sprangebbf8a82015-09-21 15:11:14 -0700593 // Always send full padding packets. This is accounted for by the
594 // RtpPacketSender,
Stefan Holmer586b19b2015-09-18 11:14:31 +0200595 // which will make sure we don't send too much padding even if a single packet
596 // is larger than requested.
597 size_t padding_bytes_in_packet =
598 std::min(MaxDataPayloadLength(), kMaxPaddingLength);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000599 size_t bytes_sent = 0;
sprang867fb522015-08-03 04:38:41 -0700600 bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
601 kRtpExtensionTransportSequenceNumber) &&
sprangebbf8a82015-09-21 15:11:14 -0700602 transport_sequence_number_allocator_;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000603 for (; bytes > 0; bytes -= padding_bytes_in_packet) {
Stefan Holmer586b19b2015-09-18 11:14:31 +0200604 if (bytes < padding_bytes_in_packet)
605 bytes = padding_bytes_in_packet;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000606
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000607 uint32_t ssrc;
608 uint16_t sequence_number;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000609 int payload_type;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000610 bool over_rtx;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000611 {
tommiae695e92016-02-02 08:31:45 -0800612 rtc::CritScope lock(&send_critsect_);
Peter Boströmfc968a22016-02-19 16:14:37 +0100613 if (!sending_media_)
614 return bytes_sent;
Stefan Holmer586b19b2015-09-18 11:14:31 +0200615 if (!timestamp_provided) {
616 timestamp = timestamp_;
617 capture_time_ms = capture_time_ms_;
618 }
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000619 if (rtx_ == kRtxOff) {
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000620 // Without RTX we can't send padding in the middle of frames.
621 if (!last_packet_marker_bit_)
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000622 return 0;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000623 ssrc = ssrc_;
624 sequence_number = sequence_number_;
625 ++sequence_number_;
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000626 payload_type = payload_type_;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000627 over_rtx = false;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000628 } else {
Stefan Holmerf5dca482016-01-27 12:58:51 +0100629 // Without abs-send-time or transport sequence number a media packet
630 // must be sent before padding so that the timestamps used for
631 // estimation are correct.
632 if (!media_has_been_sent_ &&
633 !(rtp_header_extension_map_.IsRegistered(
634 kRtpExtensionAbsoluteSendTime) ||
635 using_transport_seq)) {
andresp@webrtc.org817a0342014-08-14 08:24:47 +0000636 return 0;
Stefan Holmerf5dca482016-01-27 12:58:51 +0100637 }
Stefan Holmer586b19b2015-09-18 11:14:31 +0200638 // Only change change the timestamp of padding packets sent over RTX.
639 // Padding only packets over RTP has to be sent as part of a media
640 // frame (and therefore the same timestamp).
641 if (last_timestamp_time_ms_ > 0) {
642 timestamp +=
643 (clock_->TimeInMilliseconds() - last_timestamp_time_ms_) * 90;
644 capture_time_ms +=
645 (clock_->TimeInMilliseconds() - last_timestamp_time_ms_);
646 }
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000647 ssrc = ssrc_rtx_;
648 sequence_number = sequence_number_rtx_;
649 ++sequence_number_rtx_;
Stefan Holmer10880012016-02-03 13:29:59 +0100650 payload_type = rtx_payload_type_map_.begin()->second;
pbos@webrtc.org63c60ed2014-07-16 09:37:29 +0000651 over_rtx = true;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000652 }
653 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000654
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +0000655 uint8_t padding_packet[IP_PACKET_SIZE];
pbos@webrtc.org9334ac22014-11-24 08:25:50 +0000656 size_t header_length =
657 CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp,
658 sequence_number, std::vector<uint32_t>());
Stefan Holmer586b19b2015-09-18 11:14:31 +0200659 BuildPaddingPacket(padding_packet, header_length, padding_bytes_in_packet);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000660 size_t length = padding_bytes_in_packet + header_length;
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000661 int64_t now_ms = clock_->TimeInMilliseconds();
662
663 RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length);
664 RTPHeader rtp_header;
danilchapf6975f42015-12-28 10:18:46 -0800665 rtp_parser.Parse(&rtp_header);
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000666
667 if (capture_time_ms > 0) {
668 UpdateTransmissionTimeOffset(
669 padding_packet, length, rtp_header, now_ms - capture_time_ms);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000670 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000671
672 UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms);
sprang867fb522015-08-03 04:38:41 -0700673
stefan1d8a5062015-10-02 03:39:33 -0700674 PacketOptions options;
sprang867fb522015-08-03 04:38:41 -0700675 if (using_transport_seq) {
stefan1d8a5062015-10-02 03:39:33 -0700676 options.packet_id =
sprang867fb522015-08-03 04:38:41 -0700677 UpdateTransportSequenceNumber(padding_packet, length, rtp_header);
678 }
679
sprang5e023eb2015-09-14 06:42:43 -0700680 if (using_transport_seq && transport_feedback_observer_) {
stefanbbe876f2015-10-23 02:05:40 -0700681 transport_feedback_observer_->AddPacket(options.packet_id, length, true);
sprang5e023eb2015-09-14 06:42:43 -0700682 }
sprang867fb522015-08-03 04:38:41 -0700683
stefanf116bd02015-10-27 08:29:42 -0700684 if (!SendPacketToNetwork(padding_packet, length, options))
685 break;
686
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000687 bytes_sent += padding_bytes_in_packet;
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000688 UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false);
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000689 }
pbos@webrtc.org72491b92014-07-10 16:24:54 +0000690
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000691 return bytes_sent;
pwestin@webrtc.org12d97f62012-01-05 10:54:44 +0000692}
693
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000694void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000695 packet_history_.SetStorePacketsStatus(enable, number_to_store);
niklase@google.com470e71d2011-07-07 08:21:25 +0000696}
697
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000698bool RTPSender::StorePackets() const {
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000699 return packet_history_.StorePackets();
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000700}
niklase@google.com470e71d2011-07-07 08:21:25 +0000701
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000702int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) {
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000703 size_t length = IP_PACKET_SIZE;
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000704 uint8_t data_buffer[IP_PACKET_SIZE];
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000705 int64_t capture_time_ms;
sprang861c55e2015-10-16 10:01:21 -0700706
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000707 if (!packet_history_.GetPacketAndSetSendTime(packet_id, min_resend_time, true,
708 data_buffer, &length,
709 &capture_time_ms)) {
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000710 // Packet not found.
asapersson@webrtc.org83ed0a42012-04-23 12:43:05 +0000711 return 0;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000712 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000713
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000714 if (paced_sender_) {
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000715 RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length);
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000716 RTPHeader header;
danilchapf6975f42015-12-28 10:18:46 -0800717 if (!rtp_parser.Parse(&header)) {
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000718 assert(false);
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000719 return -1;
720 }
stefan@webrtc.org88e0dda2014-07-04 09:20:42 +0000721 // Convert from TickTime to Clock since capture_time_ms is based on
722 // TickTime.
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000723 int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_;
Peter Boströme23e7372015-10-08 11:44:14 +0200724 paced_sender_->InsertPacket(
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100725 RtpPacketSender::kNormalPriority, header.ssrc, header.sequenceNumber,
Peter Boströme23e7372015-10-08 11:44:14 +0200726 corrected_capture_tims_ms, length - header.headerLength, true);
727
728 return length;
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000729 }
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000730 int rtx = kRtxOff;
731 {
tommiae695e92016-02-02 08:31:45 -0800732 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000733 rtx = rtx_;
734 }
sprang867fb522015-08-03 04:38:41 -0700735 if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms,
736 (rtx & kRtxRetransmitted) > 0, true)) {
737 return -1;
738 }
739 return static_cast<int32_t>(length);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000740}
741
stefan1d8a5062015-10-02 03:39:33 -0700742bool RTPSender::SendPacketToNetwork(const uint8_t* packet,
743 size_t size,
744 const PacketOptions& options) {
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000745 int bytes_sent = -1;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000746 if (transport_) {
stefan1d8a5062015-10-02 03:39:33 -0700747 bytes_sent = transport_->SendRtp(packet, size, options)
748 ? static_cast<int>(size)
749 : -1;
terelius429c3452016-01-21 05:42:04 -0800750 if (event_log_ && bytes_sent > 0) {
751 event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet, size);
752 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000753 }
sprang@webrtc.org0200f702015-02-16 12:06:00 +0000754 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
755 "RTPSender::SendPacketToNetwork", "size", size, "sent",
756 bytes_sent);
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000757 // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000758 if (bytes_sent <= 0) {
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000759 LOG(LS_WARNING) << "Transport failed to send packet";
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000760 return false;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000761 }
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000762 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000763}
764
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000765int RTPSender::SelectiveRetransmissions() const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000766 if (!video_)
767 return -1;
768 return video_->SelectiveRetransmissions();
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000769}
770
771int RTPSender::SetSelectiveRetransmissions(uint8_t settings) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000772 if (!video_)
773 return -1;
mflodmanfcf54bd2015-04-14 21:28:08 +0200774 video_->SetSelectiveRetransmissions(settings);
775 return 0;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000776}
777
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000778void RTPSender::OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers,
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000779 int64_t avg_rtt) {
sprang@webrtc.org0200f702015-02-16 12:06:00 +0000780 TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
781 "RTPSender::OnReceivedNACK", "num_seqnum",
782 nack_sequence_numbers.size(), "avg_rtt", avg_rtt);
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000783 const int64_t now = clock_->TimeInMilliseconds();
stefan@webrtc.org11d81762014-12-19 09:52:24 +0000784 uint32_t bytes_re_sent = 0;
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000785 uint32_t target_bitrate = GetTargetBitrate();
niklase@google.com470e71d2011-07-07 08:21:25 +0000786
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000787 // Enough bandwidth to send NACK?
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000788 if (!ProcessNACKBitRate(now)) {
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000789 LOG(LS_INFO) << "NACK bitrate reached. Skip sending NACK response. Target "
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000790 << target_bitrate;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000791 return;
792 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000793
stefan@webrtc.orgbecf9c82013-02-01 15:09:57 +0000794 for (std::list<uint16_t>::const_iterator it = nack_sequence_numbers.begin();
795 it != nack_sequence_numbers.end(); ++it) {
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000796 const int32_t bytes_sent = ReSendPacket(*it, 5 + avg_rtt);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000797 if (bytes_sent > 0) {
798 bytes_re_sent += bytes_sent;
799 } else if (bytes_sent == 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000800 // The packet has previously been resent.
801 // Try resending next packet in the list.
802 continue;
stefan@webrtc.org11d81762014-12-19 09:52:24 +0000803 } else {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000804 // Failed to send one Sequence number. Give up the rest in this nack.
andresp@webrtc.orgdc80bae2014-04-08 11:06:12 +0000805 LOG(LS_WARNING) << "Failed resending RTP packet " << *it
806 << ", Discard rest of packets";
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000807 break;
niklase@google.com470e71d2011-07-07 08:21:25 +0000808 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000809 // Delay bandwidth estimate (RTT * BW).
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000810 if (target_bitrate != 0 && avg_rtt) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000811 // kbits/s * ms = bits => bits/8 = bytes
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000812 size_t target_bytes =
813 (static_cast<size_t>(target_bitrate / 1000) * avg_rtt) >> 3;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000814 if (bytes_re_sent > target_bytes) {
815 break; // Ignore the rest of the packets in the list.
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000816 }
817 }
818 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000819 if (bytes_re_sent > 0) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000820 UpdateNACKBitRate(bytes_re_sent, now);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000821 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000822}
823
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000824bool RTPSender::ProcessNACKBitRate(uint32_t now) {
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000825 uint32_t num = 0;
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000826 size_t byte_count = 0;
henrike@webrtc.orgfe526ff2014-06-25 20:59:51 +0000827 const uint32_t kAvgIntervalMs = 1000;
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000828 uint32_t target_bitrate = GetTargetBitrate();
niklase@google.com470e71d2011-07-07 08:21:25 +0000829
tommiae695e92016-02-02 08:31:45 -0800830 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000831
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000832 if (target_bitrate == 0) {
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000833 return true;
834 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000835 for (num = 0; num < NACK_BYTECOUNT_SIZE; ++num) {
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +0000836 if ((now - nack_byte_count_times_[num]) > kAvgIntervalMs) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000837 // Don't use data older than 1sec.
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000838 break;
839 } else {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000840 byte_count += nack_byte_count_[num];
niklase@google.com470e71d2011-07-07 08:21:25 +0000841 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000842 }
henrike@webrtc.orgfe526ff2014-06-25 20:59:51 +0000843 uint32_t time_interval = kAvgIntervalMs;
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000844 if (num == NACK_BYTECOUNT_SIZE) {
845 // More than NACK_BYTECOUNT_SIZE nack messages has been received
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000846 // during the last msg_interval.
henrike@webrtc.orgfe526ff2014-06-25 20:59:51 +0000847 if (nack_byte_count_times_[num - 1] <= now) {
848 time_interval = now - nack_byte_count_times_[num - 1];
niklase@google.com470e71d2011-07-07 08:21:25 +0000849 }
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000850 }
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000851 return (byte_count * 8) < (target_bitrate / 1000 * time_interval);
niklase@google.com470e71d2011-07-07 08:21:25 +0000852}
853
stefan@webrtc.org11d81762014-12-19 09:52:24 +0000854void RTPSender::UpdateNACKBitRate(uint32_t bytes, int64_t now) {
tommiae695e92016-02-02 08:31:45 -0800855 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org11d81762014-12-19 09:52:24 +0000856 if (bytes == 0)
857 return;
858 nack_bitrate_.Update(bytes);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +0000859 // Save bitrate statistics.
stefan@webrtc.org11d81762014-12-19 09:52:24 +0000860 // Shift all but first time.
861 for (int i = NACK_BYTECOUNT_SIZE - 2; i >= 0; i--) {
862 nack_byte_count_[i + 1] = nack_byte_count_[i];
863 nack_byte_count_times_[i + 1] = nack_byte_count_times_[i];
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000864 }
stefan@webrtc.org11d81762014-12-19 09:52:24 +0000865 nack_byte_count_[0] = bytes;
866 nack_byte_count_times_[0] = now;
niklase@google.com470e71d2011-07-07 08:21:25 +0000867}
868
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000869// Called from pacer when we can send the packet.
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000870bool RTPSender::TimeToSendPacket(uint16_t sequence_number,
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000871 int64_t capture_time_ms,
872 bool retransmission) {
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000873 size_t length = IP_PACKET_SIZE;
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +0000874 uint8_t data_buffer[IP_PACKET_SIZE];
pwestin@webrtc.orgb0061f92013-04-27 00:41:08 +0000875 int64_t stored_time_ms;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000876
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000877 if (!packet_history_.GetPacketAndSetSendTime(sequence_number,
878 0,
879 retransmission,
880 data_buffer,
881 &length,
882 &stored_time_ms)) {
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000883 // Packet cannot be found. Allow sending to continue.
884 return true;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000885 }
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +0000886 if (!retransmission && capture_time_ms > 0) {
887 UpdateDelayStatistics(capture_time_ms, clock_->TimeInMilliseconds());
888 }
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000889 int rtx;
890 {
tommiae695e92016-02-02 08:31:45 -0800891 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000892 rtx = rtx_;
893 }
894 return PrepareAndSendPacket(data_buffer,
895 length,
896 capture_time_ms,
897 retransmission && (rtx & kRtxRetransmitted) > 0,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000898 retransmission);
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000899}
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000900
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000901bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000902 size_t length,
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000903 int64_t capture_time_ms,
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000904 bool send_over_rtx,
905 bool is_retransmit) {
danilchapf6975f42015-12-28 10:18:46 -0800906 uint8_t* buffer_to_send_ptr = buffer;
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000907
pbos@webrtc.org62bafae2014-07-08 12:10:51 +0000908 RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +0000909 RTPHeader rtp_header;
danilchapf6975f42015-12-28 10:18:46 -0800910 rtp_parser.Parse(&rtp_header);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000911 if (!is_retransmit && rtp_header.markerBit) {
sprang@webrtc.org0200f702015-02-16 12:06:00 +0000912 TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
913 capture_time_ms);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000914 }
915
sprang@webrtc.org0200f702015-02-16 12:06:00 +0000916 TRACE_EVENT_INSTANT2(
917 TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PrepareAndSendPacket",
918 "timestamp", rtp_header.timestamp, "seqnum", rtp_header.sequenceNumber);
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000919
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000920 uint8_t data_buffer_rtx[IP_PACKET_SIZE];
stefan@webrtc.org7e9315b2013-12-04 10:24:26 +0000921 if (send_over_rtx) {
922 BuildRtxPacket(buffer, &length, data_buffer_rtx);
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000923 buffer_to_send_ptr = data_buffer_rtx;
924 }
925
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +0000926 int64_t now_ms = clock_->TimeInMilliseconds();
927 int64_t diff_ms = now_ms - capture_time_ms;
stefan@webrtc.org420b2562014-05-30 12:17:15 +0000928 UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header,
929 diff_ms);
930 UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms);
sprang867fb522015-08-03 04:38:41 -0700931
sprang5e023eb2015-09-14 06:42:43 -0700932 // TODO(sprang): Potentially too much overhead in IsRegistered()?
sprang867fb522015-08-03 04:38:41 -0700933 bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
934 kRtpExtensionTransportSequenceNumber) &&
sprang861c55e2015-10-16 10:01:21 -0700935 transport_sequence_number_allocator_;
936
stefan1d8a5062015-10-02 03:39:33 -0700937 PacketOptions options;
sprang867fb522015-08-03 04:38:41 -0700938 if (using_transport_seq) {
stefan1d8a5062015-10-02 03:39:33 -0700939 options.packet_id =
sprang867fb522015-08-03 04:38:41 -0700940 UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header);
941 }
942
stefanf116bd02015-10-27 08:29:42 -0700943 if (using_transport_seq && transport_feedback_observer_) {
944 transport_feedback_observer_->AddPacket(options.packet_id, length, true);
945 }
946
stefan1d8a5062015-10-02 03:39:33 -0700947 bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000948 if (ret) {
tommiae695e92016-02-02 08:31:45 -0800949 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +0000950 media_has_been_sent_ = true;
951 }
stefan@webrtc.org7c6ff2d2014-03-19 18:14:52 +0000952 UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx,
953 is_retransmit);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000954 return ret;
955}
956
957void RTPSender::UpdateRtpStats(const uint8_t* buffer,
asapersson@webrtc.org97d04892014-12-09 09:47:53 +0000958 size_t packet_length,
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000959 const RTPHeader& header,
960 bool is_rtx,
961 bool is_retransmit) {
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000962 StreamDataCounters* counters;
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000963 // Get ssrc before taking statistics_crit_ to avoid possible deadlock.
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000964 uint32_t ssrc = is_rtx ? RtxSsrc() : SSRC();
sprang@webrtc.org5314e852014-01-27 13:20:36 +0000965
danilchap7c9426c2016-04-14 03:05:31 -0700966 rtc::CritScope lock(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000967 if (is_rtx) {
968 counters = &rtx_rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000969 } else {
970 counters = &rtp_stats_;
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000971 }
972
asapersson@webrtc.org97d04892014-12-09 09:47:53 +0000973 total_bitrate_sent_.Update(packet_length);
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000974
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +0000975 if (counters->first_packet_time_ms == -1) {
asapersson@webrtc.orgd08d3892014-12-16 12:03:11 +0000976 counters->first_packet_time_ms = clock_->TimeInMilliseconds();
977 }
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000978 if (IsFecPacket(buffer, header)) {
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000979 counters->fec.AddPacket(packet_length, header);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000980 }
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000981 if (is_retransmit) {
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000982 counters->retransmitted.AddPacket(packet_length, header);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000983 }
asapersson@webrtc.org44149392015-02-04 08:34:47 +0000984 counters->transmitted.AddPacket(packet_length, header);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000985
986 if (rtp_stats_callback_) {
987 rtp_stats_callback_->DataCountersUpdated(*counters, ssrc);
988 }
989}
990
991bool RTPSender::IsFecPacket(const uint8_t* buffer,
992 const RTPHeader& header) const {
993 if (!video_) {
994 return false;
995 }
996 bool fec_enabled;
997 uint8_t pt_red;
998 uint8_t pt_fec;
danilchap6db6cdc2015-12-15 02:54:47 -0800999 video_->GenericFECStatus(&fec_enabled, &pt_red, &pt_fec);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001000 return fec_enabled &&
1001 header.payloadType == pt_red &&
1002 buffer[header.headerLength] == pt_fec;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +00001003}
1004
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +00001005size_t RTPSender::TimeToSendPadding(size_t bytes) {
Stefan Holmerb86d4e42015-12-07 10:26:18 +01001006 if (audio_configured_ || bytes == 0)
pbos545727e2015-07-01 06:31:06 -07001007 return 0;
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +00001008 size_t bytes_sent = TrySendRedundantPayloads(bytes);
1009 if (bytes_sent < bytes)
Stefan Holmer586b19b2015-09-18 11:14:31 +02001010 bytes_sent += SendPadData(bytes - bytes_sent, false, 0, 0);
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +00001011 return bytes_sent;
stefan@webrtc.org508a84b2013-06-17 12:53:37 +00001012}
1013
pbos@webrtc.org62bafae2014-07-08 12:10:51 +00001014// TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
sprangebbf8a82015-09-21 15:11:14 -07001015int32_t RTPSender::SendToNetwork(uint8_t* buffer,
1016 size_t payload_length,
1017 size_t rtp_header_length,
1018 int64_t capture_time_ms,
1019 StorageType storage,
1020 RtpPacketSender::Priority priority) {
terelius429c3452016-01-21 05:42:04 -08001021 size_t length = payload_length + rtp_header_length;
1022 RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
1023
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +00001024 RTPHeader rtp_header;
danilchapf6975f42015-12-28 10:18:46 -08001025 rtp_parser.Parse(&rtp_header);
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +00001026
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001027 int64_t now_ms = clock_->TimeInMilliseconds();
1028
stefan@webrtc.org715faaf2012-08-28 15:20:39 +00001029 // |capture_time_ms| <= 0 is considered invalid.
1030 // TODO(holmer): This should be changed all over Video Engine so that negative
1031 // time is consider invalid, while 0 is considered a valid time.
1032 if (capture_time_ms > 0) {
terelius429c3452016-01-21 05:42:04 -08001033 UpdateTransmissionTimeOffset(buffer, length, rtp_header,
1034 now_ms - capture_time_ms);
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +00001035 }
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001036
terelius429c3452016-01-21 05:42:04 -08001037 UpdateAbsoluteSendTime(buffer, length, rtp_header, now_ms);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001038
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +00001039 // Used for NACK and to spread out the transmission of packets.
terelius429c3452016-01-21 05:42:04 -08001040 if (packet_history_.PutRTPPacket(buffer, length, capture_time_ms, storage) !=
1041 0) {
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +00001042 return -1;
1043 }
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001044
Peter Boströme23e7372015-10-08 11:44:14 +02001045 if (paced_sender_) {
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +00001046 // Correct offset between implementations of millisecond time stamps in
1047 // TickTime and Clock.
1048 int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_;
Peter Boströme23e7372015-10-08 11:44:14 +02001049 paced_sender_->InsertPacket(priority, rtp_header.ssrc,
1050 rtp_header.sequenceNumber, corrected_time_ms,
1051 payload_length, false);
1052 if (last_capture_time_ms_sent_ == 0 ||
1053 corrected_time_ms > last_capture_time_ms_sent_) {
1054 last_capture_time_ms_sent_ = corrected_time_ms;
1055 TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
1056 "PacedSend", corrected_time_ms,
1057 "capture_time_ms", corrected_time_ms);
asapersson@webrtc.orge5b49a02012-11-06 13:09:39 +00001058 }
Peter Boströme23e7372015-10-08 11:44:14 +02001059 return 0;
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +00001060 }
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001061 if (capture_time_ms > 0) {
1062 UpdateDelayStatistics(capture_time_ms, now_ms);
1063 }
sprang@webrtc.org43c88392015-01-29 09:09:17 +00001064
Stefan Holmerf5dca482016-01-27 12:58:51 +01001065 // TODO(sprang): Potentially too much overhead in IsRegistered()?
1066 bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
1067 kRtpExtensionTransportSequenceNumber) &&
1068 transport_sequence_number_allocator_;
1069
1070 PacketOptions options;
1071 if (using_transport_seq) {
1072 options.packet_id =
1073 UpdateTransportSequenceNumber(buffer, length, rtp_header);
1074 if (transport_feedback_observer_) {
1075 transport_feedback_observer_->AddPacket(options.packet_id, length, true);
1076 }
1077 }
1078
1079 bool sent = SendPacketToNetwork(buffer, length, options);
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +00001080
Peter Boströme23e7372015-10-08 11:44:14 +02001081 // Mark the packet as sent in the history even if send failed. Dropping a
1082 // packet here should be treated as any other packet drop so we should be
1083 // ready for a retransmission.
1084 packet_history_.SetSent(rtp_header.sequenceNumber);
1085
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +00001086 if (!sent)
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001087 return -1;
sprang@webrtc.orgc957ffc2015-02-02 13:08:02 +00001088
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001089 {
tommiae695e92016-02-02 08:31:45 -08001090 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001091 media_has_been_sent_ = true;
1092 }
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001093 UpdateRtpStats(buffer, length, rtp_header, false, false);
1094 return 0;
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +00001095}
1096
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001097void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) {
Peter Boström71861a02015-05-28 14:45:36 +02001098 if (!send_side_delay_observer_)
1099 return;
1100
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001101 uint32_t ssrc;
1102 int avg_delay_ms = 0;
1103 int max_delay_ms = 0;
1104 {
tommiae695e92016-02-02 08:31:45 -08001105 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001106 ssrc = ssrc_;
1107 }
1108 {
danilchap7c9426c2016-04-14 03:05:31 -07001109 rtc::CritScope cs(&statistics_crit_);
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001110 // TODO(holmer): Compute this iteratively instead.
1111 send_delays_[now_ms] = now_ms - capture_time_ms;
1112 send_delays_.erase(send_delays_.begin(),
1113 send_delays_.lower_bound(now_ms -
1114 kSendSideDelayWindowMs));
Peter Boström71861a02015-05-28 14:45:36 +02001115 int num_delays = 0;
1116 for (auto it = send_delays_.upper_bound(now_ms - kSendSideDelayWindowMs);
1117 it != send_delays_.end(); ++it) {
1118 max_delay_ms = std::max(max_delay_ms, it->second);
1119 avg_delay_ms += it->second;
1120 ++num_delays;
1121 }
1122 if (num_delays == 0)
1123 return;
1124 avg_delay_ms = (avg_delay_ms + num_delays / 2) / num_delays;
stefan@webrtc.org168f23f2014-07-11 13:44:02 +00001125 }
Peter Boström71861a02015-05-28 14:45:36 +02001126 send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms,
1127 ssrc);
stefan@webrtc.org0a3c1472013-12-05 14:05:07 +00001128}
1129
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001130void RTPSender::ProcessBitrate() {
tommiae695e92016-02-02 08:31:45 -08001131 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001132 total_bitrate_sent_.Process();
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001133 nack_bitrate_.Process();
1134 if (audio_configured_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001135 return;
1136 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001137 video_->ProcessBitrate();
niklase@google.com470e71d2011-07-07 08:21:25 +00001138}
1139
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +00001140size_t RTPSender::RTPHeaderLength() const {
tommiae695e92016-02-02 08:31:45 -08001141 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001142 size_t rtp_header_length = kRtpHeaderLength;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001143 rtp_header_length += sizeof(uint32_t) * csrcs_.size();
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001144 rtp_header_length += RtpHeaderExtensionTotalLength();
1145 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +00001146}
1147
mflodmanfcf54bd2015-04-14 21:28:08 +02001148uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) {
tommiae695e92016-02-02 08:31:45 -08001149 rtc::CritScope lock(&send_critsect_);
mflodmanfcf54bd2015-04-14 21:28:08 +02001150 uint16_t first_allocated_sequence_number = sequence_number_;
1151 sequence_number_ += packets_to_send;
1152 return first_allocated_sequence_number;
niklase@google.com470e71d2011-07-07 08:21:25 +00001153}
1154
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001155void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats,
1156 StreamDataCounters* rtx_stats) const {
danilchap7c9426c2016-04-14 03:05:31 -07001157 rtc::CritScope lock(&statistics_crit_);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +00001158 *rtp_stats = rtp_stats_;
1159 *rtx_stats = rtx_rtp_stats_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001160}
1161
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001162size_t RTPSender::CreateRtpHeader(uint8_t* header,
1163 int8_t payload_type,
1164 uint32_t ssrc,
1165 bool marker_bit,
1166 uint32_t timestamp,
1167 uint16_t sequence_number,
1168 const std::vector<uint32_t>& csrcs) const {
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001169 header[0] = 0x80; // version 2.
1170 header[1] = static_cast<uint8_t>(payload_type);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001171 if (marker_bit) {
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001172 header[1] |= kRtpMarkerBitMask; // Marker bit is set.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001173 }
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001174 ByteWriter<uint16_t>::WriteBigEndian(header + 2, sequence_number);
1175 ByteWriter<uint32_t>::WriteBigEndian(header + 4, timestamp);
1176 ByteWriter<uint32_t>::WriteBigEndian(header + 8, ssrc);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001177 int32_t rtp_header_length = kRtpHeaderLength;
niklase@google.com470e71d2011-07-07 08:21:25 +00001178
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001179 if (csrcs.size() > 0) {
danilchapf6975f42015-12-28 10:18:46 -08001180 uint8_t* ptr = &header[rtp_header_length];
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001181 for (size_t i = 0; i < csrcs.size(); ++i) {
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001182 ByteWriter<uint32_t>::WriteBigEndian(ptr, csrcs[i]);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001183 ptr += 4;
niklase@google.com470e71d2011-07-07 08:21:25 +00001184 }
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001185 header[0] = (header[0] & 0xf0) | csrcs.size();
niklase@google.com470e71d2011-07-07 08:21:25 +00001186
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001187 // Update length of header.
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001188 rtp_header_length += sizeof(uint32_t) * csrcs.size();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001189 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001190
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001191 uint16_t len =
1192 BuildRTPHeaderExtension(header + rtp_header_length, marker_bit);
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001193 if (len > 0) {
1194 header[0] |= 0x10; // Set extension bit.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001195 rtp_header_length += len;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001196 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001197 return rtp_header_length;
niklase@google.com470e71d2011-07-07 08:21:25 +00001198}
1199
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001200int32_t RTPSender::BuildRTPheader(uint8_t* data_buffer,
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001201 int8_t payload_type,
1202 bool marker_bit,
1203 uint32_t capture_timestamp,
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001204 int64_t capture_time_ms,
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001205 bool timestamp_provided,
1206 bool inc_sequence_number) {
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001207 assert(payload_type >= 0);
tommiae695e92016-02-02 08:31:45 -08001208 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001209
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001210 if (timestamp_provided) {
1211 timestamp_ = start_timestamp_ + capture_timestamp;
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001212 } else {
1213 // Make a unique time stamp.
1214 // We can't inc by the actual time, since then we increase the risk of back
1215 // timing.
1216 timestamp_++;
1217 }
henrik.lundin@webrtc.org6e95d7a2013-11-15 08:59:19 +00001218 last_timestamp_time_ms_ = clock_->TimeInMilliseconds();
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001219 uint32_t sequence_number = sequence_number_++;
stefan@webrtc.org8ccb9f92013-06-19 14:13:42 +00001220 capture_time_ms_ = capture_time_ms;
1221 last_packet_marker_bit_ = marker_bit;
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001222 return CreateRtpHeader(data_buffer, payload_type, ssrc_, marker_bit,
1223 timestamp_, sequence_number, csrcs_);
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001224}
1225
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001226uint16_t RTPSender::BuildRTPHeaderExtension(uint8_t* data_buffer,
1227 bool marker_bit) const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001228 if (rtp_header_extension_map_.Size() <= 0) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001229 return 0;
1230 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001231 // RTP header extension, RFC 3550.
1232 // 0 1 2 3
1233 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1234 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1235 // | defined by profile | length |
1236 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1237 // | header extension |
1238 // | .... |
1239 //
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001240 const uint32_t kPosLength = 2;
pbos@webrtc.org3004c792013-05-07 12:36:21 +00001241 const uint32_t kHeaderLength = kRtpOneByteHeaderLength;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001242
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001243 // Add extension ID (0xBEDE).
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001244 ByteWriter<uint16_t>::WriteBigEndian(data_buffer,
1245 kRtpOneByteHeaderExtensionId);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001246
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001247 // Add extensions.
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001248 uint16_t total_block_length = 0;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001249
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001250 RTPExtensionType type = rtp_header_extension_map_.First();
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001251 while (type != kRtpExtensionNone) {
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001252 uint8_t block_length = 0;
sprang@webrtc.org30933902015-03-17 14:33:12 +00001253 uint8_t* extension_data = &data_buffer[kHeaderLength + total_block_length];
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001254 switch (type) {
1255 case kRtpExtensionTransmissionTimeOffset:
sprang@webrtc.org30933902015-03-17 14:33:12 +00001256 block_length = BuildTransmissionTimeOffsetExtension(extension_data);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001257 break;
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001258 case kRtpExtensionAudioLevel:
sprang@webrtc.org30933902015-03-17 14:33:12 +00001259 block_length = BuildAudioLevelExtension(extension_data);
solenberg@webrtc.orgc0352d52013-05-20 20:55:07 +00001260 break;
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001261 case kRtpExtensionAbsoluteSendTime:
sprang@webrtc.org30933902015-03-17 14:33:12 +00001262 block_length = BuildAbsoluteSendTimeExtension(extension_data);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001263 break;
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001264 case kRtpExtensionVideoRotation:
Guo-wei Shieh64c1e8c2015-04-01 15:33:06 -07001265 block_length = BuildVideoRotationExtension(extension_data);
sprang@webrtc.org30933902015-03-17 14:33:12 +00001266 break;
1267 case kRtpExtensionTransportSequenceNumber:
sprang867fb522015-08-03 04:38:41 -07001268 block_length = BuildTransportSequenceNumberExtension(
1269 extension_data, transport_sequence_number_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001270 break;
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001271 default:
1272 assert(false);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001273 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001274 total_block_length += block_length;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001275 type = rtp_header_extension_map_.Next(type);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001276 }
1277 if (total_block_length == 0) {
1278 // No extension added.
1279 return 0;
1280 }
sprang@webrtc.org30933902015-03-17 14:33:12 +00001281 // Add padding elements until we've filled a 32 bit block.
1282 size_t padding_bytes =
1283 RtpUtility::Word32Align(total_block_length) - total_block_length;
1284 if (padding_bytes > 0) {
1285 memset(&data_buffer[kHeaderLength + total_block_length], 0, padding_bytes);
1286 total_block_length += padding_bytes;
1287 }
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001288 // Set header length (in number of Word32, header excluded).
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001289 ByteWriter<uint16_t>::WriteBigEndian(data_buffer + kPosLength,
1290 total_block_length / 4);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001291 // Total added length.
1292 return kHeaderLength + total_block_length;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001293}
1294
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001295uint8_t RTPSender::BuildTransmissionTimeOffsetExtension(
1296 uint8_t* data_buffer) const {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001297 // From RFC 5450: Transmission Time Offsets in RTP Streams.
1298 //
1299 // The transmission time is signaled to the receiver in-band using the
1300 // general mechanism for RTP header extensions [RFC5285]. The payload
1301 // of this extension (the transmitted value) is a 24-bit signed integer.
1302 // When added to the RTP timestamp of the packet, it represents the
1303 // "effective" RTP transmission time of the packet, on the RTP
1304 // timescale.
1305 //
1306 // The form of the transmission offset extension block:
1307 //
1308 // 0 1 2 3
1309 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1310 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1311 // | ID | len=2 | transmission offset |
1312 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001313
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001314 // Get id defined by user.
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001315 uint8_t id;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001316 if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset,
1317 &id) != 0) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001318 // Not registered.
1319 return 0;
1320 }
pbos@webrtc.org3004c792013-05-07 12:36:21 +00001321 size_t pos = 0;
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001322 const uint8_t len = 2;
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001323 data_buffer[pos++] = (id << 4) + len;
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001324 ByteWriter<int32_t, 3>::WriteBigEndian(data_buffer + pos,
1325 transmission_time_offset_);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001326 pos += 3;
pbos@webrtc.org3004c792013-05-07 12:36:21 +00001327 assert(pos == kTransmissionTimeOffsetLength);
1328 return kTransmissionTimeOffsetLength;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001329}
1330
wu@webrtc.orgebdb0e32014-03-06 23:49:08 +00001331uint8_t RTPSender::BuildAudioLevelExtension(uint8_t* data_buffer) const {
1332 // An RTP Header Extension for Client-to-Mixer Audio Level Indication
1333 //
1334 // https://datatracker.ietf.org/doc/draft-lennox-avt-rtp-audio-level-exthdr/
1335 //
1336 // The form of the audio level extension block:
1337 //
sprang@webrtc.org30933902015-03-17 14:33:12 +00001338 // 0 1
1339 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
1340 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1341 // | ID | len=0 |V| level |
1342 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
wu@webrtc.orgebdb0e32014-03-06 23:49:08 +00001343 //
wu@webrtc.orgebdb0e32014-03-06 23:49:08 +00001344
1345 // Get id defined by user.
1346 uint8_t id;
1347 if (rtp_header_extension_map_.GetId(kRtpExtensionAudioLevel, &id) != 0) {
1348 // Not registered.
1349 return 0;
1350 }
1351 size_t pos = 0;
1352 const uint8_t len = 0;
1353 data_buffer[pos++] = (id << 4) + len;
1354 data_buffer[pos++] = (1 << 7) + 0; // Voice, 0 dBov.
wu@webrtc.orgebdb0e32014-03-06 23:49:08 +00001355 assert(pos == kAudioLevelLength);
1356 return kAudioLevelLength;
1357}
1358
1359uint8_t RTPSender::BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const {
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001360 // Absolute send time in RTP streams.
1361 //
1362 // The absolute send time is signaled to the receiver in-band using the
1363 // general mechanism for RTP header extensions [RFC5285]. The payload
1364 // of this extension (the transmitted value) is a 24-bit unsigned integer
1365 // containing the sender's current time in seconds as a fixed point number
1366 // with 18 bits fractional part.
1367 //
1368 // The form of the absolute send time extension block:
1369 //
1370 // 0 1 2 3
1371 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1372 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1373 // | ID | len=2 | absolute send time |
1374 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1375
1376 // Get id defined by user.
1377 uint8_t id;
1378 if (rtp_header_extension_map_.GetId(kRtpExtensionAbsoluteSendTime,
1379 &id) != 0) {
1380 // Not registered.
1381 return 0;
1382 }
1383 size_t pos = 0;
1384 const uint8_t len = 2;
1385 data_buffer[pos++] = (id << 4) + len;
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001386 ByteWriter<uint32_t, 3>::WriteBigEndian(data_buffer + pos,
1387 absolute_send_time_);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001388 pos += 3;
1389 assert(pos == kAbsoluteSendTimeLength);
1390 return kAbsoluteSendTimeLength;
1391}
1392
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001393uint8_t RTPSender::BuildVideoRotationExtension(uint8_t* data_buffer) const {
1394 // Coordination of Video Orientation in RTP streams.
1395 //
sprang@webrtc.org30933902015-03-17 14:33:12 +00001396 // Coordination of Video Orientation consists in signaling of the current
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001397 // orientation of the image captured on the sender side to the receiver for
1398 // appropriate rendering and displaying.
1399 //
sprang@webrtc.org30933902015-03-17 14:33:12 +00001400 // 0 1
1401 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
1402 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1403 // | ID | len=0 |0 0 0 0 C F R R|
1404 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001405 //
1406
1407 // Get id defined by user.
1408 uint8_t id;
1409 if (rtp_header_extension_map_.GetId(kRtpExtensionVideoRotation, &id) != 0) {
1410 // Not registered.
1411 return 0;
1412 }
1413 size_t pos = 0;
1414 const uint8_t len = 0;
1415 data_buffer[pos++] = (id << 4) + len;
guoweis@webrtc.orgfdd10572015-03-12 20:50:57 +00001416 data_buffer[pos++] = ConvertVideoRotationToCVOByte(rotation_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001417 assert(pos == kVideoRotationLength);
1418 return kVideoRotationLength;
1419}
1420
sprang@webrtc.org30933902015-03-17 14:33:12 +00001421uint8_t RTPSender::BuildTransportSequenceNumberExtension(
sprang867fb522015-08-03 04:38:41 -07001422 uint8_t* data_buffer,
1423 uint16_t sequence_number) const {
sprang@webrtc.org30933902015-03-17 14:33:12 +00001424 // 0 1 2
1425 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
1426 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1427 // | ID | L=1 |transport wide sequence number |
1428 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1429
1430 // Get id defined by user.
1431 uint8_t id;
1432 if (rtp_header_extension_map_.GetId(kRtpExtensionTransportSequenceNumber,
1433 &id) != 0) {
1434 // Not registered.
1435 return 0;
1436 }
1437 size_t pos = 0;
1438 const uint8_t len = 1;
1439 data_buffer[pos++] = (id << 4) + len;
sprang867fb522015-08-03 04:38:41 -07001440 ByteWriter<uint16_t>::WriteBigEndian(data_buffer + pos, sequence_number);
sprang@webrtc.org30933902015-03-17 14:33:12 +00001441 pos += 2;
1442 assert(pos == kTransportSequenceNumberLength);
1443 return kTransportSequenceNumberLength;
1444}
1445
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001446bool RTPSender::FindHeaderExtensionPosition(RTPExtensionType type,
1447 const uint8_t* rtp_packet,
1448 size_t rtp_packet_length,
1449 const RTPHeader& rtp_header,
1450 size_t* position) const {
1451 // Get length until start of header extension block.
1452 int extension_block_pos =
1453 rtp_header_extension_map_.GetLengthUntilBlockStartInBytes(type);
1454 if (extension_block_pos < 0) {
1455 LOG(LS_WARNING) << "Failed to find extension position for " << type
1456 << " as it is not registered.";
1457 return false;
1458 }
1459
1460 HeaderExtension header_extension(type);
1461
danilchapd9e62f52016-01-14 14:55:19 -08001462 size_t extension_pos =
1463 kRtpHeaderLength + rtp_header.numCSRCs * sizeof(uint32_t);
1464 size_t block_pos = extension_pos + extension_block_pos;
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001465 if (rtp_packet_length < block_pos + header_extension.length ||
1466 rtp_header.headerLength < block_pos + header_extension.length) {
1467 LOG(LS_WARNING) << "Failed to find extension position for " << type
1468 << " as the length is invalid.";
1469 return false;
1470 }
1471
1472 // Verify that header contains extension.
danilchapd9e62f52016-01-14 14:55:19 -08001473 if (!(rtp_packet[extension_pos] == 0xBE &&
1474 rtp_packet[extension_pos + 1] == 0xDE)) {
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001475 LOG(LS_WARNING) << "Failed to find extension position for " << type
1476 << "as hdr extension not found.";
1477 return false;
1478 }
1479
1480 *position = block_pos;
1481 return true;
1482}
1483
sprang867fb522015-08-03 04:38:41 -07001484RTPSender::ExtensionStatus RTPSender::VerifyExtension(
1485 RTPExtensionType extension_type,
1486 uint8_t* rtp_packet,
1487 size_t rtp_packet_length,
1488 const RTPHeader& rtp_header,
1489 size_t extension_length_bytes,
1490 size_t* extension_offset) const {
1491 // Get id.
1492 uint8_t id = 0;
1493 if (rtp_header_extension_map_.GetId(extension_type, &id) != 0)
1494 return ExtensionStatus::kNotRegistered;
1495
1496 size_t block_pos = 0;
1497 if (!FindHeaderExtensionPosition(extension_type, rtp_packet,
1498 rtp_packet_length, rtp_header, &block_pos))
1499 return ExtensionStatus::kError;
1500
sprang867fb522015-08-03 04:38:41 -07001501 // Verify first byte in block.
1502 const uint8_t first_block_byte = (id << 4) + (extension_length_bytes - 2);
1503 if (rtp_packet[block_pos] != first_block_byte)
1504 return ExtensionStatus::kError;
1505
1506 *extension_offset = block_pos;
1507 return ExtensionStatus::kOk;
1508}
1509
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001510void RTPSender::UpdateTransmissionTimeOffset(uint8_t* rtp_packet,
1511 size_t rtp_packet_length,
1512 const RTPHeader& rtp_header,
1513 int64_t time_diff_ms) const {
sprang867fb522015-08-03 04:38:41 -07001514 size_t offset;
tommiae695e92016-02-02 08:31:45 -08001515 rtc::CritScope lock(&send_critsect_);
sprang867fb522015-08-03 04:38:41 -07001516 switch (VerifyExtension(kRtpExtensionTransmissionTimeOffset, rtp_packet,
1517 rtp_packet_length, rtp_header,
1518 kTransmissionTimeOffsetLength, &offset)) {
1519 case ExtensionStatus::kNotRegistered:
1520 return;
1521 case ExtensionStatus::kError:
1522 LOG(LS_WARNING) << "Failed to update transmission time offset.";
1523 return;
1524 case ExtensionStatus::kOk:
1525 break;
1526 default:
1527 RTC_NOTREACHED();
stefan@webrtc.org2f8d5f32014-04-15 12:28:46 +00001528 }
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001529
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001530 // Update transmission offset field (converting to a 90 kHz timestamp).
sprang867fb522015-08-03 04:38:41 -07001531 ByteWriter<int32_t, 3>::WriteBigEndian(rtp_packet + offset + 1,
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001532 time_diff_ms * 90); // RTP timestamp.
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +00001533}
1534
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001535bool RTPSender::UpdateAudioLevel(uint8_t* rtp_packet,
1536 size_t rtp_packet_length,
1537 const RTPHeader& rtp_header,
1538 bool is_voiced,
1539 uint8_t dBov) const {
sprang867fb522015-08-03 04:38:41 -07001540 size_t offset;
tommiae695e92016-02-02 08:31:45 -08001541 rtc::CritScope lock(&send_critsect_);
wu@webrtc.orgebdb0e32014-03-06 23:49:08 +00001542
sprang867fb522015-08-03 04:38:41 -07001543 switch (VerifyExtension(kRtpExtensionAudioLevel, rtp_packet,
1544 rtp_packet_length, rtp_header, kAudioLevelLength,
1545 &offset)) {
1546 case ExtensionStatus::kNotRegistered:
1547 return false;
1548 case ExtensionStatus::kError:
1549 LOG(LS_WARNING) << "Failed to update audio level.";
1550 return false;
1551 case ExtensionStatus::kOk:
1552 break;
1553 default:
1554 RTC_NOTREACHED();
stefan@webrtc.org2f8d5f32014-04-15 12:28:46 +00001555 }
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001556
sprang867fb522015-08-03 04:38:41 -07001557 rtp_packet[offset + 1] = (is_voiced ? 0x80 : 0x00) + (dBov & 0x7f);
wu@webrtc.orgebdb0e32014-03-06 23:49:08 +00001558 return true;
1559}
1560
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001561bool RTPSender::UpdateVideoRotation(uint8_t* rtp_packet,
1562 size_t rtp_packet_length,
1563 const RTPHeader& rtp_header,
1564 VideoRotation rotation) const {
sprang867fb522015-08-03 04:38:41 -07001565 size_t offset;
tommiae695e92016-02-02 08:31:45 -08001566 rtc::CritScope lock(&send_critsect_);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001567
sprang867fb522015-08-03 04:38:41 -07001568 switch (VerifyExtension(kRtpExtensionVideoRotation, rtp_packet,
1569 rtp_packet_length, rtp_header, kVideoRotationLength,
1570 &offset)) {
1571 case ExtensionStatus::kNotRegistered:
1572 return false;
1573 case ExtensionStatus::kError:
1574 LOG(LS_WARNING) << "Failed to update CVO.";
1575 return false;
1576 case ExtensionStatus::kOk:
1577 break;
1578 default:
1579 RTC_NOTREACHED();
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001580 }
1581
sprang867fb522015-08-03 04:38:41 -07001582 rtp_packet[offset + 1] = ConvertVideoRotationToCVOByte(rotation);
guoweis@webrtc.org45362892015-03-04 22:55:15 +00001583 return true;
1584}
1585
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001586void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet,
1587 size_t rtp_packet_length,
1588 const RTPHeader& rtp_header,
1589 int64_t now_ms) const {
sprang867fb522015-08-03 04:38:41 -07001590 size_t offset;
tommiae695e92016-02-02 08:31:45 -08001591 rtc::CritScope lock(&send_critsect_);
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001592
sprang867fb522015-08-03 04:38:41 -07001593 switch (VerifyExtension(kRtpExtensionAbsoluteSendTime, rtp_packet,
1594 rtp_packet_length, rtp_header,
1595 kAbsoluteSendTimeLength, &offset)) {
1596 case ExtensionStatus::kNotRegistered:
1597 return;
1598 case ExtensionStatus::kError:
1599 LOG(LS_WARNING) << "Failed to update absolute send time";
1600 return;
1601 case ExtensionStatus::kOk:
1602 break;
1603 default:
1604 RTC_NOTREACHED();
stefan@webrtc.org2f8d5f32014-04-15 12:28:46 +00001605 }
sprang867fb522015-08-03 04:38:41 -07001606
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001607 // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit
1608 // fractional part).
sprang867fb522015-08-03 04:38:41 -07001609 ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1,
Stefan Holmer0a87ffc2015-10-21 13:41:48 +02001610 ConvertMsTo24Bits(now_ms));
solenberg@webrtc.org7ebbea12013-05-16 11:10:31 +00001611}
1612
sprang867fb522015-08-03 04:38:41 -07001613uint16_t RTPSender::UpdateTransportSequenceNumber(
1614 uint8_t* rtp_packet,
1615 size_t rtp_packet_length,
1616 const RTPHeader& rtp_header) const {
1617 size_t offset;
tommiae695e92016-02-02 08:31:45 -08001618 rtc::CritScope lock(&send_critsect_);
sprang867fb522015-08-03 04:38:41 -07001619
1620 switch (VerifyExtension(kRtpExtensionTransportSequenceNumber, rtp_packet,
1621 rtp_packet_length, rtp_header,
1622 kTransportSequenceNumberLength, &offset)) {
1623 case ExtensionStatus::kNotRegistered:
1624 return 0;
1625 case ExtensionStatus::kError:
1626 LOG(LS_WARNING) << "Failed to update transport sequence number";
1627 return 0;
1628 case ExtensionStatus::kOk:
1629 break;
1630 default:
1631 RTC_NOTREACHED();
1632 }
1633
sprangebbf8a82015-09-21 15:11:14 -07001634 uint16_t seq = transport_sequence_number_allocator_->AllocateSequenceNumber();
sprang867fb522015-08-03 04:38:41 -07001635 BuildTransportSequenceNumberExtension(rtp_packet + offset, seq);
1636 return seq;
1637}
1638
pbos@webrtc.org59f20bb2013-09-09 16:02:19 +00001639void RTPSender::SetSendingStatus(bool enabled) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001640 if (enabled) {
pbos@webrtc.org59f20bb2013-09-09 16:02:19 +00001641 uint32_t frequency_hz = SendPayloadFrequency();
danilchap1227e8b2015-12-21 11:06:50 -08001642 uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001643
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001644 // Will be ignored if it's already configured via API.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001645 SetStartTimestamp(RTPtime, false);
1646 } else {
tommiae695e92016-02-02 08:31:45 -08001647 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001648 if (!ssrc_forced_) {
1649 // Generate a new SSRC.
tommiae695e92016-02-02 08:31:45 -08001650 ssrc_db_->ReturnSSRC(ssrc_);
1651 ssrc_ = ssrc_db_->CreateSSRC();
1652 RTC_DCHECK(ssrc_ != 0);
1653 bitrates_.set_ssrc(ssrc_);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001654 }
1655 // Don't initialize seq number if SSRC passed externally.
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001656 if (!sequence_number_forced_ && !ssrc_forced_) {
1657 // Generate a new sequence number.
danilchap47a740b2015-12-15 00:30:07 -08001658 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001659 }
1660 }
1661}
1662
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001663void RTPSender::SetSendingMediaStatus(bool enabled) {
tommiae695e92016-02-02 08:31:45 -08001664 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001665 sending_media_ = enabled;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001666}
1667
1668bool RTPSender::SendingMedia() const {
tommiae695e92016-02-02 08:31:45 -08001669 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001670 return sending_media_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001671}
1672
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001673uint32_t RTPSender::Timestamp() const {
tommiae695e92016-02-02 08:31:45 -08001674 rtc::CritScope lock(&send_critsect_);
stefan@webrtc.orga8179622013-06-04 13:47:36 +00001675 return timestamp_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001676}
1677
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001678void RTPSender::SetStartTimestamp(uint32_t timestamp, bool force) {
tommiae695e92016-02-02 08:31:45 -08001679 rtc::CritScope lock(&send_critsect_);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001680 if (force) {
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001681 start_timestamp_forced_ = true;
1682 start_timestamp_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001683 } else {
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001684 if (!start_timestamp_forced_) {
1685 start_timestamp_ = timestamp;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001686 }
1687 }
1688}
1689
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001690uint32_t RTPSender::StartTimestamp() const {
tommiae695e92016-02-02 08:31:45 -08001691 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001692 return start_timestamp_;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001693}
1694
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001695uint32_t RTPSender::GenerateNewSSRC() {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001696 // If configured via API, return 0.
tommiae695e92016-02-02 08:31:45 -08001697 rtc::CritScope lock(&send_critsect_);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001698
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001699 if (ssrc_forced_) {
niklase@google.com470e71d2011-07-07 08:21:25 +00001700 return 0;
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001701 }
tommiae695e92016-02-02 08:31:45 -08001702 ssrc_ = ssrc_db_->CreateSSRC();
1703 RTC_DCHECK(ssrc_ != 0);
1704 bitrates_.set_ssrc(ssrc_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001705 return ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001706}
1707
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001708void RTPSender::SetSSRC(uint32_t ssrc) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001709 // This is configured via the API.
tommiae695e92016-02-02 08:31:45 -08001710 rtc::CritScope lock(&send_critsect_);
niklase@google.com470e71d2011-07-07 08:21:25 +00001711
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001712 if (ssrc_ == ssrc && ssrc_forced_) {
1713 return; // Since it's same ssrc, don't reset anything.
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001714 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001715 ssrc_forced_ = true;
tommiae695e92016-02-02 08:31:45 -08001716 ssrc_db_->ReturnSSRC(ssrc_);
1717 ssrc_db_->RegisterSSRC(ssrc);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001718 ssrc_ = ssrc;
tommiae695e92016-02-02 08:31:45 -08001719 bitrates_.set_ssrc(ssrc_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001720 if (!sequence_number_forced_) {
danilchap47a740b2015-12-15 00:30:07 -08001721 sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber);
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001722 }
niklase@google.com470e71d2011-07-07 08:21:25 +00001723}
1724
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001725uint32_t RTPSender::SSRC() const {
tommiae695e92016-02-02 08:31:45 -08001726 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001727 return ssrc_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001728}
1729
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001730void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
1731 assert(csrcs.size() <= kRtpCsrcSize);
tommiae695e92016-02-02 08:31:45 -08001732 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org9334ac22014-11-24 08:25:50 +00001733 csrcs_ = csrcs;
niklase@google.com470e71d2011-07-07 08:21:25 +00001734}
1735
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001736void RTPSender::SetSequenceNumber(uint16_t seq) {
tommiae695e92016-02-02 08:31:45 -08001737 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001738 sequence_number_forced_ = true;
1739 sequence_number_ = seq;
niklase@google.com470e71d2011-07-07 08:21:25 +00001740}
1741
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001742uint16_t RTPSender::SequenceNumber() const {
tommiae695e92016-02-02 08:31:45 -08001743 rtc::CritScope lock(&send_critsect_);
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001744 return sequence_number_;
niklase@google.com470e71d2011-07-07 08:21:25 +00001745}
1746
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001747// Audio.
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001748int32_t RTPSender::SendTelephoneEvent(uint8_t key,
1749 uint16_t time_ms,
1750 uint8_t level) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001751 if (!audio_configured_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001752 return -1;
1753 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001754 return audio_->SendTelephoneEvent(key, time_ms, level);
niklase@google.com470e71d2011-07-07 08:21:25 +00001755}
1756
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001757int32_t RTPSender::SetAudioPacketSize(uint16_t packet_size_samples) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001758 if (!audio_configured_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001759 return -1;
1760 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001761 return audio_->SetAudioPacketSize(packet_size_samples);
niklase@google.com470e71d2011-07-07 08:21:25 +00001762}
1763
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001764int32_t RTPSender::SetAudioLevel(uint8_t level_d_bov) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001765 return audio_->SetAudioLevel(level_d_bov);
niklase@google.com470e71d2011-07-07 08:21:25 +00001766}
1767
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +00001768int32_t RTPSender::SetRED(int8_t payload_type) {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001769 if (!audio_configured_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001770 return -1;
1771 }
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001772 return audio_->SetRED(payload_type);
niklase@google.com470e71d2011-07-07 08:21:25 +00001773}
1774
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001775int32_t RTPSender::RED(int8_t *payload_type) const {
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001776 if (!audio_configured_) {
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001777 return -1;
1778 }
danilchap6db6cdc2015-12-15 02:54:47 -08001779 return audio_->RED(payload_type);
niklase@google.com470e71d2011-07-07 08:21:25 +00001780}
1781
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001782RtpVideoCodecTypes RTPSender::VideoCodecType() const {
pbos@webrtc.org8911ce42013-03-18 16:39:03 +00001783 assert(!audio_configured_ && "Sender is an audio stream!");
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001784 return video_->VideoCodecType();
niklase@google.com470e71d2011-07-07 08:21:25 +00001785}
1786
pbosba8c15b2015-07-14 09:36:34 -07001787void RTPSender::SetGenericFECStatus(bool enable,
1788 uint8_t payload_type_red,
1789 uint8_t payload_type_fec) {
henrikg91d6ede2015-09-17 00:24:34 -07001790 RTC_DCHECK(!audio_configured_);
mflodmanfcf54bd2015-04-14 21:28:08 +02001791 video_->SetGenericFECStatus(enable, payload_type_red, payload_type_fec);
niklase@google.com470e71d2011-07-07 08:21:25 +00001792}
1793
pbosba8c15b2015-07-14 09:36:34 -07001794void RTPSender::GenericFECStatus(bool* enable,
pkasting@chromium.orgd3245462015-02-23 21:28:22 +00001795 uint8_t* payload_type_red,
1796 uint8_t* payload_type_fec) const {
henrikg91d6ede2015-09-17 00:24:34 -07001797 RTC_DCHECK(!audio_configured_);
danilchap6db6cdc2015-12-15 02:54:47 -08001798 video_->GenericFECStatus(enable, payload_type_red, payload_type_fec);
niklase@google.com470e71d2011-07-07 08:21:25 +00001799}
1800
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001801int32_t RTPSender::SetFecParameters(
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001802 const FecProtectionParams *delta_params,
1803 const FecProtectionParams *key_params) {
1804 if (audio_configured_) {
stefan@webrtc.orge0d6fa42012-03-20 22:10:56 +00001805 return -1;
1806 }
mflodmanfcf54bd2015-04-14 21:28:08 +02001807 video_->SetFecParameters(delta_params, key_params);
1808 return 0;
marpan@google.com80c5d7a2011-07-15 21:32:40 +00001809}
phoglund@webrtc.org43da54a2013-01-25 10:53:38 +00001810
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +00001811void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length,
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001812 uint8_t* buffer_rtx) {
tommiae695e92016-02-02 08:31:45 -08001813 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2f446732013-04-08 11:08:41 +00001814 uint8_t* data_buffer_rtx = buffer_rtx;
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001815 // Add RTX header.
pbos@webrtc.org62bafae2014-07-08 12:10:51 +00001816 RtpUtility::RtpHeaderParser rtp_parser(
1817 reinterpret_cast<const uint8_t*>(buffer), *length);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001818
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +00001819 RTPHeader rtp_header;
danilchapf6975f42015-12-28 10:18:46 -08001820 rtp_parser.Parse(&rtp_header);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001821
1822 // Add original RTP header.
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +00001823 memcpy(data_buffer_rtx, buffer, rtp_header.headerLength);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001824
andrew@webrtc.org8f27fcc2015-01-09 20:22:46 +00001825 // Replace payload type, if a specific type is set for RTX.
Stefan Holmer10880012016-02-03 13:29:59 +01001826 auto kv = rtx_payload_type_map_.find(rtp_header.payloadType);
1827 // Use rtx mapping associated with media codec if we can't find one, assuming
1828 // it's red.
1829 // TODO(holmer): Remove once old Chrome versions don't rely on this.
1830 if (kv == rtx_payload_type_map_.end())
1831 kv = rtx_payload_type_map_.find(payload_type_);
1832 if (kv != rtx_payload_type_map_.end())
1833 data_buffer_rtx[1] = kv->second;
1834 if (rtp_header.markerBit)
1835 data_buffer_rtx[1] |= kRtpMarkerBitMask;
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +00001836
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001837 // Replace sequence number.
danilchapf6975f42015-12-28 10:18:46 -08001838 uint8_t* ptr = data_buffer_rtx + 2;
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001839 ByteWriter<uint16_t>::WriteBigEndian(ptr, sequence_number_rtx_++);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001840
1841 // Replace SSRC.
1842 ptr += 6;
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001843 ByteWriter<uint32_t>::WriteBigEndian(ptr, ssrc_rtx_);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001844
1845 // Add OSN (original sequence number).
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +00001846 ptr = data_buffer_rtx + rtp_header.headerLength;
sprang@webrtc.org779c3d12015-03-17 16:42:49 +00001847 ByteWriter<uint16_t>::WriteBigEndian(ptr, rtp_header.sequenceNumber);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001848 ptr += 2;
1849
1850 // Add original payload data.
stefan@webrtc.orga5cb98c2013-05-29 12:12:51 +00001851 memcpy(ptr, buffer + rtp_header.headerLength,
1852 *length - rtp_header.headerLength);
mikhal@webrtc.orgbda7f302013-03-15 23:21:52 +00001853 *length += 2;
1854}
1855
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001856void RTPSender::RegisterRtpStatisticsCallback(
1857 StreamDataCountersCallback* callback) {
danilchap7c9426c2016-04-14 03:05:31 -07001858 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001859 rtp_stats_callback_ = callback;
1860}
1861
1862StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const {
danilchap7c9426c2016-04-14 03:05:31 -07001863 rtc::CritScope cs(&statistics_crit_);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +00001864 return rtp_stats_callback_;
1865}
1866
stefan@webrtc.org0bae1fa2014-11-05 14:05:29 +00001867uint32_t RTPSender::BitrateSent() const {
1868 return total_bitrate_sent_.BitrateLast();
sprang@webrtc.org6811b6e2013-12-13 09:46:59 +00001869}
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001870
1871void RTPSender::SetRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001872 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001873 sequence_number_ = rtp_state.sequence_number;
1874 sequence_number_forced_ = true;
1875 timestamp_ = rtp_state.timestamp;
1876 capture_time_ms_ = rtp_state.capture_time_ms;
1877 last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001878 media_has_been_sent_ = rtp_state.media_has_been_sent;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001879}
1880
1881RtpState RTPSender::GetRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001882 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001883
1884 RtpState state;
1885 state.sequence_number = sequence_number_;
1886 state.start_timestamp = start_timestamp_;
1887 state.timestamp = timestamp_;
1888 state.capture_time_ms = capture_time_ms_;
1889 state.last_timestamp_time_ms = last_timestamp_time_ms_;
stefan@webrtc.org8b94e3d2014-07-17 16:10:14 +00001890 state.media_has_been_sent = media_has_been_sent_;
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001891
1892 return state;
1893}
1894
1895void RTPSender::SetRtxRtpState(const RtpState& rtp_state) {
tommiae695e92016-02-02 08:31:45 -08001896 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001897 sequence_number_rtx_ = rtp_state.sequence_number;
1898}
1899
1900RtpState RTPSender::GetRtxRtpState() const {
tommiae695e92016-02-02 08:31:45 -08001901 rtc::CritScope lock(&send_critsect_);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +00001902
1903 RtpState state;
1904 state.sequence_number = sequence_number_rtx_;
1905 state.start_timestamp = start_timestamp_;
1906
1907 return state;
1908}
1909
pwestin@webrtc.orgc66e8b32012-11-07 17:01:04 +00001910} // namespace webrtc