blob: 363526196dc6349123581b92fce61033f0ed9617 [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:251/*
pwestin@webrtc.orgf6bb77a2012-01-24 17:16:592 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
niklase@google.com470e71d2011-07-07 08:21:253 *
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
mflodman@webrtc.org2f225ca2013-01-09 13:54:4311#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
12
pbos@webrtc.orga048d7c2013-05-29 14:27:3813#include <string.h>
phoglund@webrtc.orgacfdd962013-01-16 10:27:3314
mflodman@webrtc.org02270cd2015-02-06 13:10:1915#include <set>
Peter Boström9c017252016-02-26 15:26:2016#include <string>
mflodman@webrtc.org02270cd2015-02-06 13:10:1917
mflodman@webrtc.org47d657b2015-02-19 10:29:3218#include "webrtc/base/checks.h"
Peter Boströmebc0b4e2015-10-28 15:39:3319#include "webrtc/base/logging.h"
mflodman@webrtc.org2f225ca2013-01-09 13:54:4320#include "webrtc/common_types.h"
Peter Boström9c017252016-02-26 15:26:2021#include "webrtc/config.h"
Henrik Kjellander98f53512015-10-28 17:17:4022#include "webrtc/system_wrappers/include/trace.h"
niklase@google.com470e71d2011-07-07 08:21:2523
niklase@google.com470e71d2011-07-07 08:21:2524#ifdef _WIN32
phoglund@webrtc.orgacfdd962013-01-16 10:27:3325// Disable warning C4355: 'this' : used in base member initializer list.
henrike@webrtc.orgd5657c22012-02-08 23:41:4926#pragma warning(disable : 4355)
niklase@google.com470e71d2011-07-07 08:21:2527#endif
28
29namespace webrtc {
niklase@google.com470e71d2011-07-07 08:21:2530
Peter Boström9c017252016-02-26 15:26:2031RTPExtensionType StringToRtpExtensionType(const std::string& extension) {
isheriff6f8d6862016-05-26 18:24:5532 if (extension == RtpExtension::kTimestampOffsetUri)
Peter Boström9c017252016-02-26 15:26:2033 return kRtpExtensionTransmissionTimeOffset;
isheriff6f8d6862016-05-26 18:24:5534 if (extension == RtpExtension::kAudioLevelUri)
Peter Boström9c017252016-02-26 15:26:2035 return kRtpExtensionAudioLevel;
isheriff6f8d6862016-05-26 18:24:5536 if (extension == RtpExtension::kAbsSendTimeUri)
Peter Boström9c017252016-02-26 15:26:2037 return kRtpExtensionAbsoluteSendTime;
isheriff6f8d6862016-05-26 18:24:5538 if (extension == RtpExtension::kVideoRotationUri)
Peter Boström9c017252016-02-26 15:26:2039 return kRtpExtensionVideoRotation;
isheriff6f8d6862016-05-26 18:24:5540 if (extension == RtpExtension::kTransportSequenceNumberUri)
Peter Boström9c017252016-02-26 15:26:2041 return kRtpExtensionTransportSequenceNumber;
isheriff6b4b5f32016-06-08 07:24:2142 if (extension == RtpExtension::kPlayoutDelayUri)
43 return kRtpExtensionPlayoutDelay;
Peter Boström9c017252016-02-26 15:26:2044 RTC_NOTREACHED() << "Looking up unsupported RTP extension.";
45 return kRtpExtensionNone;
46}
47
phoglund@webrtc.orga22a9bd2013-01-14 10:01:5548RtpRtcp::Configuration::Configuration()
Sergey Ulanovec4f0682016-07-28 22:19:1049 : receive_statistics(NullObjectReceiveStatistics()) {}
phoglund@webrtc.orga22a9bd2013-01-14 10:01:5550
pwestin@webrtc.org2853dde2012-05-11 11:08:5451RtpRtcp* RtpRtcp::CreateRtpRtcp(const RtpRtcp::Configuration& configuration) {
52 if (configuration.clock) {
53 return new ModuleRtpRtcpImpl(configuration);
henrike@webrtc.orgf5da4da2012-02-15 23:54:5954 } else {
pbos@webrtc.org180e5162014-07-11 15:36:2655 // No clock implementation provided, use default clock.
pwestin@webrtc.org2853dde2012-05-11 11:08:5456 RtpRtcp::Configuration configuration_copy;
57 memcpy(&configuration_copy, &configuration,
58 sizeof(RtpRtcp::Configuration));
stefan@webrtc.org20ed36d2013-01-17 14:01:2059 configuration_copy.clock = Clock::GetRealTimeClock();
pbos@webrtc.org180e5162014-07-11 15:36:2660 return new ModuleRtpRtcpImpl(configuration_copy);
henrike@webrtc.orgd5657c22012-02-08 23:41:4961 }
niklase@google.com470e71d2011-07-07 08:21:2562}
63
brandtr1743a192016-11-07 11:36:0564// Deprecated.
65int32_t RtpRtcp::SetFecParameters(const FecProtectionParams* delta_params,
66 const FecProtectionParams* key_params) {
67 RTC_DCHECK(delta_params);
68 RTC_DCHECK(key_params);
69 return SetFecParameters(*delta_params, *key_params) ? 0 : -1;
70}
71
pwestin@webrtc.org2853dde2012-05-11 11:08:5472ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
Peter Boströmac547a62015-09-17 21:03:5773 : rtp_sender_(configuration.audio,
phoglund@webrtc.orgacfdd962013-01-16 10:27:3374 configuration.clock,
75 configuration.outgoing_transport,
andresp@webrtc.orgd11bec42014-07-08 14:32:5876 configuration.paced_sender,
brandtre950cad2016-11-15 13:25:4177 configuration.flexfec_sender,
sprangebbf8a82015-09-21 22:11:1478 configuration.transport_sequence_number_allocator,
sprang5e023eb2015-09-14 13:42:4379 configuration.transport_feedback_callback,
andresp@webrtc.org8f151212014-07-10 09:39:2380 configuration.send_bitrate_observer,
stefan@webrtc.org168f23f2014-07-11 13:44:0281 configuration.send_frame_count_observer,
terelius429c3452016-01-21 13:42:0482 configuration.send_side_delay_observer,
asapersson35151f32016-05-03 06:44:0183 configuration.event_log,
sprangcd349d92016-07-13 16:11:2884 configuration.send_packet_observer,
michaelt4da30442016-11-17 09:38:4385 configuration.retransmission_rate_limiter,
86 configuration.overhead_observer),
Peter Boströmac547a62015-09-17 21:03:5787 rtcp_sender_(configuration.audio,
stefan@webrtc.orga15fbfd2014-06-17 17:32:0588 configuration.clock,
pbos@webrtc.org1d0fa5d2015-02-19 12:47:0089 configuration.receive_statistics,
sprang86fd9ed2015-09-29 11:45:4390 configuration.rtcp_packet_type_counter_observer,
terelius429c3452016-01-21 13:42:0491 configuration.event_log,
sprang86fd9ed2015-09-29 11:45:4392 configuration.outgoing_transport),
Peter Boströmac547a62015-09-17 21:03:5793 rtcp_receiver_(configuration.clock,
Peter Boströmfe7a80c2015-04-23 15:53:1794 configuration.receiver_only,
pbos@webrtc.org1d0fa5d2015-02-19 12:47:0095 configuration.rtcp_packet_type_counter_observer,
mflodman@webrtc.org96abda02015-02-25 13:50:1096 configuration.bandwidth_callback,
97 configuration.intra_frame_callback,
Erik Språng6b8d3552015-09-24 13:06:5798 configuration.transport_feedback_callback,
spranga790d832016-12-02 15:29:4499 configuration.bitrate_allocation_observer,
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00100 this),
stefan@webrtc.orga678a3b2013-01-21 07:42:11101 clock_(configuration.clock),
phoglund@webrtc.orgacfdd962013-01-16 10:27:33102 audio_(configuration.audio),
stefan@webrtc.org20ed36d2013-01-17 14:01:20103 last_process_time_(configuration.clock->TimeInMilliseconds()),
104 last_bitrate_process_time_(configuration.clock->TimeInMilliseconds()),
stefan@webrtc.orgb5865072013-02-01 14:33:42105 last_rtt_process_time_(configuration.clock->TimeInMilliseconds()),
asapersson35151f32016-05-03 06:44:01106 packet_overhead_(28), // IPV4 UDP.
stefan@webrtc.orga2710702013-03-05 09:02:06107 nack_last_time_sent_full_(0),
asapersson@webrtc.orgba8138b2014-12-08 13:29:02108 nack_last_time_sent_full_prev_(0),
phoglund@webrtc.orgacfdd962013-01-16 10:27:33109 nack_last_seq_number_sent_(0),
Peter Boströme23e7372015-10-08 09:44:14110 key_frame_req_method_(kKeyFrameReqPliRtcp),
mflodman@webrtc.org7c894b72012-11-26 12:40:15111 remote_bitrate_(configuration.remote_bitrate_estimator),
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11112 rtt_stats_(configuration.rtt_stats),
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11113 rtt_ms_(0) {
danilchap71fead22016-08-18 09:01:49114 // Make sure rtcp sender use same timestamp offset as rtp sender.
115 rtcp_sender_.SetTimestampOffset(rtp_sender_.TimestampOffset());
116
117 // Set default packet size limit.
nisse284542b2017-01-10 16:58:32118 // TODO(nisse): Kind-of duplicates
119 // webrtc::VideoSendStream::Config::Rtp::kDefaultMaxPacketSize.
120 const size_t kTcpOverIpv4HeaderSize = 40;
121 SetMaxRtpPacketSize(IP_PACKET_SIZE - kTcpOverIpv4HeaderSize);
niklase@google.com470e71d2011-07-07 08:21:25122}
123
phoglund@webrtc.orgacfdd962013-01-16 10:27:33124// Returns the number of milliseconds until the module want a worker thread
125// to call Process.
pkasting@chromium.org0b1534c2014-12-15 22:09:40126int64_t ModuleRtpRtcpImpl::TimeUntilNextProcess() {
127 const int64_t now = clock_->TimeInMilliseconds();
128 const int64_t kRtpRtcpMaxIdleTimeProcessMs = 5;
129 return kRtpRtcpMaxIdleTimeProcessMs - (now - last_process_time_);
niklase@google.com470e71d2011-07-07 08:21:25130}
131
phoglund@webrtc.orgacfdd962013-01-16 10:27:33132// Process any pending tasks such as timeouts (non time critical events).
pbosa26ac922016-02-25 12:50:01133void ModuleRtpRtcpImpl::Process() {
wu@webrtc.org822fbd82013-08-15 23:38:54134 const int64_t now = clock_->TimeInMilliseconds();
phoglund@webrtc.orgacfdd962013-01-16 10:27:33135 last_process_time_ = now;
niklase@google.com470e71d2011-07-07 08:21:25136
pkasting@chromium.org0b1534c2014-12-15 22:09:40137 const int64_t kRtpRtcpBitrateProcessTimeMs = 10;
phoglund@webrtc.orgacfdd962013-01-16 10:27:33138 if (now >= last_bitrate_process_time_ + kRtpRtcpBitrateProcessTimeMs) {
139 rtp_sender_.ProcessBitrate();
phoglund@webrtc.orgacfdd962013-01-16 10:27:33140 last_bitrate_process_time_ = now;
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31141 }
niklase@google.com470e71d2011-07-07 08:21:25142
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47143 const int64_t kRtpRtcpRttProcessTimeMs = 1000;
144 bool process_rtt = now >= last_rtt_process_time_ + kRtpRtcpRttProcessTimeMs;
145 if (rtcp_sender_.Sending()) {
146 // Process RTT if we have received a receiver report and we haven't
147 // processed RTT for at least |kRtpRtcpRttProcessTimeMs| milliseconds.
148 if (rtcp_receiver_.LastReceivedReceiverReport() >
149 last_rtt_process_time_ && process_rtt) {
150 std::vector<RTCPReportBlock> receive_blocks;
151 rtcp_receiver_.StatisticsReceived(&receive_blocks);
152 int64_t max_rtt = 0;
153 for (std::vector<RTCPReportBlock>::iterator it = receive_blocks.begin();
154 it != receive_blocks.end(); ++it) {
155 int64_t rtt = 0;
156 rtcp_receiver_.RTT(it->remoteSSRC, &rtt, NULL, NULL, NULL);
157 max_rtt = (rtt > max_rtt) ? rtt : max_rtt;
mflodman@webrtc.orgd7d46882012-02-14 12:49:59158 }
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47159 // Report the rtt.
160 if (rtt_stats_ && max_rtt != 0)
161 rtt_stats_->OnRttUpdate(max_rtt);
henrike@webrtc.orgd5657c22012-02-08 23:41:49162 }
asapersson@webrtc.org7d6bd222013-10-31 12:14:34163
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47164 // Verify receiver reports are delivered and the reported sequence number
165 // is increasing.
166 int64_t rtcp_interval = RtcpReportInterval();
167 if (rtcp_receiver_.RtcpRrTimeout(rtcp_interval)) {
168 LOG_F(LS_WARNING) << "Timeout: No RTCP RR received.";
169 } else if (rtcp_receiver_.RtcpRrSequenceNumberTimeout(rtcp_interval)) {
170 LOG_F(LS_WARNING) <<
171 "Timeout: No increase in RTCP RR extended highest sequence number.";
172 }
173
174 if (remote_bitrate_ && rtcp_sender_.TMMBR()) {
175 unsigned int target_bitrate = 0;
176 std::vector<unsigned int> ssrcs;
177 if (remote_bitrate_->LatestEstimate(&ssrcs, &target_bitrate)) {
178 if (!ssrcs.empty()) {
179 target_bitrate = target_bitrate / ssrcs.size();
180 }
181 rtcp_sender_.SetTargetBitrate(target_bitrate);
182 }
183 }
184 } else {
185 // Report rtt from receiver.
asapersson@webrtc.org7d6bd222013-10-31 12:14:34186 if (process_rtt) {
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47187 int64_t rtt_ms;
188 if (rtt_stats_ && rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)) {
189 rtt_stats_->OnRttUpdate(rtt_ms);
190 }
wu@webrtc.org822fbd82013-08-15 23:38:54191 }
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31192 }
193
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47194 // Get processed rtt.
195 if (process_rtt) {
196 last_rtt_process_time_ = now;
sprange2d83d62016-02-19 17:03:26197 if (rtt_stats_) {
198 // Make sure we have a valid RTT before setting.
199 int64_t last_rtt = rtt_stats_->LastProcessedRtt();
200 if (last_rtt >= 0)
201 set_rtt_ms(last_rtt);
202 }
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47203 }
204
Danil Chapovalov70ffead2016-07-20 13:26:59205 if (rtcp_sender_.TimeToSendRTCPReport())
206 rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47207
danilchap9bf610e2017-02-20 14:03:01208 if (TMMBR() && rtcp_receiver_.UpdateTmmbrTimers()) {
209 rtcp_receiver_.NotifyTmmbrUpdated();
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31210 }
niklase@google.com470e71d2011-07-07 08:21:25211}
212
pbos@webrtc.org0b0c2412015-01-13 14:15:15213void ModuleRtpRtcpImpl::SetRtxSendStatus(int mode) {
214 rtp_sender_.SetRtxStatus(mode);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18215}
216
pbos@webrtc.org0b0c2412015-01-13 14:15:15217int ModuleRtpRtcpImpl::RtxSendStatus() const {
218 return rtp_sender_.RtxStatus();
stefan@webrtc.orgef927552014-06-05 08:25:29219}
220
221void ModuleRtpRtcpImpl::SetRtxSsrc(uint32_t ssrc) {
222 rtp_sender_.SetRtxSsrc(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18223}
224
Shao Changbine62202f2015-04-21 12:24:50225void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type,
226 int associated_payload_type) {
227 rtp_sender_.SetRtxPayloadType(payload_type, associated_payload_type);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46228}
229
brandtr9dfff292016-11-14 13:14:50230rtc::Optional<uint32_t> ModuleRtpRtcpImpl::FlexfecSsrc() const {
231 return rtp_sender_.FlexfecSsrc();
232}
233
stefan@webrtc.orga5cb98c2013-05-29 12:12:51234int32_t ModuleRtpRtcpImpl::IncomingRtcpPacket(
235 const uint8_t* rtcp_packet,
pkasting@chromium.org4591fbd2014-11-20 22:28:14236 const size_t length) {
danilchap59cb2bd2016-08-29 18:08:47237 return rtcp_receiver_.IncomingPacket(rtcp_packet, length) ? 0 : -1;
niklase@google.com470e71d2011-07-07 08:21:25238}
239
pbos@webrtc.org2f446732013-04-08 11:08:41240int32_t ModuleRtpRtcpImpl::RegisterSendPayload(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33241 const CodecInst& voice_codec) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33242 return rtp_sender_.RegisterPayload(
Sergey Ulanovec4f0682016-07-28 22:19:10243 voice_codec.plname, voice_codec.pltype, voice_codec.plfreq,
244 voice_codec.channels, (voice_codec.rate < 0) ? 0 : voice_codec.rate);
pwestin@webrtc.org1da1ce02011-10-13 15:19:55245}
246
asapersson@webrtc.org9ffd8fe2015-01-21 08:22:50247int32_t ModuleRtpRtcpImpl::RegisterSendPayload(const VideoCodec& video_codec) {
Peter Boström9d0c4322016-02-16 16:59:27248 return rtp_sender_.RegisterPayload(video_codec.plName, video_codec.plType,
249 90000, 0, 0);
niklase@google.com470e71d2011-07-07 08:21:25250}
251
Peter Boström8b79b072016-02-26 15:31:37252void ModuleRtpRtcpImpl::RegisterVideoSendPayload(int payload_type,
253 const char* payload_name) {
254 RTC_CHECK_EQ(
255 0, rtp_sender_.RegisterPayload(payload_name, payload_type, 90000, 0, 0));
256}
257
asapersson@webrtc.org9ffd8fe2015-01-21 08:22:50258int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(const int8_t payload_type) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33259 return rtp_sender_.DeRegisterSendPayload(payload_type);
niklase@google.com470e71d2011-07-07 08:21:25260}
261
pbos@webrtc.org2f446732013-04-08 11:08:41262uint32_t ModuleRtpRtcpImpl::StartTimestamp() const {
danilchap71fead22016-08-18 09:01:49263 return rtp_sender_.TimestampOffset();
niklase@google.com470e71d2011-07-07 08:21:25264}
265
phoglund@webrtc.orgacfdd962013-01-16 10:27:33266// Configure start timestamp, default is a random number.
pbos@webrtc.orgd16e8392014-12-19 13:49:55267void ModuleRtpRtcpImpl::SetStartTimestamp(const uint32_t timestamp) {
danilchap71fead22016-08-18 09:01:49268 rtcp_sender_.SetTimestampOffset(timestamp);
269 rtp_sender_.SetTimestampOffset(timestamp);
niklase@google.com470e71d2011-07-07 08:21:25270}
271
pbos@webrtc.org2f446732013-04-08 11:08:41272uint16_t ModuleRtpRtcpImpl::SequenceNumber() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33273 return rtp_sender_.SequenceNumber();
niklase@google.com470e71d2011-07-07 08:21:25274}
275
phoglund@webrtc.orgacfdd962013-01-16 10:27:33276// Set SequenceNumber, default is a random number.
pbos@webrtc.orgd16e8392014-12-19 13:49:55277void ModuleRtpRtcpImpl::SetSequenceNumber(const uint16_t seq_num) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33278 rtp_sender_.SetSequenceNumber(seq_num);
niklase@google.com470e71d2011-07-07 08:21:25279}
280
Per83d09102016-04-15 12:59:13281void ModuleRtpRtcpImpl::SetRtpState(const RtpState& rtp_state) {
Per83d09102016-04-15 12:59:13282 rtp_sender_.SetRtpState(rtp_state);
danilchap71fead22016-08-18 09:01:49283 rtcp_sender_.SetTimestampOffset(rtp_state.start_timestamp);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48284}
285
Per83d09102016-04-15 12:59:13286void ModuleRtpRtcpImpl::SetRtxState(const RtpState& rtp_state) {
287 rtp_sender_.SetRtxRtpState(rtp_state);
288}
289
290RtpState ModuleRtpRtcpImpl::GetRtpState() const {
291 return rtp_sender_.GetRtpState();
292}
293
294RtpState ModuleRtpRtcpImpl::GetRtxState() const {
295 return rtp_sender_.GetRtxRtpState();
pbos@webrtc.org2bb1bda2014-07-07 13:06:48296}
297
pbos@webrtc.org2f446732013-04-08 11:08:41298uint32_t ModuleRtpRtcpImpl::SSRC() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33299 return rtp_sender_.SSRC();
niklase@google.com470e71d2011-07-07 08:21:25300}
301
stefan@webrtc.orgef927552014-06-05 08:25:29302void ModuleRtpRtcpImpl::SetSSRC(const uint32_t ssrc) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33303 rtp_sender_.SetSSRC(ssrc);
phoglund@webrtc.orgacfdd962013-01-16 10:27:33304 rtcp_sender_.SetSSRC(ssrc);
stefan@webrtc.org28a331e2013-09-17 07:49:56305 SetRtcpReceiverSsrcs(ssrc);
niklase@google.com470e71d2011-07-07 08:21:25306}
307
pbos@webrtc.org9334ac22014-11-24 08:25:50308void ModuleRtpRtcpImpl::SetCsrcs(const std::vector<uint32_t>& csrcs) {
pbos@webrtc.org9334ac22014-11-24 08:25:50309 rtcp_sender_.SetCsrcs(csrcs);
310 rtp_sender_.SetCsrcs(csrcs);
henrike@webrtc.orgd5657c22012-02-08 23:41:49311}
312
pbos@webrtc.org2f4b14e2014-07-15 15:25:39313// TODO(pbos): Handle media and RTX streams separately (separate RTCP
314// feedbacks).
315RTCPSender::FeedbackState ModuleRtpRtcpImpl::GetFeedbackState() {
316 StreamDataCounters rtp_stats;
317 StreamDataCounters rtx_stats;
318 rtp_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
henrike@webrtc.orgd5657c22012-02-08 23:41:49319
pbos@webrtc.org2f4b14e2014-07-15 15:25:39320 RTCPSender::FeedbackState state;
nisse7be1dcb2017-03-13 12:09:27321 state.send_payload_type = rtp_sender_.SendPayloadType();
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59322 state.packets_sent = rtp_stats.transmitted.packets +
323 rtx_stats.transmitted.packets;
324 state.media_bytes_sent = rtp_stats.transmitted.payload_bytes +
325 rtx_stats.transmitted.payload_bytes;
pbos@webrtc.org2f4b14e2014-07-15 15:25:39326 state.module = this;
327
328 LastReceivedNTP(&state.last_rr_ntp_secs,
329 &state.last_rr_ntp_frac,
330 &state.remote_sr);
331
danilchap798896a2016-09-28 09:54:25332 state.has_last_xr_rr =
333 rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&state.last_xr_rr);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39334
335 uint32_t tmp;
336 BitrateSent(&state.send_bitrate, &tmp, &tmp, &tmp);
337 return state;
henrike@webrtc.orgd5657c22012-02-08 23:41:49338}
339
pbos@webrtc.org2f446732013-04-08 11:08:41340int32_t ModuleRtpRtcpImpl::SetSendingStatus(const bool sending) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33341 if (rtcp_sender_.Sending() != sending) {
342 // Sends RTCP BYE when going from true to false
pbos@webrtc.org2f4b14e2014-07-15 15:25:39343 if (rtcp_sender_.SetSendingStatus(GetFeedbackState(), sending) != 0) {
andresp@webrtc.orgdc80bae2014-04-08 11:06:12344 LOG(LS_WARNING) << "Failed to send RTCP BYE";
henrike@webrtc.orgd5657c22012-02-08 23:41:49345 }
nisse7d59f6b2017-02-21 11:40:24346 if (sending) {
347 // Update Rtcp receiver config, to track Rtx config changes from
348 // the SetRtxStatus and SetRtxSsrc methods.
349 SetRtcpReceiverSsrcs(rtp_sender_.SSRC());
350 }
henrike@webrtc.orgd5657c22012-02-08 23:41:49351 }
352 return 0;
353}
354
355bool ModuleRtpRtcpImpl::Sending() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33356 return rtcp_sender_.Sending();
henrike@webrtc.orgd5657c22012-02-08 23:41:49357}
358
pbos@webrtc.orgd16e8392014-12-19 13:49:55359void ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33360 rtp_sender_.SetSendingMediaStatus(sending);
henrike@webrtc.orgd5657c22012-02-08 23:41:49361}
362
363bool ModuleRtpRtcpImpl::SendingMedia() const {
mflodman@webrtc.org47d657b2015-02-19 10:29:32364 return rtp_sender_.SendingMedia();
niklase@google.com470e71d2011-07-07 08:21:25365}
366
Sergey Ulanov525df3f2016-08-03 00:46:41367bool ModuleRtpRtcpImpl::SendOutgoingData(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33368 FrameType frame_type,
pbos@webrtc.org2f446732013-04-08 11:08:41369 int8_t payload_type,
370 uint32_t time_stamp,
stefan@webrtc.orgddfdfed2012-07-03 13:21:22371 int64_t capture_time_ms,
pbos@webrtc.org2f446732013-04-08 11:08:41372 const uint8_t* payload_data,
pkasting@chromium.org4591fbd2014-11-20 22:28:14373 size_t payload_size,
henrike@webrtc.orgd5657c22012-02-08 23:41:49374 const RTPFragmentationHeader* fragmentation,
Sergey Ulanov525df3f2016-08-03 00:46:41375 const RTPVideoHeader* rtp_video_header,
376 uint32_t* transport_frame_id_out) {
mflodman@webrtc.org02270cd2015-02-06 13:10:19377 rtcp_sender_.SetLastRtpTime(time_stamp, capture_time_ms);
mflodman0b3d7ee2015-12-10 09:10:44378 // Make sure an RTCP report isn't queued behind a key frame.
mflodman@webrtc.org02270cd2015-02-06 13:10:19379 if (rtcp_sender_.TimeToSendRTCPReport(kVideoFrameKey == frame_type)) {
pbos@webrtc.org2f4b14e2014-07-15 15:25:39380 rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
henrike@webrtc.orgd5657c22012-02-08 23:41:49381 }
guoweis@webrtc.org45362892015-03-04 22:55:15382 return rtp_sender_.SendOutgoingData(
383 frame_type, payload_type, time_stamp, capture_time_ms, payload_data,
Sergey Ulanov525df3f2016-08-03 00:46:41384 payload_size, fragmentation, rtp_video_header, transport_frame_id_out);
niklase@google.com470e71d2011-07-07 08:21:25385}
386
hclam@chromium.org2e402ce2013-06-20 20:18:31387bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc,
pwestin@webrtc.org571a1c02012-11-13 21:12:39388 uint16_t sequence_number,
stefan@webrtc.org9b82f5a2013-11-13 15:29:21389 int64_t capture_time_ms,
philipela1ed0b32016-06-01 13:31:17390 bool retransmission,
philipelc7bf32a2017-02-17 11:59:43391 const PacedPacketInfo& pacing_info) {
brandtr9dfff292016-11-14 13:14:50392 return rtp_sender_.TimeToSendPacket(ssrc, sequence_number, capture_time_ms,
philipel8aadd502017-02-23 10:56:13393 retransmission, pacing_info);
stefan@webrtc.org508a84b2013-06-17 12:53:37394}
395
philipelc7bf32a2017-02-17 11:59:43396size_t ModuleRtpRtcpImpl::TimeToSendPadding(
397 size_t bytes,
398 const PacedPacketInfo& pacing_info) {
philipel8aadd502017-02-23 10:56:13399 return rtp_sender_.TimeToSendPadding(bytes, pacing_info);
pwestin@webrtc.org571a1c02012-11-13 21:12:39400}
401
nisse284542b2017-01-10 16:58:32402size_t ModuleRtpRtcpImpl::MaxPayloadSize() const {
403 return rtp_sender_.MaxPayloadSize();
niklase@google.com470e71d2011-07-07 08:21:25404}
405
nisse284542b2017-01-10 16:58:32406size_t ModuleRtpRtcpImpl::MaxRtpPacketSize() const {
407 return rtp_sender_.MaxRtpPacketSize();
niklase@google.com470e71d2011-07-07 08:21:25408}
409
nisse284542b2017-01-10 16:58:32410void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
411 RTC_DCHECK_LE(rtp_packet_size, IP_PACKET_SIZE)
412 << "rtp packet size too large: " << rtp_packet_size;
413 RTC_DCHECK_GT(rtp_packet_size, packet_overhead_)
414 << "rtp packet size too small: " << rtp_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25415
nisse284542b2017-01-10 16:58:32416 rtcp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
417 rtp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
henrike@webrtc.orgd5657c22012-02-08 23:41:49418}
419
pbosda903ea2015-10-02 09:36:56420RtcpMode ModuleRtpRtcpImpl::RTCP() const {
Taylor Brandstetter5f0b83b2016-03-18 22:02:07421 return rtcp_sender_.Status();
henrike@webrtc.orgd5657c22012-02-08 23:41:49422}
423
phoglund@webrtc.orgacfdd962013-01-16 10:27:33424// Configure RTCP status i.e on/off.
pbosda903ea2015-10-02 09:36:56425void ModuleRtpRtcpImpl::SetRTCPStatus(const RtcpMode method) {
pbos@webrtc.orgd16e8392014-12-19 13:49:55426 rtcp_sender_.SetRTCPStatus(method);
niklase@google.com470e71d2011-07-07 08:21:25427}
pwestin@webrtc.org1da1ce02011-10-13 15:19:55428
Peter Boström9ba52f82015-06-01 12:12:28429int32_t ModuleRtpRtcpImpl::SetCNAME(const char* c_name) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33430 return rtcp_sender_.SetCNAME(c_name);
niklase@google.com470e71d2011-07-07 08:21:25431}
432
Erik Språng0ea42d32015-06-25 12:46:16433int32_t ModuleRtpRtcpImpl::AddMixedCNAME(uint32_t ssrc, const char* c_name) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33434 return rtcp_sender_.AddMixedCNAME(ssrc, c_name);
niklase@google.com470e71d2011-07-07 08:21:25435}
436
pbos@webrtc.org2f446732013-04-08 11:08:41437int32_t ModuleRtpRtcpImpl::RemoveMixedCNAME(const uint32_t ssrc) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33438 return rtcp_sender_.RemoveMixedCNAME(ssrc);
niklase@google.com470e71d2011-07-07 08:21:25439}
440
pbos@webrtc.org2f446732013-04-08 11:08:41441int32_t ModuleRtpRtcpImpl::RemoteCNAME(
442 const uint32_t remote_ssrc,
phoglund@webrtc.orgacfdd962013-01-16 10:27:33443 char c_name[RTCP_CNAME_SIZE]) const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33444 return rtcp_receiver_.CNAME(remote_ssrc, c_name);
niklase@google.com470e71d2011-07-07 08:21:25445}
446
pbos@webrtc.org2f446732013-04-08 11:08:41447int32_t ModuleRtpRtcpImpl::RemoteNTP(
448 uint32_t* received_ntpsecs,
449 uint32_t* received_ntpfrac,
450 uint32_t* rtcp_arrival_time_secs,
451 uint32_t* rtcp_arrival_time_frac,
452 uint32_t* rtcp_timestamp) const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33453 return rtcp_receiver_.NTP(received_ntpsecs,
454 received_ntpfrac,
455 rtcp_arrival_time_secs,
456 rtcp_arrival_time_frac,
pbos@webrtc.org376b4ea2014-07-15 15:51:33457 rtcp_timestamp)
458 ? 0
459 : -1;
niklase@google.com470e71d2011-07-07 08:21:25460}
461
phoglund@webrtc.orgacfdd962013-01-16 10:27:33462// Get RoundTripTime.
pbos@webrtc.org2f446732013-04-08 11:08:41463int32_t ModuleRtpRtcpImpl::RTT(const uint32_t remote_ssrc,
pkasting@chromium.org16825b12015-01-12 21:51:21464 int64_t* rtt,
465 int64_t* avg_rtt,
466 int64_t* min_rtt,
467 int64_t* max_rtt) const {
wu@webrtc.orgcd701192014-04-24 22:10:24468 int32_t ret = rtcp_receiver_.RTT(remote_ssrc, rtt, avg_rtt, min_rtt, max_rtt);
469 if (rtt && *rtt == 0) {
470 // Try to get RTT from RtcpRttStats class.
pkasting@chromium.org16825b12015-01-12 21:51:21471 *rtt = rtt_ms();
wu@webrtc.orgcd701192014-04-24 22:10:24472 }
473 return ret;
niklase@google.com470e71d2011-07-07 08:21:25474}
475
phoglund@webrtc.orgacfdd962013-01-16 10:27:33476// Force a send of an RTCP packet.
477// Normal SR and RR are triggered via the process function.
Erik Språng242e22b2015-05-11 08:17:43478int32_t ModuleRtpRtcpImpl::SendRTCP(RTCPPacketType packet_type) {
479 return rtcp_sender_.SendRTCP(GetFeedbackState(), packet_type);
480}
481
482// Force a send of an RTCP packet.
483// Normal SR and RR are triggered via the process function.
484int32_t ModuleRtpRtcpImpl::SendCompoundRTCP(
485 const std::set<RTCPPacketType>& packet_types) {
486 return rtcp_sender_.SendCompoundRTCP(GetFeedbackState(), packet_types);
niklase@google.com470e71d2011-07-07 08:21:25487}
488
pbos@webrtc.org2f446732013-04-08 11:08:41489int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
490 const uint8_t sub_type,
491 const uint32_t name,
492 const uint8_t* data,
493 const uint16_t length) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33494 return rtcp_sender_.SetApplicationSpecificData(sub_type, name, data, length);
niklase@google.com470e71d2011-07-07 08:21:25495}
496
phoglund@webrtc.orgacfdd962013-01-16 10:27:33497// (XR) VOIP metric.
pbos@webrtc.org2f446732013-04-08 11:08:41498int32_t ModuleRtpRtcpImpl::SetRTCPVoIPMetrics(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33499 const RTCPVoIPMetric* voip_metric) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33500 return rtcp_sender_.SetRTCPVoIPMetrics(voip_metric);
niklase@google.com470e71d2011-07-07 08:21:25501}
502
asapersson@webrtc.org7d6bd222013-10-31 12:14:34503void ModuleRtpRtcpImpl::SetRtcpXrRrtrStatus(bool enable) {
Danil Chapovalovc1e55c72016-03-09 14:14:35504 rtcp_receiver_.SetRtcpXrRrtrStatus(enable);
505 rtcp_sender_.SendRtcpXrReceiverReferenceTime(enable);
asapersson@webrtc.org7d6bd222013-10-31 12:14:34506}
507
asapersson@webrtc.org8d02f5d2013-11-21 08:57:04508bool ModuleRtpRtcpImpl::RtcpXrRrtrStatus() const {
509 return rtcp_sender_.RtcpXrReceiverReferenceTime();
510}
511
asapersson@webrtc.org97d04892014-12-09 09:47:53512// TODO(asapersson): Replace this method with the one below.
pbos@webrtc.org2f446732013-04-08 11:08:41513int32_t ModuleRtpRtcpImpl::DataCountersRTP(
pkasting@chromium.org4591fbd2014-11-20 22:28:14514 size_t* bytes_sent,
wu@webrtc.org822fbd82013-08-15 23:38:54515 uint32_t* packets_sent) const {
pbos@webrtc.org2f4b14e2014-07-15 15:25:39516 StreamDataCounters rtp_stats;
517 StreamDataCounters rtx_stats;
518 rtp_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
519
phoglund@webrtc.orgacfdd962013-01-16 10:27:33520 if (bytes_sent) {
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59521 *bytes_sent = rtp_stats.transmitted.payload_bytes +
522 rtp_stats.transmitted.padding_bytes +
523 rtp_stats.transmitted.header_bytes +
524 rtx_stats.transmitted.payload_bytes +
525 rtx_stats.transmitted.padding_bytes +
526 rtx_stats.transmitted.header_bytes;
henrike@webrtc.orgd5657c22012-02-08 23:41:49527 }
phoglund@webrtc.orgacfdd962013-01-16 10:27:33528 if (packets_sent) {
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59529 *packets_sent = rtp_stats.transmitted.packets +
530 rtx_stats.transmitted.packets;
henrike@webrtc.orgd5657c22012-02-08 23:41:49531 }
wu@webrtc.org822fbd82013-08-15 23:38:54532 return 0;
niklase@google.com470e71d2011-07-07 08:21:25533}
534
asapersson@webrtc.org97d04892014-12-09 09:47:53535void ModuleRtpRtcpImpl::GetSendStreamDataCounters(
536 StreamDataCounters* rtp_counters,
537 StreamDataCounters* rtx_counters) const {
538 rtp_sender_.GetDataCounters(rtp_counters, rtx_counters);
539}
540
bcornell30409b42015-07-11 01:10:05541void ModuleRtpRtcpImpl::GetRtpPacketLossStats(
542 bool outgoing,
543 uint32_t ssrc,
544 struct RtpPacketLossStats* loss_stats) const {
545 if (!loss_stats) return;
546 const PacketLossStats* stats_source = NULL;
547 if (outgoing) {
548 if (SSRC() == ssrc) {
549 stats_source = &send_loss_stats_;
550 }
551 } else {
552 if (rtcp_receiver_.RemoteSSRC() == ssrc) {
553 stats_source = &receive_loss_stats_;
554 }
555 }
556 if (stats_source) {
557 loss_stats->single_packet_loss_count =
558 stats_source->GetSingleLossCount();
559 loss_stats->multiple_packet_loss_event_count =
560 stats_source->GetMultipleLossEventCount();
561 loss_stats->multiple_packet_loss_packet_count =
562 stats_source->GetMultipleLossPacketCount();
563 }
564}
565
pbos@webrtc.org2f446732013-04-08 11:08:41566int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(RTCPSenderInfo* sender_info) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33567 return rtcp_receiver_.SenderInfoReceived(sender_info);
niklase@google.com470e71d2011-07-07 08:21:25568}
569
phoglund@webrtc.orgacfdd962013-01-16 10:27:33570// Received RTCP report.
pbos@webrtc.org2f446732013-04-08 11:08:41571int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33572 std::vector<RTCPReportBlock>* receive_blocks) const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33573 return rtcp_receiver_.StatisticsReceived(receive_blocks);
niklase@google.com470e71d2011-07-07 08:21:25574}
575
phoglund@webrtc.orgacfdd962013-01-16 10:27:33576// (REMB) Receiver Estimated Max Bitrate.
henrike@webrtc.orgd5657c22012-02-08 23:41:49577bool ModuleRtpRtcpImpl::REMB() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33578 return rtcp_sender_.REMB();
pwestin@webrtc.org741da942011-09-20 13:52:04579}
580
pbos@webrtc.orgd16e8392014-12-19 13:49:55581void ModuleRtpRtcpImpl::SetREMBStatus(const bool enable) {
582 rtcp_sender_.SetREMBStatus(enable);
pwestin@webrtc.org741da942011-09-20 13:52:04583}
584
pbos@webrtc.orgd16e8392014-12-19 13:49:55585void ModuleRtpRtcpImpl::SetREMBData(const uint32_t bitrate,
586 const std::vector<uint32_t>& ssrcs) {
587 rtcp_sender_.SetREMBData(bitrate, ssrcs);
pwestin@webrtc.org741da942011-09-20 13:52:04588}
589
pbos@webrtc.org2f446732013-04-08 11:08:41590int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33591 const RTPExtensionType type,
pbos@webrtc.org2f446732013-04-08 11:08:41592 const uint8_t id) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33593 return rtp_sender_.RegisterRtpHeaderExtension(type, id);
asapersson@webrtc.org5249cc82011-12-16 14:31:37594}
595
pbos@webrtc.org2f446732013-04-08 11:08:41596int32_t ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33597 const RTPExtensionType type) {
598 return rtp_sender_.DeregisterRtpHeaderExtension(type);
asapersson@webrtc.org5249cc82011-12-16 14:31:37599}
600
stefan53b6cc32017-02-03 16:13:57601bool ModuleRtpRtcpImpl::HasBweExtensions() const {
602 return rtp_sender_.IsRtpHeaderExtensionRegistered(
603 kRtpExtensionTransportSequenceNumber) ||
604 rtp_sender_.IsRtpHeaderExtensionRegistered(
605 kRtpExtensionAbsoluteSendTime) ||
606 rtp_sender_.IsRtpHeaderExtensionRegistered(
607 kRtpExtensionTransmissionTimeOffset);
608}
609
phoglund@webrtc.orgacfdd962013-01-16 10:27:33610// (TMMBR) Temporary Max Media Bit Rate.
henrike@webrtc.orgd5657c22012-02-08 23:41:49611bool ModuleRtpRtcpImpl::TMMBR() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33612 return rtcp_sender_.TMMBR();
niklase@google.com470e71d2011-07-07 08:21:25613}
614
pbos@webrtc.orgd16e8392014-12-19 13:49:55615void ModuleRtpRtcpImpl::SetTMMBRStatus(const bool enable) {
616 rtcp_sender_.SetTMMBRStatus(enable);
niklase@google.com470e71d2011-07-07 08:21:25617}
618
danilchap853ecb22016-08-22 15:26:15619void ModuleRtpRtcpImpl::SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) {
620 rtcp_sender_.SetTmmbn(std::move(bounding_set));
niklase@google.com470e71d2011-07-07 08:21:25621}
622
stefan@webrtc.org6a4bef42011-12-22 12:52:41623// Returns the currently configured retransmission mode.
624int ModuleRtpRtcpImpl::SelectiveRetransmissions() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33625 return rtp_sender_.SelectiveRetransmissions();
stefan@webrtc.org6a4bef42011-12-22 12:52:41626}
627
628// Enable or disable a retransmission mode, which decides which packets will
629// be retransmitted if NACKed.
630int ModuleRtpRtcpImpl::SetSelectiveRetransmissions(uint8_t settings) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33631 return rtp_sender_.SetSelectiveRetransmissions(settings);
stefan@webrtc.org6a4bef42011-12-22 12:52:41632}
633
phoglund@webrtc.orgacfdd962013-01-16 10:27:33634// Send a Negative acknowledgment packet.
pbos@webrtc.org2f446732013-04-08 11:08:41635int32_t ModuleRtpRtcpImpl::SendNACK(const uint16_t* nack_list,
636 const uint16_t size) {
bcornell30409b42015-07-11 01:10:05637 for (int i = 0; i < size; ++i) {
638 receive_loss_stats_.AddLostPacket(nack_list[i]);
639 }
asapersson@webrtc.orgba8138b2014-12-08 13:29:02640 uint16_t nack_length = size;
641 uint16_t start_id = 0;
642 int64_t now = clock_->TimeInMilliseconds();
643 if (TimeToSendFullNackList(now)) {
644 nack_last_time_sent_full_ = now;
645 nack_last_time_sent_full_prev_ = now;
646 } else {
647 // Only send extended list.
648 if (nack_last_seq_number_sent_ == nack_list[size - 1]) {
649 // Last sequence number is the same, do not send list.
650 return 0;
651 }
652 // Send new sequence numbers.
653 for (int i = 0; i < size; ++i) {
654 if (nack_last_seq_number_sent_ == nack_list[i]) {
655 start_id = i + 1;
656 break;
657 }
658 }
659 nack_length = size - start_id;
660 }
661
662 // Our RTCP NACK implementation is limited to kRtcpMaxNackFields sequence
663 // numbers per RTCP packet.
664 if (nack_length > kRtcpMaxNackFields) {
665 nack_length = kRtcpMaxNackFields;
666 }
667 nack_last_seq_number_sent_ = nack_list[start_id + nack_length - 1];
668
philipel83f831a2016-03-12 11:30:23669 return rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpNack, nack_length,
670 &nack_list[start_id]);
671}
672
673void ModuleRtpRtcpImpl::SendNack(
674 const std::vector<uint16_t>& sequence_numbers) {
675 rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpNack, sequence_numbers.size(),
676 sequence_numbers.data());
asapersson@webrtc.orgba8138b2014-12-08 13:29:02677}
678
679bool ModuleRtpRtcpImpl::TimeToSendFullNackList(int64_t now) const {
asapersson@webrtc.orge7b1e112013-12-16 14:40:36680 // Use RTT from RtcpRttStats class if provided.
pkasting@chromium.org16825b12015-01-12 21:51:21681 int64_t rtt = rtt_ms();
asapersson@webrtc.orge7b1e112013-12-16 14:40:36682 if (rtt == 0) {
683 rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
684 }
stefan@webrtc.org8ca8a712013-04-23 16:48:32685
asapersson@webrtc.orgba8138b2014-12-08 13:29:02686 const int64_t kStartUpRttMs = 100;
asapersson@webrtc.orge7b1e112013-12-16 14:40:36687 int64_t wait_time = 5 + ((rtt * 3) >> 1); // 5 + RTT * 1.5.
asapersson@webrtc.orgba8138b2014-12-08 13:29:02688 if (rtt == 0) {
689 wait_time = kStartUpRttMs;
stefan@webrtc.org8ca8a712013-04-23 16:48:32690 }
henrike@webrtc.orgd5657c22012-02-08 23:41:49691
asapersson@webrtc.orgba8138b2014-12-08 13:29:02692 // Send a full NACK list once within every |wait_time|.
693 if (rtt_stats_) {
694 return now - nack_last_time_sent_full_ > wait_time;
henrike@webrtc.orgd5657c22012-02-08 23:41:49695 }
asapersson@webrtc.orgba8138b2014-12-08 13:29:02696 return now - nack_last_time_sent_full_prev_ > wait_time;
niklase@google.com470e71d2011-07-07 08:21:25697}
698
asapersson@webrtc.org9ffd8fe2015-01-21 08:22:50699// Store the sent packets, needed to answer to Negative acknowledgment requests.
pbos@webrtc.orgd16e8392014-12-19 13:49:55700void ModuleRtpRtcpImpl::SetStorePacketsStatus(const bool enable,
701 const uint16_t number_to_store) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33702 rtp_sender_.SetStorePacketsStatus(enable, number_to_store);
henrike@webrtc.orgd5657c22012-02-08 23:41:49703}
niklase@google.com470e71d2011-07-07 08:21:25704
wu@webrtc.org822fbd82013-08-15 23:38:54705bool ModuleRtpRtcpImpl::StorePackets() const {
706 return rtp_sender_.StorePackets();
tnakamura@webrtc.orgaa4d96a2013-07-16 19:25:04707}
708
pbos@webrtc.orgce4e9a32014-12-18 13:50:16709void ModuleRtpRtcpImpl::RegisterRtcpStatisticsCallback(
sprang@webrtc.orga6ad6e52013-12-05 09:48:44710 RtcpStatisticsCallback* callback) {
711 rtcp_receiver_.RegisterRtcpStatisticsCallback(callback);
712}
713
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00714RtcpStatisticsCallback* ModuleRtpRtcpImpl::GetRtcpStatisticsCallback() {
sprang@webrtc.orga6ad6e52013-12-05 09:48:44715 return rtcp_receiver_.GetRtcpStatisticsCallback();
716}
717
sprang233bd872015-09-08 20:25:16718bool ModuleRtpRtcpImpl::SendFeedbackPacket(
719 const rtcp::TransportFeedback& packet) {
720 return rtcp_sender_.SendFeedbackPacket(packet);
721}
722
phoglund@webrtc.orgacfdd962013-01-16 10:27:33723// Send a TelephoneEvent tone using RFC 2833 (4733).
pbos@webrtc.org2f446732013-04-08 11:08:41724int32_t ModuleRtpRtcpImpl::SendTelephoneEventOutband(
725 const uint8_t key,
726 const uint16_t time_ms,
727 const uint8_t level) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33728 return rtp_sender_.SendTelephoneEvent(key, time_ms, level);
niklase@google.com470e71d2011-07-07 08:21:25729}
730
pbos@webrtc.org2f446732013-04-08 11:08:41731int32_t ModuleRtpRtcpImpl::SetAudioPacketSize(
732 const uint16_t packet_size_samples) {
ossu00bceb12016-12-02 10:40:02733 return audio_ ? 0 : -1;
niklase@google.com470e71d2011-07-07 08:21:25734}
735
pbos@webrtc.org2f446732013-04-08 11:08:41736int32_t ModuleRtpRtcpImpl::SetAudioLevel(
737 const uint8_t level_d_bov) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33738 return rtp_sender_.SetAudioLevel(level_d_bov);
niklase@google.com470e71d2011-07-07 08:21:25739}
740
pbos@webrtc.org2f446732013-04-08 11:08:41741int32_t ModuleRtpRtcpImpl::SetKeyFrameRequestMethod(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33742 const KeyFrameRequestMethod method) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33743 key_frame_req_method_ = method;
henrike@webrtc.orgd5657c22012-02-08 23:41:49744 return 0;
niklase@google.com470e71d2011-07-07 08:21:25745}
746
pbos@webrtc.org2f446732013-04-08 11:08:41747int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33748 switch (key_frame_req_method_) {
niklase@google.com470e71d2011-07-07 08:21:25749 case kKeyFrameReqPliRtcp:
wu@webrtc.org822fbd82013-08-15 23:38:54750 return SendRTCP(kRtcpPli);
pwestin@webrtc.org5e954812012-02-10 12:13:12751 case kKeyFrameReqFirRtcp:
wu@webrtc.org822fbd82013-08-15 23:38:54752 return SendRTCP(kRtcpFir);
henrike@webrtc.orgd5657c22012-02-08 23:41:49753 }
henrike@webrtc.orgd5657c22012-02-08 23:41:49754 return -1;
niklase@google.com470e71d2011-07-07 08:21:25755}
756
brandtrf1bb4762016-11-07 11:05:06757void ModuleRtpRtcpImpl::SetUlpfecConfig(int red_payload_type,
brandtrd8048952016-11-07 10:08:51758 int ulpfec_payload_type) {
brandtrf1bb4762016-11-07 11:05:06759 rtp_sender_.SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
henrike@webrtc.orgd5657c22012-02-08 23:41:49760}
761
brandtr1743a192016-11-07 11:36:05762bool ModuleRtpRtcpImpl::SetFecParameters(
763 const FecProtectionParams& delta_params,
764 const FecProtectionParams& key_params) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33765 return rtp_sender_.SetFecParameters(delta_params, key_params);
marpan@google.com80c5d7a2011-07-15 21:32:40766}
767
pbos@webrtc.org2f446732013-04-08 11:08:41768void ModuleRtpRtcpImpl::SetRemoteSSRC(const uint32_t ssrc) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33769 // Inform about the incoming SSRC.
770 rtcp_sender_.SetRemoteSSRC(ssrc);
771 rtcp_receiver_.SetRemoteSSRC(ssrc);
niklase@google.com470e71d2011-07-07 08:21:25772}
773
pbos@webrtc.org2f446732013-04-08 11:08:41774void ModuleRtpRtcpImpl::BitrateSent(uint32_t* total_rate,
775 uint32_t* video_rate,
776 uint32_t* fec_rate,
777 uint32_t* nack_rate) const {
mflodman@webrtc.org96abda02015-02-25 13:50:10778 *total_rate = rtp_sender_.BitrateSent();
779 *video_rate = rtp_sender_.VideoBitrateSent();
780 *fec_rate = rtp_sender_.FecOverheadRate();
781 *nack_rate = rtp_sender_.NackOverheadRate();
niklase@google.com470e71d2011-07-07 08:21:25782}
783
pwestin@webrtc.org1da1ce02011-10-13 15:19:55784void ModuleRtpRtcpImpl::OnRequestSendReport() {
wu@webrtc.org822fbd82013-08-15 23:38:54785 SendRTCP(kRtcpSr);
niklase@google.com470e71d2011-07-07 08:21:25786}
787
Danil Chapovalov2800d742016-08-26 16:48:46788void ModuleRtpRtcpImpl::OnReceivedNack(
789 const std::vector<uint16_t>& nack_sequence_numbers) {
bcornell30409b42015-07-11 01:10:05790 for (uint16_t nack_sequence_number : nack_sequence_numbers) {
791 send_loss_stats_.AddLostPacket(nack_sequence_number);
792 }
phoglund@webrtc.orgacfdd962013-01-16 10:27:33793 if (!rtp_sender_.StorePackets() ||
stefan@webrtc.orgbecf9c82013-02-01 15:09:57794 nack_sequence_numbers.size() == 0) {
henrike@webrtc.orgd5657c22012-02-08 23:41:49795 return;
796 }
asapersson@webrtc.orge7b1e112013-12-16 14:40:36797 // Use RTT from RtcpRttStats class if provided.
pkasting@chromium.org16825b12015-01-12 21:51:21798 int64_t rtt = rtt_ms();
asapersson@webrtc.orge7b1e112013-12-16 14:40:36799 if (rtt == 0) {
800 rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
801 }
Danil Chapovalov2800d742016-08-26 16:48:46802 rtp_sender_.OnReceivedNack(nack_sequence_numbers, rtt);
niklase@google.com470e71d2011-07-07 08:21:25803}
804
isheriff6b4b5f32016-06-08 07:24:21805void ModuleRtpRtcpImpl::OnReceivedRtcpReportBlocks(
806 const ReportBlockList& report_blocks) {
807 rtp_sender_.OnReceivedRtcpReportBlocks(report_blocks);
808}
809
pbos@webrtc.org2f4b14e2014-07-15 15:25:39810bool ModuleRtpRtcpImpl::LastReceivedNTP(
811 uint32_t* rtcp_arrival_time_secs, // When we got the last report.
812 uint32_t* rtcp_arrival_time_frac,
813 uint32_t* remote_sr) const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33814 // Remote SR: NTP inside the last received (mid 16 bits from sec and frac).
pbos@webrtc.org2f446732013-04-08 11:08:41815 uint32_t ntp_secs = 0;
816 uint32_t ntp_frac = 0;
niklase@google.com470e71d2011-07-07 08:21:25817
pbos@webrtc.org2f4b14e2014-07-15 15:25:39818 if (!rtcp_receiver_.NTP(&ntp_secs,
819 &ntp_frac,
820 rtcp_arrival_time_secs,
821 rtcp_arrival_time_frac,
822 NULL)) {
823 return false;
henrike@webrtc.orgd5657c22012-02-08 23:41:49824 }
pbos@webrtc.org2f4b14e2014-07-15 15:25:39825 *remote_sr =
826 ((ntp_secs & 0x0000ffff) << 16) + ((ntp_frac & 0xffff0000) >> 16);
827 return true;
niklase@google.com470e71d2011-07-07 08:21:25828}
829
phoglund@webrtc.orgacfdd962013-01-16 10:27:33830// Called from RTCPsender.
danilchap2b616392016-08-18 13:17:42831std::vector<rtcp::TmmbItem> ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner) {
832 return rtcp_receiver_.BoundingSet(tmmbr_owner);
niklase@google.com470e71d2011-07-07 08:21:25833}
mflodman@webrtc.org2f225ca2013-01-09 13:54:43834
835int64_t ModuleRtpRtcpImpl::RtcpReportInterval() {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33836 if (audio_)
mflodman@webrtc.org2f225ca2013-01-09 13:54:43837 return RTCP_INTERVAL_AUDIO_MS;
838 else
839 return RTCP_INTERVAL_VIDEO_MS;
840}
stefan@webrtc.org28a331e2013-09-17 07:49:56841
842void ModuleRtpRtcpImpl::SetRtcpReceiverSsrcs(uint32_t main_ssrc) {
843 std::set<uint32_t> ssrcs;
844 ssrcs.insert(main_ssrc);
pbos@webrtc.org0b0c2412015-01-13 14:15:15845 if (rtp_sender_.RtxStatus() != kRtxOff)
846 ssrcs.insert(rtp_sender_.RtxSsrc());
stefan@webrtc.org28a331e2013-09-17 07:49:56847 rtcp_receiver_.SetSsrcs(main_ssrc, ssrcs);
848}
849
pkasting@chromium.org16825b12015-01-12 21:51:21850void ModuleRtpRtcpImpl::set_rtt_ms(int64_t rtt_ms) {
danilchap7c9426c2016-04-14 10:05:31851 rtc::CritScope cs(&critical_section_rtt_);
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11852 rtt_ms_ = rtt_ms;
853}
854
pkasting@chromium.org16825b12015-01-12 21:51:21855int64_t ModuleRtpRtcpImpl::rtt_ms() const {
danilchap7c9426c2016-04-14 10:05:31856 rtc::CritScope cs(&critical_section_rtt_);
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11857 return rtt_ms_;
858}
859
sprang@webrtc.orgebad7652013-12-05 14:29:02860void ModuleRtpRtcpImpl::RegisterSendChannelRtpStatisticsCallback(
861 StreamDataCountersCallback* callback) {
862 rtp_sender_.RegisterRtpStatisticsCallback(callback);
863}
864
865StreamDataCountersCallback*
866 ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
867 return rtp_sender_.GetRtpStatisticsCallback();
868}
sprang5e38c962016-12-01 13:18:09869
870void ModuleRtpRtcpImpl::SetVideoBitrateAllocation(
871 const BitrateAllocation& bitrate) {
872 rtcp_sender_.SetVideoBitrateAllocation(bitrate);
873}
mflodman@webrtc.org02270cd2015-02-06 13:10:19874} // namespace webrtc