Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(641)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc

Issue 2522553002: RtpPacketizer::NextPacket fills RtpPacket instead of payload. (Closed)
Patch Set: Named kTheMagicSix Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/modules/rtp_rtcp/source/rtp_format_h264.cc ('k') | webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 {
« no previous file with comments | « webrtc/modules/rtp_rtcp/source/rtp_format_h264.cc ('k') | webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698