Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 531 insertions, 0 deletions

diff --git a/third_party/libwebrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc b/third_party/libwebrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
new file mode 100644
index 0000000000..18311c6e8c
--- /dev/null
+++ b/third_party/libwebrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
@@ -0,0 +1,531 @@
+/*
+ *  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.
+ */
+
+#include "modules/rtp_rtcp/source/rtp_format_h264.h"
+
+#include <memory>
+#include <vector>
+
+#include "absl/algorithm/container.h"
+#include "api/array_view.h"
+#include "common_video/h264/h264_common.h"
+#include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
+#include "modules/rtp_rtcp/source/byte_io.h"
+#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+namespace webrtc {
+namespace {
+
+using ::testing::Each;
+using ::testing::ElementsAre;
+using ::testing::ElementsAreArray;
+using ::testing::Eq;
+using ::testing::IsEmpty;
+using ::testing::SizeIs;
+
+constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr;
+constexpr size_t kMaxPayloadSize = 1200;
+constexpr size_t kLengthFieldLength = 2;
+constexpr RtpPacketizer::PayloadSizeLimits kNoLimits;
+
+enum Nalu {
+  kSlice = 1,
+  kIdr = 5,
+  kSei = 6,
+  kSps = 7,
+  kPps = 8,
+  kStapA = 24,
+  kFuA = 28
+};
+
+static const size_t kNalHeaderSize = 1;
+static const size_t kFuAHeaderSize = 2;
+
+// Creates Buffer that looks like nal unit of given size.
+rtc::Buffer GenerateNalUnit(size_t size) {
+  RTC_CHECK_GT(size, 0);
+  rtc::Buffer buffer(size);
+  // Set some valid header.
+  buffer[0] = kSlice;
+  for (size_t i = 1; i < size; ++i) {
+    buffer[i] = static_cast<uint8_t>(i);
+  }
+  // Last byte shouldn't be 0, or it may be counted as part of next 4-byte start
+  // sequence.
+  buffer[size - 1] |= 0x10;
+  return buffer;
+}
+
+// Create frame consisting of nalus of given size.
+rtc::Buffer CreateFrame(std::initializer_list<size_t> nalu_sizes) {
+  static constexpr int kStartCodeSize = 3;
+  rtc::Buffer frame(absl::c_accumulate(nalu_sizes, size_t{0}) +
+                    kStartCodeSize * nalu_sizes.size());
+  size_t offset = 0;
+  for (size_t nalu_size : nalu_sizes) {
+    EXPECT_GE(nalu_size, 1u);
+    // Insert nalu start code
+    frame[offset] = 0;
+    frame[offset + 1] = 0;
+    frame[offset + 2] = 1;
+    // Set some valid header.
+    frame[offset + 3] = 1;
+    // Fill payload avoiding accidental start codes
+    if (nalu_size > 1) {
+      memset(frame.data() + offset + 4, 0x3f, nalu_size - 1);
+    }
+    offset += (kStartCodeSize + nalu_size);
+  }
+  return frame;
+}
+
+// Create frame consisting of given nalus.
+rtc::Buffer CreateFrame(rtc::ArrayView<const rtc::Buffer> nalus) {
+  static constexpr int kStartCodeSize = 3;
+  int frame_size = 0;
+  for (const rtc::Buffer& nalu : nalus) {
+    frame_size += (kStartCodeSize + nalu.size());
+  }
+  rtc::Buffer frame(frame_size);
+  size_t offset = 0;
+  for (const rtc::Buffer& nalu : nalus) {
+    // Insert nalu start code
+    frame[offset] = 0;
+    frame[offset + 1] = 0;
+    frame[offset + 2] = 1;
+    // Copy the nalu unit.
+    memcpy(frame.data() + offset + 3, nalu.data(), nalu.size());
+    offset += (kStartCodeSize + nalu.size());
+  }
+  return frame;
+}
+
+std::vector<RtpPacketToSend> FetchAllPackets(RtpPacketizerH264* packetizer) {
+  std::vector<RtpPacketToSend> result;
+  size_t num_packets = packetizer->NumPackets();
+  result.reserve(num_packets);
+  RtpPacketToSend packet(kNoExtensions);
+  while (packetizer->NextPacket(&packet)) {
+    result.push_back(packet);
+  }
+  EXPECT_THAT(result, SizeIs(num_packets));
+  return result;
+}
+
+// Tests that should work with both packetization mode 0 and
+// packetization mode 1.
+class RtpPacketizerH264ModeTest
+    : public ::testing::TestWithParam<H264PacketizationMode> {};
+
+TEST_P(RtpPacketizerH264ModeTest, SingleNalu) {
+  const uint8_t frame[] = {0, 0, 1, kIdr, 0xFF};
+
+  RtpPacketizerH264 packetizer(frame, kNoLimits, GetParam());
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(1));
+  EXPECT_THAT(packets[0].payload(), ElementsAre(kIdr, 0xFF));
+}
+
+TEST_P(RtpPacketizerH264ModeTest, SingleNaluTwoPackets) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = kMaxPayloadSize;
+  rtc::Buffer nalus[] = {GenerateNalUnit(kMaxPayloadSize),
+                         GenerateNalUnit(100)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, limits, GetParam());
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(2));
+  EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
+  EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[1]));
+}
+
+TEST_P(RtpPacketizerH264ModeTest,
+       SingleNaluFirstPacketReductionAppliesOnlyToFirstFragment) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 200;
+  limits.first_packet_reduction_len = 5;
+  rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/195),
+                         GenerateNalUnit(/*size=*/200),
+                         GenerateNalUnit(/*size=*/200)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, limits, GetParam());
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(3));
+  EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
+  EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[1]));
+  EXPECT_THAT(packets[2].payload(), ElementsAreArray(nalus[2]));
+}
+
+TEST_P(RtpPacketizerH264ModeTest,
+       SingleNaluLastPacketReductionAppliesOnlyToLastFragment) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 200;
+  limits.last_packet_reduction_len = 5;
+  rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/200),
+                         GenerateNalUnit(/*size=*/200),
+                         GenerateNalUnit(/*size=*/195)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, limits, GetParam());
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(3));
+  EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
+  EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[1]));
+  EXPECT_THAT(packets[2].payload(), ElementsAreArray(nalus[2]));
+}
+
+TEST_P(RtpPacketizerH264ModeTest,
+       SingleNaluFirstAndLastPacketReductionSumsForSinglePacket) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 200;
+  limits.first_packet_reduction_len = 20;
+  limits.last_packet_reduction_len = 30;
+  rtc::Buffer frame = CreateFrame({150});
+
+  RtpPacketizerH264 packetizer(frame, limits, GetParam());
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  EXPECT_THAT(packets, SizeIs(1));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    PacketMode,
+    RtpPacketizerH264ModeTest,
+    ::testing::Values(H264PacketizationMode::SingleNalUnit,
+                      H264PacketizationMode::NonInterleaved));
+
+// Aggregation tests.
+TEST(RtpPacketizerH264Test, StapA) {
+  rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/2),
+                         GenerateNalUnit(/*size=*/2),
+                         GenerateNalUnit(/*size=*/0x123)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, kNoLimits,
+                               H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(1));
+  auto payload = packets[0].payload();
+  EXPECT_EQ(payload.size(),
+            kNalHeaderSize + 3 * kLengthFieldLength + 2 + 2 + 0x123);
+
+  EXPECT_EQ(payload[0], kStapA);
+  payload = payload.subview(kNalHeaderSize);
+  // 1st fragment.
+  EXPECT_THAT(payload.subview(0, kLengthFieldLength),
+              ElementsAre(0, 2));  // Size.
+  EXPECT_THAT(payload.subview(kLengthFieldLength, 2),
+              ElementsAreArray(nalus[0]));
+  payload = payload.subview(kLengthFieldLength + 2);
+  // 2nd fragment.
+  EXPECT_THAT(payload.subview(0, kLengthFieldLength),
+              ElementsAre(0, 2));  // Size.
+  EXPECT_THAT(payload.subview(kLengthFieldLength, 2),
+              ElementsAreArray(nalus[1]));
+  payload = payload.subview(kLengthFieldLength + 2);
+  // 3rd fragment.
+  EXPECT_THAT(payload.subview(0, kLengthFieldLength),
+              ElementsAre(0x1, 0x23));  // Size.
+  EXPECT_THAT(payload.subview(kLengthFieldLength), ElementsAreArray(nalus[2]));
+}
+
+TEST(RtpPacketizerH264Test, SingleNalUnitModeHasNoStapA) {
+  // This is the same setup as for the StapA test.
+  rtc::Buffer frame = CreateFrame({2, 2, 0x123});
+
+  RtpPacketizerH264 packetizer(frame, kNoLimits,
+                               H264PacketizationMode::SingleNalUnit);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  // The three fragments should be returned as three packets.
+  ASSERT_THAT(packets, SizeIs(3));
+  EXPECT_EQ(packets[0].payload_size(), 2u);
+  EXPECT_EQ(packets[1].payload_size(), 2u);
+  EXPECT_EQ(packets[2].payload_size(), 0x123u);
+}
+
+TEST(RtpPacketizerH264Test, StapARespectsFirstPacketReduction) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1000;
+  limits.first_packet_reduction_len = 100;
+  const size_t kFirstFragmentSize =
+      limits.max_payload_len - limits.first_packet_reduction_len;
+  rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/kFirstFragmentSize),
+                         GenerateNalUnit(/*size=*/2),
+                         GenerateNalUnit(/*size=*/2)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, limits,
+                               H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(2));
+  // Expect 1st packet is single nalu.
+  EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
+  // Expect 2nd packet is aggregate of last two fragments.
+  EXPECT_THAT(packets[1].payload(),
+              ElementsAre(kStapA,                          //
+                          0, 2, nalus[1][0], nalus[1][1],  //
+                          0, 2, nalus[2][0], nalus[2][1]));
+}
+
+TEST(RtpPacketizerH264Test, StapARespectsSinglePacketReduction) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1000;
+  // It is possible for single_packet_reduction_len to be greater than
+  // first_packet_reduction_len + last_packet_reduction_len. Check that the
+  // right limit is used when first and last fragment go to one packet.
+  limits.first_packet_reduction_len = 4;
+  limits.last_packet_reduction_len = 0;
+  limits.single_packet_reduction_len = 8;
+  // 3 fragments of sizes 2 + 2 + 981, plus 7 bytes of headers, is expected to
+  // be packetized to single packet of size 992.
+  rtc::Buffer first_nalus[] = {GenerateNalUnit(/*size=*/2),
+                               GenerateNalUnit(/*size=*/2),
+                               GenerateNalUnit(/*size=*/981)};
+  rtc::Buffer first_frame = CreateFrame(first_nalus);
+
+  RtpPacketizerH264 first_packetizer(first_frame, limits,
+                                     H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&first_packetizer);
+
+  // Expect that everything fits in a single packet.
+  ASSERT_THAT(packets, SizeIs(1));
+  EXPECT_EQ(packets[0].payload_size(), 992u);
+
+  // Increasing the last fragment size by one exceeds
+  // single_packet_reduction_len and produces two packets.
+  rtc::Buffer second_nalus[] = {GenerateNalUnit(/*size=*/2),
+                                GenerateNalUnit(/*size=*/2),
+                                GenerateNalUnit(/*size=*/982)};
+  rtc::Buffer second_frame = CreateFrame(second_nalus);
+  RtpPacketizerH264 second_packetizer(second_frame, limits,
+                                      H264PacketizationMode::NonInterleaved);
+  packets = FetchAllPackets(&second_packetizer);
+  ASSERT_THAT(packets, SizeIs(2));
+}
+
+TEST(RtpPacketizerH264Test, StapARespectsLastPacketReduction) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1000;
+  limits.last_packet_reduction_len = 100;
+  const size_t kFirstFragmentSize = 1000;
+  const size_t kLastFragmentSize =
+      limits.max_payload_len - limits.last_packet_reduction_len + 1;
+  rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/kFirstFragmentSize),
+                         GenerateNalUnit(/*size=*/kLastFragmentSize)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, limits,
+                               H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(3));
+  // Expect 1st packet contains first fragment.
+  EXPECT_THAT(packets[0].payload()[0], kSlice);
+  // Expect 2nd and 3rd packets to be FU-A since last_packet_reduction_len
+  // was exceeded by one byte.
+  EXPECT_THAT(packets[1].payload()[0], kFuA);
+  EXPECT_THAT(packets[2].payload()[0], kFuA);
+}
+
+TEST(RtpPacketizerH264Test, TooSmallForStapAHeaders) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1000;
+  const size_t kLastFragmentSize =
+      limits.max_payload_len - 3 * kLengthFieldLength - 4;
+  rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/2),
+                         GenerateNalUnit(/*size=*/2),
+                         GenerateNalUnit(/*size=*/kLastFragmentSize)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, limits,
+                               H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(2));
+  // Expect 1st packet is aggregate of 1st two fragments.
+  EXPECT_THAT(packets[0].payload(),
+              ElementsAre(kStapA,                          //
+                          0, 2, nalus[0][0], nalus[0][1],  //
+                          0, 2, nalus[1][0], nalus[1][1]));
+  // Expect 2nd packet is single nalu.
+  EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[2]));
+}
+
+// Fragmentation + aggregation.
+TEST(RtpPacketizerH264Test, MixedStapAFUA) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 100;
+  const size_t kFuaPayloadSize = 70;
+  const size_t kFuaNaluSize = kNalHeaderSize + 2 * kFuaPayloadSize;
+  const size_t kStapANaluSize = 20;
+  rtc::Buffer nalus[] = {GenerateNalUnit(kFuaNaluSize),
+                         GenerateNalUnit(kStapANaluSize),
+                         GenerateNalUnit(kStapANaluSize)};
+  rtc::Buffer frame = CreateFrame(nalus);
+
+  RtpPacketizerH264 packetizer(frame, limits,
+                               H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  ASSERT_THAT(packets, SizeIs(3));
+  // First expect two FU-A packets.
+  EXPECT_THAT(packets[0].payload().subview(0, kFuAHeaderSize),
+              ElementsAre(kFuA, kH264SBit | nalus[0][0]));
+  EXPECT_THAT(
+      packets[0].payload().subview(kFuAHeaderSize),
+      ElementsAreArray(nalus[0].data() + kNalHeaderSize, kFuaPayloadSize));
+
+  EXPECT_THAT(packets[1].payload().subview(0, kFuAHeaderSize),
+              ElementsAre(kFuA, kH264EBit | nalus[0][0]));
+  EXPECT_THAT(
+      packets[1].payload().subview(kFuAHeaderSize),
+      ElementsAreArray(nalus[0].data() + kNalHeaderSize + kFuaPayloadSize,
+                       kFuaPayloadSize));
+
+  // Then expect one STAP-A packet with two nal units.
+  EXPECT_THAT(packets[2].payload()[0], kStapA);
+  auto payload = packets[2].payload().subview(kNalHeaderSize);
+  EXPECT_THAT(payload.subview(0, kLengthFieldLength),
+              ElementsAre(0, kStapANaluSize));
+  EXPECT_THAT(payload.subview(kLengthFieldLength, kStapANaluSize),
+              ElementsAreArray(nalus[1]));
+  payload = payload.subview(kLengthFieldLength + kStapANaluSize);
+  EXPECT_THAT(payload.subview(0, kLengthFieldLength),
+              ElementsAre(0, kStapANaluSize));
+  EXPECT_THAT(payload.subview(kLengthFieldLength), ElementsAreArray(nalus[2]));
+}
+
+TEST(RtpPacketizerH264Test, LastFragmentFitsInSingleButNotLastPacket) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1178;
+  limits.first_packet_reduction_len = 0;
+  limits.last_packet_reduction_len = 20;
+  limits.single_packet_reduction_len = 20;
+  // Actual sizes, which triggered this bug.
+  rtc::Buffer frame = CreateFrame({20, 8, 18, 1161});
+
+  RtpPacketizerH264 packetizer(frame, limits,
+                               H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  // Last packet has to be of correct size.
+  // Incorrect implementation might miss this constraint and not split the last
+  // fragment in two packets.
+  EXPECT_LE(static_cast<int>(packets.back().payload_size()),
+            limits.max_payload_len - limits.last_packet_reduction_len);
+}
+
+// Splits frame with payload size `frame_payload_size` without fragmentation,
+// Returns sizes of the payloads excluding fua headers.
+std::vector<int> TestFua(size_t frame_payload_size,
+                         const RtpPacketizer::PayloadSizeLimits& limits) {
+  rtc::Buffer nalu[] = {GenerateNalUnit(kNalHeaderSize + frame_payload_size)};
+  rtc::Buffer frame = CreateFrame(nalu);
+
+  RtpPacketizerH264 packetizer(frame, limits,
+                               H264PacketizationMode::NonInterleaved);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  EXPECT_GE(packets.size(), 2u);  // Single packet indicates it is not FuA.
+  std::vector<uint16_t> fua_header;
+  std::vector<int> payload_sizes;
+
+  for (const RtpPacketToSend& packet : packets) {
+    auto payload = packet.payload();
+    EXPECT_GT(payload.size(), kFuAHeaderSize);
+    fua_header.push_back((payload[0] << 8) | payload[1]);
+    payload_sizes.push_back(payload.size() - kFuAHeaderSize);
+  }
+
+  EXPECT_TRUE(fua_header.front() & kH264SBit);
+  EXPECT_TRUE(fua_header.back() & kH264EBit);
+  // Clear S and E bits before testing all are duplicating same original header.
+  fua_header.front() &= ~kH264SBit;
+  fua_header.back() &= ~kH264EBit;
+  EXPECT_THAT(fua_header, Each(Eq((kFuA << 8) | nalu[0][0])));
+
+  return payload_sizes;
+}
+
+// Fragmentation tests.
+TEST(RtpPacketizerH264Test, FUAOddSize) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1200;
+  EXPECT_THAT(TestFua(1200, limits), ElementsAre(600, 600));
+}
+
+TEST(RtpPacketizerH264Test, FUAWithFirstPacketReduction) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1200;
+  limits.first_packet_reduction_len = 4;
+  limits.single_packet_reduction_len = 4;
+  EXPECT_THAT(TestFua(1198, limits), ElementsAre(597, 601));
+}
+
+TEST(RtpPacketizerH264Test, FUAWithLastPacketReduction) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1200;
+  limits.last_packet_reduction_len = 4;
+  limits.single_packet_reduction_len = 4;
+  EXPECT_THAT(TestFua(1198, limits), ElementsAre(601, 597));
+}
+
+TEST(RtpPacketizerH264Test, FUAWithSinglePacketReduction) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1199;
+  limits.single_packet_reduction_len = 200;
+  EXPECT_THAT(TestFua(1000, limits), ElementsAre(500, 500));
+}
+
+TEST(RtpPacketizerH264Test, FUAEvenSize) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1200;
+  EXPECT_THAT(TestFua(1201, limits), ElementsAre(600, 601));
+}
+
+TEST(RtpPacketizerH264Test, FUARounding) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1448;
+  EXPECT_THAT(TestFua(10123, limits),
+              ElementsAre(1265, 1265, 1265, 1265, 1265, 1266, 1266, 1266));
+}
+
+TEST(RtpPacketizerH264Test, FUABig) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  limits.max_payload_len = 1200;
+  // Generate 10 full sized packets, leave room for FU-A headers.
+  EXPECT_THAT(
+      TestFua(10 * (1200 - kFuAHeaderSize), limits),
+      ElementsAre(1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198));
+}
+
+TEST(RtpPacketizerH264Test, RejectsOverlongDataInPacketizationMode0) {
+  RtpPacketizer::PayloadSizeLimits limits;
+  rtc::Buffer frame = CreateFrame({kMaxPayloadSize + 1});
+
+  RtpPacketizerH264 packetizer(frame, limits,
+                               H264PacketizationMode::SingleNalUnit);
+  std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
+
+  EXPECT_THAT(packets, IsEmpty());
+}
+}  // namespace
+}  // namespace webrtc