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

webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc

 /*
  *  Copyright (c) 2012 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 89 matching lines @@
   test::RtpFormatVp8TestHelper* helper_;
 };
 
 TEST_F(RtpPacketizerVp8Test, TestStrictMode) {
   const size_t kSizeVector[] = {10, 8, 27};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 200;  // > 0x7F should produce 2-byte PictureID.
   const size_t kMaxPayloadSize = 13;
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kStrict);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kStrict);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
-  // The expected sizes are obtained by running a verified good implementation.
-  const size_t kExpectedSizes[] = {9, 9, 12, 11, 11, 11, 10};
-  const int kExpectedPart[] = {0, 0, 1, 2, 2, 2, 2};
-  const bool kExpectedFragStart[] = {true,  false, true, true,
-                                     false, false, false};
+  // The expected sizes are obtained by hand.
+  const size_t kExpectedSizes[] = {9, 9, 12, 13, 13, 13};

[danilchap, 2017/05/22 12:32:00]

the result of this test changed not because you added support for reduced last
packet, but because you removed balanced aggregate mode.
Can you reflect that in the CL description.

[ilnik, 2017/05/22 14:14:09]

No, in that particular test, it is just a bug that last partition was split into
4 packets, instead of 3 now. It's still balanced. I've removed flags because in
all packetizers they were always set to true.

Besides, this is a strict mode test, not an aggregated mode test. Finally, I
changed balanced aggregate mode a bit, but not removed it (now it always
generates the smallest number of packets, but other than that it's always as
balanced as possible).

+  const int kExpectedPart[] = {0, 0, 1, 2, 2, 2};
+  const bool kExpectedFragStart[] = {true, false, true, true, false, false};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 // Verify that we get a minimal number of packets if the partition plus header
 // size fits exactly in the maximum packet size.
-// Test is disabled: https://code.google.com/p/webrtc/issues/detail?id=4019.
-TEST_F(RtpPacketizerVp8Test, DISABLED_TestStrictEqualTightPartitions) {
+TEST_F(RtpPacketizerVp8Test, TestStrictEqualTightPartitions) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 200;  // > 0x7F should produce 2-byte PictureID.
   const int kMaxPayloadSize = 14;
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kStrict);
-  packetizer.SetPayloadData(helper_->payload_data(), helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kStrict);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
-  // The expected sizes are obtained by running a verified good implementation.
+  // The expected sizes are obtained by hand.
   const size_t kExpectedSizes[] = {14, 14, 14};
   const int kExpectedPart[] = {0, 1, 2};
   const bool kExpectedFragStart[] = {true, true, true};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
                                  kExpectedFragStart, kExpectedNum);
 }
 
 TEST_F(RtpPacketizerVp8Test, TestAggregateMode) {
   const size_t kSizeVector[] = {60, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
   const size_t kMaxPayloadSize = 25;
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
-  // The expected sizes are obtained by running a verified good implementation.
+  // The expected sizes are obtained by hand.
   const size_t kExpectedSizes[] = {23, 23, 23, 23};
   const int kExpectedPart[] = {0, 0, 0, 1};
   const bool kExpectedFragStart[] = {true, false, false, true};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
+TEST_F(RtpPacketizerVp8Test, TestAggregateModePacketReductionCauseExtraPacket) {
+  const size_t kSizeVector[] = {60, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
+  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+
+  hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
+  const size_t kMaxPayloadSize = 25;
+  const size_t kLastPacketReductionLen = 5;
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize,
+                              kLastPacketReductionLen, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
+
+  // The expected sizes are obtained by hand.
+  const size_t kExpectedSizes[] = {23, 23, 23, 13, 13};
+  const int kExpectedPart[] = {0, 0, 0, 1, 2};
+  const bool kExpectedFragStart[] = {true, false, false, true, true};
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
+
+  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
+                                 kExpectedFragStart, kExpectedNum);
+}
+
+TEST_F(RtpPacketizerVp8Test, TestAggregateModePacketReduction) {
+  const size_t kSizeVector[] = {60, 10, 10};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
+  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+
+  hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
+  const size_t kMaxPayloadSize = 25;
+  const size_t kLastPacketReductionLen = 1;
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize,
+                              kLastPacketReductionLen, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
+
+  // The expected sizes are obtained by hand.
+  const size_t kExpectedSizes[] = {23, 23, 23, 23};
+  const int kExpectedPart[] = {0, 0, 0, 1};
+  const bool kExpectedFragStart[] = {true, false, false, true};
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
+
+  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
+                                 kExpectedFragStart, kExpectedNum);
+}
+
+TEST_F(RtpPacketizerVp8Test, TestAggregateModeSmallPartitions) {
+  const size_t kSizeVector[] = {3, 4, 2, 5, 2, 4};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
+  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+
+  hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
+  const size_t kMaxPayloadSize = 13;
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
+
+  // The expected sizes are obtained by hand.
+  const size_t kExpectedSizes[] = {10, 10, 9};
+  const int kExpectedPart[] = {0, 2, 4};
+  const bool kExpectedFragStart[] = {true, true, true};
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
+
+  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
+                                 kExpectedFragStart, kExpectedNum);
+}
+
 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions1) {
   const size_t kSizeVector[] = {1600, 200, 200, 200, 200, 200, 200, 200, 200};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
   const size_t kMaxPayloadSize = 1000;
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
-  // The expected sizes are obtained by running a verified good implementation.
+  // The expected sizes are obtained by hand.
   const size_t kExpectedSizes[] = {803, 803, 803, 803};
   const int kExpectedPart[] = {0, 0, 1, 5};
   const bool kExpectedFragStart[] = {true, false, true, true};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions2) {
   const size_t kSizeVector[] = {1599, 200, 200, 200, 1600, 200, 200, 200, 200};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
   const size_t kMaxPayloadSize = 1000;
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
-  // The expected sizes are obtained by running a verified good implementation.
-  const size_t kExpectedSizes[] = {803, 802, 603, 803, 803, 803};
+  // The expected sizes are obtained by hand.
+  const size_t kExpectedSizes[] = {802, 803, 603, 803, 803, 803};
   const int kExpectedPart[] = {0, 0, 1, 4, 4, 5};
   const bool kExpectedFragStart[] = {true, false, true, true, false, true};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 TEST_F(RtpPacketizerVp8Test, TestAggregateModeTwoLargePartitions) {
   const size_t kSizeVector[] = {1654, 2268};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 20;  // <= 0x7F should produce 1-byte PictureID.
   const size_t kMaxPayloadSize = 1460;
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
-  // The expected sizes are obtained by running a verified good implementation.
+  // The expected sizes are obtained by hand.
   const size_t kExpectedSizes[] = {830, 830, 1137, 1137};
   const int kExpectedPart[] = {0, 0, 1, 1};
   const bool kExpectedFragStart[] = {true, false, true, false};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 // Verify that EqualSize mode is forced if fragmentation info is missing.
 TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.pictureId = 200;          // > 0x7F should produce 2-byte PictureID
   const size_t kMaxPayloadSize = 12;  // Small enough to produce 4 packets.
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize);
-  packetizer.SetPayloadData(
-      helper_->payload_data(), helper_->payload_size(), NULL);
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0);
+  size_t num_packets = packetizer.SetPayloadData(
+      helper_->payload_data(), helper_->payload_size(), nullptr);
 
   // Expecting three full packets, and one with the remainder.
-  const size_t kExpectedSizes[] = {12, 11, 12, 11};
+  const size_t kExpectedSizes[] = {11, 11, 12, 12};
   const int kExpectedPart[] = {0, 0, 0, 0};  // Always 0 for equal size mode.
   // Frag start only true for first packet in equal size mode.
   const bool kExpectedFragStart[] = {true, false, false, false};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->set_sloppy_partitioning(true);
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
+TEST_F(RtpPacketizerVp8Test, TestEqualSizeWithLastPacketReduction) {
+  const size_t kSizeVector[] = {30, 10, 3};
+  const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
+  ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
+
+  hdr_info_.pictureId = 200;          // > 0x7F should produce 2-byte PictureID
+  const size_t kMaxPayloadSize = 15;  // Small enough to produce 5 packets.
+  const size_t kLastPacketReduction = 5;
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kLastPacketReduction);
+  size_t num_packets = packetizer.SetPayloadData(
+      helper_->payload_data(), helper_->payload_size(), nullptr);
+
+  // Calculated by hand. VP8 payload descriptors are 4 byte each. 5 packets is
+  // minimum possible to fit 43 payload bytes into packets with capacity of
+  // 15-4=11 and leave 5 free bytes in the last packet. All packets are almost

[danilchap, 2017/05/22 12:32:00]

nit: add spaces around binary operators: '15 - 4 = 11'

[ilnik, 2017/05/22 14:14:09]

Done.

+  // equal in size, even last packet if counted with free space (which will be
+  // filled up the stack by extra long RTP header).
+  const size_t kExpectedSizes[] = {13, 13, 14, 14, 9};
+  const int kExpectedPart[] = {0, 0, 0, 0, 0};  // Always 0 for equal size mode.
+  // Frag start only true for first packet in equal size mode.
+  const bool kExpectedFragStart[] = {true, false, false, false, false};
+  const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
+  CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
+
+  helper_->set_sloppy_partitioning(true);
+  helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart,
+                                 kExpectedFragStart, kExpectedNum);
+}
+
 // Verify that non-reference bit is set. EqualSize mode fallback is expected.
 TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.nonReference = true;
   const size_t kMaxPayloadSize = 25;  // Small enough to produce two packets.
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize);
-  packetizer.SetPayloadData(
-      helper_->payload_data(), helper_->payload_size(), NULL);
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0);
+  size_t num_packets = packetizer.SetPayloadData(
+      helper_->payload_data(), helper_->payload_size(), nullptr);
 
   // EqualSize mode => First packet full; other not.
   const size_t kExpectedSizes[] = {16, 16};
   const int kExpectedPart[] = {0, 0};  // Always 0 for equal size mode.
   // Frag start only true for first packet in equal size mode.
   const bool kExpectedFragStart[] = {true, false};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->set_sloppy_partitioning(true);
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 // Verify Tl0PicIdx and TID fields, and layerSync bit.
 TEST_F(RtpPacketizerVp8Test, TestTl0PicIdxAndTID) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.tl0PicIdx = 117;
   hdr_info_.temporalIdx = 2;
   hdr_info_.layerSync = true;
   // kMaxPayloadSize is only limited by allocated buffer size.
   const size_t kMaxPayloadSize = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
   // Expect one single packet of payload_size() + 4 bytes header.
   const size_t kExpectedSizes[1] = {helper_->payload_size() + 4};
   const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
   const bool kExpectedFragStart[1] = {true};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 // Verify KeyIdx field.
 TEST_F(RtpPacketizerVp8Test, TestKeyIdx) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.keyIdx = 17;
   // kMaxPayloadSize is only limited by allocated buffer size.
   const size_t kMaxPayloadSize = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
   // Expect one single packet of payload_size() + 3 bytes header.
   const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
   const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
   const bool kExpectedFragStart[1] = {true};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 // Verify TID field and KeyIdx field in combination.
 TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) {
   const size_t kSizeVector[] = {10, 10, 10};
   const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector);
   ASSERT_TRUE(Init(kSizeVector, kNumPartitions));
 
   hdr_info_.temporalIdx = 1;
   hdr_info_.keyIdx = 5;
   // kMaxPayloadSize is only limited by allocated buffer size.
   const size_t kMaxPayloadSize = helper_->buffer_size();
-  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate);
-  packetizer.SetPayloadData(helper_->payload_data(),
-                            helper_->payload_size(),
-                            helper_->fragmentation());
+  RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, 0, kAggregate);
+  size_t num_packets = packetizer.SetPayloadData(helper_->payload_data(),
+                                                 helper_->payload_size(),
+                                                 helper_->fragmentation());
 
   // Expect one single packet of payload_size() + 3 bytes header.
   const size_t kExpectedSizes[1] = {helper_->payload_size() + 3};
   const int kExpectedPart[1] = {0};  // Packet starts with partition 0.
   const bool kExpectedFragStart[1] = {true};
   const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart);
   CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart);
+  ASSERT_EQ(num_packets, kExpectedNum);
 
   helper_->GetAllPacketsAndCheck(&packetizer,
                                  kExpectedSizes,
                                  kExpectedPart,
                                  kExpectedFragStart,
                                  kExpectedNum);
 }
 
 class RtpDepacketizerVp8Test : public ::testing::Test {
  protected:
@@ skipping 157 matching lines @@
   const uint8_t kHeaderLength = 5;
   uint8_t data[10] = {0};
   RtpPacketToSend packet(kNoExtensions);
   RTPVideoHeaderVP8 input_header;
   input_header.nonReference = true;
   input_header.pictureId = 300;
   input_header.temporalIdx = 1;
   input_header.layerSync = false;
   input_header.tl0PicIdx = kNoTl0PicIdx;  // Disable.
   input_header.keyIdx = 31;
-  RtpPacketizerVp8 packetizer(input_header, 20);
-  packetizer.SetPayloadData(data, 10, NULL);
-  bool last;
-  ASSERT_TRUE(packetizer.NextPacket(&packet, &last));
-  EXPECT_TRUE(last);
+  RtpPacketizerVp8 packetizer(input_header, 20, 0);
+  EXPECT_EQ(packetizer.SetPayloadData(data, 10, NULL), 1u);
+  ASSERT_TRUE(packetizer.NextPacket(&packet));
   EXPECT_TRUE(packet.Marker());
 
   auto rtp_payload = packet.payload();
   RtpDepacketizer::ParsedPayload payload;
   ASSERT_TRUE(
       depacketizer_->Parse(&payload, rtp_payload.data(), rtp_payload.size()));
   auto vp8_payload = rtp_payload.subview(kHeaderLength);
   ExpectPacket(&payload, vp8_payload.data(), vp8_payload.size());
   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
   EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
   VerifyBasicHeader(&payload.type, 1, 1, 0);
   VerifyExtensions(&payload.type,
                    input_header.pictureId,
                    input_header.tl0PicIdx,
                    input_header.temporalIdx,
                    input_header.keyIdx);
   EXPECT_EQ(payload.type.Video.codecHeader.VP8.layerSync,
             input_header.layerSync);
 }
 
 TEST_F(RtpDepacketizerVp8Test, TestEmptyPayload) {
   // Using a wild pointer to crash on accesses from inside the depacketizer.
   uint8_t* garbage_ptr = reinterpret_cast<uint8_t*>(0x4711);
   RtpDepacketizer::ParsedPayload payload;
   EXPECT_FALSE(depacketizer_->Parse(&payload, garbage_ptr, 0));
 }
 }  // namespace webrtc