1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/rtp_rtcp/source/rtcp_sender.h"
12
13 #include <memory>
14 #include <utility>
15
16 #include "absl/base/macros.h"
17 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
18 #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
19 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
20 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
21 #include "modules/rtp_rtcp/source/rtp_rtcp_impl.h"
22 #include "modules/rtp_rtcp/source/time_util.h"
23 #include "rtc_base/rate_limiter.h"
24 #include "test/gmock.h"
25 #include "test/gtest.h"
26 #include "test/mock_transport.h"
27 #include "test/rtcp_packet_parser.h"
28
29 using ::testing::_;
30 using ::testing::ElementsAre;
31 using ::testing::Invoke;
32 using ::testing::SizeIs;
33
34 namespace webrtc {
35
36 class RtcpPacketTypeCounterObserverImpl : public RtcpPacketTypeCounterObserver {
37 public:
RtcpPacketTypeCounterObserverImpl()38 RtcpPacketTypeCounterObserverImpl() : ssrc_(0) {}
39 ~RtcpPacketTypeCounterObserverImpl() override = default;
RtcpPacketTypesCounterUpdated(uint32_t ssrc,const RtcpPacketTypeCounter & packet_counter)40 void RtcpPacketTypesCounterUpdated(
41 uint32_t ssrc,
42 const RtcpPacketTypeCounter& packet_counter) override {
43 ssrc_ = ssrc;
44 counter_ = packet_counter;
45 }
46 uint32_t ssrc_;
47 RtcpPacketTypeCounter counter_;
48 };
49
50 class TestTransport : public Transport {
51 public:
TestTransport()52 TestTransport() {}
53
SendRtp(const uint8_t *,size_t,const PacketOptions & options)54 bool SendRtp(const uint8_t* /*data*/,
55 size_t /*len*/,
56 const PacketOptions& options) override {
57 return false;
58 }
SendRtcp(const uint8_t * data,size_t len)59 bool SendRtcp(const uint8_t* data, size_t len) override {
60 parser_.Parse(data, len);
61 return true;
62 }
63 test::RtcpPacketParser parser_;
64 };
65
66 namespace {
67 static const uint32_t kSenderSsrc = 0x11111111;
68 static const uint32_t kRemoteSsrc = 0x22222222;
69 static const uint32_t kStartRtpTimestamp = 0x34567;
70 static const uint32_t kRtpTimestamp = 0x45678;
71 } // namespace
72
73 class RtcpSenderTest : public ::testing::Test {
74 protected:
RtcpSenderTest()75 RtcpSenderTest()
76 : clock_(1335900000),
77 receive_statistics_(ReceiveStatistics::Create(&clock_)),
78 retransmission_rate_limiter_(&clock_, 1000) {
79 RtpRtcp::Configuration configuration = GetDefaultConfig();
80 rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration));
81 rtcp_sender_.reset(new RTCPSender(configuration));
82 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
83 rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
84 rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
85 /*payload_type=*/0);
86 }
87
GetDefaultConfig()88 RtpRtcp::Configuration GetDefaultConfig() {
89 RtpRtcp::Configuration configuration;
90 configuration.audio = false;
91 configuration.clock = &clock_;
92 configuration.outgoing_transport = &test_transport_;
93 configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
94 configuration.rtcp_report_interval_ms = 1000;
95 configuration.receive_statistics = receive_statistics_.get();
96 configuration.local_media_ssrc = kSenderSsrc;
97 return configuration;
98 }
99
InsertIncomingPacket(uint32_t remote_ssrc,uint16_t seq_num)100 void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) {
101 RtpPacketReceived packet;
102 packet.SetSsrc(remote_ssrc);
103 packet.SetSequenceNumber(seq_num);
104 packet.SetTimestamp(12345);
105 packet.SetPayloadSize(100 - 12);
106 receive_statistics_->OnRtpPacket(packet);
107 }
108
parser()109 test::RtcpPacketParser* parser() { return &test_transport_.parser_; }
110
feedback_state()111 RTCPSender::FeedbackState feedback_state() {
112 return rtp_rtcp_impl_->GetFeedbackState();
113 }
114
115 SimulatedClock clock_;
116 TestTransport test_transport_;
117 std::unique_ptr<ReceiveStatistics> receive_statistics_;
118 std::unique_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_;
119 std::unique_ptr<RTCPSender> rtcp_sender_;
120 RateLimiter retransmission_rate_limiter_;
121 };
122
TEST_F(RtcpSenderTest,SetRtcpStatus)123 TEST_F(RtcpSenderTest, SetRtcpStatus) {
124 EXPECT_EQ(RtcpMode::kOff, rtcp_sender_->Status());
125 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
126 EXPECT_EQ(RtcpMode::kReducedSize, rtcp_sender_->Status());
127 }
128
TEST_F(RtcpSenderTest,SetSendingStatus)129 TEST_F(RtcpSenderTest, SetSendingStatus) {
130 EXPECT_FALSE(rtcp_sender_->Sending());
131 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
132 EXPECT_TRUE(rtcp_sender_->Sending());
133 }
134
TEST_F(RtcpSenderTest,NoPacketSentIfOff)135 TEST_F(RtcpSenderTest, NoPacketSentIfOff) {
136 rtcp_sender_->SetRTCPStatus(RtcpMode::kOff);
137 EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
138 }
139
TEST_F(RtcpSenderTest,SendSr)140 TEST_F(RtcpSenderTest, SendSr) {
141 const uint32_t kPacketCount = 0x12345;
142 const uint32_t kOctetCount = 0x23456;
143 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
144 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
145 rtcp_sender_->SetSendingStatus(feedback_state, true);
146 feedback_state.packets_sent = kPacketCount;
147 feedback_state.media_bytes_sent = kOctetCount;
148 NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
149 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
150 EXPECT_EQ(1, parser()->sender_report()->num_packets());
151 EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc());
152 EXPECT_EQ(ntp, parser()->sender_report()->ntp());
153 EXPECT_EQ(kPacketCount, parser()->sender_report()->sender_packet_count());
154 EXPECT_EQ(kOctetCount, parser()->sender_report()->sender_octet_count());
155 EXPECT_EQ(kStartRtpTimestamp + kRtpTimestamp,
156 parser()->sender_report()->rtp_timestamp());
157 EXPECT_EQ(0U, parser()->sender_report()->report_blocks().size());
158 }
159
TEST_F(RtcpSenderTest,SendConsecutiveSrWithExactSlope)160 TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) {
161 const uint32_t kPacketCount = 0x12345;
162 const uint32_t kOctetCount = 0x23456;
163 const int kTimeBetweenSRsUs = 10043; // Not exact value in milliseconds.
164 const int kExtraPackets = 30;
165 // Make sure clock is not exactly at some milliseconds point.
166 clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
167 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
168 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
169 rtcp_sender_->SetSendingStatus(feedback_state, true);
170 feedback_state.packets_sent = kPacketCount;
171 feedback_state.media_bytes_sent = kOctetCount;
172
173 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
174 EXPECT_EQ(1, parser()->sender_report()->num_packets());
175 NtpTime ntp1 = parser()->sender_report()->ntp();
176 uint32_t rtp1 = parser()->sender_report()->rtp_timestamp();
177
178 // Send more SRs to ensure slope is always exact for different offsets
179 for (int packets = 1; packets <= kExtraPackets; ++packets) {
180 clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
181 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
182 EXPECT_EQ(packets + 1, parser()->sender_report()->num_packets());
183
184 NtpTime ntp2 = parser()->sender_report()->ntp();
185 uint32_t rtp2 = parser()->sender_report()->rtp_timestamp();
186
187 uint32_t ntp_diff_in_rtp_units =
188 (ntp2.ToMs() - ntp1.ToMs()) * (kVideoPayloadTypeFrequency / 1000);
189 EXPECT_EQ(rtp2 - rtp1, ntp_diff_in_rtp_units);
190 }
191 }
192
TEST_F(RtcpSenderTest,DoNotSendSrBeforeRtp)193 TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
194 RtpRtcp::Configuration config;
195 config.clock = &clock_;
196 config.receive_statistics = receive_statistics_.get();
197 config.outgoing_transport = &test_transport_;
198 config.rtcp_report_interval_ms = 1000;
199 config.local_media_ssrc = kSenderSsrc;
200 rtcp_sender_.reset(new RTCPSender(config));
201 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
202 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
203 rtcp_sender_->SetSendingStatus(feedback_state(), true);
204
205 // Sender Report shouldn't be send as an SR nor as a Report.
206 rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr);
207 EXPECT_EQ(0, parser()->sender_report()->num_packets());
208 rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
209 EXPECT_EQ(0, parser()->sender_report()->num_packets());
210 // Other packets (e.g. Pli) are allowed, even if useless.
211 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
212 EXPECT_EQ(1, parser()->pli()->num_packets());
213 }
214
TEST_F(RtcpSenderTest,DoNotSendCompundBeforeRtp)215 TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) {
216 RtpRtcp::Configuration config;
217 config.clock = &clock_;
218 config.receive_statistics = receive_statistics_.get();
219 config.outgoing_transport = &test_transport_;
220 config.rtcp_report_interval_ms = 1000;
221 config.local_media_ssrc = kSenderSsrc;
222 rtcp_sender_.reset(new RTCPSender(config));
223 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
224 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
225 rtcp_sender_->SetSendingStatus(feedback_state(), true);
226
227 // In compound mode no packets are allowed (e.g. Pli) because compound mode
228 // should start with Sender Report.
229 EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
230 EXPECT_EQ(0, parser()->pli()->num_packets());
231 }
232
TEST_F(RtcpSenderTest,SendRr)233 TEST_F(RtcpSenderTest, SendRr) {
234 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
235 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
236 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
237 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
238 EXPECT_EQ(0U, parser()->receiver_report()->report_blocks().size());
239 }
240
TEST_F(RtcpSenderTest,SendRrWithOneReportBlock)241 TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
242 const uint16_t kSeqNum = 11111;
243 InsertIncomingPacket(kRemoteSsrc, kSeqNum);
244 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
245 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
246 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
247 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
248 ASSERT_EQ(1U, parser()->receiver_report()->report_blocks().size());
249 const rtcp::ReportBlock& rb = parser()->receiver_report()->report_blocks()[0];
250 EXPECT_EQ(kRemoteSsrc, rb.source_ssrc());
251 EXPECT_EQ(0U, rb.fraction_lost());
252 EXPECT_EQ(0, rb.cumulative_lost_signed());
253 EXPECT_EQ(kSeqNum, rb.extended_high_seq_num());
254 }
255
TEST_F(RtcpSenderTest,SendRrWithTwoReportBlocks)256 TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
257 const uint16_t kSeqNum = 11111;
258 InsertIncomingPacket(kRemoteSsrc, kSeqNum);
259 InsertIncomingPacket(kRemoteSsrc + 1, kSeqNum + 1);
260 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
261 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
262 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
263 EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
264 EXPECT_EQ(2U, parser()->receiver_report()->report_blocks().size());
265 EXPECT_EQ(kRemoteSsrc,
266 parser()->receiver_report()->report_blocks()[0].source_ssrc());
267 EXPECT_EQ(kRemoteSsrc + 1,
268 parser()->receiver_report()->report_blocks()[1].source_ssrc());
269 }
270
TEST_F(RtcpSenderTest,SendSdes)271 TEST_F(RtcpSenderTest, SendSdes) {
272 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
273 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
274 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
275 EXPECT_EQ(1, parser()->sdes()->num_packets());
276 EXPECT_EQ(1U, parser()->sdes()->chunks().size());
277 EXPECT_EQ(kSenderSsrc, parser()->sdes()->chunks()[0].ssrc);
278 EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname);
279 }
280
TEST_F(RtcpSenderTest,SendSdesWithMaxChunks)281 TEST_F(RtcpSenderTest, SendSdesWithMaxChunks) {
282 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
283 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
284 const char cname[] = "smith@host";
285 for (size_t i = 0; i < 30; ++i) {
286 const uint32_t csrc = 0x1234 + i;
287 EXPECT_EQ(0, rtcp_sender_->AddMixedCNAME(csrc, cname));
288 }
289 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
290 EXPECT_EQ(1, parser()->sdes()->num_packets());
291 EXPECT_EQ(31U, parser()->sdes()->chunks().size());
292 }
293
TEST_F(RtcpSenderTest,SdesIncludedInCompoundPacket)294 TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
295 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
296 EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
297 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
298 EXPECT_EQ(1, parser()->receiver_report()->num_packets());
299 EXPECT_EQ(1, parser()->sdes()->num_packets());
300 EXPECT_EQ(1U, parser()->sdes()->chunks().size());
301 }
302
TEST_F(RtcpSenderTest,SendBye)303 TEST_F(RtcpSenderTest, SendBye) {
304 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
305 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
306 EXPECT_EQ(1, parser()->bye()->num_packets());
307 EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
308 }
309
TEST_F(RtcpSenderTest,StopSendingTriggersBye)310 TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
311 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
312 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
313 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
314 EXPECT_EQ(1, parser()->bye()->num_packets());
315 EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
316 }
317
TEST_F(RtcpSenderTest,SendApp)318 TEST_F(RtcpSenderTest, SendApp) {
319 const uint8_t kSubType = 30;
320 uint32_t name = 'n' << 24;
321 name += 'a' << 16;
322 name += 'm' << 8;
323 name += 'e';
324 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
325 EXPECT_EQ(0, rtcp_sender_->SetApplicationSpecificData(kSubType, name, kData,
326 sizeof(kData)));
327 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
328 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
329 EXPECT_EQ(1, parser()->app()->num_packets());
330 EXPECT_EQ(kSubType, parser()->app()->sub_type());
331 EXPECT_EQ(name, parser()->app()->name());
332 EXPECT_EQ(sizeof(kData), parser()->app()->data_size());
333 EXPECT_EQ(0, memcmp(kData, parser()->app()->data(), sizeof(kData)));
334 }
335
TEST_F(RtcpSenderTest,SendEmptyApp)336 TEST_F(RtcpSenderTest, SendEmptyApp) {
337 const uint8_t kSubType = 30;
338 const uint32_t kName = 0x6E616D65;
339
340 EXPECT_EQ(
341 0, rtcp_sender_->SetApplicationSpecificData(kSubType, kName, nullptr, 0));
342
343 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
344 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp));
345 EXPECT_EQ(1, parser()->app()->num_packets());
346 EXPECT_EQ(kSubType, parser()->app()->sub_type());
347 EXPECT_EQ(kName, parser()->app()->name());
348 EXPECT_EQ(0U, parser()->app()->data_size());
349 }
350
TEST_F(RtcpSenderTest,SetInvalidApplicationSpecificData)351 TEST_F(RtcpSenderTest, SetInvalidApplicationSpecificData) {
352 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't'};
353 const uint16_t kInvalidDataLength = sizeof(kData) / sizeof(kData[0]);
354 EXPECT_EQ(-1,
355 rtcp_sender_->SetApplicationSpecificData(
356 0, 0, kData, kInvalidDataLength)); // Should by multiple of 4.
357 }
358
TEST_F(RtcpSenderTest,SendFir)359 TEST_F(RtcpSenderTest, SendFir) {
360 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
361 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
362 EXPECT_EQ(1, parser()->fir()->num_packets());
363 EXPECT_EQ(kSenderSsrc, parser()->fir()->sender_ssrc());
364 EXPECT_EQ(1U, parser()->fir()->requests().size());
365 EXPECT_EQ(kRemoteSsrc, parser()->fir()->requests()[0].ssrc);
366 uint8_t seq = parser()->fir()->requests()[0].seq_nr;
367 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
368 EXPECT_EQ(2, parser()->fir()->num_packets());
369 EXPECT_EQ(seq + 1, parser()->fir()->requests()[0].seq_nr);
370 }
371
TEST_F(RtcpSenderTest,SendPli)372 TEST_F(RtcpSenderTest, SendPli) {
373 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
374 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
375 EXPECT_EQ(1, parser()->pli()->num_packets());
376 EXPECT_EQ(kSenderSsrc, parser()->pli()->sender_ssrc());
377 EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc());
378 }
379
TEST_F(RtcpSenderTest,SendNack)380 TEST_F(RtcpSenderTest, SendNack) {
381 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
382 const uint16_t kList[] = {0, 1, 16};
383 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack,
384 ABSL_ARRAYSIZE(kList), kList));
385 EXPECT_EQ(1, parser()->nack()->num_packets());
386 EXPECT_EQ(kSenderSsrc, parser()->nack()->sender_ssrc());
387 EXPECT_EQ(kRemoteSsrc, parser()->nack()->media_ssrc());
388 EXPECT_THAT(parser()->nack()->packet_ids(), ElementsAre(0, 1, 16));
389 }
390
TEST_F(RtcpSenderTest,SendLossNotificationBufferingNotAllowed)391 TEST_F(RtcpSenderTest, SendLossNotificationBufferingNotAllowed) {
392 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
393 constexpr uint16_t kLastDecoded = 0x1234;
394 constexpr uint16_t kLastReceived = 0x4321;
395 constexpr bool kDecodabilityFlag = true;
396 constexpr bool kBufferingAllowed = false;
397 EXPECT_EQ(rtcp_sender_->SendLossNotification(feedback_state(), kLastDecoded,
398 kLastReceived, kDecodabilityFlag,
399 kBufferingAllowed),
400 0);
401 EXPECT_EQ(parser()->processed_rtcp_packets(), 1u);
402 EXPECT_EQ(parser()->loss_notification()->num_packets(), 1);
403 EXPECT_EQ(kSenderSsrc, parser()->loss_notification()->sender_ssrc());
404 EXPECT_EQ(kRemoteSsrc, parser()->loss_notification()->media_ssrc());
405 }
406
TEST_F(RtcpSenderTest,SendLossNotificationBufferingAllowed)407 TEST_F(RtcpSenderTest, SendLossNotificationBufferingAllowed) {
408 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
409 constexpr uint16_t kLastDecoded = 0x1234;
410 constexpr uint16_t kLastReceived = 0x4321;
411 constexpr bool kDecodabilityFlag = true;
412 constexpr bool kBufferingAllowed = true;
413 EXPECT_EQ(rtcp_sender_->SendLossNotification(feedback_state(), kLastDecoded,
414 kLastReceived, kDecodabilityFlag,
415 kBufferingAllowed),
416 0);
417
418 // No RTCP messages sent yet.
419 ASSERT_EQ(parser()->processed_rtcp_packets(), 0u);
420
421 // Sending another messages triggers sending the LNTF messages as well.
422 const uint16_t kList[] = {0, 1, 16};
423 EXPECT_EQ(rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack,
424 ABSL_ARRAYSIZE(kList), kList),
425 0);
426
427 // Exactly one packet was produced, and it contained both the buffered LNTF
428 // as well as the message that had triggered the packet.
429 EXPECT_EQ(parser()->processed_rtcp_packets(), 1u);
430 EXPECT_EQ(parser()->loss_notification()->num_packets(), 1);
431 EXPECT_EQ(parser()->loss_notification()->sender_ssrc(), kSenderSsrc);
432 EXPECT_EQ(parser()->loss_notification()->media_ssrc(), kRemoteSsrc);
433 EXPECT_EQ(parser()->nack()->num_packets(), 1);
434 EXPECT_EQ(parser()->nack()->sender_ssrc(), kSenderSsrc);
435 EXPECT_EQ(parser()->nack()->media_ssrc(), kRemoteSsrc);
436 }
437
TEST_F(RtcpSenderTest,RembNotIncludedBeforeSet)438 TEST_F(RtcpSenderTest, RembNotIncludedBeforeSet) {
439 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
440
441 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
442
443 ASSERT_EQ(1, parser()->receiver_report()->num_packets());
444 EXPECT_EQ(0, parser()->remb()->num_packets());
445 }
446
TEST_F(RtcpSenderTest,RembNotIncludedAfterUnset)447 TEST_F(RtcpSenderTest, RembNotIncludedAfterUnset) {
448 const int64_t kBitrate = 261011;
449 const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
450 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
451 rtcp_sender_->SetRemb(kBitrate, kSsrcs);
452 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
453 ASSERT_EQ(1, parser()->receiver_report()->num_packets());
454 EXPECT_EQ(1, parser()->remb()->num_packets());
455
456 // Turn off REMB. rtcp_sender no longer should send it.
457 rtcp_sender_->UnsetRemb();
458 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
459 ASSERT_EQ(2, parser()->receiver_report()->num_packets());
460 EXPECT_EQ(1, parser()->remb()->num_packets());
461 }
462
TEST_F(RtcpSenderTest,SendRemb)463 TEST_F(RtcpSenderTest, SendRemb) {
464 const int64_t kBitrate = 261011;
465 const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
466 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
467 rtcp_sender_->SetRemb(kBitrate, kSsrcs);
468
469 rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb);
470
471 EXPECT_EQ(1, parser()->remb()->num_packets());
472 EXPECT_EQ(kSenderSsrc, parser()->remb()->sender_ssrc());
473 EXPECT_EQ(kBitrate, parser()->remb()->bitrate_bps());
474 EXPECT_THAT(parser()->remb()->ssrcs(),
475 ElementsAre(kRemoteSsrc, kRemoteSsrc + 1));
476 }
477
TEST_F(RtcpSenderTest,RembIncludedInEachCompoundPacketAfterSet)478 TEST_F(RtcpSenderTest, RembIncludedInEachCompoundPacketAfterSet) {
479 const int kBitrate = 261011;
480 const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
481 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
482 rtcp_sender_->SetRemb(kBitrate, kSsrcs);
483
484 rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
485 EXPECT_EQ(1, parser()->remb()->num_packets());
486 // REMB should be included in each compound packet.
487 rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
488 EXPECT_EQ(2, parser()->remb()->num_packets());
489 }
490
TEST_F(RtcpSenderTest,SendXrWithDlrr)491 TEST_F(RtcpSenderTest, SendXrWithDlrr) {
492 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
493 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
494 rtcp::ReceiveTimeInfo last_xr_rr;
495 last_xr_rr.ssrc = 0x11111111;
496 last_xr_rr.last_rr = 0x22222222;
497 last_xr_rr.delay_since_last_rr = 0x33333333;
498 feedback_state.last_xr_rtis.push_back(last_xr_rr);
499 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
500 EXPECT_EQ(1, parser()->xr()->num_packets());
501 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
502 ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(1));
503 EXPECT_EQ(last_xr_rr.ssrc, parser()->xr()->dlrr().sub_blocks()[0].ssrc);
504 EXPECT_EQ(last_xr_rr.last_rr, parser()->xr()->dlrr().sub_blocks()[0].last_rr);
505 EXPECT_EQ(last_xr_rr.delay_since_last_rr,
506 parser()->xr()->dlrr().sub_blocks()[0].delay_since_last_rr);
507 }
508
TEST_F(RtcpSenderTest,SendXrWithMultipleDlrrSubBlocks)509 TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
510 const size_t kNumReceivers = 2;
511 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
512 RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
513 for (size_t i = 0; i < kNumReceivers; ++i) {
514 rtcp::ReceiveTimeInfo last_xr_rr;
515 last_xr_rr.ssrc = i;
516 last_xr_rr.last_rr = (i + 1) * 100;
517 last_xr_rr.delay_since_last_rr = (i + 2) * 200;
518 feedback_state.last_xr_rtis.push_back(last_xr_rr);
519 }
520
521 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
522 EXPECT_EQ(1, parser()->xr()->num_packets());
523 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
524 ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(kNumReceivers));
525 for (size_t i = 0; i < kNumReceivers; ++i) {
526 EXPECT_EQ(feedback_state.last_xr_rtis[i].ssrc,
527 parser()->xr()->dlrr().sub_blocks()[i].ssrc);
528 EXPECT_EQ(feedback_state.last_xr_rtis[i].last_rr,
529 parser()->xr()->dlrr().sub_blocks()[i].last_rr);
530 EXPECT_EQ(feedback_state.last_xr_rtis[i].delay_since_last_rr,
531 parser()->xr()->dlrr().sub_blocks()[i].delay_since_last_rr);
532 }
533 }
534
TEST_F(RtcpSenderTest,SendXrWithRrtr)535 TEST_F(RtcpSenderTest, SendXrWithRrtr) {
536 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
537 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
538 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
539 NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
540 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
541 EXPECT_EQ(1, parser()->xr()->num_packets());
542 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
543 EXPECT_FALSE(parser()->xr()->dlrr());
544 ASSERT_TRUE(parser()->xr()->rrtr());
545 EXPECT_EQ(ntp, parser()->xr()->rrtr()->ntp());
546 }
547
TEST_F(RtcpSenderTest,TestNoXrRrtrSentIfSending)548 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
549 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
550 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
551 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
552 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
553 EXPECT_EQ(0, parser()->xr()->num_packets());
554 }
555
TEST_F(RtcpSenderTest,TestNoXrRrtrSentIfNotEnabled)556 TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
557 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
558 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
559 rtcp_sender_->SendRtcpXrReceiverReferenceTime(false);
560 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
561 EXPECT_EQ(0, parser()->xr()->num_packets());
562 }
563
TEST_F(RtcpSenderTest,TestRegisterRtcpPacketTypeObserver)564 TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
565 RtcpPacketTypeCounterObserverImpl observer;
566 RtpRtcp::Configuration config;
567 config.clock = &clock_;
568 config.receive_statistics = receive_statistics_.get();
569 config.outgoing_transport = &test_transport_;
570 config.rtcp_packet_type_counter_observer = &observer;
571 config.rtcp_report_interval_ms = 1000;
572 rtcp_sender_.reset(new RTCPSender(config));
573
574 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
575 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
576 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
577 EXPECT_EQ(1, parser()->pli()->num_packets());
578 EXPECT_EQ(kRemoteSsrc, observer.ssrc_);
579 EXPECT_EQ(1U, observer.counter_.pli_packets);
580 EXPECT_EQ(clock_.TimeInMilliseconds(),
581 observer.counter_.first_packet_time_ms);
582 }
583
TEST_F(RtcpSenderTest,SendTmmbr)584 TEST_F(RtcpSenderTest, SendTmmbr) {
585 const unsigned int kBitrateBps = 312000;
586 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
587 rtcp_sender_->SetTargetBitrate(kBitrateBps);
588 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr));
589 EXPECT_EQ(1, parser()->tmmbr()->num_packets());
590 EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->sender_ssrc());
591 EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
592 EXPECT_EQ(kBitrateBps, parser()->tmmbr()->requests()[0].bitrate_bps());
593 // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero.
594 }
595
TEST_F(RtcpSenderTest,TmmbrIncludedInCompoundPacketIfEnabled)596 TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
597 const unsigned int kBitrateBps = 312000;
598 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
599 EXPECT_FALSE(rtcp_sender_->TMMBR());
600 rtcp_sender_->SetTMMBRStatus(true);
601 EXPECT_TRUE(rtcp_sender_->TMMBR());
602 rtcp_sender_->SetTargetBitrate(kBitrateBps);
603 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
604 EXPECT_EQ(1, parser()->tmmbr()->num_packets());
605 EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
606 // TMMBR should be included in each compound packet.
607 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
608 EXPECT_EQ(2, parser()->tmmbr()->num_packets());
609
610 rtcp_sender_->SetTMMBRStatus(false);
611 EXPECT_FALSE(rtcp_sender_->TMMBR());
612 }
613
TEST_F(RtcpSenderTest,SendTmmbn)614 TEST_F(RtcpSenderTest, SendTmmbn) {
615 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
616 rtcp_sender_->SetSendingStatus(feedback_state(), true);
617 std::vector<rtcp::TmmbItem> bounding_set;
618 const uint32_t kBitrateBps = 32768000;
619 const uint32_t kPacketOh = 40;
620 const uint32_t kSourceSsrc = 12345;
621 const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateBps, kPacketOh);
622 bounding_set.push_back(tmmbn);
623 rtcp_sender_->SetTmmbn(bounding_set);
624
625 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
626 EXPECT_EQ(1, parser()->sender_report()->num_packets());
627 EXPECT_EQ(1, parser()->tmmbn()->num_packets());
628 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
629 EXPECT_EQ(1U, parser()->tmmbn()->items().size());
630 EXPECT_EQ(kBitrateBps, parser()->tmmbn()->items()[0].bitrate_bps());
631 EXPECT_EQ(kPacketOh, parser()->tmmbn()->items()[0].packet_overhead());
632 EXPECT_EQ(kSourceSsrc, parser()->tmmbn()->items()[0].ssrc());
633 }
634
635 // This test is written to verify actual behaviour. It does not seem
636 // to make much sense to send an empty TMMBN, since there is no place
637 // to put an actual limit here. It's just information that no limit
638 // is set, which is kind of the starting assumption.
639 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one
640 // situation where this caused confusion.
TEST_F(RtcpSenderTest,SendsTmmbnIfSetAndEmpty)641 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
642 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
643 rtcp_sender_->SetSendingStatus(feedback_state(), true);
644 std::vector<rtcp::TmmbItem> bounding_set;
645 rtcp_sender_->SetTmmbn(bounding_set);
646 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
647 EXPECT_EQ(1, parser()->sender_report()->num_packets());
648 EXPECT_EQ(1, parser()->tmmbn()->num_packets());
649 EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
650 EXPECT_EQ(0U, parser()->tmmbn()->items().size());
651 }
652
TEST_F(RtcpSenderTest,SendCompoundPliRemb)653 TEST_F(RtcpSenderTest, SendCompoundPliRemb) {
654 const int kBitrate = 261011;
655 std::vector<uint32_t> ssrcs;
656 ssrcs.push_back(kRemoteSsrc);
657 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
658 rtcp_sender_->SetRemb(kBitrate, ssrcs);
659 std::set<RTCPPacketType> packet_types;
660 packet_types.insert(kRtcpRemb);
661 packet_types.insert(kRtcpPli);
662 EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types));
663 EXPECT_EQ(1, parser()->remb()->num_packets());
664 EXPECT_EQ(1, parser()->pli()->num_packets());
665 }
666
667 // This test is written to verify that BYE is always the last packet
668 // type in a RTCP compoud packet. The rtcp_sender_ is recreated with
669 // mock_transport, which is used to check for whether BYE at the end
670 // of a RTCP compound packet.
TEST_F(RtcpSenderTest,ByeMustBeLast)671 TEST_F(RtcpSenderTest, ByeMustBeLast) {
672 MockTransport mock_transport;
673 EXPECT_CALL(mock_transport, SendRtcp(_, _))
674 .WillOnce(Invoke([](const uint8_t* data, size_t len) {
675 const uint8_t* next_packet = data;
676 const uint8_t* const packet_end = data + len;
677 rtcp::CommonHeader packet;
678 while (next_packet < packet_end) {
679 EXPECT_TRUE(packet.Parse(next_packet, packet_end - next_packet));
680 next_packet = packet.NextPacket();
681 if (packet.type() ==
682 rtcp::Bye::kPacketType) // Main test expectation.
683 EXPECT_EQ(0, packet_end - next_packet)
684 << "Bye packet should be last in a compound RTCP packet.";
685 if (next_packet == packet_end) // Validate test was set correctly.
686 EXPECT_EQ(packet.type(), rtcp::Bye::kPacketType)
687 << "Last packet in this test expected to be Bye.";
688 }
689
690 return true;
691 }));
692
693 // Re-configure rtcp_sender_ with mock_transport_
694 RtpRtcp::Configuration config;
695 config.clock = &clock_;
696 config.receive_statistics = receive_statistics_.get();
697 config.outgoing_transport = &mock_transport;
698 config.rtcp_report_interval_ms = 1000;
699 config.local_media_ssrc = kSenderSsrc;
700 rtcp_sender_.reset(new RTCPSender(config));
701
702 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
703 rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
704 rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
705 /*payload_type=*/0);
706
707 // Set up REMB info to be included with BYE.
708 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
709 rtcp_sender_->SetRemb(1234, {});
710 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
711 }
712
TEST_F(RtcpSenderTest,SendXrWithTargetBitrate)713 TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) {
714 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
715 const size_t kNumSpatialLayers = 2;
716 const size_t kNumTemporalLayers = 2;
717 VideoBitrateAllocation allocation;
718 for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) {
719 uint32_t start_bitrate_bps = (sl + 1) * 100000;
720 for (size_t tl = 0; tl < kNumTemporalLayers; ++tl)
721 allocation.SetBitrate(sl, tl, start_bitrate_bps + (tl * 20000));
722 }
723 rtcp_sender_->SetVideoBitrateAllocation(allocation);
724
725 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
726 EXPECT_EQ(1, parser()->xr()->num_packets());
727 EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
728 const absl::optional<rtcp::TargetBitrate>& target_bitrate =
729 parser()->xr()->target_bitrate();
730 ASSERT_TRUE(target_bitrate);
731 const std::vector<rtcp::TargetBitrate::BitrateItem>& bitrates =
732 target_bitrate->GetTargetBitrates();
733 EXPECT_EQ(kNumSpatialLayers * kNumTemporalLayers, bitrates.size());
734
735 for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) {
736 uint32_t start_bitrate_bps = (sl + 1) * 100000;
737 for (size_t tl = 0; tl < kNumTemporalLayers; ++tl) {
738 size_t index = (sl * kNumSpatialLayers) + tl;
739 const rtcp::TargetBitrate::BitrateItem& item = bitrates[index];
740 EXPECT_EQ(sl, item.spatial_layer);
741 EXPECT_EQ(tl, item.temporal_layer);
742 EXPECT_EQ(start_bitrate_bps + (tl * 20000),
743 item.target_bitrate_kbps * 1000);
744 }
745 }
746 }
747
TEST_F(RtcpSenderTest,SendImmediateXrWithTargetBitrate)748 TEST_F(RtcpSenderTest, SendImmediateXrWithTargetBitrate) {
749 // Initialize. Send a first report right away.
750 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
751 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
752 clock_.AdvanceTimeMilliseconds(5);
753
754 // Video bitrate allocation generated, save until next time we send a report.
755 VideoBitrateAllocation allocation;
756 allocation.SetBitrate(0, 0, 100000);
757 rtcp_sender_->SetVideoBitrateAllocation(allocation);
758 // First seen instance will be sent immediately.
759 EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
760 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
761 clock_.AdvanceTimeMilliseconds(5);
762
763 // Update bitrate of existing layer, does not quality for immediate sending.
764 allocation.SetBitrate(0, 0, 150000);
765 rtcp_sender_->SetVideoBitrateAllocation(allocation);
766 EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
767
768 // A new spatial layer enabled, signal this as soon as possible.
769 allocation.SetBitrate(1, 0, 200000);
770 rtcp_sender_->SetVideoBitrateAllocation(allocation);
771 EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
772 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
773 clock_.AdvanceTimeMilliseconds(5);
774
775 // Explicitly disable top layer. The same set of layers now has a bitrate
776 // defined, but the explicit 0 indicates shutdown. Signal immediately.
777 allocation.SetBitrate(1, 0, 0);
778 EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
779 rtcp_sender_->SetVideoBitrateAllocation(allocation);
780 EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
781 }
782
TEST_F(RtcpSenderTest,SendTargetBitrateExplicitZeroOnStreamRemoval)783 TEST_F(RtcpSenderTest, SendTargetBitrateExplicitZeroOnStreamRemoval) {
784 // Set up and send a bitrate allocation with two layers.
785
786 rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
787 VideoBitrateAllocation allocation;
788 allocation.SetBitrate(0, 0, 100000);
789 allocation.SetBitrate(1, 0, 200000);
790 rtcp_sender_->SetVideoBitrateAllocation(allocation);
791 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
792 absl::optional<rtcp::TargetBitrate> target_bitrate =
793 parser()->xr()->target_bitrate();
794 ASSERT_TRUE(target_bitrate);
795 std::vector<rtcp::TargetBitrate::BitrateItem> bitrates =
796 target_bitrate->GetTargetBitrates();
797 ASSERT_EQ(2u, bitrates.size());
798 EXPECT_EQ(bitrates[0].target_bitrate_kbps,
799 allocation.GetBitrate(0, 0) / 1000);
800 EXPECT_EQ(bitrates[1].target_bitrate_kbps,
801 allocation.GetBitrate(1, 0) / 1000);
802
803 // Create a new allocation, where the second stream is no longer available.
804 VideoBitrateAllocation new_allocation;
805 new_allocation.SetBitrate(0, 0, 150000);
806 rtcp_sender_->SetVideoBitrateAllocation(new_allocation);
807 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
808 target_bitrate = parser()->xr()->target_bitrate();
809 ASSERT_TRUE(target_bitrate);
810 bitrates = target_bitrate->GetTargetBitrates();
811
812 // Two bitrates should still be set, with an explicit entry indicating the
813 // removed stream is gone.
814 ASSERT_EQ(2u, bitrates.size());
815 EXPECT_EQ(bitrates[0].target_bitrate_kbps,
816 new_allocation.GetBitrate(0, 0) / 1000);
817 EXPECT_EQ(bitrates[1].target_bitrate_kbps, 0u);
818 }
819
TEST_F(RtcpSenderTest,DoesntSchedulesInitialReportWhenSsrcSetOnConstruction)820 TEST_F(RtcpSenderTest, DoesntSchedulesInitialReportWhenSsrcSetOnConstruction) {
821 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
822 rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
823 // New report should not have been scheduled yet.
824 clock_.AdvanceTimeMilliseconds(100);
825 EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
826 }
827
TEST_F(RtcpSenderTest,SendsCombinedRtcpPacket)828 TEST_F(RtcpSenderTest, SendsCombinedRtcpPacket) {
829 rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
830
831 std::vector<std::unique_ptr<rtcp::RtcpPacket>> packets;
832 auto transport_feedback = std::make_unique<rtcp::TransportFeedback>();
833 transport_feedback->AddReceivedPacket(321, 10000);
834 packets.push_back(std::move(transport_feedback));
835 auto remote_estimate = std::make_unique<rtcp::RemoteEstimate>();
836 packets.push_back(std::move(remote_estimate));
837 rtcp_sender_->SendCombinedRtcpPacket(std::move(packets));
838
839 EXPECT_EQ(parser()->transport_feedback()->num_packets(), 1);
840 EXPECT_EQ(parser()->transport_feedback()->sender_ssrc(), kSenderSsrc);
841 EXPECT_EQ(parser()->app()->num_packets(), 1);
842 EXPECT_EQ(parser()->app()->sender_ssrc(), kSenderSsrc);
843 }
844
845 } // namespace webrtc
846