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 48 matching lines @@
   fragmentation->fragmentationLength[1] = 2;
   fragmentation->fragmentationOffset[2] = 4;
   fragmentation->fragmentationLength[2] =
       kNalHeaderSize + frameSize - payloadOffset;
 }
 
 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,
+  return RtpPacketizer::Create(kRtpVideoH264, max_payload_size, 0, &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 28 matching lines @@
   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);
 
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(max_payload_size, packet.FreeCapacity());
-  bool last = false;
   size_t offset = kNalHeaderSize;
+  EXPECT_EQ(packetizer->TotalPackets(), expected_sizes.size());
   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 41 matching lines @@
   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);
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_EQ(packetizer->TotalPackets(), 1u);
+  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);
 
   RtpPacketToSend packet(kNoExtensions);
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_EQ(packetizer->TotalPackets(), 2u);
+  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);
 
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_EQ(packetizer->TotalPackets(), 1u);
+  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, 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));
   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);
 
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
-  bool last = false;
-  ASSERT_TRUE(packetizer->NextPacket(&packet, &last));
+  ASSERT_EQ(packetizer->TotalPackets(), 2u);
+  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;
@@ skipping 13 matching lines @@
   std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer(
       H264PacketizationMode::NonInterleaved, 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);
   RtpPacketToSend packet(kNoExtensions);
   ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity());
-  bool last = false;
+  ASSERT_EQ(packetizer->TotalPackets(), 3u);
   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,
       std::vector<size_t>(kExpectedPayloadSizes,
                           kExpectedPayloadSizes +
                               sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
@@ skipping 95 matching lines @@
   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));
 
   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));
 
   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