Fix packetization logic to leave space for extensions in the last packet

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 45 matching lines @@
   fragmentation->fragmentationOffset[0] = 0;
   fragmentation->fragmentationLength[0] = 2;
   fragmentation->fragmentationOffset[1] = 2;
   fragmentation->fragmentationLength[1] = 2;
   fragmentation->fragmentationOffset[2] = 4;
   fragmentation->fragmentationLength[2] =
       kNalHeaderSize + frameSize - payloadOffset;
 }
 
 RtpPacketizer* CreateH264Packetizer(H264PacketizationMode mode,
-                                    size_t max_payload_size) {
+                                    size_t max_payload_size,
+                                    size_t last_packet_reduction) {
   RTPVideoTypeHeader type_header;
   type_header.H264.packetization_mode = mode;
-  return RtpPacketizer::Create(kRtpVideoH264, max_payload_size, &type_header,
+  return RtpPacketizer::Create(kRtpVideoH264, max_payload_size,
+                               last_packet_reduction, &type_header,
                                kEmptyFrame);
 }
 
 void VerifyFua(size_t fua_index,
                const uint8_t* expected_payload,
                int offset,
                rtc::ArrayView<const uint8_t> packet,
                const std::vector<size_t>& expected_sizes) {
   ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, packet.size())
       << "FUA index: " << fua_index;
@@ skipping 11 matching lines @@
   std::vector<uint8_t> expected_packet_payload(
       &expected_payload[offset],
       &expected_payload[offset + expected_sizes[fua_index]]);
   EXPECT_THAT(expected_packet_payload,
               ElementsAreArray(&packet[2], expected_sizes[fua_index]))
       << "FUA index: " << fua_index;
 }
 
 void TestFua(size_t frame_size,
              size_t max_payload_size,
+             size_t last_packet_reduction,
              const std::vector<size_t>& expected_sizes) {
   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(CreateH264Packetizer(
-      H264PacketizationMode::NonInterleaved, max_payload_size));
-  packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation);
+  std::unique_ptr<RtpPacketizer> packetizer(
+      CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
+                           max_payload_size, last_packet_reduction));
+  EXPECT_EQ(
+      expected_sizes.size(),
+      packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation));
 
   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, &last));
+    ASSERT_TRUE(packetizer->NextPacket(&packet));
     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, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
 }
 
 size_t GetExpectedNaluOffset(const RTPFragmentationHeader& fragmentation,
                              size_t start_index,
                              size_t nalu_index) {
   assert(nalu_index < fragmentation.fragmentationVectorSize);
   size_t expected_nalu_offset = kNalHeaderSize;  // STAP-A header.
   for (size_t i = start_index; i < nalu_index; ++i) {
     expected_nalu_offset +=
         kLengthFieldLength + fragmentation.fragmentationLength[i];
@@ skipping 37 matching lines @@
 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(
-      CreateH264Packetizer(GetParam(), kMaxPayloadSize));
-  packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation);
+      CreateH264Packetizer(GetParam(), kMaxPayloadSize, 0));
+  ASSERT_EQ(1u,
+            packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation));
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
   EXPECT_EQ(2u, packet.payload_size());
-  EXPECT_TRUE(last);
   VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload());
-  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
 }
 
 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(
-      CreateH264Packetizer(GetParam(), kMaxPayloadSize));
-  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
+      CreateH264Packetizer(GetParam(), kMaxPayloadSize, 0));
+  ASSERT_EQ(2u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
   RtpPacketToSend packet(kNoExtensions);
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
   ASSERT_EQ(fragmentation.fragmentationOffset[1], packet.payload_size());
   VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload());
 
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
   ASSERT_EQ(fragmentation.fragmentationLength[1], packet.payload_size());
   VerifySingleNaluPayload(fragmentation, 1, frame, packet.payload());
-  EXPECT_TRUE(last);
 
-  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
 }
 
 INSTANTIATE_TEST_CASE_P(
     PacketMode,
     RtpPacketizerH264ModeTest,
     ::testing::Values(H264PacketizationMode::SingleNalUnit,
                       H264PacketizationMode::NonInterleaved));
 
 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;
   CreateThreeFragments(&fragmentation, kFrameSize, kPayloadOffset);
   std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
-      H264PacketizationMode::NonInterleaved, kMaxPayloadSize));
-  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
+      H264PacketizationMode::NonInterleaved, kMaxPayloadSize, 0));
+  ASSERT_EQ(1u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
   size_t expected_packet_size =
       kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize;
   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, packet.payload());
 
-  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
+}
+
+TEST(RtpPacketizerH264Test, TestStapARespectsPacketReduction) {
+  const size_t kLastPacketReduction = 100;
+  const size_t kFrameSize = kMaxPayloadSize - 1 - kLastPacketReduction;
+  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(
+      CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
+                           kMaxPayloadSize, kLastPacketReduction));
+  ASSERT_EQ(2u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
+
+  RtpPacketToSend packet(kNoExtensions);
+  ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
+  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, packet.payload_size());
+  for (size_t i = 0; i < 2; ++i)
+    VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload());
+
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
+  expected_packet_size = fragmentation.fragmentationLength[2];
+  ASSERT_EQ(expected_packet_size, packet.payload_size());
+  VerifySingleNaluPayload(fragmentation, 2, frame, packet.payload());
+
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
 }
 
 TEST(RtpPacketizerH264Test, TestSingleNalUnitModeHasNoStapA) {
   // 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;
   CreateThreeFragments(&fragmentation, kFrameSize, kPayloadOffset);
   std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
-      H264PacketizationMode::SingleNalUnit, kMaxPayloadSize));
+      H264PacketizationMode::SingleNalUnit, kMaxPayloadSize, 0));
   packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
 
   RtpPacketToSend packet(kNoExtensions);
-  bool last = false;
   // The three fragments should be returned as three packets.
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
-  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
 }
 
 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(CreateH264Packetizer(
-      H264PacketizationMode::NonInterleaved, kMaxPayloadSize));
-  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
+      H264PacketizationMode::NonInterleaved, kMaxPayloadSize, 0));
+  ASSERT_EQ(2u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
   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, packet.payload_size());
-  EXPECT_FALSE(last);
   for (size_t i = 0; i < 2; ++i)
     VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload());
 
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
   expected_packet_size = fragmentation.fragmentationLength[2];
   ASSERT_EQ(expected_packet_size, packet.payload_size());
-  EXPECT_TRUE(last);
   VerifySingleNaluPayload(fragmentation, 2, frame, packet.payload());
 
-  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
 }
 
 TEST(RtpPacketizerH264Test, TestMixedStapA_FUA) {
   const size_t kFuaNaluSize = 2 * (kMaxPayloadSize - 100);
   const size_t kStapANaluSize = 100;
   RTPFragmentationHeader fragmentation;
   fragmentation.VerifyAndAllocateFragmentationHeader(3);
   fragmentation.fragmentationOffset[0] = 0;
   fragmentation.fragmentationLength[0] = kFuaNaluSize;
   fragmentation.fragmentationOffset[1] = kFuaNaluSize;
   fragmentation.fragmentationLength[1] = kStapANaluSize;
   fragmentation.fragmentationOffset[2] = kFuaNaluSize + kStapANaluSize;
   fragmentation.fragmentationLength[2] = kStapANaluSize;
   const size_t kFrameSize = kFuaNaluSize + 2 * kStapANaluSize;
   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(CreateH264Packetizer(
-      H264PacketizationMode::NonInterleaved, kMaxPayloadSize));
-  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
+      H264PacketizationMode::NonInterleaved, kMaxPayloadSize, 0));
+  ASSERT_EQ(3u, packetizer->SetPayloadData(frame, kFrameSize, &fragmentation));
 
   // First expecting two FU-A packets.
   std::vector<size_t> fua_sizes;
+  fua_sizes.push_back(1099);
   fua_sizes.push_back(1100);
-  fua_sizes.push_back(1099);
   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, &last));
+    ASSERT_TRUE(packetizer->NextPacket(&packet));
     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, &last));
+  ASSERT_TRUE(packetizer->NextPacket(&packet));
   size_t expected_packet_size =
       kNalHeaderSize + 2 * kLengthFieldLength + 2 * kStapANaluSize;
   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, packet.payload());
 
-  EXPECT_FALSE(packetizer->NextPacket(&packet, &last));
+  EXPECT_FALSE(packetizer->NextPacket(&packet));
 }
 
 TEST(RtpPacketizerH264Test, TestFUAOddSize) {
   const size_t kExpectedPayloadSizes[2] = {600, 600};
   TestFua(
-      kMaxPayloadSize + 1,
-      kMaxPayloadSize,
+      kMaxPayloadSize + 1, kMaxPayloadSize, 0,
+      std::vector<size_t>(kExpectedPayloadSizes,
+                          kExpectedPayloadSizes +
+                              sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
+}
+
+TEST(RtpPacketizerH264Test, TestFUAWithLastPacketReduction) {
+  const size_t kExpectedPayloadSizes[2] = {601, 597};
+  TestFua(
+      kMaxPayloadSize - 1, kMaxPayloadSize, 4,
       std::vector<size_t>(kExpectedPayloadSizes,
                           kExpectedPayloadSizes +
                               sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
 }
 
 TEST(RtpPacketizerH264Test, TestFUAEvenSize) {
-  const size_t kExpectedPayloadSizes[2] = {601, 600};
+  const size_t kExpectedPayloadSizes[2] = {600, 601};
   TestFua(
-      kMaxPayloadSize + 2,
-      kMaxPayloadSize,
+      kMaxPayloadSize + 2, kMaxPayloadSize, 0,
       std::vector<size_t>(kExpectedPayloadSizes,
                           kExpectedPayloadSizes +
                               sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
 }
 
 TEST(RtpPacketizerH264Test, TestFUARounding) {
-  const size_t kExpectedPayloadSizes[8] = {1266, 1266, 1266, 1266,
-                                           1266, 1266, 1266, 1261};
+  const size_t kExpectedPayloadSizes[8] = {1265, 1265, 1265, 1265,
+                                           1265, 1266, 1266, 1266};
   TestFua(
-      10124,
-      1448,
+      10124, 1448, 0,
       std::vector<size_t>(kExpectedPayloadSizes,
                           kExpectedPayloadSizes +
                               sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
 }
 
 TEST(RtpPacketizerH264Test, TestFUABig) {
   const size_t kExpectedPayloadSizes[10] = {1198, 1198, 1198, 1198, 1198,
                                             1198, 1198, 1198, 1198, 1198};
   // Generate 10 full sized packets, leave room for FU-A headers minus the NALU
   // header.
   TestFua(
-      10 * (kMaxPayloadSize - kFuAHeaderSize) + kNalHeaderSize,
-      kMaxPayloadSize,
+      10 * (kMaxPayloadSize - kFuAHeaderSize) + kNalHeaderSize, kMaxPayloadSize,
+      0,
       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 + 1;
   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(
-      H264PacketizationMode::SingleNalUnit, kMaxPayloadSize));
+      H264PacketizationMode::SingleNalUnit, kMaxPayloadSize, 0));
   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};
@@ skipping 28 matching lines @@
   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(
       CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
-                           sizeof(kOriginalSps) - 2 + kHeaderOverhead));
+                           sizeof(kOriginalSps) - 2 + kHeaderOverhead, 0));
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &fragmentation_header_);
 
-  bool last_packet = true;
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(sizeof(kOriginalSps) + kHeaderOverhead, packet.FreeCapacity());
 
-  EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet));
+  EXPECT_TRUE(packetizer_->NextPacket(&packet));
   size_t offset = H264::kNaluTypeSize;
   size_t length = packet.payload_size() - kFuAHeaderSize;
   EXPECT_THAT(packet.payload().subview(kFuAHeaderSize),
               ElementsAreArray(&kRewrittenSps[offset], length));
   offset += length;
 
-  EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet));
+  EXPECT_TRUE(packetizer_->NextPacket(&packet));
   length = packet.payload_size() - kFuAHeaderSize;
   EXPECT_THAT(packet.payload().subview(kFuAHeaderSize),
               ElementsAreArray(&kRewrittenSps[offset], length));
   offset += length;
 
   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(CreateH264Packetizer(H264PacketizationMode::NonInterleaved,
-                                         kExpectedTotalSize + kHeaderOverhead));
+                                         kExpectedTotalSize + kHeaderOverhead,
+                                         0));
 
   packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(),
                               &fragmentation_header_);
 
-  bool last_packet = true;
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kExpectedTotalSize + kHeaderOverhead, packet.FreeCapacity());
 
-  EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet));
+  EXPECT_TRUE(packetizer_->NextPacket(&packet));
   EXPECT_EQ(kExpectedTotalSize, packet.payload_size());
   EXPECT_THAT(packet.payload().subview(H264::kNaluTypeSize + kLengthFieldLength,
                                        sizeof(kRewrittenSps)),
               ElementsAreArray(kRewrittenSps));
 }
 
 class RtpDepacketizerH264Test : public ::testing::Test {
  protected:
   RtpDepacketizerH264Test()
       : depacketizer_(RtpDepacketizer::Create(kRtpVideoH264)) {}
@@ skipping 350 matching lines @@
   EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
   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