From 51bf200294622a45444b68ad1498a41f8a860df3 Mon Sep 17 00:00:00 2001 From: Danil Chapovalov Date: Fri, 11 Oct 2019 10:53:27 +0200 Subject: [PATCH] Reduce number of RTPVideoSender::SendVideo parameters use frame_type from the RTPVideoHeader instead of as an extra parameter merge payload data and payload size into single argument pass RTPVideoHeader by value (relying on copy elision) Bug: None Change-Id: Ie7970af3b198b83b723d84c7a8b047219c4b38c0 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/156400 Commit-Queue: Danil Chapovalov Reviewed-by: Niels Moller Reviewed-by: Ilya Nikolaevskiy Cr-Commit-Position: refs/heads/master@{#29445} --- call/rtp_payload_params.cc | 1 + call/rtp_video_sender.cc | 9 +- modules/rtp_rtcp/source/nack_rtx_unittest.cc | 16 +-- modules/rtp_rtcp/source/rtp_format.cc | 5 +- modules/rtp_rtcp/source/rtp_format.h | 1 - .../source/rtp_format_video_generic.cc | 10 +- .../source/rtp_format_video_generic.h | 6 +- .../rtp_format_video_generic_unittest.cc | 23 ++-- .../rtp_rtcp/source/rtp_rtcp_impl_unittest.cc | 7 +- .../rtp_rtcp/source/rtp_sender_unittest.cc | 102 +++++++------- modules/rtp_rtcp/source/rtp_sender_video.cc | 125 ++++++++++-------- modules/rtp_rtcp/source/rtp_sender_video.h | 13 +- .../source/rtp_sender_video_unittest.cc | 54 ++++---- video/rtp_video_stream_receiver_unittest.cc | 8 +- 14 files changed, 197 insertions(+), 183 deletions(-) diff --git a/call/rtp_payload_params.cc b/call/rtp_payload_params.cc index af7bfd2cac..cc9712c7f2 100644 --- a/call/rtp_payload_params.cc +++ b/call/rtp_payload_params.cc @@ -162,6 +162,7 @@ RTPVideoHeader RtpPayloadParams::GetRtpVideoHeader( PopulateRtpWithCodecSpecifics(*codec_specific_info, image.SpatialIndex(), &rtp_video_header); } + rtp_video_header.frame_type = image._frameType, rtp_video_header.rotation = image.rotation_; rtp_video_header.content_type = image.content_type_; rtp_video_header.playout_delay = image.playout_delay_; diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc index ca6132fcd5..73e356d3e8 100644 --- a/call/rtp_video_sender.cc +++ b/call/rtp_video_sender.cc @@ -489,8 +489,6 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage( stream_index = encoded_image.SpatialIndex().value_or(0); } RTC_DCHECK_LT(stream_index, rtp_streams_.size()); - RTPVideoHeader rtp_video_header = params_[stream_index].GetRtpVideoHeader( - encoded_image, codec_specific_info, shared_frame_id_); uint32_t rtp_timestamp = encoded_image.Timestamp() + @@ -515,9 +513,10 @@ EncodedImageCallback::Result RtpVideoSender::OnEncodedImage( } bool send_result = rtp_streams_[stream_index].sender_video->SendVideo( - encoded_image._frameType, rtp_config_.payload_type, codec_type_, - rtp_timestamp, encoded_image.capture_time_ms_, encoded_image.data(), - encoded_image.size(), fragmentation, &rtp_video_header, + rtp_config_.payload_type, codec_type_, rtp_timestamp, + encoded_image.capture_time_ms_, encoded_image, fragmentation, + params_[stream_index].GetRtpVideoHeader( + encoded_image, codec_specific_info, shared_frame_id_), expected_retransmission_time_ms); if (frame_count_observer_) { FrameCounts& counts = frame_counts_[stream_index]; diff --git a/modules/rtp_rtcp/source/nack_rtx_unittest.cc b/modules/rtp_rtcp/source/nack_rtx_unittest.cc index 62d5f98c34..a75fd6e101 100644 --- a/modules/rtp_rtcp/source/nack_rtx_unittest.cc +++ b/modules/rtp_rtcp/source/nack_rtx_unittest.cc @@ -121,7 +121,6 @@ class RtpRtcpRtxNackTest : public ::testing::Test { : rtp_rtcp_module_(nullptr), transport_(kTestRtxSsrc), rtx_stream_(&media_stream_, rtx_associated_payload_types_, kTestSsrc), - payload_data_length(sizeof(payload_data)), fake_clock(123456), retransmission_rate_limiter_(&fake_clock, kMaxRttMs) {} ~RtpRtcpRtxNackTest() override {} @@ -159,7 +158,7 @@ class RtpRtcpRtxNackTest : public ::testing::Test { media_receiver_ = transport_.stream_receiver_controller_.CreateReceiver( kTestSsrc, &media_stream_); - for (size_t n = 0; n < payload_data_length; n++) { + for (size_t n = 0; n < sizeof(payload_data); n++) { payload_data[n] = n % 10; } } @@ -209,10 +208,10 @@ class RtpRtcpRtxNackTest : public ::testing::Test { RTPVideoHeader video_header; EXPECT_TRUE(rtp_rtcp_module_->OnSendingRtpFrame(timestamp, timestamp / 90, kPayloadType, false)); + video_header.frame_type = VideoFrameType::kVideoFrameDelta; EXPECT_TRUE(rtp_sender_video_->SendVideo( - VideoFrameType::kVideoFrameDelta, kPayloadType, - VideoCodecType::kVideoCodecGeneric, timestamp, timestamp / 90, - payload_data, payload_data_length, nullptr, &video_header, 0)); + kPayloadType, VideoCodecType::kVideoCodecGeneric, timestamp, + timestamp / 90, payload_data, nullptr, video_header, 0)); // Min required delay until retransmit = 5 + RTT ms (RTT = 0). fake_clock.AdvanceTimeMilliseconds(5); int length = BuildNackList(nack_list); @@ -236,7 +235,6 @@ class RtpRtcpRtxNackTest : public ::testing::Test { VerifyingMediaStream media_stream_; RtxReceiveStream rtx_stream_; uint8_t payload_data[65000]; - size_t payload_data_length; SimulatedClock fake_clock; RateLimiter retransmission_rate_limiter_; std::unique_ptr media_receiver_; @@ -261,10 +259,10 @@ TEST_F(RtpRtcpRtxNackTest, LongNackList) { RTPVideoHeader video_header; EXPECT_TRUE(rtp_rtcp_module_->OnSendingRtpFrame(timestamp, timestamp / 90, kPayloadType, false)); + video_header.frame_type = VideoFrameType::kVideoFrameDelta; EXPECT_TRUE(rtp_sender_video_->SendVideo( - VideoFrameType::kVideoFrameDelta, kPayloadType, - VideoCodecType::kVideoCodecGeneric, timestamp, timestamp / 90, - payload_data, payload_data_length, nullptr, &video_header, 0)); + kPayloadType, VideoCodecType::kVideoCodecGeneric, timestamp, + timestamp / 90, payload_data, nullptr, video_header, 0)); // Prepare next frame. timestamp += 3000; fake_clock.AdvanceTimeMilliseconds(33); diff --git a/modules/rtp_rtcp/source/rtp_format.cc b/modules/rtp_rtcp/source/rtp_format.cc index df9cb023ad..47838cb385 100644 --- a/modules/rtp_rtcp/source/rtp_format.cc +++ b/modules/rtp_rtcp/source/rtp_format.cc @@ -30,7 +30,6 @@ std::unique_ptr RtpPacketizer::Create( PayloadSizeLimits limits, // Codec-specific details. const RTPVideoHeader& rtp_video_header, - VideoFrameType frame_type, const RTPFragmentationHeader* fragmentation) { if (!type) { // Use raw packetizer. @@ -56,8 +55,8 @@ std::unique_ptr RtpPacketizer::Create( return std::make_unique(payload, limits, vp9); } default: { - return std::make_unique( - payload, limits, rtp_video_header, frame_type); + return std::make_unique(payload, limits, + rtp_video_header); } } } diff --git a/modules/rtp_rtcp/source/rtp_format.h b/modules/rtp_rtcp/source/rtp_format.h index 2acf319bba..1c498119e5 100644 --- a/modules/rtp_rtcp/source/rtp_format.h +++ b/modules/rtp_rtcp/source/rtp_format.h @@ -42,7 +42,6 @@ class RtpPacketizer { PayloadSizeLimits limits, // Codec-specific details. const RTPVideoHeader& rtp_video_header, - VideoFrameType frame_type, const RTPFragmentationHeader* fragmentation); virtual ~RtpPacketizer() = default; diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic.cc b/modules/rtp_rtcp/source/rtp_format_video_generic.cc index 3c0fe03846..3c9b1622bc 100644 --- a/modules/rtp_rtcp/source/rtp_format_video_generic.cc +++ b/modules/rtp_rtcp/source/rtp_format_video_generic.cc @@ -26,10 +26,9 @@ static const size_t kExtendedHeaderLength = 2; RtpPacketizerGeneric::RtpPacketizerGeneric( rtc::ArrayView payload, PayloadSizeLimits limits, - const RTPVideoHeader& rtp_video_header, - VideoFrameType frame_type) + const RTPVideoHeader& rtp_video_header) : remaining_payload_(payload) { - BuildHeader(rtp_video_header, frame_type); + BuildHeader(rtp_video_header); limits.max_payload_len -= header_size_; payload_sizes_ = SplitAboutEqually(payload.size(), limits); @@ -82,11 +81,10 @@ bool RtpPacketizerGeneric::NextPacket(RtpPacketToSend* packet) { return true; } -void RtpPacketizerGeneric::BuildHeader(const RTPVideoHeader& rtp_video_header, - VideoFrameType frame_type) { +void RtpPacketizerGeneric::BuildHeader(const RTPVideoHeader& rtp_video_header) { header_size_ = kGenericHeaderLength; header_[0] = RtpFormatVideoGeneric::kFirstPacketBit; - if (frame_type == VideoFrameType::kVideoFrameKey) { + if (rtp_video_header.frame_type == VideoFrameType::kVideoFrameKey) { header_[0] |= RtpFormatVideoGeneric::kKeyFrameBit; } if (rtp_video_header.generic.has_value()) { diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic.h b/modules/rtp_rtcp/source/rtp_format_video_generic.h index 43d4bcfeee..e091c890ff 100644 --- a/modules/rtp_rtcp/source/rtp_format_video_generic.h +++ b/modules/rtp_rtcp/source/rtp_format_video_generic.h @@ -38,8 +38,7 @@ class RtpPacketizerGeneric : public RtpPacketizer { // Packets returned by |NextPacket| will contain the generic payload header. RtpPacketizerGeneric(rtc::ArrayView payload, PayloadSizeLimits limits, - const RTPVideoHeader& rtp_video_header, - VideoFrameType frametype); + const RTPVideoHeader& rtp_video_header); // Initialize with payload from encoder. // The payload_data must be exactly one encoded generic frame. // Packets returned by |NextPacket| will contain raw payload without the @@ -58,8 +57,7 @@ class RtpPacketizerGeneric : public RtpPacketizer { private: // Fills header_ and header_size_ members. - void BuildHeader(const RTPVideoHeader& rtp_video_header, - VideoFrameType frame_type); + void BuildHeader(const RTPVideoHeader& rtp_video_header); uint8_t header_[3]; size_t header_size_; diff --git a/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc b/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc index 67b7cba185..a1a2d47762 100644 --- a/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc @@ -48,8 +48,7 @@ TEST(RtpPacketizerVideoGeneric, RespectsMaxPayloadSize) { RtpPacketizer::PayloadSizeLimits limits; limits.max_payload_len = 6; - RtpPacketizerGeneric packetizer(kPayload, limits, RTPVideoHeader(), - VideoFrameType::kVideoFrameKey); + RtpPacketizerGeneric packetizer(kPayload, limits, RTPVideoHeader()); std::vector payload_sizes = NextPacketFillPayloadSizes(&packetizer); @@ -62,8 +61,7 @@ TEST(RtpPacketizerVideoGeneric, UsesMaxPayloadSize) { RtpPacketizer::PayloadSizeLimits limits; limits.max_payload_len = 6; - RtpPacketizerGeneric packetizer(kPayload, limits, RTPVideoHeader(), - VideoFrameType::kVideoFrameKey); + RtpPacketizerGeneric packetizer(kPayload, limits, RTPVideoHeader()); std::vector payload_sizes = NextPacketFillPayloadSizes(&packetizer); @@ -78,8 +76,8 @@ TEST(RtpPacketizerVideoGeneric, WritesExtendedHeaderWhenPictureIdIsSet) { RTPVideoHeader rtp_video_header; rtp_video_header.generic.emplace().frame_id = 37; - RtpPacketizerGeneric packetizer(kPayload, kNoSizeLimits, rtp_video_header, - VideoFrameType::kVideoFrameKey); + rtp_video_header.frame_type = VideoFrameType::kVideoFrameKey; + RtpPacketizerGeneric packetizer(kPayload, kNoSizeLimits, rtp_video_header); RtpPacketToSend packet(nullptr); ASSERT_TRUE(packetizer.NextPacket(&packet)); @@ -100,8 +98,7 @@ TEST(RtpPacketizerVideoGeneric, RespectsMaxPayloadSizeWithExtendedHeader) { limits.max_payload_len = 6; RTPVideoHeader rtp_video_header; rtp_video_header.generic.emplace().frame_id = 37; - RtpPacketizerGeneric packetizer(kPayload, limits, rtp_video_header, - VideoFrameType::kVideoFrameKey); + RtpPacketizerGeneric packetizer(kPayload, limits, rtp_video_header); std::vector payload_sizes = NextPacketFillPayloadSizes(&packetizer); @@ -116,8 +113,7 @@ TEST(RtpPacketizerVideoGeneric, UsesMaxPayloadSizeWithExtendedHeader) { limits.max_payload_len = 6; RTPVideoHeader rtp_video_header; rtp_video_header.generic.emplace().frame_id = 37; - RtpPacketizerGeneric packetizer(kPayload, limits, rtp_video_header, - VideoFrameType::kVideoFrameKey); + RtpPacketizerGeneric packetizer(kPayload, limits, rtp_video_header); std::vector payload_sizes = NextPacketFillPayloadSizes(&packetizer); // With kPayloadSize > max_payload_len^2, there should be packets that use @@ -131,8 +127,8 @@ TEST(RtpPacketizerVideoGeneric, FrameIdOver15bitsWrapsAround) { RTPVideoHeader rtp_video_header; rtp_video_header.generic.emplace().frame_id = 0x8137; - RtpPacketizerGeneric packetizer(kPayload, kNoSizeLimits, rtp_video_header, - VideoFrameType::kVideoFrameKey); + rtp_video_header.frame_type = VideoFrameType::kVideoFrameKey; + RtpPacketizerGeneric packetizer(kPayload, kNoSizeLimits, rtp_video_header); RtpPacketToSend packet(nullptr); ASSERT_TRUE(packetizer.NextPacket(&packet)); @@ -148,8 +144,7 @@ TEST(RtpPacketizerVideoGeneric, NoFrameIdDoesNotWriteExtendedHeader) { const int kPayloadSize = 13; const uint8_t kPayload[kPayloadSize] = {}; - RtpPacketizerGeneric packetizer(kPayload, kNoSizeLimits, RTPVideoHeader(), - VideoFrameType::kVideoFrameKey); + RtpPacketizerGeneric packetizer(kPayload, kNoSizeLimits, RTPVideoHeader()); RtpPacketToSend packet(nullptr); ASSERT_TRUE(packetizer.NextPacket(&packet)); diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc index 34944bc13e..0b681cf183 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc @@ -212,6 +212,7 @@ class RtpRtcpImplTest : public ::testing::Test { RTPVideoHeaderVP8 vp8_header = {}; vp8_header.temporalIdx = tid; RTPVideoHeader rtp_video_header; + rtp_video_header.frame_type = VideoFrameType::kVideoFrameKey; rtp_video_header.width = codec_.width; rtp_video_header.height = codec_.height; rtp_video_header.rotation = kVideoRotation_0; @@ -225,10 +226,8 @@ class RtpRtcpImplTest : public ::testing::Test { const uint8_t payload[100] = {0}; EXPECT_TRUE(module->impl_->OnSendingRtpFrame(0, 0, codec_.plType, true)); - EXPECT_TRUE(sender->SendVideo(VideoFrameType::kVideoFrameKey, codec_.plType, - VideoCodecType::kVideoCodecVP8, 0, 0, payload, - sizeof(payload), nullptr, &rtp_video_header, - 0)); + EXPECT_TRUE(sender->SendVideo(codec_.plType, VideoCodecType::kVideoCodecVP8, + 0, 0, payload, nullptr, rtp_video_header, 0)); } void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) { diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 90b92b3c3e..da7ba4f67b 100644 --- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -610,10 +610,10 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { .Times(1); int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); fake_clock_.AdvanceTimeMilliseconds(10); + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, kCodecType, - capture_time_ms * kCaptureTimeMsToRtpTimestamp, capture_time_ms, - kPayloadData, sizeof(kPayloadData), nullptr, &video_header, + kPayloadType, kCodecType, capture_time_ms * kCaptureTimeMsToRtpTimestamp, + capture_time_ms, kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); // Send another packet with 20 ms delay. The average, max and total should be @@ -622,10 +622,10 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { SendSideDelayUpdated(15, 20, 30, kSsrc)) .Times(1); fake_clock_.AdvanceTimeMilliseconds(10); + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, kCodecType, - capture_time_ms * kCaptureTimeMsToRtpTimestamp, capture_time_ms, - kPayloadData, sizeof(kPayloadData), nullptr, &video_header, + kPayloadType, kCodecType, capture_time_ms * kCaptureTimeMsToRtpTimestamp, + capture_time_ms, kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); // Send another packet at the same time, which replaces the last packet. @@ -635,10 +635,10 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { EXPECT_CALL(send_side_delay_observer_, SendSideDelayUpdated(5, 10, 30, kSsrc)) .Times(1); capture_time_ms = fake_clock_.TimeInMilliseconds(); + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, kCodecType, - capture_time_ms * kCaptureTimeMsToRtpTimestamp, capture_time_ms, - kPayloadData, sizeof(kPayloadData), nullptr, &video_header, + kPayloadType, kCodecType, capture_time_ms * kCaptureTimeMsToRtpTimestamp, + capture_time_ms, kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); // Send a packet 1 second later. The earlier packets should have timed @@ -649,10 +649,10 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) { fake_clock_.AdvanceTimeMilliseconds(1); EXPECT_CALL(send_side_delay_observer_, SendSideDelayUpdated(1, 1, 31, kSsrc)) .Times(1); + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, kCodecType, - capture_time_ms * kCaptureTimeMsToRtpTimestamp, capture_time_ms, - kPayloadData, sizeof(kPayloadData), nullptr, &video_header, + kPayloadType, kCodecType, capture_time_ms * kCaptureTimeMsToRtpTimestamp, + capture_time_ms, kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); } @@ -1093,10 +1093,10 @@ TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) { // Send keyframe RTPVideoHeader video_header; - ASSERT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, kCodecType, 1234, 4321, - payload, sizeof(payload), nullptr, &video_header, - kDefaultExpectedRetransmissionTimeMs)); + video_header.frame_type = VideoFrameType::kVideoFrameKey; + ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, kCodecType, 1234, 4321, + payload, nullptr, video_header, + kDefaultExpectedRetransmissionTimeMs)); auto sent_payload = transport_.last_sent_packet().payload(); uint8_t generic_header = sent_payload[0]; @@ -1109,10 +1109,10 @@ TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) { payload[1] = 42; payload[4] = 13; - ASSERT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameDelta, kPayloadType, kCodecType, 1234, 4321, - payload, sizeof(payload), nullptr, &video_header, - kDefaultExpectedRetransmissionTimeMs)); + video_header.frame_type = VideoFrameType::kVideoFrameDelta; + ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, kCodecType, 1234, 4321, + payload, nullptr, video_header, + kDefaultExpectedRetransmissionTimeMs)); sent_payload = transport_.last_sent_packet().payload(); generic_header = sent_payload[0]; @@ -1136,10 +1136,10 @@ TEST_P(RtpSenderTestWithoutPacer, SendRawVideo) { // Send a frame. RTPVideoHeader video_header; - ASSERT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, absl::nullopt, 1234, 4321, - payload, sizeof(payload), nullptr, &video_header, - kDefaultExpectedRetransmissionTimeMs)); + video_header.frame_type = VideoFrameType::kVideoFrameKey; + ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, absl::nullopt, 1234, + 4321, payload, nullptr, video_header, + kDefaultExpectedRetransmissionTimeMs)); auto sent_payload = transport_.last_sent_packet().payload(); EXPECT_THAT(sent_payload, ElementsAreArray(payload)); @@ -1212,10 +1212,10 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) { } }); + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kMediaPayloadType, kCodecType, - kTimestamp, fake_clock_.TimeInMilliseconds(), kPayloadData, - sizeof(kPayloadData), nullptr, &video_header, + kMediaPayloadType, kCodecType, kTimestamp, + fake_clock_.TimeInMilliseconds(), kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); ASSERT_TRUE(media_packet != nullptr); ASSERT_TRUE(fec_packet != nullptr); @@ -1308,10 +1308,10 @@ TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) { Pointee(Property(&RtpPacketToSend::Ssrc, kFlexFecSsrc))))) .Times(0); // Not called because packet should not be protected. + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kMediaPayloadType, kCodecType, - kTimestamp, kCaptureTimeMs, kPayloadData, sizeof(kPayloadData), nullptr, - &video_header, kDefaultExpectedRetransmissionTimeMs)); + kMediaPayloadType, kCodecType, kTimestamp, kCaptureTimeMs, kPayloadData, + nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); EXPECT_TRUE( rtp_sender_->TrySendPacket(rtp_packet.get(), PacedPacketInfo())); @@ -1350,10 +1350,11 @@ TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) { }); video_header.video_timing.flags = VideoSendTiming::kInvalid; - EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kMediaPayloadType, kCodecType, - kTimestamp + 1, kCaptureTimeMs + 1, kPayloadData, sizeof(kPayloadData), - nullptr, &video_header, kDefaultExpectedRetransmissionTimeMs)); + video_header.frame_type = VideoFrameType::kVideoFrameKey; + EXPECT_TRUE(rtp_sender_video.SendVideo(kMediaPayloadType, kCodecType, + kTimestamp + 1, kCaptureTimeMs + 1, + kPayloadData, nullptr, video_header, + kDefaultExpectedRetransmissionTimeMs)); ASSERT_TRUE(media_packet2 != nullptr); ASSERT_TRUE(fec_packet != nullptr); @@ -1418,10 +1419,11 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) { LogProxy(SameRtcEventTypeAs(RtcEvent::Type::RtpPacketOutgoing))) .Times(2); RTPVideoHeader video_header; + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kMediaPayloadType, kCodecType, kTimestamp, - fake_clock_.TimeInMilliseconds(), kPayloadData, sizeof(kPayloadData), - nullptr, &video_header, kDefaultExpectedRetransmissionTimeMs)); + kMediaPayloadType, kCodecType, kTimestamp, + fake_clock_.TimeInMilliseconds(), kPayloadData, nullptr, video_header, + kDefaultExpectedRetransmissionTimeMs)); ASSERT_EQ(2, transport_.packets_sent()); const RtpPacketReceived& media_packet = transport_.sent_packets_[0]; @@ -1693,10 +1695,10 @@ TEST_P(RtpSenderTest, FecOverheadRate) { for (size_t i = 0; i < kNumMediaPackets; ++i) { RTPVideoHeader video_header; + video_header.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kMediaPayloadType, kCodecType, - kTimestamp, fake_clock_.TimeInMilliseconds(), kPayloadData, - sizeof(kPayloadData), nullptr, &video_header, + kMediaPayloadType, kCodecType, kTimestamp, + fake_clock_.TimeInMilliseconds(), kPayloadData, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); fake_clock_.AdvanceTimeMilliseconds(kTimeBetweenPacketsMs); @@ -1777,9 +1779,9 @@ TEST_P(RtpSenderTest, BitrateCallbacks) { // Send a few frames. RTPVideoHeader video_header; for (uint32_t i = 0; i < kNumPackets; ++i) { + video_header.frame_type = VideoFrameType::kVideoFrameKey; ASSERT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, kCodecType, 1234, 4321, - payload, sizeof(payload), nullptr, &video_header, + kPayloadType, kCodecType, 1234, 4321, payload, nullptr, video_header, kDefaultExpectedRetransmissionTimeMs)); fake_clock_.AdvanceTimeMilliseconds(kPacketInterval); } @@ -1854,10 +1856,10 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { // Send a frame. RTPVideoHeader video_header; - ASSERT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameKey, kPayloadType, kCodecType, 1234, 4321, - payload, sizeof(payload), nullptr, &video_header, - kDefaultExpectedRetransmissionTimeMs)); + video_header.frame_type = VideoFrameType::kVideoFrameKey; + ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, kCodecType, 1234, 4321, + payload, nullptr, video_header, + kDefaultExpectedRetransmissionTimeMs)); StreamDataCounters expected; expected.transmitted.payload_bytes = 6; expected.transmitted.header_bytes = 12; @@ -1925,10 +1927,10 @@ TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacksUlpfec) { fec_params.fec_rate = 1; fec_params.max_fec_frames = 1; rtp_sender_video.SetFecParameters(fec_params, fec_params); - ASSERT_TRUE(rtp_sender_video.SendVideo( - VideoFrameType::kVideoFrameDelta, kPayloadType, kCodecType, 1234, 4321, - payload, sizeof(payload), nullptr, &video_header, - kDefaultExpectedRetransmissionTimeMs)); + video_header.frame_type = VideoFrameType::kVideoFrameDelta; + ASSERT_TRUE(rtp_sender_video.SendVideo(kPayloadType, kCodecType, 1234, 4321, + payload, nullptr, video_header, + kDefaultExpectedRetransmissionTimeMs)); expected.transmitted.payload_bytes = 28; expected.transmitted.header_bytes = 24; expected.transmitted.packets = 2; diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc index fc40a9723f..b6799c9dfa 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video.cc @@ -68,7 +68,6 @@ void BuildRedPayload(const RtpPacketToSend& media_packet, void AddRtpHeaderExtensions(const RTPVideoHeader& video_header, const absl::optional& playout_delay, - VideoFrameType frame_type, bool set_video_rotation, bool set_color_space, bool set_frame_marking, @@ -86,7 +85,8 @@ void AddRtpHeaderExtensions(const RTPVideoHeader& video_header, packet->SetExtension(video_header.rotation); // Report content type only for key frames. - if (last_packet && frame_type == VideoFrameType::kVideoFrameKey && + if (last_packet && + video_header.frame_type == VideoFrameType::kVideoFrameKey && video_header.content_type != VideoContentType::UNSPECIFIED) packet->SetExtension(video_header.content_type); @@ -130,7 +130,7 @@ void AddRtpHeaderExtensions(const RTPVideoHeader& video_header, generic_descriptor.SetTemporalLayer(video_header.generic->temporal_index); - if (frame_type == VideoFrameType::kVideoFrameKey) { + if (video_header.frame_type == VideoFrameType::kVideoFrameKey) { generic_descriptor.SetResolution(video_header.width, video_header.height); } @@ -144,14 +144,14 @@ void AddRtpHeaderExtensions(const RTPVideoHeader& video_header, } } -bool MinimizeDescriptor(const RTPVideoHeader& full, RTPVideoHeader* minimized) { - if (full.codec == VideoCodecType::kVideoCodecVP8) { - minimized->codec = VideoCodecType::kVideoCodecVP8; - const auto& vp8 = absl::get(full.video_type_header); +bool MinimizeDescriptor(RTPVideoHeader* video_header) { + if (auto* vp8 = + absl::get_if(&video_header->video_type_header)) { // Set minimum fields the RtpPacketizer is using to create vp8 packets. - auto& min_vp8 = minimized->video_type_header.emplace(); - min_vp8.InitRTPVideoHeaderVP8(); - min_vp8.nonReference = vp8.nonReference; + // nonReference is the only field that doesn't require extra space. + bool non_reference = vp8->nonReference; + vp8->InitRTPVideoHeaderVP8(); + vp8->nonReference = non_reference; return true; } // TODO(danilchap): Reduce vp9 codec specific descriptor too. @@ -488,9 +488,12 @@ bool RTPSenderVideo::SendVideo( } codec_type = it->second; } - return SendVideo(frame_type, payload_type, codec_type, rtp_timestamp, - capture_time_ms, payload_data, payload_size, fragmentation, - video_header, expected_retransmission_time_ms); + RTPVideoHeader rtp_video_header = *video_header; + rtp_video_header.frame_type = frame_type; + return SendVideo(payload_type, codec_type, rtp_timestamp, capture_time_ms, + rtc::MakeArrayView(payload_data, payload_size), + fragmentation, rtp_video_header, + expected_retransmission_time_ms); } bool RTPSenderVideo::SendVideo( @@ -504,16 +507,32 @@ bool RTPSenderVideo::SendVideo( const RTPFragmentationHeader* fragmentation, const RTPVideoHeader* video_header, absl::optional expected_retransmission_time_ms) { + RTPVideoHeader rtp_video_header = *video_header; + rtp_video_header.frame_type = frame_type; + return SendVideo(payload_type, codec_type, rtp_timestamp, capture_time_ms, + rtc::MakeArrayView(payload_data, payload_size), + fragmentation, rtp_video_header, + expected_retransmission_time_ms); +} + +bool RTPSenderVideo::SendVideo( + int payload_type, + absl::optional codec_type, + uint32_t rtp_timestamp, + int64_t capture_time_ms, + rtc::ArrayView payload, + const RTPFragmentationHeader* fragmentation, + RTPVideoHeader video_header, + absl::optional expected_retransmission_time_ms) { TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", capture_time_ms, "Send", "type", - FrameTypeToString(frame_type)); + FrameTypeToString(video_header.frame_type)); RTC_CHECK_RUNS_SERIALIZED(&send_checker_); - if (frame_type == VideoFrameType::kEmptyFrame) + if (video_header.frame_type == VideoFrameType::kEmptyFrame) return true; - if (payload_size == 0) + if (payload.empty()) return false; - RTC_CHECK(video_header); int32_t retransmission_settings = retransmission_settings_; if (codec_type == VideoCodecType::kVideoCodecH264) { @@ -522,11 +541,11 @@ bool RTPSenderVideo::SendVideo( } bool set_frame_marking = - video_header->codec == kVideoCodecH264 && - video_header->frame_marking.temporal_id != kNoTemporalIdx; + video_header.codec == kVideoCodecH264 && + video_header.frame_marking.temporal_id != kNoTemporalIdx; const absl::optional playout_delay = - playout_delay_oracle_->PlayoutDelayToSend(video_header->playout_delay); + playout_delay_oracle_->PlayoutDelayToSend(video_header.playout_delay); // According to // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/ @@ -540,24 +559,26 @@ bool RTPSenderVideo::SendVideo( // value sent. // Set rotation when key frame or when changed (to follow standard). // Or when different from 0 (to follow current receiver implementation). - bool set_video_rotation = frame_type == VideoFrameType::kVideoFrameKey || - video_header->rotation != last_rotation_ || - video_header->rotation != kVideoRotation_0; - last_rotation_ = video_header->rotation; + bool set_video_rotation = + video_header.frame_type == VideoFrameType::kVideoFrameKey || + video_header.rotation != last_rotation_ || + video_header.rotation != kVideoRotation_0; + last_rotation_ = video_header.rotation; // Send color space when changed or if the frame is a key frame. Keep // sending color space information until the first base layer frame to // guarantee that the information is retrieved by the receiver. bool set_color_space; - if (video_header->color_space != last_color_space_) { - last_color_space_ = video_header->color_space; + if (video_header.color_space != last_color_space_) { + last_color_space_ = video_header.color_space; set_color_space = true; - transmit_color_space_next_frame_ = !IsBaseLayer(*video_header); + transmit_color_space_next_frame_ = !IsBaseLayer(video_header); } else { - set_color_space = frame_type == VideoFrameType::kVideoFrameKey || - transmit_color_space_next_frame_; + set_color_space = + video_header.frame_type == VideoFrameType::kVideoFrameKey || + transmit_color_space_next_frame_; transmit_color_space_next_frame_ = - transmit_color_space_next_frame_ ? !IsBaseLayer(*video_header) : false; + transmit_color_space_next_frame_ ? !IsBaseLayer(video_header) : false; } size_t fec_packet_overhead; @@ -566,8 +587,9 @@ bool RTPSenderVideo::SendVideo( rtc::CritScope cs(&crit_); // FEC settings. const FecProtectionParams& fec_params = - frame_type == VideoFrameType::kVideoFrameKey ? key_fec_params_ - : delta_fec_params_; + video_header.frame_type == VideoFrameType::kVideoFrameKey + ? key_fec_params_ + : delta_fec_params_; if (flexfec_enabled()) flexfec_sender_->SetFecParameters(fec_params); if (ulpfec_enabled()) @@ -593,17 +615,17 @@ bool RTPSenderVideo::SendVideo( auto middle_packet = std::make_unique(*single_packet); auto last_packet = std::make_unique(*single_packet); // Simplest way to estimate how much extensions would occupy is to set them. - AddRtpHeaderExtensions(*video_header, playout_delay, frame_type, - set_video_rotation, set_color_space, set_frame_marking, + AddRtpHeaderExtensions(video_header, playout_delay, set_video_rotation, + set_color_space, set_frame_marking, /*first=*/true, /*last=*/true, single_packet.get()); - AddRtpHeaderExtensions(*video_header, playout_delay, frame_type, - set_video_rotation, set_color_space, set_frame_marking, + AddRtpHeaderExtensions(video_header, playout_delay, set_video_rotation, + set_color_space, set_frame_marking, /*first=*/true, /*last=*/false, first_packet.get()); - AddRtpHeaderExtensions(*video_header, playout_delay, frame_type, - set_video_rotation, set_color_space, set_frame_marking, + AddRtpHeaderExtensions(video_header, playout_delay, set_video_rotation, + set_color_space, set_frame_marking, /*first=*/false, /*last=*/false, middle_packet.get()); - AddRtpHeaderExtensions(*video_header, playout_delay, frame_type, - set_video_rotation, set_color_space, set_frame_marking, + AddRtpHeaderExtensions(video_header, playout_delay, set_video_rotation, + set_color_space, set_frame_marking, /*first=*/false, /*last=*/true, last_packet.get()); RTC_DCHECK_GT(packet_capacity, single_packet->headers_size()); @@ -625,9 +647,6 @@ bool RTPSenderVideo::SendVideo( limits.last_packet_reduction_len = last_packet->headers_size() - middle_packet->headers_size(); - RTPVideoHeader minimized_video_header; - const RTPVideoHeader* packetize_video_header = video_header; - rtc::ArrayView generic_descriptor_raw_00 = first_packet->GetRawExtension(); rtc::ArrayView generic_descriptor_raw_01 = @@ -639,13 +658,13 @@ bool RTPSenderVideo::SendVideo( return false; } + // Minimiazation of the vp8 descriptor may erase temporal_id, so save it. + const uint8_t temporal_id = GetTemporalId(video_header); rtc::ArrayView generic_descriptor_raw = !generic_descriptor_raw_01.empty() ? generic_descriptor_raw_01 : generic_descriptor_raw_00; if (!generic_descriptor_raw.empty()) { - if (MinimizeDescriptor(*video_header, &minimized_video_header)) { - packetize_video_header = &minimized_video_header; - } + MinimizeDescriptor(&video_header); } // TODO(benwright@webrtc.org) - Allocate enough to always encrypt inline. @@ -657,7 +676,7 @@ bool RTPSenderVideo::SendVideo( const size_t max_ciphertext_size = frame_encryptor_->GetMaxCiphertextByteSize(cricket::MEDIA_TYPE_VIDEO, - payload_size); + payload.size()); encrypted_video_payload.SetSize(max_ciphertext_size); size_t bytes_written = 0; @@ -670,14 +689,12 @@ bool RTPSenderVideo::SendVideo( if (frame_encryptor_->Encrypt( cricket::MEDIA_TYPE_VIDEO, first_packet->Ssrc(), additional_data, - rtc::MakeArrayView(payload_data, payload_size), - encrypted_video_payload, &bytes_written) != 0) { + payload, encrypted_video_payload, &bytes_written) != 0) { return false; } encrypted_video_payload.SetSize(bytes_written); - payload_data = encrypted_video_payload.data(); - payload_size = encrypted_video_payload.size(); + payload = encrypted_video_payload; } else if (require_frame_encryption_) { RTC_LOG(LS_WARNING) << "No FrameEncryptor is attached to this video sending stream but " @@ -685,10 +702,8 @@ bool RTPSenderVideo::SendVideo( } std::unique_ptr packetizer = RtpPacketizer::Create( - codec_type, rtc::MakeArrayView(payload_data, payload_size), limits, - *packetize_video_header, frame_type, fragmentation); + codec_type, payload, limits, video_header, fragmentation); - const uint8_t temporal_id = GetTemporalId(*video_header); // TODO(bugs.webrtc.org/10714): retransmission_settings_ should generally be // replaced by expected_retransmission_time_ms.has_value(). For now, though, // only VP8 with an injected frame buffer controller actually controls it. @@ -706,7 +721,7 @@ bool RTPSenderVideo::SendVideo( unpacketized_payload_size += fragmentation->fragmentationLength[i]; } } else { - unpacketized_payload_size = payload_size; + unpacketized_payload_size = payload.size(); } if (num_packets == 0) diff --git a/modules/rtp_rtcp/source/rtp_sender_video.h b/modules/rtp_rtcp/source/rtp_sender_video.h index d3323334b8..8906e31cce 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.h +++ b/modules/rtp_rtcp/source/rtp_sender_video.h @@ -94,10 +94,20 @@ class RTPSenderVideo { // expected_retransmission_time_ms.has_value() -> retransmission allowed. // Calls to this method is assumed to be externally serialized. + bool SendVideo(int payload_type, + absl::optional codec_type, + uint32_t rtp_timestamp, + int64_t capture_time_ms, + rtc::ArrayView payload, + const RTPFragmentationHeader* fragmentation, + RTPVideoHeader video_header, + absl::optional expected_retransmission_time_ms); + + RTC_DEPRECATED bool SendVideo(VideoFrameType frame_type, int8_t payload_type, absl::optional codec_type, - uint32_t capture_timestamp, + uint32_t rtp_timestamp, int64_t capture_time_ms, const uint8_t* payload_data, size_t payload_size, @@ -106,6 +116,7 @@ class RTPSenderVideo { absl::optional expected_retransmission_time_ms); // TODO(bugs.webrtc.org/10809): Remove when downstream usage is gone. + RTC_DEPRECATED bool SendVideo(VideoFrameType frame_type, int8_t payload_type, uint32_t capture_timestamp, diff --git a/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc index 856d2395db..17aafeddbb 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video_unittest.cc @@ -178,9 +178,9 @@ TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) { RTPVideoHeader hdr; hdr.rotation = kVideoRotation_0; - rtp_sender_video_.SendVideo(VideoFrameType::kVideoFrameKey, kPayload, kType, - kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, - &hdr, kDefaultExpectedRetransmissionTimeMs); + hdr.frame_type = VideoFrameType::kVideoFrameKey; + rtp_sender_video_.SendVideo(kPayload, kType, kTimestamp, 0, kFrame, nullptr, + hdr, kDefaultExpectedRetransmissionTimeMs); VideoRotation rotation; EXPECT_TRUE( @@ -204,9 +204,9 @@ TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) { hdr.video_timing.encode_finish_delta_ms = kEncodeFinishDeltaMs; fake_clock_.AdvanceTimeMilliseconds(kPacketizationTimeMs); - rtp_sender_video_.SendVideo(VideoFrameType::kVideoFrameKey, kPayload, kType, - kTimestamp, kCaptureTimestamp, kFrame, - sizeof(kFrame), nullptr, &hdr, + hdr.frame_type = VideoFrameType::kVideoFrameKey; + rtp_sender_video_.SendVideo(kPayload, kType, kTimestamp, kCaptureTimestamp, + kFrame, nullptr, hdr, kDefaultExpectedRetransmissionTimeMs); VideoSendTiming timing; EXPECT_TRUE(transport_.last_sent_packet().GetExtension( @@ -223,14 +223,15 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) { RTPVideoHeader hdr; hdr.rotation = kVideoRotation_90; + hdr.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video_.SendVideo( - VideoFrameType::kVideoFrameKey, kPayload, kType, kTimestamp, 0, kFrame, - sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); + kPayload, kType, kTimestamp, 0, kFrame, nullptr, hdr, + kDefaultExpectedRetransmissionTimeMs)); hdr.rotation = kVideoRotation_0; + hdr.frame_type = VideoFrameType::kVideoFrameDelta; EXPECT_TRUE(rtp_sender_video_.SendVideo( - VideoFrameType::kVideoFrameDelta, kPayload, kType, kTimestamp + 1, 0, - kFrame, sizeof(kFrame), nullptr, &hdr, + kPayload, kType, kTimestamp + 1, 0, kFrame, nullptr, hdr, kDefaultExpectedRetransmissionTimeMs)); VideoRotation rotation; @@ -246,13 +247,14 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) { RTPVideoHeader hdr; hdr.rotation = kVideoRotation_90; + hdr.frame_type = VideoFrameType::kVideoFrameKey; EXPECT_TRUE(rtp_sender_video_.SendVideo( - VideoFrameType::kVideoFrameKey, kPayload, kType, kTimestamp, 0, kFrame, - sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs)); + kPayload, kType, kTimestamp, 0, kFrame, nullptr, hdr, + kDefaultExpectedRetransmissionTimeMs)); + hdr.frame_type = VideoFrameType::kVideoFrameDelta; EXPECT_TRUE(rtp_sender_video_.SendVideo( - VideoFrameType::kVideoFrameDelta, kPayload, kType, kTimestamp + 1, 0, - kFrame, sizeof(kFrame), nullptr, &hdr, + kPayload, kType, kTimestamp + 1, 0, kFrame, nullptr, hdr, kDefaultExpectedRetransmissionTimeMs)); VideoRotation rotation; @@ -278,18 +280,18 @@ TEST_P(RtpSenderVideoTest, CheckH264FrameMarking) { hdr.frame_marking.temporal_id = kNoTemporalIdx; hdr.frame_marking.tl0_pic_idx = 99; hdr.frame_marking.base_layer_sync = true; - rtp_sender_video_.SendVideo(VideoFrameType::kVideoFrameDelta, kPayload, kType, - kTimestamp, 0, kFrame, sizeof(kFrame), &frag, - &hdr, kDefaultExpectedRetransmissionTimeMs); + hdr.frame_type = VideoFrameType::kVideoFrameDelta; + rtp_sender_video_.SendVideo(kPayload, kType, kTimestamp, 0, kFrame, &frag, + hdr, kDefaultExpectedRetransmissionTimeMs); FrameMarking fm; EXPECT_FALSE( transport_.last_sent_packet().GetExtension(&fm)); hdr.frame_marking.temporal_id = 0; - rtp_sender_video_.SendVideo(VideoFrameType::kVideoFrameDelta, kPayload, kType, - kTimestamp + 1, 0, kFrame, sizeof(kFrame), &frag, - &hdr, kDefaultExpectedRetransmissionTimeMs); + hdr.frame_type = VideoFrameType::kVideoFrameDelta; + rtp_sender_video_.SendVideo(kPayload, kType, kTimestamp + 1, 0, kFrame, &frag, + hdr, kDefaultExpectedRetransmissionTimeMs); EXPECT_TRUE( transport_.last_sent_packet().GetExtension(&fm)); @@ -529,9 +531,9 @@ void RtpSenderVideoTest::PopulateGenericFrameDescriptor(int version) { generic.higher_spatial_layers.push_back(4); generic.dependencies.push_back(kFrameId - 1); generic.dependencies.push_back(kFrameId - 500); - rtp_sender_video_.SendVideo(VideoFrameType::kVideoFrameDelta, kPayload, kType, - kTimestamp, 0, kFrame, sizeof(kFrame), nullptr, - &hdr, kDefaultExpectedRetransmissionTimeMs); + hdr.frame_type = VideoFrameType::kVideoFrameDelta; + rtp_sender_video_.SendVideo(kPayload, kType, kTimestamp, 0, kFrame, nullptr, + hdr, kDefaultExpectedRetransmissionTimeMs); RtpGenericFrameDescriptor descriptor_wire; EXPECT_EQ(1, transport_.packets_sent()); @@ -583,9 +585,9 @@ void RtpSenderVideoTest:: vp8.keyIdx = 2; RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace(); generic.frame_id = kFrameId; - rtp_sender_video_.SendVideo(VideoFrameType::kVideoFrameDelta, kPayload, - VideoCodecType::kVideoCodecVP8, kTimestamp, 0, - kFrame, sizeof(kFrame), nullptr, &hdr, + hdr.frame_type = VideoFrameType::kVideoFrameDelta; + rtp_sender_video_.SendVideo(kPayload, VideoCodecType::kVideoCodecVP8, + kTimestamp, 0, kFrame, nullptr, hdr, kDefaultExpectedRetransmissionTimeMs); ASSERT_EQ(transport_.packets_sent(), 1); diff --git a/video/rtp_video_stream_receiver_unittest.cc b/video/rtp_video_stream_receiver_unittest.cc index 885641cee0..19a398e835 100644 --- a/video/rtp_video_stream_receiver_unittest.cc +++ b/video/rtp_video_stream_receiver_unittest.cc @@ -17,6 +17,7 @@ #include "common_video/h264/h264_common.h" #include "media/base/media_constants.h" #include "modules/rtp_rtcp/source/rtp_format.h" +#include "modules/rtp_rtcp/source/rtp_format_vp9.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" @@ -233,15 +234,12 @@ TEST_F(RtpVideoStreamReceiverTest, CacheColorSpaceFromLastPacketOfKeyframe) { // Reduce max payload length to make sure the key frame generates two // packets. pay_load_size_limits.max_payload_len = 8; - RTPVideoHeader rtp_video_header; RTPVideoHeaderVP9 rtp_video_header_vp9; rtp_video_header_vp9.InitRTPVideoHeaderVP9(); rtp_video_header_vp9.inter_pic_predicted = (video_frame_type == VideoFrameType::kVideoFrameDelta); - rtp_video_header.video_type_header = rtp_video_header_vp9; - rtp_packetizer_ = RtpPacketizer::Create( - kVideoCodecVP9, rtc::MakeArrayView(payload.data(), payload.size()), - pay_load_size_limits, rtp_video_header, video_frame_type, nullptr); + rtp_packetizer_ = std::make_unique( + payload, pay_load_size_limits, rtp_video_header_vp9); } size_t NumPackets() { return rtp_packetizer_->NumPackets(); }