src/third_party/webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc

   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
  20 namespace webrtc {
  21 namespace {
  22 const size_t kMaxPayloadSize = 1200;
  23 const size_t kLengthFieldLength = 2;
  24
  25 enum Nalu {
  26   kSlice = 1,
  27   kIdr = 5,
  28   kSei = 6,
  29   kSps = 7,
  30   kPps = 8,
  31   kStapA = 24,
  32   kFuA = 28
  33 };
  34
  35 static const size_t kNalHeaderSize = 1;
  36 static const size_t kFuAHeaderSize = 2;
  37
  38 // Bit masks for FU (A and B) indicators.
  39 enum NalDefs { kFBit = 0x80, kNriMask = 0x60, kTypeMask = 0x1F };
  40
  41 // Bit masks for FU (A and B) headers.
  42 enum FuDefs { kSBit = 0x80, kEBit = 0x40, kRBit = 0x20 };
  43
  44 void 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
  72 void 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
 103 size_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
 115 void 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
 138 void 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
 153 TEST(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
 173 TEST(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
 207 TEST(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
 243 TEST(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
 287 TEST(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
 338 TEST(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
 348 TEST(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
 358 TEST(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
 369 TEST(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
 382 class 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
 400 TEST_F(RtpDepacketizerH264Test, TestSingleNalu) {
 401   uint8_t packet[2] = {0x05, 0xFF};  // F=0, NRI=0, Type=5.
 402   RtpDepacketizer::ParsedPayload payload;
 403
 404   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
 405   ExpectPacket(&payload, packet, sizeof(packet));
 406   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
 407   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
 408   EXPECT_TRUE(payload.type.Video.isFirstPacket);
 409   EXPECT_TRUE(payload.type.Video.codecHeader.H264.single_nalu);
 410   EXPECT_FALSE(payload.type.Video.codecHeader.H264.stap_a);
 411 }
 412
 413 TEST_F(RtpDepacketizerH264Test, TestStapAKey) {
 414   uint8_t packet[16] = {kStapA,  // F=0, NRI=0, Type=24.
 415                         // Length, nal header, payload.
 416                         0,      0x02, kIdr, 0xFF, 0,    0x03, kIdr, 0xFF,
 417                         0x00,   0,    0x04, kIdr, 0xFF, 0x00, 0x11};
 418   RtpDepacketizer::ParsedPayload payload;
 419
 420   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
 421   ExpectPacket(&payload, packet, sizeof(packet));
 422   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
 423   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
 424   EXPECT_TRUE(payload.type.Video.isFirstPacket);
 425   EXPECT_TRUE(payload.type.Video.codecHeader.H264.single_nalu);
 426   EXPECT_TRUE(payload.type.Video.codecHeader.H264.stap_a);
 427 }
 428
 429 TEST_F(RtpDepacketizerH264Test, TestStapADelta) {
 430   uint8_t packet[16] = {kStapA,  // F=0, NRI=0, Type=24.
 431                         // Length, nal header, payload.
 432                         0,      0x02, kSlice, 0xFF,   0,    0x03, kSlice, 0xFF,
 433                         0x00,   0,    0x04,   kSlice, 0xFF, 0x00, 0x11};
 434   RtpDepacketizer::ParsedPayload payload;
 435
 436   ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
 437   ExpectPacket(&payload, packet, sizeof(packet));
 438   EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
 439   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
 440   EXPECT_TRUE(payload.type.Video.isFirstPacket);
 441   EXPECT_TRUE(payload.type.Video.codecHeader.H264.single_nalu);
 442   EXPECT_TRUE(payload.type.Video.codecHeader.H264.stap_a);
 443 }
 444
 445 TEST_F(RtpDepacketizerH264Test, TestFuA) {
 446   uint8_t packet1[3] = {
 447       kFuA,          // F=0, NRI=0, Type=28.
 448       kSBit | kIdr,  // FU header.
 449       0x01           // Payload.
 450   };
 451   const uint8_t kExpected1[2] = {kIdr, 0x01};
 452
 453   uint8_t packet2[3] = {
 454       kFuA,  // F=0, NRI=0, Type=28.
 455       kIdr,  // FU header.
 456       0x02   // Payload.
 457   };
 458   const uint8_t kExpected2[1] = {0x02};
 459
 460   uint8_t packet3[3] = {
 461       kFuA,          // F=0, NRI=0, Type=28.
 462       kEBit | kIdr,  // FU header.
 463       0x03           // Payload.
 464   };
 465   const uint8_t kExpected3[1] = {0x03};
 466
 467   RtpDepacketizer::ParsedPayload payload;
 468
 469   // We expect that the first packet is one byte shorter since the FU-A header
 470   // has been replaced by the original nal header.
 471   ASSERT_TRUE(depacketizer_->Parse(&payload, packet1, sizeof(packet1)));
 472   ExpectPacket(&payload, kExpected1, sizeof(kExpected1));
 473   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
 474   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
 475   EXPECT_TRUE(payload.type.Video.isFirstPacket);
 476   EXPECT_FALSE(payload.type.Video.codecHeader.H264.single_nalu);
 477   EXPECT_FALSE(payload.type.Video.codecHeader.H264.stap_a);
 478
 479   // Following packets will be 2 bytes shorter since they will only be appended
 480   // onto the first packet.
 481   payload = RtpDepacketizer::ParsedPayload();
 482   ASSERT_TRUE(depacketizer_->Parse(&payload, packet2, sizeof(packet2)));
 483   ExpectPacket(&payload, kExpected2, sizeof(kExpected2));
 484   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
 485   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
 486   EXPECT_FALSE(payload.type.Video.isFirstPacket);
 487   EXPECT_FALSE(payload.type.Video.codecHeader.H264.single_nalu);
 488   EXPECT_FALSE(payload.type.Video.codecHeader.H264.stap_a);
 489
 490   payload = RtpDepacketizer::ParsedPayload();
 491   ASSERT_TRUE(depacketizer_->Parse(&payload, packet3, sizeof(packet3)));
 492   ExpectPacket(&payload, kExpected3, sizeof(kExpected3));
 493   EXPECT_EQ(kVideoFrameKey, payload.frame_type);
 494   EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
 495   EXPECT_FALSE(payload.type.Video.isFirstPacket);
 496   EXPECT_FALSE(payload.type.Video.codecHeader.H264.single_nalu);
 497   EXPECT_FALSE(payload.type.Video.codecHeader.H264.stap_a);
 498 }
 499 }  // namespace webrtc