H.264 packetization mode 0 (try 2)

webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 25 matching lines @@
 
 static const size_t kNalHeaderSize = 1;
 static const size_t kFuAHeaderSize = 2;
 
 // Bit masks for FU (A and B) indicators.
 enum NalDefs { kFBit = 0x80, kNriMask = 0x60, kTypeMask = 0x1F };
 
 // Bit masks for FU (A and B) headers.
 enum FuDefs { kSBit = 0x80, kEBit = 0x40, kRBit = 0x20 };
 
+RtpPacketizer* CreateH264Packetizer(H264PacketizationMode mode,
+                                    size_t max_payload_size) {
+  RTPVideoTypeHeader type_header;
+  type_header.H264.packetization_mode = mode;
+  return RtpPacketizer::Create(kRtpVideoH264, max_payload_size, &type_header,
+                               kEmptyFrame);
+}
+
 void VerifyFua(size_t fua_index,
                const uint8_t* expected_payload,
                int offset,
                const uint8_t* packet,
                size_t length,
                const std::vector<size_t>& expected_sizes) {
   ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, length)
       << "FUA index: " << fua_index;
   const uint8_t kFuIndicator = 0x1C;  // F=0, NRI=0, Type=28.
   EXPECT_EQ(kFuIndicator, packet[0]) << "FUA index: " << fua_index;
@@ skipping 21 matching lines @@
   std::unique_ptr<uint8_t[]> frame;
   frame.reset(new uint8_t[frame_size]);
   frame[0] = 0x05;  // F=0, NRI=0, Type=5.
   for (size_t i = 0; i < frame_size - kNalHeaderSize; ++i) {
     frame[i + kNalHeaderSize] = i;
   }
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = frame_size;
-  std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
-      kRtpVideoH264, max_payload_size, NULL, kEmptyFrame));
+  std::unique_ptr<RtpPacketizer> packetizer(
+      CreateH264Packetizer(kH264PacketizationMode1, max_payload_size));
   packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation);
 
   std::unique_ptr<uint8_t[]> packet(new uint8_t[max_payload_size]);
   size_t length = 0;
   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);
     EXPECT_EQ(i == expected_sizes.size() - 1, last) << "FUA index: " << i;
@@ skipping 46 matching lines @@
                              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));
 }
 }  // namespace
 
-TEST(RtpPacketizerH264Test, TestSingleNalu) {
+// Tests that should work with both packetization mode 0 and
+// packetization mode 1.
+class RtpPacketizerH264ModeTest
+    : public ::testing::TestWithParam<H264PacketizationMode> {};
+
+TEST_P(RtpPacketizerH264ModeTest, TestSingleNalu) {
   const uint8_t frame[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5.
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(1);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = sizeof(frame);
   std::unique_ptr<RtpPacketizer> packetizer(
-      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
+      CreateH264Packetizer(GetParam(), kMaxPayloadSize));
   packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation);
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
   ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
   EXPECT_EQ(2u, length);
   EXPECT_TRUE(last);
-  VerifySingleNaluPayload(
-      fragmentation, 0, frame, sizeof(frame), packet, length);
+  VerifySingleNaluPayload(fragmentation, 0, frame, sizeof(frame), packet,
+                          length);
   EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
 }
 
-TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) {
+TEST_P(RtpPacketizerH264ModeTest, TestSingleNaluTwoPackets) {
   const size_t kFrameSize = kMaxPayloadSize + 100;
   uint8_t frame[kFrameSize] = {0};
   for (size_t i = 0; i < kFrameSize; ++i)
     frame[i] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(2);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = kMaxPayloadSize;
   fragmentation.fragmentationOffset[1] = kMaxPayloadSize;
   fragmentation.fragmentationLength[1] = 100;
   // Set NAL headers.
   frame[fragmentation.fragmentationOffset[0]] = 0x01;
   frame[fragmentation.fragmentationOffset[1]] = 0x01;
 
   std::unique_ptr<RtpPacketizer> packetizer(
-      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
+      CreateH264Packetizer(GetParam(), kMaxPayloadSize));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   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, &length, &last));
   ASSERT_EQ(fragmentation.fragmentationLength[1], length);
   VerifySingleNaluPayload(fragmentation, 1, frame, kFrameSize, packet, length);
   EXPECT_TRUE(last);
 
   EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
 }
 
+INSTANTIATE_TEST_CASE_P(PacketMode,
+                        RtpPacketizerH264ModeTest,
+                        ::testing::Values(kH264PacketizationMode0,
+                                          kH264PacketizationMode1));
+
 TEST(RtpPacketizerH264Test, TestStapA) {
   const size_t kFrameSize =
       kMaxPayloadSize - 3 * kLengthFieldLength - kNalHeaderSize;
   uint8_t frame[kFrameSize] = {0x07, 0xFF,  // F=0, NRI=0, Type=7 (SPS).
                                0x08, 0xFF,  // F=0, NRI=0, Type=8 (PPS).
                                0x05};       // F=0, NRI=0, Type=5 (IDR).
   const size_t kPayloadOffset = 5;
   for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i)
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = 2;
   fragmentation.fragmentationOffset[1] = 2;
   fragmentation.fragmentationLength[1] = 2;
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
   std::unique_ptr<RtpPacketizer> packetizer(
-      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
+      CreateH264Packetizer(kH264PacketizationMode1, kMaxPayloadSize));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
   ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
   size_t expected_packet_size =
       kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize;
   ASSERT_EQ(expected_packet_size, length);
   EXPECT_TRUE(last);
   for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i)
     VerifyStapAPayload(fragmentation, 0, i, frame, kFrameSize, packet, length);
 
   EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
 }
 
+TEST(RtpPacketizerH264Test, TestMode0HasNoStapA) {
+  // This is the same setup as for the TestStapA test.
+  const size_t kFrameSize =
+      kMaxPayloadSize - 3 * kLengthFieldLength - kNalHeaderSize;
+  uint8_t frame[kFrameSize] = {0x07, 0xFF,  // F=0, NRI=0, Type=7 (SPS).
+                               0x08, 0xFF,  // F=0, NRI=0, Type=8 (PPS).
+                               0x05};       // F=0, NRI=0, Type=5 (IDR).
+  const size_t kPayloadOffset = 5;
+  for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i)
+    frame[i + kPayloadOffset] = i;
+  RTPFragmentationHeader fragmentation;
+  fragmentation.VerifyAndAllocateFragmentationHeader(3);
+  fragmentation.fragmentationOffset[0] = 0;
+  fragmentation.fragmentationLength[0] = 2;
+  fragmentation.fragmentationOffset[1] = 2;
+  fragmentation.fragmentationLength[1] = 2;
+  fragmentation.fragmentationOffset[2] = 4;
+  fragmentation.fragmentationLength[2] =
+      kNalHeaderSize + kFrameSize - kPayloadOffset;
+  std::unique_ptr<RtpPacketizer> packetizer(
+      CreateH264Packetizer(kH264PacketizationMode0, kMaxPayloadSize));
+  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
+
+  uint8_t packet[kMaxPayloadSize] = {0};
+  size_t length = 0;
+  bool last = false;
+  // The three fragments should be returned as three packets.
+  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
+  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
+  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
+  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
+}
+
 TEST(RtpPacketizerH264Test, TestTooSmallForStapAHeaders) {
   const size_t kFrameSize = kMaxPayloadSize - 1;
   uint8_t frame[kFrameSize] = {0x07, 0xFF,  // F=0, NRI=0, Type=7.
                                0x08, 0xFF,  // F=0, NRI=0, Type=8.
                                0x05};       // F=0, NRI=0, Type=5.
   const size_t kPayloadOffset = 5;
   for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i)
     frame[i + kPayloadOffset] = i;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = 2;
   fragmentation.fragmentationOffset[1] = 2;
   fragmentation.fragmentationLength[1] = 2;
   fragmentation.fragmentationOffset[2] = 4;
   fragmentation.fragmentationLength[2] =
       kNalHeaderSize + kFrameSize - kPayloadOffset;
   std::unique_ptr<RtpPacketizer> packetizer(
-      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
+      CreateH264Packetizer(kH264PacketizationMode1, kMaxPayloadSize));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   uint8_t packet[kMaxPayloadSize] = {0};
   size_t length = 0;
   bool last = false;
   ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
   size_t expected_packet_size = kNalHeaderSize;
   for (size_t i = 0; i < 2; ++i) {
     expected_packet_size +=
         kLengthFieldLength + fragmentation.fragmentationLength[i];
@@ skipping 27 matching lines @@
   uint8_t frame[kFrameSize];
   size_t nalu_offset = 0;
   for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) {
     nalu_offset = fragmentation.fragmentationOffset[i];
     frame[nalu_offset] = 0x05;  // F=0, NRI=0, Type=5.
     for (size_t j = 1; j < fragmentation.fragmentationLength[i]; ++j) {
       frame[nalu_offset + j] = i + j;
     }
   }
   std::unique_ptr<RtpPacketizer> packetizer(
-      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame));
+      CreateH264Packetizer(kH264PacketizationMode1, kMaxPayloadSize));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   // First expecting two FU-A packets.
   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;
   bool last = false;
   int fua_offset = kNalHeaderSize;
@@ skipping 52 matching lines @@
   // Generate 10 full sized packets, leave room for FU-A headers minus the NALU
   // header.
   TestFua(
       10 * (kMaxPayloadSize - kFuAHeaderSize) + kNalHeaderSize,
       kMaxPayloadSize,
       std::vector<size_t>(kExpectedPayloadSizes,
                           kExpectedPayloadSizes +
                               sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
 }
 
+#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+
+TEST(RtpPacketizerH264DeathTest, SendOverlongDataInPacketizationMode0) {
+  const size_t kFrameSize = kMaxPayloadSize + 100;
+  uint8_t frame[kFrameSize] = {0};
+  for (size_t i = 0; i < kFrameSize; ++i)
+    frame[i] = i;
+  RTPFragmentationHeader fragmentation;
+  fragmentation.VerifyAndAllocateFragmentationHeader(1);
+  fragmentation.fragmentationOffset[0] = 0;
+  fragmentation.fragmentationLength[0] = kFrameSize;
+  // Set NAL headers.
+  frame[fragmentation.fragmentationOffset[0]] = 0x01;
+
+  std::unique_ptr<RtpPacketizer> packetizer(
+      CreateH264Packetizer(kH264PacketizationMode0, kMaxPayloadSize));
+  EXPECT_DEATH(packetizer->SetPayloadData(frame, kFrameSize, &fragmentation),
+               "payload_size");
+}
+
+#endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+
 namespace {
 const uint8_t kStartSequence[] = {0x00, 0x00, 0x00, 0x01};
 const uint8_t kOriginalSps[] = {kSps, 0x00, 0x00, 0x03, 0x03,
                                 0xF4, 0x05, 0x03, 0xC7, 0xC0};
 const uint8_t kRewrittenSps[] = {kSps, 0x00, 0x00, 0x03, 0x03, 0xF4, 0x05, 0x03,
                                  0xC7, 0xE0, 0x1B, 0x41, 0x10, 0x8D, 0x00};
 const uint8_t kIdrOne[] = {kIdr, 0xFF, 0x00, 0x00, 0x04};
 const uint8_t kIdrTwo[] = {kIdr, 0xFF, 0x00, 0x11};
 }
 
@@ skipping 20 matching lines @@
  protected:
   rtc::Buffer in_buffer_;
   RTPFragmentationHeader fragmentation_header_;
   std::unique_ptr<RtpPacketizer> packetizer_;
 };
 
 TEST_F(RtpPacketizerH264TestSpsRewriting, FuASps) {
   const size_t kHeaderOverhead = kFuAHeaderSize + 1;
 
   // Set size to fragment SPS into two FU-A packets.
-  packetizer_.reset(RtpPacketizer::Create(
-      kRtpVideoH264, sizeof(kOriginalSps) - 2 + kHeaderOverhead, nullptr,
-      kEmptyFrame));
+  packetizer_.reset(CreateH264Packetizer(
+      kH264PacketizationMode1, sizeof(kOriginalSps) - 2 + kHeaderOverhead));
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &fragmentation_header_);
 
   bool last_packet = true;
   uint8_t buffer[sizeof(kOriginalSps) + kHeaderOverhead] = {};
   size_t num_bytes = 0;
 
   EXPECT_TRUE(packetizer_->NextPacket(buffer, &num_bytes, &last_packet));
   size_t offset = H264::kNaluTypeSize;
@@ skipping 15 matching lines @@
   EXPECT_EQ(offset, sizeof(kRewrittenSps));
 }
 
 TEST_F(RtpPacketizerH264TestSpsRewriting, StapASps) {
   const size_t kHeaderOverhead = kFuAHeaderSize + 1;
   const size_t kExpectedTotalSize = H264::kNaluTypeSize +  // Stap-A type.
                                     sizeof(kRewrittenSps) + sizeof(kIdrOne) +
                                     sizeof(kIdrTwo) + (kLengthFieldLength * 3);
 
   // Set size to include SPS and the rest of the packets in a Stap-A package.
-  packetizer_.reset(RtpPacketizer::Create(kRtpVideoH264,
-                                          kExpectedTotalSize + kHeaderOverhead,
-                                          nullptr, kEmptyFrame));
+  packetizer_.reset(CreateH264Packetizer(kH264PacketizationMode1,
+                                         kExpectedTotalSize + kHeaderOverhead));
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &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);
@@ skipping 356 matching lines @@
   const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
   EXPECT_EQ(kH264SingleNalu, h264.packetization_type);
   EXPECT_EQ(kSei, h264.nalu_type);
   ASSERT_EQ(1u, h264.nalus_length);
   EXPECT_EQ(static_cast<H264::NaluType>(kSei), h264.nalus[0].type);
   EXPECT_EQ(-1, h264.nalus[0].sps_id);
   EXPECT_EQ(-1, h264.nalus[0].pps_id);
 }
 
 }  // namespace webrtc