rtp_format_h264_unittest.cc revision 730d2707713c4240070af17e56edd10d039bafd2 
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 <vector>
12
13#include "testing/gmock/include/gmock/gmock.h"
14#include "testing/gtest/include/gtest/gtest.h"
15#include "webrtc/modules/interface/module_common_types.h"
16#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
17#include "webrtc/modules/rtp_rtcp/source/rtp_format.h"
18#include "webrtc/system_wrappers/interface/scoped_ptr.h"
19
20namespace webrtc {
21namespace {
22const size_t kMaxPayloadSize = 1200;
23const size_t kLengthFieldLength = 2;
24
25enum Nalu {
26  kSlice = 1,
27  kIdr = 5,
28  kSei = 6,
29  kSps = 7,
30  kPps = 8,
31  kStapA = 24,
32  kFuA = 28
33};
34
35static const size_t kNalHeaderSize = 1;
36static const size_t kFuAHeaderSize = 2;
37
38// Bit masks for FU (A and B) indicators.
39enum NalDefs { kFBit = 0x80, kNriMask = 0x60, kTypeMask = 0x1F };
40
41// Bit masks for FU (A and B) headers.
42enum FuDefs { kSBit = 0x80, kEBit = 0x40, kRBit = 0x20 };
43
44void VerifyFua(size_t fua_index,
45               const uint8_t* expected_payload,
46               int offset,
47               const uint8_t* packet,
48               size_t length,
49               const std::vector<size_t>& expected_sizes) {
50  ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, length)
51      << "FUA index: " << fua_index;
52  const uint8_t kFuIndicator = 0x1C;  // F=0, NRI=0, Type=28.
53  EXPECT_EQ(kFuIndicator, packet[0]) << "FUA index: " << fua_index;
54  bool should_be_last_fua = (fua_index == expected_sizes.size() - 1);
55  uint8_t fu_header = 0;
56  if (fua_index == 0)
57    fu_header = 0x85;  // S=1, E=0, R=0, Type=5.
58  else if (should_be_last_fua)
59    fu_header = 0x45;  // S=0, E=1, R=0, Type=5.
60  else
61    fu_header = 0x05;  // S=0, E=0, R=0, Type=5.
62  EXPECT_EQ(fu_header, packet[1]) << "FUA index: " << fua_index;
63  std::vector<uint8_t> expected_packet_payload(
64      &expected_payload[offset],
65      &expected_payload[offset + expected_sizes[fua_index]]);
66  EXPECT_THAT(
67      expected_packet_payload,
68      ::testing::ElementsAreArray(&packet[2], expected_sizes[fua_index]))
69      << "FUA index: " << fua_index;
70}
71
72void TestFua(size_t frame_size,
73             size_t max_payload_size,
74             const std::vector<size_t>& expected_sizes) {
75  scoped_ptr<uint8_t[]> frame;
76  frame.reset(new uint8_t[frame_size]);
77  frame[0] = 0x05;  // F=0, NRI=0, Type=5.
78  for (size_t i = 0; i < frame_size - kNalHeaderSize; ++i) {
79    frame[i + kNalHeaderSize] = i;
80  }
81  RTPFragmentationHeader fragmentation;
82  fragmentation.VerifyAndAllocateFragmentationHeader(1);
83  fragmentation.fragmentationOffset[0] = 0;
84  fragmentation.fragmentationLength[0] = frame_size;
85  scoped_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
86      kRtpVideoH264, max_payload_size, NULL, kFrameEmpty));
87  packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation);
88
89  scoped_ptr<uint8_t[]> packet(new uint8_t[max_payload_size]);
90  size_t length = 0;
91  bool last = false;
92  size_t offset = kNalHeaderSize;
93  for (size_t i = 0; i < expected_sizes.size(); ++i) {
94    ASSERT_TRUE(packetizer->NextPacket(packet.get(), &length, &last));
95    VerifyFua(i, frame.get(), offset, packet.get(), length, expected_sizes);
96    EXPECT_EQ(i == expected_sizes.size() - 1, last) << "FUA index: " << i;
97    offset += expected_sizes[i];
98  }
99
100  EXPECT_FALSE(packetizer->NextPacket(packet.get(), &length, &last));
101}
102
103size_t GetExpectedNaluOffset(const RTPFragmentationHeader& fragmentation,
104                             size_t start_index,
105                             size_t nalu_index) {
106  assert(nalu_index < fragmentation.fragmentationVectorSize);
107  size_t expected_nalu_offset = kNalHeaderSize;  // STAP-A header.
108  for (size_t i = start_index; i < nalu_index; ++i) {
109    expected_nalu_offset +=
110        kLengthFieldLength + fragmentation.fragmentationLength[i];
111  }
112  return expected_nalu_offset;
113}
114
115void VerifyStapAPayload(const RTPFragmentationHeader& fragmentation,
116                        size_t first_stapa_index,
117                        size_t nalu_index,
118                        const uint8_t* frame,
119                        size_t frame_length,
120                        const uint8_t* packet,
121                        size_t packet_length) {
122  size_t expected_payload_offset =
123      GetExpectedNaluOffset(fragmentation, first_stapa_index, nalu_index) +
124      kLengthFieldLength;
125  size_t offset = fragmentation.fragmentationOffset[nalu_index];
126  const uint8_t* expected_payload = &frame[offset];
127  size_t expected_payload_length =
128      fragmentation.fragmentationLength[nalu_index];
129  ASSERT_LE(offset + expected_payload_length, frame_length);
130  ASSERT_LE(expected_payload_offset + expected_payload_length, packet_length);
131  std::vector<uint8_t> expected_payload_vector(
132      expected_payload, &expected_payload[expected_payload_length]);
133  EXPECT_THAT(expected_payload_vector,
134              ::testing::ElementsAreArray(&packet[expected_payload_offset],
135                                          expected_payload_length));
136}
137
138void VerifySingleNaluPayload(const RTPFragmentationHeader& fragmentation,
139                             size_t nalu_index,
140                             const uint8_t* frame,
141                             size_t frame_length,
142                             const uint8_t* packet,
143                             size_t packet_length) {
144  std::vector<uint8_t> expected_payload_vector(
145      &frame[fragmentation.fragmentationOffset[nalu_index]],
146      &frame[fragmentation.fragmentationOffset[nalu_index] +
147             fragmentation.fragmentationLength[nalu_index]]);
148  EXPECT_THAT(expected_payload_vector,
149              ::testing::ElementsAreArray(packet, packet_length));
150}
151}  // namespace
152
153TEST(RtpPacketizerH264Test, TestSingleNalu) {
154  const uint8_t frame[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5.
155  RTPFragmentationHeader fragmentation;
156  fragmentation.VerifyAndAllocateFragmentationHeader(1);
157  fragmentation.fragmentationOffset[0] = 0;
158  fragmentation.fragmentationLength[0] = sizeof(frame);
159  scoped_ptr<RtpPacketizer> packetizer(
160      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kFrameEmpty));
161  packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation);
162  uint8_t packet[kMaxPayloadSize] = {0};
163  size_t length = 0;
164  bool last = false;
165  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
166  EXPECT_EQ(2u, length);
167  EXPECT_TRUE(last);
168  VerifySingleNaluPayload(
169      fragmentation, 0, frame, sizeof(frame), packet, length);
170  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
171}
172
173TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) {
174  const size_t kFrameSize = kMaxPayloadSize + 100;
175  uint8_t frame[kFrameSize] = {0};
176  for (size_t i = 0; i < kFrameSize; ++i)
177    frame[i] = i;
178  RTPFragmentationHeader fragmentation;
179  fragmentation.VerifyAndAllocateFragmentationHeader(2);
180  fragmentation.fragmentationOffset[0] = 0;
181  fragmentation.fragmentationLength[0] = kMaxPayloadSize;
182  fragmentation.fragmentationOffset[1] = kMaxPayloadSize;
183  fragmentation.fragmentationLength[1] = 100;
184  // Set NAL headers.
185  frame[fragmentation.fragmentationOffset[0]] = 0x01;
186  frame[fragmentation.fragmentationOffset[1]] = 0x01;
187
188  scoped_ptr<RtpPacketizer> packetizer(
189      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kFrameEmpty));
190  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
191
192  uint8_t packet[kMaxPayloadSize] = {0};
193  size_t length = 0;
194  bool last = false;
195  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
196  ASSERT_EQ(fragmentation.fragmentationOffset[1], length);
197  VerifySingleNaluPayload(fragmentation, 0, frame, kFrameSize, packet, length);
198
199  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
200  ASSERT_EQ(fragmentation.fragmentationLength[1], length);
201  VerifySingleNaluPayload(fragmentation, 1, frame, kFrameSize, packet, length);
202  EXPECT_TRUE(last);
203
204  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
205}
206
207TEST(RtpPacketizerH264Test, TestStapA) {
208  const size_t kFrameSize =
209      kMaxPayloadSize - 3 * kLengthFieldLength - kNalHeaderSize;
210  uint8_t frame[kFrameSize] = {0x07, 0xFF,  // F=0, NRI=0, Type=7.
211                               0x08, 0xFF,  // F=0, NRI=0, Type=8.
212                               0x05};       // F=0, NRI=0, Type=5.
213  const size_t kPayloadOffset = 5;
214  for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i)
215    frame[i + kPayloadOffset] = i;
216  RTPFragmentationHeader fragmentation;
217  fragmentation.VerifyAndAllocateFragmentationHeader(3);
218  fragmentation.fragmentationOffset[0] = 0;
219  fragmentation.fragmentationLength[0] = 2;
220  fragmentation.fragmentationOffset[1] = 2;
221  fragmentation.fragmentationLength[1] = 2;
222  fragmentation.fragmentationOffset[2] = 4;
223  fragmentation.fragmentationLength[2] =
224      kNalHeaderSize + kFrameSize - kPayloadOffset;
225  scoped_ptr<RtpPacketizer> packetizer(
226      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kFrameEmpty));
227  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
228
229  uint8_t packet[kMaxPayloadSize] = {0};
230  size_t length = 0;
231  bool last = false;
232  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
233  size_t expected_packet_size =
234      kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize;
235  ASSERT_EQ(expected_packet_size, length);
236  EXPECT_TRUE(last);
237  for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i)
238    VerifyStapAPayload(fragmentation, 0, i, frame, kFrameSize, packet, length);
239
240  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
241}
242
243TEST(RtpPacketizerH264Test, TestTooSmallForStapAHeaders) {
244  const size_t kFrameSize = kMaxPayloadSize - 1;
245  uint8_t frame[kFrameSize] = {0x07, 0xFF,  // F=0, NRI=0, Type=7.
246                               0x08, 0xFF,  // F=0, NRI=0, Type=8.
247                               0x05};       // F=0, NRI=0, Type=5.
248  const size_t kPayloadOffset = 5;
249  for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i)
250    frame[i + kPayloadOffset] = i;
251  RTPFragmentationHeader fragmentation;
252  fragmentation.VerifyAndAllocateFragmentationHeader(3);
253  fragmentation.fragmentationOffset[0] = 0;
254  fragmentation.fragmentationLength[0] = 2;
255  fragmentation.fragmentationOffset[1] = 2;
256  fragmentation.fragmentationLength[1] = 2;
257  fragmentation.fragmentationOffset[2] = 4;
258  fragmentation.fragmentationLength[2] =
259      kNalHeaderSize + kFrameSize - kPayloadOffset;
260  scoped_ptr<RtpPacketizer> packetizer(
261      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kFrameEmpty));
262  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
263
264  uint8_t packet[kMaxPayloadSize] = {0};
265  size_t length = 0;
266  bool last = false;
267  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
268  size_t expected_packet_size = kNalHeaderSize;
269  for (size_t i = 0; i < 2; ++i) {
270    expected_packet_size +=
271        kLengthFieldLength + fragmentation.fragmentationLength[i];
272  }
273  ASSERT_EQ(expected_packet_size, length);
274  EXPECT_FALSE(last);
275  for (size_t i = 0; i < 2; ++i)
276    VerifyStapAPayload(fragmentation, 0, i, frame, kFrameSize, packet, length);
277
278  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
279  expected_packet_size = fragmentation.fragmentationLength[2];
280  ASSERT_EQ(expected_packet_size, length);
281  EXPECT_TRUE(last);
282  VerifySingleNaluPayload(fragmentation, 2, frame, kFrameSize, packet, length);
283
284  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
285}
286
287TEST(RtpPacketizerH264Test, TestMixedStapA_FUA) {
288  const size_t kFuaNaluSize = 2 * (kMaxPayloadSize - 100);
289  const size_t kStapANaluSize = 100;
290  RTPFragmentationHeader fragmentation;
291  fragmentation.VerifyAndAllocateFragmentationHeader(3);
292  fragmentation.fragmentationOffset[0] = 0;
293  fragmentation.fragmentationLength[0] = kFuaNaluSize;
294  fragmentation.fragmentationOffset[1] = kFuaNaluSize;
295  fragmentation.fragmentationLength[1] = kStapANaluSize;
296  fragmentation.fragmentationOffset[2] = kFuaNaluSize + kStapANaluSize;
297  fragmentation.fragmentationLength[2] = kStapANaluSize;
298  const size_t kFrameSize = kFuaNaluSize + 2 * kStapANaluSize;
299  uint8_t frame[kFrameSize];
300  size_t nalu_offset = 0;
301  for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) {
302    nalu_offset = fragmentation.fragmentationOffset[i];
303    frame[nalu_offset] = 0x05;  // F=0, NRI=0, Type=5.
304    for (size_t j = 1; j < fragmentation.fragmentationLength[i]; ++j) {
305      frame[nalu_offset + j] = i + j;
306    }
307  }
308  scoped_ptr<RtpPacketizer> packetizer(
309      RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kFrameEmpty));
310  packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
311
312  // First expecting two FU-A packets.
313  std::vector<size_t> fua_sizes;
314  fua_sizes.push_back(1100);
315  fua_sizes.push_back(1099);
316  uint8_t packet[kMaxPayloadSize] = {0};
317  size_t length = 0;
318  bool last = false;
319  int fua_offset = kNalHeaderSize;
320  for (size_t i = 0; i < 2; ++i) {
321    ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
322    VerifyFua(i, frame, fua_offset, packet, length, fua_sizes);
323    EXPECT_FALSE(last);
324    fua_offset += fua_sizes[i];
325  }
326  // Then expecting one STAP-A packet with two nal units.
327  ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
328  size_t expected_packet_size =
329      kNalHeaderSize + 2 * kLengthFieldLength + 2 * kStapANaluSize;
330  ASSERT_EQ(expected_packet_size, length);
331  EXPECT_TRUE(last);
332  for (size_t i = 1; i < fragmentation.fragmentationVectorSize; ++i)
333    VerifyStapAPayload(fragmentation, 1, i, frame, kFrameSize, packet, length);
334
335  EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
336}
337
338TEST(RtpPacketizerH264Test, TestFUAOddSize) {
339  const size_t kExpectedPayloadSizes[2] = {600, 600};
340  TestFua(
341      kMaxPayloadSize + 1,
342      kMaxPayloadSize,
343      std::vector<size_t>(kExpectedPayloadSizes,
344                          kExpectedPayloadSizes +
345                              sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
346}
347
348TEST(RtpPacketizerH264Test, TestFUAEvenSize) {
349  const size_t kExpectedPayloadSizes[2] = {601, 600};
350  TestFua(
351      kMaxPayloadSize + 2,
352      kMaxPayloadSize,
353      std::vector<size_t>(kExpectedPayloadSizes,
354                          kExpectedPayloadSizes +
355                              sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
356}
357
358TEST(RtpPacketizerH264Test, TestFUARounding) {
359  const size_t kExpectedPayloadSizes[8] = {1266, 1266, 1266, 1266,
360                                           1266, 1266, 1266, 1261};
361  TestFua(
362      10124,
363      1448,
364      std::vector<size_t>(kExpectedPayloadSizes,
365                          kExpectedPayloadSizes +
366                              sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
367}
368
369TEST(RtpPacketizerH264Test, TestFUABig) {
370  const size_t kExpectedPayloadSizes[10] = {1198, 1198, 1198, 1198, 1198,
371                                            1198, 1198, 1198, 1198, 1198};
372  // Generate 10 full sized packets, leave room for FU-A headers minus the NALU
373  // header.
374  TestFua(
375      10 * (kMaxPayloadSize - kFuAHeaderSize) + kNalHeaderSize,
376      kMaxPayloadSize,
377      std::vector<size_t>(kExpectedPayloadSizes,
378                          kExpectedPayloadSizes +
379                              sizeof(kExpectedPayloadSizes) / sizeof(size_t)));
380}
381
382class RtpDepacketizerH264Test : public ::testing::Test {
383 protected:
384  RtpDepacketizerH264Test()
385      : depacketizer_(RtpDepacketizer::Create(kRtpVideoH264)) {}
386
387  void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload,
388                    const uint8_t* data,
389                    size_t length) {
390    ASSERT_TRUE(parsed_payload != NULL);
391    EXPECT_THAT(std::vector<uint8_t>(
392                    parsed_payload->payload,
393                    parsed_payload->payload + parsed_payload->payload_length),
394                ::testing::ElementsAreArray(data, length));
395  }
396
397  scoped_ptr<RtpDepacketizer> depacketizer_;
398};
399
400TEST_F(RtpDepacketizerH264Test, TestSingleNalu) {
401  uint8_t packet[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5.
402
403  WebRtcRTPHeader expected_header;
404  memset(&expected_header, 0, sizeof(expected_header));
405  RtpDepacketizer::ParsedPayload payload(&expected_header);
406
407  ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
408  ExpectPacket(&payload, packet, sizeof(packet));
409  EXPECT_EQ(kVideoFrameKey, payload.header->frameType);
410  EXPECT_TRUE(payload.header->type.Video.isFirstPacket);
411  EXPECT_TRUE(payload.header->type.Video.codecHeader.H264.single_nalu);
412  EXPECT_FALSE(payload.header->type.Video.codecHeader.H264.stap_a);
413}
414
415TEST_F(RtpDepacketizerH264Test, TestStapAKey) {
416  uint8_t packet[16] = {kStapA,  // F=0, NRI=0, Type=24.
417                        // Length, nal header, payload.
418                        0,      0x02, kIdr, 0xFF, 0,    0x03, kIdr, 0xFF,
419                        0x00,   0,    0x04, kIdr, 0xFF, 0x00, 0x11};
420
421  WebRtcRTPHeader expected_header;
422  memset(&expected_header, 0, sizeof(expected_header));
423  RtpDepacketizer::ParsedPayload payload(&expected_header);
424
425  ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
426  ExpectPacket(&payload, packet, sizeof(packet));
427  EXPECT_EQ(kVideoFrameKey, payload.header->frameType);
428  EXPECT_TRUE(payload.header->type.Video.isFirstPacket);
429  EXPECT_TRUE(payload.header->type.Video.codecHeader.H264.single_nalu);
430  EXPECT_TRUE(payload.header->type.Video.codecHeader.H264.stap_a);
431}
432
433TEST_F(RtpDepacketizerH264Test, TestStapADelta) {
434  uint8_t packet[16] = {kStapA,  // F=0, NRI=0, Type=24.
435                        // Length, nal header, payload.
436                        0,      0x02, kSlice, 0xFF,   0,    0x03, kSlice, 0xFF,
437                        0x00,   0,    0x04,   kSlice, 0xFF, 0x00, 0x11};
438
439  WebRtcRTPHeader expected_header;
440  memset(&expected_header, 0, sizeof(expected_header));
441  RtpDepacketizer::ParsedPayload payload(&expected_header);
442
443  ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
444  ExpectPacket(&payload, packet, sizeof(packet));
445  EXPECT_EQ(kVideoFrameDelta, payload.header->frameType);
446  EXPECT_TRUE(payload.header->type.Video.isFirstPacket);
447  EXPECT_TRUE(payload.header->type.Video.codecHeader.H264.single_nalu);
448  EXPECT_TRUE(payload.header->type.Video.codecHeader.H264.stap_a);
449}
450
451TEST_F(RtpDepacketizerH264Test, TestFuA) {
452  uint8_t packet1[3] = {
453      kFuA,          // F=0, NRI=0, Type=28.
454      kSBit | kIdr,  // FU header.
455      0x01           // Payload.
456  };
457  const uint8_t kExpected1[2] = {kIdr, 0x01};
458
459  uint8_t packet2[3] = {
460      kFuA,  // F=0, NRI=0, Type=28.
461      kIdr,  // FU header.
462      0x02   // Payload.
463  };
464  const uint8_t kExpected2[1] = {0x02};
465
466  uint8_t packet3[3] = {
467      kFuA,          // F=0, NRI=0, Type=28.
468      kEBit | kIdr,  // FU header.
469      0x03           // Payload.
470  };
471  const uint8_t kExpected3[1] = {0x03};
472
473  WebRtcRTPHeader expected_header;
474  memset(&expected_header, 0, sizeof(expected_header));
475  RtpDepacketizer::ParsedPayload payload(&expected_header);
476
477  // We expect that the first packet is one byte shorter since the FU-A header
478  // has been replaced by the original nal header.
479  ASSERT_TRUE(depacketizer_->Parse(&payload, packet1, sizeof(packet1)));
480  ExpectPacket(&payload, kExpected1, sizeof(kExpected1));
481  EXPECT_EQ(kVideoFrameKey, payload.header->frameType);
482  EXPECT_TRUE(payload.header->type.Video.isFirstPacket);
483  EXPECT_FALSE(payload.header->type.Video.codecHeader.H264.single_nalu);
484  EXPECT_FALSE(payload.header->type.Video.codecHeader.H264.stap_a);
485
486  // Following packets will be 2 bytes shorter since they will only be appended
487  // onto the first packet.
488  ASSERT_TRUE(depacketizer_->Parse(&payload, packet2, sizeof(packet2)));
489  ExpectPacket(&payload, kExpected2, sizeof(kExpected2));
490  EXPECT_EQ(kVideoFrameKey, payload.header->frameType);
491  EXPECT_FALSE(payload.header->type.Video.isFirstPacket);
492  EXPECT_FALSE(payload.header->type.Video.codecHeader.H264.single_nalu);
493  EXPECT_FALSE(payload.header->type.Video.codecHeader.H264.stap_a);
494
495  ASSERT_TRUE(depacketizer_->Parse(&payload, packet3, sizeof(packet3)));
496  ExpectPacket(&payload, kExpected3, sizeof(kExpected3));
497  EXPECT_EQ(kVideoFrameKey, payload.header->frameType);
498  EXPECT_FALSE(payload.header->type.Video.isFirstPacket);
499  EXPECT_FALSE(payload.header->type.Video.codecHeader.H264.single_nalu);
500  EXPECT_FALSE(payload.header->type.Video.codecHeader.H264.stap_a);
501}
502}  // namespace webrtc
503