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