Index: webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc |
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc |
index 894415da8a7960d70bad206f115182e67e35f235..03082a420d2cd9d1a09c2aa9c22fac65c462a485 100644 |
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc |
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc |
@@ -11,16 +11,22 @@ |
#include <memory> |
#include <vector> |
+#include "webrtc/base/array_view.h" |
#include "webrtc/common_video/h264/h264_common.h" |
#include "webrtc/modules/include/module_common_types.h" |
#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" |
#include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
#include "webrtc/modules/rtp_rtcp/source/rtp_format.h" |
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" |
#include "webrtc/test/gmock.h" |
#include "webrtc/test/gtest.h" |
namespace webrtc { |
namespace { |
+ |
+using ::testing::ElementsAreArray; |
+ |
+constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr; |
const size_t kMaxPayloadSize = 1200; |
const size_t kLengthFieldLength = 2; |
@@ -46,10 +52,9 @@ enum FuDefs { kSBit = 0x80, kEBit = 0x40, kRBit = 0x20 }; |
void VerifyFua(size_t fua_index, |
const uint8_t* expected_payload, |
int offset, |
- const uint8_t* packet, |
- size_t length, |
+ rtc::ArrayView<const uint8_t> packet, |
const std::vector<size_t>& expected_sizes) { |
- ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, length) |
+ ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, packet.size()) |
<< "FUA index: " << fua_index; |
const uint8_t kFuIndicator = 0x1C; // F=0, NRI=0, Type=28. |
EXPECT_EQ(kFuIndicator, packet[0]) << "FUA index: " << fua_index; |
@@ -65,9 +70,8 @@ void VerifyFua(size_t fua_index, |
std::vector<uint8_t> expected_packet_payload( |
&expected_payload[offset], |
&expected_payload[offset + expected_sizes[fua_index]]); |
- EXPECT_THAT( |
- expected_packet_payload, |
- ::testing::ElementsAreArray(&packet[2], expected_sizes[fua_index])) |
+ EXPECT_THAT(expected_packet_payload, |
+ ElementsAreArray(&packet[2], expected_sizes[fua_index])) |
<< "FUA index: " << fua_index; |
} |
@@ -88,18 +92,18 @@ void TestFua(size_t frame_size, |
kRtpVideoH264, max_payload_size, NULL, kEmptyFrame)); |
packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation); |
- std::unique_ptr<uint8_t[]> packet(new uint8_t[max_payload_size]); |
- size_t length = 0; |
+ RtpPacketToSend packet(kNoExtensions); |
+ ASSERT_LE(max_payload_size, packet.FreeCapacity()); |
bool last = false; |
size_t offset = kNalHeaderSize; |
for (size_t i = 0; i < expected_sizes.size(); ++i) { |
- ASSERT_TRUE(packetizer->NextPacket(packet.get(), &length, &last)); |
- VerifyFua(i, frame.get(), offset, packet.get(), length, expected_sizes); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
+ VerifyFua(i, frame.get(), offset, packet.payload(), expected_sizes); |
EXPECT_EQ(i == expected_sizes.size() - 1, last) << "FUA index: " << i; |
offset += expected_sizes[i]; |
} |
- EXPECT_FALSE(packetizer->NextPacket(packet.get(), &length, &last)); |
+ EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
} |
size_t GetExpectedNaluOffset(const RTPFragmentationHeader& fragmentation, |
@@ -117,10 +121,8 @@ size_t GetExpectedNaluOffset(const RTPFragmentationHeader& fragmentation, |
void VerifyStapAPayload(const RTPFragmentationHeader& fragmentation, |
size_t first_stapa_index, |
size_t nalu_index, |
- const uint8_t* frame, |
- size_t frame_length, |
- const uint8_t* packet, |
- size_t packet_length) { |
+ rtc::ArrayView<const uint8_t> frame, |
+ rtc::ArrayView<const uint8_t> packet) { |
size_t expected_payload_offset = |
GetExpectedNaluOffset(fragmentation, first_stapa_index, nalu_index) + |
kLengthFieldLength; |
@@ -128,27 +130,22 @@ void VerifyStapAPayload(const RTPFragmentationHeader& fragmentation, |
const uint8_t* expected_payload = &frame[offset]; |
size_t expected_payload_length = |
fragmentation.fragmentationLength[nalu_index]; |
- ASSERT_LE(offset + expected_payload_length, frame_length); |
- ASSERT_LE(expected_payload_offset + expected_payload_length, packet_length); |
+ ASSERT_LE(offset + expected_payload_length, frame.size()); |
+ ASSERT_LE(expected_payload_offset + expected_payload_length, packet.size()); |
std::vector<uint8_t> expected_payload_vector( |
expected_payload, &expected_payload[expected_payload_length]); |
EXPECT_THAT(expected_payload_vector, |
- ::testing::ElementsAreArray(&packet[expected_payload_offset], |
- expected_payload_length)); |
+ ElementsAreArray(&packet[expected_payload_offset], |
+ expected_payload_length)); |
} |
void VerifySingleNaluPayload(const RTPFragmentationHeader& fragmentation, |
size_t nalu_index, |
- const uint8_t* frame, |
- size_t frame_length, |
- const uint8_t* packet, |
- size_t packet_length) { |
- std::vector<uint8_t> expected_payload_vector( |
- &frame[fragmentation.fragmentationOffset[nalu_index]], |
- &frame[fragmentation.fragmentationOffset[nalu_index] + |
- fragmentation.fragmentationLength[nalu_index]]); |
- EXPECT_THAT(expected_payload_vector, |
- ::testing::ElementsAreArray(packet, packet_length)); |
+ rtc::ArrayView<const uint8_t> frame, |
+ rtc::ArrayView<const uint8_t> packet) { |
+ auto fragment = frame.subview(fragmentation.fragmentationOffset[nalu_index], |
+ fragmentation.fragmentationLength[nalu_index]); |
+ EXPECT_THAT(packet, ElementsAreArray(fragment.begin(), fragment.end())); |
} |
} // namespace |
@@ -161,15 +158,14 @@ TEST(RtpPacketizerH264Test, TestSingleNalu) { |
std::unique_ptr<RtpPacketizer> packetizer( |
RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); |
packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation); |
- uint8_t packet[kMaxPayloadSize] = {0}; |
- size_t length = 0; |
+ RtpPacketToSend packet(kNoExtensions); |
+ ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
bool last = false; |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
- EXPECT_EQ(2u, length); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
+ EXPECT_EQ(2u, packet.payload_size()); |
EXPECT_TRUE(last); |
- VerifySingleNaluPayload( |
- fragmentation, 0, frame, sizeof(frame), packet, length); |
- EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last)); |
+ VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload()); |
+ EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
} |
TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) { |
@@ -191,19 +187,18 @@ TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) { |
RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); |
packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
- uint8_t packet[kMaxPayloadSize] = {0}; |
- size_t length = 0; |
+ RtpPacketToSend packet(kNoExtensions); |
bool last = false; |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
- ASSERT_EQ(fragmentation.fragmentationOffset[1], length); |
- VerifySingleNaluPayload(fragmentation, 0, frame, kFrameSize, packet, length); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
+ ASSERT_EQ(fragmentation.fragmentationOffset[1], packet.payload_size()); |
+ VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload()); |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
- ASSERT_EQ(fragmentation.fragmentationLength[1], length); |
- VerifySingleNaluPayload(fragmentation, 1, frame, kFrameSize, packet, length); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
+ ASSERT_EQ(fragmentation.fragmentationLength[1], packet.payload_size()); |
+ VerifySingleNaluPayload(fragmentation, 1, frame, packet.payload()); |
EXPECT_TRUE(last); |
- EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last)); |
+ EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
} |
TEST(RtpPacketizerH264Test, TestStapA) { |
@@ -228,18 +223,18 @@ TEST(RtpPacketizerH264Test, TestStapA) { |
RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); |
packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
- uint8_t packet[kMaxPayloadSize] = {0}; |
- size_t length = 0; |
+ RtpPacketToSend packet(kNoExtensions); |
+ ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
bool last = false; |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
size_t expected_packet_size = |
kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize; |
- ASSERT_EQ(expected_packet_size, length); |
+ ASSERT_EQ(expected_packet_size, packet.payload_size()); |
EXPECT_TRUE(last); |
for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) |
- VerifyStapAPayload(fragmentation, 0, i, frame, kFrameSize, packet, length); |
+ VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload()); |
- EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last)); |
+ EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
} |
TEST(RtpPacketizerH264Test, TestTooSmallForStapAHeaders) { |
@@ -263,27 +258,27 @@ TEST(RtpPacketizerH264Test, TestTooSmallForStapAHeaders) { |
RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); |
packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
- uint8_t packet[kMaxPayloadSize] = {0}; |
- size_t length = 0; |
+ RtpPacketToSend packet(kNoExtensions); |
+ ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
bool last = false; |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
size_t expected_packet_size = kNalHeaderSize; |
for (size_t i = 0; i < 2; ++i) { |
expected_packet_size += |
kLengthFieldLength + fragmentation.fragmentationLength[i]; |
} |
- ASSERT_EQ(expected_packet_size, length); |
+ ASSERT_EQ(expected_packet_size, packet.payload_size()); |
EXPECT_FALSE(last); |
for (size_t i = 0; i < 2; ++i) |
- VerifyStapAPayload(fragmentation, 0, i, frame, kFrameSize, packet, length); |
+ VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload()); |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
expected_packet_size = fragmentation.fragmentationLength[2]; |
- ASSERT_EQ(expected_packet_size, length); |
+ ASSERT_EQ(expected_packet_size, packet.payload_size()); |
EXPECT_TRUE(last); |
- VerifySingleNaluPayload(fragmentation, 2, frame, kFrameSize, packet, length); |
+ VerifySingleNaluPayload(fragmentation, 2, frame, packet.payload()); |
- EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last)); |
+ EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
} |
TEST(RtpPacketizerH264Test, TestMixedStapA_FUA) { |
@@ -315,26 +310,26 @@ TEST(RtpPacketizerH264Test, TestMixedStapA_FUA) { |
std::vector<size_t> fua_sizes; |
fua_sizes.push_back(1100); |
fua_sizes.push_back(1099); |
- uint8_t packet[kMaxPayloadSize] = {0}; |
- size_t length = 0; |
+ RtpPacketToSend packet(kNoExtensions); |
+ ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
bool last = false; |
int fua_offset = kNalHeaderSize; |
for (size_t i = 0; i < 2; ++i) { |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
- VerifyFua(i, frame, fua_offset, packet, length, fua_sizes); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
+ VerifyFua(i, frame, fua_offset, packet.payload(), fua_sizes); |
EXPECT_FALSE(last); |
fua_offset += fua_sizes[i]; |
} |
// Then expecting one STAP-A packet with two nal units. |
- ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last)); |
+ ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
size_t expected_packet_size = |
kNalHeaderSize + 2 * kLengthFieldLength + 2 * kStapANaluSize; |
- ASSERT_EQ(expected_packet_size, length); |
+ ASSERT_EQ(expected_packet_size, packet.payload_size()); |
EXPECT_TRUE(last); |
for (size_t i = 1; i < fragmentation.fragmentationVectorSize; ++i) |
- VerifyStapAPayload(fragmentation, 1, i, frame, kFrameSize, packet, length); |
+ VerifyStapAPayload(fragmentation, 1, i, frame, packet.payload()); |
- EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last)); |
+ EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
} |
TEST(RtpPacketizerH264Test, TestFUAOddSize) { |
@@ -429,24 +424,20 @@ TEST_F(RtpPacketizerH264TestSpsRewriting, FuASps) { |
&fragmentation_header_); |
bool last_packet = true; |
- uint8_t buffer[sizeof(kOriginalSps) + kHeaderOverhead] = {}; |
- size_t num_bytes = 0; |
+ RtpPacketToSend packet(kNoExtensions); |
+ ASSERT_LE(sizeof(kOriginalSps) + kHeaderOverhead, packet.FreeCapacity()); |
- EXPECT_TRUE(packetizer_->NextPacket(buffer, &num_bytes, &last_packet)); |
+ EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet)); |
size_t offset = H264::kNaluTypeSize; |
- size_t length = num_bytes - kFuAHeaderSize; |
- std::vector<uint8_t> expected_payload(&kRewrittenSps[offset], |
- &kRewrittenSps[offset + length]); |
- EXPECT_THAT(expected_payload, |
- ::testing::ElementsAreArray(&buffer[kFuAHeaderSize], length)); |
+ size_t length = packet.payload_size() - kFuAHeaderSize; |
+ EXPECT_THAT(packet.payload().subview(kFuAHeaderSize), |
+ ElementsAreArray(&kRewrittenSps[offset], length)); |
offset += length; |
- EXPECT_TRUE(packetizer_->NextPacket(buffer, &num_bytes, &last_packet)); |
- length = num_bytes - kFuAHeaderSize; |
- expected_payload = std::vector<uint8_t>(&kRewrittenSps[offset], |
- &kRewrittenSps[offset + length]); |
- EXPECT_THAT(expected_payload, |
- ::testing::ElementsAreArray(&buffer[kFuAHeaderSize], length)); |
+ EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet)); |
+ length = packet.payload_size() - kFuAHeaderSize; |
+ EXPECT_THAT(packet.payload().subview(kFuAHeaderSize), |
+ ElementsAreArray(&kRewrittenSps[offset], length)); |
offset += length; |
EXPECT_EQ(offset, sizeof(kRewrittenSps)); |
@@ -467,18 +458,14 @@ TEST_F(RtpPacketizerH264TestSpsRewriting, StapASps) { |
&fragmentation_header_); |
bool last_packet = true; |
- uint8_t buffer[kExpectedTotalSize + kHeaderOverhead] = {}; |
- size_t num_bytes = 0; |
- |
- EXPECT_TRUE(packetizer_->NextPacket(buffer, &num_bytes, &last_packet)); |
- EXPECT_EQ(kExpectedTotalSize, num_bytes); |
- |
- std::vector<uint8_t> expected_payload(kRewrittenSps, |
- &kRewrittenSps[sizeof(kRewrittenSps)]); |
- EXPECT_THAT(expected_payload, |
- ::testing::ElementsAreArray( |
- &buffer[H264::kNaluTypeSize + kLengthFieldLength], |
- sizeof(kRewrittenSps))); |
+ RtpPacketToSend packet(kNoExtensions); |
+ ASSERT_LE(kExpectedTotalSize + kHeaderOverhead, packet.FreeCapacity()); |
+ |
+ EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet)); |
+ EXPECT_EQ(kExpectedTotalSize, packet.payload_size()); |
+ EXPECT_THAT(packet.payload().subview(H264::kNaluTypeSize + kLengthFieldLength, |
+ sizeof(kRewrittenSps)), |
+ ElementsAreArray(kRewrittenSps)); |
} |
class RtpDepacketizerH264Test : public ::testing::Test { |