1 /*
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/rtp_rtcp/source/rtp_format_h264.h"
12
13 #include <memory>
14 #include <vector>
15
16 #include "absl/algorithm/container.h"
17 #include "api/array_view.h"
18 #include "common_video/h264/h264_common.h"
19 #include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
20 #include "modules/rtp_rtcp/source/byte_io.h"
21 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
22 #include "test/gmock.h"
23 #include "test/gtest.h"
24
25 namespace webrtc {
26 namespace {
27
28 using ::testing::Each;
29 using ::testing::ElementsAre;
30 using ::testing::ElementsAreArray;
31 using ::testing::Eq;
32 using ::testing::IsEmpty;
33 using ::testing::SizeIs;
34
35 constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr;
36 constexpr size_t kMaxPayloadSize = 1200;
37 constexpr size_t kLengthFieldLength = 2;
38 constexpr RtpPacketizer::PayloadSizeLimits kNoLimits;
39
40 enum Nalu {
41 kSlice = 1,
42 kIdr = 5,
43 kSei = 6,
44 kSps = 7,
45 kPps = 8,
46 kStapA = 24,
47 kFuA = 28
48 };
49
50 static const size_t kNalHeaderSize = 1;
51 static const size_t kFuAHeaderSize = 2;
52
53 // Creates Buffer that looks like nal unit of given size.
GenerateNalUnit(size_t size)54 rtc::Buffer GenerateNalUnit(size_t size) {
55 RTC_CHECK_GT(size, 0);
56 rtc::Buffer buffer(size);
57 // Set some valid header.
58 buffer[0] = kSlice;
59 for (size_t i = 1; i < size; ++i) {
60 buffer[i] = static_cast<uint8_t>(i);
61 }
62 // Last byte shouldn't be 0, or it may be counted as part of next 4-byte start
63 // sequence.
64 buffer[size - 1] |= 0x10;
65 return buffer;
66 }
67
68 // Create frame consisting of nalus of given size.
CreateFrame(std::initializer_list<size_t> nalu_sizes)69 rtc::Buffer CreateFrame(std::initializer_list<size_t> nalu_sizes) {
70 static constexpr int kStartCodeSize = 3;
71 rtc::Buffer frame(absl::c_accumulate(nalu_sizes, 0) +
72 kStartCodeSize * nalu_sizes.size());
73 size_t offset = 0;
74 for (size_t nalu_size : nalu_sizes) {
75 EXPECT_GE(nalu_size, 1u);
76 // Insert nalu start code
77 frame[offset] = 0;
78 frame[offset + 1] = 0;
79 frame[offset + 2] = 1;
80 // Set some valid header.
81 frame[offset + 3] = 1;
82 // Fill payload avoiding accidental start codes
83 if (nalu_size > 1) {
84 memset(frame.data() + offset + 4, 0x3f, nalu_size - 1);
85 }
86 offset += (kStartCodeSize + nalu_size);
87 }
88 return frame;
89 }
90
91 // Create frame consisting of given nalus.
CreateFrame(rtc::ArrayView<const rtc::Buffer> nalus)92 rtc::Buffer CreateFrame(rtc::ArrayView<const rtc::Buffer> nalus) {
93 static constexpr int kStartCodeSize = 3;
94 int frame_size = 0;
95 for (const rtc::Buffer& nalu : nalus) {
96 frame_size += (kStartCodeSize + nalu.size());
97 }
98 rtc::Buffer frame(frame_size);
99 size_t offset = 0;
100 for (const rtc::Buffer& nalu : nalus) {
101 // Insert nalu start code
102 frame[offset] = 0;
103 frame[offset + 1] = 0;
104 frame[offset + 2] = 1;
105 // Copy the nalu unit.
106 memcpy(frame.data() + offset + 3, nalu.data(), nalu.size());
107 offset += (kStartCodeSize + nalu.size());
108 }
109 return frame;
110 }
111
FetchAllPackets(RtpPacketizerH264 * packetizer)112 std::vector<RtpPacketToSend> FetchAllPackets(RtpPacketizerH264* packetizer) {
113 std::vector<RtpPacketToSend> result;
114 size_t num_packets = packetizer->NumPackets();
115 result.reserve(num_packets);
116 RtpPacketToSend packet(kNoExtensions);
117 while (packetizer->NextPacket(&packet)) {
118 result.push_back(packet);
119 }
120 EXPECT_THAT(result, SizeIs(num_packets));
121 return result;
122 }
123
124 // Tests that should work with both packetization mode 0 and
125 // packetization mode 1.
126 class RtpPacketizerH264ModeTest
127 : public ::testing::TestWithParam<H264PacketizationMode> {};
128
TEST_P(RtpPacketizerH264ModeTest,SingleNalu)129 TEST_P(RtpPacketizerH264ModeTest, SingleNalu) {
130 const uint8_t frame[] = {0, 0, 1, kIdr, 0xFF};
131
132 RtpPacketizerH264 packetizer(frame, kNoLimits, GetParam());
133 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
134
135 ASSERT_THAT(packets, SizeIs(1));
136 EXPECT_THAT(packets[0].payload(), ElementsAre(kIdr, 0xFF));
137 }
138
TEST_P(RtpPacketizerH264ModeTest,SingleNaluTwoPackets)139 TEST_P(RtpPacketizerH264ModeTest, SingleNaluTwoPackets) {
140 RtpPacketizer::PayloadSizeLimits limits;
141 limits.max_payload_len = kMaxPayloadSize;
142 rtc::Buffer nalus[] = {GenerateNalUnit(kMaxPayloadSize),
143 GenerateNalUnit(100)};
144 rtc::Buffer frame = CreateFrame(nalus);
145
146 RtpPacketizerH264 packetizer(frame, limits, GetParam());
147 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
148
149 ASSERT_THAT(packets, SizeIs(2));
150 EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
151 EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[1]));
152 }
153
TEST_P(RtpPacketizerH264ModeTest,SingleNaluFirstPacketReductionAppliesOnlyToFirstFragment)154 TEST_P(RtpPacketizerH264ModeTest,
155 SingleNaluFirstPacketReductionAppliesOnlyToFirstFragment) {
156 RtpPacketizer::PayloadSizeLimits limits;
157 limits.max_payload_len = 200;
158 limits.first_packet_reduction_len = 5;
159 rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/195),
160 GenerateNalUnit(/*size=*/200),
161 GenerateNalUnit(/*size=*/200)};
162 rtc::Buffer frame = CreateFrame(nalus);
163
164 RtpPacketizerH264 packetizer(frame, limits, GetParam());
165 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
166
167 ASSERT_THAT(packets, SizeIs(3));
168 EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
169 EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[1]));
170 EXPECT_THAT(packets[2].payload(), ElementsAreArray(nalus[2]));
171 }
172
TEST_P(RtpPacketizerH264ModeTest,SingleNaluLastPacketReductionAppliesOnlyToLastFragment)173 TEST_P(RtpPacketizerH264ModeTest,
174 SingleNaluLastPacketReductionAppliesOnlyToLastFragment) {
175 RtpPacketizer::PayloadSizeLimits limits;
176 limits.max_payload_len = 200;
177 limits.last_packet_reduction_len = 5;
178 rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/200),
179 GenerateNalUnit(/*size=*/200),
180 GenerateNalUnit(/*size=*/195)};
181 rtc::Buffer frame = CreateFrame(nalus);
182
183 RtpPacketizerH264 packetizer(frame, limits, GetParam());
184 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
185
186 ASSERT_THAT(packets, SizeIs(3));
187 EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
188 EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[1]));
189 EXPECT_THAT(packets[2].payload(), ElementsAreArray(nalus[2]));
190 }
191
TEST_P(RtpPacketizerH264ModeTest,SingleNaluFirstAndLastPacketReductionSumsForSinglePacket)192 TEST_P(RtpPacketizerH264ModeTest,
193 SingleNaluFirstAndLastPacketReductionSumsForSinglePacket) {
194 RtpPacketizer::PayloadSizeLimits limits;
195 limits.max_payload_len = 200;
196 limits.first_packet_reduction_len = 20;
197 limits.last_packet_reduction_len = 30;
198 rtc::Buffer frame = CreateFrame({150});
199
200 RtpPacketizerH264 packetizer(frame, limits, GetParam());
201 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
202
203 EXPECT_THAT(packets, SizeIs(1));
204 }
205
206 INSTANTIATE_TEST_SUITE_P(
207 PacketMode,
208 RtpPacketizerH264ModeTest,
209 ::testing::Values(H264PacketizationMode::SingleNalUnit,
210 H264PacketizationMode::NonInterleaved));
211
212 // Aggregation tests.
TEST(RtpPacketizerH264Test,StapA)213 TEST(RtpPacketizerH264Test, StapA) {
214 rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/2),
215 GenerateNalUnit(/*size=*/2),
216 GenerateNalUnit(/*size=*/0x123)};
217 rtc::Buffer frame = CreateFrame(nalus);
218
219 RtpPacketizerH264 packetizer(frame, kNoLimits,
220 H264PacketizationMode::NonInterleaved);
221 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
222
223 ASSERT_THAT(packets, SizeIs(1));
224 auto payload = packets[0].payload();
225 EXPECT_EQ(payload.size(),
226 kNalHeaderSize + 3 * kLengthFieldLength + 2 + 2 + 0x123);
227
228 EXPECT_EQ(payload[0], kStapA);
229 payload = payload.subview(kNalHeaderSize);
230 // 1st fragment.
231 EXPECT_THAT(payload.subview(0, kLengthFieldLength),
232 ElementsAre(0, 2)); // Size.
233 EXPECT_THAT(payload.subview(kLengthFieldLength, 2),
234 ElementsAreArray(nalus[0]));
235 payload = payload.subview(kLengthFieldLength + 2);
236 // 2nd fragment.
237 EXPECT_THAT(payload.subview(0, kLengthFieldLength),
238 ElementsAre(0, 2)); // Size.
239 EXPECT_THAT(payload.subview(kLengthFieldLength, 2),
240 ElementsAreArray(nalus[1]));
241 payload = payload.subview(kLengthFieldLength + 2);
242 // 3rd fragment.
243 EXPECT_THAT(payload.subview(0, kLengthFieldLength),
244 ElementsAre(0x1, 0x23)); // Size.
245 EXPECT_THAT(payload.subview(kLengthFieldLength), ElementsAreArray(nalus[2]));
246 }
247
TEST(RtpPacketizerH264Test,SingleNalUnitModeHasNoStapA)248 TEST(RtpPacketizerH264Test, SingleNalUnitModeHasNoStapA) {
249 // This is the same setup as for the StapA test.
250 rtc::Buffer frame = CreateFrame({2, 2, 0x123});
251
252 RtpPacketizerH264 packetizer(frame, kNoLimits,
253 H264PacketizationMode::SingleNalUnit);
254 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
255
256 // The three fragments should be returned as three packets.
257 ASSERT_THAT(packets, SizeIs(3));
258 EXPECT_EQ(packets[0].payload_size(), 2u);
259 EXPECT_EQ(packets[1].payload_size(), 2u);
260 EXPECT_EQ(packets[2].payload_size(), 0x123u);
261 }
262
TEST(RtpPacketizerH264Test,StapARespectsFirstPacketReduction)263 TEST(RtpPacketizerH264Test, StapARespectsFirstPacketReduction) {
264 RtpPacketizer::PayloadSizeLimits limits;
265 limits.max_payload_len = 1000;
266 limits.first_packet_reduction_len = 100;
267 const size_t kFirstFragmentSize =
268 limits.max_payload_len - limits.first_packet_reduction_len;
269 rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/kFirstFragmentSize),
270 GenerateNalUnit(/*size=*/2),
271 GenerateNalUnit(/*size=*/2)};
272 rtc::Buffer frame = CreateFrame(nalus);
273
274 RtpPacketizerH264 packetizer(frame, limits,
275 H264PacketizationMode::NonInterleaved);
276 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
277
278 ASSERT_THAT(packets, SizeIs(2));
279 // Expect 1st packet is single nalu.
280 EXPECT_THAT(packets[0].payload(), ElementsAreArray(nalus[0]));
281 // Expect 2nd packet is aggregate of last two fragments.
282 EXPECT_THAT(packets[1].payload(),
283 ElementsAre(kStapA, //
284 0, 2, nalus[1][0], nalus[1][1], //
285 0, 2, nalus[2][0], nalus[2][1]));
286 }
287
TEST(RtpPacketizerH264Test,StapARespectsLastPacketReduction)288 TEST(RtpPacketizerH264Test, StapARespectsLastPacketReduction) {
289 RtpPacketizer::PayloadSizeLimits limits;
290 limits.max_payload_len = 1000;
291 limits.last_packet_reduction_len = 100;
292 const size_t kLastFragmentSize =
293 limits.max_payload_len - limits.last_packet_reduction_len;
294 rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/2),
295 GenerateNalUnit(/*size=*/2),
296 GenerateNalUnit(/*size=*/kLastFragmentSize)};
297 rtc::Buffer frame = CreateFrame(nalus);
298
299 RtpPacketizerH264 packetizer(frame, limits,
300 H264PacketizationMode::NonInterleaved);
301 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
302
303 ASSERT_THAT(packets, SizeIs(2));
304 // Expect 1st packet is aggregate of 1st two fragments.
305 EXPECT_THAT(packets[0].payload(),
306 ElementsAre(kStapA, //
307 0, 2, nalus[0][0], nalus[0][1], //
308 0, 2, nalus[1][0], nalus[1][1]));
309 // Expect 2nd packet is single nalu.
310 EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[2]));
311 }
312
TEST(RtpPacketizerH264Test,TooSmallForStapAHeaders)313 TEST(RtpPacketizerH264Test, TooSmallForStapAHeaders) {
314 RtpPacketizer::PayloadSizeLimits limits;
315 limits.max_payload_len = 1000;
316 const size_t kLastFragmentSize =
317 limits.max_payload_len - 3 * kLengthFieldLength - 4;
318 rtc::Buffer nalus[] = {GenerateNalUnit(/*size=*/2),
319 GenerateNalUnit(/*size=*/2),
320 GenerateNalUnit(/*size=*/kLastFragmentSize)};
321 rtc::Buffer frame = CreateFrame(nalus);
322
323 RtpPacketizerH264 packetizer(frame, limits,
324 H264PacketizationMode::NonInterleaved);
325 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
326
327 ASSERT_THAT(packets, SizeIs(2));
328 // Expect 1st packet is aggregate of 1st two fragments.
329 EXPECT_THAT(packets[0].payload(),
330 ElementsAre(kStapA, //
331 0, 2, nalus[0][0], nalus[0][1], //
332 0, 2, nalus[1][0], nalus[1][1]));
333 // Expect 2nd packet is single nalu.
334 EXPECT_THAT(packets[1].payload(), ElementsAreArray(nalus[2]));
335 }
336
337 // Fragmentation + aggregation.
TEST(RtpPacketizerH264Test,MixedStapAFUA)338 TEST(RtpPacketizerH264Test, MixedStapAFUA) {
339 RtpPacketizer::PayloadSizeLimits limits;
340 limits.max_payload_len = 100;
341 const size_t kFuaPayloadSize = 70;
342 const size_t kFuaNaluSize = kNalHeaderSize + 2 * kFuaPayloadSize;
343 const size_t kStapANaluSize = 20;
344 rtc::Buffer nalus[] = {GenerateNalUnit(kFuaNaluSize),
345 GenerateNalUnit(kStapANaluSize),
346 GenerateNalUnit(kStapANaluSize)};
347 rtc::Buffer frame = CreateFrame(nalus);
348
349 RtpPacketizerH264 packetizer(frame, limits,
350 H264PacketizationMode::NonInterleaved);
351 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
352
353 ASSERT_THAT(packets, SizeIs(3));
354 // First expect two FU-A packets.
355 EXPECT_THAT(packets[0].payload().subview(0, kFuAHeaderSize),
356 ElementsAre(kFuA, kH264SBit | nalus[0][0]));
357 EXPECT_THAT(
358 packets[0].payload().subview(kFuAHeaderSize),
359 ElementsAreArray(nalus[0].data() + kNalHeaderSize, kFuaPayloadSize));
360
361 EXPECT_THAT(packets[1].payload().subview(0, kFuAHeaderSize),
362 ElementsAre(kFuA, kH264EBit | nalus[0][0]));
363 EXPECT_THAT(
364 packets[1].payload().subview(kFuAHeaderSize),
365 ElementsAreArray(nalus[0].data() + kNalHeaderSize + kFuaPayloadSize,
366 kFuaPayloadSize));
367
368 // Then expect one STAP-A packet with two nal units.
369 EXPECT_THAT(packets[2].payload()[0], kStapA);
370 auto payload = packets[2].payload().subview(kNalHeaderSize);
371 EXPECT_THAT(payload.subview(0, kLengthFieldLength),
372 ElementsAre(0, kStapANaluSize));
373 EXPECT_THAT(payload.subview(kLengthFieldLength, kStapANaluSize),
374 ElementsAreArray(nalus[1]));
375 payload = payload.subview(kLengthFieldLength + kStapANaluSize);
376 EXPECT_THAT(payload.subview(0, kLengthFieldLength),
377 ElementsAre(0, kStapANaluSize));
378 EXPECT_THAT(payload.subview(kLengthFieldLength), ElementsAreArray(nalus[2]));
379 }
380
TEST(RtpPacketizerH264Test,LastFragmentFitsInSingleButNotLastPacket)381 TEST(RtpPacketizerH264Test, LastFragmentFitsInSingleButNotLastPacket) {
382 RtpPacketizer::PayloadSizeLimits limits;
383 limits.max_payload_len = 1178;
384 limits.first_packet_reduction_len = 0;
385 limits.last_packet_reduction_len = 20;
386 limits.single_packet_reduction_len = 20;
387 // Actual sizes, which triggered this bug.
388 rtc::Buffer frame = CreateFrame({20, 8, 18, 1161});
389
390 RtpPacketizerH264 packetizer(frame, limits,
391 H264PacketizationMode::NonInterleaved);
392 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
393
394 // Last packet has to be of correct size.
395 // Incorrect implementation might miss this constraint and not split the last
396 // fragment in two packets.
397 EXPECT_LE(static_cast<int>(packets.back().payload_size()),
398 limits.max_payload_len - limits.last_packet_reduction_len);
399 }
400
401 // Splits frame with payload size `frame_payload_size` without fragmentation,
402 // Returns sizes of the payloads excluding fua headers.
TestFua(size_t frame_payload_size,const RtpPacketizer::PayloadSizeLimits & limits)403 std::vector<int> TestFua(size_t frame_payload_size,
404 const RtpPacketizer::PayloadSizeLimits& limits) {
405 rtc::Buffer nalu[] = {GenerateNalUnit(kNalHeaderSize + frame_payload_size)};
406 rtc::Buffer frame = CreateFrame(nalu);
407
408 RtpPacketizerH264 packetizer(frame, limits,
409 H264PacketizationMode::NonInterleaved);
410 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
411
412 EXPECT_GE(packets.size(), 2u); // Single packet indicates it is not FuA.
413 std::vector<uint16_t> fua_header;
414 std::vector<int> payload_sizes;
415
416 for (const RtpPacketToSend& packet : packets) {
417 auto payload = packet.payload();
418 EXPECT_GT(payload.size(), kFuAHeaderSize);
419 fua_header.push_back((payload[0] << 8) | payload[1]);
420 payload_sizes.push_back(payload.size() - kFuAHeaderSize);
421 }
422
423 EXPECT_TRUE(fua_header.front() & kH264SBit);
424 EXPECT_TRUE(fua_header.back() & kH264EBit);
425 // Clear S and E bits before testing all are duplicating same original header.
426 fua_header.front() &= ~kH264SBit;
427 fua_header.back() &= ~kH264EBit;
428 EXPECT_THAT(fua_header, Each(Eq((kFuA << 8) | nalu[0][0])));
429
430 return payload_sizes;
431 }
432
433 // Fragmentation tests.
TEST(RtpPacketizerH264Test,FUAOddSize)434 TEST(RtpPacketizerH264Test, FUAOddSize) {
435 RtpPacketizer::PayloadSizeLimits limits;
436 limits.max_payload_len = 1200;
437 EXPECT_THAT(TestFua(1200, limits), ElementsAre(600, 600));
438 }
439
TEST(RtpPacketizerH264Test,FUAWithFirstPacketReduction)440 TEST(RtpPacketizerH264Test, FUAWithFirstPacketReduction) {
441 RtpPacketizer::PayloadSizeLimits limits;
442 limits.max_payload_len = 1200;
443 limits.first_packet_reduction_len = 4;
444 limits.single_packet_reduction_len = 4;
445 EXPECT_THAT(TestFua(1198, limits), ElementsAre(597, 601));
446 }
447
TEST(RtpPacketizerH264Test,FUAWithLastPacketReduction)448 TEST(RtpPacketizerH264Test, FUAWithLastPacketReduction) {
449 RtpPacketizer::PayloadSizeLimits limits;
450 limits.max_payload_len = 1200;
451 limits.last_packet_reduction_len = 4;
452 limits.single_packet_reduction_len = 4;
453 EXPECT_THAT(TestFua(1198, limits), ElementsAre(601, 597));
454 }
455
TEST(RtpPacketizerH264Test,FUAWithSinglePacketReduction)456 TEST(RtpPacketizerH264Test, FUAWithSinglePacketReduction) {
457 RtpPacketizer::PayloadSizeLimits limits;
458 limits.max_payload_len = 1199;
459 limits.single_packet_reduction_len = 200;
460 EXPECT_THAT(TestFua(1000, limits), ElementsAre(500, 500));
461 }
462
TEST(RtpPacketizerH264Test,FUAEvenSize)463 TEST(RtpPacketizerH264Test, FUAEvenSize) {
464 RtpPacketizer::PayloadSizeLimits limits;
465 limits.max_payload_len = 1200;
466 EXPECT_THAT(TestFua(1201, limits), ElementsAre(600, 601));
467 }
468
TEST(RtpPacketizerH264Test,FUARounding)469 TEST(RtpPacketizerH264Test, FUARounding) {
470 RtpPacketizer::PayloadSizeLimits limits;
471 limits.max_payload_len = 1448;
472 EXPECT_THAT(TestFua(10123, limits),
473 ElementsAre(1265, 1265, 1265, 1265, 1265, 1266, 1266, 1266));
474 }
475
TEST(RtpPacketizerH264Test,FUABig)476 TEST(RtpPacketizerH264Test, FUABig) {
477 RtpPacketizer::PayloadSizeLimits limits;
478 limits.max_payload_len = 1200;
479 // Generate 10 full sized packets, leave room for FU-A headers.
480 EXPECT_THAT(
481 TestFua(10 * (1200 - kFuAHeaderSize), limits),
482 ElementsAre(1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198, 1198));
483 }
484
TEST(RtpPacketizerH264Test,RejectsOverlongDataInPacketizationMode0)485 TEST(RtpPacketizerH264Test, RejectsOverlongDataInPacketizationMode0) {
486 RtpPacketizer::PayloadSizeLimits limits;
487 rtc::Buffer frame = CreateFrame({kMaxPayloadSize + 1});
488
489 RtpPacketizerH264 packetizer(frame, limits,
490 H264PacketizationMode::SingleNalUnit);
491 std::vector<RtpPacketToSend> packets = FetchAllPackets(&packetizer);
492
493 EXPECT_THAT(packets, IsEmpty());
494 }
495 } // namespace
496 } // namespace webrtc
497