niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1 | /* |
pwestin@webrtc.org | f6bb77a | 2012-01-24 17:16:59 +0000 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 3 | * |
| 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.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 11 | #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h" |
| 12 | |
pbos@webrtc.org | 12dc1a3 | 2013-08-05 16:22:53 +0000 | [diff] [blame] | 13 | #include <stdlib.h> // srand |
danilchap | b8b6fbb | 2015-12-10 05:05:27 -0800 | [diff] [blame] | 14 | #include <algorithm> |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 15 | #include <utility> |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 16 | |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 17 | #include "webrtc/base/checks.h" |
Peter Boström | ebc0b4e | 2015-10-28 16:39:33 +0100 | [diff] [blame] | 18 | #include "webrtc/base/logging.h" |
tommi | e4f9650 | 2015-10-20 23:00:48 -0700 | [diff] [blame] | 19 | #include "webrtc/base/trace_event.h" |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 20 | #include "webrtc/call.h" |
| 21 | #include "webrtc/call/rtc_event_log.h" |
Henrik Kjellander | ff761fb | 2015-11-04 08:31:52 +0100 | [diff] [blame] | 22 | #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h" |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 23 | #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 24 | #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h" |
| 25 | #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h" |
danilchap | 1227e8b | 2015-12-21 11:06:50 -0800 | [diff] [blame] | 26 | #include "webrtc/modules/rtp_rtcp/source/time_util.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 18:17:40 +0100 | [diff] [blame] | 27 | #include "webrtc/system_wrappers/include/tick_util.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 28 | |
| 29 | namespace webrtc { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 30 | |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 31 | // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP. |
Stefan Holmer | 0a87ffc | 2015-10-21 13:41:48 +0200 | [diff] [blame] | 32 | static const size_t kMaxPaddingLength = 224; |
| 33 | static const int kSendSideDelayWindowMs = 1000; |
| 34 | static const uint32_t kAbsSendTimeFraction = 18; |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 35 | |
hclam@chromium.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 36 | namespace { |
| 37 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 38 | const size_t kRtpHeaderLength = 12; |
danilchap | 47a740b | 2015-12-15 00:30:07 -0800 | [diff] [blame] | 39 | const uint16_t kMaxInitRtpSeqNumber = 32767; // 2^15 -1. |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 40 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 41 | const char* FrameTypeToString(FrameType frame_type) { |
hclam@chromium.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 42 | switch (frame_type) { |
pbos | 22993e1 | 2015-10-19 02:39:06 -0700 | [diff] [blame] | 43 | case kEmptyFrame: |
| 44 | return "empty"; |
hclam@chromium.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 45 | 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.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 49 | } |
| 50 | return ""; |
| 51 | } |
| 52 | |
Stefan Holmer | 0a87ffc | 2015-10-21 13:41:48 +0200 | [diff] [blame] | 53 | // TODO(holmer): Merge this with the implementation in |
| 54 | // remote_bitrate_estimator_abs_send_time.cc. |
| 55 | uint32_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.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 63 | } // namespace |
| 64 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 65 | RTPSender::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.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 71 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 72 | void RTPSender::BitrateAggregator::OnStatsUpdated() const { |
| 73 | if (callback_) { |
| 74 | callback_->Notify(total_bitrate_observer_.statistics(), |
| 75 | retransmit_bitrate_observer_.statistics(), ssrc_); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 76 | } |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 77 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 78 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 79 | Bitrate::Observer* RTPSender::BitrateAggregator::total_bitrate_observer() { |
| 80 | return &total_bitrate_observer_; |
| 81 | } |
| 82 | Bitrate::Observer* RTPSender::BitrateAggregator::retransmit_bitrate_observer() { |
| 83 | return &retransmit_bitrate_observer_; |
| 84 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 85 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 86 | void RTPSender::BitrateAggregator::set_ssrc(uint32_t ssrc) { |
| 87 | ssrc_ = ssrc; |
| 88 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 89 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 90 | RTPSender::BitrateAggregator::BitrateObserver::BitrateObserver( |
| 91 | const BitrateAggregator& aggregator) |
| 92 | : aggregator_(aggregator) {} |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 93 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 94 | // Implements Bitrate::Observer. |
| 95 | void RTPSender::BitrateAggregator::BitrateObserver::BitrateUpdated( |
| 96 | const BitrateStatistics& stats) { |
| 97 | statistics_ = stats; |
| 98 | aggregator_.OnStatsUpdated(); |
| 99 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 100 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 101 | const BitrateStatistics& |
| 102 | RTPSender::BitrateAggregator::BitrateObserver::statistics() const { |
| 103 | return statistics_; |
| 104 | } |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 105 | |
sprang | ebbf8a8 | 2015-09-21 15:11:14 -0700 | [diff] [blame] | 106 | RTPSender::RTPSender( |
| 107 | bool audio, |
| 108 | Clock* clock, |
| 109 | Transport* transport, |
sprang | ebbf8a8 | 2015-09-21 15:11:14 -0700 | [diff] [blame] | 110 | RtpPacketSender* paced_sender, |
| 111 | TransportSequenceNumberAllocator* sequence_number_allocator, |
| 112 | TransportFeedbackObserver* transport_feedback_observer, |
| 113 | BitrateStatisticsObserver* bitrate_callback, |
| 114 | FrameCountObserver* frame_count_observer, |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 115 | SendSideDelayObserver* send_side_delay_observer, |
| 116 | RtcEventLog* event_log) |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 117 | : clock_(clock), |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 118 | // TODO(holmer): Remove this conversion when we remove the use of |
| 119 | // TickTime. |
| 120 | clock_delta_ms_(clock_->TimeInMilliseconds() - |
| 121 | TickTime::MillisecondTimestamp()), |
danilchap | 47a740b | 2015-12-15 00:30:07 -0800 | [diff] [blame] | 122 | random_(clock_->TimeInMicroseconds()), |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 123 | bitrates_(bitrate_callback), |
| 124 | total_bitrate_sent_(clock, bitrates_.total_bitrate_observer()), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 125 | audio_configured_(audio), |
solenberg | 6021fe2 | 2016-03-15 11:41:53 -0700 | [diff] [blame] | 126 | audio_(audio ? new RTPSenderAudio(clock, this) : nullptr), |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 127 | video_(audio ? nullptr : new RTPSenderVideo(clock, this)), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 128 | paced_sender_(paced_sender), |
sprang | ebbf8a8 | 2015-09-21 15:11:14 -0700 | [diff] [blame] | 129 | transport_sequence_number_allocator_(sequence_number_allocator), |
sprang | 5e023eb | 2015-09-14 06:42:43 -0700 | [diff] [blame] | 130 | transport_feedback_observer_(transport_feedback_observer), |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 131 | last_capture_time_ms_sent_(0), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 132 | 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.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 135 | payload_type_(-1), |
| 136 | payload_type_map_(), |
| 137 | rtp_header_extension_map_(), |
| 138 | transmission_time_offset_(0), |
| 139 | absolute_send_time_(0), |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 140 | rotation_(kVideoRotation_0), |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 141 | cvo_mode_(kCVONone), |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 142 | transport_sequence_number_(0), |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 143 | // NACK. |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 144 | nack_byte_count_times_(), |
| 145 | nack_byte_count_(), |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 146 | nack_bitrate_(clock, bitrates_.retransmit_bitrate_observer()), |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 147 | packet_history_(clock), |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 148 | // Statistics |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 149 | rtp_stats_callback_(NULL), |
andresp@webrtc.org | 8f15121 | 2014-07-10 09:39:23 +0000 | [diff] [blame] | 150 | frame_count_observer_(frame_count_observer), |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 151 | send_side_delay_observer_(send_side_delay_observer), |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 152 | event_log_(event_log), |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 153 | // RTP variables |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 154 | start_timestamp_forced_(false), |
| 155 | start_timestamp_(0), |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 156 | ssrc_db_(SSRCDatabase::GetSSRCDatabase()), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 157 | 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.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 163 | media_has_been_sent_(false), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 164 | last_packet_marker_bit_(false), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 165 | csrcs_(), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 166 | rtx_(kRtxOff), |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 167 | target_bitrate_(0) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 168 | memset(nack_byte_count_times_, 0, sizeof(nack_byte_count_times_)); |
| 169 | memset(nack_byte_count_, 0, sizeof(nack_byte_count_)); |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 170 | // 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.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 173 | srand(static_cast<uint32_t>(clock_->TimeInMilliseconds())); |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 174 | 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.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 180 | // Random start, 16 bits. Can't be 0. |
danilchap | 47a740b | 2015-12-15 00:30:07 -0800 | [diff] [blame] | 181 | sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
| 182 | sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 183 | } |
| 184 | |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 185 | RTPSender::~RTPSender() { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 186 | // 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.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 195 | if (remote_ssrc_ != 0) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 196 | ssrc_db_->ReturnSSRC(remote_ssrc_); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 197 | } |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 198 | ssrc_db_->ReturnSSRC(ssrc_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 199 | |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 200 | SSRCDatabase::ReturnSSRCDatabase(); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 201 | while (!payload_type_map_.empty()) { |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 202 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 203 | payload_type_map_.begin(); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 204 | delete it->second; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 205 | payload_type_map_.erase(it); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 206 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 207 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 208 | |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 209 | void RTPSender::SetTargetBitrate(uint32_t bitrate) { |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 210 | rtc::CritScope cs(&target_bitrate_critsect_); |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 211 | target_bitrate_ = bitrate; |
| 212 | } |
| 213 | |
| 214 | uint32_t RTPSender::GetTargetBitrate() { |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 215 | rtc::CritScope cs(&target_bitrate_critsect_); |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 216 | return target_bitrate_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 217 | } |
stefan@webrtc.org | d0bdab0 | 2011-10-14 14:24:54 +0000 | [diff] [blame] | 218 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 219 | uint16_t RTPSender::ActualSendBitrateKbit() const { |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 220 | return (uint16_t)(total_bitrate_sent_.BitrateNow() / 1000); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 221 | } |
| 222 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 223 | uint32_t RTPSender::VideoBitrateSent() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 224 | if (video_) { |
| 225 | return video_->VideoBitrateSent(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 226 | } |
| 227 | return 0; |
stefan@webrtc.org | fbea4e5 | 2011-10-27 16:08:29 +0000 | [diff] [blame] | 228 | } |
| 229 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 230 | uint32_t RTPSender::FecOverheadRate() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 231 | if (video_) { |
| 232 | return video_->FecOverheadRate(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 233 | } |
| 234 | return 0; |
stefan@webrtc.org | d0bdab0 | 2011-10-14 14:24:54 +0000 | [diff] [blame] | 235 | } |
| 236 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 237 | uint32_t RTPSender::NackOverheadRate() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 238 | return nack_bitrate_.BitrateLast(); |
stefan@webrtc.org | d0bdab0 | 2011-10-14 14:24:54 +0000 | [diff] [blame] | 239 | } |
| 240 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 241 | int32_t RTPSender::SetTransmissionTimeOffset(int32_t transmission_time_offset) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 242 | if (transmission_time_offset > (0x800000 - 1) || |
| 243 | transmission_time_offset < -(0x800000 - 1)) { // Word24. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 244 | return -1; |
| 245 | } |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 246 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 247 | transmission_time_offset_ = transmission_time_offset; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 248 | return 0; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 249 | } |
| 250 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 251 | int32_t RTPSender::SetAbsoluteSendTime(uint32_t absolute_send_time) { |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 252 | if (absolute_send_time > 0xffffff) { // UWord24. |
| 253 | return -1; |
| 254 | } |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 255 | rtc::CritScope lock(&send_critsect_); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 256 | absolute_send_time_ = absolute_send_time; |
| 257 | return 0; |
| 258 | } |
| 259 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 260 | void RTPSender::SetVideoRotation(VideoRotation rotation) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 261 | rtc::CritScope lock(&send_critsect_); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 262 | rotation_ = rotation; |
| 263 | } |
| 264 | |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 265 | int32_t RTPSender::SetTransportSequenceNumber(uint16_t sequence_number) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 266 | rtc::CritScope lock(&send_critsect_); |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 267 | transport_sequence_number_ = sequence_number; |
| 268 | return 0; |
| 269 | } |
| 270 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 271 | int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type, |
| 272 | uint8_t id) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 273 | rtc::CritScope lock(&send_critsect_); |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 274 | if (type == kRtpExtensionVideoRotation) { |
| 275 | cvo_mode_ = kCVOInactive; |
| 276 | return rtp_header_extension_map_.RegisterInactive(type, id); |
| 277 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 278 | return rtp_header_extension_map_.Register(type, id); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 279 | } |
| 280 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 281 | bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 282 | rtc::CritScope lock(&send_critsect_); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 283 | return rtp_header_extension_map_.IsRegistered(type); |
| 284 | } |
| 285 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 286 | int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 287 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 288 | return rtp_header_extension_map_.Deregister(type); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 289 | } |
| 290 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 291 | size_t RTPSender::RtpHeaderExtensionTotalLength() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 292 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 293 | return rtp_header_extension_map_.GetTotalLengthInBytes(); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 294 | } |
| 295 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 296 | int32_t RTPSender::RegisterPayload( |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 297 | const char payload_name[RTP_PAYLOAD_NAME_SIZE], |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 298 | int8_t payload_number, |
| 299 | uint32_t frequency, |
Peter Kasting | 6955870 | 2016-01-12 16:26:35 -0800 | [diff] [blame] | 300 | size_t channels, |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 301 | uint32_t rate) { |
Peter Boström | 8b79b07 | 2016-02-26 16:31:37 +0100 | [diff] [blame] | 302 | RTC_DCHECK_LT(strlen(payload_name), RTP_PAYLOAD_NAME_SIZE); |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 303 | rtc::CritScope lock(&send_critsect_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 304 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 305 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 306 | payload_type_map_.find(payload_number); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 307 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 308 | if (payload_type_map_.end() != it) { |
| 309 | // We already use this payload type. |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 310 | RtpUtility::Payload* payload = it->second; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 311 | assert(payload); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 312 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 313 | // Check if it's the same as we already have. |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 314 | if (RtpUtility::StringCompare( |
| 315 | payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1)) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 316 | if (audio_configured_ && payload->audio && |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 317 | payload->typeSpecific.Audio.frequency == frequency && |
| 318 | (payload->typeSpecific.Audio.rate == rate || |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 319 | payload->typeSpecific.Audio.rate == 0 || rate == 0)) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 320 | payload->typeSpecific.Audio.rate = rate; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 321 | // Ensure that we update the rate if new or old is zero. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 322 | return 0; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 323 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 324 | if (!audio_configured_ && !payload->audio) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 325 | return 0; |
| 326 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 327 | } |
| 328 | return -1; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 329 | } |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 330 | int32_t ret_val = 0; |
danilchap | 6db6cdc | 2015-12-15 02:54:47 -0800 | [diff] [blame] | 331 | RtpUtility::Payload* payload = nullptr; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 332 | if (audio_configured_) { |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 333 | // TODO(mflodman): Change to CreateAudioPayload and make static. |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 334 | ret_val = audio_->RegisterAudioPayload(payload_name, payload_number, |
danilchap | 6db6cdc | 2015-12-15 02:54:47 -0800 | [diff] [blame] | 335 | frequency, channels, rate, &payload); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 336 | } else { |
Peter Boström | 9d0c432 | 2016-02-16 17:59:27 +0100 | [diff] [blame] | 337 | payload = video_->CreateVideoPayload(payload_name, payload_number); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 338 | } |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 339 | if (payload) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 340 | payload_type_map_[payload_number] = payload; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 341 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 342 | return ret_val; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 343 | } |
| 344 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 345 | int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 346 | rtc::CritScope lock(&send_critsect_); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 347 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 348 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 349 | payload_type_map_.find(payload_type); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 350 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 351 | if (payload_type_map_.end() == it) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 352 | return -1; |
| 353 | } |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 354 | RtpUtility::Payload* payload = it->second; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 355 | delete payload; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 356 | payload_type_map_.erase(it); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 357 | return 0; |
| 358 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 359 | |
andresp@webrtc.org | c3c2911 | 2014-08-27 09:39:43 +0000 | [diff] [blame] | 360 | void RTPSender::SetSendPayloadType(int8_t payload_type) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 361 | rtc::CritScope lock(&send_critsect_); |
andresp@webrtc.org | c3c2911 | 2014-08-27 09:39:43 +0000 | [diff] [blame] | 362 | payload_type_ = payload_type; |
| 363 | } |
| 364 | |
sprang@webrtc.org | efcad39 | 2014-03-25 16:51:35 +0000 | [diff] [blame] | 365 | int8_t RTPSender::SendPayloadType() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 366 | rtc::CritScope lock(&send_critsect_); |
sprang@webrtc.org | efcad39 | 2014-03-25 16:51:35 +0000 | [diff] [blame] | 367 | return payload_type_; |
| 368 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 369 | |
pbos@webrtc.org | 59f20bb | 2013-09-09 16:02:19 +0000 | [diff] [blame] | 370 | int RTPSender::SendPayloadFrequency() const { |
| 371 | return audio_ != NULL ? audio_->AudioFrequency() : kVideoPayloadTypeFrequency; |
| 372 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 373 | |
danilchap | 41befce | 2016-03-30 11:11:51 -0700 | [diff] [blame] | 374 | void RTPSender::SetMaxPayloadLength(size_t max_payload_length) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 375 | // Sanity check. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 376 | RTC_DCHECK(max_payload_length >= 100 && max_payload_length <= IP_PACKET_SIZE) |
Peter Boström | d6f1a38 | 2015-07-14 16:08:02 +0200 | [diff] [blame] | 377 | << "Invalid max payload length: " << max_payload_length; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 378 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 379 | max_payload_length_ = max_payload_length; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 380 | } |
| 381 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 382 | size_t RTPSender::MaxDataPayloadLength() const { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 383 | int rtx; |
| 384 | { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 385 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 386 | rtx = rtx_; |
| 387 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 388 | if (audio_configured_) { |
| 389 | return max_payload_length_ - RTPHeaderLength(); |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 390 | } else { |
sprang@webrtc.org | 346094c | 2014-02-18 08:40:33 +0000 | [diff] [blame] | 391 | return max_payload_length_ - RTPHeaderLength() // RTP overhead. |
| 392 | - video_->FECPacketOverhead() // FEC/ULP/RED overhead. |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 393 | - ((rtx) ? 2 : 0); // RTX overhead. |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 394 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 395 | } |
| 396 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 397 | size_t RTPSender::MaxPayloadLength() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 398 | return max_payload_length_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 399 | } |
| 400 | |
pbos@webrtc.org | 0b0c241 | 2015-01-13 14:15:15 +0000 | [diff] [blame] | 401 | void RTPSender::SetRtxStatus(int mode) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 402 | rtc::CritScope lock(&send_critsect_); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 403 | rtx_ = mode; |
stefan@webrtc.org | ef92755 | 2014-06-05 08:25:29 +0000 | [diff] [blame] | 404 | } |
| 405 | |
pbos@webrtc.org | 0b0c241 | 2015-01-13 14:15:15 +0000 | [diff] [blame] | 406 | int RTPSender::RtxStatus() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 407 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 0b0c241 | 2015-01-13 14:15:15 +0000 | [diff] [blame] | 408 | return rtx_; |
| 409 | } |
| 410 | |
stefan@webrtc.org | ef92755 | 2014-06-05 08:25:29 +0000 | [diff] [blame] | 411 | void RTPSender::SetRtxSsrc(uint32_t ssrc) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 412 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | ef92755 | 2014-06-05 08:25:29 +0000 | [diff] [blame] | 413 | ssrc_rtx_ = ssrc; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 414 | } |
| 415 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 416 | uint32_t RTPSender::RtxSsrc() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 417 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 418 | return ssrc_rtx_; |
| 419 | } |
| 420 | |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 421 | void RTPSender::SetRtxPayloadType(int payload_type, |
| 422 | int associated_payload_type) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 423 | rtc::CritScope lock(&send_critsect_); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 424 | RTC_DCHECK_LE(payload_type, 127); |
| 425 | RTC_DCHECK_LE(associated_payload_type, 127); |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 426 | 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 Persson | 6ae2572 | 2015-04-13 17:48:08 +0200 | [diff] [blame] | 432 | } |
| 433 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 434 | int32_t RTPSender::CheckPayloadType(int8_t payload_type, |
| 435 | RtpVideoCodecTypes* video_type) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 436 | rtc::CritScope lock(&send_critsect_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 437 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 438 | if (payload_type < 0) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 439 | LOG(LS_ERROR) << "Invalid payload_type " << payload_type; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 440 | return -1; |
| 441 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 442 | if (audio_configured_) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 443 | int8_t red_pl_type = -1; |
danilchap | 6db6cdc | 2015-12-15 02:54:47 -0800 | [diff] [blame] | 444 | if (audio_->RED(&red_pl_type) == 0) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 445 | // We have configured RED. |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 446 | if (red_pl_type == payload_type) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 447 | // And it's a match... |
| 448 | return 0; |
| 449 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 450 | } |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 451 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 452 | if (payload_type_ == payload_type) { |
| 453 | if (!audio_configured_) { |
| 454 | *video_type = video_->VideoCodecType(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 455 | } |
| 456 | return 0; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 457 | } |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 458 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 459 | payload_type_map_.find(payload_type); |
| 460 | if (it == payload_type_map_.end()) { |
Stefan Holmer | b86d4e4 | 2015-12-07 10:26:18 +0100 | [diff] [blame] | 461 | LOG(LS_WARNING) << "Payload type " << static_cast<int>(payload_type) |
| 462 | << " not registered."; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 463 | return -1; |
| 464 | } |
andresp@webrtc.org | c3c2911 | 2014-08-27 09:39:43 +0000 | [diff] [blame] | 465 | SetSendPayloadType(payload_type); |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 466 | RtpUtility::Payload* payload = it->second; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 467 | assert(payload); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 468 | if (!payload->audio && !audio_configured_) { |
| 469 | video_->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType); |
| 470 | *video_type = payload->typeSpecific.Video.videoCodecType; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 471 | } |
| 472 | return 0; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 473 | } |
| 474 | |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 475 | RTPSenderInterface::CVOMode RTPSender::ActivateCVORtpHeaderExtension() { |
| 476 | if (cvo_mode_ == kCVOInactive) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 477 | rtc::CritScope lock(&send_critsect_); |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 478 | if (rtp_header_extension_map_.SetActive(kRtpExtensionVideoRotation, true)) { |
| 479 | cvo_mode_ = kCVOActivated; |
| 480 | } |
| 481 | } |
| 482 | return cvo_mode_; |
| 483 | } |
| 484 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 485 | int32_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.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 492 | const RTPVideoHeader* rtp_hdr) { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 493 | uint32_t ssrc; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 494 | { |
| 495 | // Drop this packet if we're not sending media packets. |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 496 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 497 | ssrc = ssrc_; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 498 | if (!sending_media_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 499 | return 0; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 500 | } |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 501 | } |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 502 | RtpVideoCodecTypes video_type = kRtpVideoGeneric; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 503 | if (CheckPayloadType(payload_type, &video_type) != 0) { |
Stefan Holmer | b86d4e4 | 2015-12-07 10:26:18 +0100 | [diff] [blame] | 504 | LOG(LS_ERROR) << "Don't send data with unknown payload type: " |
| 505 | << static_cast<int>(payload_type) << "."; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 506 | return -1; |
| 507 | } |
| 508 | |
Peter Boström | d6f1a38 | 2015-07-14 16:08:02 +0200 | [diff] [blame] | 509 | int32_t ret_val; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 510 | if (audio_configured_) { |
hclam@chromium.org | 1a7b9b9 | 2013-07-08 21:31:18 +0000 | [diff] [blame] | 511 | TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", capture_timestamp, |
| 512 | "Send", "type", FrameTypeToString(frame_type)); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 513 | assert(frame_type == kAudioFrameSpeech || frame_type == kAudioFrameCN || |
pbos | 22993e1 | 2015-10-19 02:39:06 -0700 | [diff] [blame] | 514 | frame_type == kEmptyFrame); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 515 | |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 516 | ret_val = audio_->SendAudio(frame_type, payload_type, capture_timestamp, |
| 517 | payload_data, payload_size, fragmentation); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 518 | } else { |
hclam@chromium.org | 1a7b9b9 | 2013-07-08 21:31:18 +0000 | [diff] [blame] | 519 | TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms, |
| 520 | "Send", "type", FrameTypeToString(frame_type)); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 521 | assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 522 | |
pbos | 22993e1 | 2015-10-19 02:39:06 -0700 | [diff] [blame] | 523 | if (frame_type == kEmptyFrame) |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 524 | return 0; |
| 525 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 526 | ret_val = |
| 527 | video_->SendVideo(video_type, frame_type, payload_type, |
| 528 | capture_timestamp, capture_time_ms, payload_data, |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 529 | payload_size, fragmentation, rtp_hdr); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 530 | } |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 531 | |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 532 | rtc::CritScope cs(&statistics_crit_); |
pbos@webrtc.org | ce4e9a3 | 2014-12-18 13:50:16 +0000 | [diff] [blame] | 533 | // 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.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 539 | if (frame_count_observer_) { |
pbos@webrtc.org | ce4e9a3 | 2014-12-18 13:50:16 +0000 | [diff] [blame] | 540 | frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc); |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 541 | } |
| 542 | |
| 543 | return ret_val; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 544 | } |
| 545 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 546 | size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) { |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 547 | { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 548 | rtc::CritScope lock(&send_critsect_); |
Peter Boström | fc968a2 | 2016-02-19 16:14:37 +0100 | [diff] [blame] | 549 | if (!sending_media_) |
| 550 | return 0; |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 551 | if ((rtx_ & kRtxRedundantPayloads) == 0) |
| 552 | return 0; |
| 553 | } |
| 554 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 555 | uint8_t buffer[IP_PACKET_SIZE]; |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 556 | int bytes_left = static_cast<int>(bytes_to_send); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 557 | while (bytes_left > 0) { |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 558 | size_t length = bytes_left; |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 559 | int64_t capture_time_ms; |
| 560 | if (!packet_history_.GetBestFittingPacket(buffer, &length, |
| 561 | &capture_time_ms)) { |
| 562 | break; |
| 563 | } |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 564 | if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false)) |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 565 | break; |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 566 | RtpUtility::RtpHeaderParser rtp_parser(buffer, length); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 567 | RTPHeader rtp_header; |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 568 | rtp_parser.Parse(&rtp_header); |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 569 | bytes_left -= static_cast<int>(length - rtp_header.headerLength); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 570 | } |
| 571 | return bytes_to_send - bytes_left; |
| 572 | } |
| 573 | |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 574 | void RTPSender::BuildPaddingPacket(uint8_t* packet, |
| 575 | size_t header_length, |
| 576 | size_t padding_length) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 577 | packet[0] |= 0x20; // Set padding bit. |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 578 | int32_t* data = reinterpret_cast<int32_t*>(&(packet[header_length])); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 579 | |
| 580 | // Fill data buffer with random data. |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 581 | for (size_t j = 0; j < (padding_length >> 2); ++j) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 582 | data[j] = rand(); // NOLINT |
| 583 | } |
| 584 | // Set number of padding bytes in the last byte of the packet. |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 585 | packet[header_length + padding_length - 1] = |
| 586 | static_cast<uint8_t>(padding_length); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 587 | } |
| 588 | |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 589 | size_t RTPSender::SendPadData(size_t bytes, |
| 590 | bool timestamp_provided, |
| 591 | uint32_t timestamp, |
| 592 | int64_t capture_time_ms) { |
sprang | ebbf8a8 | 2015-09-21 15:11:14 -0700 | [diff] [blame] | 593 | // Always send full padding packets. This is accounted for by the |
| 594 | // RtpPacketSender, |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 595 | // 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.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 599 | size_t bytes_sent = 0; |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 600 | bool using_transport_seq = rtp_header_extension_map_.IsRegistered( |
| 601 | kRtpExtensionTransportSequenceNumber) && |
sprang | ebbf8a8 | 2015-09-21 15:11:14 -0700 | [diff] [blame] | 602 | transport_sequence_number_allocator_; |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 603 | for (; bytes > 0; bytes -= padding_bytes_in_packet) { |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 604 | if (bytes < padding_bytes_in_packet) |
| 605 | bytes = padding_bytes_in_packet; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 606 | |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 607 | uint32_t ssrc; |
| 608 | uint16_t sequence_number; |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 609 | int payload_type; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 610 | bool over_rtx; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 611 | { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 612 | rtc::CritScope lock(&send_critsect_); |
Peter Boström | fc968a2 | 2016-02-19 16:14:37 +0100 | [diff] [blame] | 613 | if (!sending_media_) |
| 614 | return bytes_sent; |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 615 | if (!timestamp_provided) { |
| 616 | timestamp = timestamp_; |
| 617 | capture_time_ms = capture_time_ms_; |
| 618 | } |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 619 | if (rtx_ == kRtxOff) { |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 620 | // Without RTX we can't send padding in the middle of frames. |
| 621 | if (!last_packet_marker_bit_) |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 622 | return 0; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 623 | ssrc = ssrc_; |
| 624 | sequence_number = sequence_number_; |
| 625 | ++sequence_number_; |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 626 | payload_type = payload_type_; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 627 | over_rtx = false; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 628 | } else { |
Stefan Holmer | f5dca48 | 2016-01-27 12:58:51 +0100 | [diff] [blame] | 629 | // 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.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 636 | return 0; |
Stefan Holmer | f5dca48 | 2016-01-27 12:58:51 +0100 | [diff] [blame] | 637 | } |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 638 | // 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.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 647 | ssrc = ssrc_rtx_; |
| 648 | sequence_number = sequence_number_rtx_; |
| 649 | ++sequence_number_rtx_; |
Stefan Holmer | 1088001 | 2016-02-03 13:29:59 +0100 | [diff] [blame] | 650 | payload_type = rtx_payload_type_map_.begin()->second; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 651 | over_rtx = true; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 652 | } |
| 653 | } |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 654 | |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 655 | uint8_t padding_packet[IP_PACKET_SIZE]; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 656 | size_t header_length = |
| 657 | CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp, |
| 658 | sequence_number, std::vector<uint32_t>()); |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 659 | BuildPaddingPacket(padding_packet, header_length, padding_bytes_in_packet); |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 660 | size_t length = padding_bytes_in_packet + header_length; |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 661 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 662 | |
| 663 | RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length); |
| 664 | RTPHeader rtp_header; |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 665 | rtp_parser.Parse(&rtp_header); |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 666 | |
| 667 | if (capture_time_ms > 0) { |
| 668 | UpdateTransmissionTimeOffset( |
| 669 | padding_packet, length, rtp_header, now_ms - capture_time_ms); |
pwestin@webrtc.org | 12d97f6 | 2012-01-05 10:54:44 +0000 | [diff] [blame] | 670 | } |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 671 | |
| 672 | UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms); |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 673 | |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 674 | PacketOptions options; |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 675 | if (using_transport_seq) { |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 676 | options.packet_id = |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 677 | UpdateTransportSequenceNumber(padding_packet, length, rtp_header); |
| 678 | } |
| 679 | |
sprang | 5e023eb | 2015-09-14 06:42:43 -0700 | [diff] [blame] | 680 | if (using_transport_seq && transport_feedback_observer_) { |
stefan | bbe876f | 2015-10-23 02:05:40 -0700 | [diff] [blame] | 681 | transport_feedback_observer_->AddPacket(options.packet_id, length, true); |
sprang | 5e023eb | 2015-09-14 06:42:43 -0700 | [diff] [blame] | 682 | } |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 683 | |
stefan | f116bd0 | 2015-10-27 08:29:42 -0700 | [diff] [blame] | 684 | if (!SendPacketToNetwork(padding_packet, length, options)) |
| 685 | break; |
| 686 | |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 687 | bytes_sent += padding_bytes_in_packet; |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 688 | UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false); |
pwestin@webrtc.org | 12d97f6 | 2012-01-05 10:54:44 +0000 | [diff] [blame] | 689 | } |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 690 | |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 691 | return bytes_sent; |
pwestin@webrtc.org | 12d97f6 | 2012-01-05 10:54:44 +0000 | [diff] [blame] | 692 | } |
| 693 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 694 | void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) { |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 695 | packet_history_.SetStorePacketsStatus(enable, number_to_store); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 696 | } |
| 697 | |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 698 | bool RTPSender::StorePackets() const { |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 699 | return packet_history_.StorePackets(); |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 700 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 701 | |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 702 | int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) { |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 703 | size_t length = IP_PACKET_SIZE; |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 704 | uint8_t data_buffer[IP_PACKET_SIZE]; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 705 | int64_t capture_time_ms; |
sprang | 861c55e | 2015-10-16 10:01:21 -0700 | [diff] [blame] | 706 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 707 | if (!packet_history_.GetPacketAndSetSendTime(packet_id, min_resend_time, true, |
| 708 | data_buffer, &length, |
| 709 | &capture_time_ms)) { |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 710 | // Packet not found. |
asapersson@webrtc.org | 83ed0a4 | 2012-04-23 12:43:05 +0000 | [diff] [blame] | 711 | return 0; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 712 | } |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 713 | |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 714 | if (paced_sender_) { |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 715 | RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length); |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 716 | RTPHeader header; |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 717 | if (!rtp_parser.Parse(&header)) { |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 718 | assert(false); |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 719 | return -1; |
| 720 | } |
stefan@webrtc.org | 88e0dda | 2014-07-04 09:20:42 +0000 | [diff] [blame] | 721 | // Convert from TickTime to Clock since capture_time_ms is based on |
| 722 | // TickTime. |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 723 | int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_; |
Peter Boström | e23e737 | 2015-10-08 11:44:14 +0200 | [diff] [blame] | 724 | paced_sender_->InsertPacket( |
Stefan Holmer | b86d4e4 | 2015-12-07 10:26:18 +0100 | [diff] [blame] | 725 | RtpPacketSender::kNormalPriority, header.ssrc, header.sequenceNumber, |
Peter Boström | e23e737 | 2015-10-08 11:44:14 +0200 | [diff] [blame] | 726 | corrected_capture_tims_ms, length - header.headerLength, true); |
| 727 | |
| 728 | return length; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 729 | } |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 730 | int rtx = kRtxOff; |
| 731 | { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 732 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 733 | rtx = rtx_; |
| 734 | } |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 735 | 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.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 740 | } |
| 741 | |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 742 | bool RTPSender::SendPacketToNetwork(const uint8_t* packet, |
| 743 | size_t size, |
| 744 | const PacketOptions& options) { |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 745 | int bytes_sent = -1; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 746 | if (transport_) { |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 747 | bytes_sent = transport_->SendRtp(packet, size, options) |
| 748 | ? static_cast<int>(size) |
| 749 | : -1; |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 750 | if (event_log_ && bytes_sent > 0) { |
| 751 | event_log_->LogRtpHeader(kOutgoingPacket, MediaType::ANY, packet, size); |
| 752 | } |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 753 | } |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 754 | TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
| 755 | "RTPSender::SendPacketToNetwork", "size", size, "sent", |
| 756 | bytes_sent); |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 757 | // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer. |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 758 | if (bytes_sent <= 0) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 759 | LOG(LS_WARNING) << "Transport failed to send packet"; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 760 | return false; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 761 | } |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 762 | return true; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 763 | } |
| 764 | |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 765 | int RTPSender::SelectiveRetransmissions() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 766 | if (!video_) |
| 767 | return -1; |
| 768 | return video_->SelectiveRetransmissions(); |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 769 | } |
| 770 | |
| 771 | int RTPSender::SetSelectiveRetransmissions(uint8_t settings) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 772 | if (!video_) |
| 773 | return -1; |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 774 | video_->SetSelectiveRetransmissions(settings); |
| 775 | return 0; |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 776 | } |
| 777 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 778 | void RTPSender::OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers, |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 779 | int64_t avg_rtt) { |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 780 | TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
| 781 | "RTPSender::OnReceivedNACK", "num_seqnum", |
| 782 | nack_sequence_numbers.size(), "avg_rtt", avg_rtt); |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 783 | const int64_t now = clock_->TimeInMilliseconds(); |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 784 | uint32_t bytes_re_sent = 0; |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 785 | uint32_t target_bitrate = GetTargetBitrate(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 786 | |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 787 | // Enough bandwidth to send NACK? |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 788 | if (!ProcessNACKBitRate(now)) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 789 | LOG(LS_INFO) << "NACK bitrate reached. Skip sending NACK response. Target " |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 790 | << target_bitrate; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 791 | return; |
| 792 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 793 | |
stefan@webrtc.org | becf9c8 | 2013-02-01 15:09:57 +0000 | [diff] [blame] | 794 | for (std::list<uint16_t>::const_iterator it = nack_sequence_numbers.begin(); |
| 795 | it != nack_sequence_numbers.end(); ++it) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 796 | const int32_t bytes_sent = ReSendPacket(*it, 5 + avg_rtt); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 797 | if (bytes_sent > 0) { |
| 798 | bytes_re_sent += bytes_sent; |
| 799 | } else if (bytes_sent == 0) { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 800 | // The packet has previously been resent. |
| 801 | // Try resending next packet in the list. |
| 802 | continue; |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 803 | } else { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 804 | // Failed to send one Sequence number. Give up the rest in this nack. |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 805 | LOG(LS_WARNING) << "Failed resending RTP packet " << *it |
| 806 | << ", Discard rest of packets"; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 807 | break; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 808 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 809 | // Delay bandwidth estimate (RTT * BW). |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 810 | if (target_bitrate != 0 && avg_rtt) { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 811 | // kbits/s * ms = bits => bits/8 = bytes |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 812 | size_t target_bytes = |
| 813 | (static_cast<size_t>(target_bitrate / 1000) * avg_rtt) >> 3; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 814 | if (bytes_re_sent > target_bytes) { |
| 815 | break; // Ignore the rest of the packets in the list. |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 816 | } |
| 817 | } |
| 818 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 819 | if (bytes_re_sent > 0) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 820 | UpdateNACKBitRate(bytes_re_sent, now); |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 821 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 822 | } |
| 823 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 824 | bool RTPSender::ProcessNACKBitRate(uint32_t now) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 825 | uint32_t num = 0; |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 826 | size_t byte_count = 0; |
henrike@webrtc.org | fe526ff | 2014-06-25 20:59:51 +0000 | [diff] [blame] | 827 | const uint32_t kAvgIntervalMs = 1000; |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 828 | uint32_t target_bitrate = GetTargetBitrate(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 829 | |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 830 | rtc::CritScope lock(&send_critsect_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 831 | |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 832 | if (target_bitrate == 0) { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 833 | return true; |
| 834 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 835 | for (num = 0; num < NACK_BYTECOUNT_SIZE; ++num) { |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 836 | if ((now - nack_byte_count_times_[num]) > kAvgIntervalMs) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 837 | // Don't use data older than 1sec. |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 838 | break; |
| 839 | } else { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 840 | byte_count += nack_byte_count_[num]; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 841 | } |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 842 | } |
henrike@webrtc.org | fe526ff | 2014-06-25 20:59:51 +0000 | [diff] [blame] | 843 | uint32_t time_interval = kAvgIntervalMs; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 844 | if (num == NACK_BYTECOUNT_SIZE) { |
| 845 | // More than NACK_BYTECOUNT_SIZE nack messages has been received |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 846 | // during the last msg_interval. |
henrike@webrtc.org | fe526ff | 2014-06-25 20:59:51 +0000 | [diff] [blame] | 847 | if (nack_byte_count_times_[num - 1] <= now) { |
| 848 | time_interval = now - nack_byte_count_times_[num - 1]; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 849 | } |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 850 | } |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 851 | return (byte_count * 8) < (target_bitrate / 1000 * time_interval); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 852 | } |
| 853 | |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 854 | void RTPSender::UpdateNACKBitRate(uint32_t bytes, int64_t now) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 855 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 856 | if (bytes == 0) |
| 857 | return; |
| 858 | nack_bitrate_.Update(bytes); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 859 | // Save bitrate statistics. |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 860 | // 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.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 864 | } |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 865 | nack_byte_count_[0] = bytes; |
| 866 | nack_byte_count_times_[0] = now; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 867 | } |
| 868 | |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 869 | // Called from pacer when we can send the packet. |
hclam@chromium.org | 2e402ce | 2013-06-20 20:18:31 +0000 | [diff] [blame] | 870 | bool RTPSender::TimeToSendPacket(uint16_t sequence_number, |
stefan@webrtc.org | 9b82f5a | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 871 | int64_t capture_time_ms, |
| 872 | bool retransmission) { |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 873 | size_t length = IP_PACKET_SIZE; |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 874 | uint8_t data_buffer[IP_PACKET_SIZE]; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 875 | int64_t stored_time_ms; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 876 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 877 | if (!packet_history_.GetPacketAndSetSendTime(sequence_number, |
| 878 | 0, |
| 879 | retransmission, |
| 880 | data_buffer, |
| 881 | &length, |
| 882 | &stored_time_ms)) { |
hclam@chromium.org | 2e402ce | 2013-06-20 20:18:31 +0000 | [diff] [blame] | 883 | // Packet cannot be found. Allow sending to continue. |
| 884 | return true; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 885 | } |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 886 | if (!retransmission && capture_time_ms > 0) { |
| 887 | UpdateDelayStatistics(capture_time_ms, clock_->TimeInMilliseconds()); |
| 888 | } |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 889 | int rtx; |
| 890 | { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 891 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 892 | rtx = rtx_; |
| 893 | } |
| 894 | return PrepareAndSendPacket(data_buffer, |
| 895 | length, |
| 896 | capture_time_ms, |
| 897 | retransmission && (rtx & kRtxRetransmitted) > 0, |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 898 | retransmission); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 899 | } |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 900 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 901 | bool RTPSender::PrepareAndSendPacket(uint8_t* buffer, |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 902 | size_t length, |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 903 | int64_t capture_time_ms, |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 904 | bool send_over_rtx, |
| 905 | bool is_retransmit) { |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 906 | uint8_t* buffer_to_send_ptr = buffer; |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 907 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 908 | RtpUtility::RtpHeaderParser rtp_parser(buffer, length); |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 909 | RTPHeader rtp_header; |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 910 | rtp_parser.Parse(&rtp_header); |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 911 | if (!is_retransmit && rtp_header.markerBit) { |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 912 | TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend", |
| 913 | capture_time_ms); |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 914 | } |
| 915 | |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 916 | TRACE_EVENT_INSTANT2( |
| 917 | TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PrepareAndSendPacket", |
| 918 | "timestamp", rtp_header.timestamp, "seqnum", rtp_header.sequenceNumber); |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 919 | |
stefan@webrtc.org | 9b82f5a | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 920 | uint8_t data_buffer_rtx[IP_PACKET_SIZE]; |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 921 | if (send_over_rtx) { |
| 922 | BuildRtxPacket(buffer, &length, data_buffer_rtx); |
stefan@webrtc.org | 9b82f5a | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 923 | buffer_to_send_ptr = data_buffer_rtx; |
| 924 | } |
| 925 | |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 926 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 927 | int64_t diff_ms = now_ms - capture_time_ms; |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 928 | UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header, |
| 929 | diff_ms); |
| 930 | UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms); |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 931 | |
sprang | 5e023eb | 2015-09-14 06:42:43 -0700 | [diff] [blame] | 932 | // TODO(sprang): Potentially too much overhead in IsRegistered()? |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 933 | bool using_transport_seq = rtp_header_extension_map_.IsRegistered( |
| 934 | kRtpExtensionTransportSequenceNumber) && |
sprang | 861c55e | 2015-10-16 10:01:21 -0700 | [diff] [blame] | 935 | transport_sequence_number_allocator_; |
| 936 | |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 937 | PacketOptions options; |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 938 | if (using_transport_seq) { |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 939 | options.packet_id = |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 940 | UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header); |
| 941 | } |
| 942 | |
stefan | f116bd0 | 2015-10-27 08:29:42 -0700 | [diff] [blame] | 943 | if (using_transport_seq && transport_feedback_observer_) { |
| 944 | transport_feedback_observer_->AddPacket(options.packet_id, length, true); |
| 945 | } |
| 946 | |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 947 | bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 948 | if (ret) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 949 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 950 | media_has_been_sent_ = true; |
| 951 | } |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 952 | UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx, |
| 953 | is_retransmit); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 954 | return ret; |
| 955 | } |
| 956 | |
| 957 | void RTPSender::UpdateRtpStats(const uint8_t* buffer, |
asapersson@webrtc.org | 97d0489 | 2014-12-09 09:47:53 +0000 | [diff] [blame] | 958 | size_t packet_length, |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 959 | const RTPHeader& header, |
| 960 | bool is_rtx, |
| 961 | bool is_retransmit) { |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 962 | StreamDataCounters* counters; |
sprang@webrtc.org | 5314e85 | 2014-01-27 13:20:36 +0000 | [diff] [blame] | 963 | // Get ssrc before taking statistics_crit_ to avoid possible deadlock. |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 964 | uint32_t ssrc = is_rtx ? RtxSsrc() : SSRC(); |
sprang@webrtc.org | 5314e85 | 2014-01-27 13:20:36 +0000 | [diff] [blame] | 965 | |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 966 | rtc::CritScope lock(&statistics_crit_); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 967 | if (is_rtx) { |
| 968 | counters = &rtx_rtp_stats_; |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 969 | } else { |
| 970 | counters = &rtp_stats_; |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 971 | } |
| 972 | |
asapersson@webrtc.org | 97d0489 | 2014-12-09 09:47:53 +0000 | [diff] [blame] | 973 | total_bitrate_sent_.Update(packet_length); |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 974 | |
asapersson@webrtc.org | cfd82df | 2015-01-22 09:39:59 +0000 | [diff] [blame] | 975 | if (counters->first_packet_time_ms == -1) { |
asapersson@webrtc.org | d08d389 | 2014-12-16 12:03:11 +0000 | [diff] [blame] | 976 | counters->first_packet_time_ms = clock_->TimeInMilliseconds(); |
| 977 | } |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 978 | if (IsFecPacket(buffer, header)) { |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 979 | counters->fec.AddPacket(packet_length, header); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 980 | } |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 981 | if (is_retransmit) { |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 982 | counters->retransmitted.AddPacket(packet_length, header); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 983 | } |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 984 | counters->transmitted.AddPacket(packet_length, header); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 985 | |
| 986 | if (rtp_stats_callback_) { |
| 987 | rtp_stats_callback_->DataCountersUpdated(*counters, ssrc); |
| 988 | } |
| 989 | } |
| 990 | |
| 991 | bool 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; |
danilchap | 6db6cdc | 2015-12-15 02:54:47 -0800 | [diff] [blame] | 999 | video_->GenericFECStatus(&fec_enabled, &pt_red, &pt_fec); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1000 | return fec_enabled && |
| 1001 | header.payloadType == pt_red && |
| 1002 | buffer[header.headerLength] == pt_fec; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 1003 | } |
| 1004 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1005 | size_t RTPSender::TimeToSendPadding(size_t bytes) { |
Stefan Holmer | b86d4e4 | 2015-12-07 10:26:18 +0100 | [diff] [blame] | 1006 | if (audio_configured_ || bytes == 0) |
pbos | 545727e | 2015-07-01 06:31:06 -0700 | [diff] [blame] | 1007 | return 0; |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1008 | size_t bytes_sent = TrySendRedundantPayloads(bytes); |
| 1009 | if (bytes_sent < bytes) |
Stefan Holmer | 586b19b | 2015-09-18 11:14:31 +0200 | [diff] [blame] | 1010 | bytes_sent += SendPadData(bytes - bytes_sent, false, 0, 0); |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1011 | return bytes_sent; |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 1012 | } |
| 1013 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 1014 | // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again. |
sprang | ebbf8a8 | 2015-09-21 15:11:14 -0700 | [diff] [blame] | 1015 | int32_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) { |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 1021 | size_t length = payload_length + rtp_header_length; |
| 1022 | RtpUtility::RtpHeaderParser rtp_parser(buffer, length); |
| 1023 | |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1024 | RTPHeader rtp_header; |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 1025 | rtp_parser.Parse(&rtp_header); |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 1026 | |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1027 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 1028 | |
stefan@webrtc.org | 715faaf | 2012-08-28 15:20:39 +0000 | [diff] [blame] | 1029 | // |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) { |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 1033 | UpdateTransmissionTimeOffset(buffer, length, rtp_header, |
| 1034 | now_ms - capture_time_ms); |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 1035 | } |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1036 | |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 1037 | UpdateAbsoluteSendTime(buffer, length, rtp_header, now_ms); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1038 | |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 1039 | // Used for NACK and to spread out the transmission of packets. |
terelius | 429c345 | 2016-01-21 05:42:04 -0800 | [diff] [blame] | 1040 | if (packet_history_.PutRTPPacket(buffer, length, capture_time_ms, storage) != |
| 1041 | 0) { |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 1042 | return -1; |
| 1043 | } |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1044 | |
Peter Boström | e23e737 | 2015-10-08 11:44:14 +0200 | [diff] [blame] | 1045 | if (paced_sender_) { |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 1046 | // 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öm | e23e737 | 2015-10-08 11:44:14 +0200 | [diff] [blame] | 1049 | 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.org | e5b49a0 | 2012-11-06 13:09:39 +0000 | [diff] [blame] | 1058 | } |
Peter Boström | e23e737 | 2015-10-08 11:44:14 +0200 | [diff] [blame] | 1059 | return 0; |
stefan@webrtc.org | ddfdfed | 2012-07-03 13:21:22 +0000 | [diff] [blame] | 1060 | } |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 1061 | if (capture_time_ms > 0) { |
| 1062 | UpdateDelayStatistics(capture_time_ms, now_ms); |
| 1063 | } |
sprang@webrtc.org | 43c8839 | 2015-01-29 09:09:17 +0000 | [diff] [blame] | 1064 | |
Stefan Holmer | f5dca48 | 2016-01-27 12:58:51 +0100 | [diff] [blame] | 1065 | // 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.org | c957ffc | 2015-02-02 13:08:02 +0000 | [diff] [blame] | 1080 | |
Peter Boström | e23e737 | 2015-10-08 11:44:14 +0200 | [diff] [blame] | 1081 | // 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.org | c957ffc | 2015-02-02 13:08:02 +0000 | [diff] [blame] | 1086 | if (!sent) |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1087 | return -1; |
sprang@webrtc.org | c957ffc | 2015-02-02 13:08:02 +0000 | [diff] [blame] | 1088 | |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1089 | { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1090 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1091 | media_has_been_sent_ = true; |
| 1092 | } |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1093 | UpdateRtpStats(buffer, length, rtp_header, false, false); |
| 1094 | return 0; |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 1095 | } |
| 1096 | |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 1097 | void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { |
Peter Boström | 71861a0 | 2015-05-28 14:45:36 +0200 | [diff] [blame] | 1098 | if (!send_side_delay_observer_) |
| 1099 | return; |
| 1100 | |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 1101 | uint32_t ssrc; |
| 1102 | int avg_delay_ms = 0; |
| 1103 | int max_delay_ms = 0; |
| 1104 | { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1105 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 1106 | ssrc = ssrc_; |
| 1107 | } |
| 1108 | { |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 1109 | rtc::CritScope cs(&statistics_crit_); |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 1110 | // 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öm | 71861a0 | 2015-05-28 14:45:36 +0200 | [diff] [blame] | 1115 | 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.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 1125 | } |
Peter Boström | 71861a0 | 2015-05-28 14:45:36 +0200 | [diff] [blame] | 1126 | send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, max_delay_ms, |
| 1127 | ssrc); |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 1128 | } |
| 1129 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1130 | void RTPSender::ProcessBitrate() { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1131 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1132 | total_bitrate_sent_.Process(); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1133 | nack_bitrate_.Process(); |
| 1134 | if (audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1135 | return; |
| 1136 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1137 | video_->ProcessBitrate(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1138 | } |
| 1139 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1140 | size_t RTPSender::RTPHeaderLength() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1141 | rtc::CritScope lock(&send_critsect_); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1142 | size_t rtp_header_length = kRtpHeaderLength; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1143 | rtp_header_length += sizeof(uint32_t) * csrcs_.size(); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1144 | rtp_header_length += RtpHeaderExtensionTotalLength(); |
| 1145 | return rtp_header_length; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1146 | } |
| 1147 | |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 1148 | uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1149 | rtc::CritScope lock(&send_critsect_); |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 1150 | uint16_t first_allocated_sequence_number = sequence_number_; |
| 1151 | sequence_number_ += packets_to_send; |
| 1152 | return first_allocated_sequence_number; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1153 | } |
| 1154 | |
pbos@webrtc.org | 2f4b14e | 2014-07-15 15:25:39 +0000 | [diff] [blame] | 1155 | void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats, |
| 1156 | StreamDataCounters* rtx_stats) const { |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 1157 | rtc::CritScope lock(&statistics_crit_); |
pbos@webrtc.org | 2f4b14e | 2014-07-15 15:25:39 +0000 | [diff] [blame] | 1158 | *rtp_stats = rtp_stats_; |
| 1159 | *rtx_stats = rtx_rtp_stats_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1160 | } |
| 1161 | |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1162 | size_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.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1169 | header[0] = 0x80; // version 2. |
| 1170 | header[1] = static_cast<uint8_t>(payload_type); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1171 | if (marker_bit) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1172 | header[1] |= kRtpMarkerBitMask; // Marker bit is set. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1173 | } |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1174 | 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.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1177 | int32_t rtp_header_length = kRtpHeaderLength; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1178 | |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1179 | if (csrcs.size() > 0) { |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 1180 | uint8_t* ptr = &header[rtp_header_length]; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1181 | for (size_t i = 0; i < csrcs.size(); ++i) { |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1182 | ByteWriter<uint32_t>::WriteBigEndian(ptr, csrcs[i]); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1183 | ptr += 4; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1184 | } |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1185 | header[0] = (header[0] & 0xf0) | csrcs.size(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1186 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1187 | // Update length of header. |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1188 | rtp_header_length += sizeof(uint32_t) * csrcs.size(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1189 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1190 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1191 | uint16_t len = |
| 1192 | BuildRTPHeaderExtension(header + rtp_header_length, marker_bit); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1193 | if (len > 0) { |
| 1194 | header[0] |= 0x10; // Set extension bit. |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1195 | rtp_header_length += len; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1196 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1197 | return rtp_header_length; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1198 | } |
| 1199 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1200 | int32_t RTPSender::BuildRTPheader(uint8_t* data_buffer, |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1201 | int8_t payload_type, |
| 1202 | bool marker_bit, |
| 1203 | uint32_t capture_timestamp, |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1204 | int64_t capture_time_ms, |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1205 | bool timestamp_provided, |
| 1206 | bool inc_sequence_number) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1207 | assert(payload_type >= 0); |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1208 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1209 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1210 | if (timestamp_provided) { |
| 1211 | timestamp_ = start_timestamp_ + capture_timestamp; |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1212 | } 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.org | 6e95d7a | 2013-11-15 08:59:19 +0000 | [diff] [blame] | 1218 | last_timestamp_time_ms_ = clock_->TimeInMilliseconds(); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1219 | uint32_t sequence_number = sequence_number_++; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 1220 | capture_time_ms_ = capture_time_ms; |
| 1221 | last_packet_marker_bit_ = marker_bit; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1222 | return CreateRtpHeader(data_buffer, payload_type, ssrc_, marker_bit, |
| 1223 | timestamp_, sequence_number, csrcs_); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1224 | } |
| 1225 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1226 | uint16_t RTPSender::BuildRTPHeaderExtension(uint8_t* data_buffer, |
| 1227 | bool marker_bit) const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1228 | if (rtp_header_extension_map_.Size() <= 0) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1229 | return 0; |
| 1230 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1231 | // 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.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1240 | const uint32_t kPosLength = 2; |
pbos@webrtc.org | 3004c79 | 2013-05-07 12:36:21 +0000 | [diff] [blame] | 1241 | const uint32_t kHeaderLength = kRtpOneByteHeaderLength; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1242 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1243 | // Add extension ID (0xBEDE). |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1244 | ByteWriter<uint16_t>::WriteBigEndian(data_buffer, |
| 1245 | kRtpOneByteHeaderExtensionId); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1246 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1247 | // Add extensions. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1248 | uint16_t total_block_length = 0; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1249 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1250 | RTPExtensionType type = rtp_header_extension_map_.First(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1251 | while (type != kRtpExtensionNone) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1252 | uint8_t block_length = 0; |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1253 | uint8_t* extension_data = &data_buffer[kHeaderLength + total_block_length]; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1254 | switch (type) { |
| 1255 | case kRtpExtensionTransmissionTimeOffset: |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1256 | block_length = BuildTransmissionTimeOffsetExtension(extension_data); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1257 | break; |
solenberg@webrtc.org | c0352d5 | 2013-05-20 20:55:07 +0000 | [diff] [blame] | 1258 | case kRtpExtensionAudioLevel: |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1259 | block_length = BuildAudioLevelExtension(extension_data); |
solenberg@webrtc.org | c0352d5 | 2013-05-20 20:55:07 +0000 | [diff] [blame] | 1260 | break; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1261 | case kRtpExtensionAbsoluteSendTime: |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1262 | block_length = BuildAbsoluteSendTimeExtension(extension_data); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1263 | break; |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1264 | case kRtpExtensionVideoRotation: |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame] | 1265 | block_length = BuildVideoRotationExtension(extension_data); |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1266 | break; |
| 1267 | case kRtpExtensionTransportSequenceNumber: |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1268 | block_length = BuildTransportSequenceNumberExtension( |
| 1269 | extension_data, transport_sequence_number_); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1270 | break; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1271 | default: |
| 1272 | assert(false); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1273 | } |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1274 | total_block_length += block_length; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1275 | type = rtp_header_extension_map_.Next(type); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1276 | } |
| 1277 | if (total_block_length == 0) { |
| 1278 | // No extension added. |
| 1279 | return 0; |
| 1280 | } |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1281 | // 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.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1288 | // Set header length (in number of Word32, header excluded). |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1289 | ByteWriter<uint16_t>::WriteBigEndian(data_buffer + kPosLength, |
| 1290 | total_block_length / 4); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1291 | // Total added length. |
| 1292 | return kHeaderLength + total_block_length; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1293 | } |
| 1294 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1295 | uint8_t RTPSender::BuildTransmissionTimeOffsetExtension( |
| 1296 | uint8_t* data_buffer) const { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1297 | // 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.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1313 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1314 | // Get id defined by user. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1315 | uint8_t id; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1316 | if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset, |
| 1317 | &id) != 0) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1318 | // Not registered. |
| 1319 | return 0; |
| 1320 | } |
pbos@webrtc.org | 3004c79 | 2013-05-07 12:36:21 +0000 | [diff] [blame] | 1321 | size_t pos = 0; |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1322 | const uint8_t len = 2; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1323 | data_buffer[pos++] = (id << 4) + len; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1324 | ByteWriter<int32_t, 3>::WriteBigEndian(data_buffer + pos, |
| 1325 | transmission_time_offset_); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1326 | pos += 3; |
pbos@webrtc.org | 3004c79 | 2013-05-07 12:36:21 +0000 | [diff] [blame] | 1327 | assert(pos == kTransmissionTimeOffsetLength); |
| 1328 | return kTransmissionTimeOffsetLength; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1329 | } |
| 1330 | |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1331 | uint8_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.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1338 | // 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.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1343 | // |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1344 | |
| 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.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1355 | assert(pos == kAudioLevelLength); |
| 1356 | return kAudioLevelLength; |
| 1357 | } |
| 1358 | |
| 1359 | uint8_t RTPSender::BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const { |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1360 | // 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.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1386 | ByteWriter<uint32_t, 3>::WriteBigEndian(data_buffer + pos, |
| 1387 | absolute_send_time_); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1388 | pos += 3; |
| 1389 | assert(pos == kAbsoluteSendTimeLength); |
| 1390 | return kAbsoluteSendTimeLength; |
| 1391 | } |
| 1392 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1393 | uint8_t RTPSender::BuildVideoRotationExtension(uint8_t* data_buffer) const { |
| 1394 | // Coordination of Video Orientation in RTP streams. |
| 1395 | // |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1396 | // Coordination of Video Orientation consists in signaling of the current |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1397 | // orientation of the image captured on the sender side to the receiver for |
| 1398 | // appropriate rendering and displaying. |
| 1399 | // |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1400 | // 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.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1405 | // |
| 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.org | fdd1057 | 2015-03-12 20:50:57 +0000 | [diff] [blame] | 1416 | data_buffer[pos++] = ConvertVideoRotationToCVOByte(rotation_); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1417 | assert(pos == kVideoRotationLength); |
| 1418 | return kVideoRotationLength; |
| 1419 | } |
| 1420 | |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1421 | uint8_t RTPSender::BuildTransportSequenceNumberExtension( |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1422 | uint8_t* data_buffer, |
| 1423 | uint16_t sequence_number) const { |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1424 | // 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; |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1440 | ByteWriter<uint16_t>::WriteBigEndian(data_buffer + pos, sequence_number); |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1441 | pos += 2; |
| 1442 | assert(pos == kTransportSequenceNumberLength); |
| 1443 | return kTransportSequenceNumberLength; |
| 1444 | } |
| 1445 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1446 | bool 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 | |
danilchap | d9e62f5 | 2016-01-14 14:55:19 -0800 | [diff] [blame] | 1462 | size_t extension_pos = |
| 1463 | kRtpHeaderLength + rtp_header.numCSRCs * sizeof(uint32_t); |
| 1464 | size_t block_pos = extension_pos + extension_block_pos; |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1465 | 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. |
danilchap | d9e62f5 | 2016-01-14 14:55:19 -0800 | [diff] [blame] | 1473 | if (!(rtp_packet[extension_pos] == 0xBE && |
| 1474 | rtp_packet[extension_pos + 1] == 0xDE)) { |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1475 | 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 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1484 | RTPSender::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 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1501 | // 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.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1510 | void RTPSender::UpdateTransmissionTimeOffset(uint8_t* rtp_packet, |
| 1511 | size_t rtp_packet_length, |
| 1512 | const RTPHeader& rtp_header, |
| 1513 | int64_t time_diff_ms) const { |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1514 | size_t offset; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1515 | rtc::CritScope lock(&send_critsect_); |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1516 | 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.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1528 | } |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1529 | |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1530 | // Update transmission offset field (converting to a 90 kHz timestamp). |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1531 | ByteWriter<int32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1532 | time_diff_ms * 90); // RTP timestamp. |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 1533 | } |
| 1534 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1535 | bool 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 { |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1540 | size_t offset; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1541 | rtc::CritScope lock(&send_critsect_); |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1542 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1543 | 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.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1555 | } |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1556 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1557 | rtp_packet[offset + 1] = (is_voiced ? 0x80 : 0x00) + (dBov & 0x7f); |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1558 | return true; |
| 1559 | } |
| 1560 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1561 | bool RTPSender::UpdateVideoRotation(uint8_t* rtp_packet, |
| 1562 | size_t rtp_packet_length, |
| 1563 | const RTPHeader& rtp_header, |
| 1564 | VideoRotation rotation) const { |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1565 | size_t offset; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1566 | rtc::CritScope lock(&send_critsect_); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1567 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1568 | 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.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1580 | } |
| 1581 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1582 | rtp_packet[offset + 1] = ConvertVideoRotationToCVOByte(rotation); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1583 | return true; |
| 1584 | } |
| 1585 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1586 | void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet, |
| 1587 | size_t rtp_packet_length, |
| 1588 | const RTPHeader& rtp_header, |
| 1589 | int64_t now_ms) const { |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1590 | size_t offset; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1591 | rtc::CritScope lock(&send_critsect_); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1592 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1593 | 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.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1605 | } |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1606 | |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1607 | // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit |
| 1608 | // fractional part). |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1609 | ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1, |
Stefan Holmer | 0a87ffc | 2015-10-21 13:41:48 +0200 | [diff] [blame] | 1610 | ConvertMsTo24Bits(now_ms)); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1611 | } |
| 1612 | |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1613 | uint16_t RTPSender::UpdateTransportSequenceNumber( |
| 1614 | uint8_t* rtp_packet, |
| 1615 | size_t rtp_packet_length, |
| 1616 | const RTPHeader& rtp_header) const { |
| 1617 | size_t offset; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1618 | rtc::CritScope lock(&send_critsect_); |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1619 | |
| 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 | |
sprang | ebbf8a8 | 2015-09-21 15:11:14 -0700 | [diff] [blame] | 1634 | uint16_t seq = transport_sequence_number_allocator_->AllocateSequenceNumber(); |
sprang | 867fb52 | 2015-08-03 04:38:41 -0700 | [diff] [blame] | 1635 | BuildTransportSequenceNumberExtension(rtp_packet + offset, seq); |
| 1636 | return seq; |
| 1637 | } |
| 1638 | |
pbos@webrtc.org | 59f20bb | 2013-09-09 16:02:19 +0000 | [diff] [blame] | 1639 | void RTPSender::SetSendingStatus(bool enabled) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1640 | if (enabled) { |
pbos@webrtc.org | 59f20bb | 2013-09-09 16:02:19 +0000 | [diff] [blame] | 1641 | uint32_t frequency_hz = SendPayloadFrequency(); |
danilchap | 1227e8b | 2015-12-21 11:06:50 -0800 | [diff] [blame] | 1642 | uint32_t RTPtime = CurrentRtp(*clock_, frequency_hz); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1643 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1644 | // Will be ignored if it's already configured via API. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1645 | SetStartTimestamp(RTPtime, false); |
| 1646 | } else { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1647 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1648 | if (!ssrc_forced_) { |
| 1649 | // Generate a new SSRC. |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1650 | ssrc_db_->ReturnSSRC(ssrc_); |
| 1651 | ssrc_ = ssrc_db_->CreateSSRC(); |
| 1652 | RTC_DCHECK(ssrc_ != 0); |
| 1653 | bitrates_.set_ssrc(ssrc_); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1654 | } |
| 1655 | // Don't initialize seq number if SSRC passed externally. |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1656 | if (!sequence_number_forced_ && !ssrc_forced_) { |
| 1657 | // Generate a new sequence number. |
danilchap | 47a740b | 2015-12-15 00:30:07 -0800 | [diff] [blame] | 1658 | sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1659 | } |
| 1660 | } |
| 1661 | } |
| 1662 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1663 | void RTPSender::SetSendingMediaStatus(bool enabled) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1664 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1665 | sending_media_ = enabled; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1666 | } |
| 1667 | |
| 1668 | bool RTPSender::SendingMedia() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1669 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1670 | return sending_media_; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1671 | } |
| 1672 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1673 | uint32_t RTPSender::Timestamp() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1674 | rtc::CritScope lock(&send_critsect_); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1675 | return timestamp_; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1676 | } |
| 1677 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1678 | void RTPSender::SetStartTimestamp(uint32_t timestamp, bool force) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1679 | rtc::CritScope lock(&send_critsect_); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1680 | if (force) { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1681 | start_timestamp_forced_ = true; |
| 1682 | start_timestamp_ = timestamp; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1683 | } else { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1684 | if (!start_timestamp_forced_) { |
| 1685 | start_timestamp_ = timestamp; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1686 | } |
| 1687 | } |
| 1688 | } |
| 1689 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1690 | uint32_t RTPSender::StartTimestamp() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1691 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1692 | return start_timestamp_; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1693 | } |
| 1694 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1695 | uint32_t RTPSender::GenerateNewSSRC() { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1696 | // If configured via API, return 0. |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1697 | rtc::CritScope lock(&send_critsect_); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1698 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1699 | if (ssrc_forced_) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1700 | return 0; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1701 | } |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1702 | ssrc_ = ssrc_db_->CreateSSRC(); |
| 1703 | RTC_DCHECK(ssrc_ != 0); |
| 1704 | bitrates_.set_ssrc(ssrc_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1705 | return ssrc_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1706 | } |
| 1707 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1708 | void RTPSender::SetSSRC(uint32_t ssrc) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1709 | // This is configured via the API. |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1710 | rtc::CritScope lock(&send_critsect_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1711 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1712 | if (ssrc_ == ssrc && ssrc_forced_) { |
| 1713 | return; // Since it's same ssrc, don't reset anything. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1714 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1715 | ssrc_forced_ = true; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1716 | ssrc_db_->ReturnSSRC(ssrc_); |
| 1717 | ssrc_db_->RegisterSSRC(ssrc); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1718 | ssrc_ = ssrc; |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1719 | bitrates_.set_ssrc(ssrc_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1720 | if (!sequence_number_forced_) { |
danilchap | 47a740b | 2015-12-15 00:30:07 -0800 | [diff] [blame] | 1721 | sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1722 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1723 | } |
| 1724 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1725 | uint32_t RTPSender::SSRC() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1726 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1727 | return ssrc_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1728 | } |
| 1729 | |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1730 | void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { |
| 1731 | assert(csrcs.size() <= kRtpCsrcSize); |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1732 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1733 | csrcs_ = csrcs; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1734 | } |
| 1735 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1736 | void RTPSender::SetSequenceNumber(uint16_t seq) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1737 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1738 | sequence_number_forced_ = true; |
| 1739 | sequence_number_ = seq; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1740 | } |
| 1741 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1742 | uint16_t RTPSender::SequenceNumber() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1743 | rtc::CritScope lock(&send_critsect_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1744 | return sequence_number_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1745 | } |
| 1746 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1747 | // Audio. |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1748 | int32_t RTPSender::SendTelephoneEvent(uint8_t key, |
| 1749 | uint16_t time_ms, |
| 1750 | uint8_t level) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1751 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1752 | return -1; |
| 1753 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1754 | return audio_->SendTelephoneEvent(key, time_ms, level); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1755 | } |
| 1756 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1757 | int32_t RTPSender::SetAudioPacketSize(uint16_t packet_size_samples) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1758 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1759 | return -1; |
| 1760 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1761 | return audio_->SetAudioPacketSize(packet_size_samples); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1762 | } |
| 1763 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1764 | int32_t RTPSender::SetAudioLevel(uint8_t level_d_bov) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1765 | return audio_->SetAudioLevel(level_d_bov); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1766 | } |
| 1767 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1768 | int32_t RTPSender::SetRED(int8_t payload_type) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1769 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1770 | return -1; |
| 1771 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1772 | return audio_->SetRED(payload_type); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1773 | } |
| 1774 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1775 | int32_t RTPSender::RED(int8_t *payload_type) const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1776 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1777 | return -1; |
| 1778 | } |
danilchap | 6db6cdc | 2015-12-15 02:54:47 -0800 | [diff] [blame] | 1779 | return audio_->RED(payload_type); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1780 | } |
| 1781 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1782 | RtpVideoCodecTypes RTPSender::VideoCodecType() const { |
pbos@webrtc.org | 8911ce4 | 2013-03-18 16:39:03 +0000 | [diff] [blame] | 1783 | assert(!audio_configured_ && "Sender is an audio stream!"); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1784 | return video_->VideoCodecType(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1785 | } |
| 1786 | |
pbos | ba8c15b | 2015-07-14 09:36:34 -0700 | [diff] [blame] | 1787 | void RTPSender::SetGenericFECStatus(bool enable, |
| 1788 | uint8_t payload_type_red, |
| 1789 | uint8_t payload_type_fec) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1790 | RTC_DCHECK(!audio_configured_); |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 1791 | video_->SetGenericFECStatus(enable, payload_type_red, payload_type_fec); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1792 | } |
| 1793 | |
pbos | ba8c15b | 2015-07-14 09:36:34 -0700 | [diff] [blame] | 1794 | void RTPSender::GenericFECStatus(bool* enable, |
pkasting@chromium.org | d324546 | 2015-02-23 21:28:22 +0000 | [diff] [blame] | 1795 | uint8_t* payload_type_red, |
| 1796 | uint8_t* payload_type_fec) const { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1797 | RTC_DCHECK(!audio_configured_); |
danilchap | 6db6cdc | 2015-12-15 02:54:47 -0800 | [diff] [blame] | 1798 | video_->GenericFECStatus(enable, payload_type_red, payload_type_fec); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1799 | } |
| 1800 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1801 | int32_t RTPSender::SetFecParameters( |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1802 | const FecProtectionParams *delta_params, |
| 1803 | const FecProtectionParams *key_params) { |
| 1804 | if (audio_configured_) { |
stefan@webrtc.org | e0d6fa4 | 2012-03-20 22:10:56 +0000 | [diff] [blame] | 1805 | return -1; |
| 1806 | } |
mflodman | fcf54bd | 2015-04-14 21:28:08 +0200 | [diff] [blame] | 1807 | video_->SetFecParameters(delta_params, key_params); |
| 1808 | return 0; |
marpan@google.com | 80c5d7a | 2011-07-15 21:32:40 +0000 | [diff] [blame] | 1809 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1810 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1811 | void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length, |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1812 | uint8_t* buffer_rtx) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1813 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1814 | uint8_t* data_buffer_rtx = buffer_rtx; |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1815 | // Add RTX header. |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 1816 | RtpUtility::RtpHeaderParser rtp_parser( |
| 1817 | reinterpret_cast<const uint8_t*>(buffer), *length); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1818 | |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1819 | RTPHeader rtp_header; |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 1820 | rtp_parser.Parse(&rtp_header); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1821 | |
| 1822 | // Add original RTP header. |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1823 | memcpy(data_buffer_rtx, buffer, rtp_header.headerLength); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1824 | |
andrew@webrtc.org | 8f27fcc | 2015-01-09 20:22:46 +0000 | [diff] [blame] | 1825 | // Replace payload type, if a specific type is set for RTX. |
Stefan Holmer | 1088001 | 2016-02-03 13:29:59 +0100 | [diff] [blame] | 1826 | 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.org | 9f5ebb5 | 2013-04-12 14:55:46 +0000 | [diff] [blame] | 1836 | |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1837 | // Replace sequence number. |
danilchap | f6975f4 | 2015-12-28 10:18:46 -0800 | [diff] [blame] | 1838 | uint8_t* ptr = data_buffer_rtx + 2; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1839 | ByteWriter<uint16_t>::WriteBigEndian(ptr, sequence_number_rtx_++); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1840 | |
| 1841 | // Replace SSRC. |
| 1842 | ptr += 6; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1843 | ByteWriter<uint32_t>::WriteBigEndian(ptr, ssrc_rtx_); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1844 | |
| 1845 | // Add OSN (original sequence number). |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1846 | ptr = data_buffer_rtx + rtp_header.headerLength; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1847 | ByteWriter<uint16_t>::WriteBigEndian(ptr, rtp_header.sequenceNumber); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1848 | ptr += 2; |
| 1849 | |
| 1850 | // Add original payload data. |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1851 | memcpy(ptr, buffer + rtp_header.headerLength, |
| 1852 | *length - rtp_header.headerLength); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1853 | *length += 2; |
| 1854 | } |
| 1855 | |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1856 | void RTPSender::RegisterRtpStatisticsCallback( |
| 1857 | StreamDataCountersCallback* callback) { |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 1858 | rtc::CritScope cs(&statistics_crit_); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1859 | rtp_stats_callback_ = callback; |
| 1860 | } |
| 1861 | |
| 1862 | StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const { |
danilchap | 7c9426c | 2016-04-14 03:05:31 -0700 | [diff] [blame^] | 1863 | rtc::CritScope cs(&statistics_crit_); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1864 | return rtp_stats_callback_; |
| 1865 | } |
| 1866 | |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1867 | uint32_t RTPSender::BitrateSent() const { |
| 1868 | return total_bitrate_sent_.BitrateLast(); |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 1869 | } |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1870 | |
| 1871 | void RTPSender::SetRtpState(const RtpState& rtp_state) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1872 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1873 | 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.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1878 | media_has_been_sent_ = rtp_state.media_has_been_sent; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1879 | } |
| 1880 | |
| 1881 | RtpState RTPSender::GetRtpState() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1882 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1883 | |
| 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.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1890 | state.media_has_been_sent = media_has_been_sent_; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1891 | |
| 1892 | return state; |
| 1893 | } |
| 1894 | |
| 1895 | void RTPSender::SetRtxRtpState(const RtpState& rtp_state) { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1896 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1897 | sequence_number_rtx_ = rtp_state.sequence_number; |
| 1898 | } |
| 1899 | |
| 1900 | RtpState RTPSender::GetRtxRtpState() const { |
tommi | ae695e9 | 2016-02-02 08:31:45 -0800 | [diff] [blame] | 1901 | rtc::CritScope lock(&send_critsect_); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1902 | |
| 1903 | RtpState state; |
| 1904 | state.sequence_number = sequence_number_rtx_; |
| 1905 | state.start_timestamp = start_timestamp_; |
| 1906 | |
| 1907 | return state; |
| 1908 | } |
| 1909 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1910 | } // namespace webrtc |