admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reduce number of RTPVideoSender::SendVideo parameters

Browse Source 
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 <danilchap@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29445}
This commit is contained in:
Danil Chapovalov 2019-10-11 10:53:27 +02:00 committed by Commit Bot
parent 4b64411406
commit 51bf200294
14 changed files with 197 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
call/rtp_payload_params.cc
View File

@ -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_;

9
call/rtp_video_sender.cc
View File

@ -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];

16
modules/rtp_rtcp/source/nack_rtx_unittest.cc
View File

@ -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<RtpStreamReceiverInterface> 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);

5
modules/rtp_rtcp/source/rtp_format.cc
View File

@ -30,7 +30,6 @@ std::unique_ptr<RtpPacketizer> 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> RtpPacketizer::Create(
return std::make_unique<RtpPacketizerVp9>(payload, limits, vp9);
}
default: {
return std::make_unique<RtpPacketizerGeneric>(
payload, limits, rtp_video_header, frame_type);
return std::make_unique<RtpPacketizerGeneric>(payload, limits,
rtp_video_header);
}
}
}

1
modules/rtp_rtcp/source/rtp_format.h
View File

@ -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;

10
modules/rtp_rtcp/source/rtp_format_video_generic.cc
View File

@ -26,10 +26,9 @@ static const size_t kExtendedHeaderLength = 2;
RtpPacketizerGeneric::RtpPacketizerGeneric(
rtc::ArrayView<const uint8_t> 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()) {

6
modules/rtp_rtcp/source/rtp_format_video_generic.h
View File

@ -38,8 +38,7 @@ class RtpPacketizerGeneric : public RtpPacketizer {
// Packets returned by |NextPacket| will contain the generic payload header.
RtpPacketizerGeneric(rtc::ArrayView<const uint8_t> 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_;

23
modules/rtp_rtcp/source/rtp_format_video_generic_unittest.cc
View File

@ -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<int> 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<int> 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<int> 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<int> 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));

7
modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -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) {

102
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -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;

125
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -68,7 +68,6 @@ void BuildRedPayload(const RtpPacketToSend& media_packet,
void AddRtpHeaderExtensions(const RTPVideoHeader& video_header,
const absl::optional<PlayoutDelay>& 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<VideoOrientation>(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<VideoContentTypeExtension>(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<RTPVideoHeaderVP8>(full.video_type_header);
bool MinimizeDescriptor(RTPVideoHeader* video_header) {
if (auto* vp8 =
absl::get_if<RTPVideoHeaderVP8>(&video_header->video_type_header)) {
// Set minimum fields the RtpPacketizer is using to create vp8 packets.
auto& min_vp8 = minimized->video_type_header.emplace<RTPVideoHeaderVP8>();
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<int64_t> 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<VideoCodecType> codec_type,
uint32_t rtp_timestamp,
int64_t capture_time_ms,
rtc::ArrayView<const uint8_t> payload,
const RTPFragmentationHeader* fragmentation,
RTPVideoHeader video_header,
absl::optional<int64_t> 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<PlayoutDelay> 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<RtpPacketToSend>(*single_packet);
auto last_packet = std::make_unique<RtpPacketToSend>(*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<const uint8_t> generic_descriptor_raw_00 =
first_packet->GetRawExtension<RtpGenericFrameDescriptorExtension00>();
rtc::ArrayView<const uint8_t> 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<const uint8_t> 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<RtpPacketizer> 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)

13
modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -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<VideoCodecType> codec_type,
uint32_t rtp_timestamp,
int64_t capture_time_ms,
rtc::ArrayView<const uint8_t> payload,
const RTPFragmentationHeader* fragmentation,
RTPVideoHeader video_header,
absl::optional<int64_t> expected_retransmission_time_ms);
RTC_DEPRECATED
bool SendVideo(VideoFrameType frame_type,
int8_t payload_type,
absl::optional<VideoCodecType> 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<int64_t> 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,

54
modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
View File

@ -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<VideoTimingExtension>(
@ -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<FrameMarkingExtension>(&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<FrameMarkingExtension>(&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);

8
video/rtp_video_stream_receiver_unittest.cc
View File

@ -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<RtpPacketizerVp9>(
payload, pay_load_size_limits, rtp_video_header_vp9);
}
size_t NumPackets() { return rtp_packetizer_->NumPackets(); }