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 |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 14 | |
guoweis@webrtc.org | fdd1057 | 2015-03-12 20:50:57 +0000 | [diff] [blame] | 15 | #include "webrtc/modules/rtp_rtcp/interface/rtp_cvo.h" |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 16 | #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 17 | #include "webrtc/modules/rtp_rtcp/source/rtp_sender_audio.h" |
| 18 | #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h" |
| 19 | #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 20 | #include "webrtc/system_wrappers/interface/logging.h" |
stefan@webrtc.org | 88e0dda | 2014-07-04 09:20:42 +0000 | [diff] [blame] | 21 | #include "webrtc/system_wrappers/interface/tick_util.h" |
hclam@chromium.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 22 | #include "webrtc/system_wrappers/interface/trace_event.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 23 | |
| 24 | namespace webrtc { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 25 | |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 26 | // Max in the RFC 3550 is 255 bytes, we limit it to be modulus 32 for SRTP. |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 27 | const size_t kMaxPaddingLength = 224; |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 28 | const int kSendSideDelayWindowMs = 1000; |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 29 | |
hclam@chromium.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 30 | namespace { |
| 31 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 32 | const size_t kRtpHeaderLength = 12; |
| 33 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 34 | const char* FrameTypeToString(FrameType frame_type) { |
hclam@chromium.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 35 | switch (frame_type) { |
| 36 | case kFrameEmpty: return "empty"; |
| 37 | case kAudioFrameSpeech: return "audio_speech"; |
| 38 | case kAudioFrameCN: return "audio_cn"; |
| 39 | case kVideoFrameKey: return "video_key"; |
| 40 | case kVideoFrameDelta: return "video_delta"; |
hclam@chromium.org | 806dc3b | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 41 | } |
| 42 | return ""; |
| 43 | } |
| 44 | |
| 45 | } // namespace |
| 46 | |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 47 | class BitrateAggregator { |
| 48 | public: |
| 49 | explicit BitrateAggregator(BitrateStatisticsObserver* bitrate_callback) |
| 50 | : callback_(bitrate_callback), |
| 51 | total_bitrate_observer_(*this), |
| 52 | retransmit_bitrate_observer_(*this), |
| 53 | ssrc_(0) {} |
| 54 | |
| 55 | void OnStatsUpdated() const { |
| 56 | if (callback_) |
| 57 | callback_->Notify(total_bitrate_observer_.statistics(), |
| 58 | retransmit_bitrate_observer_.statistics(), |
| 59 | ssrc_); |
| 60 | } |
| 61 | |
| 62 | Bitrate::Observer* total_bitrate_observer() { |
| 63 | return &total_bitrate_observer_; |
| 64 | } |
| 65 | Bitrate::Observer* retransmit_bitrate_observer() { |
| 66 | return &retransmit_bitrate_observer_; |
| 67 | } |
| 68 | |
| 69 | void set_ssrc(uint32_t ssrc) { ssrc_ = ssrc; } |
| 70 | |
| 71 | private: |
| 72 | // We assume that these observers are called on the same thread, which is |
| 73 | // true for RtpSender as they are called on the Process thread. |
| 74 | class BitrateObserver : public Bitrate::Observer { |
| 75 | public: |
| 76 | explicit BitrateObserver(const BitrateAggregator& aggregator) |
| 77 | : aggregator_(aggregator) {} |
| 78 | |
| 79 | // Implements Bitrate::Observer. |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 +0000 | [diff] [blame] | 80 | void BitrateUpdated(const BitrateStatistics& stats) override { |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 81 | statistics_ = stats; |
| 82 | aggregator_.OnStatsUpdated(); |
| 83 | } |
| 84 | |
| 85 | BitrateStatistics statistics() const { return statistics_; } |
| 86 | |
| 87 | private: |
| 88 | BitrateStatistics statistics_; |
| 89 | const BitrateAggregator& aggregator_; |
| 90 | }; |
| 91 | |
| 92 | BitrateStatisticsObserver* const callback_; |
| 93 | BitrateObserver total_bitrate_observer_; |
| 94 | BitrateObserver retransmit_bitrate_observer_; |
| 95 | uint32_t ssrc_; |
| 96 | }; |
| 97 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 98 | RTPSender::RTPSender(int32_t id, |
| 99 | bool audio, |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 100 | Clock* clock, |
| 101 | Transport* transport, |
| 102 | RtpAudioFeedback* audio_feedback, |
andresp@webrtc.org | d11bec4 | 2014-07-08 14:32:58 +0000 | [diff] [blame] | 103 | PacedSender* paced_sender, |
andresp@webrtc.org | 8f15121 | 2014-07-10 09:39:23 +0000 | [diff] [blame] | 104 | BitrateStatisticsObserver* bitrate_callback, |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 105 | FrameCountObserver* frame_count_observer, |
| 106 | SendSideDelayObserver* send_side_delay_observer) |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 107 | : clock_(clock), |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 108 | // TODO(holmer): Remove this conversion when we remove the use of |
| 109 | // TickTime. |
| 110 | clock_delta_ms_(clock_->TimeInMilliseconds() - |
| 111 | TickTime::MillisecondTimestamp()), |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 112 | bitrates_(new BitrateAggregator(bitrate_callback)), |
| 113 | total_bitrate_sent_(clock, bitrates_->total_bitrate_observer()), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 114 | id_(id), |
| 115 | audio_configured_(audio), |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 116 | audio_(audio ? new RTPSenderAudio(id, clock, this, audio_feedback) |
| 117 | : nullptr), |
| 118 | video_(audio ? nullptr : new RTPSenderVideo(clock, this)), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 119 | paced_sender_(paced_sender), |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 120 | last_capture_time_ms_sent_(0), |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 121 | send_critsect_(CriticalSectionWrapper::CreateCriticalSection()), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 122 | transport_(transport), |
| 123 | sending_media_(true), // Default to sending media. |
| 124 | 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] | 125 | packet_over_head_(28), |
| 126 | payload_type_(-1), |
| 127 | payload_type_map_(), |
| 128 | rtp_header_extension_map_(), |
| 129 | transmission_time_offset_(0), |
| 130 | absolute_send_time_(0), |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 131 | rotation_(kVideoRotation_0), |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame^] | 132 | cvo_mode_(kCVONone), |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 133 | transport_sequence_number_(0), |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 134 | // NACK. |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 135 | nack_byte_count_times_(), |
| 136 | nack_byte_count_(), |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 137 | nack_bitrate_(clock, bitrates_->retransmit_bitrate_observer()), |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 138 | packet_history_(clock), |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 139 | // Statistics |
pbos@webrtc.org | e07049f | 2013-09-10 11:29:17 +0000 | [diff] [blame] | 140 | statistics_crit_(CriticalSectionWrapper::CreateCriticalSection()), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 141 | rtp_stats_callback_(NULL), |
andresp@webrtc.org | 8f15121 | 2014-07-10 09:39:23 +0000 | [diff] [blame] | 142 | frame_count_observer_(frame_count_observer), |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 143 | send_side_delay_observer_(send_side_delay_observer), |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 144 | // RTP variables |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 145 | start_timestamp_forced_(false), |
| 146 | start_timestamp_(0), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 147 | ssrc_db_(*SSRCDatabase::GetSSRCDatabase()), |
| 148 | remote_ssrc_(0), |
| 149 | sequence_number_forced_(false), |
| 150 | ssrc_forced_(false), |
| 151 | timestamp_(0), |
| 152 | capture_time_ms_(0), |
| 153 | last_timestamp_time_ms_(0), |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 154 | media_has_been_sent_(false), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 155 | last_packet_marker_bit_(false), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 156 | csrcs_(), |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 157 | rtx_(kRtxOff), |
andrew@webrtc.org | 8f27fcc | 2015-01-09 20:22:46 +0000 | [diff] [blame] | 158 | payload_type_rtx_(-1), |
andresp@webrtc.org | d09d074 | 2014-03-26 14:27:34 +0000 | [diff] [blame] | 159 | target_bitrate_critsect_(CriticalSectionWrapper::CreateCriticalSection()), |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 160 | target_bitrate_(0) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 161 | memset(nack_byte_count_times_, 0, sizeof(nack_byte_count_times_)); |
| 162 | memset(nack_byte_count_, 0, sizeof(nack_byte_count_)); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 163 | // We need to seed the random generator. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 164 | srand(static_cast<uint32_t>(clock_->TimeInMilliseconds())); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 165 | ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 166 | ssrc_rtx_ = ssrc_db_.CreateSSRC(); // Can't be 0. |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 167 | bitrates_->set_ssrc(ssrc_); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 168 | // Random start, 16 bits. Can't be 0. |
| 169 | sequence_number_rtx_ = static_cast<uint16_t>(rand() + 1) & 0x7FFF; |
| 170 | sequence_number_ = static_cast<uint16_t>(rand() + 1) & 0x7FFF; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 171 | } |
| 172 | |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 173 | RTPSender::~RTPSender() { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 174 | if (remote_ssrc_ != 0) { |
| 175 | ssrc_db_.ReturnSSRC(remote_ssrc_); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 176 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 177 | ssrc_db_.ReturnSSRC(ssrc_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 178 | |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 179 | SSRCDatabase::ReturnSSRCDatabase(); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 180 | while (!payload_type_map_.empty()) { |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 181 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 182 | payload_type_map_.begin(); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 183 | delete it->second; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 184 | payload_type_map_.erase(it); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 185 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 186 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 187 | |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 188 | void RTPSender::SetTargetBitrate(uint32_t bitrate) { |
| 189 | CriticalSectionScoped cs(target_bitrate_critsect_.get()); |
| 190 | target_bitrate_ = bitrate; |
| 191 | } |
| 192 | |
| 193 | uint32_t RTPSender::GetTargetBitrate() { |
| 194 | CriticalSectionScoped cs(target_bitrate_critsect_.get()); |
| 195 | return target_bitrate_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 196 | } |
stefan@webrtc.org | d0bdab0 | 2011-10-14 14:24:54 +0000 | [diff] [blame] | 197 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 198 | uint16_t RTPSender::ActualSendBitrateKbit() const { |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 199 | return (uint16_t)(total_bitrate_sent_.BitrateNow() / 1000); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 200 | } |
| 201 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 202 | uint32_t RTPSender::VideoBitrateSent() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 203 | if (video_) { |
| 204 | return video_->VideoBitrateSent(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 205 | } |
| 206 | return 0; |
stefan@webrtc.org | fbea4e5 | 2011-10-27 16:08:29 +0000 | [diff] [blame] | 207 | } |
| 208 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 209 | uint32_t RTPSender::FecOverheadRate() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 210 | if (video_) { |
| 211 | return video_->FecOverheadRate(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 212 | } |
| 213 | return 0; |
stefan@webrtc.org | d0bdab0 | 2011-10-14 14:24:54 +0000 | [diff] [blame] | 214 | } |
| 215 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 216 | uint32_t RTPSender::NackOverheadRate() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 217 | return nack_bitrate_.BitrateLast(); |
stefan@webrtc.org | d0bdab0 | 2011-10-14 14:24:54 +0000 | [diff] [blame] | 218 | } |
| 219 | |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 220 | bool RTPSender::GetSendSideDelay(int* avg_send_delay_ms, |
| 221 | int* max_send_delay_ms) const { |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 222 | CriticalSectionScoped lock(statistics_crit_.get()); |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 223 | SendDelayMap::const_iterator it = send_delays_.upper_bound( |
| 224 | clock_->TimeInMilliseconds() - kSendSideDelayWindowMs); |
sprang@webrtc.org | 5a320fb | 2014-03-13 15:12:37 +0000 | [diff] [blame] | 225 | if (it == send_delays_.end()) |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 226 | return false; |
| 227 | int num_delays = 0; |
| 228 | for (; it != send_delays_.end(); ++it) { |
| 229 | *max_send_delay_ms = std::max(*max_send_delay_ms, it->second); |
| 230 | *avg_send_delay_ms += it->second; |
| 231 | ++num_delays; |
| 232 | } |
| 233 | *avg_send_delay_ms = (*avg_send_delay_ms + num_delays / 2) / num_delays; |
| 234 | return true; |
| 235 | } |
| 236 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 237 | int32_t RTPSender::SetTransmissionTimeOffset(int32_t transmission_time_offset) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 238 | if (transmission_time_offset > (0x800000 - 1) || |
| 239 | transmission_time_offset < -(0x800000 - 1)) { // Word24. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 240 | return -1; |
| 241 | } |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 242 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 243 | transmission_time_offset_ = transmission_time_offset; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 244 | return 0; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 245 | } |
| 246 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 247 | int32_t RTPSender::SetAbsoluteSendTime(uint32_t absolute_send_time) { |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 248 | if (absolute_send_time > 0xffffff) { // UWord24. |
| 249 | return -1; |
| 250 | } |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 251 | CriticalSectionScoped cs(send_critsect_.get()); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 252 | absolute_send_time_ = absolute_send_time; |
| 253 | return 0; |
| 254 | } |
| 255 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 256 | void RTPSender::SetVideoRotation(VideoRotation rotation) { |
| 257 | CriticalSectionScoped cs(send_critsect_.get()); |
| 258 | rotation_ = rotation; |
| 259 | } |
| 260 | |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 261 | int32_t RTPSender::SetTransportSequenceNumber(uint16_t sequence_number) { |
| 262 | CriticalSectionScoped cs(send_critsect_.get()); |
| 263 | transport_sequence_number_ = sequence_number; |
| 264 | return 0; |
| 265 | } |
| 266 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 267 | int32_t RTPSender::RegisterRtpHeaderExtension(RTPExtensionType type, |
| 268 | uint8_t id) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 269 | CriticalSectionScoped cs(send_critsect_.get()); |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame^] | 270 | if (type == kRtpExtensionVideoRotation) { |
| 271 | cvo_mode_ = kCVOInactive; |
| 272 | return rtp_header_extension_map_.RegisterInactive(type, id); |
| 273 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 274 | return rtp_header_extension_map_.Register(type, id); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 275 | } |
| 276 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 277 | bool RTPSender::IsRtpHeaderExtensionRegistered(RTPExtensionType type) { |
| 278 | CriticalSectionScoped cs(send_critsect_.get()); |
| 279 | return rtp_header_extension_map_.IsRegistered(type); |
| 280 | } |
| 281 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 282 | int32_t RTPSender::DeregisterRtpHeaderExtension(RTPExtensionType type) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 283 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 284 | return rtp_header_extension_map_.Deregister(type); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 285 | } |
| 286 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 287 | size_t RTPSender::RtpHeaderExtensionTotalLength() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 288 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 289 | return rtp_header_extension_map_.GetTotalLengthInBytes(); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 290 | } |
| 291 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 292 | int32_t RTPSender::RegisterPayload( |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 293 | const char payload_name[RTP_PAYLOAD_NAME_SIZE], |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 294 | int8_t payload_number, |
| 295 | uint32_t frequency, |
| 296 | uint8_t channels, |
| 297 | uint32_t rate) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 298 | assert(payload_name); |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 299 | CriticalSectionScoped cs(send_critsect_.get()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 300 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 301 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 302 | payload_type_map_.find(payload_number); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 303 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 304 | if (payload_type_map_.end() != it) { |
| 305 | // We already use this payload type. |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 306 | RtpUtility::Payload* payload = it->second; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 307 | assert(payload); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 308 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 309 | // Check if it's the same as we already have. |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 310 | if (RtpUtility::StringCompare( |
| 311 | payload->name, payload_name, RTP_PAYLOAD_NAME_SIZE - 1)) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 312 | if (audio_configured_ && payload->audio && |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 313 | payload->typeSpecific.Audio.frequency == frequency && |
| 314 | (payload->typeSpecific.Audio.rate == rate || |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 315 | payload->typeSpecific.Audio.rate == 0 || rate == 0)) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 316 | payload->typeSpecific.Audio.rate = rate; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 317 | // 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] | 318 | return 0; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 319 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 320 | if (!audio_configured_ && !payload->audio) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 321 | return 0; |
| 322 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 323 | } |
| 324 | return -1; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 325 | } |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 326 | int32_t ret_val = -1; |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 327 | RtpUtility::Payload* payload = NULL; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 328 | if (audio_configured_) { |
| 329 | ret_val = audio_->RegisterAudioPayload(payload_name, payload_number, |
| 330 | frequency, channels, rate, payload); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 331 | } else { |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 332 | ret_val = video_->RegisterVideoPayload(payload_name, payload_number, rate, |
| 333 | payload); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 334 | } |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 335 | if (payload) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 336 | payload_type_map_[payload_number] = payload; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 337 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 338 | return ret_val; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 339 | } |
| 340 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 341 | int32_t RTPSender::DeRegisterSendPayload(int8_t payload_type) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 342 | CriticalSectionScoped lock(send_critsect_.get()); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 343 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 344 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 345 | payload_type_map_.find(payload_type); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 346 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 347 | if (payload_type_map_.end() == it) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 348 | return -1; |
| 349 | } |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 350 | RtpUtility::Payload* payload = it->second; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 351 | delete payload; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 352 | payload_type_map_.erase(it); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 353 | return 0; |
| 354 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 355 | |
andresp@webrtc.org | c3c2911 | 2014-08-27 09:39:43 +0000 | [diff] [blame] | 356 | void RTPSender::SetSendPayloadType(int8_t payload_type) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 357 | CriticalSectionScoped cs(send_critsect_.get()); |
andresp@webrtc.org | c3c2911 | 2014-08-27 09:39:43 +0000 | [diff] [blame] | 358 | payload_type_ = payload_type; |
| 359 | } |
| 360 | |
sprang@webrtc.org | efcad39 | 2014-03-25 16:51:35 +0000 | [diff] [blame] | 361 | int8_t RTPSender::SendPayloadType() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 362 | CriticalSectionScoped cs(send_critsect_.get()); |
sprang@webrtc.org | efcad39 | 2014-03-25 16:51:35 +0000 | [diff] [blame] | 363 | return payload_type_; |
| 364 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 365 | |
pbos@webrtc.org | 59f20bb | 2013-09-09 16:02:19 +0000 | [diff] [blame] | 366 | int RTPSender::SendPayloadFrequency() const { |
| 367 | return audio_ != NULL ? audio_->AudioFrequency() : kVideoPayloadTypeFrequency; |
| 368 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 369 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 370 | int32_t RTPSender::SetMaxPayloadLength(size_t max_payload_length, |
| 371 | uint16_t packet_over_head) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 372 | // Sanity check. |
| 373 | if (max_payload_length < 100 || max_payload_length > IP_PACKET_SIZE) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 374 | LOG(LS_ERROR) << "Invalid max payload length: " << max_payload_length; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 375 | return -1; |
| 376 | } |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 377 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 378 | max_payload_length_ = max_payload_length; |
| 379 | packet_over_head_ = packet_over_head; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 380 | return 0; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 381 | } |
| 382 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 383 | size_t RTPSender::MaxDataPayloadLength() const { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 384 | int rtx; |
| 385 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 386 | CriticalSectionScoped rtx_lock(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 387 | rtx = rtx_; |
| 388 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 389 | if (audio_configured_) { |
| 390 | return max_payload_length_ - RTPHeaderLength(); |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 391 | } else { |
sprang@webrtc.org | 346094c | 2014-02-18 08:40:33 +0000 | [diff] [blame] | 392 | return max_payload_length_ - RTPHeaderLength() // RTP overhead. |
| 393 | - video_->FECPacketOverhead() // FEC/ULP/RED overhead. |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 394 | - ((rtx) ? 2 : 0); // RTX overhead. |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 395 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 396 | } |
| 397 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 398 | size_t RTPSender::MaxPayloadLength() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 399 | return max_payload_length_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 400 | } |
| 401 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 402 | uint16_t RTPSender::PacketOverHead() const { return packet_over_head_; } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 403 | |
pbos@webrtc.org | 0b0c241 | 2015-01-13 14:15:15 +0000 | [diff] [blame] | 404 | void RTPSender::SetRtxStatus(int mode) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 405 | CriticalSectionScoped cs(send_critsect_.get()); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 406 | rtx_ = mode; |
stefan@webrtc.org | ef92755 | 2014-06-05 08:25:29 +0000 | [diff] [blame] | 407 | } |
| 408 | |
pbos@webrtc.org | 0b0c241 | 2015-01-13 14:15:15 +0000 | [diff] [blame] | 409 | int RTPSender::RtxStatus() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 410 | CriticalSectionScoped cs(send_critsect_.get()); |
pbos@webrtc.org | 0b0c241 | 2015-01-13 14:15:15 +0000 | [diff] [blame] | 411 | return rtx_; |
| 412 | } |
| 413 | |
stefan@webrtc.org | ef92755 | 2014-06-05 08:25:29 +0000 | [diff] [blame] | 414 | void RTPSender::SetRtxSsrc(uint32_t ssrc) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 415 | CriticalSectionScoped cs(send_critsect_.get()); |
stefan@webrtc.org | ef92755 | 2014-06-05 08:25:29 +0000 | [diff] [blame] | 416 | ssrc_rtx_ = ssrc; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 417 | } |
| 418 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 419 | uint32_t RTPSender::RtxSsrc() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 420 | CriticalSectionScoped cs(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 421 | return ssrc_rtx_; |
| 422 | } |
| 423 | |
andrew@webrtc.org | 8f27fcc | 2015-01-09 20:22:46 +0000 | [diff] [blame] | 424 | void RTPSender::SetRtxPayloadType(int payload_type) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 425 | CriticalSectionScoped cs(send_critsect_.get()); |
andrew@webrtc.org | 8f27fcc | 2015-01-09 20:22:46 +0000 | [diff] [blame] | 426 | payload_type_rtx_ = payload_type; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 427 | } |
| 428 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 429 | int32_t RTPSender::CheckPayloadType(int8_t payload_type, |
| 430 | RtpVideoCodecTypes* video_type) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 431 | CriticalSectionScoped cs(send_critsect_.get()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 432 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 433 | if (payload_type < 0) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 434 | LOG(LS_ERROR) << "Invalid payload_type " << payload_type; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 435 | return -1; |
| 436 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 437 | if (audio_configured_) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 438 | int8_t red_pl_type = -1; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 439 | if (audio_->RED(red_pl_type) == 0) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 440 | // We have configured RED. |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 441 | if (red_pl_type == payload_type) { |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 442 | // And it's a match... |
| 443 | return 0; |
| 444 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 445 | } |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 446 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 447 | if (payload_type_ == payload_type) { |
| 448 | if (!audio_configured_) { |
| 449 | *video_type = video_->VideoCodecType(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 450 | } |
| 451 | return 0; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 452 | } |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 453 | std::map<int8_t, RtpUtility::Payload*>::iterator it = |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 454 | payload_type_map_.find(payload_type); |
| 455 | if (it == payload_type_map_.end()) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 456 | LOG(LS_WARNING) << "Payload type " << payload_type << " not registered."; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 457 | return -1; |
| 458 | } |
andresp@webrtc.org | c3c2911 | 2014-08-27 09:39:43 +0000 | [diff] [blame] | 459 | SetSendPayloadType(payload_type); |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 460 | RtpUtility::Payload* payload = it->second; |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 461 | assert(payload); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 462 | if (!payload->audio && !audio_configured_) { |
| 463 | video_->SetVideoCodecType(payload->typeSpecific.Video.videoCodecType); |
| 464 | *video_type = payload->typeSpecific.Video.videoCodecType; |
| 465 | video_->SetMaxConfiguredBitrateVideo(payload->typeSpecific.Video.maxRate); |
pwestin@webrtc.org | 0074187 | 2012-01-19 15:56:10 +0000 | [diff] [blame] | 466 | } |
| 467 | return 0; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 468 | } |
| 469 | |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame^] | 470 | RTPSenderInterface::CVOMode RTPSender::ActivateCVORtpHeaderExtension() { |
| 471 | if (cvo_mode_ == kCVOInactive) { |
| 472 | CriticalSectionScoped cs(send_critsect_.get()); |
| 473 | if (rtp_header_extension_map_.SetActive(kRtpExtensionVideoRotation, true)) { |
| 474 | cvo_mode_ = kCVOActivated; |
| 475 | } |
| 476 | } |
| 477 | return cvo_mode_; |
| 478 | } |
| 479 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 480 | int32_t RTPSender::SendOutgoingData(FrameType frame_type, |
| 481 | int8_t payload_type, |
| 482 | uint32_t capture_timestamp, |
| 483 | int64_t capture_time_ms, |
| 484 | const uint8_t* payload_data, |
| 485 | size_t payload_size, |
| 486 | const RTPFragmentationHeader* fragmentation, |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 487 | VideoCodecInformation* codec_info, |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 488 | const RTPVideoHeader* rtp_hdr) { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 489 | uint32_t ssrc; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 490 | { |
| 491 | // Drop this packet if we're not sending media packets. |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 492 | CriticalSectionScoped cs(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 493 | ssrc = ssrc_; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 494 | if (!sending_media_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 495 | return 0; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 496 | } |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 497 | } |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 498 | RtpVideoCodecTypes video_type = kRtpVideoGeneric; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 499 | if (CheckPayloadType(payload_type, &video_type) != 0) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 500 | LOG(LS_ERROR) << "Don't send data with unknown payload type."; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 501 | return -1; |
| 502 | } |
| 503 | |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 504 | uint32_t ret_val; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 505 | if (audio_configured_) { |
hclam@chromium.org | 1a7b9b9 | 2013-07-08 21:31:18 +0000 | [diff] [blame] | 506 | TRACE_EVENT_ASYNC_STEP1("webrtc", "Audio", capture_timestamp, |
| 507 | "Send", "type", FrameTypeToString(frame_type)); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 508 | assert(frame_type == kAudioFrameSpeech || frame_type == kAudioFrameCN || |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 509 | frame_type == kFrameEmpty); |
| 510 | |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 511 | ret_val = audio_->SendAudio(frame_type, payload_type, capture_timestamp, |
| 512 | payload_data, payload_size, fragmentation); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 513 | } else { |
hclam@chromium.org | 1a7b9b9 | 2013-07-08 21:31:18 +0000 | [diff] [blame] | 514 | TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms, |
| 515 | "Send", "type", FrameTypeToString(frame_type)); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 516 | assert(frame_type != kAudioFrameSpeech && frame_type != kAudioFrameCN); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 517 | |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 518 | if (frame_type == kFrameEmpty) |
| 519 | return 0; |
| 520 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 521 | ret_val = |
| 522 | video_->SendVideo(video_type, frame_type, payload_type, |
| 523 | capture_timestamp, capture_time_ms, payload_data, |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 524 | payload_size, fragmentation, codec_info, rtp_hdr); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 525 | } |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 526 | |
| 527 | CriticalSectionScoped cs(statistics_crit_.get()); |
pbos@webrtc.org | ce4e9a3 | 2014-12-18 13:50:16 +0000 | [diff] [blame] | 528 | // Note: This is currently only counting for video. |
| 529 | if (frame_type == kVideoFrameKey) { |
| 530 | ++frame_counts_.key_frames; |
| 531 | } else if (frame_type == kVideoFrameDelta) { |
| 532 | ++frame_counts_.delta_frames; |
| 533 | } |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 534 | if (frame_count_observer_) { |
pbos@webrtc.org | ce4e9a3 | 2014-12-18 13:50:16 +0000 | [diff] [blame] | 535 | frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc); |
sprang@webrtc.org | 71f055f | 2013-12-04 15:09:27 +0000 | [diff] [blame] | 536 | } |
| 537 | |
| 538 | return ret_val; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 539 | } |
| 540 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 541 | size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) { |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 542 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 543 | CriticalSectionScoped cs(send_critsect_.get()); |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 544 | if ((rtx_ & kRtxRedundantPayloads) == 0) |
| 545 | return 0; |
| 546 | } |
| 547 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 548 | uint8_t buffer[IP_PACKET_SIZE]; |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 549 | int bytes_left = static_cast<int>(bytes_to_send); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 550 | while (bytes_left > 0) { |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 551 | size_t length = bytes_left; |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 552 | int64_t capture_time_ms; |
| 553 | if (!packet_history_.GetBestFittingPacket(buffer, &length, |
| 554 | &capture_time_ms)) { |
| 555 | break; |
| 556 | } |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 557 | if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false)) |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 558 | break; |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 559 | RtpUtility::RtpHeaderParser rtp_parser(buffer, length); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 560 | RTPHeader rtp_header; |
| 561 | rtp_parser.Parse(rtp_header); |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 562 | bytes_left -= static_cast<int>(length - rtp_header.headerLength); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 563 | } |
| 564 | return bytes_to_send - bytes_left; |
| 565 | } |
| 566 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 567 | size_t RTPSender::BuildPaddingPacket(uint8_t* packet, size_t header_length) { |
| 568 | size_t padding_bytes_in_packet = kMaxPaddingLength; |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 569 | packet[0] |= 0x20; // Set padding bit. |
| 570 | int32_t *data = |
| 571 | reinterpret_cast<int32_t *>(&(packet[header_length])); |
| 572 | |
| 573 | // Fill data buffer with random data. |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 574 | for (size_t j = 0; j < (padding_bytes_in_packet >> 2); ++j) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 575 | data[j] = rand(); // NOLINT |
| 576 | } |
| 577 | // Set number of padding bytes in the last byte of the packet. |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 578 | packet[header_length + padding_bytes_in_packet - 1] = |
| 579 | static_cast<uint8_t>(padding_bytes_in_packet); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 580 | return padding_bytes_in_packet; |
| 581 | } |
| 582 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 583 | size_t RTPSender::TrySendPadData(size_t bytes) { |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 584 | int64_t capture_time_ms; |
| 585 | uint32_t timestamp; |
| 586 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 587 | CriticalSectionScoped cs(send_critsect_.get()); |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 588 | timestamp = timestamp_; |
| 589 | capture_time_ms = capture_time_ms_; |
| 590 | if (last_timestamp_time_ms_ > 0) { |
| 591 | timestamp += |
| 592 | (clock_->TimeInMilliseconds() - last_timestamp_time_ms_) * 90; |
| 593 | capture_time_ms += |
| 594 | (clock_->TimeInMilliseconds() - last_timestamp_time_ms_); |
| 595 | } |
| 596 | } |
| 597 | return SendPadData(timestamp, capture_time_ms, bytes); |
| 598 | } |
| 599 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 600 | size_t RTPSender::SendPadData(uint32_t timestamp, |
| 601 | int64_t capture_time_ms, |
| 602 | size_t bytes) { |
| 603 | size_t padding_bytes_in_packet = 0; |
| 604 | size_t bytes_sent = 0; |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 605 | for (; bytes > 0; bytes -= padding_bytes_in_packet) { |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 606 | // Always send full padding packets. |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 607 | if (bytes < kMaxPaddingLength) |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 608 | bytes = kMaxPaddingLength; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 609 | |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 610 | uint32_t ssrc; |
| 611 | uint16_t sequence_number; |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 612 | int payload_type; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 613 | bool over_rtx; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 614 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 615 | CriticalSectionScoped cs(send_critsect_.get()); |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 616 | // Only send padding packets following the last packet of a frame, |
| 617 | // indicated by the marker bit. |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 618 | if (rtx_ == kRtxOff) { |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 619 | // Without RTX we can't send padding in the middle of frames. |
| 620 | if (!last_packet_marker_bit_) |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 621 | return 0; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 622 | ssrc = ssrc_; |
| 623 | sequence_number = sequence_number_; |
| 624 | ++sequence_number_; |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 625 | payload_type = payload_type_; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 626 | over_rtx = false; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 627 | } else { |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 628 | // Without abs-send-time a media packet must be sent before padding so |
| 629 | // that the timestamps used for estimation are correct. |
| 630 | if (!media_has_been_sent_ && !rtp_header_extension_map_.IsRegistered( |
| 631 | kRtpExtensionAbsoluteSendTime)) |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 632 | return 0; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 633 | ssrc = ssrc_rtx_; |
| 634 | sequence_number = sequence_number_rtx_; |
| 635 | ++sequence_number_rtx_; |
andrew@webrtc.org | 8f27fcc | 2015-01-09 20:22:46 +0000 | [diff] [blame] | 636 | payload_type = ((rtx_ & kRtxRedundantPayloads) > 0) ? payload_type_rtx_ |
| 637 | : payload_type_; |
pbos@webrtc.org | 63c60ed | 2014-07-16 09:37:29 +0000 | [diff] [blame] | 638 | over_rtx = true; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 639 | } |
| 640 | } |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 641 | |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 642 | uint8_t padding_packet[IP_PACKET_SIZE]; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 643 | size_t header_length = |
| 644 | CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp, |
| 645 | sequence_number, std::vector<uint32_t>()); |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 646 | assert(header_length != static_cast<size_t>(-1)); |
| 647 | padding_bytes_in_packet = BuildPaddingPacket(padding_packet, header_length); |
| 648 | assert(padding_bytes_in_packet <= bytes); |
| 649 | size_t length = padding_bytes_in_packet + header_length; |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 650 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 651 | |
| 652 | RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length); |
| 653 | RTPHeader rtp_header; |
| 654 | rtp_parser.Parse(rtp_header); |
| 655 | |
| 656 | if (capture_time_ms > 0) { |
| 657 | UpdateTransmissionTimeOffset( |
| 658 | padding_packet, length, rtp_header, now_ms - capture_time_ms); |
pwestin@webrtc.org | 12d97f6 | 2012-01-05 10:54:44 +0000 | [diff] [blame] | 659 | } |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 660 | |
| 661 | UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms); |
| 662 | if (!SendPacketToNetwork(padding_packet, length)) |
| 663 | break; |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 664 | bytes_sent += padding_bytes_in_packet; |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 665 | UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false); |
pwestin@webrtc.org | 12d97f6 | 2012-01-05 10:54:44 +0000 | [diff] [blame] | 666 | } |
pbos@webrtc.org | 72491b9 | 2014-07-10 16:24:54 +0000 | [diff] [blame] | 667 | |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 668 | return bytes_sent; |
pwestin@webrtc.org | 12d97f6 | 2012-01-05 10:54:44 +0000 | [diff] [blame] | 669 | } |
| 670 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 671 | void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) { |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 672 | packet_history_.SetStorePacketsStatus(enable, number_to_store); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 673 | } |
| 674 | |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 675 | bool RTPSender::StorePackets() const { |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 676 | return packet_history_.StorePackets(); |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 677 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 678 | |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 679 | 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] | 680 | size_t length = IP_PACKET_SIZE; |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 681 | uint8_t data_buffer[IP_PACKET_SIZE]; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 682 | int64_t capture_time_ms; |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 683 | if (!packet_history_.GetPacketAndSetSendTime(packet_id, min_resend_time, true, |
| 684 | data_buffer, &length, |
| 685 | &capture_time_ms)) { |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 686 | // Packet not found. |
asapersson@webrtc.org | 83ed0a4 | 2012-04-23 12:43:05 +0000 | [diff] [blame] | 687 | return 0; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 688 | } |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 689 | |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 690 | if (paced_sender_) { |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 691 | RtpUtility::RtpHeaderParser rtp_parser(data_buffer, length); |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 692 | RTPHeader header; |
| 693 | if (!rtp_parser.Parse(header)) { |
| 694 | assert(false); |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 695 | return -1; |
| 696 | } |
stefan@webrtc.org | 88e0dda | 2014-07-04 09:20:42 +0000 | [diff] [blame] | 697 | // Convert from TickTime to Clock since capture_time_ms is based on |
| 698 | // TickTime. |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 699 | int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_; |
| 700 | if (!paced_sender_->SendPacket( |
| 701 | PacedSender::kHighPriority, header.ssrc, header.sequenceNumber, |
| 702 | corrected_capture_tims_ms, length - header.headerLength, true)) { |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 703 | // We can't send the packet right now. |
| 704 | // We will be called when it is time. |
stefan@webrtc.org | 5c58f63 | 2013-05-23 13:36:55 +0000 | [diff] [blame] | 705 | return length; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 706 | } |
| 707 | } |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 708 | int rtx = kRtxOff; |
| 709 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 710 | CriticalSectionScoped lock(send_critsect_.get()); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 711 | rtx = rtx_; |
| 712 | } |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 713 | return PrepareAndSendPacket(data_buffer, length, capture_time_ms, |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 714 | (rtx & kRtxRetransmitted) > 0, true) ? |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 715 | static_cast<int32_t>(length) : -1; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 716 | } |
| 717 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 718 | bool RTPSender::SendPacketToNetwork(const uint8_t *packet, size_t size) { |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 719 | int bytes_sent = -1; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 720 | if (transport_) { |
| 721 | bytes_sent = transport_->SendPacket(id_, packet, size); |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 722 | } |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 723 | TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
| 724 | "RTPSender::SendPacketToNetwork", "size", size, "sent", |
| 725 | bytes_sent); |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 726 | // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer. |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 727 | if (bytes_sent <= 0) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 728 | LOG(LS_WARNING) << "Transport failed to send packet"; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 729 | return false; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 730 | } |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 731 | return true; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 732 | } |
| 733 | |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 734 | int RTPSender::SelectiveRetransmissions() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 735 | if (!video_) |
| 736 | return -1; |
| 737 | return video_->SelectiveRetransmissions(); |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 738 | } |
| 739 | |
| 740 | int RTPSender::SetSelectiveRetransmissions(uint8_t settings) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 741 | if (!video_) |
| 742 | return -1; |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 743 | return video_->SetSelectiveRetransmissions(settings); |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 744 | } |
| 745 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 746 | void RTPSender::OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers, |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 747 | int64_t avg_rtt) { |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 748 | TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
| 749 | "RTPSender::OnReceivedNACK", "num_seqnum", |
| 750 | nack_sequence_numbers.size(), "avg_rtt", avg_rtt); |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 751 | const int64_t now = clock_->TimeInMilliseconds(); |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 752 | uint32_t bytes_re_sent = 0; |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 753 | uint32_t target_bitrate = GetTargetBitrate(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 754 | |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 755 | // Enough bandwidth to send NACK? |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 756 | if (!ProcessNACKBitRate(now)) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 757 | LOG(LS_INFO) << "NACK bitrate reached. Skip sending NACK response. Target " |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 758 | << target_bitrate; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 759 | return; |
| 760 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 761 | |
stefan@webrtc.org | becf9c8 | 2013-02-01 15:09:57 +0000 | [diff] [blame] | 762 | for (std::list<uint16_t>::const_iterator it = nack_sequence_numbers.begin(); |
| 763 | it != nack_sequence_numbers.end(); ++it) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 764 | const int32_t bytes_sent = ReSendPacket(*it, 5 + avg_rtt); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 765 | if (bytes_sent > 0) { |
| 766 | bytes_re_sent += bytes_sent; |
| 767 | } else if (bytes_sent == 0) { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 768 | // The packet has previously been resent. |
| 769 | // Try resending next packet in the list. |
| 770 | continue; |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 771 | } else { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 772 | // 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] | 773 | LOG(LS_WARNING) << "Failed resending RTP packet " << *it |
| 774 | << ", Discard rest of packets"; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 775 | break; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 776 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 777 | // Delay bandwidth estimate (RTT * BW). |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 778 | if (target_bitrate != 0 && avg_rtt) { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 779 | // kbits/s * ms = bits => bits/8 = bytes |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 780 | size_t target_bytes = |
| 781 | (static_cast<size_t>(target_bitrate / 1000) * avg_rtt) >> 3; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 782 | if (bytes_re_sent > target_bytes) { |
| 783 | break; // Ignore the rest of the packets in the list. |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 784 | } |
| 785 | } |
| 786 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 787 | if (bytes_re_sent > 0) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 788 | UpdateNACKBitRate(bytes_re_sent, now); |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 789 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 790 | } |
| 791 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 792 | bool RTPSender::ProcessNACKBitRate(uint32_t now) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 793 | uint32_t num = 0; |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 794 | size_t byte_count = 0; |
henrike@webrtc.org | fe526ff | 2014-06-25 20:59:51 +0000 | [diff] [blame] | 795 | const uint32_t kAvgIntervalMs = 1000; |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 796 | uint32_t target_bitrate = GetTargetBitrate(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 797 | |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 798 | CriticalSectionScoped cs(send_critsect_.get()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 799 | |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 800 | if (target_bitrate == 0) { |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 801 | return true; |
| 802 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 803 | for (num = 0; num < NACK_BYTECOUNT_SIZE; ++num) { |
stefan@webrtc.org | a15fbfd | 2014-06-17 17:32:05 +0000 | [diff] [blame] | 804 | if ((now - nack_byte_count_times_[num]) > kAvgIntervalMs) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 805 | // Don't use data older than 1sec. |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 806 | break; |
| 807 | } else { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 808 | byte_count += nack_byte_count_[num]; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 809 | } |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 810 | } |
henrike@webrtc.org | fe526ff | 2014-06-25 20:59:51 +0000 | [diff] [blame] | 811 | uint32_t time_interval = kAvgIntervalMs; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 812 | if (num == NACK_BYTECOUNT_SIZE) { |
| 813 | // More than NACK_BYTECOUNT_SIZE nack messages has been received |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 814 | // during the last msg_interval. |
henrike@webrtc.org | fe526ff | 2014-06-25 20:59:51 +0000 | [diff] [blame] | 815 | if (nack_byte_count_times_[num - 1] <= now) { |
| 816 | time_interval = now - nack_byte_count_times_[num - 1]; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 817 | } |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 818 | } |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 819 | return (byte_count * 8) < (target_bitrate / 1000 * time_interval); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 820 | } |
| 821 | |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 822 | void RTPSender::UpdateNACKBitRate(uint32_t bytes, int64_t now) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 823 | CriticalSectionScoped cs(send_critsect_.get()); |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 824 | if (bytes == 0) |
| 825 | return; |
| 826 | nack_bitrate_.Update(bytes); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 827 | // Save bitrate statistics. |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 828 | // Shift all but first time. |
| 829 | for (int i = NACK_BYTECOUNT_SIZE - 2; i >= 0; i--) { |
| 830 | nack_byte_count_[i + 1] = nack_byte_count_[i]; |
| 831 | nack_byte_count_times_[i + 1] = nack_byte_count_times_[i]; |
pwestin@webrtc.org | 8281e7d | 2012-01-10 14:09:18 +0000 | [diff] [blame] | 832 | } |
stefan@webrtc.org | 11d8176 | 2014-12-19 09:52:24 +0000 | [diff] [blame] | 833 | nack_byte_count_[0] = bytes; |
| 834 | nack_byte_count_times_[0] = now; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 835 | } |
| 836 | |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 837 | // Called from pacer when we can send the packet. |
hclam@chromium.org | 2e402ce | 2013-06-20 20:18:31 +0000 | [diff] [blame] | 838 | bool RTPSender::TimeToSendPacket(uint16_t sequence_number, |
stefan@webrtc.org | 9b82f5a | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 839 | int64_t capture_time_ms, |
| 840 | bool retransmission) { |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 841 | size_t length = IP_PACKET_SIZE; |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 842 | uint8_t data_buffer[IP_PACKET_SIZE]; |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 843 | int64_t stored_time_ms; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 844 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 845 | if (!packet_history_.GetPacketAndSetSendTime(sequence_number, |
| 846 | 0, |
| 847 | retransmission, |
| 848 | data_buffer, |
| 849 | &length, |
| 850 | &stored_time_ms)) { |
hclam@chromium.org | 2e402ce | 2013-06-20 20:18:31 +0000 | [diff] [blame] | 851 | // Packet cannot be found. Allow sending to continue. |
| 852 | return true; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 853 | } |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 854 | if (!retransmission && capture_time_ms > 0) { |
| 855 | UpdateDelayStatistics(capture_time_ms, clock_->TimeInMilliseconds()); |
| 856 | } |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 857 | int rtx; |
| 858 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 859 | CriticalSectionScoped lock(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 860 | rtx = rtx_; |
| 861 | } |
| 862 | return PrepareAndSendPacket(data_buffer, |
| 863 | length, |
| 864 | capture_time_ms, |
| 865 | retransmission && (rtx & kRtxRetransmitted) > 0, |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 866 | retransmission); |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 867 | } |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 868 | |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 869 | bool RTPSender::PrepareAndSendPacket(uint8_t* buffer, |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 870 | size_t length, |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 871 | int64_t capture_time_ms, |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 872 | bool send_over_rtx, |
| 873 | bool is_retransmit) { |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 874 | uint8_t *buffer_to_send_ptr = buffer; |
| 875 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 876 | RtpUtility::RtpHeaderParser rtp_parser(buffer, length); |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 877 | RTPHeader rtp_header; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 878 | rtp_parser.Parse(rtp_header); |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 879 | if (!is_retransmit && rtp_header.markerBit) { |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 880 | TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend", |
| 881 | capture_time_ms); |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 882 | } |
| 883 | |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 884 | TRACE_EVENT_INSTANT2( |
| 885 | TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PrepareAndSendPacket", |
| 886 | "timestamp", rtp_header.timestamp, "seqnum", rtp_header.sequenceNumber); |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 887 | |
stefan@webrtc.org | 9b82f5a | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 888 | uint8_t data_buffer_rtx[IP_PACKET_SIZE]; |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 889 | if (send_over_rtx) { |
| 890 | BuildRtxPacket(buffer, &length, data_buffer_rtx); |
stefan@webrtc.org | 9b82f5a | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 891 | buffer_to_send_ptr = data_buffer_rtx; |
| 892 | } |
| 893 | |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 894 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 895 | int64_t diff_ms = now_ms - capture_time_ms; |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 896 | UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header, |
| 897 | diff_ms); |
| 898 | UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 899 | bool ret = SendPacketToNetwork(buffer_to_send_ptr, length); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 900 | if (ret) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 901 | CriticalSectionScoped lock(send_critsect_.get()); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 902 | media_has_been_sent_ = true; |
| 903 | } |
stefan@webrtc.org | 7c6ff2d | 2014-03-19 18:14:52 +0000 | [diff] [blame] | 904 | UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx, |
| 905 | is_retransmit); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 906 | return ret; |
| 907 | } |
| 908 | |
| 909 | void RTPSender::UpdateRtpStats(const uint8_t* buffer, |
asapersson@webrtc.org | 97d0489 | 2014-12-09 09:47:53 +0000 | [diff] [blame] | 910 | size_t packet_length, |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 911 | const RTPHeader& header, |
| 912 | bool is_rtx, |
| 913 | bool is_retransmit) { |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 914 | StreamDataCounters* counters; |
sprang@webrtc.org | 5314e85 | 2014-01-27 13:20:36 +0000 | [diff] [blame] | 915 | // Get ssrc before taking statistics_crit_ to avoid possible deadlock. |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 916 | uint32_t ssrc = is_rtx ? RtxSsrc() : SSRC(); |
sprang@webrtc.org | 5314e85 | 2014-01-27 13:20:36 +0000 | [diff] [blame] | 917 | |
| 918 | CriticalSectionScoped lock(statistics_crit_.get()); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 919 | if (is_rtx) { |
| 920 | counters = &rtx_rtp_stats_; |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 921 | } else { |
| 922 | counters = &rtp_stats_; |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 923 | } |
| 924 | |
asapersson@webrtc.org | 97d0489 | 2014-12-09 09:47:53 +0000 | [diff] [blame] | 925 | total_bitrate_sent_.Update(packet_length); |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 926 | |
asapersson@webrtc.org | cfd82df | 2015-01-22 09:39:59 +0000 | [diff] [blame] | 927 | if (counters->first_packet_time_ms == -1) { |
asapersson@webrtc.org | d08d389 | 2014-12-16 12:03:11 +0000 | [diff] [blame] | 928 | counters->first_packet_time_ms = clock_->TimeInMilliseconds(); |
| 929 | } |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 930 | if (IsFecPacket(buffer, header)) { |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 931 | counters->fec.AddPacket(packet_length, header); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 932 | } |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 933 | if (is_retransmit) { |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 934 | counters->retransmitted.AddPacket(packet_length, header); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 935 | } |
asapersson@webrtc.org | 4414939 | 2015-02-04 08:34:47 +0000 | [diff] [blame] | 936 | counters->transmitted.AddPacket(packet_length, header); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 937 | |
| 938 | if (rtp_stats_callback_) { |
| 939 | rtp_stats_callback_->DataCountersUpdated(*counters, ssrc); |
| 940 | } |
| 941 | } |
| 942 | |
| 943 | bool RTPSender::IsFecPacket(const uint8_t* buffer, |
| 944 | const RTPHeader& header) const { |
| 945 | if (!video_) { |
| 946 | return false; |
| 947 | } |
| 948 | bool fec_enabled; |
| 949 | uint8_t pt_red; |
| 950 | uint8_t pt_fec; |
| 951 | video_->GenericFECStatus(fec_enabled, pt_red, pt_fec); |
| 952 | return fec_enabled && |
| 953 | header.payloadType == pt_red && |
| 954 | buffer[header.headerLength] == pt_fec; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 955 | } |
| 956 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 957 | size_t RTPSender::TimeToSendPadding(size_t bytes) { |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 958 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 959 | CriticalSectionScoped cs(send_critsect_.get()); |
andresp@webrtc.org | 817a034 | 2014-08-14 08:24:47 +0000 | [diff] [blame] | 960 | if (!sending_media_) return 0; |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 961 | } |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 962 | if (bytes == 0) |
| 963 | return 0; |
| 964 | size_t bytes_sent = TrySendRedundantPayloads(bytes); |
| 965 | if (bytes_sent < bytes) |
| 966 | bytes_sent += TrySendPadData(bytes - bytes_sent); |
| 967 | return bytes_sent; |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 968 | } |
| 969 | |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 970 | // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 971 | int32_t RTPSender::SendToNetwork( |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 972 | uint8_t *buffer, size_t payload_length, size_t rtp_header_length, |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 973 | int64_t capture_time_ms, StorageType storage, |
| 974 | PacedSender::Priority priority) { |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 975 | RtpUtility::RtpHeaderParser rtp_parser(buffer, |
| 976 | payload_length + rtp_header_length); |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 977 | RTPHeader rtp_header; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 978 | rtp_parser.Parse(rtp_header); |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 979 | |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 980 | int64_t now_ms = clock_->TimeInMilliseconds(); |
| 981 | |
stefan@webrtc.org | 715faaf | 2012-08-28 15:20:39 +0000 | [diff] [blame] | 982 | // |capture_time_ms| <= 0 is considered invalid. |
| 983 | // TODO(holmer): This should be changed all over Video Engine so that negative |
| 984 | // time is consider invalid, while 0 is considered a valid time. |
| 985 | if (capture_time_ms > 0) { |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 986 | UpdateTransmissionTimeOffset(buffer, payload_length + rtp_header_length, |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 987 | rtp_header, now_ms - capture_time_ms); |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 988 | } |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 989 | |
| 990 | UpdateAbsoluteSendTime(buffer, payload_length + rtp_header_length, |
| 991 | rtp_header, now_ms); |
| 992 | |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 993 | // Used for NACK and to spread out the transmission of packets. |
stefan@webrtc.org | 7e9315b | 2013-12-04 10:24:26 +0000 | [diff] [blame] | 994 | if (packet_history_.PutRTPPacket(buffer, rtp_header_length + payload_length, |
| 995 | max_payload_length_, capture_time_ms, |
| 996 | storage) != 0) { |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 997 | return -1; |
| 998 | } |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 999 | |
stefan@webrtc.org | bfacda6 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 1000 | if (paced_sender_ && storage != kDontStore) { |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 1001 | // Correct offset between implementations of millisecond time stamps in |
| 1002 | // TickTime and Clock. |
| 1003 | int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_; |
stefan@webrtc.org | 508a84b | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 1004 | if (!paced_sender_->SendPacket(priority, rtp_header.ssrc, |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 1005 | rtp_header.sequenceNumber, corrected_time_ms, |
stefan@webrtc.org | 9b82f5a | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 1006 | payload_length, false)) { |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 1007 | if (last_capture_time_ms_sent_ == 0 || |
| 1008 | corrected_time_ms > last_capture_time_ms_sent_) { |
| 1009 | last_capture_time_ms_sent_ = corrected_time_ms; |
sprang@webrtc.org | 0200f70 | 2015-02-16 12:06:00 +0000 | [diff] [blame] | 1010 | TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), |
| 1011 | "PacedSend", corrected_time_ms, |
sprang@webrtc.org | dcebf2d | 2014-11-04 16:27:16 +0000 | [diff] [blame] | 1012 | "capture_time_ms", corrected_time_ms); |
| 1013 | } |
pwestin@webrtc.org | 571a1c0 | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 1014 | // We can't send the packet right now. |
| 1015 | // We will be called when it is time. |
pwestin@webrtc.org | b0061f9 | 2013-04-27 00:41:08 +0000 | [diff] [blame] | 1016 | return 0; |
asapersson@webrtc.org | e5b49a0 | 2012-11-06 13:09:39 +0000 | [diff] [blame] | 1017 | } |
stefan@webrtc.org | ddfdfed | 2012-07-03 13:21:22 +0000 | [diff] [blame] | 1018 | } |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 1019 | if (capture_time_ms > 0) { |
| 1020 | UpdateDelayStatistics(capture_time_ms, now_ms); |
| 1021 | } |
sprang@webrtc.org | 43c8839 | 2015-01-29 09:09:17 +0000 | [diff] [blame] | 1022 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1023 | size_t length = payload_length + rtp_header_length; |
sprang@webrtc.org | c957ffc | 2015-02-02 13:08:02 +0000 | [diff] [blame] | 1024 | bool sent = SendPacketToNetwork(buffer, length); |
| 1025 | |
| 1026 | if (storage != kDontStore) { |
| 1027 | // Mark the packet as sent in the history even if send failed. Dropping a |
| 1028 | // packet here should be treated as any other packet drop so we should be |
| 1029 | // ready for a retransmission. |
| 1030 | packet_history_.SetSent(rtp_header.sequenceNumber); |
| 1031 | } |
| 1032 | if (!sent) |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1033 | return -1; |
sprang@webrtc.org | c957ffc | 2015-02-02 13:08:02 +0000 | [diff] [blame] | 1034 | |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1035 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1036 | CriticalSectionScoped lock(send_critsect_.get()); |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1037 | media_has_been_sent_ = true; |
| 1038 | } |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1039 | UpdateRtpStats(buffer, length, rtp_header, false, false); |
| 1040 | return 0; |
stefan@webrtc.org | 6a4bef4 | 2011-12-22 12:52:41 +0000 | [diff] [blame] | 1041 | } |
| 1042 | |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 1043 | void RTPSender::UpdateDelayStatistics(int64_t capture_time_ms, int64_t now_ms) { |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 1044 | uint32_t ssrc; |
| 1045 | int avg_delay_ms = 0; |
| 1046 | int max_delay_ms = 0; |
| 1047 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1048 | CriticalSectionScoped lock(send_critsect_.get()); |
stefan@webrtc.org | 168f23f | 2014-07-11 13:44:02 +0000 | [diff] [blame] | 1049 | ssrc = ssrc_; |
| 1050 | } |
| 1051 | { |
| 1052 | CriticalSectionScoped cs(statistics_crit_.get()); |
| 1053 | // TODO(holmer): Compute this iteratively instead. |
| 1054 | send_delays_[now_ms] = now_ms - capture_time_ms; |
| 1055 | send_delays_.erase(send_delays_.begin(), |
| 1056 | send_delays_.lower_bound(now_ms - |
| 1057 | kSendSideDelayWindowMs)); |
| 1058 | } |
| 1059 | if (send_side_delay_observer_ && |
| 1060 | GetSendSideDelay(&avg_delay_ms, &max_delay_ms)) { |
| 1061 | send_side_delay_observer_->SendSideDelayUpdated(avg_delay_ms, |
| 1062 | max_delay_ms, ssrc); |
| 1063 | } |
stefan@webrtc.org | 0a3c147 | 2013-12-05 14:05:07 +0000 | [diff] [blame] | 1064 | } |
| 1065 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1066 | void RTPSender::ProcessBitrate() { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1067 | CriticalSectionScoped cs(send_critsect_.get()); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1068 | total_bitrate_sent_.Process(); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1069 | nack_bitrate_.Process(); |
| 1070 | if (audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1071 | return; |
| 1072 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1073 | video_->ProcessBitrate(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1074 | } |
| 1075 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1076 | size_t RTPSender::RTPHeaderLength() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1077 | CriticalSectionScoped lock(send_critsect_.get()); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1078 | size_t rtp_header_length = kRtpHeaderLength; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1079 | rtp_header_length += sizeof(uint32_t) * csrcs_.size(); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1080 | rtp_header_length += RtpHeaderExtensionTotalLength(); |
| 1081 | return rtp_header_length; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1082 | } |
| 1083 | |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 1084 | uint16_t RTPSender::IncrementSequenceNumber() { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1085 | CriticalSectionScoped cs(send_critsect_.get()); |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 1086 | return sequence_number_++; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1087 | } |
| 1088 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1089 | void RTPSender::ResetDataCounters() { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1090 | uint32_t ssrc; |
| 1091 | uint32_t ssrc_rtx; |
pbos@webrtc.org | 49096de | 2015-02-24 22:37:52 +0000 | [diff] [blame] | 1092 | bool report_rtx; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1093 | { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1094 | CriticalSectionScoped ssrc_lock(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1095 | ssrc = ssrc_; |
| 1096 | ssrc_rtx = ssrc_rtx_; |
pbos@webrtc.org | 49096de | 2015-02-24 22:37:52 +0000 | [diff] [blame] | 1097 | report_rtx = rtx_ != kRtxOff; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1098 | } |
pbos@webrtc.org | e07049f | 2013-09-10 11:29:17 +0000 | [diff] [blame] | 1099 | CriticalSectionScoped lock(statistics_crit_.get()); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1100 | rtp_stats_ = StreamDataCounters(); |
| 1101 | rtx_rtp_stats_ = StreamDataCounters(); |
| 1102 | if (rtp_stats_callback_) { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1103 | rtp_stats_callback_->DataCountersUpdated(rtp_stats_, ssrc); |
pbos@webrtc.org | 49096de | 2015-02-24 22:37:52 +0000 | [diff] [blame] | 1104 | if (report_rtx) |
| 1105 | rtp_stats_callback_->DataCountersUpdated(rtx_rtp_stats_, ssrc_rtx); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1106 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1107 | } |
| 1108 | |
pbos@webrtc.org | 2f4b14e | 2014-07-15 15:25:39 +0000 | [diff] [blame] | 1109 | void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats, |
| 1110 | StreamDataCounters* rtx_stats) const { |
pbos@webrtc.org | e07049f | 2013-09-10 11:29:17 +0000 | [diff] [blame] | 1111 | CriticalSectionScoped lock(statistics_crit_.get()); |
pbos@webrtc.org | 2f4b14e | 2014-07-15 15:25:39 +0000 | [diff] [blame] | 1112 | *rtp_stats = rtp_stats_; |
| 1113 | *rtx_stats = rtx_rtp_stats_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1114 | } |
| 1115 | |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1116 | size_t RTPSender::CreateRtpHeader(uint8_t* header, |
| 1117 | int8_t payload_type, |
| 1118 | uint32_t ssrc, |
| 1119 | bool marker_bit, |
| 1120 | uint32_t timestamp, |
| 1121 | uint16_t sequence_number, |
| 1122 | const std::vector<uint32_t>& csrcs) const { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1123 | header[0] = 0x80; // version 2. |
| 1124 | header[1] = static_cast<uint8_t>(payload_type); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1125 | if (marker_bit) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1126 | header[1] |= kRtpMarkerBitMask; // Marker bit is set. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1127 | } |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1128 | ByteWriter<uint16_t>::WriteBigEndian(header + 2, sequence_number); |
| 1129 | ByteWriter<uint32_t>::WriteBigEndian(header + 4, timestamp); |
| 1130 | ByteWriter<uint32_t>::WriteBigEndian(header + 8, ssrc); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1131 | int32_t rtp_header_length = kRtpHeaderLength; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1132 | |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1133 | if (csrcs.size() > 0) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1134 | uint8_t *ptr = &header[rtp_header_length]; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1135 | for (size_t i = 0; i < csrcs.size(); ++i) { |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1136 | ByteWriter<uint32_t>::WriteBigEndian(ptr, csrcs[i]); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1137 | ptr += 4; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1138 | } |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1139 | header[0] = (header[0] & 0xf0) | csrcs.size(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1140 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1141 | // Update length of header. |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1142 | rtp_header_length += sizeof(uint32_t) * csrcs.size(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1143 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1144 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1145 | uint16_t len = |
| 1146 | BuildRTPHeaderExtension(header + rtp_header_length, marker_bit); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1147 | if (len > 0) { |
| 1148 | header[0] |= 0x10; // Set extension bit. |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1149 | rtp_header_length += len; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1150 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1151 | return rtp_header_length; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1152 | } |
| 1153 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1154 | int32_t RTPSender::BuildRTPheader(uint8_t* data_buffer, |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1155 | int8_t payload_type, |
| 1156 | bool marker_bit, |
| 1157 | uint32_t capture_timestamp, |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1158 | int64_t capture_time_ms, |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1159 | bool timestamp_provided, |
| 1160 | bool inc_sequence_number) { |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1161 | assert(payload_type >= 0); |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1162 | CriticalSectionScoped cs(send_critsect_.get()); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1163 | |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1164 | if (timestamp_provided) { |
| 1165 | timestamp_ = start_timestamp_ + capture_timestamp; |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1166 | } else { |
| 1167 | // Make a unique time stamp. |
| 1168 | // We can't inc by the actual time, since then we increase the risk of back |
| 1169 | // timing. |
| 1170 | timestamp_++; |
| 1171 | } |
henrik.lundin@webrtc.org | 6e95d7a | 2013-11-15 08:59:19 +0000 | [diff] [blame] | 1172 | last_timestamp_time_ms_ = clock_->TimeInMilliseconds(); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1173 | uint32_t sequence_number = sequence_number_++; |
stefan@webrtc.org | 8ccb9f9 | 2013-06-19 14:13:42 +0000 | [diff] [blame] | 1174 | capture_time_ms_ = capture_time_ms; |
| 1175 | last_packet_marker_bit_ = marker_bit; |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1176 | return CreateRtpHeader(data_buffer, payload_type, ssrc_, marker_bit, |
| 1177 | timestamp_, sequence_number, csrcs_); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1178 | } |
| 1179 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1180 | uint16_t RTPSender::BuildRTPHeaderExtension(uint8_t* data_buffer, |
| 1181 | bool marker_bit) const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1182 | if (rtp_header_extension_map_.Size() <= 0) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1183 | return 0; |
| 1184 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1185 | // RTP header extension, RFC 3550. |
| 1186 | // 0 1 2 3 |
| 1187 | // 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 |
| 1188 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1189 | // | defined by profile | length | |
| 1190 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1191 | // | header extension | |
| 1192 | // | .... | |
| 1193 | // |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1194 | const uint32_t kPosLength = 2; |
pbos@webrtc.org | 3004c79 | 2013-05-07 12:36:21 +0000 | [diff] [blame] | 1195 | const uint32_t kHeaderLength = kRtpOneByteHeaderLength; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1196 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1197 | // Add extension ID (0xBEDE). |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1198 | ByteWriter<uint16_t>::WriteBigEndian(data_buffer, |
| 1199 | kRtpOneByteHeaderExtensionId); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1200 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1201 | // Add extensions. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1202 | uint16_t total_block_length = 0; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1203 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1204 | RTPExtensionType type = rtp_header_extension_map_.First(); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1205 | while (type != kRtpExtensionNone) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1206 | uint8_t block_length = 0; |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1207 | uint8_t* extension_data = &data_buffer[kHeaderLength + total_block_length]; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1208 | switch (type) { |
| 1209 | case kRtpExtensionTransmissionTimeOffset: |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1210 | block_length = BuildTransmissionTimeOffsetExtension(extension_data); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1211 | break; |
solenberg@webrtc.org | c0352d5 | 2013-05-20 20:55:07 +0000 | [diff] [blame] | 1212 | case kRtpExtensionAudioLevel: |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1213 | block_length = BuildAudioLevelExtension(extension_data); |
solenberg@webrtc.org | c0352d5 | 2013-05-20 20:55:07 +0000 | [diff] [blame] | 1214 | break; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1215 | case kRtpExtensionAbsoluteSendTime: |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1216 | block_length = BuildAbsoluteSendTimeExtension(extension_data); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1217 | break; |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1218 | case kRtpExtensionVideoRotation: |
Guo-wei Shieh | 64c1e8c | 2015-04-01 15:33:06 -0700 | [diff] [blame^] | 1219 | block_length = BuildVideoRotationExtension(extension_data); |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1220 | break; |
| 1221 | case kRtpExtensionTransportSequenceNumber: |
| 1222 | block_length = BuildTransportSequenceNumberExtension(extension_data); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1223 | break; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1224 | default: |
| 1225 | assert(false); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1226 | } |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1227 | total_block_length += block_length; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1228 | type = rtp_header_extension_map_.Next(type); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1229 | } |
| 1230 | if (total_block_length == 0) { |
| 1231 | // No extension added. |
| 1232 | return 0; |
| 1233 | } |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1234 | // Add padding elements until we've filled a 32 bit block. |
| 1235 | size_t padding_bytes = |
| 1236 | RtpUtility::Word32Align(total_block_length) - total_block_length; |
| 1237 | if (padding_bytes > 0) { |
| 1238 | memset(&data_buffer[kHeaderLength + total_block_length], 0, padding_bytes); |
| 1239 | total_block_length += padding_bytes; |
| 1240 | } |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1241 | // Set header length (in number of Word32, header excluded). |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1242 | ByteWriter<uint16_t>::WriteBigEndian(data_buffer + kPosLength, |
| 1243 | total_block_length / 4); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1244 | // Total added length. |
| 1245 | return kHeaderLength + total_block_length; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1246 | } |
| 1247 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1248 | uint8_t RTPSender::BuildTransmissionTimeOffsetExtension( |
| 1249 | uint8_t* data_buffer) const { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1250 | // From RFC 5450: Transmission Time Offsets in RTP Streams. |
| 1251 | // |
| 1252 | // The transmission time is signaled to the receiver in-band using the |
| 1253 | // general mechanism for RTP header extensions [RFC5285]. The payload |
| 1254 | // of this extension (the transmitted value) is a 24-bit signed integer. |
| 1255 | // When added to the RTP timestamp of the packet, it represents the |
| 1256 | // "effective" RTP transmission time of the packet, on the RTP |
| 1257 | // timescale. |
| 1258 | // |
| 1259 | // The form of the transmission offset extension block: |
| 1260 | // |
| 1261 | // 0 1 2 3 |
| 1262 | // 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 |
| 1263 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1264 | // | ID | len=2 | transmission offset | |
| 1265 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1266 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1267 | // Get id defined by user. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1268 | uint8_t id; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1269 | if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset, |
| 1270 | &id) != 0) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1271 | // Not registered. |
| 1272 | return 0; |
| 1273 | } |
pbos@webrtc.org | 3004c79 | 2013-05-07 12:36:21 +0000 | [diff] [blame] | 1274 | size_t pos = 0; |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1275 | const uint8_t len = 2; |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1276 | data_buffer[pos++] = (id << 4) + len; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1277 | ByteWriter<int32_t, 3>::WriteBigEndian(data_buffer + pos, |
| 1278 | transmission_time_offset_); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1279 | pos += 3; |
pbos@webrtc.org | 3004c79 | 2013-05-07 12:36:21 +0000 | [diff] [blame] | 1280 | assert(pos == kTransmissionTimeOffsetLength); |
| 1281 | return kTransmissionTimeOffsetLength; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1282 | } |
| 1283 | |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1284 | uint8_t RTPSender::BuildAudioLevelExtension(uint8_t* data_buffer) const { |
| 1285 | // An RTP Header Extension for Client-to-Mixer Audio Level Indication |
| 1286 | // |
| 1287 | // https://datatracker.ietf.org/doc/draft-lennox-avt-rtp-audio-level-exthdr/ |
| 1288 | // |
| 1289 | // The form of the audio level extension block: |
| 1290 | // |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1291 | // 0 1 |
| 1292 | // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 |
| 1293 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1294 | // | ID | len=0 |V| level | |
| 1295 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1296 | // |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1297 | |
| 1298 | // Get id defined by user. |
| 1299 | uint8_t id; |
| 1300 | if (rtp_header_extension_map_.GetId(kRtpExtensionAudioLevel, &id) != 0) { |
| 1301 | // Not registered. |
| 1302 | return 0; |
| 1303 | } |
| 1304 | size_t pos = 0; |
| 1305 | const uint8_t len = 0; |
| 1306 | data_buffer[pos++] = (id << 4) + len; |
| 1307 | data_buffer[pos++] = (1 << 7) + 0; // Voice, 0 dBov. |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1308 | assert(pos == kAudioLevelLength); |
| 1309 | return kAudioLevelLength; |
| 1310 | } |
| 1311 | |
| 1312 | uint8_t RTPSender::BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const { |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1313 | // Absolute send time in RTP streams. |
| 1314 | // |
| 1315 | // The absolute send time is signaled to the receiver in-band using the |
| 1316 | // general mechanism for RTP header extensions [RFC5285]. The payload |
| 1317 | // of this extension (the transmitted value) is a 24-bit unsigned integer |
| 1318 | // containing the sender's current time in seconds as a fixed point number |
| 1319 | // with 18 bits fractional part. |
| 1320 | // |
| 1321 | // The form of the absolute send time extension block: |
| 1322 | // |
| 1323 | // 0 1 2 3 |
| 1324 | // 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 |
| 1325 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1326 | // | ID | len=2 | absolute send time | |
| 1327 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1328 | |
| 1329 | // Get id defined by user. |
| 1330 | uint8_t id; |
| 1331 | if (rtp_header_extension_map_.GetId(kRtpExtensionAbsoluteSendTime, |
| 1332 | &id) != 0) { |
| 1333 | // Not registered. |
| 1334 | return 0; |
| 1335 | } |
| 1336 | size_t pos = 0; |
| 1337 | const uint8_t len = 2; |
| 1338 | data_buffer[pos++] = (id << 4) + len; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1339 | ByteWriter<uint32_t, 3>::WriteBigEndian(data_buffer + pos, |
| 1340 | absolute_send_time_); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1341 | pos += 3; |
| 1342 | assert(pos == kAbsoluteSendTimeLength); |
| 1343 | return kAbsoluteSendTimeLength; |
| 1344 | } |
| 1345 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1346 | uint8_t RTPSender::BuildVideoRotationExtension(uint8_t* data_buffer) const { |
| 1347 | // Coordination of Video Orientation in RTP streams. |
| 1348 | // |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1349 | // Coordination of Video Orientation consists in signaling of the current |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1350 | // orientation of the image captured on the sender side to the receiver for |
| 1351 | // appropriate rendering and displaying. |
| 1352 | // |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1353 | // 0 1 |
| 1354 | // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 |
| 1355 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1356 | // | ID | len=0 |0 0 0 0 C F R R| |
| 1357 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1358 | // |
| 1359 | |
| 1360 | // Get id defined by user. |
| 1361 | uint8_t id; |
| 1362 | if (rtp_header_extension_map_.GetId(kRtpExtensionVideoRotation, &id) != 0) { |
| 1363 | // Not registered. |
| 1364 | return 0; |
| 1365 | } |
| 1366 | size_t pos = 0; |
| 1367 | const uint8_t len = 0; |
| 1368 | data_buffer[pos++] = (id << 4) + len; |
guoweis@webrtc.org | fdd1057 | 2015-03-12 20:50:57 +0000 | [diff] [blame] | 1369 | data_buffer[pos++] = ConvertVideoRotationToCVOByte(rotation_); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1370 | assert(pos == kVideoRotationLength); |
| 1371 | return kVideoRotationLength; |
| 1372 | } |
| 1373 | |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1374 | uint8_t RTPSender::BuildTransportSequenceNumberExtension( |
| 1375 | uint8_t* data_buffer) const { |
| 1376 | // 0 1 2 |
| 1377 | // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 |
| 1378 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1379 | // | ID | L=1 |transport wide sequence number | |
| 1380 | // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| 1381 | |
| 1382 | // Get id defined by user. |
| 1383 | uint8_t id; |
| 1384 | if (rtp_header_extension_map_.GetId(kRtpExtensionTransportSequenceNumber, |
| 1385 | &id) != 0) { |
| 1386 | // Not registered. |
| 1387 | return 0; |
| 1388 | } |
| 1389 | size_t pos = 0; |
| 1390 | const uint8_t len = 1; |
| 1391 | data_buffer[pos++] = (id << 4) + len; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1392 | ByteWriter<uint16_t>::WriteBigEndian(data_buffer + pos, |
| 1393 | transport_sequence_number_); |
sprang@webrtc.org | 3093390 | 2015-03-17 14:33:12 +0000 | [diff] [blame] | 1394 | pos += 2; |
| 1395 | assert(pos == kTransportSequenceNumberLength); |
| 1396 | return kTransportSequenceNumberLength; |
| 1397 | } |
| 1398 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1399 | bool RTPSender::FindHeaderExtensionPosition(RTPExtensionType type, |
| 1400 | const uint8_t* rtp_packet, |
| 1401 | size_t rtp_packet_length, |
| 1402 | const RTPHeader& rtp_header, |
| 1403 | size_t* position) const { |
| 1404 | // Get length until start of header extension block. |
| 1405 | int extension_block_pos = |
| 1406 | rtp_header_extension_map_.GetLengthUntilBlockStartInBytes(type); |
| 1407 | if (extension_block_pos < 0) { |
| 1408 | LOG(LS_WARNING) << "Failed to find extension position for " << type |
| 1409 | << " as it is not registered."; |
| 1410 | return false; |
| 1411 | } |
| 1412 | |
| 1413 | HeaderExtension header_extension(type); |
| 1414 | |
| 1415 | size_t block_pos = |
| 1416 | kRtpHeaderLength + rtp_header.numCSRCs + extension_block_pos; |
| 1417 | if (rtp_packet_length < block_pos + header_extension.length || |
| 1418 | rtp_header.headerLength < block_pos + header_extension.length) { |
| 1419 | LOG(LS_WARNING) << "Failed to find extension position for " << type |
| 1420 | << " as the length is invalid."; |
| 1421 | return false; |
| 1422 | } |
| 1423 | |
| 1424 | // Verify that header contains extension. |
| 1425 | if (!((rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs] == 0xBE) && |
| 1426 | (rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs + 1] == 0xDE))) { |
| 1427 | LOG(LS_WARNING) << "Failed to find extension position for " << type |
| 1428 | << "as hdr extension not found."; |
| 1429 | return false; |
| 1430 | } |
| 1431 | |
| 1432 | *position = block_pos; |
| 1433 | return true; |
| 1434 | } |
| 1435 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1436 | void RTPSender::UpdateTransmissionTimeOffset(uint8_t* rtp_packet, |
| 1437 | size_t rtp_packet_length, |
| 1438 | const RTPHeader& rtp_header, |
| 1439 | int64_t time_diff_ms) const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1440 | CriticalSectionScoped cs(send_critsect_.get()); |
stefan@webrtc.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1441 | // Get id. |
| 1442 | uint8_t id = 0; |
| 1443 | if (rtp_header_extension_map_.GetId(kRtpExtensionTransmissionTimeOffset, |
| 1444 | &id) != 0) { |
| 1445 | // Not registered. |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1446 | return; |
stefan@webrtc.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1447 | } |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1448 | |
| 1449 | size_t block_pos = 0; |
| 1450 | if (!FindHeaderExtensionPosition(kRtpExtensionTransmissionTimeOffset, |
| 1451 | rtp_packet, rtp_packet_length, rtp_header, |
| 1452 | &block_pos)) { |
| 1453 | LOG(LS_WARNING) << "Failed to update transmission time offset."; |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1454 | return; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 1455 | } |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1456 | |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 1457 | // Verify first byte in block. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1458 | const uint8_t first_block_byte = (id << 4) + 2; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 1459 | if (rtp_packet[block_pos] != first_block_byte) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 1460 | LOG(LS_WARNING) << "Failed to update transmission time offset."; |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1461 | return; |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 1462 | } |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1463 | // Update transmission offset field (converting to a 90 kHz timestamp). |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1464 | ByteWriter<int32_t, 3>::WriteBigEndian(rtp_packet + block_pos + 1, |
| 1465 | time_diff_ms * 90); // RTP timestamp. |
asapersson@webrtc.org | 0b3c35a | 2012-01-16 11:06:31 +0000 | [diff] [blame] | 1466 | } |
| 1467 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1468 | bool RTPSender::UpdateAudioLevel(uint8_t* rtp_packet, |
| 1469 | size_t rtp_packet_length, |
| 1470 | const RTPHeader& rtp_header, |
| 1471 | bool is_voiced, |
| 1472 | uint8_t dBov) const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1473 | CriticalSectionScoped cs(send_critsect_.get()); |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1474 | |
stefan@webrtc.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1475 | // Get id. |
| 1476 | uint8_t id = 0; |
| 1477 | if (rtp_header_extension_map_.GetId(kRtpExtensionAudioLevel, &id) != 0) { |
| 1478 | // Not registered. |
| 1479 | return false; |
| 1480 | } |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1481 | |
| 1482 | size_t block_pos = 0; |
| 1483 | if (!FindHeaderExtensionPosition(kRtpExtensionAudioLevel, rtp_packet, |
| 1484 | rtp_packet_length, rtp_header, &block_pos)) { |
| 1485 | LOG(LS_WARNING) << "Failed to update audio level."; |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1486 | return false; |
| 1487 | } |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1488 | |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1489 | // Verify first byte in block. |
| 1490 | const uint8_t first_block_byte = (id << 4) + 0; |
| 1491 | if (rtp_packet[block_pos] != first_block_byte) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 1492 | LOG(LS_WARNING) << "Failed to update audio level."; |
wu@webrtc.org | ebdb0e3 | 2014-03-06 23:49:08 +0000 | [diff] [blame] | 1493 | return false; |
| 1494 | } |
| 1495 | rtp_packet[block_pos + 1] = (is_voiced ? 0x80 : 0x00) + (dBov & 0x7f); |
| 1496 | return true; |
| 1497 | } |
| 1498 | |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1499 | bool RTPSender::UpdateVideoRotation(uint8_t* rtp_packet, |
| 1500 | size_t rtp_packet_length, |
| 1501 | const RTPHeader& rtp_header, |
| 1502 | VideoRotation rotation) const { |
| 1503 | CriticalSectionScoped cs(send_critsect_.get()); |
| 1504 | |
| 1505 | // Get id. |
| 1506 | uint8_t id = 0; |
| 1507 | if (rtp_header_extension_map_.GetId(kRtpExtensionVideoRotation, &id) != 0) { |
| 1508 | // Not registered. |
| 1509 | return false; |
| 1510 | } |
| 1511 | |
| 1512 | size_t block_pos = 0; |
| 1513 | if (!FindHeaderExtensionPosition(kRtpExtensionVideoRotation, rtp_packet, |
| 1514 | rtp_packet_length, rtp_header, &block_pos)) { |
| 1515 | LOG(LS_WARNING) << "Failed to update video rotation (CVO)."; |
| 1516 | return false; |
| 1517 | } |
| 1518 | // Get length until start of header extension block. |
| 1519 | int extension_block_pos = |
| 1520 | rtp_header_extension_map_.GetLengthUntilBlockStartInBytes( |
| 1521 | kRtpExtensionVideoRotation); |
| 1522 | if (extension_block_pos < 0) { |
| 1523 | // The feature is not enabled. |
| 1524 | return false; |
| 1525 | } |
| 1526 | |
| 1527 | // Verify first byte in block. |
| 1528 | const uint8_t first_block_byte = (id << 4) + 0; |
| 1529 | if (rtp_packet[block_pos] != first_block_byte) { |
| 1530 | LOG(LS_WARNING) << "Failed to update CVO."; |
| 1531 | return false; |
| 1532 | } |
guoweis@webrtc.org | fdd1057 | 2015-03-12 20:50:57 +0000 | [diff] [blame] | 1533 | rtp_packet[block_pos + 1] = ConvertVideoRotationToCVOByte(rotation); |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1534 | return true; |
| 1535 | } |
| 1536 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1537 | void RTPSender::UpdateAbsoluteSendTime(uint8_t* rtp_packet, |
| 1538 | size_t rtp_packet_length, |
| 1539 | const RTPHeader& rtp_header, |
| 1540 | int64_t now_ms) const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1541 | CriticalSectionScoped cs(send_critsect_.get()); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1542 | |
stefan@webrtc.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1543 | // Get id. |
| 1544 | uint8_t id = 0; |
| 1545 | if (rtp_header_extension_map_.GetId(kRtpExtensionAbsoluteSendTime, |
| 1546 | &id) != 0) { |
| 1547 | // Not registered. |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1548 | return; |
stefan@webrtc.org | 2f8d5f3 | 2014-04-15 12:28:46 +0000 | [diff] [blame] | 1549 | } |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1550 | // Get length until start of header extension block. |
| 1551 | int extension_block_pos = |
| 1552 | rtp_header_extension_map_.GetLengthUntilBlockStartInBytes( |
| 1553 | kRtpExtensionAbsoluteSendTime); |
| 1554 | if (extension_block_pos < 0) { |
andrew@webrtc.org | 2c3f1ab | 2014-04-15 21:26:34 +0000 | [diff] [blame] | 1555 | // The feature is not enabled. |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1556 | return; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1557 | } |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1558 | size_t block_pos = |
| 1559 | kRtpHeaderLength + rtp_header.numCSRCs + extension_block_pos; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1560 | if (rtp_packet_length < block_pos + kAbsoluteSendTimeLength || |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1561 | rtp_header.headerLength < block_pos + kAbsoluteSendTimeLength) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 1562 | LOG(LS_WARNING) << "Failed to update absolute send time, invalid length."; |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1563 | return; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1564 | } |
| 1565 | // Verify that header contains extension. |
guoweis@webrtc.org | 4536289 | 2015-03-04 22:55:15 +0000 | [diff] [blame] | 1566 | if (!((rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs] == 0xBE) && |
| 1567 | (rtp_packet[kRtpHeaderLength + rtp_header.numCSRCs + 1] == 0xDE))) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 1568 | LOG(LS_WARNING) |
| 1569 | << "Failed to update absolute send time, hdr extension not found."; |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1570 | return; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1571 | } |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1572 | // Verify first byte in block. |
| 1573 | const uint8_t first_block_byte = (id << 4) + 2; |
| 1574 | if (rtp_packet[block_pos] != first_block_byte) { |
andresp@webrtc.org | dc80bae | 2014-04-08 11:06:12 +0000 | [diff] [blame] | 1575 | LOG(LS_WARNING) << "Failed to update absolute send time."; |
stefan@webrtc.org | 420b256 | 2014-05-30 12:17:15 +0000 | [diff] [blame] | 1576 | return; |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1577 | } |
| 1578 | // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit |
| 1579 | // fractional part). |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1580 | ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + block_pos + 1, |
| 1581 | ((now_ms << 18) / 1000) & 0x00ffffff); |
solenberg@webrtc.org | 7ebbea1 | 2013-05-16 11:10:31 +0000 | [diff] [blame] | 1582 | } |
| 1583 | |
pbos@webrtc.org | 59f20bb | 2013-09-09 16:02:19 +0000 | [diff] [blame] | 1584 | void RTPSender::SetSendingStatus(bool enabled) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1585 | if (enabled) { |
pbos@webrtc.org | 59f20bb | 2013-09-09 16:02:19 +0000 | [diff] [blame] | 1586 | uint32_t frequency_hz = SendPayloadFrequency(); |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 1587 | uint32_t RTPtime = RtpUtility::GetCurrentRTP(clock_, frequency_hz); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1588 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1589 | // Will be ignored if it's already configured via API. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1590 | SetStartTimestamp(RTPtime, false); |
| 1591 | } else { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1592 | CriticalSectionScoped lock(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1593 | if (!ssrc_forced_) { |
| 1594 | // Generate a new SSRC. |
| 1595 | ssrc_db_.ReturnSSRC(ssrc_); |
| 1596 | ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1597 | bitrates_->set_ssrc(ssrc_); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1598 | } |
| 1599 | // Don't initialize seq number if SSRC passed externally. |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1600 | if (!sequence_number_forced_ && !ssrc_forced_) { |
| 1601 | // Generate a new sequence number. |
| 1602 | sequence_number_ = |
| 1603 | rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER); // NOLINT |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1604 | } |
| 1605 | } |
| 1606 | } |
| 1607 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1608 | void RTPSender::SetSendingMediaStatus(bool enabled) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1609 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1610 | sending_media_ = enabled; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1611 | } |
| 1612 | |
| 1613 | bool RTPSender::SendingMedia() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1614 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1615 | return sending_media_; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1616 | } |
| 1617 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1618 | uint32_t RTPSender::Timestamp() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1619 | CriticalSectionScoped cs(send_critsect_.get()); |
stefan@webrtc.org | a817962 | 2013-06-04 13:47:36 +0000 | [diff] [blame] | 1620 | return timestamp_; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1621 | } |
| 1622 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1623 | void RTPSender::SetStartTimestamp(uint32_t timestamp, bool force) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1624 | CriticalSectionScoped cs(send_critsect_.get()); |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1625 | if (force) { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1626 | start_timestamp_forced_ = true; |
| 1627 | start_timestamp_ = timestamp; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1628 | } else { |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1629 | if (!start_timestamp_forced_) { |
| 1630 | start_timestamp_ = timestamp; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1631 | } |
| 1632 | } |
| 1633 | } |
| 1634 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1635 | uint32_t RTPSender::StartTimestamp() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1636 | CriticalSectionScoped cs(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1637 | return start_timestamp_; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1638 | } |
| 1639 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1640 | uint32_t RTPSender::GenerateNewSSRC() { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1641 | // If configured via API, return 0. |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1642 | CriticalSectionScoped cs(send_critsect_.get()); |
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 | if (ssrc_forced_) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1645 | return 0; |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1646 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1647 | ssrc_ = ssrc_db_.CreateSSRC(); // Can't be 0. |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1648 | bitrates_->set_ssrc(ssrc_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1649 | return ssrc_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1650 | } |
| 1651 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1652 | void RTPSender::SetSSRC(uint32_t ssrc) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1653 | // This is configured via the API. |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1654 | CriticalSectionScoped cs(send_critsect_.get()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1655 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1656 | if (ssrc_ == ssrc && ssrc_forced_) { |
| 1657 | return; // Since it's same ssrc, don't reset anything. |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1658 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1659 | ssrc_forced_ = true; |
| 1660 | ssrc_db_.ReturnSSRC(ssrc_); |
| 1661 | ssrc_db_.RegisterSSRC(ssrc); |
| 1662 | ssrc_ = ssrc; |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1663 | bitrates_->set_ssrc(ssrc_); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1664 | if (!sequence_number_forced_) { |
| 1665 | sequence_number_ = |
| 1666 | rand() / (RAND_MAX / MAX_INIT_RTP_SEQ_NUMBER); // NOLINT |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1667 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1668 | } |
| 1669 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1670 | uint32_t RTPSender::SSRC() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1671 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1672 | return ssrc_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1673 | } |
| 1674 | |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1675 | void RTPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) { |
| 1676 | assert(csrcs.size() <= kRtpCsrcSize); |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1677 | CriticalSectionScoped cs(send_critsect_.get()); |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 1678 | csrcs_ = csrcs; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1679 | } |
| 1680 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1681 | void RTPSender::SetSequenceNumber(uint16_t seq) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1682 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1683 | sequence_number_forced_ = true; |
| 1684 | sequence_number_ = seq; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1685 | } |
| 1686 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1687 | uint16_t RTPSender::SequenceNumber() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1688 | CriticalSectionScoped cs(send_critsect_.get()); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1689 | return sequence_number_; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1690 | } |
| 1691 | |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1692 | // Audio. |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1693 | int32_t RTPSender::SendTelephoneEvent(uint8_t key, |
| 1694 | uint16_t time_ms, |
| 1695 | uint8_t level) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1696 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1697 | return -1; |
| 1698 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1699 | return audio_->SendTelephoneEvent(key, time_ms, level); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1700 | } |
| 1701 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1702 | int32_t RTPSender::SetAudioPacketSize(uint16_t packet_size_samples) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1703 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1704 | return -1; |
| 1705 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1706 | return audio_->SetAudioPacketSize(packet_size_samples); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1707 | } |
| 1708 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1709 | int32_t RTPSender::SetAudioLevel(uint8_t level_d_bov) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1710 | return audio_->SetAudioLevel(level_d_bov); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1711 | } |
| 1712 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1713 | int32_t RTPSender::SetRED(int8_t payload_type) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1714 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1715 | return -1; |
| 1716 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1717 | return audio_->SetRED(payload_type); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1718 | } |
| 1719 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1720 | int32_t RTPSender::RED(int8_t *payload_type) const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1721 | if (!audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1722 | return -1; |
| 1723 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1724 | return audio_->RED(*payload_type); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1725 | } |
| 1726 | |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 1727 | // Video |
| 1728 | VideoCodecInformation *RTPSender::CodecInformationVideo() { |
| 1729 | if (audio_configured_) { |
| 1730 | return NULL; |
| 1731 | } |
| 1732 | return video_->CodecInformationVideo(); |
| 1733 | } |
| 1734 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1735 | RtpVideoCodecTypes RTPSender::VideoCodecType() const { |
pbos@webrtc.org | 8911ce4 | 2013-03-18 16:39:03 +0000 | [diff] [blame] | 1736 | assert(!audio_configured_ && "Sender is an audio stream!"); |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1737 | return video_->VideoCodecType(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1738 | } |
| 1739 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1740 | uint32_t RTPSender::MaxConfiguredBitrateVideo() const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1741 | if (audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1742 | return 0; |
| 1743 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1744 | return video_->MaxConfiguredBitrateVideo(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1745 | } |
| 1746 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1747 | int32_t RTPSender::SendRTPIntraRequest() { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1748 | if (audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1749 | return -1; |
| 1750 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1751 | return video_->SendRTPIntraRequest(); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1752 | } |
| 1753 | |
pbos@webrtc.org | d16e839 | 2014-12-19 13:49:55 +0000 | [diff] [blame] | 1754 | int32_t RTPSender::SetGenericFECStatus(bool enable, |
| 1755 | uint8_t payload_type_red, |
| 1756 | uint8_t payload_type_fec) { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1757 | if (audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1758 | return -1; |
| 1759 | } |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 1760 | return video_->SetGenericFECStatus(enable, payload_type_red, |
| 1761 | payload_type_fec); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1762 | } |
| 1763 | |
pkasting@chromium.org | d324546 | 2015-02-23 21:28:22 +0000 | [diff] [blame] | 1764 | int32_t RTPSender::GenericFECStatus(bool* enable, |
| 1765 | uint8_t* payload_type_red, |
| 1766 | uint8_t* payload_type_fec) const { |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1767 | if (audio_configured_) { |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1768 | return -1; |
| 1769 | } |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 1770 | return video_->GenericFECStatus( |
| 1771 | *enable, *payload_type_red, *payload_type_fec); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1772 | } |
| 1773 | |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1774 | int32_t RTPSender::SetFecParameters( |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1775 | const FecProtectionParams *delta_params, |
| 1776 | const FecProtectionParams *key_params) { |
| 1777 | if (audio_configured_) { |
stefan@webrtc.org | e0d6fa4 | 2012-03-20 22:10:56 +0000 | [diff] [blame] | 1778 | return -1; |
| 1779 | } |
mflodman | 0828a0c | 2015-03-31 15:29:23 +0200 | [diff] [blame] | 1780 | return video_->SetFecParameters(delta_params, key_params); |
marpan@google.com | 80c5d7a | 2011-07-15 21:32:40 +0000 | [diff] [blame] | 1781 | } |
phoglund@webrtc.org | 43da54a | 2013-01-25 10:53:38 +0000 | [diff] [blame] | 1782 | |
pkasting@chromium.org | 4591fbd | 2014-11-20 22:28:14 +0000 | [diff] [blame] | 1783 | void RTPSender::BuildRtxPacket(uint8_t* buffer, size_t* length, |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1784 | uint8_t* buffer_rtx) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1785 | CriticalSectionScoped cs(send_critsect_.get()); |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1786 | uint8_t* data_buffer_rtx = buffer_rtx; |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1787 | // Add RTX header. |
pbos@webrtc.org | 62bafae | 2014-07-08 12:10:51 +0000 | [diff] [blame] | 1788 | RtpUtility::RtpHeaderParser rtp_parser( |
| 1789 | reinterpret_cast<const uint8_t*>(buffer), *length); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1790 | |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1791 | RTPHeader rtp_header; |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1792 | rtp_parser.Parse(rtp_header); |
| 1793 | |
| 1794 | // Add original RTP header. |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1795 | memcpy(data_buffer_rtx, buffer, rtp_header.headerLength); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1796 | |
andrew@webrtc.org | 8f27fcc | 2015-01-09 20:22:46 +0000 | [diff] [blame] | 1797 | // Replace payload type, if a specific type is set for RTX. |
| 1798 | if (payload_type_rtx_ != -1) { |
| 1799 | data_buffer_rtx[1] = static_cast<uint8_t>(payload_type_rtx_); |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1800 | if (rtp_header.markerBit) |
mflodman@webrtc.org | 9f5ebb5 | 2013-04-12 14:55:46 +0000 | [diff] [blame] | 1801 | data_buffer_rtx[1] |= kRtpMarkerBitMask; |
| 1802 | } |
| 1803 | |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1804 | // Replace sequence number. |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 1805 | uint8_t *ptr = data_buffer_rtx + 2; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1806 | ByteWriter<uint16_t>::WriteBigEndian(ptr, sequence_number_rtx_++); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1807 | |
| 1808 | // Replace SSRC. |
| 1809 | ptr += 6; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1810 | ByteWriter<uint32_t>::WriteBigEndian(ptr, ssrc_rtx_); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1811 | |
| 1812 | // Add OSN (original sequence number). |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1813 | ptr = data_buffer_rtx + rtp_header.headerLength; |
sprang@webrtc.org | 779c3d1 | 2015-03-17 16:42:49 +0000 | [diff] [blame] | 1814 | ByteWriter<uint16_t>::WriteBigEndian(ptr, rtp_header.sequenceNumber); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1815 | ptr += 2; |
| 1816 | |
| 1817 | // Add original payload data. |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 1818 | memcpy(ptr, buffer + rtp_header.headerLength, |
| 1819 | *length - rtp_header.headerLength); |
mikhal@webrtc.org | bda7f30 | 2013-03-15 23:21:52 +0000 | [diff] [blame] | 1820 | *length += 2; |
| 1821 | } |
| 1822 | |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1823 | void RTPSender::RegisterRtpStatisticsCallback( |
| 1824 | StreamDataCountersCallback* callback) { |
| 1825 | CriticalSectionScoped cs(statistics_crit_.get()); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 1826 | rtp_stats_callback_ = callback; |
| 1827 | } |
| 1828 | |
| 1829 | StreamDataCountersCallback* RTPSender::GetRtpStatisticsCallback() const { |
| 1830 | CriticalSectionScoped cs(statistics_crit_.get()); |
| 1831 | return rtp_stats_callback_; |
| 1832 | } |
| 1833 | |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1834 | uint32_t RTPSender::BitrateSent() const { |
| 1835 | return total_bitrate_sent_.BitrateLast(); |
sprang@webrtc.org | 6811b6e | 2013-12-13 09:46:59 +0000 | [diff] [blame] | 1836 | } |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1837 | |
| 1838 | void RTPSender::SetRtpState(const RtpState& rtp_state) { |
| 1839 | SetStartTimestamp(rtp_state.start_timestamp, true); |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1840 | CriticalSectionScoped lock(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1841 | sequence_number_ = rtp_state.sequence_number; |
| 1842 | sequence_number_forced_ = true; |
| 1843 | timestamp_ = rtp_state.timestamp; |
| 1844 | capture_time_ms_ = rtp_state.capture_time_ms; |
| 1845 | last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms; |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1846 | media_has_been_sent_ = rtp_state.media_has_been_sent; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1847 | } |
| 1848 | |
| 1849 | RtpState RTPSender::GetRtpState() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1850 | CriticalSectionScoped lock(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1851 | |
| 1852 | RtpState state; |
| 1853 | state.sequence_number = sequence_number_; |
| 1854 | state.start_timestamp = start_timestamp_; |
| 1855 | state.timestamp = timestamp_; |
| 1856 | state.capture_time_ms = capture_time_ms_; |
| 1857 | state.last_timestamp_time_ms = last_timestamp_time_ms_; |
stefan@webrtc.org | 8b94e3d | 2014-07-17 16:10:14 +0000 | [diff] [blame] | 1858 | state.media_has_been_sent = media_has_been_sent_; |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1859 | |
| 1860 | return state; |
| 1861 | } |
| 1862 | |
| 1863 | void RTPSender::SetRtxRtpState(const RtpState& rtp_state) { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1864 | CriticalSectionScoped lock(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1865 | sequence_number_rtx_ = rtp_state.sequence_number; |
| 1866 | } |
| 1867 | |
| 1868 | RtpState RTPSender::GetRtxRtpState() const { |
pbos@webrtc.org | 7c4d20f | 2015-02-12 12:20:08 +0000 | [diff] [blame] | 1869 | CriticalSectionScoped lock(send_critsect_.get()); |
pbos@webrtc.org | 2bb1bda | 2014-07-07 13:06:48 +0000 | [diff] [blame] | 1870 | |
| 1871 | RtpState state; |
| 1872 | state.sequence_number = sequence_number_rtx_; |
| 1873 | state.start_timestamp = start_timestamp_; |
| 1874 | |
| 1875 | return state; |
| 1876 | } |
| 1877 | |
pwestin@webrtc.org | c66e8b3 | 2012-11-07 17:01:04 +0000 | [diff] [blame] | 1878 | } // namespace webrtc |