blob: d6ea7f70be929fc2a23255c6613a48a45c27b55e [file] [log] [blame]
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +00001/*
henrike@webrtc.orgd6d014f2012-02-16 02:18:09 +00002 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +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
kwiberg84be5112016-04-27 01:19:58 -070011#include <memory>
12
Mirko Bonadei71207422017-09-15 13:58:09 +020013#include "common_types.h" // NOLINT(build/include)
Ilya Nikolaevskiy88c2c502018-10-26 16:00:08 +020014#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020015#include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
16#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
17#include "modules/rtp_rtcp/source/rtcp_sender.h"
Niels Möller1f3206c2018-09-14 08:26:32 +020018#include "modules/rtp_rtcp/source/rtp_packet_received.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020019#include "modules/rtp_rtcp/source/rtp_rtcp_impl.h"
Ilya Nikolaevskiy88c2c502018-10-26 16:00:08 +020020#include "modules/rtp_rtcp/source/time_util.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020021#include "rtc_base/rate_limiter.h"
22#include "test/gmock.h"
23#include "test/gtest.h"
24#include "test/mock_transport.h"
25#include "test/rtcp_packet_parser.h"
asapersson22ff75a2015-08-21 00:02:47 -070026
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -080027using ::testing::_;
asapersson22ff75a2015-08-21 00:02:47 -070028using ::testing::ElementsAre;
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -080029using ::testing::Invoke;
Mirta Dvornicicb1f063d2018-04-16 11:16:21 +020030using ::testing::SizeIs;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000031
32namespace webrtc {
33
asapersson22ff75a2015-08-21 00:02:47 -070034class RtcpPacketTypeCounterObserverImpl : public RtcpPacketTypeCounterObserver {
35 public:
36 RtcpPacketTypeCounterObserverImpl() : ssrc_(0) {}
Danil Chapovalovdd7e2842018-03-09 15:37:03 +000037 ~RtcpPacketTypeCounterObserverImpl() override = default;
asapersson22ff75a2015-08-21 00:02:47 -070038 void RtcpPacketTypesCounterUpdated(
39 uint32_t ssrc,
40 const RtcpPacketTypeCounter& packet_counter) override {
41 ssrc_ = ssrc;
42 counter_ = packet_counter;
43 }
44 uint32_t ssrc_;
45 RtcpPacketTypeCounter counter_;
46};
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000047
Niels Möller8fb57462018-11-13 10:08:33 +010048class TestTransport : public Transport {
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000049 public:
asapersson22ff75a2015-08-21 00:02:47 -070050 TestTransport() {}
51
stefan1d8a5062015-10-02 03:39:33 -070052 bool SendRtp(const uint8_t* /*data*/,
53 size_t /*len*/,
54 const PacketOptions& options) override {
pbos2d566682015-09-28 09:59:31 -070055 return false;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000056 }
pbos2d566682015-09-28 09:59:31 -070057 bool SendRtcp(const uint8_t* data, size_t len) override {
Danil Chapovalovba6f7be2016-09-02 18:29:10 +020058 parser_.Parse(data, len);
pbos2d566682015-09-28 09:59:31 -070059 return true;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000060 }
asapersson22ff75a2015-08-21 00:02:47 -070061 test::RtcpPacketParser parser_;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000062};
63
Erik Språnga38233a2015-07-24 09:58:18 +020064namespace {
asapersson22ff75a2015-08-21 00:02:47 -070065static const uint32_t kSenderSsrc = 0x11111111;
66static const uint32_t kRemoteSsrc = 0x22222222;
Danil Chapovalov70ffead2016-07-20 15:26:59 +020067static const uint32_t kStartRtpTimestamp = 0x34567;
68static const uint32_t kRtpTimestamp = 0x45678;
Yves Gerey665174f2018-06-19 15:03:05 +020069} // namespace
Erik Språnga38233a2015-07-24 09:58:18 +020070
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000071class RtcpSenderTest : public ::testing::Test {
72 protected:
stefan@webrtc.org9354cc92012-06-07 08:10:14 +000073 RtcpSenderTest()
asapersson22ff75a2015-08-21 00:02:47 -070074 : clock_(1335900000),
Erik Språng737336d2016-07-29 12:59:36 +020075 receive_statistics_(ReceiveStatistics::Create(&clock_)),
76 retransmission_rate_limiter_(&clock_, 1000) {
pwestin@webrtc.org2853dde2012-05-11 11:08:54 +000077 RtpRtcp::Configuration configuration;
pwestin@webrtc.org2853dde2012-05-11 11:08:54 +000078 configuration.audio = false;
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +000079 configuration.clock = &clock_;
asapersson22ff75a2015-08-21 00:02:47 -070080 configuration.outgoing_transport = &test_transport_;
Erik Språng737336d2016-07-29 12:59:36 +020081 configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
Jiawei Ou8b5d9d82018-11-15 16:44:37 -080082 configuration.rtcp_report_interval_ms = 1000;
pwestin@webrtc.org2853dde2012-05-11 11:08:54 +000083
asapersson22ff75a2015-08-21 00:02:47 -070084 rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration));
sprang86fd9ed2015-09-29 04:45:43 -070085 rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
Jiawei Ou3587b832018-01-31 22:08:26 -080086 nullptr, nullptr, &test_transport_,
Jiawei Ou8b5d9d82018-11-15 16:44:37 -080087 configuration.rtcp_report_interval_ms));
asapersson22ff75a2015-08-21 00:02:47 -070088 rtcp_sender_->SetSSRC(kSenderSsrc);
89 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
danilchap71fead22016-08-18 02:01:49 -070090 rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
Ilya Nikolaevskiy5e58bcb2018-10-24 13:34:32 +020091 rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
92 /*paylpad_type=*/0);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +000093 }
Erik Språnga38233a2015-07-24 09:58:18 +020094
asapersson22ff75a2015-08-21 00:02:47 -070095 void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) {
Niels Möller1f3206c2018-09-14 08:26:32 +020096 RtpPacketReceived packet;
97 packet.SetSsrc(remote_ssrc);
98 packet.SetSequenceNumber(seq_num);
99 packet.SetTimestamp(12345);
100 packet.SetPayloadSize(100 - 12);
101 receive_statistics_->OnRtpPacket(packet);
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000102 }
103
asapersson22ff75a2015-08-21 00:02:47 -0700104 test::RtcpPacketParser* parser() { return &test_transport_.parser_; }
105
106 RTCPSender::FeedbackState feedback_state() {
107 return rtp_rtcp_impl_->GetFeedbackState();
hta@webrtc.org9d54cd12012-04-30 08:24:55 +0000108 }
109
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +0000110 SimulatedClock clock_;
asapersson22ff75a2015-08-21 00:02:47 -0700111 TestTransport test_transport_;
kwiberg84be5112016-04-27 01:19:58 -0700112 std::unique_ptr<ReceiveStatistics> receive_statistics_;
113 std::unique_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_;
114 std::unique_ptr<RTCPSender> rtcp_sender_;
Erik Språng737336d2016-07-29 12:59:36 +0200115 RateLimiter retransmission_rate_limiter_;
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000116};
117
asapersson22ff75a2015-08-21 00:02:47 -0700118TEST_F(RtcpSenderTest, SetRtcpStatus) {
pbosda903ea2015-10-02 02:36:56 -0700119 EXPECT_EQ(RtcpMode::kOff, rtcp_sender_->Status());
120 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
121 EXPECT_EQ(RtcpMode::kReducedSize, rtcp_sender_->Status());
asapersson22ff75a2015-08-21 00:02:47 -0700122}
123
124TEST_F(RtcpSenderTest, SetSendingStatus) {
125 EXPECT_FALSE(rtcp_sender_->Sending());
126 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
127 EXPECT_TRUE(rtcp_sender_->Sending());
128}
129
130TEST_F(RtcpSenderTest, NoPacketSentIfOff) {
pbosda903ea2015-10-02 02:36:56 -0700131 rtcp_sender_->SetRTCPStatus(RtcpMode::kOff);
asapersson22ff75a2015-08-21 00:02:47 -0700132 EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000133}
134
asapersson22ff75a2015-08-21 00:02:47 -0700135TEST_F(RtcpSenderTest, SendSr) {
136 const uint32_t kPacketCount = 0x12345;
137 const uint32_t kOctetCount = 0x23456;
pbosda903ea2015-10-02 02:36:56 -0700138 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000139 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200140 rtcp_sender_->SetSendingStatus(feedback_state, true);
asapersson22ff75a2015-08-21 00:02:47 -0700141 feedback_state.packets_sent = kPacketCount;
142 feedback_state.media_bytes_sent = kOctetCount;
Ilya Nikolaevskiy88c2c502018-10-26 16:00:08 +0200143 NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
asapersson22ff75a2015-08-21 00:02:47 -0700144 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
145 EXPECT_EQ(1, parser()->sender_report()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200146 EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc());
danilchap21dc1892017-03-07 02:51:09 -0800147 EXPECT_EQ(ntp, parser()->sender_report()->ntp());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200148 EXPECT_EQ(kPacketCount, parser()->sender_report()->sender_packet_count());
149 EXPECT_EQ(kOctetCount, parser()->sender_report()->sender_octet_count());
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200150 EXPECT_EQ(kStartRtpTimestamp + kRtpTimestamp,
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200151 parser()->sender_report()->rtp_timestamp());
152 EXPECT_EQ(0U, parser()->sender_report()->report_blocks().size());
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000153}
154
Ilya Nikolaevskiy88c2c502018-10-26 16:00:08 +0200155TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) {
156 const uint32_t kPacketCount = 0x12345;
157 const uint32_t kOctetCount = 0x23456;
158 const int kTimeBetweenSRsUs = 10043; // Not exact value in milliseconds.
159 const int kExtraPackets = 30;
160 // Make sure clock is not exactly at some milliseconds point.
161 clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
162 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
163 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
164 rtcp_sender_->SetSendingStatus(feedback_state, true);
165 feedback_state.packets_sent = kPacketCount;
166 feedback_state.media_bytes_sent = kOctetCount;
167
168 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
169 EXPECT_EQ(1, parser()->sender_report()->num_packets());
170 NtpTime ntp1 = parser()->sender_report()->ntp();
171 uint32_t rtp1 = parser()->sender_report()->rtp_timestamp();
172
173 // Send more SRs to ensure slope is always exact for different offsets
174 for (int packets = 1; packets <= kExtraPackets; ++packets) {
175 clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
176 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
177 EXPECT_EQ(packets + 1, parser()->sender_report()->num_packets());
178
179 NtpTime ntp2 = parser()->sender_report()->ntp();
180 uint32_t rtp2 = parser()->sender_report()->rtp_timestamp();
181
182 uint32_t ntp_diff_in_rtp_units =
183 (ntp2.ToMs() - ntp1.ToMs()) * (kVideoPayloadTypeFrequency / 1000);
184 EXPECT_EQ(rtp2 - rtp1, ntp_diff_in_rtp_units);
185 }
186}
187
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200188TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
189 rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
Jiawei Ou8b5d9d82018-11-15 16:44:37 -0800190 nullptr, nullptr, &test_transport_, 1000));
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200191 rtcp_sender_->SetSSRC(kSenderSsrc);
192 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
193 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
194 rtcp_sender_->SetSendingStatus(feedback_state(), true);
195
196 // Sender Report shouldn't be send as an SR nor as a Report.
197 rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr);
198 EXPECT_EQ(0, parser()->sender_report()->num_packets());
199 rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
200 EXPECT_EQ(0, parser()->sender_report()->num_packets());
201 // Other packets (e.g. Pli) are allowed, even if useless.
202 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
203 EXPECT_EQ(1, parser()->pli()->num_packets());
204}
205
206TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) {
207 rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
Jiawei Ou8b5d9d82018-11-15 16:44:37 -0800208 nullptr, nullptr, &test_transport_, 1000));
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200209 rtcp_sender_->SetSSRC(kSenderSsrc);
210 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
211 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
212 rtcp_sender_->SetSendingStatus(feedback_state(), true);
213
214 // In compound mode no packets are allowed (e.g. Pli) because compound mode
215 // should start with Sender Report.
216 EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
217 EXPECT_EQ(0, parser()->pli()->num_packets());
218}
219
asapersson22ff75a2015-08-21 00:02:47 -0700220TEST_F(RtcpSenderTest, SendRr) {
pbosda903ea2015-10-02 02:36:56 -0700221 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700222 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
223 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200224 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
225 EXPECT_EQ(0U, parser()->receiver_report()->report_blocks().size());
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000226}
227
asapersson22ff75a2015-08-21 00:02:47 -0700228TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
229 const uint16_t kSeqNum = 11111;
230 InsertIncomingPacket(kRemoteSsrc, kSeqNum);
pbosda903ea2015-10-02 02:36:56 -0700231 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
asapersson22ff75a2015-08-21 00:02:47 -0700232 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
233 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200234 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
235 ASSERT_EQ(1U, parser()->receiver_report()->report_blocks().size());
236 const rtcp::ReportBlock& rb = parser()->receiver_report()->report_blocks()[0];
237 EXPECT_EQ(kRemoteSsrc, rb.source_ssrc());
238 EXPECT_EQ(0U, rb.fraction_lost());
Harald Alvestrand70206d62017-12-08 08:59:07 +0100239 EXPECT_EQ(0, rb.cumulative_lost_signed());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200240 EXPECT_EQ(kSeqNum, rb.extended_high_seq_num());
asapersson22ff75a2015-08-21 00:02:47 -0700241}
242
243TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
244 const uint16_t kSeqNum = 11111;
245 InsertIncomingPacket(kRemoteSsrc, kSeqNum);
246 InsertIncomingPacket(kRemoteSsrc + 1, kSeqNum + 1);
pbosda903ea2015-10-02 02:36:56 -0700247 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
asapersson22ff75a2015-08-21 00:02:47 -0700248 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
249 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200250 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
251 EXPECT_EQ(2U, parser()->receiver_report()->report_blocks().size());
252 EXPECT_EQ(kRemoteSsrc,
253 parser()->receiver_report()->report_blocks()[0].source_ssrc());
254 EXPECT_EQ(kRemoteSsrc + 1,
255 parser()->receiver_report()->report_blocks()[1].source_ssrc());
asapersson22ff75a2015-08-21 00:02:47 -0700256}
257
258TEST_F(RtcpSenderTest, SendSdes) {
pbosda903ea2015-10-02 02:36:56 -0700259 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700260 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
261 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
262 EXPECT_EQ(1, parser()->sdes()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200263 EXPECT_EQ(1U, parser()->sdes()->chunks().size());
264 EXPECT_EQ(kSenderSsrc, parser()->sdes()->chunks()[0].ssrc);
265 EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname);
asapersson22ff75a2015-08-21 00:02:47 -0700266}
267
danilchap74e8df8f2017-03-16 08:04:08 -0700268TEST_F(RtcpSenderTest, SendSdesWithMaxChunks) {
269 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
270 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
271 const char cname[] = "smith@host";
272 for (size_t i = 0; i < 30; ++i) {
273 const uint32_t csrc = 0x1234 + i;
274 EXPECT_EQ(0, rtcp_sender_->AddMixedCNAME(csrc, cname));
275 }
276 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
277 EXPECT_EQ(1, parser()->sdes()->num_packets());
278 EXPECT_EQ(31U, parser()->sdes()->chunks().size());
279}
280
asapersson22ff75a2015-08-21 00:02:47 -0700281TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
pbosda903ea2015-10-02 02:36:56 -0700282 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
asapersson22ff75a2015-08-21 00:02:47 -0700283 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
284 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
285 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
286 EXPECT_EQ(1, parser()->sdes()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200287 EXPECT_EQ(1U, parser()->sdes()->chunks().size());
asapersson22ff75a2015-08-21 00:02:47 -0700288}
289
290TEST_F(RtcpSenderTest, SendBye) {
pbosda903ea2015-10-02 02:36:56 -0700291 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700292 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
293 EXPECT_EQ(1, parser()->bye()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200294 EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
asapersson22ff75a2015-08-21 00:02:47 -0700295}
296
297TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
pbosda903ea2015-10-02 02:36:56 -0700298 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700299 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
300 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
301 EXPECT_EQ(1, parser()->bye()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200302 EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
asapersson22ff75a2015-08-21 00:02:47 -0700303}
304
305TEST_F(RtcpSenderTest, SendApp) {
306 const uint8_t kSubType = 30;
307 uint32_t name = 'n' << 24;
308 name += 'a' << 16;
309 name += 'm' << 8;
310 name += 'e';
311 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
asapersson22ff75a2015-08-21 00:02:47 -0700312 EXPECT_EQ(0, rtcp_sender_->SetApplicationSpecificData(kSubType, name, kData,
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200313 sizeof(kData)));
pbosda903ea2015-10-02 02:36:56 -0700314 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700315 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
316 EXPECT_EQ(1, parser()->app()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200317 EXPECT_EQ(kSubType, parser()->app()->sub_type());
318 EXPECT_EQ(name, parser()->app()->name());
319 EXPECT_EQ(sizeof(kData), parser()->app()->data_size());
320 EXPECT_EQ(0, memcmp(kData, parser()->app()->data(), sizeof(kData)));
asapersson22ff75a2015-08-21 00:02:47 -0700321}
322
Erik Språng521875a2015-09-01 10:11:16 +0200323TEST_F(RtcpSenderTest, SendEmptyApp) {
324 const uint8_t kSubType = 30;
325 const uint32_t kName = 0x6E616D65;
326
327 EXPECT_EQ(
328 0, rtcp_sender_->SetApplicationSpecificData(kSubType, kName, nullptr, 0));
329
pbosda903ea2015-10-02 02:36:56 -0700330 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
Erik Språng521875a2015-09-01 10:11:16 +0200331 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
332 EXPECT_EQ(1, parser()->app()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200333 EXPECT_EQ(kSubType, parser()->app()->sub_type());
334 EXPECT_EQ(kName, parser()->app()->name());
335 EXPECT_EQ(0U, parser()->app()->data_size());
Erik Språng521875a2015-09-01 10:11:16 +0200336}
337
asapersson22ff75a2015-08-21 00:02:47 -0700338TEST_F(RtcpSenderTest, SetInvalidApplicationSpecificData) {
339 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't'};
340 const uint16_t kInvalidDataLength = sizeof(kData) / sizeof(kData[0]);
Yves Gerey665174f2018-06-19 15:03:05 +0200341 EXPECT_EQ(-1,
342 rtcp_sender_->SetApplicationSpecificData(
343 0, 0, kData, kInvalidDataLength)); // Should by multiple of 4.
asapersson22ff75a2015-08-21 00:02:47 -0700344}
345
danilchap498ee8e2017-02-08 05:24:31 -0800346TEST_F(RtcpSenderTest, SendFir) {
pbosda903ea2015-10-02 02:36:56 -0700347 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700348 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
349 EXPECT_EQ(1, parser()->fir()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200350 EXPECT_EQ(kSenderSsrc, parser()->fir()->sender_ssrc());
351 EXPECT_EQ(1U, parser()->fir()->requests().size());
352 EXPECT_EQ(kRemoteSsrc, parser()->fir()->requests()[0].ssrc);
353 uint8_t seq = parser()->fir()->requests()[0].seq_nr;
asapersson22ff75a2015-08-21 00:02:47 -0700354 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
355 EXPECT_EQ(2, parser()->fir()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200356 EXPECT_EQ(seq + 1, parser()->fir()->requests()[0].seq_nr);
asapersson22ff75a2015-08-21 00:02:47 -0700357}
358
asapersson22ff75a2015-08-21 00:02:47 -0700359TEST_F(RtcpSenderTest, SendPli) {
pbosda903ea2015-10-02 02:36:56 -0700360 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700361 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
362 EXPECT_EQ(1, parser()->pli()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200363 EXPECT_EQ(kSenderSsrc, parser()->pli()->sender_ssrc());
364 EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc());
asapersson22ff75a2015-08-21 00:02:47 -0700365}
366
asapersson22ff75a2015-08-21 00:02:47 -0700367TEST_F(RtcpSenderTest, SendNack) {
pbosda903ea2015-10-02 02:36:56 -0700368 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700369 const uint16_t kList[] = {0, 1, 16};
370 const int32_t kListLength = sizeof(kList) / sizeof(kList[0]);
371 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack, kListLength,
372 kList));
373 EXPECT_EQ(1, parser()->nack()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200374 EXPECT_EQ(kSenderSsrc, parser()->nack()->sender_ssrc());
375 EXPECT_EQ(kRemoteSsrc, parser()->nack()->media_ssrc());
376 EXPECT_THAT(parser()->nack()->packet_ids(), ElementsAre(0, 1, 16));
asapersson22ff75a2015-08-21 00:02:47 -0700377}
378
Elad Alon7d6a4c02019-02-25 13:00:51 +0100379TEST_F(RtcpSenderTest, SendLossNotification) {
380 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
381 constexpr uint16_t kLastDecoded = 0x1234;
382 constexpr uint16_t kLastReceived = 0x4321;
383 constexpr bool kDecodabilityFlag = true;
384 const int32_t result = rtcp_sender_->SendLossNotification(
385 feedback_state(), kLastDecoded, kLastReceived, kDecodabilityFlag);
386 EXPECT_EQ(result, 0);
387 EXPECT_EQ(1, parser()->loss_notification()->num_packets());
388 EXPECT_EQ(kSenderSsrc, parser()->loss_notification()->sender_ssrc());
389 EXPECT_EQ(kRemoteSsrc, parser()->loss_notification()->media_ssrc());
390}
391
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200392TEST_F(RtcpSenderTest, RembNotIncludedBeforeSet) {
393 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
394
395 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
396
397 ASSERT_EQ(1, parser()->receiver_report()->num_packets());
398 EXPECT_EQ(0, parser()->remb()->num_packets());
399}
400
401TEST_F(RtcpSenderTest, RembNotIncludedAfterUnset) {
danilchapba6aa902017-04-18 06:57:02 -0700402 const uint64_t kBitrate = 261011;
403 const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
404 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200405 rtcp_sender_->SetRemb(kBitrate, kSsrcs);
danilchapba6aa902017-04-18 06:57:02 -0700406 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
407 ASSERT_EQ(1, parser()->receiver_report()->num_packets());
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200408 EXPECT_EQ(1, parser()->remb()->num_packets());
danilchapba6aa902017-04-18 06:57:02 -0700409
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200410 // Turn off REMB. rtcp_sender no longer should send it.
411 rtcp_sender_->UnsetRemb();
danilchapba6aa902017-04-18 06:57:02 -0700412 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
413 ASSERT_EQ(2, parser()->receiver_report()->num_packets());
414 EXPECT_EQ(1, parser()->remb()->num_packets());
Danil Chapovalov857a8fb2016-09-06 11:41:46 +0200415}
416
asapersson22ff75a2015-08-21 00:02:47 -0700417TEST_F(RtcpSenderTest, SendRemb) {
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200418 const uint64_t kBitrate = 261011;
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200419 const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
pbosda903ea2015-10-02 02:36:56 -0700420 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200421 rtcp_sender_->SetRemb(kBitrate, kSsrcs);
422
423 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb);
424
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200425 EXPECT_EQ(1, parser()->remb()->num_packets());
426 EXPECT_EQ(kSenderSsrc, parser()->remb()->sender_ssrc());
427 EXPECT_EQ(kBitrate, parser()->remb()->bitrate_bps());
428 EXPECT_THAT(parser()->remb()->ssrcs(),
asapersson22ff75a2015-08-21 00:02:47 -0700429 ElementsAre(kRemoteSsrc, kRemoteSsrc + 1));
430}
431
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200432TEST_F(RtcpSenderTest, RembIncludedInEachCompoundPacketAfterSet) {
asapersson22ff75a2015-08-21 00:02:47 -0700433 const int kBitrate = 261011;
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200434 const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
pbosda903ea2015-10-02 02:36:56 -0700435 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200436 rtcp_sender_->SetRemb(kBitrate, kSsrcs);
437
438 rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200439 EXPECT_EQ(1, parser()->remb()->num_packets());
asapersson22ff75a2015-08-21 00:02:47 -0700440 // REMB should be included in each compound packet.
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200441 rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200442 EXPECT_EQ(2, parser()->remb()->num_packets());
asapersson22ff75a2015-08-21 00:02:47 -0700443}
444
asapersson22ff75a2015-08-21 00:02:47 -0700445TEST_F(RtcpSenderTest, SendXrWithDlrr) {
pbosda903ea2015-10-02 02:36:56 -0700446 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
pbos@webrtc.org2f4b14e2014-07-15 15:25:39 +0000447 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
danilchap798896a2016-09-28 02:54:25 -0700448 rtcp::ReceiveTimeInfo last_xr_rr;
449 last_xr_rr.ssrc = 0x11111111;
450 last_xr_rr.last_rr = 0x22222222;
451 last_xr_rr.delay_since_last_rr = 0x33333333;
Mirta Dvornicicb1f063d2018-04-16 11:16:21 +0200452 feedback_state.last_xr_rtis.push_back(last_xr_rr);
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +0000453 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200454 EXPECT_EQ(1, parser()->xr()->num_packets());
455 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
Mirta Dvornicicb1f063d2018-04-16 11:16:21 +0200456 ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(1));
danilchap80ac24d2016-10-31 08:40:47 -0700457 EXPECT_EQ(last_xr_rr.ssrc, parser()->xr()->dlrr().sub_blocks()[0].ssrc);
458 EXPECT_EQ(last_xr_rr.last_rr, parser()->xr()->dlrr().sub_blocks()[0].last_rr);
danilchap798896a2016-09-28 02:54:25 -0700459 EXPECT_EQ(last_xr_rr.delay_since_last_rr,
danilchap80ac24d2016-10-31 08:40:47 -0700460 parser()->xr()->dlrr().sub_blocks()[0].delay_since_last_rr);
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +0000461}
462
Mirta Dvornicicb1f063d2018-04-16 11:16:21 +0200463TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
464 const size_t kNumReceivers = 2;
465 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
466 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
467 for (size_t i = 0; i < kNumReceivers; ++i) {
468 rtcp::ReceiveTimeInfo last_xr_rr;
469 last_xr_rr.ssrc = i;
470 last_xr_rr.last_rr = (i + 1) * 100;
471 last_xr_rr.delay_since_last_rr = (i + 2) * 200;
472 feedback_state.last_xr_rtis.push_back(last_xr_rr);
473 }
474
475 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
476 EXPECT_EQ(1, parser()->xr()->num_packets());
477 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
478 ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(kNumReceivers));
479 for (size_t i = 0; i < kNumReceivers; ++i) {
480 EXPECT_EQ(feedback_state.last_xr_rtis[i].ssrc,
481 parser()->xr()->dlrr().sub_blocks()[i].ssrc);
482 EXPECT_EQ(feedback_state.last_xr_rtis[i].last_rr,
483 parser()->xr()->dlrr().sub_blocks()[i].last_rr);
484 EXPECT_EQ(feedback_state.last_xr_rtis[i].delay_since_last_rr,
485 parser()->xr()->dlrr().sub_blocks()[i].delay_since_last_rr);
486 }
487}
488
asapersson22ff75a2015-08-21 00:02:47 -0700489TEST_F(RtcpSenderTest, SendXrWithRrtr) {
pbosda903ea2015-10-02 02:36:56 -0700490 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
asapersson22ff75a2015-08-21 00:02:47 -0700491 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +0000492 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
Ilya Nikolaevskiy88c2c502018-10-26 16:00:08 +0200493 NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
asapersson22ff75a2015-08-21 00:02:47 -0700494 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200495 EXPECT_EQ(1, parser()->xr()->num_packets());
496 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
danilchap80ac24d2016-10-31 08:40:47 -0700497 EXPECT_FALSE(parser()->xr()->dlrr());
danilchap80ac24d2016-10-31 08:40:47 -0700498 ASSERT_TRUE(parser()->xr()->rrtr());
danilchap21dc1892017-03-07 02:51:09 -0800499 EXPECT_EQ(ntp, parser()->xr()->rrtr()->ntp());
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +0000500}
501
asapersson22ff75a2015-08-21 00:02:47 -0700502TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
pbosda903ea2015-10-02 02:36:56 -0700503 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
asapersson22ff75a2015-08-21 00:02:47 -0700504 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
505 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
506 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200507 EXPECT_EQ(0, parser()->xr()->num_packets());
asapersson22ff75a2015-08-21 00:02:47 -0700508}
509
510TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
pbosda903ea2015-10-02 02:36:56 -0700511 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
asapersson22ff75a2015-08-21 00:02:47 -0700512 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +0000513 rtcp_sender_->SendRtcpXrReceiverReferenceTime(false);
asapersson22ff75a2015-08-21 00:02:47 -0700514 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200515 EXPECT_EQ(0, parser()->xr()->num_packets());
asapersson@webrtc.org8469f7b2013-10-02 13:15:34 +0000516}
517
asapersson22ff75a2015-08-21 00:02:47 -0700518TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
519 RtcpPacketTypeCounterObserverImpl observer;
sprang86fd9ed2015-09-29 04:45:43 -0700520 rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
Jiawei Ou3587b832018-01-31 22:08:26 -0800521 &observer, nullptr, &test_transport_,
Jiawei Ou8b5d9d82018-11-15 16:44:37 -0800522 1000));
asapersson22ff75a2015-08-21 00:02:47 -0700523 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
pbosda903ea2015-10-02 02:36:56 -0700524 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700525 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
526 EXPECT_EQ(1, parser()->pli()->num_packets());
527 EXPECT_EQ(kRemoteSsrc, observer.ssrc_);
528 EXPECT_EQ(1U, observer.counter_.pli_packets);
529 EXPECT_EQ(clock_.TimeInMilliseconds(),
530 observer.counter_.first_packet_time_ms);
531}
532
533TEST_F(RtcpSenderTest, SendTmmbr) {
534 const unsigned int kBitrateBps = 312000;
pbosda903ea2015-10-02 02:36:56 -0700535 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
asapersson22ff75a2015-08-21 00:02:47 -0700536 rtcp_sender_->SetTargetBitrate(kBitrateBps);
537 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr));
538 EXPECT_EQ(1, parser()->tmmbr()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200539 EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->sender_ssrc());
540 EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
541 EXPECT_EQ(kBitrateBps, parser()->tmmbr()->requests()[0].bitrate_bps());
asapersson22ff75a2015-08-21 00:02:47 -0700542 // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero.
543}
544
545TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
546 const unsigned int kBitrateBps = 312000;
pbosda903ea2015-10-02 02:36:56 -0700547 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
asapersson22ff75a2015-08-21 00:02:47 -0700548 EXPECT_FALSE(rtcp_sender_->TMMBR());
549 rtcp_sender_->SetTMMBRStatus(true);
550 EXPECT_TRUE(rtcp_sender_->TMMBR());
551 rtcp_sender_->SetTargetBitrate(kBitrateBps);
552 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
553 EXPECT_EQ(1, parser()->tmmbr()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200554 EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
asapersson22ff75a2015-08-21 00:02:47 -0700555 // TMMBR should be included in each compound packet.
556 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
557 EXPECT_EQ(2, parser()->tmmbr()->num_packets());
asapersson22ff75a2015-08-21 00:02:47 -0700558
559 rtcp_sender_->SetTMMBRStatus(false);
560 EXPECT_FALSE(rtcp_sender_->TMMBR());
561}
562
563TEST_F(RtcpSenderTest, SendTmmbn) {
pbosda903ea2015-10-02 02:36:56 -0700564 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200565 rtcp_sender_->SetSendingStatus(feedback_state(), true);
danilchap6eaa3a42016-05-09 10:59:50 -0700566 std::vector<rtcp::TmmbItem> bounding_set;
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200567 const uint32_t kBitrateBps = 32768000;
asapersson22ff75a2015-08-21 00:02:47 -0700568 const uint32_t kPacketOh = 40;
569 const uint32_t kSourceSsrc = 12345;
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200570 const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateBps, kPacketOh);
danilchap6eaa3a42016-05-09 10:59:50 -0700571 bounding_set.push_back(tmmbn);
danilchap853ecb22016-08-22 08:26:15 -0700572 rtcp_sender_->SetTmmbn(bounding_set);
danilchap6eaa3a42016-05-09 10:59:50 -0700573
asapersson22ff75a2015-08-21 00:02:47 -0700574 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
575 EXPECT_EQ(1, parser()->sender_report()->num_packets());
576 EXPECT_EQ(1, parser()->tmmbn()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200577 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
578 EXPECT_EQ(1U, parser()->tmmbn()->items().size());
579 EXPECT_EQ(kBitrateBps, parser()->tmmbn()->items()[0].bitrate_bps());
580 EXPECT_EQ(kPacketOh, parser()->tmmbn()->items()[0].packet_overhead());
581 EXPECT_EQ(kSourceSsrc, parser()->tmmbn()->items()[0].ssrc());
asapersson22ff75a2015-08-21 00:02:47 -0700582}
583
hta@webrtc.org9d54cd12012-04-30 08:24:55 +0000584// This test is written to verify actual behaviour. It does not seem
585// to make much sense to send an empty TMMBN, since there is no place
586// to put an actual limit here. It's just information that no limit
587// is set, which is kind of the starting assumption.
588// See http://code.google.com/p/webrtc/issues/detail?id=468 for one
589// situation where this caused confusion.
590TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
pbosda903ea2015-10-02 02:36:56 -0700591 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
Danil Chapovalov70ffead2016-07-20 15:26:59 +0200592 rtcp_sender_->SetSendingStatus(feedback_state(), true);
danilchap6eaa3a42016-05-09 10:59:50 -0700593 std::vector<rtcp::TmmbItem> bounding_set;
danilchap853ecb22016-08-22 08:26:15 -0700594 rtcp_sender_->SetTmmbn(bounding_set);
asapersson22ff75a2015-08-21 00:02:47 -0700595 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
596 EXPECT_EQ(1, parser()->sender_report()->num_packets());
597 EXPECT_EQ(1, parser()->tmmbn()->num_packets());
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200598 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
599 EXPECT_EQ(0U, parser()->tmmbn()->items().size());
hta@webrtc.org65a4e4e2012-04-30 11:23:41 +0000600}
601
asapersson22ff75a2015-08-21 00:02:47 -0700602TEST_F(RtcpSenderTest, SendCompoundPliRemb) {
603 const int kBitrate = 261011;
604 std::vector<uint32_t> ssrcs;
605 ssrcs.push_back(kRemoteSsrc);
pbosda903ea2015-10-02 02:36:56 -0700606 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
Danil Chapovalovf74d6412017-10-18 13:32:57 +0200607 rtcp_sender_->SetRemb(kBitrate, ssrcs);
asapersson22ff75a2015-08-21 00:02:47 -0700608 std::set<RTCPPacketType> packet_types;
609 packet_types.insert(kRtcpRemb);
610 packet_types.insert(kRtcpPli);
611 EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types));
Danil Chapovalovba6f7be2016-09-02 18:29:10 +0200612 EXPECT_EQ(1, parser()->remb()->num_packets());
asapersson22ff75a2015-08-21 00:02:47 -0700613 EXPECT_EQ(1, parser()->pli()->num_packets());
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000614}
Erik Språnga38233a2015-07-24 09:58:18 +0200615
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -0800616// This test is written to verify that BYE is always the last packet
617// type in a RTCP compoud packet. The rtcp_sender_ is recreated with
618// mock_transport, which is used to check for whether BYE at the end
619// of a RTCP compound packet.
620TEST_F(RtcpSenderTest, ByeMustBeLast) {
621 MockTransport mock_transport;
622 EXPECT_CALL(mock_transport, SendRtcp(_, _))
Yves Gerey665174f2018-06-19 15:03:05 +0200623 .WillOnce(Invoke([](const uint8_t* data, size_t len) {
624 const uint8_t* next_packet = data;
625 const uint8_t* const packet_end = data + len;
626 rtcp::CommonHeader packet;
627 while (next_packet < packet_end) {
628 EXPECT_TRUE(packet.Parse(next_packet, packet_end - next_packet));
629 next_packet = packet.NextPacket();
630 if (packet.type() ==
631 rtcp::Bye::kPacketType) // Main test expectation.
632 EXPECT_EQ(0, packet_end - next_packet)
633 << "Bye packet should be last in a compound RTCP packet.";
634 if (next_packet == packet_end) // Validate test was set correctly.
635 EXPECT_EQ(packet.type(), rtcp::Bye::kPacketType)
636 << "Last packet in this test expected to be Bye.";
637 }
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -0800638
Yves Gerey665174f2018-06-19 15:03:05 +0200639 return true;
640 }));
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -0800641
642 // Re-configure rtcp_sender_ with mock_transport_
643 rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(),
Jiawei Ou8b5d9d82018-11-15 16:44:37 -0800644 nullptr, nullptr, &mock_transport, 1000));
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -0800645 rtcp_sender_->SetSSRC(kSenderSsrc);
646 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
danilchap71fead22016-08-18 02:01:49 -0700647 rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
Ilya Nikolaevskiy5e58bcb2018-10-24 13:34:32 +0200648 rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
649 /*paylpad_type=*/0);
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -0800650
Niels Möller44b384d2018-10-05 11:15:57 +0200651 // Set up REMB info to be included with BYE.
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -0800652 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
Niels Möller44b384d2018-10-05 11:15:57 +0200653 rtcp_sender_->SetRemb(1234, {});
aleungbroadsoft0e2e50c2016-02-18 08:33:26 -0800654 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
655}
656
sprang5e38c962016-12-01 05:18:09 -0800657TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) {
658 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
659 const size_t kNumSpatialLayers = 2;
660 const size_t kNumTemporalLayers = 2;
Erik Språng566124a2018-04-23 12:32:22 +0200661 VideoBitrateAllocation allocation;
sprang5e38c962016-12-01 05:18:09 -0800662 for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) {
663 uint32_t start_bitrate_bps = (sl + 1) * 100000;
664 for (size_t tl = 0; tl < kNumTemporalLayers; ++tl)
665 allocation.SetBitrate(sl, tl, start_bitrate_bps + (tl * 20000));
666 }
667 rtcp_sender_->SetVideoBitrateAllocation(allocation);
668
669 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
670 EXPECT_EQ(1, parser()->xr()->num_packets());
671 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
Danil Chapovalovd264df52018-06-14 12:59:38 +0200672 const absl::optional<rtcp::TargetBitrate>& target_bitrate =
sprang5e38c962016-12-01 05:18:09 -0800673 parser()->xr()->target_bitrate();
674 ASSERT_TRUE(target_bitrate);
675 const std::vector<rtcp::TargetBitrate::BitrateItem>& bitrates =
676 target_bitrate->GetTargetBitrates();
677 EXPECT_EQ(kNumSpatialLayers * kNumTemporalLayers, bitrates.size());
678
679 for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) {
680 uint32_t start_bitrate_bps = (sl + 1) * 100000;
681 for (size_t tl = 0; tl < kNumTemporalLayers; ++tl) {
682 size_t index = (sl * kNumSpatialLayers) + tl;
683 const rtcp::TargetBitrate::BitrateItem& item = bitrates[index];
684 EXPECT_EQ(sl, item.spatial_layer);
685 EXPECT_EQ(tl, item.temporal_layer);
686 EXPECT_EQ(start_bitrate_bps + (tl * 20000),
687 item.target_bitrate_kbps * 1000);
688 }
689 }
690}
691
Erik Språng8782a582018-10-04 15:36:06 +0200692TEST_F(RtcpSenderTest, SendImmediateXrWithTargetBitrate) {
693 // Initialize. Send a first report right away.
694 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
695 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
696 clock_.AdvanceTimeMilliseconds(5);
697
698 // Video bitrate allocation generated, save until next time we send a report.
699 VideoBitrateAllocation allocation;
700 allocation.SetBitrate(0, 0, 100000);
701 rtcp_sender_->SetVideoBitrateAllocation(allocation);
702 // First seen instance will be sent immediately.
703 EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
704 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
705 clock_.AdvanceTimeMilliseconds(5);
706
707 // Update bitrate of existing layer, does not quality for immediate sending.
708 allocation.SetBitrate(0, 0, 150000);
709 rtcp_sender_->SetVideoBitrateAllocation(allocation);
710 EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
711
712 // A new spatial layer enabled, signal this as soon as possible.
713 allocation.SetBitrate(1, 0, 200000);
714 rtcp_sender_->SetVideoBitrateAllocation(allocation);
715 EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
716 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
717 clock_.AdvanceTimeMilliseconds(5);
718
719 // Explicitly disable top layer. The same set of layers now has a bitrate
720 // defined, but the explicit 0 indicates shutdown. Signal immediately.
721 allocation.SetBitrate(1, 0, 0);
722 EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
723 rtcp_sender_->SetVideoBitrateAllocation(allocation);
724 EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
725}
726
Erik Språng1cd73912018-10-05 12:57:59 +0200727TEST_F(RtcpSenderTest, SendTargetBitrateExplicitZeroOnStreamRemoval) {
728 // Set up and send a bitrate allocation with two layers.
729
730 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
731 VideoBitrateAllocation allocation;
732 allocation.SetBitrate(0, 0, 100000);
733 allocation.SetBitrate(1, 0, 200000);
734 rtcp_sender_->SetVideoBitrateAllocation(allocation);
735 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
736 absl::optional<rtcp::TargetBitrate> target_bitrate =
737 parser()->xr()->target_bitrate();
738 ASSERT_TRUE(target_bitrate);
739 std::vector<rtcp::TargetBitrate::BitrateItem> bitrates =
740 target_bitrate->GetTargetBitrates();
741 ASSERT_EQ(2u, bitrates.size());
742 EXPECT_EQ(bitrates[0].target_bitrate_kbps,
743 allocation.GetBitrate(0, 0) / 1000);
744 EXPECT_EQ(bitrates[1].target_bitrate_kbps,
745 allocation.GetBitrate(1, 0) / 1000);
746
747 // Create a new allocation, where the second stream is no longer available.
748 VideoBitrateAllocation new_allocation;
749 new_allocation.SetBitrate(0, 0, 150000);
750 rtcp_sender_->SetVideoBitrateAllocation(new_allocation);
751 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
752 target_bitrate = parser()->xr()->target_bitrate();
753 ASSERT_TRUE(target_bitrate);
754 bitrates = target_bitrate->GetTargetBitrates();
755
756 // Two bitrates should still be set, with an explicit entry indicating the
757 // removed stream is gone.
758 ASSERT_EQ(2u, bitrates.size());
759 EXPECT_EQ(bitrates[0].target_bitrate_kbps,
760 new_allocation.GetBitrate(0, 0) / 1000);
761 EXPECT_EQ(bitrates[1].target_bitrate_kbps, 0u);
762}
763
asapersson@webrtc.org5249cc82011-12-16 14:31:37 +0000764} // namespace webrtc