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