blob: 20ae51987514289a13f7e6e8ed363f199deeed11 [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:25 +00001/*
pwestin@webrtc.orgf6bb77a2012-01-24 17:16:59 +00002 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
niklase@google.com470e71d2011-07-07 08:21:25 +00003 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/rtp_rtcp/source/rtp_rtcp_impl.h"
mflodman@webrtc.org2f225ca2013-01-09 13:54:43 +000012
pbos@webrtc.orga048d7c2013-05-29 14:27:38 +000013#include <string.h>
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +000014
sprang168794c2017-07-06 04:38:06 -070015#include <algorithm>
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +000016#include <set>
Peter Boström9c017252016-02-26 16:26:20 +010017#include <string>
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +000018
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020019#include "api/rtpparameters.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020020#include "rtc_base/checks.h"
21#include "rtc_base/logging.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000022
niklase@google.com470e71d2011-07-07 08:21:25 +000023#ifdef _WIN32
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +000024// Disable warning C4355: 'this' : used in base member initializer list.
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +000025#pragma warning(disable : 4355)
niklase@google.com470e71d2011-07-07 08:21:25 +000026#endif
27
28namespace webrtc {
sprang168794c2017-07-06 04:38:06 -070029namespace {
30const int64_t kRtpRtcpMaxIdleTimeProcessMs = 5;
31const int64_t kRtpRtcpRttProcessTimeMs = 1000;
32const int64_t kRtpRtcpBitrateProcessTimeMs = 10;
spranga8ae6f22017-09-04 07:23:56 -070033const int64_t kDefaultExpectedRetransmissionTimeMs = 125;
sprang168794c2017-07-06 04:38:06 -070034} // namespace
niklase@google.com470e71d2011-07-07 08:21:25 +000035
Peter Boström9c017252016-02-26 16:26:20 +010036RTPExtensionType StringToRtpExtensionType(const std::string& extension) {
isheriff6f8d6862016-05-26 11:24:55 -070037 if (extension == RtpExtension::kTimestampOffsetUri)
Peter Boström9c017252016-02-26 16:26:20 +010038 return kRtpExtensionTransmissionTimeOffset;
isheriff6f8d6862016-05-26 11:24:55 -070039 if (extension == RtpExtension::kAudioLevelUri)
Peter Boström9c017252016-02-26 16:26:20 +010040 return kRtpExtensionAudioLevel;
isheriff6f8d6862016-05-26 11:24:55 -070041 if (extension == RtpExtension::kAbsSendTimeUri)
Peter Boström9c017252016-02-26 16:26:20 +010042 return kRtpExtensionAbsoluteSendTime;
isheriff6f8d6862016-05-26 11:24:55 -070043 if (extension == RtpExtension::kVideoRotationUri)
Peter Boström9c017252016-02-26 16:26:20 +010044 return kRtpExtensionVideoRotation;
isheriff6f8d6862016-05-26 11:24:55 -070045 if (extension == RtpExtension::kTransportSequenceNumberUri)
Peter Boström9c017252016-02-26 16:26:20 +010046 return kRtpExtensionTransportSequenceNumber;
isheriff6b4b5f32016-06-08 00:24:21 -070047 if (extension == RtpExtension::kPlayoutDelayUri)
48 return kRtpExtensionPlayoutDelay;
ilnik00d802b2017-04-11 10:34:31 -070049 if (extension == RtpExtension::kVideoContentTypeUri)
50 return kRtpExtensionVideoContentType;
ilnik04f4d122017-06-19 07:18:55 -070051 if (extension == RtpExtension::kVideoTimingUri)
52 return kRtpExtensionVideoTiming;
Johnny Leee0c8b232018-09-11 16:50:49 -040053 if (extension == RtpExtension::kFrameMarkingUri)
54 return kRtpExtensionFrameMarking;
Steve Antonbb50ce52018-03-26 10:24:32 -070055 if (extension == RtpExtension::kMidUri)
56 return kRtpExtensionMid;
Peter Boström9c017252016-02-26 16:26:20 +010057 RTC_NOTREACHED() << "Looking up unsupported RTP extension.";
58 return kRtpExtensionNone;
59}
60
danilchapd3f3c342017-07-25 04:20:12 -070061RtpRtcp::Configuration::Configuration() = default;
phoglund@webrtc.orga22a9bd2013-01-14 10:01:55 +000062
pwestin@webrtc.org2853dde2012-05-11 11:08:54 +000063RtpRtcp* RtpRtcp::CreateRtpRtcp(const RtpRtcp::Configuration& configuration) {
64 if (configuration.clock) {
65 return new ModuleRtpRtcpImpl(configuration);
henrike@webrtc.orgf5da4da2012-02-15 23:54:59 +000066 } else {
pbos@webrtc.org180e5162014-07-11 15:36:26 +000067 // No clock implementation provided, use default clock.
pwestin@webrtc.org2853dde2012-05-11 11:08:54 +000068 RtpRtcp::Configuration configuration_copy;
Yves Gerey665174f2018-06-19 15:03:05 +020069 memcpy(&configuration_copy, &configuration, sizeof(RtpRtcp::Configuration));
stefan@webrtc.org20ed36d2013-01-17 14:01:20 +000070 configuration_copy.clock = Clock::GetRealTimeClock();
pbos@webrtc.org180e5162014-07-11 15:36:26 +000071 return new ModuleRtpRtcpImpl(configuration_copy);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +000072 }
niklase@google.com470e71d2011-07-07 08:21:25 +000073}
74
brandtr1743a192016-11-07 03:36:05 -080075// Deprecated.
76int32_t RtpRtcp::SetFecParameters(const FecProtectionParams* delta_params,
77 const FecProtectionParams* key_params) {
78 RTC_DCHECK(delta_params);
79 RTC_DCHECK(key_params);
80 return SetFecParameters(*delta_params, *key_params) ? 0 : -1;
81}
82
pwestin@webrtc.org2853dde2012-05-11 11:08:54 +000083ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
nisse14adba72017-03-20 03:52:39 -070084 : rtcp_sender_(configuration.audio,
stefan@webrtc.orga15fbfd2014-06-17 17:32:05 +000085 configuration.clock,
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +000086 configuration.receive_statistics,
sprang86fd9ed2015-09-29 04:45:43 -070087 configuration.rtcp_packet_type_counter_observer,
terelius429c3452016-01-21 05:42:04 -080088 configuration.event_log,
Jiawei Ou3587b832018-01-31 22:08:26 -080089 configuration.outgoing_transport,
90 configuration.rtcp_interval_config),
Peter Boströmac547a62015-09-17 23:03:57 +020091 rtcp_receiver_(configuration.clock,
Peter Boströmfe7a80c2015-04-23 17:53:17 +020092 configuration.receiver_only,
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +000093 configuration.rtcp_packet_type_counter_observer,
mflodman@webrtc.org96abda02015-02-25 13:50:10 +000094 configuration.bandwidth_callback,
95 configuration.intra_frame_callback,
Erik Språng6b8d3552015-09-24 15:06:57 +020096 configuration.transport_feedback_callback,
spranga790d832016-12-02 07:29:44 -080097 configuration.bitrate_allocation_observer,
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +000098 this),
stefan@webrtc.orga678a3b2013-01-21 07:42:11 +000099 clock_(configuration.clock),
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000100 audio_(configuration.audio),
sprang168794c2017-07-06 04:38:06 -0700101 keepalive_config_(configuration.keepalive_config),
102 last_bitrate_process_time_(clock_->TimeInMilliseconds()),
103 last_rtt_process_time_(clock_->TimeInMilliseconds()),
104 next_process_time_(clock_->TimeInMilliseconds() +
105 kRtpRtcpMaxIdleTimeProcessMs),
106 next_keepalive_time_(-1),
asapersson35151f32016-05-02 23:44:01 -0700107 packet_overhead_(28), // IPV4 UDP.
stefan@webrtc.orga2710702013-03-05 09:02:06 +0000108 nack_last_time_sent_full_(0),
asapersson@webrtc.orgba8138b2014-12-08 13:29:02 +0000109 nack_last_time_sent_full_prev_(0),
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000110 nack_last_seq_number_sent_(0),
Peter Boströme23e7372015-10-08 11:44:14 +0200111 key_frame_req_method_(kKeyFrameReqPliRtcp),
mflodman@webrtc.org7c894b72012-11-26 12:40:15 +0000112 remote_bitrate_(configuration.remote_bitrate_estimator),
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11 +0000113 rtt_stats_(configuration.rtt_stats),
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11 +0000114 rtt_ms_(0) {
nisse14adba72017-03-20 03:52:39 -0700115 if (!configuration.receiver_only) {
116 rtp_sender_.reset(new RTPSender(
Erik Språng7b52f102018-02-07 14:37:37 +0100117 configuration.audio, configuration.clock,
118 configuration.outgoing_transport, configuration.paced_sender,
nisse14adba72017-03-20 03:52:39 -0700119 configuration.flexfec_sender,
120 configuration.transport_sequence_number_allocator,
121 configuration.transport_feedback_callback,
122 configuration.send_bitrate_observer,
123 configuration.send_frame_count_observer,
Erik Språng7b52f102018-02-07 14:37:37 +0100124 configuration.send_side_delay_observer, configuration.event_log,
nisse14adba72017-03-20 03:52:39 -0700125 configuration.send_packet_observer,
126 configuration.retransmission_rate_limiter,
Erik Språng7b52f102018-02-07 14:37:37 +0100127 configuration.overhead_observer,
128 configuration.populate_network2_timestamp));
nisse14adba72017-03-20 03:52:39 -0700129 // Make sure rtcp sender use same timestamp offset as rtp sender.
130 rtcp_sender_.SetTimestampOffset(rtp_sender_->TimestampOffset());
sprang168794c2017-07-06 04:38:06 -0700131
132 if (keepalive_config_.timeout_interval_ms != -1) {
133 next_keepalive_time_ =
134 clock_->TimeInMilliseconds() + keepalive_config_.timeout_interval_ms;
135 }
nisse14adba72017-03-20 03:52:39 -0700136 }
danilchap71fead22016-08-18 02:01:49 -0700137
138 // Set default packet size limit.
nisse284542b2017-01-10 08:58:32 -0800139 // TODO(nisse): Kind-of duplicates
140 // webrtc::VideoSendStream::Config::Rtp::kDefaultMaxPacketSize.
141 const size_t kTcpOverIpv4HeaderSize = 40;
142 SetMaxRtpPacketSize(IP_PACKET_SIZE - kTcpOverIpv4HeaderSize);
niklase@google.com470e71d2011-07-07 08:21:25 +0000143}
144
Danil Chapovalov2a5ce2b2018-02-07 09:38:31 +0100145ModuleRtpRtcpImpl::~ModuleRtpRtcpImpl() = default;
146
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000147// Returns the number of milliseconds until the module want a worker thread
148// to call Process.
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000149int64_t ModuleRtpRtcpImpl::TimeUntilNextProcess() {
sprang168794c2017-07-06 04:38:06 -0700150 return std::max<int64_t>(0,
151 next_process_time_ - clock_->TimeInMilliseconds());
niklase@google.com470e71d2011-07-07 08:21:25 +0000152}
153
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000154// Process any pending tasks such as timeouts (non time critical events).
pbosa26ac922016-02-25 04:50:01 -0800155void ModuleRtpRtcpImpl::Process() {
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000156 const int64_t now = clock_->TimeInMilliseconds();
sprang168794c2017-07-06 04:38:06 -0700157 next_process_time_ = now + kRtpRtcpMaxIdleTimeProcessMs;
niklase@google.com470e71d2011-07-07 08:21:25 +0000158
nisse14adba72017-03-20 03:52:39 -0700159 if (rtp_sender_) {
nisse14adba72017-03-20 03:52:39 -0700160 if (now >= last_bitrate_process_time_ + kRtpRtcpBitrateProcessTimeMs) {
161 rtp_sender_->ProcessBitrate();
162 last_bitrate_process_time_ = now;
sprang168794c2017-07-06 04:38:06 -0700163 next_process_time_ =
164 std::min(next_process_time_, now + kRtpRtcpBitrateProcessTimeMs);
165 }
166 if (keepalive_config_.timeout_interval_ms > 0 &&
167 now >= next_keepalive_time_) {
168 int64_t last_send_time_ms = rtp_sender_->LastTimestampTimeMs();
169 // If no packet has been sent, |last_send_time_ms| will be 0, and so the
170 // keep-alive will be triggered as expected.
171 if (now >= last_send_time_ms + keepalive_config_.timeout_interval_ms) {
172 rtp_sender_->SendKeepAlive(keepalive_config_.payload_type);
173 next_keepalive_time_ = now + keepalive_config_.timeout_interval_ms;
174 } else {
175 next_keepalive_time_ =
176 last_send_time_ms + keepalive_config_.timeout_interval_ms;
177 }
178 next_process_time_ = std::min(next_process_time_, next_keepalive_time_);
nisse14adba72017-03-20 03:52:39 -0700179 }
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000180 }
sprang168794c2017-07-06 04:38:06 -0700181
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000182 bool process_rtt = now >= last_rtt_process_time_ + kRtpRtcpRttProcessTimeMs;
183 if (rtcp_sender_.Sending()) {
Danil Chapovalov760c4b42017-09-27 13:25:24 +0200184 // Process RTT if we have received a report block and we haven't
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000185 // processed RTT for at least |kRtpRtcpRttProcessTimeMs| milliseconds.
Danil Chapovalov760c4b42017-09-27 13:25:24 +0200186 if (rtcp_receiver_.LastReceivedReportBlockMs() > last_rtt_process_time_ &&
187 process_rtt) {
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000188 std::vector<RTCPReportBlock> receive_blocks;
189 rtcp_receiver_.StatisticsReceived(&receive_blocks);
190 int64_t max_rtt = 0;
191 for (std::vector<RTCPReportBlock>::iterator it = receive_blocks.begin();
192 it != receive_blocks.end(); ++it) {
193 int64_t rtt = 0;
srte3e69e5c2017-08-09 06:13:45 -0700194 rtcp_receiver_.RTT(it->sender_ssrc, &rtt, NULL, NULL, NULL);
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000195 max_rtt = (rtt > max_rtt) ? rtt : max_rtt;
mflodman@webrtc.orgd7d46882012-02-14 12:49:59 +0000196 }
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000197 // Report the rtt.
198 if (rtt_stats_ && max_rtt != 0)
199 rtt_stats_->OnRttUpdate(max_rtt);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000200 }
asapersson@webrtc.org7d6bd222013-10-31 12:14:34 +0000201
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000202 // Verify receiver reports are delivered and the reported sequence number
203 // is increasing.
204 int64_t rtcp_interval = RtcpReportInterval();
205 if (rtcp_receiver_.RtcpRrTimeout(rtcp_interval)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100206 RTC_LOG_F(LS_WARNING) << "Timeout: No RTCP RR received.";
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000207 } else if (rtcp_receiver_.RtcpRrSequenceNumberTimeout(rtcp_interval)) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100208 RTC_LOG_F(LS_WARNING) << "Timeout: No increase in RTCP RR extended "
209 "highest sequence number.";
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000210 }
211
212 if (remote_bitrate_ && rtcp_sender_.TMMBR()) {
213 unsigned int target_bitrate = 0;
214 std::vector<unsigned int> ssrcs;
215 if (remote_bitrate_->LatestEstimate(&ssrcs, &target_bitrate)) {
216 if (!ssrcs.empty()) {
217 target_bitrate = target_bitrate / ssrcs.size();
218 }
219 rtcp_sender_.SetTargetBitrate(target_bitrate);
220 }
221 }
222 } else {
223 // Report rtt from receiver.
asapersson@webrtc.org7d6bd222013-10-31 12:14:34 +0000224 if (process_rtt) {
Yves Gerey665174f2018-06-19 15:03:05 +0200225 int64_t rtt_ms;
226 if (rtt_stats_ && rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)) {
227 rtt_stats_->OnRttUpdate(rtt_ms);
228 }
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000229 }
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000230 }
231
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000232 // Get processed rtt.
233 if (process_rtt) {
234 last_rtt_process_time_ = now;
sprang168794c2017-07-06 04:38:06 -0700235 next_process_time_ = std::min(
236 next_process_time_, last_rtt_process_time_ + kRtpRtcpRttProcessTimeMs);
sprange2d83d62016-02-19 09:03:26 -0800237 if (rtt_stats_) {
238 // Make sure we have a valid RTT before setting.
239 int64_t last_rtt = rtt_stats_->LastProcessedRtt();
240 if (last_rtt >= 0)
241 set_rtt_ms(last_rtt);
242 }
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000243 }
244
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200245 if (rtcp_sender_.TimeToSendRTCPReport())
246 rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
mflodman@webrtc.org9dd0ebc2015-02-26 12:57:47 +0000247
danilchap9bf610e2017-02-20 06:03:01 -0800248 if (TMMBR() && rtcp_receiver_.UpdateTmmbrTimers()) {
249 rtcp_receiver_.NotifyTmmbrUpdated();
asapersson@webrtc.org0b3c35a2012-01-16 11:06:31 +0000250 }
niklase@google.com470e71d2011-07-07 08:21:25 +0000251}
252
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000253void ModuleRtpRtcpImpl::SetRtxSendStatus(int mode) {
nisse14adba72017-03-20 03:52:39 -0700254 rtp_sender_->SetRtxStatus(mode);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000255}
256
pbos@webrtc.org0b0c2412015-01-13 14:15:15 +0000257int ModuleRtpRtcpImpl::RtxSendStatus() const {
nisse14adba72017-03-20 03:52:39 -0700258 return rtp_sender_ ? rtp_sender_->RtxStatus() : kRtxOff;
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000259}
260
261void ModuleRtpRtcpImpl::SetRtxSsrc(uint32_t ssrc) {
nisse14adba72017-03-20 03:52:39 -0700262 rtp_sender_->SetRtxSsrc(ssrc);
pwestin@webrtc.org8281e7d2012-01-10 14:09:18 +0000263}
264
Shao Changbine62202f2015-04-21 20:24:50 +0800265void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type,
266 int associated_payload_type) {
nisse14adba72017-03-20 03:52:39 -0700267 rtp_sender_->SetRtxPayloadType(payload_type, associated_payload_type);
mflodman@webrtc.org9f5ebb52013-04-12 14:55:46 +0000268}
269
Danil Chapovalovd264df52018-06-14 12:59:38 +0200270absl::optional<uint32_t> ModuleRtpRtcpImpl::FlexfecSsrc() const {
brandtr7c7796b2017-07-03 06:02:53 -0700271 if (rtp_sender_)
272 return rtp_sender_->FlexfecSsrc();
Danil Chapovalovd264df52018-06-14 12:59:38 +0200273 return absl::nullopt;
brandtr9dfff292016-11-14 05:14:50 -0800274}
275
nisse479d3d72017-09-13 07:53:37 -0700276void ModuleRtpRtcpImpl::IncomingRtcpPacket(const uint8_t* rtcp_packet,
277 const size_t length) {
278 rtcp_receiver_.IncomingPacket(rtcp_packet, length);
niklase@google.com470e71d2011-07-07 08:21:25 +0000279}
280
Yves Gerey665174f2018-06-19 15:03:05 +0200281int32_t ModuleRtpRtcpImpl::RegisterSendPayload(const CodecInst& voice_codec) {
nisse14adba72017-03-20 03:52:39 -0700282 return rtp_sender_->RegisterPayload(
Sergey Ulanovec4f0682016-07-28 15:19:10 -0700283 voice_codec.plname, voice_codec.pltype, voice_codec.plfreq,
284 voice_codec.channels, (voice_codec.rate < 0) ? 0 : voice_codec.rate);
pwestin@webrtc.org1da1ce02011-10-13 15:19:55 +0000285}
286
Peter Boström8b79b072016-02-26 16:31:37 +0100287void ModuleRtpRtcpImpl::RegisterVideoSendPayload(int payload_type,
288 const char* payload_name) {
289 RTC_CHECK_EQ(
nisse14adba72017-03-20 03:52:39 -0700290 0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, 0, 0));
Peter Boström8b79b072016-02-26 16:31:37 +0100291}
292
asapersson@webrtc.org9ffd8fe2015-01-21 08:22:50 +0000293int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(const int8_t payload_type) {
nisse14adba72017-03-20 03:52:39 -0700294 return rtp_sender_->DeRegisterSendPayload(payload_type);
niklase@google.com470e71d2011-07-07 08:21:25 +0000295}
296
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000297uint32_t ModuleRtpRtcpImpl::StartTimestamp() const {
nisse14adba72017-03-20 03:52:39 -0700298 return rtp_sender_->TimestampOffset();
niklase@google.com470e71d2011-07-07 08:21:25 +0000299}
300
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000301// Configure start timestamp, default is a random number.
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000302void ModuleRtpRtcpImpl::SetStartTimestamp(const uint32_t timestamp) {
danilchap71fead22016-08-18 02:01:49 -0700303 rtcp_sender_.SetTimestampOffset(timestamp);
nisse14adba72017-03-20 03:52:39 -0700304 rtp_sender_->SetTimestampOffset(timestamp);
niklase@google.com470e71d2011-07-07 08:21:25 +0000305}
306
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000307uint16_t ModuleRtpRtcpImpl::SequenceNumber() const {
nisse14adba72017-03-20 03:52:39 -0700308 return rtp_sender_->SequenceNumber();
niklase@google.com470e71d2011-07-07 08:21:25 +0000309}
310
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000311// Set SequenceNumber, default is a random number.
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000312void ModuleRtpRtcpImpl::SetSequenceNumber(const uint16_t seq_num) {
nisse14adba72017-03-20 03:52:39 -0700313 rtp_sender_->SetSequenceNumber(seq_num);
niklase@google.com470e71d2011-07-07 08:21:25 +0000314}
315
Per83d09102016-04-15 14:59:13 +0200316void ModuleRtpRtcpImpl::SetRtpState(const RtpState& rtp_state) {
nisse14adba72017-03-20 03:52:39 -0700317 rtp_sender_->SetRtpState(rtp_state);
danilchap71fead22016-08-18 02:01:49 -0700318 rtcp_sender_.SetTimestampOffset(rtp_state.start_timestamp);
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000319}
320
Per83d09102016-04-15 14:59:13 +0200321void ModuleRtpRtcpImpl::SetRtxState(const RtpState& rtp_state) {
nisse14adba72017-03-20 03:52:39 -0700322 rtp_sender_->SetRtxRtpState(rtp_state);
Per83d09102016-04-15 14:59:13 +0200323}
324
325RtpState ModuleRtpRtcpImpl::GetRtpState() const {
nisse14adba72017-03-20 03:52:39 -0700326 return rtp_sender_->GetRtpState();
Per83d09102016-04-15 14:59:13 +0200327}
328
329RtpState ModuleRtpRtcpImpl::GetRtxState() const {
nisse14adba72017-03-20 03:52:39 -0700330 return rtp_sender_->GetRtxRtpState();
pbos@webrtc.org2bb1bda2014-07-07 13:06:48 +0000331}
332
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000333uint32_t ModuleRtpRtcpImpl::SSRC() const {
nisse14adba72017-03-20 03:52:39 -0700334 return rtcp_sender_.SSRC();
niklase@google.com470e71d2011-07-07 08:21:25 +0000335}
336
stefan@webrtc.orgef927552014-06-05 08:25:29 +0000337void ModuleRtpRtcpImpl::SetSSRC(const uint32_t ssrc) {
nisse14adba72017-03-20 03:52:39 -0700338 if (rtp_sender_) {
339 rtp_sender_->SetSSRC(ssrc);
340 }
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000341 rtcp_sender_.SetSSRC(ssrc);
stefan@webrtc.org28a331e2013-09-17 07:49:56 +0000342 SetRtcpReceiverSsrcs(ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +0000343}
344
Steve Anton296a0ce2018-03-22 15:17:27 -0700345void ModuleRtpRtcpImpl::SetMid(const std::string& mid) {
346 if (rtp_sender_) {
347 rtp_sender_->SetMid(mid);
348 }
349 // TODO(bugs.webrtc.org/4050): If we end up supporting the MID SDES item for
350 // RTCP, this will need to be passed down to the RTCPSender also.
351}
352
pbos@webrtc.org9334ac22014-11-24 08:25:50 +0000353void ModuleRtpRtcpImpl::SetCsrcs(const std::vector<uint32_t>& csrcs) {
pbos@webrtc.org9334ac22014-11-24 08:25:50 +0000354 rtcp_sender_.SetCsrcs(csrcs);
nisse14adba72017-03-20 03:52:39 -0700355 rtp_sender_->SetCsrcs(csrcs);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000356}
357
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000358// TODO(pbos): Handle media and RTX streams separately (separate RTCP
359// feedbacks).
360RTCPSender::FeedbackState ModuleRtpRtcpImpl::GetFeedbackState() {
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000361 RTCPSender::FeedbackState state;
nisse14adba72017-03-20 03:52:39 -0700362 // This is called also when receiver_only is true. Hence below
363 // checks that rtp_sender_ exists.
364 if (rtp_sender_) {
365 StreamDataCounters rtp_stats;
366 StreamDataCounters rtx_stats;
367 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
Yves Gerey665174f2018-06-19 15:03:05 +0200368 state.packets_sent =
369 rtp_stats.transmitted.packets + rtx_stats.transmitted.packets;
nisse14adba72017-03-20 03:52:39 -0700370 state.media_bytes_sent = rtp_stats.transmitted.payload_bytes +
371 rtx_stats.transmitted.payload_bytes;
372 state.send_bitrate = rtp_sender_->BitrateSent();
373 }
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000374 state.module = this;
375
Yves Gerey665174f2018-06-19 15:03:05 +0200376 LastReceivedNTP(&state.last_rr_ntp_secs, &state.last_rr_ntp_frac,
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000377 &state.remote_sr);
378
Mirta Dvornicicb1f063d2018-04-16 11:16:21 +0200379 state.last_xr_rtis = rtcp_receiver_.ConsumeReceivedXrReferenceTimeInfo();
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000380
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000381 return state;
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000382}
383
nisse14adba72017-03-20 03:52:39 -0700384// TODO(nisse): This method shouldn't be called for a receive-only
385// stream. Delete rtp_sender_ check as soon as all applications are
386// updated.
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000387int32_t ModuleRtpRtcpImpl::SetSendingStatus(const bool sending) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000388 if (rtcp_sender_.Sending() != sending) {
389 // Sends RTCP BYE when going from true to false
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000390 if (rtcp_sender_.SetSendingStatus(GetFeedbackState(), sending) != 0) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100391 RTC_LOG(LS_WARNING) << "Failed to send RTCP BYE";
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000392 }
nisse14adba72017-03-20 03:52:39 -0700393 if (sending && rtp_sender_) {
nisse7d59f6b2017-02-21 03:40:24 -0800394 // Update Rtcp receiver config, to track Rtx config changes from
395 // the SetRtxStatus and SetRtxSsrc methods.
nisse14adba72017-03-20 03:52:39 -0700396 SetRtcpReceiverSsrcs(rtp_sender_->SSRC());
nisse7d59f6b2017-02-21 03:40:24 -0800397 }
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000398 }
399 return 0;
400}
401
402bool ModuleRtpRtcpImpl::Sending() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000403 return rtcp_sender_.Sending();
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000404}
405
nisse14adba72017-03-20 03:52:39 -0700406// TODO(nisse): This method shouldn't be called for a receive-only
407// stream. Delete rtp_sender_ check as soon as all applications are
408// updated.
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000409void ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
nisse14adba72017-03-20 03:52:39 -0700410 if (rtp_sender_) {
411 rtp_sender_->SetSendingMediaStatus(sending);
412 } else {
413 RTC_DCHECK(!sending);
414 }
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000415}
416
417bool ModuleRtpRtcpImpl::SendingMedia() const {
nisse14adba72017-03-20 03:52:39 -0700418 return rtp_sender_ ? rtp_sender_->SendingMedia() : false;
niklase@google.com470e71d2011-07-07 08:21:25 +0000419}
420
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700421bool ModuleRtpRtcpImpl::SendOutgoingData(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000422 FrameType frame_type,
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000423 int8_t payload_type,
424 uint32_t time_stamp,
stefan@webrtc.orgddfdfed2012-07-03 13:21:22 +0000425 int64_t capture_time_ms,
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000426 const uint8_t* payload_data,
pkasting@chromium.org4591fbd2014-11-20 22:28:14 +0000427 size_t payload_size,
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000428 const RTPFragmentationHeader* fragmentation,
Sergey Ulanov525df3f2016-08-02 17:46:41 -0700429 const RTPVideoHeader* rtp_video_header,
430 uint32_t* transport_frame_id_out) {
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000431 rtcp_sender_.SetLastRtpTime(time_stamp, capture_time_ms);
mflodman0b3d7ee2015-12-10 10:10:44 +0100432 // Make sure an RTCP report isn't queued behind a key frame.
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000433 if (rtcp_sender_.TimeToSendRTCPReport(kVideoFrameKey == frame_type)) {
Yves Gerey665174f2018-06-19 15:03:05 +0200434 rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpReport);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000435 }
spranga8ae6f22017-09-04 07:23:56 -0700436 int64_t expected_retransmission_time_ms = rtt_ms();
437 if (expected_retransmission_time_ms == 0) {
438 // No rtt available (|kRtpRtcpRttProcessTimeMs| not yet passed?), so try to
439 // poll avg_rtt_ms directly from rtcp receiver.
440 if (rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), nullptr,
441 &expected_retransmission_time_ms, nullptr,
442 nullptr) == -1) {
443 expected_retransmission_time_ms = kDefaultExpectedRetransmissionTimeMs;
444 }
445 }
nisse14adba72017-03-20 03:52:39 -0700446 return rtp_sender_->SendOutgoingData(
guoweis@webrtc.org45362892015-03-04 22:55:15 +0000447 frame_type, payload_type, time_stamp, capture_time_ms, payload_data,
spranga8ae6f22017-09-04 07:23:56 -0700448 payload_size, fragmentation, rtp_video_header, transport_frame_id_out,
449 expected_retransmission_time_ms);
niklase@google.com470e71d2011-07-07 08:21:25 +0000450}
451
hclam@chromium.org2e402ce2013-06-20 20:18:31 +0000452bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc,
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +0000453 uint16_t sequence_number,
stefan@webrtc.org9b82f5a2013-11-13 15:29:21 +0000454 int64_t capture_time_ms,
philipela1ed0b32016-06-01 06:31:17 -0700455 bool retransmission,
philipelc7bf32a2017-02-17 03:59:43 -0800456 const PacedPacketInfo& pacing_info) {
nisse14adba72017-03-20 03:52:39 -0700457 return rtp_sender_->TimeToSendPacket(ssrc, sequence_number, capture_time_ms,
Yves Gerey665174f2018-06-19 15:03:05 +0200458 retransmission, pacing_info);
stefan@webrtc.org508a84b2013-06-17 12:53:37 +0000459}
460
philipelc7bf32a2017-02-17 03:59:43 -0800461size_t ModuleRtpRtcpImpl::TimeToSendPadding(
462 size_t bytes,
463 const PacedPacketInfo& pacing_info) {
nisse14adba72017-03-20 03:52:39 -0700464 return rtp_sender_->TimeToSendPadding(bytes, pacing_info);
pwestin@webrtc.org571a1c02012-11-13 21:12:39 +0000465}
466
nisse284542b2017-01-10 08:58:32 -0800467size_t ModuleRtpRtcpImpl::MaxRtpPacketSize() const {
nisse14adba72017-03-20 03:52:39 -0700468 return rtp_sender_->MaxRtpPacketSize();
niklase@google.com470e71d2011-07-07 08:21:25 +0000469}
470
nisse284542b2017-01-10 08:58:32 -0800471void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
472 RTC_DCHECK_LE(rtp_packet_size, IP_PACKET_SIZE)
473 << "rtp packet size too large: " << rtp_packet_size;
474 RTC_DCHECK_GT(rtp_packet_size, packet_overhead_)
475 << "rtp packet size too small: " << rtp_packet_size;
niklase@google.com470e71d2011-07-07 08:21:25 +0000476
nisse284542b2017-01-10 08:58:32 -0800477 rtcp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
nisse14adba72017-03-20 03:52:39 -0700478 if (rtp_sender_)
479 rtp_sender_->SetMaxRtpPacketSize(rtp_packet_size);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000480}
481
pbosda903ea2015-10-02 02:36:56 -0700482RtcpMode ModuleRtpRtcpImpl::RTCP() const {
Taylor Brandstetter5f0b83b2016-03-18 15:02:07 -0700483 return rtcp_sender_.Status();
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000484}
485
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000486// Configure RTCP status i.e on/off.
pbosda903ea2015-10-02 02:36:56 -0700487void ModuleRtpRtcpImpl::SetRTCPStatus(const RtcpMode method) {
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000488 rtcp_sender_.SetRTCPStatus(method);
niklase@google.com470e71d2011-07-07 08:21:25 +0000489}
pwestin@webrtc.org1da1ce02011-10-13 15:19:55 +0000490
Peter Boström9ba52f82015-06-01 14:12:28 +0200491int32_t ModuleRtpRtcpImpl::SetCNAME(const char* c_name) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000492 return rtcp_sender_.SetCNAME(c_name);
niklase@google.com470e71d2011-07-07 08:21:25 +0000493}
494
Erik Språng0ea42d32015-06-25 14:46:16 +0200495int32_t ModuleRtpRtcpImpl::AddMixedCNAME(uint32_t ssrc, const char* c_name) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000496 return rtcp_sender_.AddMixedCNAME(ssrc, c_name);
niklase@google.com470e71d2011-07-07 08:21:25 +0000497}
498
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000499int32_t ModuleRtpRtcpImpl::RemoveMixedCNAME(const uint32_t ssrc) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000500 return rtcp_sender_.RemoveMixedCNAME(ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +0000501}
502
Yves Gerey665174f2018-06-19 15:03:05 +0200503int32_t ModuleRtpRtcpImpl::RemoteCNAME(const uint32_t remote_ssrc,
504 char c_name[RTCP_CNAME_SIZE]) const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000505 return rtcp_receiver_.CNAME(remote_ssrc, c_name);
niklase@google.com470e71d2011-07-07 08:21:25 +0000506}
507
Yves Gerey665174f2018-06-19 15:03:05 +0200508int32_t ModuleRtpRtcpImpl::RemoteNTP(uint32_t* received_ntpsecs,
509 uint32_t* received_ntpfrac,
510 uint32_t* rtcp_arrival_time_secs,
511 uint32_t* rtcp_arrival_time_frac,
512 uint32_t* rtcp_timestamp) const {
513 return rtcp_receiver_.NTP(received_ntpsecs, received_ntpfrac,
514 rtcp_arrival_time_secs, rtcp_arrival_time_frac,
pbos@webrtc.org376b4ea2014-07-15 15:51:33 +0000515 rtcp_timestamp)
516 ? 0
517 : -1;
niklase@google.com470e71d2011-07-07 08:21:25 +0000518}
519
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000520// Get RoundTripTime.
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000521int32_t ModuleRtpRtcpImpl::RTT(const uint32_t remote_ssrc,
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000522 int64_t* rtt,
523 int64_t* avg_rtt,
524 int64_t* min_rtt,
525 int64_t* max_rtt) const {
wu@webrtc.orgcd701192014-04-24 22:10:24 +0000526 int32_t ret = rtcp_receiver_.RTT(remote_ssrc, rtt, avg_rtt, min_rtt, max_rtt);
527 if (rtt && *rtt == 0) {
528 // Try to get RTT from RtcpRttStats class.
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000529 *rtt = rtt_ms();
wu@webrtc.orgcd701192014-04-24 22:10:24 +0000530 }
531 return ret;
niklase@google.com470e71d2011-07-07 08:21:25 +0000532}
533
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000534// Force a send of an RTCP packet.
535// Normal SR and RR are triggered via the process function.
Erik Språng242e22b2015-05-11 10:17:43 +0200536int32_t ModuleRtpRtcpImpl::SendRTCP(RTCPPacketType packet_type) {
537 return rtcp_sender_.SendRTCP(GetFeedbackState(), packet_type);
538}
539
540// Force a send of an RTCP packet.
541// Normal SR and RR are triggered via the process function.
542int32_t ModuleRtpRtcpImpl::SendCompoundRTCP(
543 const std::set<RTCPPacketType>& packet_types) {
544 return rtcp_sender_.SendCompoundRTCP(GetFeedbackState(), packet_types);
niklase@google.com470e71d2011-07-07 08:21:25 +0000545}
546
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000547int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
548 const uint8_t sub_type,
549 const uint32_t name,
550 const uint8_t* data,
551 const uint16_t length) {
Yves Gerey665174f2018-06-19 15:03:05 +0200552 return rtcp_sender_.SetApplicationSpecificData(sub_type, name, data, length);
niklase@google.com470e71d2011-07-07 08:21:25 +0000553}
554
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000555// (XR) VOIP metric.
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000556int32_t ModuleRtpRtcpImpl::SetRTCPVoIPMetrics(
Yves Gerey665174f2018-06-19 15:03:05 +0200557 const RTCPVoIPMetric* voip_metric) {
558 return rtcp_sender_.SetRTCPVoIPMetrics(voip_metric);
niklase@google.com470e71d2011-07-07 08:21:25 +0000559}
560
asapersson@webrtc.org7d6bd222013-10-31 12:14:34 +0000561void ModuleRtpRtcpImpl::SetRtcpXrRrtrStatus(bool enable) {
Danil Chapovalovc1e55c72016-03-09 15:14:35 +0100562 rtcp_receiver_.SetRtcpXrRrtrStatus(enable);
563 rtcp_sender_.SendRtcpXrReceiverReferenceTime(enable);
asapersson@webrtc.org7d6bd222013-10-31 12:14:34 +0000564}
565
asapersson@webrtc.org8d02f5d2013-11-21 08:57:04 +0000566bool ModuleRtpRtcpImpl::RtcpXrRrtrStatus() const {
567 return rtcp_sender_.RtcpXrReceiverReferenceTime();
568}
569
asapersson@webrtc.org97d04892014-12-09 09:47:53 +0000570// TODO(asapersson): Replace this method with the one below.
Yves Gerey665174f2018-06-19 15:03:05 +0200571int32_t ModuleRtpRtcpImpl::DataCountersRTP(size_t* bytes_sent,
572 uint32_t* packets_sent) const {
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000573 StreamDataCounters rtp_stats;
574 StreamDataCounters rtx_stats;
nisse14adba72017-03-20 03:52:39 -0700575 rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000576
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000577 if (bytes_sent) {
asapersson@webrtc.orgcfd82df2015-01-22 09:39:59 +0000578 *bytes_sent = rtp_stats.transmitted.payload_bytes +
579 rtp_stats.transmitted.padding_bytes +
580 rtp_stats.transmitted.header_bytes +
581 rtx_stats.transmitted.payload_bytes +
582 rtx_stats.transmitted.padding_bytes +
583 rtx_stats.transmitted.header_bytes;
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000584 }
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000585 if (packets_sent) {
Yves Gerey665174f2018-06-19 15:03:05 +0200586 *packets_sent =
587 rtp_stats.transmitted.packets + rtx_stats.transmitted.packets;
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000588 }
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000589 return 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000590}
591
asapersson@webrtc.org97d04892014-12-09 09:47:53 +0000592void ModuleRtpRtcpImpl::GetSendStreamDataCounters(
593 StreamDataCounters* rtp_counters,
594 StreamDataCounters* rtx_counters) const {
nisse14adba72017-03-20 03:52:39 -0700595 rtp_sender_->GetDataCounters(rtp_counters, rtx_counters);
asapersson@webrtc.org97d04892014-12-09 09:47:53 +0000596}
597
bcornell30409b42015-07-10 18:10:05 -0700598void ModuleRtpRtcpImpl::GetRtpPacketLossStats(
599 bool outgoing,
600 uint32_t ssrc,
601 struct RtpPacketLossStats* loss_stats) const {
Yves Gerey665174f2018-06-19 15:03:05 +0200602 if (!loss_stats)
603 return;
bcornell30409b42015-07-10 18:10:05 -0700604 const PacketLossStats* stats_source = NULL;
605 if (outgoing) {
606 if (SSRC() == ssrc) {
607 stats_source = &send_loss_stats_;
608 }
609 } else {
610 if (rtcp_receiver_.RemoteSSRC() == ssrc) {
611 stats_source = &receive_loss_stats_;
612 }
613 }
614 if (stats_source) {
Yves Gerey665174f2018-06-19 15:03:05 +0200615 loss_stats->single_packet_loss_count = stats_source->GetSingleLossCount();
bcornell30409b42015-07-10 18:10:05 -0700616 loss_stats->multiple_packet_loss_event_count =
617 stats_source->GetMultipleLossEventCount();
618 loss_stats->multiple_packet_loss_packet_count =
619 stats_source->GetMultipleLossPacketCount();
620 }
621}
622
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000623// Received RTCP report.
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000624int32_t ModuleRtpRtcpImpl::RemoteRTCPStat(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000625 std::vector<RTCPReportBlock>* receive_blocks) const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000626 return rtcp_receiver_.StatisticsReceived(receive_blocks);
niklase@google.com470e71d2011-07-07 08:21:25 +0000627}
628
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000629// (REMB) Receiver Estimated Max Bitrate.
Danil Chapovalov1de4b622017-12-13 13:35:10 +0100630void ModuleRtpRtcpImpl::SetRemb(int64_t bitrate_bps,
631 std::vector<uint32_t> ssrcs) {
632 rtcp_sender_.SetRemb(bitrate_bps, std::move(ssrcs));
pwestin@webrtc.org741da942011-09-20 13:52:04 +0000633}
634
Danil Chapovalov51e21aa2017-10-10 17:46:26 +0200635void ModuleRtpRtcpImpl::UnsetRemb() {
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200636 rtcp_sender_.UnsetRemb();
pwestin@webrtc.org741da942011-09-20 13:52:04 +0000637}
638
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000639int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000640 const RTPExtensionType type,
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000641 const uint8_t id) {
nisse14adba72017-03-20 03:52:39 -0700642 return rtp_sender_->RegisterRtpHeaderExtension(type, id);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000643}
644
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000645int32_t ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000646 const RTPExtensionType type) {
nisse14adba72017-03-20 03:52:39 -0700647 return rtp_sender_->DeregisterRtpHeaderExtension(type);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000648}
649
stefan53b6cc32017-02-03 08:13:57 -0800650bool ModuleRtpRtcpImpl::HasBweExtensions() const {
nisse14adba72017-03-20 03:52:39 -0700651 return rtp_sender_->IsRtpHeaderExtensionRegistered(
stefan53b6cc32017-02-03 08:13:57 -0800652 kRtpExtensionTransportSequenceNumber) ||
nisse14adba72017-03-20 03:52:39 -0700653 rtp_sender_->IsRtpHeaderExtensionRegistered(
stefan53b6cc32017-02-03 08:13:57 -0800654 kRtpExtensionAbsoluteSendTime) ||
nisse14adba72017-03-20 03:52:39 -0700655 rtp_sender_->IsRtpHeaderExtensionRegistered(
stefan53b6cc32017-02-03 08:13:57 -0800656 kRtpExtensionTransmissionTimeOffset);
657}
658
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000659// (TMMBR) Temporary Max Media Bit Rate.
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000660bool ModuleRtpRtcpImpl::TMMBR() const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000661 return rtcp_sender_.TMMBR();
niklase@google.com470e71d2011-07-07 08:21:25 +0000662}
663
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000664void ModuleRtpRtcpImpl::SetTMMBRStatus(const bool enable) {
665 rtcp_sender_.SetTMMBRStatus(enable);
niklase@google.com470e71d2011-07-07 08:21:25 +0000666}
667
danilchap853ecb22016-08-22 08:26:15 -0700668void ModuleRtpRtcpImpl::SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) {
669 rtcp_sender_.SetTmmbn(std::move(bounding_set));
niklase@google.com470e71d2011-07-07 08:21:25 +0000670}
671
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000672// Returns the currently configured retransmission mode.
673int ModuleRtpRtcpImpl::SelectiveRetransmissions() const {
nisse14adba72017-03-20 03:52:39 -0700674 return rtp_sender_->SelectiveRetransmissions();
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000675}
676
677// Enable or disable a retransmission mode, which decides which packets will
678// be retransmitted if NACKed.
679int ModuleRtpRtcpImpl::SetSelectiveRetransmissions(uint8_t settings) {
nisse14adba72017-03-20 03:52:39 -0700680 return rtp_sender_->SetSelectiveRetransmissions(settings);
stefan@webrtc.org6a4bef42011-12-22 12:52:41 +0000681}
682
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000683// Send a Negative acknowledgment packet.
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000684int32_t ModuleRtpRtcpImpl::SendNACK(const uint16_t* nack_list,
685 const uint16_t size) {
bcornell30409b42015-07-10 18:10:05 -0700686 for (int i = 0; i < size; ++i) {
687 receive_loss_stats_.AddLostPacket(nack_list[i]);
688 }
asapersson@webrtc.orgba8138b2014-12-08 13:29:02 +0000689 uint16_t nack_length = size;
690 uint16_t start_id = 0;
691 int64_t now = clock_->TimeInMilliseconds();
692 if (TimeToSendFullNackList(now)) {
693 nack_last_time_sent_full_ = now;
694 nack_last_time_sent_full_prev_ = now;
695 } else {
696 // Only send extended list.
697 if (nack_last_seq_number_sent_ == nack_list[size - 1]) {
698 // Last sequence number is the same, do not send list.
699 return 0;
700 }
701 // Send new sequence numbers.
702 for (int i = 0; i < size; ++i) {
703 if (nack_last_seq_number_sent_ == nack_list[i]) {
704 start_id = i + 1;
705 break;
706 }
707 }
708 nack_length = size - start_id;
709 }
710
711 // Our RTCP NACK implementation is limited to kRtcpMaxNackFields sequence
712 // numbers per RTCP packet.
713 if (nack_length > kRtcpMaxNackFields) {
714 nack_length = kRtcpMaxNackFields;
715 }
716 nack_last_seq_number_sent_ = nack_list[start_id + nack_length - 1];
717
philipel83f831a2016-03-12 03:30:23 -0800718 return rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpNack, nack_length,
719 &nack_list[start_id]);
720}
721
722void ModuleRtpRtcpImpl::SendNack(
723 const std::vector<uint16_t>& sequence_numbers) {
724 rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpNack, sequence_numbers.size(),
725 sequence_numbers.data());
asapersson@webrtc.orgba8138b2014-12-08 13:29:02 +0000726}
727
728bool ModuleRtpRtcpImpl::TimeToSendFullNackList(int64_t now) const {
asapersson@webrtc.orge7b1e112013-12-16 14:40:36 +0000729 // Use RTT from RtcpRttStats class if provided.
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000730 int64_t rtt = rtt_ms();
asapersson@webrtc.orge7b1e112013-12-16 14:40:36 +0000731 if (rtt == 0) {
732 rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
733 }
stefan@webrtc.org8ca8a712013-04-23 16:48:32 +0000734
asapersson@webrtc.orgba8138b2014-12-08 13:29:02 +0000735 const int64_t kStartUpRttMs = 100;
asapersson@webrtc.orge7b1e112013-12-16 14:40:36 +0000736 int64_t wait_time = 5 + ((rtt * 3) >> 1); // 5 + RTT * 1.5.
asapersson@webrtc.orgba8138b2014-12-08 13:29:02 +0000737 if (rtt == 0) {
738 wait_time = kStartUpRttMs;
stefan@webrtc.org8ca8a712013-04-23 16:48:32 +0000739 }
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000740
asapersson@webrtc.orgba8138b2014-12-08 13:29:02 +0000741 // Send a full NACK list once within every |wait_time|.
742 if (rtt_stats_) {
743 return now - nack_last_time_sent_full_ > wait_time;
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000744 }
asapersson@webrtc.orgba8138b2014-12-08 13:29:02 +0000745 return now - nack_last_time_sent_full_prev_ > wait_time;
niklase@google.com470e71d2011-07-07 08:21:25 +0000746}
747
asapersson@webrtc.org9ffd8fe2015-01-21 08:22:50 +0000748// Store the sent packets, needed to answer to Negative acknowledgment requests.
pbos@webrtc.orgd16e8392014-12-19 13:49:55 +0000749void ModuleRtpRtcpImpl::SetStorePacketsStatus(const bool enable,
750 const uint16_t number_to_store) {
nisse14adba72017-03-20 03:52:39 -0700751 rtp_sender_->SetStorePacketsStatus(enable, number_to_store);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000752}
niklase@google.com470e71d2011-07-07 08:21:25 +0000753
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000754bool ModuleRtpRtcpImpl::StorePackets() const {
nisse14adba72017-03-20 03:52:39 -0700755 return rtp_sender_->StorePackets();
tnakamura@webrtc.orgaa4d96a2013-07-16 19:25:04 +0000756}
757
pbos@webrtc.orgce4e9a32014-12-18 13:50:16 +0000758void ModuleRtpRtcpImpl::RegisterRtcpStatisticsCallback(
sprang@webrtc.orga6ad6e52013-12-05 09:48:44 +0000759 RtcpStatisticsCallback* callback) {
760 rtcp_receiver_.RegisterRtcpStatisticsCallback(callback);
761}
762
pbos@webrtc.org1d0fa5d2015-02-19 12:47:00 +0000763RtcpStatisticsCallback* ModuleRtpRtcpImpl::GetRtcpStatisticsCallback() {
sprang@webrtc.orga6ad6e52013-12-05 09:48:44 +0000764 return rtcp_receiver_.GetRtcpStatisticsCallback();
765}
766
sprang233bd872015-09-08 13:25:16 -0700767bool ModuleRtpRtcpImpl::SendFeedbackPacket(
768 const rtcp::TransportFeedback& packet) {
769 return rtcp_sender_.SendFeedbackPacket(packet);
770}
771
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000772// Send a TelephoneEvent tone using RFC 2833 (4733).
Yves Gerey665174f2018-06-19 15:03:05 +0200773int32_t ModuleRtpRtcpImpl::SendTelephoneEventOutband(const uint8_t key,
774 const uint16_t time_ms,
775 const uint8_t level) {
nisse14adba72017-03-20 03:52:39 -0700776 return rtp_sender_->SendTelephoneEvent(key, time_ms, level);
niklase@google.com470e71d2011-07-07 08:21:25 +0000777}
778
Yves Gerey665174f2018-06-19 15:03:05 +0200779int32_t ModuleRtpRtcpImpl::SetAudioLevel(const uint8_t level_d_bov) {
nisse14adba72017-03-20 03:52:39 -0700780 return rtp_sender_->SetAudioLevel(level_d_bov);
niklase@google.com470e71d2011-07-07 08:21:25 +0000781}
782
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000783int32_t ModuleRtpRtcpImpl::SetKeyFrameRequestMethod(
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000784 const KeyFrameRequestMethod method) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000785 key_frame_req_method_ = method;
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000786 return 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000787}
788
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000789int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000790 switch (key_frame_req_method_) {
niklase@google.com470e71d2011-07-07 08:21:25 +0000791 case kKeyFrameReqPliRtcp:
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000792 return SendRTCP(kRtcpPli);
pwestin@webrtc.org5e954812012-02-10 12:13:12 +0000793 case kKeyFrameReqFirRtcp:
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000794 return SendRTCP(kRtcpFir);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000795 }
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000796 return -1;
niklase@google.com470e71d2011-07-07 08:21:25 +0000797}
798
brandtrf1bb4762016-11-07 03:05:06 -0800799void ModuleRtpRtcpImpl::SetUlpfecConfig(int red_payload_type,
brandtrd8048952016-11-07 02:08:51 -0800800 int ulpfec_payload_type) {
nisse14adba72017-03-20 03:52:39 -0700801 rtp_sender_->SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000802}
803
brandtr1743a192016-11-07 03:36:05 -0800804bool ModuleRtpRtcpImpl::SetFecParameters(
805 const FecProtectionParams& delta_params,
806 const FecProtectionParams& key_params) {
nisse14adba72017-03-20 03:52:39 -0700807 return rtp_sender_->SetFecParameters(delta_params, key_params);
marpan@google.com80c5d7a2011-07-15 21:32:40 +0000808}
809
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000810void ModuleRtpRtcpImpl::SetRemoteSSRC(const uint32_t ssrc) {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000811 // Inform about the incoming SSRC.
812 rtcp_sender_.SetRemoteSSRC(ssrc);
813 rtcp_receiver_.SetRemoteSSRC(ssrc);
niklase@google.com470e71d2011-07-07 08:21:25 +0000814}
815
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000816void ModuleRtpRtcpImpl::BitrateSent(uint32_t* total_rate,
817 uint32_t* video_rate,
818 uint32_t* fec_rate,
819 uint32_t* nack_rate) const {
nisse14adba72017-03-20 03:52:39 -0700820 *total_rate = rtp_sender_->BitrateSent();
821 *video_rate = rtp_sender_->VideoBitrateSent();
822 *fec_rate = rtp_sender_->FecOverheadRate();
823 *nack_rate = rtp_sender_->NackOverheadRate();
niklase@google.com470e71d2011-07-07 08:21:25 +0000824}
825
pwestin@webrtc.org1da1ce02011-10-13 15:19:55 +0000826void ModuleRtpRtcpImpl::OnRequestSendReport() {
wu@webrtc.org822fbd82013-08-15 23:38:54 +0000827 SendRTCP(kRtcpSr);
niklase@google.com470e71d2011-07-07 08:21:25 +0000828}
829
Danil Chapovalov2800d742016-08-26 18:48:46 +0200830void ModuleRtpRtcpImpl::OnReceivedNack(
831 const std::vector<uint16_t>& nack_sequence_numbers) {
nisse14adba72017-03-20 03:52:39 -0700832 if (!rtp_sender_)
833 return;
834
bcornell30409b42015-07-10 18:10:05 -0700835 for (uint16_t nack_sequence_number : nack_sequence_numbers) {
836 send_loss_stats_.AddLostPacket(nack_sequence_number);
837 }
Yves Gerey665174f2018-06-19 15:03:05 +0200838 if (!rtp_sender_->StorePackets() || nack_sequence_numbers.size() == 0) {
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000839 return;
840 }
asapersson@webrtc.orge7b1e112013-12-16 14:40:36 +0000841 // Use RTT from RtcpRttStats class if provided.
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000842 int64_t rtt = rtt_ms();
asapersson@webrtc.orge7b1e112013-12-16 14:40:36 +0000843 if (rtt == 0) {
844 rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
845 }
nisse14adba72017-03-20 03:52:39 -0700846 rtp_sender_->OnReceivedNack(nack_sequence_numbers, rtt);
niklase@google.com470e71d2011-07-07 08:21:25 +0000847}
848
isheriff6b4b5f32016-06-08 00:24:21 -0700849void ModuleRtpRtcpImpl::OnReceivedRtcpReportBlocks(
850 const ReportBlockList& report_blocks) {
nisse14adba72017-03-20 03:52:39 -0700851 if (rtp_sender_)
852 rtp_sender_->OnReceivedRtcpReportBlocks(report_blocks);
isheriff6b4b5f32016-06-08 00:24:21 -0700853}
854
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000855bool ModuleRtpRtcpImpl::LastReceivedNTP(
856 uint32_t* rtcp_arrival_time_secs, // When we got the last report.
857 uint32_t* rtcp_arrival_time_frac,
858 uint32_t* remote_sr) const {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000859 // Remote SR: NTP inside the last received (mid 16 bits from sec and frac).
pbos@webrtc.org2f446732013-04-08 11:08:41 +0000860 uint32_t ntp_secs = 0;
861 uint32_t ntp_frac = 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000862
Yves Gerey665174f2018-06-19 15:03:05 +0200863 if (!rtcp_receiver_.NTP(&ntp_secs, &ntp_frac, rtcp_arrival_time_secs,
864 rtcp_arrival_time_frac, NULL)) {
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000865 return false;
henrike@webrtc.orgd5657c22012-02-08 23:41:49 +0000866 }
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000867 *remote_sr =
868 ((ntp_secs & 0x0000ffff) << 16) + ((ntp_frac & 0xffff0000) >> 16);
869 return true;
niklase@google.com470e71d2011-07-07 08:21:25 +0000870}
871
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000872// Called from RTCPsender.
danilchap2b616392016-08-18 06:17:42 -0700873std::vector<rtcp::TmmbItem> ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner) {
874 return rtcp_receiver_.BoundingSet(tmmbr_owner);
niklase@google.com470e71d2011-07-07 08:21:25 +0000875}
mflodman@webrtc.org2f225ca2013-01-09 13:54:43 +0000876
877int64_t ModuleRtpRtcpImpl::RtcpReportInterval() {
phoglund@webrtc.orgacfdd962013-01-16 10:27:33 +0000878 if (audio_)
Jiawei Ou3587b832018-01-31 22:08:26 -0800879 return rtcp_sender_.RtcpAudioReportInverval();
mflodman@webrtc.org2f225ca2013-01-09 13:54:43 +0000880 else
Jiawei Ou3587b832018-01-31 22:08:26 -0800881 return rtcp_sender_.RtcpVideoReportInverval();
mflodman@webrtc.org2f225ca2013-01-09 13:54:43 +0000882}
stefan@webrtc.org28a331e2013-09-17 07:49:56 +0000883
884void ModuleRtpRtcpImpl::SetRtcpReceiverSsrcs(uint32_t main_ssrc) {
885 std::set<uint32_t> ssrcs;
886 ssrcs.insert(main_ssrc);
nisse14adba72017-03-20 03:52:39 -0700887 if (RtxSendStatus() != kRtxOff)
888 ssrcs.insert(rtp_sender_->RtxSsrc());
Danil Chapovalovd264df52018-06-14 12:59:38 +0200889 absl::optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
brandtr7c7796b2017-07-03 06:02:53 -0700890 if (flexfec_ssrc)
891 ssrcs.insert(*flexfec_ssrc);
stefan@webrtc.org28a331e2013-09-17 07:49:56 +0000892 rtcp_receiver_.SetSsrcs(main_ssrc, ssrcs);
893}
894
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000895void ModuleRtpRtcpImpl::set_rtt_ms(int64_t rtt_ms) {
danilchap7c9426c2016-04-14 03:05:31 -0700896 rtc::CritScope cs(&critical_section_rtt_);
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11 +0000897 rtt_ms_ = rtt_ms;
Erik Språng8b101922018-01-18 11:58:05 -0800898 if (rtp_sender_)
899 rtp_sender_->SetRtt(rtt_ms);
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11 +0000900}
901
pkasting@chromium.org16825b12015-01-12 21:51:21 +0000902int64_t ModuleRtpRtcpImpl::rtt_ms() const {
danilchap7c9426c2016-04-14 03:05:31 -0700903 rtc::CritScope cs(&critical_section_rtt_);
asapersson@webrtc.org1ae1d0c2013-11-20 12:46:11 +0000904 return rtt_ms_;
905}
906
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000907void ModuleRtpRtcpImpl::RegisterSendChannelRtpStatisticsCallback(
908 StreamDataCountersCallback* callback) {
nisse14adba72017-03-20 03:52:39 -0700909 rtp_sender_->RegisterRtpStatisticsCallback(callback);
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000910}
911
912StreamDataCountersCallback*
Yves Gerey665174f2018-06-19 15:03:05 +0200913ModuleRtpRtcpImpl::GetSendChannelRtpStatisticsCallback() const {
nisse14adba72017-03-20 03:52:39 -0700914 return rtp_sender_->GetRtpStatisticsCallback();
sprang@webrtc.orgebad7652013-12-05 14:29:02 +0000915}
sprang5e38c962016-12-01 05:18:09 -0800916
917void ModuleRtpRtcpImpl::SetVideoBitrateAllocation(
Erik Språng566124a2018-04-23 12:32:22 +0200918 const VideoBitrateAllocation& bitrate) {
sprang5e38c962016-12-01 05:18:09 -0800919 rtcp_sender_.SetVideoBitrateAllocation(bitrate);
920}
mflodman@webrtc.org02270cd2015-02-06 13:10:19 +0000921} // namespace webrtc