1 /*
2 * Copyright (c) 2013 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/rtp_rtcp_impl2.h"
12
13 #include <map>
14 #include <memory>
15 #include <set>
16
17 #include "api/transport/field_trial_based_config.h"
18 #include "api/video_codecs/video_codec.h"
19 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
20 #include "modules/rtp_rtcp/source/rtcp_packet.h"
21 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
22 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
23 #include "modules/rtp_rtcp/source/rtp_sender_video.h"
24 #include "rtc_base/rate_limiter.h"
25 #include "test/gmock.h"
26 #include "test/gtest.h"
27 #include "test/rtcp_packet_parser.h"
28 #include "test/rtp_header_parser.h"
29 #include "test/run_loop.h"
30 #include "test/time_controller/simulated_time_controller.h"
31
32 using ::testing::ElementsAre;
33
34 namespace webrtc {
35 namespace {
36 const uint32_t kSenderSsrc = 0x12345;
37 const uint32_t kReceiverSsrc = 0x23456;
38 const int64_t kOneWayNetworkDelayMs = 100;
39 const uint8_t kBaseLayerTid = 0;
40 const uint8_t kHigherLayerTid = 1;
41 const uint16_t kSequenceNumber = 100;
42
43 class RtcpRttStatsTestImpl : public RtcpRttStats {
44 public:
RtcpRttStatsTestImpl()45 RtcpRttStatsTestImpl() : rtt_ms_(0) {}
46 ~RtcpRttStatsTestImpl() override = default;
47
OnRttUpdate(int64_t rtt_ms)48 void OnRttUpdate(int64_t rtt_ms) override { rtt_ms_ = rtt_ms; }
LastProcessedRtt() const49 int64_t LastProcessedRtt() const override { return rtt_ms_; }
50 int64_t rtt_ms_;
51 };
52
53 class SendTransport : public Transport {
54 public:
SendTransport()55 SendTransport()
56 : receiver_(nullptr),
57 time_controller_(nullptr),
58 delay_ms_(0),
59 rtp_packets_sent_(0),
60 rtcp_packets_sent_(0) {}
61
SetRtpRtcpModule(ModuleRtpRtcpImpl2 * receiver)62 void SetRtpRtcpModule(ModuleRtpRtcpImpl2* receiver) { receiver_ = receiver; }
SimulateNetworkDelay(int64_t delay_ms,TimeController * time_controller)63 void SimulateNetworkDelay(int64_t delay_ms, TimeController* time_controller) {
64 time_controller_ = time_controller;
65 delay_ms_ = delay_ms;
66 }
SendRtp(const uint8_t * data,size_t len,const PacketOptions & options)67 bool SendRtp(const uint8_t* data,
68 size_t len,
69 const PacketOptions& options) override {
70 RTPHeader header;
71 std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::CreateForTest());
72 EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), len, &header));
73 ++rtp_packets_sent_;
74 last_rtp_header_ = header;
75 return true;
76 }
SendRtcp(const uint8_t * data,size_t len)77 bool SendRtcp(const uint8_t* data, size_t len) override {
78 test::RtcpPacketParser parser;
79 parser.Parse(data, len);
80 last_nack_list_ = parser.nack()->packet_ids();
81
82 if (time_controller_) {
83 time_controller_->AdvanceTime(TimeDelta::Millis(delay_ms_));
84 }
85 EXPECT_TRUE(receiver_);
86 receiver_->IncomingRtcpPacket(data, len);
87 ++rtcp_packets_sent_;
88 return true;
89 }
90
NumRtcpSent()91 size_t NumRtcpSent() { return rtcp_packets_sent_; }
92
93 ModuleRtpRtcpImpl2* receiver_;
94 TimeController* time_controller_;
95 int64_t delay_ms_;
96 int rtp_packets_sent_;
97 size_t rtcp_packets_sent_;
98 RTPHeader last_rtp_header_;
99 std::vector<uint16_t> last_nack_list_;
100 };
101
102 class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
103 public:
RtpRtcpModule(TimeController * time_controller,bool is_sender)104 RtpRtcpModule(TimeController* time_controller, bool is_sender)
105 : is_sender_(is_sender),
106 receive_statistics_(
107 ReceiveStatistics::Create(time_controller->GetClock())),
108 time_controller_(time_controller) {
109 CreateModuleImpl();
110 transport_.SimulateNetworkDelay(kOneWayNetworkDelayMs, time_controller);
111 }
112
113 const bool is_sender_;
114 RtcpPacketTypeCounter packets_sent_;
115 RtcpPacketTypeCounter packets_received_;
116 std::unique_ptr<ReceiveStatistics> receive_statistics_;
117 SendTransport transport_;
118 RtcpRttStatsTestImpl rtt_stats_;
119 std::unique_ptr<ModuleRtpRtcpImpl2> impl_;
120 int rtcp_report_interval_ms_ = 0;
121
RtcpPacketTypesCounterUpdated(uint32_t ssrc,const RtcpPacketTypeCounter & packet_counter)122 void RtcpPacketTypesCounterUpdated(
123 uint32_t ssrc,
124 const RtcpPacketTypeCounter& packet_counter) override {
125 counter_map_[ssrc] = packet_counter;
126 }
127
RtcpSent()128 RtcpPacketTypeCounter RtcpSent() {
129 // RTCP counters for remote SSRC.
130 return counter_map_[is_sender_ ? kReceiverSsrc : kSenderSsrc];
131 }
132
RtcpReceived()133 RtcpPacketTypeCounter RtcpReceived() {
134 // Received RTCP stats for (own) local SSRC.
135 return counter_map_[impl_->SSRC()];
136 }
RtpSent()137 int RtpSent() { return transport_.rtp_packets_sent_; }
LastRtpSequenceNumber()138 uint16_t LastRtpSequenceNumber() {
139 return transport_.last_rtp_header_.sequenceNumber;
140 }
LastNackListSent()141 std::vector<uint16_t> LastNackListSent() {
142 return transport_.last_nack_list_;
143 }
SetRtcpReportIntervalAndReset(int rtcp_report_interval_ms)144 void SetRtcpReportIntervalAndReset(int rtcp_report_interval_ms) {
145 rtcp_report_interval_ms_ = rtcp_report_interval_ms;
146 CreateModuleImpl();
147 }
148
149 private:
CreateModuleImpl()150 void CreateModuleImpl() {
151 RtpRtcpInterface::Configuration config;
152 config.audio = false;
153 config.clock = time_controller_->GetClock();
154 config.outgoing_transport = &transport_;
155 config.receive_statistics = receive_statistics_.get();
156 config.rtcp_packet_type_counter_observer = this;
157 config.rtt_stats = &rtt_stats_;
158 config.rtcp_report_interval_ms = rtcp_report_interval_ms_;
159 config.local_media_ssrc = is_sender_ ? kSenderSsrc : kReceiverSsrc;
160 config.need_rtp_packet_infos = true;
161
162 impl_.reset(new ModuleRtpRtcpImpl2(config));
163 impl_->SetRemoteSSRC(is_sender_ ? kReceiverSsrc : kSenderSsrc);
164 impl_->SetRTCPStatus(RtcpMode::kCompound);
165 }
166
167 TimeController* const time_controller_;
168 std::map<uint32_t, RtcpPacketTypeCounter> counter_map_;
169 };
170 } // namespace
171
172 class RtpRtcpImpl2Test : public ::testing::Test {
173 protected:
RtpRtcpImpl2Test()174 RtpRtcpImpl2Test()
175 : time_controller_(Timestamp::Micros(133590000000000)),
176 sender_(&time_controller_, /*is_sender=*/true),
177 receiver_(&time_controller_, /*is_sender=*/false) {}
178
SetUp()179 void SetUp() override {
180 // Send module.
181 EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
182 sender_.impl_->SetSendingMediaStatus(true);
183 sender_.impl_->SetSequenceNumber(kSequenceNumber);
184 sender_.impl_->SetStorePacketsStatus(true, 100);
185
186 FieldTrialBasedConfig field_trials;
187 RTPSenderVideo::Config video_config;
188 video_config.clock = time_controller_.GetClock();
189 video_config.rtp_sender = sender_.impl_->RtpSender();
190 video_config.field_trials = &field_trials;
191 sender_video_ = std::make_unique<RTPSenderVideo>(video_config);
192
193 memset(&codec_, 0, sizeof(VideoCodec));
194 codec_.plType = 100;
195 codec_.width = 320;
196 codec_.height = 180;
197
198 // Receive module.
199 EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
200 receiver_.impl_->SetSendingMediaStatus(false);
201 // Transport settings.
202 sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get());
203 receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
204 }
205
AdvanceTimeMs(int64_t milliseconds)206 void AdvanceTimeMs(int64_t milliseconds) {
207 time_controller_.AdvanceTime(TimeDelta::Millis(milliseconds));
208 }
209
210 GlobalSimulatedTimeController time_controller_;
211 // test::RunLoop loop_;
212 // SimulatedClock clock_;
213 RtpRtcpModule sender_;
214 std::unique_ptr<RTPSenderVideo> sender_video_;
215 RtpRtcpModule receiver_;
216 VideoCodec codec_;
217
SendFrame(const RtpRtcpModule * module,RTPSenderVideo * sender,uint8_t tid)218 void SendFrame(const RtpRtcpModule* module,
219 RTPSenderVideo* sender,
220 uint8_t tid) {
221 RTPVideoHeaderVP8 vp8_header = {};
222 vp8_header.temporalIdx = tid;
223 RTPVideoHeader rtp_video_header;
224 rtp_video_header.frame_type = VideoFrameType::kVideoFrameKey;
225 rtp_video_header.width = codec_.width;
226 rtp_video_header.height = codec_.height;
227 rtp_video_header.rotation = kVideoRotation_0;
228 rtp_video_header.content_type = VideoContentType::UNSPECIFIED;
229 rtp_video_header.playout_delay = {-1, -1};
230 rtp_video_header.is_first_packet_in_frame = true;
231 rtp_video_header.simulcastIdx = 0;
232 rtp_video_header.codec = kVideoCodecVP8;
233 rtp_video_header.video_type_header = vp8_header;
234 rtp_video_header.video_timing = {0u, 0u, 0u, 0u, 0u, 0u, false};
235
236 const uint8_t payload[100] = {0};
237 EXPECT_TRUE(module->impl_->OnSendingRtpFrame(0, 0, codec_.plType, true));
238 EXPECT_TRUE(sender->SendVideo(codec_.plType, VideoCodecType::kVideoCodecVP8,
239 0, 0, payload, rtp_video_header, 0));
240 }
241
IncomingRtcpNack(const RtpRtcpModule * module,uint16_t sequence_number)242 void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) {
243 bool sender = module->impl_->SSRC() == kSenderSsrc;
244 rtcp::Nack nack;
245 uint16_t list[1];
246 list[0] = sequence_number;
247 const uint16_t kListLength = sizeof(list) / sizeof(list[0]);
248 nack.SetSenderSsrc(sender ? kReceiverSsrc : kSenderSsrc);
249 nack.SetMediaSsrc(sender ? kSenderSsrc : kReceiverSsrc);
250 nack.SetPacketIds(list, kListLength);
251 rtc::Buffer packet = nack.Build();
252 module->impl_->IncomingRtcpPacket(packet.data(), packet.size());
253 }
254 };
255
TEST_F(RtpRtcpImpl2Test,RetransmitsAllLayers)256 TEST_F(RtpRtcpImpl2Test, RetransmitsAllLayers) {
257 // Send frames.
258 EXPECT_EQ(0, sender_.RtpSent());
259 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid); // kSequenceNumber
260 SendFrame(&sender_, sender_video_.get(),
261 kHigherLayerTid); // kSequenceNumber + 1
262 SendFrame(&sender_, sender_video_.get(),
263 kNoTemporalIdx); // kSequenceNumber + 2
264 EXPECT_EQ(3, sender_.RtpSent());
265 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
266
267 // Min required delay until retransmit = 5 + RTT ms (RTT = 0).
268 AdvanceTimeMs(5);
269
270 // Frame with kBaseLayerTid re-sent.
271 IncomingRtcpNack(&sender_, kSequenceNumber);
272 EXPECT_EQ(4, sender_.RtpSent());
273 EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
274 // Frame with kHigherLayerTid re-sent.
275 IncomingRtcpNack(&sender_, kSequenceNumber + 1);
276 EXPECT_EQ(5, sender_.RtpSent());
277 EXPECT_EQ(kSequenceNumber + 1, sender_.LastRtpSequenceNumber());
278 // Frame with kNoTemporalIdx re-sent.
279 IncomingRtcpNack(&sender_, kSequenceNumber + 2);
280 EXPECT_EQ(6, sender_.RtpSent());
281 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
282 }
283
TEST_F(RtpRtcpImpl2Test,Rtt)284 TEST_F(RtpRtcpImpl2Test, Rtt) {
285 RtpPacketReceived packet;
286 packet.SetTimestamp(1);
287 packet.SetSequenceNumber(123);
288 packet.SetSsrc(kSenderSsrc);
289 packet.AllocatePayload(100 - 12);
290 receiver_.receive_statistics_->OnRtpPacket(packet);
291
292 // Send Frame before sending an SR.
293 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
294 // Sender module should send an SR.
295 EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
296
297 // Receiver module should send a RR with a response to the last received SR.
298 AdvanceTimeMs(1000);
299 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
300
301 // Verify RTT.
302 int64_t rtt;
303 int64_t avg_rtt;
304 int64_t min_rtt;
305 int64_t max_rtt;
306 EXPECT_EQ(
307 0, sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt));
308 EXPECT_NEAR(2 * kOneWayNetworkDelayMs, rtt, 1);
309 EXPECT_NEAR(2 * kOneWayNetworkDelayMs, avg_rtt, 1);
310 EXPECT_NEAR(2 * kOneWayNetworkDelayMs, min_rtt, 1);
311 EXPECT_NEAR(2 * kOneWayNetworkDelayMs, max_rtt, 1);
312
313 // No RTT from other ssrc.
314 EXPECT_EQ(-1, sender_.impl_->RTT(kReceiverSsrc + 1, &rtt, &avg_rtt, &min_rtt,
315 &max_rtt));
316
317 // Verify RTT from rtt_stats config.
318 EXPECT_EQ(0, sender_.rtt_stats_.LastProcessedRtt());
319 EXPECT_EQ(0, sender_.impl_->rtt_ms());
320 AdvanceTimeMs(1000);
321
322 EXPECT_NEAR(2 * kOneWayNetworkDelayMs, sender_.rtt_stats_.LastProcessedRtt(),
323 1);
324 EXPECT_NEAR(2 * kOneWayNetworkDelayMs, sender_.impl_->rtt_ms(), 1);
325 }
326
TEST_F(RtpRtcpImpl2Test,SetRtcpXrRrtrStatus)327 TEST_F(RtpRtcpImpl2Test, SetRtcpXrRrtrStatus) {
328 EXPECT_FALSE(receiver_.impl_->RtcpXrRrtrStatus());
329 receiver_.impl_->SetRtcpXrRrtrStatus(true);
330 EXPECT_TRUE(receiver_.impl_->RtcpXrRrtrStatus());
331 }
332
TEST_F(RtpRtcpImpl2Test,RttForReceiverOnly)333 TEST_F(RtpRtcpImpl2Test, RttForReceiverOnly) {
334 receiver_.impl_->SetRtcpXrRrtrStatus(true);
335
336 // Receiver module should send a Receiver time reference report (RTRR).
337 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
338
339 // Sender module should send a response to the last received RTRR (DLRR).
340 AdvanceTimeMs(1000);
341 // Send Frame before sending a SR.
342 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
343 EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
344
345 // Verify RTT.
346 EXPECT_EQ(0, receiver_.rtt_stats_.LastProcessedRtt());
347 EXPECT_EQ(0, receiver_.impl_->rtt_ms());
348 AdvanceTimeMs(1000);
349 EXPECT_NEAR(2 * kOneWayNetworkDelayMs,
350 receiver_.rtt_stats_.LastProcessedRtt(), 1);
351 EXPECT_NEAR(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms(), 1);
352 }
353
TEST_F(RtpRtcpImpl2Test,NoSrBeforeMedia)354 TEST_F(RtpRtcpImpl2Test, NoSrBeforeMedia) {
355 // Ignore fake transport delays in this test.
356 sender_.transport_.SimulateNetworkDelay(0, &time_controller_);
357 receiver_.transport_.SimulateNetworkDelay(0, &time_controller_);
358
359 sender_.impl_->Process();
360 EXPECT_EQ(-1, sender_.RtcpSent().first_packet_time_ms);
361
362 // Verify no SR is sent before media has been sent, RR should still be sent
363 // from the receiving module though.
364 AdvanceTimeMs(2000);
365 int64_t current_time = time_controller_.GetClock()->TimeInMilliseconds();
366 sender_.impl_->Process();
367 receiver_.impl_->Process();
368 EXPECT_EQ(-1, sender_.RtcpSent().first_packet_time_ms);
369 EXPECT_EQ(receiver_.RtcpSent().first_packet_time_ms, current_time);
370
371 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
372 EXPECT_EQ(sender_.RtcpSent().first_packet_time_ms, current_time);
373 }
374
TEST_F(RtpRtcpImpl2Test,RtcpPacketTypeCounter_Nack)375 TEST_F(RtpRtcpImpl2Test, RtcpPacketTypeCounter_Nack) {
376 EXPECT_EQ(-1, receiver_.RtcpSent().first_packet_time_ms);
377 EXPECT_EQ(-1, sender_.RtcpReceived().first_packet_time_ms);
378 EXPECT_EQ(0U, sender_.RtcpReceived().nack_packets);
379 EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
380
381 // Receive module sends a NACK.
382 const uint16_t kNackLength = 1;
383 uint16_t nack_list[kNackLength] = {123};
384 EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
385 EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
386 EXPECT_GT(receiver_.RtcpSent().first_packet_time_ms, -1);
387
388 // Send module receives the NACK.
389 EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
390 EXPECT_GT(sender_.RtcpReceived().first_packet_time_ms, -1);
391 }
392
TEST_F(RtpRtcpImpl2Test,AddStreamDataCounters)393 TEST_F(RtpRtcpImpl2Test, AddStreamDataCounters) {
394 StreamDataCounters rtp;
395 const int64_t kStartTimeMs = 1;
396 rtp.first_packet_time_ms = kStartTimeMs;
397 rtp.transmitted.packets = 1;
398 rtp.transmitted.payload_bytes = 1;
399 rtp.transmitted.header_bytes = 2;
400 rtp.transmitted.padding_bytes = 3;
401 EXPECT_EQ(rtp.transmitted.TotalBytes(), rtp.transmitted.payload_bytes +
402 rtp.transmitted.header_bytes +
403 rtp.transmitted.padding_bytes);
404
405 StreamDataCounters rtp2;
406 rtp2.first_packet_time_ms = -1;
407 rtp2.transmitted.packets = 10;
408 rtp2.transmitted.payload_bytes = 10;
409 rtp2.retransmitted.header_bytes = 4;
410 rtp2.retransmitted.payload_bytes = 5;
411 rtp2.retransmitted.padding_bytes = 6;
412 rtp2.retransmitted.packets = 7;
413 rtp2.fec.packets = 8;
414
415 StreamDataCounters sum = rtp;
416 sum.Add(rtp2);
417 EXPECT_EQ(kStartTimeMs, sum.first_packet_time_ms);
418 EXPECT_EQ(11U, sum.transmitted.packets);
419 EXPECT_EQ(11U, sum.transmitted.payload_bytes);
420 EXPECT_EQ(2U, sum.transmitted.header_bytes);
421 EXPECT_EQ(3U, sum.transmitted.padding_bytes);
422 EXPECT_EQ(4U, sum.retransmitted.header_bytes);
423 EXPECT_EQ(5U, sum.retransmitted.payload_bytes);
424 EXPECT_EQ(6U, sum.retransmitted.padding_bytes);
425 EXPECT_EQ(7U, sum.retransmitted.packets);
426 EXPECT_EQ(8U, sum.fec.packets);
427 EXPECT_EQ(sum.transmitted.TotalBytes(),
428 rtp.transmitted.TotalBytes() + rtp2.transmitted.TotalBytes());
429
430 StreamDataCounters rtp3;
431 rtp3.first_packet_time_ms = kStartTimeMs + 10;
432 sum.Add(rtp3);
433 EXPECT_EQ(kStartTimeMs, sum.first_packet_time_ms); // Holds oldest time.
434 }
435
TEST_F(RtpRtcpImpl2Test,SendsInitialNackList)436 TEST_F(RtpRtcpImpl2Test, SendsInitialNackList) {
437 // Send module sends a NACK.
438 const uint16_t kNackLength = 1;
439 uint16_t nack_list[kNackLength] = {123};
440 EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
441 // Send Frame before sending a compound RTCP that starts with SR.
442 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
443 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
444 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
445 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
446 }
447
TEST_F(RtpRtcpImpl2Test,SendsExtendedNackList)448 TEST_F(RtpRtcpImpl2Test, SendsExtendedNackList) {
449 // Send module sends a NACK.
450 const uint16_t kNackLength = 1;
451 uint16_t nack_list[kNackLength] = {123};
452 EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
453 // Send Frame before sending a compound RTCP that starts with SR.
454 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
455 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
456 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
457 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
458
459 // Same list not re-send.
460 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
461 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
462 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
463
464 // Only extended list sent.
465 const uint16_t kNackExtLength = 2;
466 uint16_t nack_list_ext[kNackExtLength] = {123, 124};
467 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list_ext, kNackExtLength));
468 EXPECT_EQ(2U, sender_.RtcpSent().nack_packets);
469 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(124));
470 }
471
TEST_F(RtpRtcpImpl2Test,ReSendsNackListAfterRttMs)472 TEST_F(RtpRtcpImpl2Test, ReSendsNackListAfterRttMs) {
473 sender_.transport_.SimulateNetworkDelay(0, &time_controller_);
474 // Send module sends a NACK.
475 const uint16_t kNackLength = 2;
476 uint16_t nack_list[kNackLength] = {123, 125};
477 EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
478 // Send Frame before sending a compound RTCP that starts with SR.
479 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
480 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
481 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
482 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
483
484 // Same list not re-send, rtt interval has not passed.
485 const int kStartupRttMs = 100;
486 AdvanceTimeMs(kStartupRttMs);
487 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
488 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
489
490 // Rtt interval passed, full list sent.
491 AdvanceTimeMs(1);
492 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
493 EXPECT_EQ(2U, sender_.RtcpSent().nack_packets);
494 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
495 }
496
TEST_F(RtpRtcpImpl2Test,UniqueNackRequests)497 TEST_F(RtpRtcpImpl2Test, UniqueNackRequests) {
498 receiver_.transport_.SimulateNetworkDelay(0, &time_controller_);
499 EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
500 EXPECT_EQ(0U, receiver_.RtcpSent().nack_requests);
501 EXPECT_EQ(0U, receiver_.RtcpSent().unique_nack_requests);
502 EXPECT_EQ(0, receiver_.RtcpSent().UniqueNackRequestsInPercent());
503
504 // Receive module sends NACK request.
505 const uint16_t kNackLength = 4;
506 uint16_t nack_list[kNackLength] = {10, 11, 13, 18};
507 EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
508 EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
509 EXPECT_EQ(4U, receiver_.RtcpSent().nack_requests);
510 EXPECT_EQ(4U, receiver_.RtcpSent().unique_nack_requests);
511 EXPECT_THAT(receiver_.LastNackListSent(), ElementsAre(10, 11, 13, 18));
512
513 // Send module receives the request.
514 EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
515 EXPECT_EQ(4U, sender_.RtcpReceived().nack_requests);
516 EXPECT_EQ(4U, sender_.RtcpReceived().unique_nack_requests);
517 EXPECT_EQ(100, sender_.RtcpReceived().UniqueNackRequestsInPercent());
518
519 // Receive module sends new request with duplicated packets.
520 const int kStartupRttMs = 100;
521 AdvanceTimeMs(kStartupRttMs + 1);
522 const uint16_t kNackLength2 = 4;
523 uint16_t nack_list2[kNackLength2] = {11, 18, 20, 21};
524 EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list2, kNackLength2));
525 EXPECT_EQ(2U, receiver_.RtcpSent().nack_packets);
526 EXPECT_EQ(8U, receiver_.RtcpSent().nack_requests);
527 EXPECT_EQ(6U, receiver_.RtcpSent().unique_nack_requests);
528 EXPECT_THAT(receiver_.LastNackListSent(), ElementsAre(11, 18, 20, 21));
529
530 // Send module receives the request.
531 EXPECT_EQ(2U, sender_.RtcpReceived().nack_packets);
532 EXPECT_EQ(8U, sender_.RtcpReceived().nack_requests);
533 EXPECT_EQ(6U, sender_.RtcpReceived().unique_nack_requests);
534 EXPECT_EQ(75, sender_.RtcpReceived().UniqueNackRequestsInPercent());
535 }
536
TEST_F(RtpRtcpImpl2Test,ConfigurableRtcpReportInterval)537 TEST_F(RtpRtcpImpl2Test, ConfigurableRtcpReportInterval) {
538 const int kVideoReportInterval = 3000;
539
540 // Recreate sender impl with new configuration, and redo setup.
541 sender_.SetRtcpReportIntervalAndReset(kVideoReportInterval);
542 SetUp();
543
544 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
545
546 // Initial state
547 sender_.impl_->Process();
548 EXPECT_EQ(sender_.RtcpSent().first_packet_time_ms, -1);
549 EXPECT_EQ(0u, sender_.transport_.NumRtcpSent());
550
551 // Move ahead to the last ms before a rtcp is expected, no action.
552 AdvanceTimeMs(kVideoReportInterval / 2 - 1);
553 sender_.impl_->Process();
554 EXPECT_EQ(sender_.RtcpSent().first_packet_time_ms, -1);
555 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 0u);
556
557 // Move ahead to the first rtcp. Send RTCP.
558 AdvanceTimeMs(1);
559 sender_.impl_->Process();
560 EXPECT_GT(sender_.RtcpSent().first_packet_time_ms, -1);
561 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u);
562
563 SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
564
565 // Move ahead to the last possible second before second rtcp is expected.
566 AdvanceTimeMs(kVideoReportInterval * 1 / 2 - 1);
567 sender_.impl_->Process();
568 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u);
569
570 // Move ahead into the range of second rtcp, the second rtcp may be sent.
571 AdvanceTimeMs(1);
572 sender_.impl_->Process();
573 EXPECT_GE(sender_.transport_.NumRtcpSent(), 1u);
574
575 AdvanceTimeMs(kVideoReportInterval / 2);
576 sender_.impl_->Process();
577 EXPECT_GE(sender_.transport_.NumRtcpSent(), 1u);
578
579 // Move out the range of second rtcp, the second rtcp must have been sent.
580 AdvanceTimeMs(kVideoReportInterval / 2);
581 sender_.impl_->Process();
582 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 2u);
583 }
584
TEST_F(RtpRtcpImpl2Test,StoresPacketInfoForSentPackets)585 TEST_F(RtpRtcpImpl2Test, StoresPacketInfoForSentPackets) {
586 const uint32_t kStartTimestamp = 1u;
587 SetUp();
588 sender_.impl_->SetStartTimestamp(kStartTimestamp);
589
590 PacedPacketInfo pacing_info;
591 RtpPacketToSend packet(nullptr);
592 packet.set_packet_type(RtpPacketToSend::Type::kVideo);
593 packet.SetSsrc(kSenderSsrc);
594
595 // Single-packet frame.
596 packet.SetTimestamp(1);
597 packet.SetSequenceNumber(1);
598 packet.set_first_packet_of_frame(true);
599 packet.SetMarker(true);
600 sender_.impl_->TrySendPacket(&packet, pacing_info);
601 AdvanceTimeMs(1);
602
603 std::vector<RtpSequenceNumberMap::Info> seqno_info =
604 sender_.impl_->GetSentRtpPacketInfos(std::vector<uint16_t>{1});
605
606 EXPECT_THAT(seqno_info, ElementsAre(RtpSequenceNumberMap::Info(
607 /*timestamp=*/1 - kStartTimestamp,
608 /*is_first=*/1,
609 /*is_last=*/1)));
610
611 // Three-packet frame.
612 packet.SetTimestamp(2);
613 packet.SetSequenceNumber(2);
614 packet.set_first_packet_of_frame(true);
615 packet.SetMarker(false);
616 sender_.impl_->TrySendPacket(&packet, pacing_info);
617
618 packet.SetSequenceNumber(3);
619 packet.set_first_packet_of_frame(false);
620 sender_.impl_->TrySendPacket(&packet, pacing_info);
621
622 packet.SetSequenceNumber(4);
623 packet.SetMarker(true);
624 sender_.impl_->TrySendPacket(&packet, pacing_info);
625
626 AdvanceTimeMs(1);
627
628 seqno_info =
629 sender_.impl_->GetSentRtpPacketInfos(std::vector<uint16_t>{2, 3, 4});
630
631 EXPECT_THAT(seqno_info, ElementsAre(RtpSequenceNumberMap::Info(
632 /*timestamp=*/2 - kStartTimestamp,
633 /*is_first=*/1,
634 /*is_last=*/0),
635 RtpSequenceNumberMap::Info(
636 /*timestamp=*/2 - kStartTimestamp,
637 /*is_first=*/0,
638 /*is_last=*/0),
639 RtpSequenceNumberMap::Info(
640 /*timestamp=*/2 - kStartTimestamp,
641 /*is_first=*/0,
642 /*is_last=*/1)));
643 }
644
645 } // namespace webrtc
646