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 <deque>
14 #include <map>
15 #include <memory>
16 #include <set>
17 #include <utility>
18
19 #include "absl/types/optional.h"
20 #include "api/field_trials_registry.h"
21 #include "api/units/time_delta.h"
22 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
23 #include "modules/rtp_rtcp/source/rtcp_packet.h"
24 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
25 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
26 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
27 #include "modules/rtp_rtcp/source/rtp_sender_video.h"
28 #include "rtc_base/logging.h"
29 #include "rtc_base/rate_limiter.h"
30 #include "rtc_base/strings/string_builder.h"
31 #include "test/explicit_key_value_config.h"
32 #include "test/gmock.h"
33 #include "test/gtest.h"
34 #include "test/rtcp_packet_parser.h"
35 #include "test/run_loop.h"
36 #include "test/time_controller/simulated_time_controller.h"
37
38 using ::testing::AllOf;
39 using ::testing::ElementsAre;
40 using ::testing::Eq;
41 using ::testing::Field;
42 using ::testing::Gt;
43 using ::testing::Not;
44 using ::testing::Optional;
45 using ::testing::SizeIs;
46
47 using webrtc::test::ExplicitKeyValueConfig;
48
49 namespace webrtc {
50 namespace {
51 constexpr uint32_t kSenderSsrc = 0x12345;
52 constexpr uint32_t kReceiverSsrc = 0x23456;
53 constexpr uint32_t kRtxSenderSsrc = 0x12346;
54 constexpr TimeDelta kOneWayNetworkDelay = TimeDelta::Millis(100);
55 constexpr uint8_t kBaseLayerTid = 0;
56 constexpr uint8_t kHigherLayerTid = 1;
57 constexpr uint16_t kSequenceNumber = 100;
58 constexpr uint8_t kPayloadType = 100;
59 constexpr uint8_t kRtxPayloadType = 98;
60 constexpr int kWidth = 320;
61 constexpr int kHeight = 100;
62 constexpr int kCaptureTimeMsToRtpTimestamp = 90; // 90 kHz clock.
63 constexpr TimeDelta kDefaultReportInterval = TimeDelta::Millis(1000);
64
65 // RTP header extension ids.
66 enum : int {
67 kAbsoluteSendTimeExtensionId = 1,
68 kTransportSequenceNumberExtensionId,
69 kTransmissionOffsetExtensionId,
70 };
71
72 class RtcpRttStatsTestImpl : public RtcpRttStats {
73 public:
RtcpRttStatsTestImpl()74 RtcpRttStatsTestImpl() : rtt_ms_(0) {}
75 ~RtcpRttStatsTestImpl() override = default;
76
OnRttUpdate(int64_t rtt_ms)77 void OnRttUpdate(int64_t rtt_ms) override { rtt_ms_ = rtt_ms; }
LastProcessedRtt() const78 int64_t LastProcessedRtt() const override { return rtt_ms_; }
79 int64_t rtt_ms_;
80 };
81
82 // TODO(bugs.webrtc.org/11581): remove inheritance once the ModuleRtpRtcpImpl2
83 // Module/ProcessThread dependency is gone.
84 class SendTransport : public Transport,
85 public sim_time_impl::SimulatedSequenceRunner {
86 public:
SendTransport(TimeDelta delay,GlobalSimulatedTimeController * time_controller)87 SendTransport(TimeDelta delay, GlobalSimulatedTimeController* time_controller)
88 : receiver_(nullptr),
89 time_controller_(time_controller),
90 delay_(delay),
91 rtp_packets_sent_(0),
92 rtcp_packets_sent_(0),
93 last_packet_(&header_extensions_) {
94 time_controller_->Register(this);
95 }
96
~SendTransport()97 ~SendTransport() { time_controller_->Unregister(this); }
98
SetRtpRtcpModule(ModuleRtpRtcpImpl2 * receiver)99 void SetRtpRtcpModule(ModuleRtpRtcpImpl2* receiver) { receiver_ = receiver; }
SimulateNetworkDelay(TimeDelta delay)100 void SimulateNetworkDelay(TimeDelta delay) { delay_ = delay; }
SendRtp(const uint8_t * data,size_t len,const PacketOptions & options)101 bool SendRtp(const uint8_t* data,
102 size_t len,
103 const PacketOptions& options) override {
104 EXPECT_TRUE(last_packet_.Parse(data, len));
105 ++rtp_packets_sent_;
106 return true;
107 }
SendRtcp(const uint8_t * data,size_t len)108 bool SendRtcp(const uint8_t* data, size_t len) override {
109 test::RtcpPacketParser parser;
110 parser.Parse(data, len);
111 last_nack_list_ = parser.nack()->packet_ids();
112 Timestamp current_time = time_controller_->GetClock()->CurrentTime();
113 Timestamp delivery_time = current_time + delay_;
114 rtcp_packets_.push_back(
115 Packet{delivery_time, std::vector<uint8_t>(data, data + len)});
116 ++rtcp_packets_sent_;
117 RunReady(current_time);
118 return true;
119 }
120
121 // sim_time_impl::SimulatedSequenceRunner
GetNextRunTime() const122 Timestamp GetNextRunTime() const override {
123 if (!rtcp_packets_.empty())
124 return rtcp_packets_.front().send_time;
125 return Timestamp::PlusInfinity();
126 }
RunReady(Timestamp at_time)127 void RunReady(Timestamp at_time) override {
128 while (!rtcp_packets_.empty() &&
129 rtcp_packets_.front().send_time <= at_time) {
130 Packet packet = std::move(rtcp_packets_.front());
131 rtcp_packets_.pop_front();
132 EXPECT_TRUE(receiver_);
133 receiver_->IncomingRtcpPacket(packet.data.data(), packet.data.size());
134 }
135 }
GetAsTaskQueue()136 TaskQueueBase* GetAsTaskQueue() override {
137 return reinterpret_cast<TaskQueueBase*>(this);
138 }
139
NumRtcpSent()140 size_t NumRtcpSent() { return rtcp_packets_sent_; }
141
142 ModuleRtpRtcpImpl2* receiver_;
143 GlobalSimulatedTimeController* const time_controller_;
144 TimeDelta delay_;
145 int rtp_packets_sent_;
146 size_t rtcp_packets_sent_;
147 std::vector<uint16_t> last_nack_list_;
148 RtpHeaderExtensionMap header_extensions_;
149 RtpPacketReceived last_packet_;
150 struct Packet {
151 Timestamp send_time;
152 std::vector<uint8_t> data;
153 };
154 std::deque<Packet> rtcp_packets_;
155 };
156
157 class RtpRtcpModule : public RtcpPacketTypeCounterObserver,
158 public SendPacketObserver {
159 public:
160 struct SentPacket {
SentPacketwebrtc::__anon0ef847c40111::RtpRtcpModule::SentPacket161 SentPacket(uint16_t packet_id, int64_t capture_time_ms, uint32_t ssrc)
162 : packet_id(packet_id), capture_time_ms(capture_time_ms), ssrc(ssrc) {}
163 uint16_t packet_id;
164 int64_t capture_time_ms;
165 uint32_t ssrc;
166 };
167
RtpRtcpModule(GlobalSimulatedTimeController * time_controller,bool is_sender,const FieldTrialsRegistry & trials)168 RtpRtcpModule(GlobalSimulatedTimeController* time_controller,
169 bool is_sender,
170 const FieldTrialsRegistry& trials)
171 : time_controller_(time_controller),
172 is_sender_(is_sender),
173 trials_(trials),
174 receive_statistics_(
175 ReceiveStatistics::Create(time_controller->GetClock())),
176 transport_(kOneWayNetworkDelay, time_controller) {
177 CreateModuleImpl();
178 }
179
180 TimeController* const time_controller_;
181 const bool is_sender_;
182 const FieldTrialsRegistry& trials_;
183 RtcpPacketTypeCounter packets_sent_;
184 RtcpPacketTypeCounter packets_received_;
185 std::unique_ptr<ReceiveStatistics> receive_statistics_;
186 SendTransport transport_;
187 RtcpRttStatsTestImpl rtt_stats_;
188 std::unique_ptr<ModuleRtpRtcpImpl2> impl_;
189
RtcpPacketTypesCounterUpdated(uint32_t ssrc,const RtcpPacketTypeCounter & packet_counter)190 void RtcpPacketTypesCounterUpdated(
191 uint32_t ssrc,
192 const RtcpPacketTypeCounter& packet_counter) override {
193 counter_map_[ssrc] = packet_counter;
194 }
195
OnSendPacket(uint16_t packet_id,int64_t capture_time_ms,uint32_t ssrc)196 void OnSendPacket(uint16_t packet_id,
197 int64_t capture_time_ms,
198 uint32_t ssrc) override {
199 last_sent_packet_.emplace(packet_id, capture_time_ms, ssrc);
200 }
201
last_sent_packet() const202 absl::optional<SentPacket> last_sent_packet() const {
203 return last_sent_packet_;
204 }
205
RtcpSent()206 RtcpPacketTypeCounter RtcpSent() {
207 // RTCP counters for remote SSRC.
208 return counter_map_[is_sender_ ? kReceiverSsrc : kSenderSsrc];
209 }
210
RtcpReceived()211 RtcpPacketTypeCounter RtcpReceived() {
212 // Received RTCP stats for (own) local SSRC.
213 return counter_map_[impl_->SSRC()];
214 }
RtpSent()215 int RtpSent() { return transport_.rtp_packets_sent_; }
LastRtpSequenceNumber()216 uint16_t LastRtpSequenceNumber() { return last_packet().SequenceNumber(); }
LastNackListSent()217 std::vector<uint16_t> LastNackListSent() {
218 return transport_.last_nack_list_;
219 }
SetRtcpReportIntervalAndReset(TimeDelta rtcp_report_interval)220 void SetRtcpReportIntervalAndReset(TimeDelta rtcp_report_interval) {
221 rtcp_report_interval_ = rtcp_report_interval;
222 CreateModuleImpl();
223 }
last_packet()224 const RtpPacketReceived& last_packet() { return transport_.last_packet_; }
RegisterHeaderExtension(absl::string_view uri,int id)225 void RegisterHeaderExtension(absl::string_view uri, int id) {
226 impl_->RegisterRtpHeaderExtension(uri, id);
227 transport_.header_extensions_.RegisterByUri(id, uri);
228 transport_.last_packet_.IdentifyExtensions(transport_.header_extensions_);
229 }
ReinintWithFec(VideoFecGenerator * fec_generator)230 void ReinintWithFec(VideoFecGenerator* fec_generator) {
231 fec_generator_ = fec_generator;
232 CreateModuleImpl();
233 }
234
CreateModuleImpl()235 void CreateModuleImpl() {
236 RtpRtcpInterface::Configuration config;
237 config.audio = false;
238 config.clock = time_controller_->GetClock();
239 config.outgoing_transport = &transport_;
240 config.receive_statistics = receive_statistics_.get();
241 config.rtcp_packet_type_counter_observer = this;
242 config.rtt_stats = &rtt_stats_;
243 config.rtcp_report_interval_ms = rtcp_report_interval_.ms();
244 config.local_media_ssrc = is_sender_ ? kSenderSsrc : kReceiverSsrc;
245 config.rtx_send_ssrc =
246 is_sender_ ? absl::make_optional(kRtxSenderSsrc) : absl::nullopt;
247 config.need_rtp_packet_infos = true;
248 config.non_sender_rtt_measurement = true;
249 config.field_trials = &trials_;
250 config.send_packet_observer = this;
251 config.fec_generator = fec_generator_;
252 impl_.reset(new ModuleRtpRtcpImpl2(config));
253 impl_->SetRemoteSSRC(is_sender_ ? kReceiverSsrc : kSenderSsrc);
254 impl_->SetRTCPStatus(RtcpMode::kCompound);
255 }
256
257 private:
258 std::map<uint32_t, RtcpPacketTypeCounter> counter_map_;
259 absl::optional<SentPacket> last_sent_packet_;
260 VideoFecGenerator* fec_generator_ = nullptr;
261 TimeDelta rtcp_report_interval_ = kDefaultReportInterval;
262 };
263 } // namespace
264
265 class RtpRtcpImpl2Test : public ::testing::Test {
266 protected:
RtpRtcpImpl2Test()267 RtpRtcpImpl2Test()
268 : time_controller_(Timestamp::Micros(133590000000000)),
269 field_trials_(""),
270 sender_(&time_controller_,
271 /*is_sender=*/true,
272 field_trials_),
273 receiver_(&time_controller_,
274 /*is_sender=*/false,
275 field_trials_) {}
276
SetUp()277 void SetUp() override {
278 // Send module.
279 EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
280 sender_.impl_->SetSendingMediaStatus(true);
281 sender_.impl_->SetSequenceNumber(kSequenceNumber);
282 sender_.impl_->SetStorePacketsStatus(true, 100);
283
284 RTPSenderVideo::Config video_config;
285 video_config.clock = time_controller_.GetClock();
286 video_config.rtp_sender = sender_.impl_->RtpSender();
287 video_config.field_trials = &field_trials_;
288 sender_video_ = std::make_unique<RTPSenderVideo>(video_config);
289
290 // Receive module.
291 EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
292 receiver_.impl_->SetSendingMediaStatus(false);
293 // Transport settings.
294 sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get());
295 receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
296 }
297
AdvanceTime(TimeDelta duration)298 void AdvanceTime(TimeDelta duration) {
299 time_controller_.AdvanceTime(duration);
300 }
301
ReinitWithFec(VideoFecGenerator * fec_generator,absl::optional<int> red_payload_type)302 void ReinitWithFec(VideoFecGenerator* fec_generator,
303 absl::optional<int> red_payload_type) {
304 sender_.ReinintWithFec(fec_generator);
305 EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
306 sender_.impl_->SetSendingMediaStatus(true);
307 sender_.impl_->SetSequenceNumber(kSequenceNumber);
308 sender_.impl_->SetStorePacketsStatus(true, 100);
309 receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
310
311 RTPSenderVideo::Config video_config;
312 video_config.clock = time_controller_.GetClock();
313 video_config.rtp_sender = sender_.impl_->RtpSender();
314 video_config.field_trials = &field_trials_;
315 video_config.fec_overhead_bytes = fec_generator->MaxPacketOverhead();
316 video_config.fec_type = fec_generator->GetFecType();
317 video_config.red_payload_type = red_payload_type;
318 sender_video_ = std::make_unique<RTPSenderVideo>(video_config);
319 }
320
321 GlobalSimulatedTimeController time_controller_;
322 test::ExplicitKeyValueConfig field_trials_;
323 RtpRtcpModule sender_;
324 std::unique_ptr<RTPSenderVideo> sender_video_;
325 RtpRtcpModule receiver_;
326
SendFrame(const RtpRtcpModule * module,RTPSenderVideo * sender,uint8_t tid)327 bool SendFrame(const RtpRtcpModule* module,
328 RTPSenderVideo* sender,
329 uint8_t tid) {
330 int64_t now_ms = time_controller_.GetClock()->TimeInMilliseconds();
331 return SendFrame(
332 module, sender, tid,
333 static_cast<uint32_t>(now_ms * kCaptureTimeMsToRtpTimestamp), now_ms);
334 }
335
SendFrame(const RtpRtcpModule * module,RTPSenderVideo * sender,uint8_t tid,uint32_t rtp_timestamp,int64_t capture_time_ms)336 bool SendFrame(const RtpRtcpModule* module,
337 RTPSenderVideo* sender,
338 uint8_t tid,
339 uint32_t rtp_timestamp,
340 int64_t capture_time_ms) {
341 RTPVideoHeaderVP8 vp8_header = {};
342 vp8_header.temporalIdx = tid;
343 RTPVideoHeader rtp_video_header;
344 rtp_video_header.frame_type = VideoFrameType::kVideoFrameKey;
345 rtp_video_header.width = kWidth;
346 rtp_video_header.height = kHeight;
347 rtp_video_header.rotation = kVideoRotation_0;
348 rtp_video_header.content_type = VideoContentType::UNSPECIFIED;
349 rtp_video_header.playout_delay = {-1, -1};
350 rtp_video_header.is_first_packet_in_frame = true;
351 rtp_video_header.simulcastIdx = 0;
352 rtp_video_header.codec = kVideoCodecVP8;
353 rtp_video_header.video_type_header = vp8_header;
354 rtp_video_header.video_timing = {0u, 0u, 0u, 0u, 0u, 0u, false};
355
356 const uint8_t payload[100] = {0};
357 bool success = module->impl_->OnSendingRtpFrame(0, 0, kPayloadType, true);
358
359 success &= sender->SendVideo(kPayloadType, VideoCodecType::kVideoCodecVP8,
360 rtp_timestamp, capture_time_ms, payload,
361 rtp_video_header, 0);
362 return success;
363 }
364
IncomingRtcpNack(const RtpRtcpModule * module,uint16_t sequence_number)365 void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) {
366 bool sender = module->impl_->SSRC() == kSenderSsrc;
367 rtcp::Nack nack;
368 uint16_t list[1];
369 list[0] = sequence_number;
370 const uint16_t kListLength = sizeof(list) / sizeof(list[0]);
371 nack.SetSenderSsrc(sender ? kReceiverSsrc : kSenderSsrc);
372 nack.SetMediaSsrc(sender ? kSenderSsrc : kReceiverSsrc);
373 nack.SetPacketIds(list, kListLength);
374 rtc::Buffer packet = nack.Build();
375 module->impl_->IncomingRtcpPacket(packet.data(), packet.size());
376 }
377 };
378
TEST_F(RtpRtcpImpl2Test,RetransmitsAllLayers)379 TEST_F(RtpRtcpImpl2Test, RetransmitsAllLayers) {
380 // Send frames.
381 EXPECT_EQ(0, sender_.RtpSent());
382 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(),
383 kBaseLayerTid)); // kSequenceNumber
384 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(),
385 kHigherLayerTid)); // kSequenceNumber + 1
386 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(),
387 kNoTemporalIdx)); // kSequenceNumber + 2
388 EXPECT_EQ(3, sender_.RtpSent());
389 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
390
391 // Min required delay until retransmit = 5 + RTT ms (RTT = 0).
392 AdvanceTime(TimeDelta::Millis(5));
393
394 // Frame with kBaseLayerTid re-sent.
395 IncomingRtcpNack(&sender_, kSequenceNumber);
396 EXPECT_EQ(4, sender_.RtpSent());
397 EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
398 // Frame with kHigherLayerTid re-sent.
399 IncomingRtcpNack(&sender_, kSequenceNumber + 1);
400 EXPECT_EQ(5, sender_.RtpSent());
401 EXPECT_EQ(kSequenceNumber + 1, sender_.LastRtpSequenceNumber());
402 // Frame with kNoTemporalIdx re-sent.
403 IncomingRtcpNack(&sender_, kSequenceNumber + 2);
404 EXPECT_EQ(6, sender_.RtpSent());
405 EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
406 }
407
TEST_F(RtpRtcpImpl2Test,Rtt)408 TEST_F(RtpRtcpImpl2Test, Rtt) {
409 RtpPacketReceived packet;
410 packet.SetTimestamp(1);
411 packet.SetSequenceNumber(123);
412 packet.SetSsrc(kSenderSsrc);
413 packet.AllocatePayload(100 - 12);
414 receiver_.receive_statistics_->OnRtpPacket(packet);
415
416 // Send Frame before sending an SR.
417 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
418 // Sender module should send an SR.
419 EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
420 AdvanceTime(kOneWayNetworkDelay);
421
422 // Receiver module should send a RR with a response to the last received SR.
423 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
424 AdvanceTime(kOneWayNetworkDelay);
425
426 // Verify RTT.
427 int64_t rtt;
428 int64_t avg_rtt;
429 int64_t min_rtt;
430 int64_t max_rtt;
431 EXPECT_EQ(
432 0, sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt));
433 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(), rtt, 1);
434 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(), avg_rtt, 1);
435 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(), min_rtt, 1);
436 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(), max_rtt, 1);
437
438 // No RTT from other ssrc.
439 EXPECT_EQ(-1, sender_.impl_->RTT(kReceiverSsrc + 1, &rtt, &avg_rtt, &min_rtt,
440 &max_rtt));
441
442 // Verify RTT from rtt_stats config.
443 EXPECT_EQ(0, sender_.rtt_stats_.LastProcessedRtt());
444 EXPECT_EQ(0, sender_.impl_->rtt_ms());
445 AdvanceTime(TimeDelta::Millis(1000));
446
447 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(),
448 sender_.rtt_stats_.LastProcessedRtt(), 1);
449 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(), sender_.impl_->rtt_ms(), 1);
450 }
451
TEST_F(RtpRtcpImpl2Test,RttForReceiverOnly)452 TEST_F(RtpRtcpImpl2Test, RttForReceiverOnly) {
453 // Receiver module should send a Receiver time reference report (RTRR).
454 EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
455
456 // Sender module should send a response to the last received RTRR (DLRR).
457 AdvanceTime(TimeDelta::Millis(1000));
458 // Send Frame before sending a SR.
459 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
460 EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
461
462 // Verify RTT.
463 EXPECT_EQ(0, receiver_.rtt_stats_.LastProcessedRtt());
464 EXPECT_EQ(0, receiver_.impl_->rtt_ms());
465 AdvanceTime(TimeDelta::Millis(1000));
466 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(),
467 receiver_.rtt_stats_.LastProcessedRtt(), 1);
468 EXPECT_NEAR(2 * kOneWayNetworkDelay.ms(), receiver_.impl_->rtt_ms(), 1);
469 }
470
TEST_F(RtpRtcpImpl2Test,NoSrBeforeMedia)471 TEST_F(RtpRtcpImpl2Test, NoSrBeforeMedia) {
472 // Ignore fake transport delays in this test.
473 sender_.transport_.SimulateNetworkDelay(TimeDelta::Zero());
474 receiver_.transport_.SimulateNetworkDelay(TimeDelta::Zero());
475
476 // Move ahead to the instant a rtcp is expected.
477 // Verify no SR is sent before media has been sent, RR should still be sent
478 // from the receiving module though.
479 AdvanceTime(kDefaultReportInterval / 2);
480 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 0u);
481 EXPECT_EQ(receiver_.transport_.NumRtcpSent(), 1u);
482
483 // RTCP should be triggered by the RTP send.
484 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
485 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u);
486 }
487
TEST_F(RtpRtcpImpl2Test,RtcpPacketTypeCounter_Nack)488 TEST_F(RtpRtcpImpl2Test, RtcpPacketTypeCounter_Nack) {
489 EXPECT_EQ(0U, sender_.RtcpReceived().nack_packets);
490 EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
491
492 // Receive module sends a NACK.
493 const uint16_t kNackLength = 1;
494 uint16_t nack_list[kNackLength] = {123};
495 EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
496 AdvanceTime(kOneWayNetworkDelay);
497 EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
498
499 // Send module receives the NACK.
500 EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
501 }
502
TEST_F(RtpRtcpImpl2Test,AddStreamDataCounters)503 TEST_F(RtpRtcpImpl2Test, AddStreamDataCounters) {
504 StreamDataCounters rtp;
505 const int64_t kStartTimeMs = 1;
506 rtp.first_packet_time_ms = kStartTimeMs;
507 rtp.transmitted.packets = 1;
508 rtp.transmitted.payload_bytes = 1;
509 rtp.transmitted.header_bytes = 2;
510 rtp.transmitted.padding_bytes = 3;
511 EXPECT_EQ(rtp.transmitted.TotalBytes(), rtp.transmitted.payload_bytes +
512 rtp.transmitted.header_bytes +
513 rtp.transmitted.padding_bytes);
514
515 StreamDataCounters rtp2;
516 rtp2.first_packet_time_ms = -1;
517 rtp2.transmitted.packets = 10;
518 rtp2.transmitted.payload_bytes = 10;
519 rtp2.retransmitted.header_bytes = 4;
520 rtp2.retransmitted.payload_bytes = 5;
521 rtp2.retransmitted.padding_bytes = 6;
522 rtp2.retransmitted.packets = 7;
523 rtp2.fec.packets = 8;
524
525 StreamDataCounters sum = rtp;
526 sum.Add(rtp2);
527 EXPECT_EQ(kStartTimeMs, sum.first_packet_time_ms);
528 EXPECT_EQ(11U, sum.transmitted.packets);
529 EXPECT_EQ(11U, sum.transmitted.payload_bytes);
530 EXPECT_EQ(2U, sum.transmitted.header_bytes);
531 EXPECT_EQ(3U, sum.transmitted.padding_bytes);
532 EXPECT_EQ(4U, sum.retransmitted.header_bytes);
533 EXPECT_EQ(5U, sum.retransmitted.payload_bytes);
534 EXPECT_EQ(6U, sum.retransmitted.padding_bytes);
535 EXPECT_EQ(7U, sum.retransmitted.packets);
536 EXPECT_EQ(8U, sum.fec.packets);
537 EXPECT_EQ(sum.transmitted.TotalBytes(),
538 rtp.transmitted.TotalBytes() + rtp2.transmitted.TotalBytes());
539
540 StreamDataCounters rtp3;
541 rtp3.first_packet_time_ms = kStartTimeMs + 10;
542 sum.Add(rtp3);
543 EXPECT_EQ(kStartTimeMs, sum.first_packet_time_ms); // Holds oldest time.
544 }
545
TEST_F(RtpRtcpImpl2Test,SendsInitialNackList)546 TEST_F(RtpRtcpImpl2Test, SendsInitialNackList) {
547 // Send module sends a NACK.
548 const uint16_t kNackLength = 1;
549 uint16_t nack_list[kNackLength] = {123};
550 EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
551 // Send Frame before sending a compound RTCP that starts with SR.
552 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
553 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
554 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
555 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
556 }
557
TEST_F(RtpRtcpImpl2Test,SendsExtendedNackList)558 TEST_F(RtpRtcpImpl2Test, SendsExtendedNackList) {
559 // Send module sends a NACK.
560 const uint16_t kNackLength = 1;
561 uint16_t nack_list[kNackLength] = {123};
562 EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
563 // Send Frame before sending a compound RTCP that starts with SR.
564 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
565 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
566 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
567 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
568
569 // Same list not re-send.
570 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
571 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
572 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
573
574 // Only extended list sent.
575 const uint16_t kNackExtLength = 2;
576 uint16_t nack_list_ext[kNackExtLength] = {123, 124};
577 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list_ext, kNackExtLength));
578 EXPECT_EQ(2U, sender_.RtcpSent().nack_packets);
579 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(124));
580 }
581
TEST_F(RtpRtcpImpl2Test,ReSendsNackListAfterRttMs)582 TEST_F(RtpRtcpImpl2Test, ReSendsNackListAfterRttMs) {
583 sender_.transport_.SimulateNetworkDelay(TimeDelta::Zero());
584 // Send module sends a NACK.
585 const uint16_t kNackLength = 2;
586 uint16_t nack_list[kNackLength] = {123, 125};
587 EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
588 // Send Frame before sending a compound RTCP that starts with SR.
589 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
590 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
591 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
592 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
593
594 // Same list not re-send, rtt interval has not passed.
595 const TimeDelta kStartupRtt = TimeDelta::Millis(100);
596 AdvanceTime(kStartupRtt);
597 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
598 EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
599
600 // Rtt interval passed, full list sent.
601 AdvanceTime(TimeDelta::Millis(1));
602 EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
603 EXPECT_EQ(2U, sender_.RtcpSent().nack_packets);
604 EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
605 }
606
TEST_F(RtpRtcpImpl2Test,UniqueNackRequests)607 TEST_F(RtpRtcpImpl2Test, UniqueNackRequests) {
608 receiver_.transport_.SimulateNetworkDelay(TimeDelta::Zero());
609 EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
610 EXPECT_EQ(0U, receiver_.RtcpSent().nack_requests);
611 EXPECT_EQ(0U, receiver_.RtcpSent().unique_nack_requests);
612 EXPECT_EQ(0, receiver_.RtcpSent().UniqueNackRequestsInPercent());
613
614 // Receive module sends NACK request.
615 const uint16_t kNackLength = 4;
616 uint16_t nack_list[kNackLength] = {10, 11, 13, 18};
617 EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
618 EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
619 EXPECT_EQ(4U, receiver_.RtcpSent().nack_requests);
620 EXPECT_EQ(4U, receiver_.RtcpSent().unique_nack_requests);
621 EXPECT_THAT(receiver_.LastNackListSent(), ElementsAre(10, 11, 13, 18));
622
623 // Send module receives the request.
624 EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
625 EXPECT_EQ(4U, sender_.RtcpReceived().nack_requests);
626 EXPECT_EQ(4U, sender_.RtcpReceived().unique_nack_requests);
627 EXPECT_EQ(100, sender_.RtcpReceived().UniqueNackRequestsInPercent());
628
629 // Receive module sends new request with duplicated packets.
630 const TimeDelta kStartupRtt = TimeDelta::Millis(100);
631 AdvanceTime(kStartupRtt + TimeDelta::Millis(1));
632 const uint16_t kNackLength2 = 4;
633 uint16_t nack_list2[kNackLength2] = {11, 18, 20, 21};
634 EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list2, kNackLength2));
635 EXPECT_EQ(2U, receiver_.RtcpSent().nack_packets);
636 EXPECT_EQ(8U, receiver_.RtcpSent().nack_requests);
637 EXPECT_EQ(6U, receiver_.RtcpSent().unique_nack_requests);
638 EXPECT_THAT(receiver_.LastNackListSent(), ElementsAre(11, 18, 20, 21));
639
640 // Send module receives the request.
641 EXPECT_EQ(2U, sender_.RtcpReceived().nack_packets);
642 EXPECT_EQ(8U, sender_.RtcpReceived().nack_requests);
643 EXPECT_EQ(6U, sender_.RtcpReceived().unique_nack_requests);
644 EXPECT_EQ(75, sender_.RtcpReceived().UniqueNackRequestsInPercent());
645 }
646
TEST_F(RtpRtcpImpl2Test,ConfigurableRtcpReportInterval)647 TEST_F(RtpRtcpImpl2Test, ConfigurableRtcpReportInterval) {
648 const TimeDelta kVideoReportInterval = TimeDelta::Millis(3000);
649
650 // Recreate sender impl with new configuration, and redo setup.
651 sender_.SetRtcpReportIntervalAndReset(kVideoReportInterval);
652 SetUp();
653
654 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
655
656 // Initial state
657 EXPECT_EQ(0u, sender_.transport_.NumRtcpSent());
658
659 // Move ahead to the last ms before a rtcp is expected, no action.
660 AdvanceTime(kVideoReportInterval / 2 - TimeDelta::Millis(1));
661 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 0u);
662
663 // Move ahead to the first rtcp. Send RTCP.
664 AdvanceTime(TimeDelta::Millis(1));
665 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u);
666
667 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
668
669 // Move ahead to the last possible second before second rtcp is expected.
670 AdvanceTime(kVideoReportInterval * 1 / 2 - TimeDelta::Millis(1));
671 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u);
672
673 // Move ahead into the range of second rtcp, the second rtcp may be sent.
674 AdvanceTime(TimeDelta::Millis(1));
675 EXPECT_GE(sender_.transport_.NumRtcpSent(), 1u);
676
677 AdvanceTime(kVideoReportInterval / 2);
678 EXPECT_GE(sender_.transport_.NumRtcpSent(), 1u);
679
680 // Move out the range of second rtcp, the second rtcp must have been sent.
681 AdvanceTime(kVideoReportInterval / 2);
682 EXPECT_EQ(sender_.transport_.NumRtcpSent(), 2u);
683 }
684
TEST_F(RtpRtcpImpl2Test,RtpSenderEgressTimestampOffset)685 TEST_F(RtpRtcpImpl2Test, RtpSenderEgressTimestampOffset) {
686 // RTP timestamp offset not explicitly set, default to random value.
687 uint16_t seqno = sender_.impl_->GetRtpState().sequence_number;
688 uint32_t media_rtp_ts = 1001;
689 uint32_t rtp_ts = media_rtp_ts + sender_.impl_->StartTimestamp();
690 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, rtp_ts,
691 /*capture_time_ms=*/0));
692 AdvanceTime(kOneWayNetworkDelay);
693 EXPECT_THAT(
694 sender_.impl_->GetSentRtpPacketInfos(std::vector<uint16_t>{seqno}),
695 ElementsAre(Field(&RtpSequenceNumberMap::Info::timestamp, media_rtp_ts)));
696
697 RtpState saved_rtp_state = sender_.impl_->GetRtpState();
698
699 // Change RTP timestamp offset.
700 sender_.impl_->SetStartTimestamp(2000);
701
702 // Restores RtpState and make sure the old timestamp offset is in place.
703 sender_.impl_->SetRtpState(saved_rtp_state);
704 seqno = sender_.impl_->GetRtpState().sequence_number;
705 media_rtp_ts = 1031;
706 rtp_ts = media_rtp_ts + sender_.impl_->StartTimestamp();
707 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, rtp_ts,
708 /*capture_time_ms=*/0));
709 AdvanceTime(kOneWayNetworkDelay);
710 EXPECT_THAT(
711 sender_.impl_->GetSentRtpPacketInfos(std::vector<uint16_t>{seqno}),
712 ElementsAre(Field(&RtpSequenceNumberMap::Info::timestamp, media_rtp_ts)));
713 }
714
TEST_F(RtpRtcpImpl2Test,StoresPacketInfoForSentPackets)715 TEST_F(RtpRtcpImpl2Test, StoresPacketInfoForSentPackets) {
716 const uint32_t kStartTimestamp = 1u;
717 SetUp();
718 sender_.impl_->SetStartTimestamp(kStartTimestamp);
719
720 sender_.impl_->SetSequenceNumber(1);
721
722 PacedPacketInfo pacing_info;
723 RtpPacketToSend packet(nullptr);
724 packet.set_packet_type(RtpPacketToSend::Type::kVideo);
725 packet.SetSsrc(kSenderSsrc);
726
727 // Single-packet frame.
728 packet.SetTimestamp(1);
729 packet.set_first_packet_of_frame(true);
730 packet.SetMarker(true);
731 sender_.impl_->TrySendPacket(&packet, pacing_info);
732 AdvanceTime(TimeDelta::Millis(1));
733
734 std::vector<RtpSequenceNumberMap::Info> seqno_info =
735 sender_.impl_->GetSentRtpPacketInfos(std::vector<uint16_t>{1});
736
737 EXPECT_THAT(seqno_info, ElementsAre(RtpSequenceNumberMap::Info(
738 /*timestamp=*/1 - kStartTimestamp,
739 /*is_first=*/1,
740 /*is_last=*/1)));
741
742 // Three-packet frame.
743 packet.SetTimestamp(2);
744 packet.set_first_packet_of_frame(true);
745 packet.SetMarker(false);
746 sender_.impl_->TrySendPacket(&packet, pacing_info);
747
748 packet.set_first_packet_of_frame(false);
749 sender_.impl_->TrySendPacket(&packet, pacing_info);
750
751 packet.SetMarker(true);
752 sender_.impl_->TrySendPacket(&packet, pacing_info);
753
754 AdvanceTime(TimeDelta::Millis(1));
755
756 seqno_info =
757 sender_.impl_->GetSentRtpPacketInfos(std::vector<uint16_t>{2, 3, 4});
758
759 EXPECT_THAT(seqno_info, ElementsAre(RtpSequenceNumberMap::Info(
760 /*timestamp=*/2 - kStartTimestamp,
761 /*is_first=*/1,
762 /*is_last=*/0),
763 RtpSequenceNumberMap::Info(
764 /*timestamp=*/2 - kStartTimestamp,
765 /*is_first=*/0,
766 /*is_last=*/0),
767 RtpSequenceNumberMap::Info(
768 /*timestamp=*/2 - kStartTimestamp,
769 /*is_first=*/0,
770 /*is_last=*/1)));
771 }
772
773 // Checks that the sender report stats are not available if no RTCP SR was sent.
TEST_F(RtpRtcpImpl2Test,SenderReportStatsNotAvailable)774 TEST_F(RtpRtcpImpl2Test, SenderReportStatsNotAvailable) {
775 EXPECT_THAT(receiver_.impl_->GetSenderReportStats(), Eq(absl::nullopt));
776 }
777
778 // Checks that the sender report stats are available if an RTCP SR was sent.
TEST_F(RtpRtcpImpl2Test,SenderReportStatsAvailable)779 TEST_F(RtpRtcpImpl2Test, SenderReportStatsAvailable) {
780 // Send a frame in order to send an SR.
781 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
782 // Send an SR.
783 ASSERT_THAT(sender_.impl_->SendRTCP(kRtcpReport), Eq(0));
784 AdvanceTime(kOneWayNetworkDelay);
785 EXPECT_THAT(receiver_.impl_->GetSenderReportStats(), Not(Eq(absl::nullopt)));
786 }
787
788 // Checks that the sender report stats are not available if an RTCP SR with an
789 // unexpected SSRC is received.
TEST_F(RtpRtcpImpl2Test,SenderReportStatsNotUpdatedWithUnexpectedSsrc)790 TEST_F(RtpRtcpImpl2Test, SenderReportStatsNotUpdatedWithUnexpectedSsrc) {
791 constexpr uint32_t kUnexpectedSenderSsrc = 0x87654321;
792 static_assert(kUnexpectedSenderSsrc != kSenderSsrc, "");
793 // Forge a sender report and pass it to the receiver as if an RTCP SR were
794 // sent by an unexpected sender.
795 rtcp::SenderReport sr;
796 sr.SetSenderSsrc(kUnexpectedSenderSsrc);
797 sr.SetNtp({/*seconds=*/1u, /*fractions=*/1u << 31});
798 sr.SetPacketCount(123u);
799 sr.SetOctetCount(456u);
800 auto raw_packet = sr.Build();
801 receiver_.impl_->IncomingRtcpPacket(raw_packet.data(), raw_packet.size());
802 EXPECT_THAT(receiver_.impl_->GetSenderReportStats(), Eq(absl::nullopt));
803 }
804
805 // Checks the stats derived from the last received RTCP SR are set correctly.
TEST_F(RtpRtcpImpl2Test,SenderReportStatsCheckStatsFromLastReport)806 TEST_F(RtpRtcpImpl2Test, SenderReportStatsCheckStatsFromLastReport) {
807 using SenderReportStats = RtpRtcpInterface::SenderReportStats;
808 const NtpTime ntp(/*seconds=*/1u, /*fractions=*/1u << 31);
809 constexpr uint32_t kPacketCount = 123u;
810 constexpr uint32_t kOctetCount = 456u;
811 // Forge a sender report and pass it to the receiver as if an RTCP SR were
812 // sent by the sender.
813 rtcp::SenderReport sr;
814 sr.SetSenderSsrc(kSenderSsrc);
815 sr.SetNtp(ntp);
816 sr.SetPacketCount(kPacketCount);
817 sr.SetOctetCount(kOctetCount);
818 auto raw_packet = sr.Build();
819 receiver_.impl_->IncomingRtcpPacket(raw_packet.data(), raw_packet.size());
820
821 EXPECT_THAT(
822 receiver_.impl_->GetSenderReportStats(),
823 Optional(AllOf(Field(&SenderReportStats::last_remote_timestamp, Eq(ntp)),
824 Field(&SenderReportStats::packets_sent, Eq(kPacketCount)),
825 Field(&SenderReportStats::bytes_sent, Eq(kOctetCount)))));
826 }
827
828 // Checks that the sender report stats count equals the number of sent RTCP SRs.
TEST_F(RtpRtcpImpl2Test,SenderReportStatsCount)829 TEST_F(RtpRtcpImpl2Test, SenderReportStatsCount) {
830 using SenderReportStats = RtpRtcpInterface::SenderReportStats;
831 // Send a frame in order to send an SR.
832 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
833 // Send the first SR.
834 ASSERT_THAT(sender_.impl_->SendRTCP(kRtcpReport), Eq(0));
835 AdvanceTime(kOneWayNetworkDelay);
836 EXPECT_THAT(receiver_.impl_->GetSenderReportStats(),
837 Optional(Field(&SenderReportStats::reports_count, Eq(1u))));
838 // Send the second SR.
839 ASSERT_THAT(sender_.impl_->SendRTCP(kRtcpReport), Eq(0));
840 AdvanceTime(kOneWayNetworkDelay);
841 EXPECT_THAT(receiver_.impl_->GetSenderReportStats(),
842 Optional(Field(&SenderReportStats::reports_count, Eq(2u))));
843 }
844
845 // Checks that the sender report stats include a valid arrival time if an RTCP
846 // SR was sent.
TEST_F(RtpRtcpImpl2Test,SenderReportStatsArrivalTimestampSet)847 TEST_F(RtpRtcpImpl2Test, SenderReportStatsArrivalTimestampSet) {
848 // Send a frame in order to send an SR.
849 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
850 // Send an SR.
851 ASSERT_THAT(sender_.impl_->SendRTCP(kRtcpReport), Eq(0));
852 AdvanceTime(kOneWayNetworkDelay);
853 auto stats = receiver_.impl_->GetSenderReportStats();
854 ASSERT_THAT(stats, Not(Eq(absl::nullopt)));
855 EXPECT_TRUE(stats->last_arrival_timestamp.Valid());
856 }
857
858 // Checks that the packet and byte counters from an RTCP SR are not zero once
859 // a frame is sent.
TEST_F(RtpRtcpImpl2Test,SenderReportStatsPacketByteCounters)860 TEST_F(RtpRtcpImpl2Test, SenderReportStatsPacketByteCounters) {
861 using SenderReportStats = RtpRtcpInterface::SenderReportStats;
862 // Send a frame in order to send an SR.
863 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
864 ASSERT_THAT(sender_.transport_.rtp_packets_sent_, Gt(0));
865 // Advance time otherwise the RTCP SR report will not include any packets
866 // generated by `SendFrame()`.
867 AdvanceTime(TimeDelta::Millis(1));
868 // Send an SR.
869 ASSERT_THAT(sender_.impl_->SendRTCP(kRtcpReport), Eq(0));
870 AdvanceTime(kOneWayNetworkDelay);
871 EXPECT_THAT(receiver_.impl_->GetSenderReportStats(),
872 Optional(AllOf(Field(&SenderReportStats::packets_sent, Gt(0u)),
873 Field(&SenderReportStats::bytes_sent, Gt(0u)))));
874 }
875
TEST_F(RtpRtcpImpl2Test,SendingVideoAdvancesSequenceNumber)876 TEST_F(RtpRtcpImpl2Test, SendingVideoAdvancesSequenceNumber) {
877 const uint16_t sequence_number = sender_.impl_->SequenceNumber();
878 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
879 ASSERT_THAT(sender_.transport_.rtp_packets_sent_, Gt(0));
880 EXPECT_EQ(sequence_number + 1, sender_.impl_->SequenceNumber());
881 }
882
TEST_F(RtpRtcpImpl2Test,SequenceNumberNotAdvancedWhenNotSending)883 TEST_F(RtpRtcpImpl2Test, SequenceNumberNotAdvancedWhenNotSending) {
884 const uint16_t sequence_number = sender_.impl_->SequenceNumber();
885 sender_.impl_->SetSendingMediaStatus(false);
886 EXPECT_FALSE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
887 ASSERT_THAT(sender_.transport_.rtp_packets_sent_, Eq(0));
888 EXPECT_EQ(sequence_number, sender_.impl_->SequenceNumber());
889 }
890
TEST_F(RtpRtcpImpl2Test,PaddingNotAllowedInMiddleOfFrame)891 TEST_F(RtpRtcpImpl2Test, PaddingNotAllowedInMiddleOfFrame) {
892 constexpr size_t kPaddingSize = 100;
893
894 // Can't send padding before media.
895 EXPECT_THAT(sender_.impl_->GeneratePadding(kPaddingSize), SizeIs(0u));
896
897 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
898
899 // Padding is now ok.
900 EXPECT_THAT(sender_.impl_->GeneratePadding(kPaddingSize), SizeIs(Gt(0u)));
901
902 // Send half a video frame.
903 PacedPacketInfo pacing_info;
904 std::unique_ptr<RtpPacketToSend> packet =
905 sender_.impl_->RtpSender()->AllocatePacket();
906 packet->set_packet_type(RtpPacketToSend::Type::kVideo);
907 packet->set_first_packet_of_frame(true);
908 packet->SetMarker(false); // Marker false - not last packet of frame.
909
910 EXPECT_TRUE(sender_.impl_->TrySendPacket(packet.get(), pacing_info));
911
912 // Padding not allowed in middle of frame.
913 EXPECT_THAT(sender_.impl_->GeneratePadding(kPaddingSize), SizeIs(0u));
914
915 packet = sender_.impl_->RtpSender()->AllocatePacket();
916 packet->set_packet_type(RtpPacketToSend::Type::kVideo);
917 packet->set_first_packet_of_frame(true);
918 packet->SetMarker(true);
919
920 EXPECT_TRUE(sender_.impl_->TrySendPacket(packet.get(), pacing_info));
921
922 // Padding is OK again.
923 EXPECT_THAT(sender_.impl_->GeneratePadding(kPaddingSize), SizeIs(Gt(0u)));
924 }
925
TEST_F(RtpRtcpImpl2Test,PaddingTimestampMatchesMedia)926 TEST_F(RtpRtcpImpl2Test, PaddingTimestampMatchesMedia) {
927 constexpr size_t kPaddingSize = 100;
928 const uint32_t kTimestamp = 123;
929
930 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid,
931 kTimestamp, /*capture_time_ms=*/0));
932 EXPECT_EQ(sender_.last_packet().Timestamp(), kTimestamp);
933 uint16_t media_seq = sender_.last_packet().SequenceNumber();
934
935 // Generate and send padding.
936 auto padding = sender_.impl_->GeneratePadding(kPaddingSize);
937 ASSERT_FALSE(padding.empty());
938 for (auto& packet : padding) {
939 sender_.impl_->TrySendPacket(packet.get(), PacedPacketInfo());
940 }
941
942 // Verify we sent a new packet, but with the same timestamp.
943 EXPECT_NE(sender_.last_packet().SequenceNumber(), media_seq);
944 EXPECT_EQ(sender_.last_packet().Timestamp(), kTimestamp);
945 }
946
TEST_F(RtpRtcpImpl2Test,AssignsTransportSequenceNumber)947 TEST_F(RtpRtcpImpl2Test, AssignsTransportSequenceNumber) {
948 sender_.RegisterHeaderExtension(TransportSequenceNumber::Uri(),
949 kTransportSequenceNumberExtensionId);
950
951 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
952 uint16_t first_transport_seq = 0;
953 EXPECT_TRUE(sender_.last_packet().GetExtension<TransportSequenceNumber>(
954 &first_transport_seq));
955
956 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
957 uint16_t second_transport_seq = 0;
958 EXPECT_TRUE(sender_.last_packet().GetExtension<TransportSequenceNumber>(
959 &second_transport_seq));
960
961 EXPECT_EQ(first_transport_seq + 1, second_transport_seq);
962 }
963
TEST_F(RtpRtcpImpl2Test,AssignsAbsoluteSendTime)964 TEST_F(RtpRtcpImpl2Test, AssignsAbsoluteSendTime) {
965 sender_.RegisterHeaderExtension(AbsoluteSendTime::Uri(),
966 kAbsoluteSendTimeExtensionId);
967
968 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
969 EXPECT_NE(sender_.last_packet().GetExtension<AbsoluteSendTime>(), 0u);
970 }
971
TEST_F(RtpRtcpImpl2Test,AssignsTransmissionTimeOffset)972 TEST_F(RtpRtcpImpl2Test, AssignsTransmissionTimeOffset) {
973 sender_.RegisterHeaderExtension(TransmissionOffset::Uri(),
974 kTransmissionOffsetExtensionId);
975
976 constexpr TimeDelta kOffset = TimeDelta::Millis(100);
977 // Transmission offset is calculated from difference between capture time
978 // and send time.
979 int64_t capture_time_ms = time_controller_.GetClock()->TimeInMilliseconds();
980 time_controller_.AdvanceTime(kOffset);
981
982 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid,
983 /*timestamp=*/0, capture_time_ms));
984 EXPECT_EQ(sender_.last_packet().GetExtension<TransmissionOffset>(),
985 kOffset.ms() * kCaptureTimeMsToRtpTimestamp);
986 }
987
TEST_F(RtpRtcpImpl2Test,PropagatesSentPacketInfo)988 TEST_F(RtpRtcpImpl2Test, PropagatesSentPacketInfo) {
989 sender_.RegisterHeaderExtension(TransportSequenceNumber::Uri(),
990 kTransportSequenceNumberExtensionId);
991 int64_t now_ms = time_controller_.GetClock()->TimeInMilliseconds();
992 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
993 EXPECT_THAT(
994 sender_.last_sent_packet(),
995 Optional(
996 AllOf(Field(&RtpRtcpModule::SentPacket::packet_id,
997 Eq(sender_.last_packet()
998 .GetExtension<TransportSequenceNumber>())),
999 Field(&RtpRtcpModule::SentPacket::capture_time_ms, Eq(now_ms)),
1000 Field(&RtpRtcpModule::SentPacket::ssrc, Eq(kSenderSsrc)))));
1001 }
1002
TEST_F(RtpRtcpImpl2Test,GeneratesFlexfec)1003 TEST_F(RtpRtcpImpl2Test, GeneratesFlexfec) {
1004 constexpr int kFlexfecPayloadType = 118;
1005 constexpr uint32_t kFlexfecSsrc = 17;
1006 const char kNoMid[] = "";
1007 const std::vector<RtpExtension> kNoRtpExtensions;
1008 const std::vector<RtpExtensionSize> kNoRtpExtensionSizes;
1009
1010 // Make sure FlexFec sequence numbers start at a different point than media.
1011 const uint16_t fec_start_seq = sender_.impl_->SequenceNumber() + 100;
1012 RtpState start_state;
1013 start_state.sequence_number = fec_start_seq;
1014 FlexfecSender flexfec_sender(kFlexfecPayloadType, kFlexfecSsrc, kSenderSsrc,
1015 kNoMid, kNoRtpExtensions, kNoRtpExtensionSizes,
1016 &start_state, time_controller_.GetClock());
1017 ReinitWithFec(&flexfec_sender, /*red_payload_type=*/absl::nullopt);
1018
1019 // Parameters selected to generate a single FEC packet per media packet.
1020 FecProtectionParams params;
1021 params.fec_rate = 15;
1022 params.max_fec_frames = 1;
1023 params.fec_mask_type = kFecMaskRandom;
1024 sender_.impl_->SetFecProtectionParams(params, params);
1025
1026 // Send a one packet frame, expect one media packet and one FEC packet.
1027 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
1028 ASSERT_THAT(sender_.transport_.rtp_packets_sent_, Eq(2));
1029
1030 const RtpPacketReceived& fec_packet = sender_.last_packet();
1031 EXPECT_EQ(fec_packet.SequenceNumber(), fec_start_seq);
1032 EXPECT_EQ(fec_packet.Ssrc(), kFlexfecSsrc);
1033 EXPECT_EQ(fec_packet.PayloadType(), kFlexfecPayloadType);
1034 }
1035
TEST_F(RtpRtcpImpl2Test,GeneratesUlpfec)1036 TEST_F(RtpRtcpImpl2Test, GeneratesUlpfec) {
1037 constexpr int kUlpfecPayloadType = 118;
1038 constexpr int kRedPayloadType = 119;
1039 UlpfecGenerator ulpfec_sender(kRedPayloadType, kUlpfecPayloadType,
1040 time_controller_.GetClock());
1041 ReinitWithFec(&ulpfec_sender, kRedPayloadType);
1042
1043 // Parameters selected to generate a single FEC packet per media packet.
1044 FecProtectionParams params;
1045 params.fec_rate = 15;
1046 params.max_fec_frames = 1;
1047 params.fec_mask_type = kFecMaskRandom;
1048 sender_.impl_->SetFecProtectionParams(params, params);
1049
1050 // Send a one packet frame, expect one media packet and one FEC packet.
1051 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
1052 ASSERT_THAT(sender_.transport_.rtp_packets_sent_, Eq(2));
1053
1054 // Ulpfec is sent on the media ssrc, sharing the sequene number series.
1055 const RtpPacketReceived& fec_packet = sender_.last_packet();
1056 EXPECT_EQ(fec_packet.SequenceNumber(), kSequenceNumber + 1);
1057 EXPECT_EQ(fec_packet.Ssrc(), kSenderSsrc);
1058 // The packets are encapsulated in RED packets, check that and that the RED
1059 // header (first byte of payload) indicates the desired FEC payload type.
1060 EXPECT_EQ(fec_packet.PayloadType(), kRedPayloadType);
1061 EXPECT_EQ(fec_packet.payload()[0], kUlpfecPayloadType);
1062 }
1063
TEST_F(RtpRtcpImpl2Test,RtpStateReflectsCurrentState)1064 TEST_F(RtpRtcpImpl2Test, RtpStateReflectsCurrentState) {
1065 // Verify that that each of the field of GetRtpState actually reflects
1066 // the current state.
1067
1068 // Current time will be used for `timestamp`, `capture_time_ms` and
1069 // `last_timestamp_time_ms`.
1070 const int64_t time_ms = time_controller_.GetClock()->TimeInMilliseconds();
1071
1072 // Use different than default sequence number to test `sequence_number`.
1073 const uint16_t kSeq = kSequenceNumber + 123;
1074 // Hard-coded value for `start_timestamp`.
1075 const uint32_t kStartTimestamp = 3456;
1076 const int64_t capture_time_ms = time_ms;
1077 const uint32_t timestamp = capture_time_ms * kCaptureTimeMsToRtpTimestamp;
1078
1079 sender_.impl_->SetSequenceNumber(kSeq - 1);
1080 sender_.impl_->SetStartTimestamp(kStartTimestamp);
1081 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
1082
1083 // Simulate an RTCP receiver report in order to populate `ssrc_has_acked`.
1084 RTCPReportBlock ack;
1085 ack.source_ssrc = kSenderSsrc;
1086 ack.extended_highest_sequence_number = kSeq;
1087 sender_.impl_->OnReceivedRtcpReportBlocks({ack});
1088
1089 RtpState state = sender_.impl_->GetRtpState();
1090 EXPECT_EQ(state.sequence_number, kSeq);
1091 EXPECT_EQ(state.start_timestamp, kStartTimestamp);
1092 EXPECT_EQ(state.timestamp, timestamp);
1093 EXPECT_EQ(state.capture_time_ms, capture_time_ms);
1094 EXPECT_EQ(state.last_timestamp_time_ms, time_ms);
1095 EXPECT_EQ(state.ssrc_has_acked, true);
1096
1097 // Reset sender, advance time, restore state. Directly observing state
1098 // is not feasible, so just verify returned state matches what we set.
1099 sender_.CreateModuleImpl();
1100 time_controller_.AdvanceTime(TimeDelta::Millis(10));
1101 sender_.impl_->SetRtpState(state);
1102
1103 state = sender_.impl_->GetRtpState();
1104 EXPECT_EQ(state.sequence_number, kSeq);
1105 EXPECT_EQ(state.start_timestamp, kStartTimestamp);
1106 EXPECT_EQ(state.timestamp, timestamp);
1107 EXPECT_EQ(state.capture_time_ms, capture_time_ms);
1108 EXPECT_EQ(state.last_timestamp_time_ms, time_ms);
1109 EXPECT_EQ(state.ssrc_has_acked, true);
1110 }
1111
TEST_F(RtpRtcpImpl2Test,RtxRtpStateReflectsCurrentState)1112 TEST_F(RtpRtcpImpl2Test, RtxRtpStateReflectsCurrentState) {
1113 // Enable RTX.
1114 sender_.impl_->SetStorePacketsStatus(/*enable=*/true, /*number_to_store=*/10);
1115 sender_.impl_->SetRtxSendPayloadType(kRtxPayloadType, kPayloadType);
1116 sender_.impl_->SetRtxSendStatus(kRtxRetransmitted | kRtxRedundantPayloads);
1117
1118 // `start_timestamp` is the only timestamp populate in the RTX state.
1119 const uint32_t kStartTimestamp = 3456;
1120 sender_.impl_->SetStartTimestamp(kStartTimestamp);
1121
1122 // Send a frame and ask for a retransmit of the last packet. Capture the RTX
1123 // packet in order to verify RTX sequence number.
1124 EXPECT_TRUE(SendFrame(&sender_, sender_video_.get(), kBaseLayerTid));
1125 time_controller_.AdvanceTime(TimeDelta::Millis(5));
1126 sender_.impl_->OnReceivedNack(
1127 std::vector<uint16_t>{sender_.transport_.last_packet_.SequenceNumber()});
1128 RtpPacketReceived& rtx_packet = sender_.transport_.last_packet_;
1129 EXPECT_EQ(rtx_packet.Ssrc(), kRtxSenderSsrc);
1130
1131 // Simulate an RTCP receiver report in order to populate `ssrc_has_acked`.
1132 RTCPReportBlock ack;
1133 ack.source_ssrc = kRtxSenderSsrc;
1134 ack.extended_highest_sequence_number = rtx_packet.SequenceNumber();
1135 sender_.impl_->OnReceivedRtcpReportBlocks({ack});
1136
1137 RtpState rtp_state = sender_.impl_->GetRtpState();
1138 RtpState rtx_state = sender_.impl_->GetRtxState();
1139 EXPECT_EQ(rtx_state.start_timestamp, kStartTimestamp);
1140 EXPECT_EQ(rtx_state.ssrc_has_acked, true);
1141 EXPECT_EQ(rtx_state.sequence_number, rtx_packet.SequenceNumber() + 1);
1142
1143 // Reset sender, advance time, restore state. Directly observing state
1144 // is not feasible, so just verify returned state matches what we set.
1145 // Needs SetRtpState() too in order to propagate start timestamp.
1146 sender_.CreateModuleImpl();
1147 time_controller_.AdvanceTime(TimeDelta::Millis(10));
1148 sender_.impl_->SetRtpState(rtp_state);
1149 sender_.impl_->SetRtxState(rtx_state);
1150
1151 rtx_state = sender_.impl_->GetRtxState();
1152 EXPECT_EQ(rtx_state.start_timestamp, kStartTimestamp);
1153 EXPECT_EQ(rtx_state.ssrc_has_acked, true);
1154 EXPECT_EQ(rtx_state.sequence_number, rtx_packet.SequenceNumber() + 1);
1155 }
1156
1157 } // namespace webrtc
1158