| /* | |
| * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved. | |
| * | |
| * Use of this source code is governed by a BSD-style license | |
| * that can be found in the LICENSE file in the root of the source | |
| * tree. An additional intellectual property rights grant can be found | |
| * in the file PATENTS. All contributing project authors may | |
| * be found in the AUTHORS file in the root of the source tree. | |
| */ | |
| #include "modules/rtp_rtcp/source/rtp_sender_video.h" | |
| #include <array> | |
| #include <cstddef> | |
| #include <cstdint> | |
| #include <memory> | |
| #include <optional> | |
| #include <utility> | |
| #include <vector> | |
| #include "absl/memory/memory.h" | |
| #include "api/array_view.h" | |
| #include "api/call/transport.h" | |
| #include "api/environment/environment.h" | |
| #include "api/environment/environment_factory.h" | |
| #include "api/field_trials_view.h" | |
| #include "api/frame_transformer_factory.h" | |
| #include "api/frame_transformer_interface.h" | |
| #include "api/make_ref_counted.h" | |
| #include "api/rtp_headers.h" | |
| #include "api/scoped_refptr.h" | |
| #include "api/task_queue/task_queue_base.h" | |
| #include "api/task_queue/task_queue_factory.h" | |
| #include "api/test/mock_frame_encryptor.h" | |
| #include "api/test/mock_frame_transformer.h" | |
| #include "api/transport/rtp/corruption_detection_message.h" | |
| #include "api/transport/rtp/dependency_descriptor.h" | |
| #include "api/units/data_rate.h" | |
| #include "api/units/time_delta.h" | |
| #include "api/units/timestamp.h" | |
| #include "api/video/corruption_detection/frame_instrumentation_data.h" | |
| #include "api/video/encoded_image.h" | |
| #include "api/video/video_codec_constants.h" | |
| #include "api/video/video_codec_type.h" | |
| #include "api/video/video_frame_type.h" | |
| #include "api/video/video_layers_allocation.h" | |
| #include "api/video/video_rotation.h" | |
| #include "api/video/video_timing.h" | |
| #include "modules/rtp_rtcp/include/rtp_cvo.h" | |
| #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" | |
| #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" | |
| #include "modules/rtp_rtcp/source/corruption_detection_extension.h" | |
| #include "modules/rtp_rtcp/source/rtcp_packet/nack.h" | |
| #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" | |
| #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h" | |
| #include "modules/rtp_rtcp/source/rtp_dependency_descriptor_extension.h" | |
| #include "modules/rtp_rtcp/source/rtp_format_video_generic.h" | |
| #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h" | |
| #include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h" | |
| #include "modules/rtp_rtcp/source/rtp_header_extensions.h" | |
| #include "modules/rtp_rtcp/source/rtp_packet.h" | |
| #include "modules/rtp_rtcp/source/rtp_packet_received.h" | |
| #include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h" | |
| #include "modules/rtp_rtcp/source/rtp_sender.h" | |
| #include "modules/rtp_rtcp/source/rtp_video_layers_allocation_extension.h" | |
| #include "modules/video_coding/codecs/h264/include/h264_globals.h" | |
| #include "modules/video_coding/codecs/vp8/include/vp8_globals.h" | |
| #include "modules/video_coding/codecs/vp9/include/vp9_globals.h" | |
| #include "rtc_base/checks.h" | |
| #include "rtc_base/rate_limiter.h" | |
| #include "rtc_base/thread.h" | |
| #include "system_wrappers/include/clock.h" | |
| #include "system_wrappers/include/ntp_time.h" | |
| #include "test/gmock.h" | |
| #include "test/gtest.h" | |
| #include "test/time_controller/simulated_time_controller.h" | |
| namespace webrtc { | |
| namespace { | |
| using ::testing::_; | |
| using ::testing::ContainerEq; | |
| using ::testing::ElementsAre; | |
| using ::testing::ElementsAreArray; | |
| using ::testing::IsEmpty; | |
| using ::testing::NiceMock; | |
| using ::testing::Not; | |
| using ::testing::ReturnArg; | |
| using ::testing::SaveArg; | |
| using ::testing::SizeIs; | |
| using ::testing::WithArgs; | |
| enum : int { // The first valid value is 1. | |
| kAbsoluteSendTimeExtensionId = 1, | |
| kGenericDescriptorId, | |
| kDependencyDescriptorId, | |
| kTransmissionTimeOffsetExtensionId, | |
| kTransportSequenceNumberExtensionId, | |
| kVideoRotationExtensionId, | |
| kVideoTimingExtensionId, | |
| kAbsoluteCaptureTimeExtensionId, | |
| kPlayoutDelayExtensionId, | |
| kVideoLayersAllocationExtensionId, | |
| kCorruptionDetectionExtensionId, | |
| }; | |
| constexpr int kPayloadType = 100; | |
| constexpr VideoCodecType kType = VideoCodecType::kVideoCodecGeneric; | |
| constexpr uint32_t kTimestamp = 10; | |
| constexpr uint16_t kSeqNum = 33; | |
| constexpr uint32_t kSsrc = 725242; | |
| constexpr uint32_t kRtxSsrc = 912364; | |
| constexpr int kMaxPacketLength = 1500; | |
| constexpr Timestamp kStartTime = Timestamp::Millis(123456789); | |
| constexpr TimeDelta kDefaultExpectedRetransmissionTime = TimeDelta::Millis(125); | |
| class LoopbackTransportTest : public Transport { | |
| public: | |
| LoopbackTransportTest() { | |
| receivers_extensions_.Register<TransmissionOffset>( | |
| kTransmissionTimeOffsetExtensionId); | |
| receivers_extensions_.Register<AbsoluteSendTime>( | |
| kAbsoluteSendTimeExtensionId); | |
| receivers_extensions_.Register<TransportSequenceNumber>( | |
| kTransportSequenceNumberExtensionId); | |
| receivers_extensions_.Register<VideoOrientation>(kVideoRotationExtensionId); | |
| receivers_extensions_.Register<VideoTimingExtension>( | |
| kVideoTimingExtensionId); | |
| receivers_extensions_.Register<RtpGenericFrameDescriptorExtension00>( | |
| kGenericDescriptorId); | |
| receivers_extensions_.Register<RtpDependencyDescriptorExtension>( | |
| kDependencyDescriptorId); | |
| receivers_extensions_.Register<AbsoluteCaptureTimeExtension>( | |
| kAbsoluteCaptureTimeExtensionId); | |
| receivers_extensions_.Register<PlayoutDelayLimits>( | |
| kPlayoutDelayExtensionId); | |
| receivers_extensions_.Register<RtpVideoLayersAllocationExtension>( | |
| kVideoLayersAllocationExtensionId); | |
| receivers_extensions_.Register<CorruptionDetectionExtension>( | |
| kCorruptionDetectionExtensionId); | |
| } | |
| bool SendRtp(ArrayView<const uint8_t> data, | |
| const PacketOptions& /* options */) override { | |
| sent_packets_.push_back(RtpPacketReceived(&receivers_extensions_)); | |
| EXPECT_TRUE(sent_packets_.back().Parse(data)); | |
| return true; | |
| } | |
| bool SendRtcp(ArrayView<const uint8_t> /* data */, | |
| const PacketOptions& /* options */) override { | |
| return false; | |
| } | |
| const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); } | |
| int packets_sent() { return sent_packets_.size(); } | |
| const std::vector<RtpPacketReceived>& sent_packets() const { | |
| return sent_packets_; | |
| } | |
| private: | |
| RtpHeaderExtensionMap receivers_extensions_; | |
| std::vector<RtpPacketReceived> sent_packets_; | |
| }; | |
| class TestRtpSenderVideo : public RTPSenderVideo { | |
| public: | |
| TestRtpSenderVideo(Clock* clock, | |
| RTPSender* rtp_sender, | |
| const FieldTrialsView& field_trials, | |
| bool raw_packetization) | |
| : RTPSenderVideo([&] { | |
| Config config; | |
| config.clock = clock; | |
| config.rtp_sender = rtp_sender; | |
| config.field_trials = &field_trials; | |
| config.raw_packetization = raw_packetization; | |
| return config; | |
| }()) {} | |
| ~TestRtpSenderVideo() override {} | |
| bool AllowRetransmission(const RTPVideoHeader& header, | |
| int32_t retransmission_settings, | |
| TimeDelta expected_retransmission_time) { | |
| return RTPSenderVideo::AllowRetransmission(GetTemporalId(header), | |
| retransmission_settings, | |
| expected_retransmission_time); | |
| } | |
| }; | |
| class RtpSenderVideoTest : public ::testing::Test { | |
| public: | |
| explicit RtpSenderVideoTest(bool raw_packetization = false) | |
| : fake_clock_(kStartTime), | |
| env_(CreateEnvironment(&fake_clock_)), | |
| retransmission_rate_limiter_(&fake_clock_, 1000), | |
| rtp_module_( | |
| env_, | |
| {.outgoing_transport = &transport_, | |
| .retransmission_rate_limiter = &retransmission_rate_limiter_, | |
| .local_media_ssrc = kSsrc, | |
| .rtx_send_ssrc = kRtxSsrc, | |
| .rid = "rid"}), | |
| rtp_sender_video_( | |
| std::make_unique<TestRtpSenderVideo>(&fake_clock_, | |
| rtp_module_.RtpSender(), | |
| env_.field_trials(), | |
| raw_packetization)) { | |
| rtp_module_.SetSequenceNumber(kSeqNum); | |
| rtp_module_.SetStartTimestamp(0); | |
| } | |
| void UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed( | |
| int version); | |
| protected: | |
| AutoThread main_thread_; | |
| SimulatedClock fake_clock_; | |
| const Environment env_; | |
| LoopbackTransportTest transport_; | |
| RateLimiter retransmission_rate_limiter_; | |
| ModuleRtpRtcpImpl2 rtp_module_; | |
| std::unique_ptr<TestRtpSenderVideo> rtp_sender_video_; | |
| }; | |
| TEST_F(RtpSenderVideoTest, KeyFrameHasCVO) { | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(VideoOrientation::Uri(), | |
| kVideoRotationExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.rotation = kVideoRotation_0; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoRotation rotation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); | |
| EXPECT_EQ(kVideoRotation_0, rotation); | |
| } | |
| TEST_F(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) { | |
| uint8_t kFrame[kMaxPacketLength]; | |
| const int64_t kPacketizationTimeMs = 100; | |
| const int64_t kEncodeStartDeltaMs = 10; | |
| const int64_t kEncodeFinishDeltaMs = 50; | |
| rtp_module_.RegisterRtpHeaderExtension(VideoTimingExtension::Uri(), | |
| kVideoTimingExtensionId); | |
| const Timestamp kCaptureTimestamp = fake_clock_.CurrentTime(); | |
| RTPVideoHeader hdr; | |
| hdr.video_timing.flags = VideoSendTiming::kTriggeredByTimer; | |
| hdr.video_timing.encode_start_delta_ms = kEncodeStartDeltaMs; | |
| hdr.video_timing.encode_finish_delta_ms = kEncodeFinishDeltaMs; | |
| fake_clock_.AdvanceTimeMilliseconds(kPacketizationTimeMs); | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo(kPayloadType, kType, kTimestamp, | |
| kCaptureTimestamp, kFrame, sizeof(kFrame), hdr, | |
| kDefaultExpectedRetransmissionTime, {}); | |
| VideoSendTiming timing; | |
| EXPECT_TRUE(transport_.last_sent_packet().GetExtension<VideoTimingExtension>( | |
| &timing)); | |
| EXPECT_EQ(kPacketizationTimeMs, timing.packetization_finish_delta_ms); | |
| EXPECT_EQ(kEncodeStartDeltaMs, timing.encode_start_delta_ms); | |
| EXPECT_EQ(kEncodeFinishDeltaMs, timing.encode_finish_delta_ms); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| WriteCorruptionExtensionIfHeaderContainsFrameInstrumentationData) { | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(CorruptionDetectionExtension::Uri(), | |
| kCorruptionDetectionExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| FrameInstrumentationData data; | |
| data.SetSequenceIndex(130); // 128 + 2 | |
| data.SetStdDev(2.0); | |
| data.SetLumaErrorThreshold(3); | |
| data.SetChromaErrorThreshold(2); | |
| data.SetSampleValues({12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0}); | |
| hdr.frame_instrumentation_data = data; | |
| CorruptionDetectionMessage message; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| // Only written on last packet. | |
| for (const RtpPacketReceived& packet : transport_.sent_packets()) { | |
| if (&packet == &transport_.last_sent_packet()) { | |
| EXPECT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<CorruptionDetectionExtension>(&message)); | |
| } else { | |
| EXPECT_FALSE(packet.HasExtension<CorruptionDetectionExtension>()); | |
| } | |
| } | |
| EXPECT_EQ(message.sequence_index(), 2); | |
| EXPECT_FALSE(message.interpret_sequence_index_as_most_significant_bits()); | |
| EXPECT_NEAR(message.std_dev(), 2.0392156862745097, 0.041); // ~2% | |
| EXPECT_EQ(message.luma_error_threshold(), 3); | |
| EXPECT_EQ(message.chroma_error_threshold(), 2); | |
| EXPECT_THAT(message.sample_values(), | |
| ElementsAre(12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0, 12.0)); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| WriteCorruptionExtensionIfHeaderContainsFrameInstrumentationSyncData) { | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(CorruptionDetectionExtension::Uri(), | |
| kCorruptionDetectionExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| // Send data with sequence index divisible by 2^7 and no sample values in | |
| // order create a sync message with upper bits set. | |
| hdr.frame_instrumentation_data.emplace().SetSequenceIndex(128); | |
| CorruptionDetectionMessage message; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| // Only written on last packet. | |
| for (const RtpPacketReceived& packet : transport_.sent_packets()) { | |
| if (&packet == &transport_.last_sent_packet()) { | |
| EXPECT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<CorruptionDetectionExtension>(&message)); | |
| } else { | |
| EXPECT_FALSE(packet.HasExtension<CorruptionDetectionExtension>()); | |
| } | |
| } | |
| EXPECT_EQ(message.sequence_index(), 1); | |
| EXPECT_TRUE(message.interpret_sequence_index_as_most_significant_bits()); | |
| EXPECT_DOUBLE_EQ(message.std_dev(), 0.0); | |
| EXPECT_EQ(message.luma_error_threshold(), 0); | |
| EXPECT_EQ(message.chroma_error_threshold(), 0); | |
| EXPECT_THAT(message.sample_values(), IsEmpty()); | |
| } | |
| TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) { | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(VideoOrientation::Uri(), | |
| kVideoRotationExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.rotation = kVideoRotation_90; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| EXPECT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {})); | |
| hdr.rotation = kVideoRotation_0; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| EXPECT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp + 1, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {})); | |
| VideoRotation rotation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); | |
| EXPECT_EQ(kVideoRotation_0, rotation); | |
| } | |
| TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) { | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(VideoOrientation::Uri(), | |
| kVideoRotationExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.rotation = kVideoRotation_90; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| EXPECT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {})); | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| EXPECT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp + 1, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {})); | |
| VideoRotation rotation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet().GetExtension<VideoOrientation>(&rotation)); | |
| EXPECT_EQ(kVideoRotation_90, rotation); | |
| } | |
| // Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits | |
| // are set in the CVO byte. | |
| TEST_F(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) { | |
| // Test extracting rotation when Camera (C) and Flip (F) bits are zero. | |
| EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0)); | |
| EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1)); | |
| EXPECT_EQ(kVideoRotation_180, ConvertCVOByteToVideoRotation(2)); | |
| EXPECT_EQ(kVideoRotation_270, ConvertCVOByteToVideoRotation(3)); | |
| // Test extracting rotation when Camera (C) and Flip (F) bits are set. | |
| const int flip_bit = 1 << 2; | |
| const int camera_bit = 1 << 3; | |
| EXPECT_EQ(kVideoRotation_0, | |
| ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0)); | |
| EXPECT_EQ(kVideoRotation_90, | |
| ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1)); | |
| EXPECT_EQ(kVideoRotation_180, | |
| ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2)); | |
| EXPECT_EQ(kVideoRotation_270, | |
| ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3)); | |
| } | |
| TEST_F(RtpSenderVideoTest, RetransmissionTypesGeneric) { | |
| RTPVideoHeader header; | |
| header.codec = kVideoCodecGeneric; | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitOff, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitBaseLayer, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kConditionallyRetransmitHigherLayers, | |
| kDefaultExpectedRetransmissionTime)); | |
| } | |
| TEST_F(RtpSenderVideoTest, RetransmissionTypesH264) { | |
| RTPVideoHeader header; | |
| header.video_type_header.emplace<RTPVideoHeaderH264>().packetization_mode = | |
| H264PacketizationMode::NonInterleaved; | |
| header.codec = kVideoCodecH264; | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitOff, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitBaseLayer, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kConditionallyRetransmitHigherLayers, | |
| kDefaultExpectedRetransmissionTime)); | |
| } | |
| TEST_F(RtpSenderVideoTest, RetransmissionTypesVP8BaseLayer) { | |
| RTPVideoHeader header; | |
| header.codec = kVideoCodecVP8; | |
| auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| vp8_header.temporalIdx = 0; | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitOff, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitBaseLayer, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers | kRetransmitBaseLayer, | |
| kDefaultExpectedRetransmissionTime)); | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kConditionallyRetransmitHigherLayers, | |
| kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers, | |
| kDefaultExpectedRetransmissionTime)); | |
| } | |
| TEST_F(RtpSenderVideoTest, RetransmissionTypesVP8HigherLayers) { | |
| RTPVideoHeader header; | |
| header.codec = kVideoCodecVP8; | |
| auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) { | |
| vp8_header.temporalIdx = tid; | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitOff, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitBaseLayer, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers | kRetransmitBaseLayer, | |
| kDefaultExpectedRetransmissionTime)); | |
| } | |
| } | |
| TEST_F(RtpSenderVideoTest, RetransmissionTypesVP9) { | |
| RTPVideoHeader header; | |
| header.codec = kVideoCodecVP9; | |
| auto& vp9_header = header.video_type_header.emplace<RTPVideoHeaderVP9>(); | |
| for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) { | |
| vp9_header.temporal_idx = tid; | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitOff, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitBaseLayer, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers, kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission( | |
| header, kRetransmitHigherLayers | kRetransmitBaseLayer, | |
| kDefaultExpectedRetransmissionTime)); | |
| } | |
| } | |
| TEST_F(RtpSenderVideoTest, ConditionalRetransmit) { | |
| constexpr TimeDelta kFrameInterval = TimeDelta::Millis(33); | |
| constexpr TimeDelta kRtt = (kFrameInterval * 3) / 2; | |
| const uint8_t kSettings = | |
| kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers; | |
| // Insert VP8 frames for all temporal layers, but stop before the final index. | |
| RTPVideoHeader header; | |
| header.codec = kVideoCodecVP8; | |
| // Fill averaging window to prevent rounding errors. | |
| constexpr int kNumRepetitions = | |
| RTPSenderVideo::kTLRateWindowSize / kFrameInterval; | |
| constexpr std::array kPattern = {0, 2, 1, 2}; | |
| auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| for (size_t i = 0; i < kPattern.size() * kNumRepetitions; ++i) { | |
| vp8_header.temporalIdx = kPattern[i % kPattern.size()]; | |
| rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt); | |
| fake_clock_.AdvanceTime(kFrameInterval); | |
| } | |
| // Since we're at the start of the pattern, the next expected frame in TL0 is | |
| // right now. We will wait at most one expected retransmission time before | |
| // acknowledging that it did not arrive, which means this frame and the next | |
| // will not be retransmitted. | |
| vp8_header.temporalIdx = 1; | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt)); | |
| fake_clock_.AdvanceTime(kFrameInterval); | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt)); | |
| fake_clock_.AdvanceTime(kFrameInterval); | |
| // The TL0 frame did not arrive. So allow retransmission. | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt)); | |
| fake_clock_.AdvanceTime(kFrameInterval); | |
| // Insert a frame for TL2. We just had frame in TL1, so the next one there is | |
| // in three frames away. TL0 is still too far in the past. So, allow | |
| // retransmission. | |
| vp8_header.temporalIdx = 2; | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt)); | |
| fake_clock_.AdvanceTime(kFrameInterval); | |
| // Another TL2, next in TL1 is two frames away. Allow again. | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt)); | |
| fake_clock_.AdvanceTime(kFrameInterval); | |
| // Yet another TL2, next in TL1 is now only one frame away, so don't store | |
| // for retransmission. | |
| EXPECT_FALSE(rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt)); | |
| } | |
| TEST_F(RtpSenderVideoTest, ConditionalRetransmitLimit) { | |
| constexpr TimeDelta kFrameInterval = TimeDelta::Millis(200); | |
| constexpr TimeDelta kRtt = (kFrameInterval * 3) / 2; | |
| const int32_t kSettings = | |
| kRetransmitBaseLayer | kConditionallyRetransmitHigherLayers; | |
| // Insert VP8 frames for all temporal layers, but stop before the final index. | |
| RTPVideoHeader header; | |
| header.codec = kVideoCodecVP8; | |
| // Fill averaging window to prevent rounding errors. | |
| constexpr int kNumRepetitions = | |
| RTPSenderVideo::kTLRateWindowSize / kFrameInterval; | |
| constexpr std::array kPattern = {0, 2, 2, 2}; | |
| auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| for (size_t i = 0; i < kPattern.size() * kNumRepetitions; ++i) { | |
| vp8_header.temporalIdx = kPattern[i % kPattern.size()]; | |
| rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt); | |
| fake_clock_.AdvanceTime(kFrameInterval); | |
| } | |
| // Since we're at the start of the pattern, the next expected frame will be | |
| // right now in TL0. Put it in TL1 instead. Regular rules would dictate that | |
| // we don't store for retransmission because we expect a frame in a lower | |
| // layer, but that last frame in TL1 was a long time ago in absolute terms, | |
| // so allow retransmission anyway. | |
| vp8_header.temporalIdx = 1; | |
| EXPECT_TRUE(rtp_sender_video_->AllowRetransmission(header, kSettings, kRtt)); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| ReservesEnoughSpaceForRtxPacketWhenMidAndRsidAreRegistered) { | |
| constexpr int kMediaPayloadId = 100; | |
| constexpr int kRtxPayloadId = 101; | |
| constexpr size_t kMaxPacketSize = 1'000; | |
| rtp_module_.SetMaxRtpPacketSize(kMaxPacketSize); | |
| rtp_module_.RegisterRtpHeaderExtension(RtpMid::Uri(), 1); | |
| rtp_module_.RegisterRtpHeaderExtension(RtpStreamId::Uri(), 2); | |
| rtp_module_.RegisterRtpHeaderExtension(RepairedRtpStreamId::Uri(), 3); | |
| rtp_module_.RegisterRtpHeaderExtension(AbsoluteSendTime::Uri(), 4); | |
| rtp_module_.SetMid("long_mid"); | |
| rtp_module_.SetRtxSendPayloadType(kRtxPayloadId, kMediaPayloadId); | |
| rtp_module_.SetStorePacketsStatus(/*enable=*/true, 10); | |
| rtp_module_.SetRtxSendStatus(kRtxRetransmitted); | |
| RTPVideoHeader header; | |
| header.codec = kVideoCodecVP8; | |
| header.frame_type = VideoFrameType::kVideoFrameDelta; | |
| auto& vp8_header = header.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| vp8_header.temporalIdx = 0; | |
| uint8_t kPayload[kMaxPacketSize] = {}; | |
| EXPECT_TRUE(rtp_sender_video_->SendVideo( | |
| kMediaPayloadId, /*codec_type=*/kVideoCodecVP8, /*rtp_timestamp=*/0, | |
| /*capture_time=*/Timestamp::Seconds(1), kPayload, sizeof(kPayload), | |
| header, | |
| /*expected_retransmission_time=*/TimeDelta::PlusInfinity(), | |
| /*csrcs=*/{})); | |
| ASSERT_THAT(transport_.sent_packets(), Not(IsEmpty())); | |
| // Ack media ssrc, but not rtx ssrc. | |
| rtcp::ReceiverReport rr; | |
| rtcp::ReportBlock rb; | |
| rb.SetMediaSsrc(kSsrc); | |
| rb.SetExtHighestSeqNum(transport_.last_sent_packet().SequenceNumber()); | |
| rr.AddReportBlock(rb); | |
| rtp_module_.IncomingRtcpPacket(rr.Build()); | |
| // Test for various frame size close to `kMaxPacketSize` to catch edge cases | |
| // when rtx packet barely fit. | |
| for (size_t frame_size = 800; frame_size < kMaxPacketSize; ++frame_size) { | |
| SCOPED_TRACE(frame_size); | |
| ArrayView<const uint8_t> payload(kPayload, frame_size); | |
| EXPECT_TRUE(rtp_sender_video_->SendVideo( | |
| kMediaPayloadId, /*codec_type=*/kVideoCodecVP8, /*rtp_timestamp=*/0, | |
| /*capture_time=*/Timestamp::Seconds(1), payload, frame_size, header, | |
| /*expected_retransmission_time=*/TimeDelta::Seconds(1), /*csrcs=*/{})); | |
| const RtpPacketReceived& media_packet = transport_.last_sent_packet(); | |
| EXPECT_EQ(media_packet.Ssrc(), kSsrc); | |
| rtcp::Nack nack; | |
| nack.SetMediaSsrc(kSsrc); | |
| nack.SetPacketIds({media_packet.SequenceNumber()}); | |
| rtp_module_.IncomingRtcpPacket(nack.Build()); | |
| const RtpPacketReceived& rtx_packet = transport_.last_sent_packet(); | |
| EXPECT_EQ(rtx_packet.Ssrc(), kRtxSsrc); | |
| EXPECT_LE(rtx_packet.size(), kMaxPacketSize); | |
| } | |
| } | |
| TEST_F(RtpSenderVideoTest, SendsDependencyDescriptorWhenVideoStructureIsSet) { | |
| const int64_t kFrameId = 100000; | |
| uint8_t kFrame[100]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpDependencyDescriptorExtension::Uri(), kDependencyDescriptorId); | |
| FrameDependencyStructure video_structure; | |
| video_structure.num_decode_targets = 2; | |
| video_structure.templates = { | |
| FrameDependencyTemplate().S(0).T(0).Dtis("SS"), | |
| FrameDependencyTemplate().S(1).T(0).Dtis("-S"), | |
| FrameDependencyTemplate().S(1).T(1).Dtis("-D"), | |
| }; | |
| rtp_sender_video_->SetVideoStructure(&video_structure); | |
| // Send key frame. | |
| RTPVideoHeader hdr; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); | |
| generic.frame_id = kFrameId; | |
| generic.temporal_index = 0; | |
| generic.spatial_index = 0; | |
| generic.decode_target_indications = {DecodeTargetIndication::kSwitch, | |
| DecodeTargetIndication::kSwitch}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_EQ(transport_.packets_sent(), 1); | |
| DependencyDescriptor descriptor_key; | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<RtpDependencyDescriptorExtension>( | |
| nullptr, &descriptor_key)); | |
| ASSERT_TRUE(descriptor_key.attached_structure); | |
| EXPECT_EQ(descriptor_key.attached_structure->num_decode_targets, 2); | |
| EXPECT_THAT(descriptor_key.attached_structure->templates, SizeIs(3)); | |
| EXPECT_EQ(descriptor_key.frame_number, kFrameId & 0xFFFF); | |
| EXPECT_EQ(descriptor_key.frame_dependencies.spatial_id, 0); | |
| EXPECT_EQ(descriptor_key.frame_dependencies.temporal_id, 0); | |
| EXPECT_EQ(descriptor_key.frame_dependencies.decode_target_indications, | |
| generic.decode_target_indications); | |
| EXPECT_THAT(descriptor_key.frame_dependencies.frame_diffs, IsEmpty()); | |
| // Send delta frame. | |
| generic.frame_id = kFrameId + 1; | |
| generic.temporal_index = 1; | |
| generic.spatial_index = 1; | |
| generic.dependencies = {kFrameId, kFrameId - 500}; | |
| generic.decode_target_indications = {DecodeTargetIndication::kNotPresent, | |
| DecodeTargetIndication::kRequired}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_EQ(transport_.packets_sent(), 2); | |
| DependencyDescriptor descriptor_delta; | |
| ASSERT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpDependencyDescriptorExtension>( | |
| descriptor_key.attached_structure.get(), &descriptor_delta)); | |
| EXPECT_EQ(descriptor_delta.attached_structure, nullptr); | |
| EXPECT_EQ(descriptor_delta.frame_number, (kFrameId + 1) & 0xFFFF); | |
| EXPECT_EQ(descriptor_delta.frame_dependencies.spatial_id, 1); | |
| EXPECT_EQ(descriptor_delta.frame_dependencies.temporal_id, 1); | |
| EXPECT_EQ(descriptor_delta.frame_dependencies.decode_target_indications, | |
| generic.decode_target_indications); | |
| EXPECT_THAT(descriptor_delta.frame_dependencies.frame_diffs, | |
| ElementsAre(1, 501)); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| SkipsDependencyDescriptorOnDeltaFrameWhenFailedToAttachToKeyFrame) { | |
| const int64_t kFrameId = 100000; | |
| uint8_t kFrame[100]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpDependencyDescriptorExtension::Uri(), kDependencyDescriptorId); | |
| rtp_module_.SetExtmapAllowMixed(false); | |
| FrameDependencyStructure video_structure; | |
| video_structure.num_decode_targets = 2; | |
| // Use many templates so that key dependency descriptor would be too large | |
| // to fit into 16 bytes (max size of one byte header rtp header extension) | |
| video_structure.templates = { | |
| FrameDependencyTemplate().S(0).T(0).Dtis("SS"), | |
| FrameDependencyTemplate().S(1).T(0).Dtis("-S"), | |
| FrameDependencyTemplate().S(1).T(1).Dtis("-D").FrameDiffs({1, 2, 3, 4}), | |
| FrameDependencyTemplate().S(1).T(1).Dtis("-D").FrameDiffs({2, 3, 4, 5}), | |
| FrameDependencyTemplate().S(1).T(1).Dtis("-D").FrameDiffs({3, 4, 5, 6}), | |
| FrameDependencyTemplate().S(1).T(1).Dtis("-D").FrameDiffs({4, 5, 6, 7}), | |
| }; | |
| rtp_sender_video_->SetVideoStructure(&video_structure); | |
| // Send key frame. | |
| RTPVideoHeader hdr; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); | |
| generic.frame_id = kFrameId; | |
| generic.temporal_index = 0; | |
| generic.spatial_index = 0; | |
| generic.decode_target_indications = {DecodeTargetIndication::kSwitch, | |
| DecodeTargetIndication::kSwitch}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_EQ(transport_.packets_sent(), 1); | |
| DependencyDescriptor descriptor_key; | |
| ASSERT_FALSE(transport_.last_sent_packet() | |
| .HasExtension<RtpDependencyDescriptorExtension>()); | |
| // Send delta frame. | |
| generic.frame_id = kFrameId + 1; | |
| generic.temporal_index = 1; | |
| generic.spatial_index = 1; | |
| generic.dependencies = {kFrameId, kFrameId - 500}; | |
| generic.decode_target_indications = {DecodeTargetIndication::kNotPresent, | |
| DecodeTargetIndication::kRequired}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_EQ(transport_.packets_sent(), 2); | |
| EXPECT_FALSE(transport_.last_sent_packet() | |
| .HasExtension<RtpDependencyDescriptorExtension>()); | |
| } | |
| TEST_F(RtpSenderVideoTest, PropagatesChainDiffsIntoDependencyDescriptor) { | |
| const int64_t kFrameId = 100000; | |
| uint8_t kFrame[100]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpDependencyDescriptorExtension::Uri(), kDependencyDescriptorId); | |
| FrameDependencyStructure video_structure; | |
| video_structure.num_decode_targets = 2; | |
| video_structure.num_chains = 1; | |
| video_structure.decode_target_protected_by_chain = {0, 0}; | |
| video_structure.templates = { | |
| FrameDependencyTemplate().S(0).T(0).Dtis("SS").ChainDiffs({1}), | |
| }; | |
| rtp_sender_video_->SetVideoStructure(&video_structure); | |
| RTPVideoHeader hdr; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); | |
| generic.frame_id = kFrameId; | |
| generic.decode_target_indications = {DecodeTargetIndication::kSwitch, | |
| DecodeTargetIndication::kSwitch}; | |
| generic.chain_diffs = {2}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_EQ(transport_.packets_sent(), 1); | |
| DependencyDescriptor descriptor_key; | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<RtpDependencyDescriptorExtension>( | |
| nullptr, &descriptor_key)); | |
| EXPECT_THAT(descriptor_key.frame_dependencies.chain_diffs, | |
| ContainerEq(generic.chain_diffs)); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| PropagatesActiveDecodeTargetsIntoDependencyDescriptor) { | |
| const int64_t kFrameId = 100000; | |
| uint8_t kFrame[100]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpDependencyDescriptorExtension::Uri(), kDependencyDescriptorId); | |
| FrameDependencyStructure video_structure; | |
| video_structure.num_decode_targets = 2; | |
| video_structure.num_chains = 1; | |
| video_structure.decode_target_protected_by_chain = {0, 0}; | |
| video_structure.templates = { | |
| FrameDependencyTemplate().S(0).T(0).Dtis("SS").ChainDiffs({1}), | |
| }; | |
| rtp_sender_video_->SetVideoStructure(&video_structure); | |
| RTPVideoHeader hdr; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); | |
| generic.frame_id = kFrameId; | |
| generic.decode_target_indications = {DecodeTargetIndication::kSwitch, | |
| DecodeTargetIndication::kSwitch}; | |
| generic.active_decode_targets = 0b01; | |
| generic.chain_diffs = {1}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_EQ(transport_.packets_sent(), 1); | |
| DependencyDescriptor descriptor_key; | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<RtpDependencyDescriptorExtension>( | |
| nullptr, &descriptor_key)); | |
| EXPECT_EQ(descriptor_key.active_decode_targets_bitmask, 0b01u); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| SetDiffentVideoStructureAvoidsCollisionWithThePreviousStructure) { | |
| const int64_t kFrameId = 100000; | |
| uint8_t kFrame[100]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpDependencyDescriptorExtension::Uri(), kDependencyDescriptorId); | |
| FrameDependencyStructure video_structure1; | |
| video_structure1.num_decode_targets = 2; | |
| video_structure1.templates = { | |
| FrameDependencyTemplate().S(0).T(0).Dtis("SS"), | |
| FrameDependencyTemplate().S(0).T(1).Dtis("D-"), | |
| }; | |
| FrameDependencyStructure video_structure2; | |
| video_structure2.num_decode_targets = 2; | |
| video_structure2.templates = { | |
| FrameDependencyTemplate().S(0).T(0).Dtis("SS"), | |
| FrameDependencyTemplate().S(0).T(1).Dtis("R-"), | |
| }; | |
| // Send 1st key frame. | |
| RTPVideoHeader hdr; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); | |
| generic.frame_id = kFrameId; | |
| generic.decode_target_indications = {DecodeTargetIndication::kSwitch, | |
| DecodeTargetIndication::kSwitch}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SetVideoStructure(&video_structure1); | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| // Parse 1st extension. | |
| ASSERT_EQ(transport_.packets_sent(), 1); | |
| DependencyDescriptor descriptor_key1; | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<RtpDependencyDescriptorExtension>( | |
| nullptr, &descriptor_key1)); | |
| ASSERT_TRUE(descriptor_key1.attached_structure); | |
| // Send the delta frame. | |
| generic.frame_id = kFrameId + 1; | |
| generic.temporal_index = 1; | |
| generic.decode_target_indications = {DecodeTargetIndication::kDiscardable, | |
| DecodeTargetIndication::kNotPresent}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_EQ(transport_.packets_sent(), 2); | |
| RtpPacket delta_packet = transport_.last_sent_packet(); | |
| // Send 2nd key frame. | |
| generic.frame_id = kFrameId + 2; | |
| generic.decode_target_indications = {DecodeTargetIndication::kSwitch, | |
| DecodeTargetIndication::kSwitch}; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SetVideoStructure(&video_structure2); | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| // Parse the 2nd key frame. | |
| ASSERT_EQ(transport_.packets_sent(), 3); | |
| DependencyDescriptor descriptor_key2; | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<RtpDependencyDescriptorExtension>( | |
| nullptr, &descriptor_key2)); | |
| ASSERT_TRUE(descriptor_key2.attached_structure); | |
| // Try to parse the 1st delta frame. It should parseble using the structure | |
| // from the 1st key frame, but not using the structure from the 2nd key frame. | |
| DependencyDescriptor descriptor_delta; | |
| EXPECT_TRUE(delta_packet.GetExtension<RtpDependencyDescriptorExtension>( | |
| descriptor_key1.attached_structure.get(), &descriptor_delta)); | |
| EXPECT_FALSE(delta_packet.GetExtension<RtpDependencyDescriptorExtension>( | |
| descriptor_key2.attached_structure.get(), &descriptor_delta)); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| AuthenticateVideoHeaderWhenDependencyDescriptorExtensionIsUsed) { | |
| static constexpr size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize] = {1, 2, 3, 4}; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpDependencyDescriptorExtension::Uri(), kDependencyDescriptorId); | |
| auto encryptor = make_ref_counted<NiceMock<MockFrameEncryptor>>(); | |
| ON_CALL(*encryptor, GetMaxCiphertextByteSize).WillByDefault(ReturnArg<1>()); | |
| ON_CALL(*encryptor, Encrypt) | |
| .WillByDefault(WithArgs<3, 5>( | |
| [](ArrayView<const uint8_t> frame, size_t* bytes_written) { | |
| *bytes_written = frame.size(); | |
| return 0; | |
| })); | |
| RTPSenderVideo::Config config; | |
| config.clock = &fake_clock_; | |
| config.rtp_sender = rtp_module_.RtpSender(); | |
| config.field_trials = &env_.field_trials(); | |
| config.frame_encryptor = encryptor.get(); | |
| RTPSenderVideo rtp_sender_video(config); | |
| FrameDependencyStructure video_structure; | |
| video_structure.num_decode_targets = 1; | |
| video_structure.templates = {FrameDependencyTemplate().Dtis("S")}; | |
| rtp_sender_video.SetVideoStructure(&video_structure); | |
| // Send key frame. | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| hdr.generic.emplace().decode_target_indications = | |
| video_structure.templates[0].decode_target_indications; | |
| EXPECT_CALL(*encryptor, | |
| Encrypt(_, _, Not(IsEmpty()), ElementsAreArray(kFrame), _, _)); | |
| rtp_sender_video.SendVideo(kPayloadType, kType, kTimestamp, | |
| fake_clock_.CurrentTime(), kFrame, sizeof(kFrame), | |
| hdr, kDefaultExpectedRetransmissionTime, {}); | |
| // Double check packet with the dependency descriptor is sent. | |
| ASSERT_EQ(transport_.packets_sent(), 1); | |
| EXPECT_TRUE(transport_.last_sent_packet() | |
| .HasExtension<RtpDependencyDescriptorExtension>()); | |
| } | |
| TEST_F(RtpSenderVideoTest, PopulateGenericFrameDescriptor) { | |
| const int64_t kFrameId = 100000; | |
| uint8_t kFrame[100]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpGenericFrameDescriptorExtension00::Uri(), kGenericDescriptorId); | |
| RTPVideoHeader hdr; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); | |
| generic.frame_id = kFrameId; | |
| generic.temporal_index = 3; | |
| generic.spatial_index = 2; | |
| generic.dependencies.push_back(kFrameId - 1); | |
| generic.dependencies.push_back(kFrameId - 500); | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| RtpGenericFrameDescriptor descriptor_wire; | |
| EXPECT_EQ(1, transport_.packets_sent()); | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .GetExtension<RtpGenericFrameDescriptorExtension00>( | |
| &descriptor_wire)); | |
| EXPECT_EQ(static_cast<uint16_t>(generic.frame_id), descriptor_wire.FrameId()); | |
| EXPECT_EQ(generic.temporal_index, descriptor_wire.TemporalLayer()); | |
| EXPECT_THAT(descriptor_wire.FrameDependenciesDiffs(), ElementsAre(1, 500)); | |
| EXPECT_EQ(descriptor_wire.SpatialLayersBitmask(), 0b0000'0100); | |
| } | |
| void RtpSenderVideoTest:: | |
| UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed( | |
| int /* version */) { | |
| const int64_t kFrameId = 100000; | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpGenericFrameDescriptorExtension00::Uri(), kGenericDescriptorId); | |
| RTPVideoHeader hdr; | |
| hdr.codec = kVideoCodecVP8; | |
| RTPVideoHeaderVP8& vp8 = hdr.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| vp8.pictureId = kFrameId % 0X7FFF; | |
| vp8.tl0PicIdx = 13; | |
| vp8.temporalIdx = 1; | |
| vp8.keyIdx = 2; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); | |
| generic.frame_id = kFrameId; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo(kPayloadType, VideoCodecType::kVideoCodecVP8, | |
| kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, | |
| kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_EQ(transport_.packets_sent(), 1); | |
| // Expect only minimal 1-byte vp8 descriptor was generated. | |
| EXPECT_EQ(transport_.last_sent_packet().payload_size(), 1 + kFrameSize); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed00) { | |
| UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed(0); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed01) { | |
| UsesMinimalVp8DescriptorWhenGenericFrameDescriptorExtensionIsUsed(1); | |
| } | |
| TEST_F(RtpSenderVideoTest, VideoLayersAllocationWithResolutionSentOnKeyFrames) { | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpVideoLayersAllocationExtension::Uri(), | |
| kVideoLayersAllocationExtensionId); | |
| VideoLayersAllocation allocation; | |
| VideoLayersAllocation::SpatialLayer layer; | |
| layer.width = 360; | |
| layer.height = 180; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(50)); | |
| allocation.resolution_and_frame_rate_is_valid = true; | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoLayersAllocation sent_allocation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| EXPECT_THAT(sent_allocation.active_spatial_layers, ElementsAre(layer)); | |
| // Next key frame also have the allocation. | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| VideoLayersAllocationWithoutResolutionSentOnDeltaWhenUpdated) { | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpVideoLayersAllocationExtension::Uri(), | |
| kVideoLayersAllocationExtensionId); | |
| VideoLayersAllocation allocation; | |
| VideoLayersAllocation::SpatialLayer layer; | |
| layer.width = 360; | |
| layer.height = 180; | |
| allocation.resolution_and_frame_rate_is_valid = true; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(50)); | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_TRUE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| // No allocation sent on delta frame unless it has been updated. | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_FALSE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| // Update the allocation. | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoLayersAllocation sent_allocation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| ASSERT_THAT(sent_allocation.active_spatial_layers, SizeIs(1)); | |
| EXPECT_FALSE(sent_allocation.resolution_and_frame_rate_is_valid); | |
| EXPECT_THAT(sent_allocation.active_spatial_layers[0] | |
| .target_bitrate_per_temporal_layer, | |
| SizeIs(1)); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| VideoLayersAllocationWithResolutionSentOnDeltaWhenSpatialLayerAdded) { | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpVideoLayersAllocationExtension::Uri(), | |
| kVideoLayersAllocationExtensionId); | |
| VideoLayersAllocation allocation; | |
| allocation.resolution_and_frame_rate_is_valid = true; | |
| VideoLayersAllocation::SpatialLayer layer; | |
| layer.width = 360; | |
| layer.height = 180; | |
| layer.spatial_id = 0; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(50)); | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| // Update the allocation. | |
| layer.width = 640; | |
| layer.height = 320; | |
| layer.spatial_id = 1; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(100)); | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoLayersAllocation sent_allocation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| EXPECT_THAT(sent_allocation.active_spatial_layers, SizeIs(2)); | |
| EXPECT_TRUE(sent_allocation.resolution_and_frame_rate_is_valid); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| VideoLayersAllocationWithResolutionSentOnLargeFrameRateChange) { | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpVideoLayersAllocationExtension::Uri(), | |
| kVideoLayersAllocationExtensionId); | |
| VideoLayersAllocation allocation; | |
| allocation.resolution_and_frame_rate_is_valid = true; | |
| VideoLayersAllocation::SpatialLayer layer; | |
| layer.width = 360; | |
| layer.height = 180; | |
| layer.spatial_id = 0; | |
| layer.frame_rate_fps = 10; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(50)); | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| // Update frame rate only. | |
| allocation.active_spatial_layers[0].frame_rate_fps = 20; | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoLayersAllocation sent_allocation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| ASSERT_TRUE(sent_allocation.resolution_and_frame_rate_is_valid); | |
| EXPECT_EQ(sent_allocation.active_spatial_layers[0].frame_rate_fps, 20); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| VideoLayersAllocationWithoutResolutionSentOnSmallFrameRateChange) { | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpVideoLayersAllocationExtension::Uri(), | |
| kVideoLayersAllocationExtensionId); | |
| VideoLayersAllocation allocation; | |
| allocation.resolution_and_frame_rate_is_valid = true; | |
| VideoLayersAllocation::SpatialLayer layer; | |
| layer.width = 360; | |
| layer.height = 180; | |
| layer.spatial_id = 0; | |
| layer.frame_rate_fps = 10; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(50)); | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_TRUE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| // Update frame rate slightly. | |
| allocation.active_spatial_layers[0].frame_rate_fps = 9; | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoLayersAllocation sent_allocation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| EXPECT_FALSE(sent_allocation.resolution_and_frame_rate_is_valid); | |
| } | |
| TEST_F(RtpSenderVideoTest, VideoLayersAllocationSentOnDeltaFramesOnlyOnUpdate) { | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpVideoLayersAllocationExtension::Uri(), | |
| kVideoLayersAllocationExtensionId); | |
| VideoLayersAllocation allocation; | |
| VideoLayersAllocation::SpatialLayer layer; | |
| layer.width = 360; | |
| layer.height = 180; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(50)); | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoLayersAllocation sent_allocation; | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| EXPECT_THAT(sent_allocation.active_spatial_layers, SizeIs(1)); | |
| // VideoLayersAllocation not sent on the next delta frame. | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_FALSE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| // Update allocation. VideoLayesAllocation should be sent on the next frame. | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_TRUE( | |
| transport_.last_sent_packet() | |
| .GetExtension<RtpVideoLayersAllocationExtension>(&sent_allocation)); | |
| } | |
| TEST_F(RtpSenderVideoTest, VideoLayersAllocationNotSentOnHigherTemporalLayers) { | |
| const size_t kFrameSize = 100; | |
| uint8_t kFrame[kFrameSize]; | |
| rtp_module_.RegisterRtpHeaderExtension( | |
| RtpVideoLayersAllocationExtension::Uri(), | |
| kVideoLayersAllocationExtensionId); | |
| VideoLayersAllocation allocation; | |
| allocation.resolution_and_frame_rate_is_valid = true; | |
| VideoLayersAllocation::SpatialLayer layer; | |
| layer.width = 360; | |
| layer.height = 180; | |
| layer.target_bitrate_per_temporal_layer.push_back( | |
| DataRate::KilobitsPerSec(50)); | |
| allocation.active_spatial_layers.push_back(layer); | |
| rtp_sender_video_->SetVideoLayersAllocation(allocation); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| hdr.codec = VideoCodecType::kVideoCodecVP8; | |
| auto& vp8_header = hdr.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| vp8_header.temporalIdx = 1; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_FALSE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| // Send a delta frame on tl0. | |
| vp8_header.temporalIdx = 0; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_TRUE(transport_.last_sent_packet() | |
| .HasExtension<RtpVideoLayersAllocationExtension>()); | |
| } | |
| TEST_F(RtpSenderVideoTest, | |
| AbsoluteCaptureTimeNotForwardedWhenImageHasNoCaptureTime) { | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(AbsoluteCaptureTimeExtension::Uri(), | |
| kAbsoluteCaptureTimeExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo(kPayloadType, kType, kTimestamp, | |
| /*capture_time=*/Timestamp::MinusInfinity(), | |
| kFrame, sizeof(kFrame), hdr, | |
| kDefaultExpectedRetransmissionTime, {}); | |
| // No absolute capture time should be set as the capture_time_ms was the | |
| // default value. | |
| for (const RtpPacketReceived& packet : transport_.sent_packets()) { | |
| EXPECT_FALSE(packet.HasExtension<AbsoluteCaptureTimeExtension>()); | |
| } | |
| } | |
| TEST_F(RtpSenderVideoTest, AbsoluteCaptureTime) { | |
| rtp_sender_video_ = std::make_unique<TestRtpSenderVideo>( | |
| &fake_clock_, rtp_module_.RtpSender(), env_.field_trials(), | |
| /*raw_packetization=*/false); | |
| constexpr Timestamp kAbsoluteCaptureTimestamp = Timestamp::Millis(12345678); | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(AbsoluteCaptureTimeExtension::Uri(), | |
| kAbsoluteCaptureTimeExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, kAbsoluteCaptureTimestamp, kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| std::optional<AbsoluteCaptureTime> absolute_capture_time; | |
| // It is expected that one and only one of the packets sent on this video | |
| // frame has absolute capture time header extension. | |
| for (const RtpPacketReceived& packet : transport_.sent_packets()) { | |
| if (absolute_capture_time.has_value()) { | |
| EXPECT_FALSE(packet.HasExtension<AbsoluteCaptureTimeExtension>()); | |
| } else { | |
| absolute_capture_time = | |
| packet.GetExtension<AbsoluteCaptureTimeExtension>(); | |
| } | |
| } | |
| // Verify the capture timestamp and that the clock offset is set to zero. | |
| ASSERT_TRUE(absolute_capture_time.has_value()); | |
| EXPECT_EQ(absolute_capture_time->absolute_capture_timestamp, | |
| Int64MsToUQ32x32( | |
| fake_clock_.ConvertTimestampToNtpTime(kAbsoluteCaptureTimestamp) | |
| .ToMs())); | |
| EXPECT_EQ(absolute_capture_time->estimated_capture_clock_offset, 0); | |
| } | |
| TEST_F(RtpSenderVideoTest, AbsoluteCaptureTimeWithExtensionProvided) { | |
| constexpr AbsoluteCaptureTime kAbsoluteCaptureTime = { | |
| .absolute_capture_timestamp = 123, | |
| .estimated_capture_clock_offset = std::optional<int64_t>(456), | |
| }; | |
| uint8_t kFrame[kMaxPacketLength]; | |
| rtp_module_.RegisterRtpHeaderExtension(AbsoluteCaptureTimeExtension::Uri(), | |
| kAbsoluteCaptureTimeExtensionId); | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| hdr.absolute_capture_time = kAbsoluteCaptureTime; | |
| rtp_sender_video_->SendVideo(kPayloadType, kType, kTimestamp, | |
| /*capture_time=*/Timestamp::Millis(789), kFrame, | |
| sizeof(kFrame), hdr, | |
| kDefaultExpectedRetransmissionTime, {}); | |
| std::optional<AbsoluteCaptureTime> absolute_capture_time; | |
| // It is expected that one and only one of the packets sent on this video | |
| // frame has absolute capture time header extension. | |
| for (const RtpPacketReceived& packet : transport_.sent_packets()) { | |
| if (absolute_capture_time.has_value()) { | |
| EXPECT_FALSE(packet.HasExtension<AbsoluteCaptureTimeExtension>()); | |
| } else { | |
| absolute_capture_time = | |
| packet.GetExtension<AbsoluteCaptureTimeExtension>(); | |
| } | |
| } | |
| // Verify the extension. | |
| EXPECT_EQ(absolute_capture_time, kAbsoluteCaptureTime); | |
| } | |
| TEST_F(RtpSenderVideoTest, PopulatesPlayoutDelay) { | |
| // Single packet frames. | |
| constexpr size_t kPacketSize = 123; | |
| uint8_t kFrame[kPacketSize]; | |
| rtp_module_.RegisterRtpHeaderExtension(PlayoutDelayLimits::Uri(), | |
| kPlayoutDelayExtensionId); | |
| const VideoPlayoutDelay kExpectedDelay(TimeDelta::Millis(10), | |
| TimeDelta::Millis(20)); | |
| // Send initial key-frame without playout delay. | |
| RTPVideoHeader hdr; | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| hdr.codec = VideoCodecType::kVideoCodecVP8; | |
| auto& vp8_header = hdr.video_type_header.emplace<RTPVideoHeaderVP8>(); | |
| vp8_header.temporalIdx = 0; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_FALSE( | |
| transport_.last_sent_packet().HasExtension<PlayoutDelayLimits>()); | |
| // Set playout delay on a discardable frame. | |
| hdr.playout_delay = kExpectedDelay; | |
| hdr.frame_type = VideoFrameType::kVideoFrameDelta; | |
| vp8_header.temporalIdx = 1; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| VideoPlayoutDelay received_delay = VideoPlayoutDelay(); | |
| ASSERT_TRUE(transport_.last_sent_packet().GetExtension<PlayoutDelayLimits>( | |
| &received_delay)); | |
| EXPECT_EQ(received_delay, kExpectedDelay); | |
| // Set playout delay on a non-discardable frame, the extension should still | |
| // be populated since dilvery wasn't guaranteed on the last one. | |
| hdr.playout_delay = std::nullopt; // Indicates "no change". | |
| vp8_header.temporalIdx = 0; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_TRUE(transport_.last_sent_packet().GetExtension<PlayoutDelayLimits>( | |
| &received_delay)); | |
| EXPECT_EQ(received_delay, kExpectedDelay); | |
| // The next frame does not need the extensions since it's delivery has | |
| // already been guaranteed. | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| EXPECT_FALSE( | |
| transport_.last_sent_packet().HasExtension<PlayoutDelayLimits>()); | |
| // Insert key-frame, we need to refresh the state here. | |
| hdr.frame_type = VideoFrameType::kVideoFrameKey; | |
| rtp_sender_video_->SendVideo( | |
| kPayloadType, kType, kTimestamp, fake_clock_.CurrentTime(), kFrame, | |
| sizeof(kFrame), hdr, kDefaultExpectedRetransmissionTime, {}); | |
| ASSERT_TRUE(transport_.last_sent_packet().GetExtension<PlayoutDelayLimits>( | |
| &received_delay)); | |
| EXPECT_EQ(received_delay, kExpectedDelay); | |
| } | |
| TEST_F(RtpSenderVideoTest, SendGenericVideo) { | |
| const uint8_t kPayloadTypeGeneric = 127; | |
| const VideoCodecType kCodecType = VideoCodecType::kVideoCodecGeneric; | |
| const uint8_t kPayload[] = {47, 11, 32, 93, 89}; | |
| // Send keyframe. | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| ASSERT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadTypeGeneric, kCodecType, 1234, fake_clock_.CurrentTime(), | |
| kPayload, sizeof(kPayload), video_header, TimeDelta::PlusInfinity(), {})); | |
| ArrayView<const uint8_t> sent_payload = | |
| transport_.last_sent_packet().payload(); | |
| uint8_t generic_header = sent_payload[0]; | |
| EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); | |
| EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); | |
| EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(kPayload)); | |
| // Send delta frame. | |
| const uint8_t kDeltaPayload[] = {13, 42, 32, 93, 13}; | |
| video_header.frame_type = VideoFrameType::kVideoFrameDelta; | |
| ASSERT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadTypeGeneric, kCodecType, 1234, fake_clock_.CurrentTime(), | |
| kDeltaPayload, sizeof(kDeltaPayload), video_header, | |
| TimeDelta::PlusInfinity(), {})); | |
| sent_payload = sent_payload = transport_.last_sent_packet().payload(); | |
| generic_header = sent_payload[0]; | |
| EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit); | |
| EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit); | |
| EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(kDeltaPayload)); | |
| } | |
| class RtpSenderVideoRawPacketizationTest : public RtpSenderVideoTest { | |
| public: | |
| RtpSenderVideoRawPacketizationTest() : RtpSenderVideoTest(true) {} | |
| }; | |
| TEST_F(RtpSenderVideoRawPacketizationTest, SendRawVideo) { | |
| const uint8_t kPayloadTypeRaw = 111; | |
| const uint8_t kPayload[] = {11, 22, 33, 44, 55}; | |
| // Send a frame. | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| ASSERT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadTypeRaw, VideoCodecType::kVideoCodecGeneric, 1234, | |
| fake_clock_.CurrentTime(), kPayload, sizeof(kPayload), video_header, | |
| TimeDelta::PlusInfinity(), {})); | |
| ArrayView<const uint8_t> sent_payload = | |
| transport_.last_sent_packet().payload(); | |
| EXPECT_THAT(sent_payload, ElementsAreArray(kPayload)); | |
| } | |
| TEST_F(RtpSenderVideoRawPacketizationTest, SendVideoWithSetCodecTypeStillRaw) { | |
| const uint8_t kPayloadTypeRaw = 111; | |
| const uint8_t kPayload[] = {11, 22, 33, 44, 55}; | |
| // Send a frame with codectype "generic" | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| ASSERT_TRUE(rtp_sender_video_->SendVideo( | |
| kPayloadTypeRaw, VideoCodecType::kVideoCodecGeneric, 1234, | |
| fake_clock_.CurrentTime(), kPayload, sizeof(kPayload), video_header, | |
| TimeDelta::PlusInfinity(), {})); | |
| // Should still be packetized as raw. | |
| EXPECT_THAT(transport_.last_sent_packet().payload(), | |
| ElementsAreArray(kPayload)); | |
| } | |
| class RtpSenderVideoWithFrameTransformerTest : public ::testing::Test { | |
| public: | |
| RtpSenderVideoWithFrameTransformerTest() | |
| : time_controller_(kStartTime), | |
| env_(CreateEnvironment(time_controller_.GetClock(), | |
| time_controller_.GetTaskQueueFactory())), | |
| retransmission_rate_limiter_(time_controller_.GetClock(), 1000), | |
| rtp_module_( | |
| env_, | |
| {.outgoing_transport = &transport_, | |
| .retransmission_rate_limiter = &retransmission_rate_limiter_, | |
| .local_media_ssrc = kSsrc, | |
| .rid = "myrid"}) { | |
| rtp_module_.SetSequenceNumber(kSeqNum); | |
| rtp_module_.SetStartTimestamp(0); | |
| } | |
| std::unique_ptr<RTPSenderVideo> CreateSenderWithFrameTransformer( | |
| scoped_refptr<FrameTransformerInterface> transformer) { | |
| RTPSenderVideo::Config config; | |
| config.clock = time_controller_.GetClock(); | |
| config.rtp_sender = rtp_module_.RtpSender(); | |
| config.field_trials = &env_.field_trials(); | |
| config.frame_transformer = transformer; | |
| config.task_queue_factory = time_controller_.GetTaskQueueFactory(); | |
| return std::make_unique<RTPSenderVideo>(config); | |
| } | |
| protected: | |
| GlobalSimulatedTimeController time_controller_; | |
| const Environment env_; | |
| LoopbackTransportTest transport_; | |
| RateLimiter retransmission_rate_limiter_; | |
| ModuleRtpRtcpImpl2 rtp_module_; | |
| }; | |
| std::unique_ptr<EncodedImage> CreateDefaultEncodedImage() { | |
| const uint8_t data[] = {1, 2, 3, 4}; | |
| auto encoded_image = std::make_unique<EncodedImage>(); | |
| encoded_image->SetEncodedData(EncodedImageBuffer::Create(data, sizeof(data))); | |
| return encoded_image; | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| CreateSenderRegistersFrameTransformer) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| EXPECT_CALL(*mock_frame_transformer, | |
| RegisterTransformedFrameSinkCallback(_, kSsrc)); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| DestroySenderUnregistersFrameTransformer) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| EXPECT_CALL(*mock_frame_transformer, | |
| UnregisterTransformedFrameSinkCallback(kSsrc)); | |
| rtp_sender_video = nullptr; | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| SendEncodedImageTransformsFrame) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| RTPVideoHeader video_header; | |
| EXPECT_CALL(*mock_frame_transformer, Transform); | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| } | |
| TEST_F(RtpSenderVideoTest, SendEncodedImageIncludesProvidedCsrcs) { | |
| std::vector<uint32_t> expected_csrcs = {1, 2, 3}; | |
| std::unique_ptr<EncodedImage> encoded_image = CreateDefaultEncodedImage(); | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| ASSERT_TRUE(rtp_sender_video_->SendEncodedImage( | |
| 0, kType, kTimestamp, *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime, expected_csrcs)); | |
| ASSERT_GT(transport_.packets_sent(), 0); | |
| std::vector<uint32_t> csrcs = transport_.last_sent_packet().Csrcs(); | |
| EXPECT_EQ(csrcs, expected_csrcs); | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| SendEncodedImageIncludesProvidedCsrcs) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| scoped_refptr<TransformedFrameCallback> callback; | |
| EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameSinkCallback) | |
| .WillOnce(SaveArg<0>(&callback)); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| ASSERT_TRUE(callback); | |
| ON_CALL(*mock_frame_transformer, Transform) | |
| .WillByDefault( | |
| [&callback](std::unique_ptr<TransformableFrameInterface> frame) { | |
| callback->OnTransformedFrame(std::move(frame)); | |
| }); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| std::vector<uint32_t> expected_csrcs = {1, 2, 3}; | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| auto encoder_queue = time_controller_.GetTaskQueueFactory()->CreateTaskQueue( | |
| "encoder_queue", TaskQueueFactory::Priority::NORMAL); | |
| encoder_queue->PostTask([&] { | |
| rtp_sender_video->SendEncodedImage( | |
| kPayloadType, kType, kTimestamp, *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime, expected_csrcs); | |
| }); | |
| time_controller_.AdvanceTime(TimeDelta::Zero()); | |
| ASSERT_GT(transport_.packets_sent(), 0); | |
| std::vector<uint32_t> csrcs = transport_.last_sent_packet().Csrcs(); | |
| EXPECT_EQ(csrcs, expected_csrcs); | |
| } | |
| #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, ValidPayloadTypes) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| RTPVideoHeader video_header; | |
| EXPECT_TRUE(rtp_sender_video->SendEncodedImage( | |
| 0, kType, kTimestamp, *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime)); | |
| EXPECT_TRUE(rtp_sender_video->SendEncodedImage( | |
| 127, kType, kTimestamp, *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime)); | |
| EXPECT_DEATH(rtp_sender_video->SendEncodedImage( | |
| -1, kType, kTimestamp, *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime), | |
| ""); | |
| EXPECT_DEATH(rtp_sender_video->SendEncodedImage( | |
| 128, kType, kTimestamp, *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime), | |
| ""); | |
| } | |
| #endif | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, OnTransformedFrameSendsVideo) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| scoped_refptr<TransformedFrameCallback> callback; | |
| EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameSinkCallback) | |
| .WillOnce(SaveArg<0>(&callback)); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| ASSERT_TRUE(callback); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| ON_CALL(*mock_frame_transformer, Transform) | |
| .WillByDefault( | |
| [&callback](std::unique_ptr<TransformableFrameInterface> frame) { | |
| callback->OnTransformedFrame(std::move(frame)); | |
| }); | |
| auto encoder_queue = time_controller_.GetTaskQueueFactory()->CreateTaskQueue( | |
| "encoder_queue", TaskQueueFactory::Priority::NORMAL); | |
| encoder_queue->PostTask([&] { | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| }); | |
| time_controller_.AdvanceTime(TimeDelta::Zero()); | |
| EXPECT_EQ(transport_.packets_sent(), 1); | |
| encoder_queue->PostTask([&] { | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| }); | |
| time_controller_.AdvanceTime(TimeDelta::Zero()); | |
| EXPECT_EQ(transport_.packets_sent(), 2); | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| TransformOverheadCorrectlyAccountedFor) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| scoped_refptr<TransformedFrameCallback> callback; | |
| EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameSinkCallback) | |
| .WillOnce(SaveArg<0>(&callback)); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| ASSERT_TRUE(callback); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| ON_CALL(*mock_frame_transformer, Transform) | |
| .WillByDefault( | |
| [&callback](std::unique_ptr<TransformableFrameInterface> frame) { | |
| const uint8_t data[] = {1, 2, 3, 4, 5, 6, 7, 8, | |
| 9, 10, 11, 12, 13, 14, 15, 16}; | |
| frame->SetData(data); | |
| callback->OnTransformedFrame(std::move(frame)); | |
| }); | |
| auto encoder_queue = time_controller_.GetTaskQueueFactory()->CreateTaskQueue( | |
| "encoder_queue", TaskQueueFactory::Priority::NORMAL); | |
| const int kFramesPerSecond = 25; | |
| for (int i = 0; i < kFramesPerSecond; ++i) { | |
| encoder_queue->PostTask([&] { | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| }); | |
| time_controller_.AdvanceTime(TimeDelta::Millis(1000 / kFramesPerSecond)); | |
| } | |
| EXPECT_EQ(transport_.packets_sent(), kFramesPerSecond); | |
| EXPECT_GT(rtp_sender_video->PostEncodeOverhead().bps(), 2200); | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| TransformableFrameMetadataHasCorrectValue) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| RTPVideoHeader video_header; | |
| video_header.width = 1280u; | |
| video_header.height = 720u; | |
| RTPVideoHeader::GenericDescriptorInfo& generic = | |
| video_header.generic.emplace(); | |
| generic.frame_id = 10; | |
| generic.temporal_index = 3; | |
| generic.spatial_index = 2; | |
| generic.decode_target_indications = {DecodeTargetIndication::kSwitch}; | |
| generic.dependencies = {5}; | |
| // Check that the transformable frame passed to the frame transformer has the | |
| // correct metadata. | |
| EXPECT_CALL(*mock_frame_transformer, Transform) | |
| .WillOnce( | |
| [](std::unique_ptr<TransformableFrameInterface> transformable_frame) { | |
| auto frame = | |
| absl::WrapUnique(static_cast<TransformableVideoFrameInterface*>( | |
| transformable_frame.release())); | |
| ASSERT_TRUE(frame); | |
| auto metadata = frame->Metadata(); | |
| EXPECT_EQ(frame->Rid(), "myrid"); | |
| EXPECT_EQ(metadata.GetWidth(), 1280u); | |
| EXPECT_EQ(metadata.GetHeight(), 720u); | |
| EXPECT_EQ(metadata.GetFrameId(), 10); | |
| EXPECT_EQ(metadata.GetTemporalIndex(), 3); | |
| EXPECT_EQ(metadata.GetSpatialIndex(), 2); | |
| EXPECT_THAT(metadata.GetFrameDependencies(), ElementsAre(5)); | |
| EXPECT_THAT(metadata.GetDecodeTargetIndications(), | |
| ElementsAre(DecodeTargetIndication::kSwitch)); | |
| }); | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| TransformableFrameHasCorrectCaptureIdentifier) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| encoded_image->SetPresentationTimestamp(Timestamp::Millis(1)); | |
| RTPVideoHeader video_header; | |
| EXPECT_CALL(*mock_frame_transformer, Transform) | |
| .WillOnce([&encoded_image](std::unique_ptr<TransformableFrameInterface> | |
| transformable_frame) { | |
| auto* frame = static_cast<TransformableVideoFrameInterface*>( | |
| transformable_frame.get()); | |
| ASSERT_TRUE(frame); | |
| EXPECT_EQ(frame->GetPresentationTimestamp(), | |
| encoded_image->PresentationTimestamp()); | |
| }); | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| } | |
| TEST_F(RtpSenderVideoWithFrameTransformerTest, | |
| OnTransformedFrameSendsVideoWhenCloned) { | |
| auto mock_frame_transformer = | |
| make_ref_counted<NiceMock<MockFrameTransformer>>(); | |
| scoped_refptr<TransformedFrameCallback> callback; | |
| EXPECT_CALL(*mock_frame_transformer, RegisterTransformedFrameSinkCallback) | |
| .WillOnce(SaveArg<0>(&callback)); | |
| std::unique_ptr<RTPSenderVideo> rtp_sender_video = | |
| CreateSenderWithFrameTransformer(mock_frame_transformer); | |
| ASSERT_TRUE(callback); | |
| auto encoded_image = CreateDefaultEncodedImage(); | |
| RTPVideoHeader video_header; | |
| video_header.frame_type = VideoFrameType::kVideoFrameKey; | |
| ON_CALL(*mock_frame_transformer, Transform) | |
| .WillByDefault( | |
| [&callback](std::unique_ptr<TransformableFrameInterface> frame) { | |
| auto clone = CloneVideoFrame( | |
| static_cast<TransformableVideoFrameInterface*>(frame.get())); | |
| EXPECT_TRUE(clone); | |
| callback->OnTransformedFrame(std::move(clone)); | |
| }); | |
| auto encoder_queue = time_controller_.GetTaskQueueFactory()->CreateTaskQueue( | |
| "encoder_queue", TaskQueueFactory::Priority::NORMAL); | |
| encoder_queue->PostTask([&] { | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| }); | |
| time_controller_.AdvanceTime(TimeDelta::Zero()); | |
| EXPECT_EQ(transport_.packets_sent(), 1); | |
| encoder_queue->PostTask([&] { | |
| rtp_sender_video->SendEncodedImage(kPayloadType, kType, kTimestamp, | |
| *encoded_image, video_header, | |
| kDefaultExpectedRetransmissionTime); | |
| }); | |
| time_controller_.AdvanceTime(TimeDelta::Zero()); | |
| EXPECT_EQ(transport_.packets_sent(), 2); | |
| } | |
| } // namespace | |
| } // namespace webrtc |