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

webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
index 0e1a474e35a47b8af7988b77214651b6090546ee..c20269cf857b2564b660666e94ff9ca83470ba43 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
@@ -107,19 +107,19 @@ TEST_F(RtpPacketizerVp8Test, TestStrictMode) {
 
   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());
-
-  // 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};
+  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 hand.
+  const size_t kExpectedSizes[] = {9, 9, 12, 13, 13, 13};
+  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,
@@ -138,17 +138,19 @@ TEST_F(RtpPacketizerVp8Test, DISABLED_TestStrictEqualTightPartitions) {
 
   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);
@@ -161,18 +163,19 @@ TEST_F(RtpPacketizerVp8Test, TestAggregateMode) {
 
   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,
@@ -181,6 +184,85 @@ TEST_F(RtpPacketizerVp8Test, TestAggregateMode) {
                                  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};

[danilchap, 2017/05/19 12:03:46]

what happen with same kSizeVector but with kLastPacketReductionLen = 2?

[ilnik, 2017/05/19 12:57:45]

Nothing really changes. last packet still has 4 free bytes (13-9). This solution
will also generate smallest largest packet.

If, however kLastPacketReductionLen were be 5 or 6, there would still be a way
to fit everything in 3 packets (all vp8 payload descriptors are 3 bytes, so we
have 10 free bytes in each packet). aggregation would be 3+4+2 in the first
packet, 5+2 in the second and 4 in the last packet. Alternatively, it may be
3+4/2+5+2/4 which has the same score. I fill there's no need to add a new test
as there are already tests for that below.

+  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);
@@ -188,18 +270,19 @@ TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions1) {
 
   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,
@@ -215,18 +298,19 @@ TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions2) {
 
   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,
@@ -242,18 +326,19 @@ TEST_F(RtpPacketizerVp8Test, TestAggregateModeTwoLargePartitions) {
 
   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,
@@ -270,18 +355,19 @@ TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) {
 
   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,
@@ -291,6 +377,33 @@ TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) {
                                  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);
+
+  // Expecting three full packets, and one with the remainder.
+  const size_t kExpectedSizes[] = {13, 13, 14, 14, 9};

[danilchap, 2017/05/19 12:03:46]

Can you add comment explaining expected sizes because I do not understand why
they are correct:
Total payload size is 30+10+3 = 43 bytes.
descriptor (with 2-byte picture id) is 3 bytes,
so expected size state that total payload put into packets will be
10 + 10 + 11 + 11 + 6 = 48 bytes.

[ilnik, 2017/05/19 12:57:45]

Descriptor is 4 bytes in that case according to rfc:
https://tools.ietf.org/html/rfc7741#page-7 (one required byte, extended control
bits byte, and 2-byte pictureID). Thus, we get 9+9+10+10+5=43=30+10+3.

Added a comment.

+  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};
@@ -299,9 +412,9 @@ TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) {
 
   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};
@@ -311,6 +424,7 @@ TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) {
   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,
@@ -331,10 +445,10 @@ TEST_F(RtpPacketizerVp8Test, TestTl0PicIdxAndTID) {
   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};
@@ -343,6 +457,7 @@ TEST_F(RtpPacketizerVp8Test, TestTl0PicIdxAndTID) {
   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,
@@ -360,10 +475,10 @@ TEST_F(RtpPacketizerVp8Test, TestKeyIdx) {
   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};
@@ -372,6 +487,7 @@ TEST_F(RtpPacketizerVp8Test, TestKeyIdx) {
   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,
@@ -390,10 +506,10 @@ TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) {
   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};
@@ -402,6 +518,7 @@ TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) {
   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,
@@ -579,11 +696,9 @@ TEST_F(RtpDepacketizerVp8Test, TestWithPacketizer) {
   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();