rtp_packet_unittest.cc (54030B)
1 /* 2 * Copyright (c) 2016 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 #include "modules/rtp_rtcp/source/rtp_packet.h" 11 12 #include <cstddef> 13 #include <cstdint> 14 #include <cstring> 15 #include <optional> 16 #include <string> 17 #include <type_traits> 18 #include <utility> 19 20 #include "absl/strings/string_view.h" 21 #include "api/array_view.h" 22 #include "api/rtp_headers.h" 23 #include "api/units/time_delta.h" 24 #include "api/video/color_space.h" 25 #include "api/video/video_timing.h" 26 #include "common_video/test/utilities.h" 27 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" 28 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" 29 #include "modules/rtp_rtcp/source/rtp_dependency_descriptor_extension.h" 30 #include "modules/rtp_rtcp/source/rtp_header_extensions.h" 31 #include "modules/rtp_rtcp/source/rtp_packet_received.h" 32 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" 33 #include "rtc_base/copy_on_write_buffer.h" 34 #include "test/gmock.h" 35 #include "test/gtest.h" 36 37 namespace webrtc { 38 namespace { 39 40 using ::testing::Each; 41 using ::testing::ElementsAre; 42 using ::testing::ElementsAreArray; 43 using ::testing::IsEmpty; 44 45 constexpr int8_t kPayloadType = 100; 46 constexpr uint32_t kSsrc = 0x12345678; 47 constexpr uint16_t kSeqNum = 0x1234; 48 constexpr uint8_t kSeqNumFirstByte = kSeqNum >> 8; 49 constexpr uint8_t kSeqNumSecondByte = kSeqNum & 0xff; 50 constexpr uint32_t kTimestamp = 0x65431278; 51 constexpr uint8_t kTransmissionOffsetExtensionId = 1; 52 constexpr uint8_t kDependencyDescriptorExtensionId = 2; 53 constexpr uint8_t kAudioLevelExtensionId = 9; 54 constexpr uint8_t kRtpStreamIdExtensionId = 0xa; 55 constexpr uint8_t kRtpMidExtensionId = 0xb; 56 constexpr uint8_t kVideoTimingExtensionId = 0xc; 57 // ID for two-bytes header extensions. See RFC8285 section 4.3. 58 constexpr uint8_t kTwoByteExtensionId = 0xf0; 59 constexpr int32_t kTimeOffset = 0x56ce; 60 constexpr bool kVoiceActive = true; 61 constexpr uint8_t kAudioLevel = 0x5a; 62 constexpr char kStreamId[] = "streamid"; 63 constexpr char kMid[] = "mid"; 64 constexpr char kLongMid[] = "extra-long string to test two-byte header"; 65 constexpr size_t kMaxPaddingSize = 224u; 66 67 // clang-format off 68 constexpr uint8_t kMinimumPacket[] = { 69 0x80, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 70 0x65, 0x43, 0x12, 0x78, 71 0x12, 0x34, 0x56, 0x78}; 72 73 constexpr uint8_t kPacketWithTO[] = { 74 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 75 0x65, 0x43, 0x12, 0x78, 76 0x12, 0x34, 0x56, 0x78, 77 0xbe, 0xde, 0x00, 0x01, 78 0x12, 0x00, 0x56, 0xce}; 79 80 constexpr uint8_t kPacketWithTOAndAL[] = { 81 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 82 0x65, 0x43, 0x12, 0x78, 83 0x12, 0x34, 0x56, 0x78, 84 0xbe, 0xde, 0x00, 0x02, 85 0x12, 0x00, 0x56, 0xce, 86 0x90, 0x80|kAudioLevel, 0x00, 0x00}; 87 88 constexpr uint8_t kPacketWithTwoByteExtensionIdLast[] = { 89 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 90 0x65, 0x43, 0x12, 0x78, 91 0x12, 0x34, 0x56, 0x78, 92 0x10, 0x00, 0x00, 0x04, 93 0x01, 0x03, 0x00, 0x56, 94 0xce, 0x09, 0x01, 0x80|kAudioLevel, 95 kTwoByteExtensionId, 0x03, 0x00, 0x30, // => 0x00 0x30 0x22 96 0x22, 0x00, 0x00, 0x00}; // => Playout delay.min_ms = 3*10 97 // => Playout delay.max_ms = 34*10 98 99 constexpr uint8_t kPacketWithTwoByteExtensionIdFirst[] = { 100 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 101 0x65, 0x43, 0x12, 0x78, 102 0x12, 0x34, 0x56, 0x78, 103 0x10, 0x00, 0x00, 0x04, 104 kTwoByteExtensionId, 0x03, 0x00, 0x30, // => 0x00 0x30 0x22 105 0x22, 0x01, 0x03, 0x00, // => Playout delay.min_ms = 3*10 106 0x56, 0xce, 0x09, 0x01, // => Playout delay.max_ms = 34*10 107 0x80|kAudioLevel, 0x00, 0x00, 0x00}; 108 109 constexpr uint8_t kPacketWithTOAndALInvalidPadding[] = { 110 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 111 0x65, 0x43, 0x12, 0x78, 112 0x12, 0x34, 0x56, 0x78, 113 0xbe, 0xde, 0x00, 0x03, 114 0x12, 0x00, 0x56, 0xce, 115 0x00, 0x02, 0x00, 0x00, // 0x02 is invalid padding, parsing should stop. 116 0x90, 0x80|kAudioLevel, 0x00, 0x00}; 117 118 constexpr uint8_t kPacketWithTOAndALReservedExtensionId[] = { 119 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 120 0x65, 0x43, 0x12, 0x78, 121 0x12, 0x34, 0x56, 0x78, 122 0xbe, 0xde, 0x00, 0x03, 123 0x12, 0x00, 0x56, 0xce, 124 0x00, 0xF0, 0x00, 0x00, // F is a reserved id, parsing should stop. 125 0x90, 0x80|kAudioLevel, 0x00, 0x00}; 126 127 constexpr uint8_t kPacketWithRsid[] = { 128 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 129 0x65, 0x43, 0x12, 0x78, 130 0x12, 0x34, 0x56, 0x78, 131 0xbe, 0xde, 0x00, 0x03, 132 0xa7, 's', 't', 'r', 133 'e', 'a', 'm', 'i', 134 'd' , 0x00, 0x00, 0x00}; 135 136 constexpr uint8_t kPacketWithMid[] = { 137 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 138 0x65, 0x43, 0x12, 0x78, 139 0x12, 0x34, 0x56, 0x78, 140 0xbe, 0xde, 0x00, 0x01, 141 0xb2, 'm', 'i', 'd'}; 142 143 constexpr uint8_t kCsrcAudioLevelExtensionId = 0xc; 144 constexpr uint8_t kCsrcAudioLevelsSize = 4; 145 constexpr uint8_t kCsrcAudioLevels[] = {0x7f, 0x00, 0x10, 0x08}; 146 constexpr uint8_t kPacketWithCsrcAudioLevels[] = { 147 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 148 0x65, 0x43, 0x12, 0x78, 149 0x12, 0x34, 0x56, 0x78, 150 0xbe, 0xde, 0x00, 0x02, 151 (kCsrcAudioLevelExtensionId << 4) | (kCsrcAudioLevelsSize - 1), 152 0x7f, 0x00, 0x10, 153 0x08, 0x00, 0x00, 0x00}; 154 155 constexpr uint32_t kCsrcs[] = {0x34567890, 0x32435465}; 156 constexpr uint8_t kPayload[] = {'p', 'a', 'y', 'l', 'o', 'a', 'd'}; 157 constexpr uint8_t kPacketPaddingSize = 8; 158 constexpr uint8_t kPacket[] = { 159 0xb2, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 160 0x65, 0x43, 0x12, 0x78, 161 0x12, 0x34, 0x56, 0x78, 162 0x34, 0x56, 0x78, 0x90, 163 0x32, 0x43, 0x54, 0x65, 164 0xbe, 0xde, 0x00, 0x01, 165 0x12, 0x00, 0x56, 0xce, 166 'p', 'a', 'y', 'l', 'o', 'a', 'd', 167 'p', 'a', 'd', 'd', 'i', 'n', 'g', kPacketPaddingSize}; 168 169 constexpr uint8_t kPacketWithTwoByteHeaderExtension[] = { 170 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 171 0x65, 0x43, 0x12, 0x78, 172 0x12, 0x34, 0x56, 0x78, 173 0x10, 0x00, 0x00, 0x02, // Two-byte header extension profile id + length. 174 kTwoByteExtensionId, 0x03, 0x00, 0x56, 175 0xce, 0x00, 0x00, 0x00}; 176 177 constexpr uint8_t kPacketWithLongTwoByteHeaderExtension[] = { 178 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 179 0x65, 0x43, 0x12, 0x78, 180 0x12, 0x34, 0x56, 0x78, 181 0x10, 0x00, 0x00, 0x0B, // Two-byte header extension profile id + length. 182 kTwoByteExtensionId, 0x29, 'e', 'x', 183 't', 'r', 'a', '-', 'l', 'o', 'n', 'g', 184 ' ', 's', 't', 'r', 'i', 'n', 'g', ' ', 185 't', 'o', ' ', 't', 'e', 's', 't', ' ', 186 't', 'w', 'o', '-', 'b', 'y', 't', 'e', 187 ' ', 'h', 'e', 'a', 'd', 'e', 'r', 0x00}; 188 189 constexpr uint8_t kPacketWithTwoByteHeaderExtensionWithPadding[] = { 190 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 191 0x65, 0x43, 0x12, 0x78, 192 0x12, 0x34, 0x56, 0x78, 193 0x10, 0x00, 0x00, 0x03, // Two-byte header extension profile id + length. 194 kTwoByteExtensionId, 0x03, 0x00, 0x56, 195 0xce, 0x00, 0x00, 0x00, // Three padding bytes. 196 kAudioLevelExtensionId, 0x01, 0x80|kAudioLevel, 0x00}; 197 198 constexpr uint8_t kPacketWithInvalidExtension[] = { 199 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 200 0x65, 0x43, 0x12, 0x78, // kTimestamp. 201 0x12, 0x34, 0x56, 0x78, // kSSrc. 202 0xbe, 0xde, 0x00, 0x02, // Extension block of size 2 x 32bit words. 203 (kTransmissionOffsetExtensionId << 4) | 6, // (6+1)-byte extension, but 204 'e', 'x', 't', // Transmission Offset 205 'd', 'a', 't', 'a', // expected to be 3-bytes. 206 'p', 'a', 'y', 'l', 'o', 'a', 'd'}; 207 208 constexpr uint8_t kPacketWithLegacyTimingExtension[] = { 209 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 210 0x65, 0x43, 0x12, 0x78, // kTimestamp. 211 0x12, 0x34, 0x56, 0x78, // kSSrc. 212 0xbe, 0xde, 0x00, 0x04, // Extension block of size 4 x 32bit words. 213 (kVideoTimingExtensionId << 4) 214 | VideoTimingExtension::kValueSizeBytes - 2, // Old format without flags. 215 0x00, 0x01, 0x00, 216 0x02, 0x00, 0x03, 0x00, 217 0x04, 0x00, 0x00, 0x00, 218 0x00, 0x00, 0x00, 0x00}; 219 // clang-format on 220 221 void TestCreateAndParseColorSpaceExtension(bool with_hdr_metadata) { 222 // Create packet with extension. 223 RtpPacket::ExtensionManager extensions(/*extmap_allow_mixed=*/true); 224 extensions.Register<ColorSpaceExtension>(1); 225 RtpPacket packet(&extensions); 226 const ColorSpace kColorSpace = CreateTestColorSpace(with_hdr_metadata); 227 EXPECT_TRUE(packet.SetExtension<ColorSpaceExtension>(kColorSpace)); 228 packet.SetPayloadSize(42); 229 230 // Read packet with the extension. 231 RtpPacketReceived parsed(&extensions); 232 EXPECT_TRUE(parsed.Parse(packet.Buffer())); 233 ColorSpace parsed_color_space; 234 EXPECT_TRUE(parsed.GetExtension<ColorSpaceExtension>(&parsed_color_space)); 235 EXPECT_EQ(kColorSpace, parsed_color_space); 236 } 237 238 TEST(RtpPacketTest, CreateMinimum) { 239 RtpPacketToSend packet(nullptr); 240 packet.SetPayloadType(kPayloadType); 241 packet.SetSequenceNumber(kSeqNum); 242 packet.SetTimestamp(kTimestamp); 243 packet.SetSsrc(kSsrc); 244 EXPECT_THAT(kMinimumPacket, ElementsAreArray(packet.data(), packet.size())); 245 } 246 247 TEST(RtpPacketTest, CreateWithExtension) { 248 RtpPacketToSend::ExtensionManager extensions; 249 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 250 RtpPacketToSend packet(&extensions); 251 packet.SetPayloadType(kPayloadType); 252 packet.SetSequenceNumber(kSeqNum); 253 packet.SetTimestamp(kTimestamp); 254 packet.SetSsrc(kSsrc); 255 packet.SetExtension<TransmissionOffset>(kTimeOffset); 256 EXPECT_THAT(kPacketWithTO, ElementsAreArray(packet.data(), packet.size())); 257 } 258 259 TEST(RtpPacketTest, CreateWith2Extensions) { 260 RtpPacketToSend::ExtensionManager extensions; 261 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 262 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 263 RtpPacketToSend packet(&extensions); 264 packet.SetPayloadType(kPayloadType); 265 packet.SetSequenceNumber(kSeqNum); 266 packet.SetTimestamp(kTimestamp); 267 packet.SetSsrc(kSsrc); 268 packet.SetExtension<TransmissionOffset>(kTimeOffset); 269 packet.SetExtension<AudioLevelExtension>( 270 AudioLevel(kVoiceActive, kAudioLevel)); 271 EXPECT_THAT(kPacketWithTOAndAL, 272 ElementsAreArray(packet.data(), packet.size())); 273 } 274 275 TEST(RtpPacketTest, CreateWithTwoByteHeaderExtensionFirst) { 276 RtpPacketToSend::ExtensionManager extensions(/*extmap_allow_mixed=*/true); 277 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 278 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 279 extensions.Register<PlayoutDelayLimits>(kTwoByteExtensionId); 280 RtpPacketToSend packet(&extensions); 281 packet.SetPayloadType(kPayloadType); 282 packet.SetSequenceNumber(kSeqNum); 283 packet.SetTimestamp(kTimestamp); 284 packet.SetSsrc(kSsrc); 285 // Set extension that requires two-byte header. 286 VideoPlayoutDelay playout_delay(TimeDelta::Millis(30), 287 TimeDelta::Millis(340)); 288 ASSERT_TRUE(packet.SetExtension<PlayoutDelayLimits>(playout_delay)); 289 packet.SetExtension<TransmissionOffset>(kTimeOffset); 290 packet.SetExtension<AudioLevelExtension>( 291 AudioLevel(kVoiceActive, kAudioLevel)); 292 EXPECT_THAT(kPacketWithTwoByteExtensionIdFirst, 293 ElementsAreArray(packet.data(), packet.size())); 294 } 295 296 TEST(RtpPacketTest, CreateWithTwoByteHeaderExtensionLast) { 297 // This test will trigger RtpPacket::PromoteToTwoByteHeaderExtension(). 298 RtpPacketToSend::ExtensionManager extensions(/*extmap_allow_mixed=*/true); 299 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 300 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 301 extensions.Register<PlayoutDelayLimits>(kTwoByteExtensionId); 302 RtpPacketToSend packet(&extensions); 303 packet.SetPayloadType(kPayloadType); 304 packet.SetSequenceNumber(kSeqNum); 305 packet.SetTimestamp(kTimestamp); 306 packet.SetSsrc(kSsrc); 307 packet.SetExtension<TransmissionOffset>(kTimeOffset); 308 packet.SetExtension<AudioLevelExtension>( 309 AudioLevel(kVoiceActive, kAudioLevel)); 310 EXPECT_THAT(kPacketWithTOAndAL, 311 ElementsAreArray(packet.data(), packet.size())); 312 // Set extension that requires two-byte header. 313 VideoPlayoutDelay playout_delay(TimeDelta::Millis(30), 314 TimeDelta::Millis(340)); 315 ASSERT_TRUE(packet.SetExtension<PlayoutDelayLimits>(playout_delay)); 316 EXPECT_THAT(kPacketWithTwoByteExtensionIdLast, 317 ElementsAreArray(packet.data(), packet.size())); 318 } 319 320 TEST(RtpPacketTest, CreateWithDynamicSizedExtensions) { 321 RtpPacketToSend::ExtensionManager extensions; 322 extensions.Register<RtpStreamId>(kRtpStreamIdExtensionId); 323 RtpPacketToSend packet(&extensions); 324 packet.SetPayloadType(kPayloadType); 325 packet.SetSequenceNumber(kSeqNum); 326 packet.SetTimestamp(kTimestamp); 327 packet.SetSsrc(kSsrc); 328 packet.SetExtension<RtpStreamId>(kStreamId); 329 EXPECT_THAT(kPacketWithRsid, ElementsAreArray(packet.data(), packet.size())); 330 } 331 332 TEST(RtpPacketTest, TryToCreateWithEmptyRsid) { 333 RtpPacketToSend::ExtensionManager extensions; 334 extensions.Register<RtpStreamId>(kRtpStreamIdExtensionId); 335 RtpPacketToSend packet(&extensions); 336 EXPECT_FALSE(packet.SetExtension<RtpStreamId>("")); 337 } 338 339 TEST(RtpPacketTest, TryToCreateWithLongRsid) { 340 RtpPacketToSend::ExtensionManager extensions; 341 constexpr char kLongStreamId[] = "LoooooooooongRsid"; 342 ASSERT_EQ(strlen(kLongStreamId), 17u); 343 extensions.Register<RtpStreamId>(kRtpStreamIdExtensionId); 344 RtpPacketToSend packet(&extensions); 345 EXPECT_FALSE(packet.SetExtension<RtpStreamId>(kLongStreamId)); 346 } 347 348 TEST(RtpPacketTest, TryToCreateWithEmptyMid) { 349 RtpPacketToSend::ExtensionManager extensions; 350 extensions.Register<RtpMid>(kRtpMidExtensionId); 351 RtpPacketToSend packet(&extensions); 352 EXPECT_FALSE(packet.SetExtension<RtpMid>("")); 353 } 354 355 TEST(RtpPacketTest, TryToCreateWithLongMid) { 356 RtpPacketToSend::ExtensionManager extensions; 357 constexpr char kOtherLongMid[] = "LoooooooooonogMid"; 358 ASSERT_EQ(strlen(kOtherLongMid), 17u); 359 extensions.Register<RtpMid>(kRtpMidExtensionId); 360 RtpPacketToSend packet(&extensions); 361 EXPECT_FALSE(packet.SetExtension<RtpMid>(kOtherLongMid)); 362 } 363 364 TEST(RtpPacketTest, TryToCreateTwoByteHeaderNotSupported) { 365 RtpPacketToSend::ExtensionManager extensions; 366 extensions.Register<AudioLevelExtension>(kTwoByteExtensionId); 367 RtpPacketToSend packet(&extensions); 368 // Set extension that requires two-byte header. 369 EXPECT_FALSE(packet.SetExtension<AudioLevelExtension>( 370 AudioLevel(kVoiceActive, kAudioLevel))); 371 } 372 373 TEST(RtpPacketTest, CreateTwoByteHeaderSupportedIfExtmapAllowMixed) { 374 RtpPacketToSend::ExtensionManager extensions(/*extmap_allow_mixed=*/true); 375 extensions.Register<AudioLevelExtension>(kTwoByteExtensionId); 376 RtpPacketToSend packet(&extensions); 377 // Set extension that requires two-byte header. 378 EXPECT_TRUE(packet.SetExtension<AudioLevelExtension>( 379 AudioLevel(kVoiceActive, kAudioLevel))); 380 } 381 382 TEST(RtpPacketTest, CreateWithMaxSizeHeaderExtension) { 383 const std::string kValue = "123456789abcdef"; 384 RtpPacket::ExtensionManager extensions; 385 extensions.Register<RtpMid>(1); 386 extensions.Register<RtpStreamId>(2); 387 388 RtpPacket packet(&extensions); 389 EXPECT_TRUE(packet.SetExtension<RtpMid>(kValue)); 390 391 packet.SetPayloadSize(42); 392 // Rewriting allocated extension is allowed. 393 EXPECT_TRUE(packet.SetExtension<RtpMid>(kValue)); 394 // Adding another extension after payload is set is not allowed. 395 EXPECT_FALSE(packet.SetExtension<RtpStreamId>(kValue)); 396 397 // Read packet with the extension. 398 RtpPacketReceived parsed(&extensions); 399 EXPECT_TRUE(parsed.Parse(packet.Buffer())); 400 std::string read; 401 EXPECT_TRUE(parsed.GetExtension<RtpMid>(&read)); 402 EXPECT_EQ(read, kValue); 403 } 404 405 TEST(RtpPacketTest, SetsRegisteredExtension) { 406 RtpPacketToSend::ExtensionManager extensions; 407 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 408 RtpPacketToSend packet(&extensions); 409 410 EXPECT_TRUE(packet.IsRegistered<TransmissionOffset>()); 411 EXPECT_FALSE(packet.HasExtension<TransmissionOffset>()); 412 413 // Try to set the extensions. 414 EXPECT_TRUE(packet.SetExtension<TransmissionOffset>(kTimeOffset)); 415 416 EXPECT_TRUE(packet.HasExtension<TransmissionOffset>()); 417 EXPECT_EQ(packet.GetExtension<TransmissionOffset>(), kTimeOffset); 418 } 419 420 TEST(RtpPacketTest, FailsToSetUnregisteredExtension) { 421 RtpPacketToSend::ExtensionManager extensions; 422 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 423 RtpPacketToSend packet(&extensions); 424 425 EXPECT_FALSE(packet.IsRegistered<TransportSequenceNumber>()); 426 EXPECT_FALSE(packet.HasExtension<TransportSequenceNumber>()); 427 428 EXPECT_FALSE(packet.SetExtension<TransportSequenceNumber>(42)); 429 430 EXPECT_FALSE(packet.HasExtension<TransportSequenceNumber>()); 431 EXPECT_EQ(packet.GetExtension<TransportSequenceNumber>(), std::nullopt); 432 } 433 434 TEST(RtpPacketTest, CreateWithDynamicSizedExtensionCsrcAudioLevel) { 435 RtpPacketToSend::ExtensionManager extensions; 436 extensions.Register<CsrcAudioLevel>(kCsrcAudioLevelExtensionId); 437 RtpPacketToSend packet(&extensions); 438 packet.SetPayloadType(kPayloadType); 439 packet.SetSequenceNumber(kSeqNum); 440 packet.SetTimestamp(kTimestamp); 441 packet.SetSsrc(kSsrc); 442 CsrcAudioLevelList levels; 443 levels.numAudioLevels = kCsrcAudioLevelsSize; 444 for (uint8_t i = 0; i < kCsrcAudioLevelsSize; i++) { 445 levels.arrOfAudioLevels[i] = kCsrcAudioLevels[i]; 446 } 447 packet.SetExtension<CsrcAudioLevel>(levels); 448 EXPECT_THAT(kPacketWithCsrcAudioLevels, 449 ElementsAreArray(packet.data(), packet.size())); 450 } 451 452 TEST(RtpPacketTest, SetReservedExtensionsAfterPayload) { 453 const size_t kPayloadSize = 4; 454 RtpPacketToSend::ExtensionManager extensions; 455 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 456 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 457 RtpPacketToSend packet(&extensions); 458 459 EXPECT_TRUE(packet.ReserveExtension<TransmissionOffset>()); 460 packet.SetPayloadSize(kPayloadSize); 461 // Can't set extension after payload. 462 EXPECT_FALSE(packet.SetExtension<AudioLevelExtension>( 463 AudioLevel(kVoiceActive, kAudioLevel))); 464 // Unless reserved. 465 EXPECT_TRUE(packet.SetExtension<TransmissionOffset>(kTimeOffset)); 466 } 467 468 TEST(RtpPacketTest, SetPayload) { 469 const uint8_t payload[] = {1, 2, 3, 4, 2, 0, 42}; 470 RtpPacket packet; 471 packet.SetPayload(payload); 472 473 EXPECT_THAT(packet.payload(), ElementsAreArray(payload)); 474 } 475 476 TEST(RtpPacketTest, CreatePurePadding) { 477 const size_t kPaddingSize = kMaxPaddingSize - 1; 478 RtpPacketToSend packet(nullptr, 12 + kPaddingSize); 479 packet.SetPayloadType(kPayloadType); 480 packet.SetSequenceNumber(kSeqNum); 481 packet.SetTimestamp(kTimestamp); 482 packet.SetSsrc(kSsrc); 483 484 EXPECT_LT(packet.size(), packet.capacity()); 485 EXPECT_FALSE(packet.SetPadding(kPaddingSize + 1)); 486 EXPECT_TRUE(packet.SetPadding(kPaddingSize)); 487 EXPECT_EQ(packet.size(), packet.capacity()); 488 } 489 490 TEST(RtpPacketTest, CreateUnalignedPadding) { 491 const size_t kPayloadSize = 3; // Make padding start at unaligned address. 492 RtpPacketToSend packet(nullptr, 12 + kPayloadSize + kMaxPaddingSize); 493 packet.SetPayloadType(kPayloadType); 494 packet.SetSequenceNumber(kSeqNum); 495 packet.SetTimestamp(kTimestamp); 496 packet.SetSsrc(kSsrc); 497 packet.SetPayloadSize(kPayloadSize); 498 499 EXPECT_LT(packet.size(), packet.capacity()); 500 EXPECT_TRUE(packet.SetPadding(kMaxPaddingSize)); 501 EXPECT_EQ(packet.size(), packet.capacity()); 502 } 503 504 TEST(RtpPacketTest, WritesPaddingSizeToLastByte) { 505 const size_t kPaddingSize = 5; 506 RtpPacket packet; 507 508 EXPECT_TRUE(packet.SetPadding(kPaddingSize)); 509 EXPECT_EQ(packet.data()[packet.size() - 1], kPaddingSize); 510 } 511 512 TEST(RtpPacketTest, UsesZerosForPadding) { 513 const size_t kPaddingSize = 5; 514 RtpPacket packet; 515 516 EXPECT_TRUE(packet.SetPadding(kPaddingSize)); 517 EXPECT_THAT(MakeArrayView(packet.data() + 12, kPaddingSize - 1), Each(0)); 518 } 519 520 TEST(RtpPacketTest, CreateOneBytePadding) { 521 size_t kPayloadSize = 123; 522 RtpPacket packet(nullptr, 12 + kPayloadSize + 1); 523 packet.SetPayloadSize(kPayloadSize); 524 525 EXPECT_TRUE(packet.SetPadding(1)); 526 527 EXPECT_EQ(packet.size(), 12 + kPayloadSize + 1); 528 EXPECT_EQ(packet.padding_size(), 1u); 529 } 530 531 TEST(RtpPacketTest, FailsToAddPaddingWithoutCapacity) { 532 size_t kPayloadSize = 123; 533 RtpPacket packet(nullptr, 12 + kPayloadSize); 534 packet.SetPayloadSize(kPayloadSize); 535 536 EXPECT_FALSE(packet.SetPadding(1)); 537 } 538 539 TEST(RtpPacketTest, ParseMinimum) { 540 RtpPacketReceived packet; 541 EXPECT_TRUE(packet.Parse(kMinimumPacket, sizeof(kMinimumPacket))); 542 EXPECT_EQ(kPayloadType, packet.PayloadType()); 543 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); 544 EXPECT_EQ(kTimestamp, packet.Timestamp()); 545 EXPECT_EQ(kSsrc, packet.Ssrc()); 546 EXPECT_EQ(0u, packet.padding_size()); 547 EXPECT_EQ(0u, packet.payload_size()); 548 } 549 550 TEST(RtpPacketTest, ParseBuffer) { 551 CopyOnWriteBuffer unparsed(kMinimumPacket); 552 const uint8_t* raw = unparsed.data(); 553 554 RtpPacketReceived packet; 555 EXPECT_TRUE(packet.Parse(std::move(unparsed))); 556 EXPECT_EQ(raw, packet.data()); // Expect packet take the buffer without copy. 557 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); 558 EXPECT_EQ(kTimestamp, packet.Timestamp()); 559 EXPECT_EQ(kSsrc, packet.Ssrc()); 560 EXPECT_EQ(0u, packet.padding_size()); 561 EXPECT_EQ(0u, packet.payload_size()); 562 } 563 564 TEST(RtpPacketTest, ParseWithExtension) { 565 RtpPacketToSend::ExtensionManager extensions; 566 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 567 568 RtpPacketReceived packet(&extensions); 569 EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO))); 570 EXPECT_EQ(kPayloadType, packet.PayloadType()); 571 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); 572 EXPECT_EQ(kTimestamp, packet.Timestamp()); 573 EXPECT_EQ(kSsrc, packet.Ssrc()); 574 int32_t time_offset; 575 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 576 EXPECT_EQ(kTimeOffset, time_offset); 577 EXPECT_EQ(0u, packet.payload_size()); 578 EXPECT_EQ(0u, packet.padding_size()); 579 } 580 581 TEST(RtpPacketTest, ParseHeaderOnly) { 582 // clang-format off 583 constexpr uint8_t kPaddingHeader[] = { 584 0x80, 0x62, 0x35, 0x79, 585 0x65, 0x43, 0x12, 0x78, 586 0x12, 0x34, 0x56, 0x78}; 587 // clang-format on 588 589 RtpPacket packet; 590 EXPECT_TRUE(packet.Parse(CopyOnWriteBuffer(kPaddingHeader))); 591 EXPECT_EQ(packet.PayloadType(), 0x62u); 592 EXPECT_EQ(packet.SequenceNumber(), 0x3579u); 593 EXPECT_EQ(packet.Timestamp(), 0x65431278u); 594 EXPECT_EQ(packet.Ssrc(), 0x12345678u); 595 596 EXPECT_FALSE(packet.has_padding()); 597 EXPECT_EQ(packet.padding_size(), 0u); 598 EXPECT_EQ(packet.payload_size(), 0u); 599 } 600 601 TEST(RtpPacketTest, ParseHeaderOnlyWithPadding) { 602 // clang-format off 603 constexpr uint8_t kPaddingHeader[] = { 604 0xa0, 0x62, 0x35, 0x79, 605 0x65, 0x43, 0x12, 0x78, 606 0x12, 0x34, 0x56, 0x78}; 607 // clang-format on 608 609 RtpPacket packet; 610 EXPECT_TRUE(packet.Parse(CopyOnWriteBuffer(kPaddingHeader))); 611 612 EXPECT_TRUE(packet.has_padding()); 613 EXPECT_EQ(packet.padding_size(), 0u); 614 EXPECT_EQ(packet.payload_size(), 0u); 615 } 616 617 TEST(RtpPacketTest, ParseHeaderOnlyWithExtensionAndPadding) { 618 // clang-format off 619 constexpr uint8_t kPaddingHeader[] = { 620 0xb0, 0x62, 0x35, 0x79, 621 0x65, 0x43, 0x12, 0x78, 622 0x12, 0x34, 0x56, 0x78, 623 0xbe, 0xde, 0x00, 0x01, 624 0x11, 0x00, 0x00, 0x00}; 625 // clang-format on 626 627 RtpHeaderExtensionMap extensions; 628 extensions.Register<TransmissionOffset>(1); 629 RtpPacket packet(&extensions); 630 EXPECT_TRUE(packet.Parse(CopyOnWriteBuffer(kPaddingHeader))); 631 EXPECT_TRUE(packet.has_padding()); 632 EXPECT_TRUE(packet.HasExtension<TransmissionOffset>()); 633 EXPECT_EQ(packet.padding_size(), 0u); 634 } 635 636 TEST(RtpPacketTest, ParsePaddingOnlyPacket) { 637 // clang-format off 638 constexpr uint8_t kPaddingHeader[] = { 639 0xa0, 0x62, 0x35, 0x79, 640 0x65, 0x43, 0x12, 0x78, 641 0x12, 0x34, 0x56, 0x78, 642 0, 0, 3}; 643 // clang-format on 644 645 RtpPacket packet; 646 EXPECT_TRUE(packet.Parse(CopyOnWriteBuffer(kPaddingHeader))); 647 EXPECT_TRUE(packet.has_padding()); 648 EXPECT_EQ(packet.padding_size(), 3u); 649 } 650 651 TEST(RtpPacketTest, GetExtensionWithoutParametersReturnsOptionalValue) { 652 RtpPacket::ExtensionManager extensions; 653 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 654 extensions.Register<RtpStreamId>(kRtpStreamIdExtensionId); 655 656 RtpPacketReceived packet(&extensions); 657 EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO))); 658 659 auto time_offset = packet.GetExtension<TransmissionOffset>(); 660 static_assert( 661 std::is_same<decltype(time_offset), 662 std::optional<TransmissionOffset::value_type>>::value, 663 ""); 664 EXPECT_EQ(time_offset, kTimeOffset); 665 EXPECT_FALSE(packet.GetExtension<RtpStreamId>().has_value()); 666 } 667 668 TEST(RtpPacketTest, GetRawExtensionWhenPresent) { 669 constexpr uint8_t kRawPacket[] = { 670 // comment for clang-format to align kRawPacket nicer. 671 0x90, 100, 0x5e, 0x04, // 672 0x65, 0x43, 0x12, 0x78, // Timestamp. 673 0x12, 0x34, 0x56, 0x78, // Ssrc 674 0xbe, 0xde, 0x00, 0x01, // Extension header 675 0x12, 'm', 'i', 'd', // 3-byte extension with id=1. 676 'p', 'a', 'y', 'l', 'o', 'a', 'd'}; 677 RtpPacketToSend::ExtensionManager extensions; 678 extensions.Register<RtpMid>(1); 679 RtpPacket packet(&extensions); 680 ASSERT_TRUE(packet.Parse(kRawPacket, sizeof(kRawPacket))); 681 EXPECT_THAT(packet.GetRawExtension<RtpMid>(), ElementsAre('m', 'i', 'd')); 682 } 683 684 TEST(RtpPacketTest, GetRawExtensionWhenAbsent) { 685 constexpr uint8_t kRawPacket[] = { 686 // comment for clang-format to align kRawPacket nicer. 687 0x90, 100, 0x5e, 0x04, // 688 0x65, 0x43, 0x12, 0x78, // Timestamp. 689 0x12, 0x34, 0x56, 0x78, // Ssrc 690 0xbe, 0xde, 0x00, 0x01, // Extension header 691 0x12, 'm', 'i', 'd', // 3-byte extension with id=1. 692 'p', 'a', 'y', 'l', 'o', 'a', 'd'}; 693 RtpPacketToSend::ExtensionManager extensions; 694 extensions.Register<RtpMid>(2); 695 RtpPacket packet(&extensions); 696 ASSERT_TRUE(packet.Parse(kRawPacket, sizeof(kRawPacket))); 697 EXPECT_THAT(packet.GetRawExtension<RtpMid>(), IsEmpty()); 698 } 699 700 TEST(RtpPacketTest, ParseWithInvalidSizedExtension) { 701 RtpPacketToSend::ExtensionManager extensions; 702 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 703 704 RtpPacketReceived packet(&extensions); 705 EXPECT_TRUE(packet.Parse(kPacketWithInvalidExtension, 706 sizeof(kPacketWithInvalidExtension))); 707 708 // Extension should be ignored. 709 int32_t time_offset; 710 EXPECT_FALSE(packet.GetExtension<TransmissionOffset>(&time_offset)); 711 712 // But shouldn't prevent reading payload. 713 EXPECT_THAT(packet.payload(), ElementsAreArray(kPayload)); 714 } 715 716 TEST(RtpPacketTest, ParseWithOverSizedExtension) { 717 // clang-format off 718 const uint8_t bad_packet[] = { 719 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 720 0x65, 0x43, 0x12, 0x78, // kTimestamp. 721 0x12, 0x34, 0x56, 0x78, // kSsrc. 722 0xbe, 0xde, 0x00, 0x01, // Extension of size 1x32bit word. 723 0x00, // Add a byte of padding. 724 0x12, // Extension id 1 size (2+1). 725 0xda, 0x1a // Only 2 bytes of extension payload. 726 }; 727 // clang-format on 728 RtpPacketToSend::ExtensionManager extensions; 729 extensions.Register<TransmissionOffset>(1); 730 RtpPacketReceived packet(&extensions); 731 732 // Parse should ignore bad extension and proceed. 733 EXPECT_TRUE(packet.Parse(bad_packet, sizeof(bad_packet))); 734 int32_t time_offset; 735 // But extracting extension should fail. 736 EXPECT_FALSE(packet.GetExtension<TransmissionOffset>(&time_offset)); 737 } 738 739 TEST(RtpPacketTest, ParseWith2Extensions) { 740 RtpPacketToSend::ExtensionManager extensions; 741 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 742 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 743 RtpPacketReceived packet(&extensions); 744 EXPECT_TRUE(packet.Parse(kPacketWithTOAndAL, sizeof(kPacketWithTOAndAL))); 745 int32_t time_offset; 746 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 747 EXPECT_EQ(kTimeOffset, time_offset); 748 AudioLevel audio_level; 749 EXPECT_TRUE(packet.GetExtension<AudioLevelExtension>(&audio_level)); 750 EXPECT_EQ(kVoiceActive, audio_level.voice_activity()); 751 EXPECT_EQ(kAudioLevel, audio_level.level()); 752 } 753 754 TEST(RtpPacketTest, ParseSecondPacketWithFewerExtensions) { 755 RtpPacketToSend::ExtensionManager extensions; 756 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 757 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 758 RtpPacketReceived packet(&extensions); 759 EXPECT_TRUE(packet.Parse(kPacketWithTOAndAL, sizeof(kPacketWithTOAndAL))); 760 EXPECT_TRUE(packet.HasExtension<TransmissionOffset>()); 761 EXPECT_TRUE(packet.HasExtension<AudioLevelExtension>()); 762 763 // Second packet without audio level. 764 EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO))); 765 EXPECT_TRUE(packet.HasExtension<TransmissionOffset>()); 766 EXPECT_FALSE(packet.HasExtension<AudioLevelExtension>()); 767 } 768 769 TEST(RtpPacketTest, ParseWith2ExtensionsInvalidPadding) { 770 RtpPacketToSend::ExtensionManager extensions; 771 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 772 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 773 RtpPacketReceived packet(&extensions); 774 EXPECT_TRUE(packet.Parse(kPacketWithTOAndALInvalidPadding, 775 sizeof(kPacketWithTOAndALInvalidPadding))); 776 int32_t time_offset; 777 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 778 EXPECT_EQ(kTimeOffset, time_offset); 779 AudioLevel audio_level; 780 EXPECT_FALSE(packet.GetExtension<AudioLevelExtension>(&audio_level)); 781 } 782 783 TEST(RtpPacketTest, ParseWith2ExtensionsReservedExtensionId) { 784 RtpPacketToSend::ExtensionManager extensions; 785 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 786 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 787 RtpPacketReceived packet(&extensions); 788 EXPECT_TRUE(packet.Parse(kPacketWithTOAndALReservedExtensionId, 789 sizeof(kPacketWithTOAndALReservedExtensionId))); 790 int32_t time_offset; 791 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 792 EXPECT_EQ(kTimeOffset, time_offset); 793 AudioLevel audio_level; 794 EXPECT_FALSE(packet.GetExtension<AudioLevelExtension>(&audio_level)); 795 } 796 797 TEST(RtpPacketTest, ParseWithAllFeatures) { 798 RtpPacketToSend::ExtensionManager extensions; 799 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 800 RtpPacketReceived packet(&extensions); 801 EXPECT_TRUE(packet.Parse(kPacket, sizeof(kPacket))); 802 EXPECT_EQ(kPayloadType, packet.PayloadType()); 803 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); 804 EXPECT_EQ(kTimestamp, packet.Timestamp()); 805 EXPECT_EQ(kSsrc, packet.Ssrc()); 806 EXPECT_THAT(packet.Csrcs(), ElementsAreArray(kCsrcs)); 807 EXPECT_THAT(packet.payload(), ElementsAreArray(kPayload)); 808 EXPECT_EQ(kPacketPaddingSize, packet.padding_size()); 809 int32_t time_offset; 810 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 811 } 812 813 TEST(RtpPacketTest, ParseTwoByteHeaderExtension) { 814 RtpPacketToSend::ExtensionManager extensions; 815 extensions.Register<TransmissionOffset>(kTwoByteExtensionId); 816 RtpPacketReceived packet(&extensions); 817 EXPECT_TRUE(packet.Parse(kPacketWithTwoByteHeaderExtension, 818 sizeof(kPacketWithTwoByteHeaderExtension))); 819 int32_t time_offset; 820 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 821 EXPECT_EQ(kTimeOffset, time_offset); 822 } 823 824 TEST(RtpPacketTest, ParseLongTwoByteHeaderExtension) { 825 RtpPacketToSend::ExtensionManager extensions; 826 extensions.Register<RtpMid>(kTwoByteExtensionId); 827 RtpPacketReceived packet(&extensions); 828 EXPECT_TRUE(packet.Parse(kPacketWithLongTwoByteHeaderExtension, 829 sizeof(kPacketWithLongTwoByteHeaderExtension))); 830 std::string long_rtp_mid; 831 EXPECT_TRUE(packet.GetExtension<RtpMid>(&long_rtp_mid)); 832 EXPECT_EQ(kLongMid, long_rtp_mid); 833 } 834 835 TEST(RtpPacketTest, ParseTwoByteHeaderExtensionWithPadding) { 836 RtpPacketToSend::ExtensionManager extensions; 837 extensions.Register<TransmissionOffset>(kTwoByteExtensionId); 838 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 839 RtpPacketReceived packet(&extensions); 840 EXPECT_TRUE( 841 packet.Parse(kPacketWithTwoByteHeaderExtensionWithPadding, 842 sizeof(kPacketWithTwoByteHeaderExtensionWithPadding))); 843 int32_t time_offset; 844 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 845 EXPECT_EQ(kTimeOffset, time_offset); 846 AudioLevel audio_level; 847 EXPECT_TRUE(packet.GetExtension<AudioLevelExtension>(&audio_level)); 848 EXPECT_EQ(kVoiceActive, audio_level.voice_activity()); 849 EXPECT_EQ(kAudioLevel, audio_level.level()); 850 } 851 852 TEST(RtpPacketTest, ParseWithExtensionDelayed) { 853 RtpPacketReceived packet; 854 EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO))); 855 EXPECT_EQ(kPayloadType, packet.PayloadType()); 856 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); 857 EXPECT_EQ(kTimestamp, packet.Timestamp()); 858 EXPECT_EQ(kSsrc, packet.Ssrc()); 859 860 RtpPacketToSend::ExtensionManager extensions; 861 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 862 863 int32_t time_offset; 864 EXPECT_FALSE(packet.GetExtension<TransmissionOffset>(&time_offset)); 865 packet.IdentifyExtensions(extensions); 866 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); 867 EXPECT_EQ(kTimeOffset, time_offset); 868 EXPECT_EQ(0u, packet.payload_size()); 869 EXPECT_EQ(0u, packet.padding_size()); 870 } 871 872 TEST(RtpPacketTest, ParseDynamicSizeExtension) { 873 // clang-format off 874 const uint8_t kPacket1[] = { 875 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 876 0x65, 0x43, 0x12, 0x78, // Timestamp. 877 0x12, 0x34, 0x56, 0x78, // Ssrc. 878 0xbe, 0xde, 0x00, 0x02, // Extensions block of size 2x32bit words. 879 0x21, 'H', 'D', // Extension with id = 2, size = (1+1). 880 0x12, 'r', 't', 'x', // Extension with id = 1, size = (2+1). 881 0x00}; // Extension padding. 882 const uint8_t kPacket2[] = { 883 0x90, kPayloadType, kSeqNumFirstByte, kSeqNumSecondByte, 884 0x65, 0x43, 0x12, 0x78, // Timestamp. 885 0x12, 0x34, 0x56, 0x79, // Ssrc. 886 0xbe, 0xde, 0x00, 0x01, // Extensions block of size 1x32bit words. 887 0x11, 'H', 'D', // Extension with id = 1, size = (1+1). 888 0x00}; // Extension padding. 889 // clang-format on 890 RtpPacketReceived::ExtensionManager extensions; 891 extensions.Register<RtpStreamId>(1); 892 extensions.Register<RepairedRtpStreamId>(2); 893 RtpPacketReceived packet(&extensions); 894 ASSERT_TRUE(packet.Parse(kPacket1, sizeof(kPacket1))); 895 896 std::string rsid; 897 EXPECT_TRUE(packet.GetExtension<RtpStreamId>(&rsid)); 898 EXPECT_EQ(rsid, "rtx"); 899 900 std::string repaired_rsid; 901 EXPECT_TRUE(packet.GetExtension<RepairedRtpStreamId>(&repaired_rsid)); 902 EXPECT_EQ(repaired_rsid, "HD"); 903 904 // Parse another packet with RtpStreamId extension of different size. 905 ASSERT_TRUE(packet.Parse(kPacket2, sizeof(kPacket2))); 906 EXPECT_TRUE(packet.GetExtension<RtpStreamId>(&rsid)); 907 EXPECT_EQ(rsid, "HD"); 908 EXPECT_FALSE(packet.GetExtension<RepairedRtpStreamId>(&repaired_rsid)); 909 } 910 911 TEST(RtpPacketTest, ParseWithMid) { 912 RtpPacketReceived::ExtensionManager extensions; 913 extensions.Register<RtpMid>(kRtpMidExtensionId); 914 RtpPacketReceived packet(&extensions); 915 ASSERT_TRUE(packet.Parse(kPacketWithMid, sizeof(kPacketWithMid))); 916 917 std::string mid; 918 EXPECT_TRUE(packet.GetExtension<RtpMid>(&mid)); 919 EXPECT_EQ(mid, kMid); 920 } 921 922 struct UncopyableValue { 923 UncopyableValue() = default; 924 UncopyableValue(const UncopyableValue&) = delete; 925 UncopyableValue& operator=(const UncopyableValue&) = delete; 926 }; 927 struct UncopyableExtension { 928 static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor; 929 static constexpr absl::string_view Uri() { return "uri"; } 930 931 static size_t ValueSize(const UncopyableValue& /* value */) { return 1; } 932 static bool Write(ArrayView<uint8_t> /* data */, 933 const UncopyableValue& /* value */) { 934 return true; 935 } 936 static bool Parse(ArrayView<const uint8_t> /* data */, 937 UncopyableValue* /* value */) { 938 return true; 939 } 940 }; 941 942 TEST(RtpPacketTest, SetUncopyableExtension) { 943 RtpPacket::ExtensionManager extensions; 944 extensions.Register<UncopyableExtension>(1); 945 RtpPacket rtp_packet(&extensions); 946 947 UncopyableValue value; 948 EXPECT_TRUE(rtp_packet.SetExtension<UncopyableExtension>(value)); 949 } 950 951 TEST(RtpPacketTest, GetUncopyableExtension) { 952 RtpPacket::ExtensionManager extensions; 953 extensions.Register<UncopyableExtension>(1); 954 RtpPacket rtp_packet(&extensions); 955 UncopyableValue value; 956 rtp_packet.SetExtension<UncopyableExtension>(value); 957 958 UncopyableValue value2; 959 EXPECT_TRUE(rtp_packet.GetExtension<UncopyableExtension>(&value2)); 960 } 961 962 struct ParseByReferenceExtension { 963 static constexpr RTPExtensionType kId = kRtpExtensionDependencyDescriptor; 964 static constexpr absl::string_view Uri() { return "uri"; } 965 966 static size_t ValueSize(uint8_t /* value1 */, uint8_t /* value2 */) { 967 return 2; 968 } 969 static bool Write(ArrayView<uint8_t> data, uint8_t value1, uint8_t value2) { 970 data[0] = value1; 971 data[1] = value2; 972 return true; 973 } 974 static bool Parse(ArrayView<const uint8_t> data, 975 uint8_t& value1, 976 uint8_t& value2) { 977 value1 = data[0]; 978 value2 = data[1]; 979 return true; 980 } 981 }; 982 983 TEST(RtpPacketTest, GetExtensionByReference) { 984 RtpHeaderExtensionMap extensions; 985 extensions.Register<ParseByReferenceExtension>(1); 986 RtpPacket rtp_packet(&extensions); 987 rtp_packet.SetExtension<ParseByReferenceExtension>(13, 42); 988 989 uint8_t value1 = 1; 990 uint8_t value2 = 1; 991 EXPECT_TRUE( 992 rtp_packet.GetExtension<ParseByReferenceExtension>(value1, value2)); 993 EXPECT_EQ(int{value1}, 13); 994 EXPECT_EQ(int{value2}, 42); 995 } 996 997 TEST(RtpPacketTest, CreateAndParseTimingFrameExtension) { 998 // Create a packet with video frame timing extension populated. 999 RtpPacketToSend::ExtensionManager send_extensions; 1000 send_extensions.Register<VideoTimingExtension>(kVideoTimingExtensionId); 1001 RtpPacketToSend send_packet(&send_extensions); 1002 send_packet.SetPayloadType(kPayloadType); 1003 send_packet.SetSequenceNumber(kSeqNum); 1004 send_packet.SetTimestamp(kTimestamp); 1005 send_packet.SetSsrc(kSsrc); 1006 1007 VideoSendTiming timing; 1008 timing.encode_start_delta_ms = 1; 1009 timing.encode_finish_delta_ms = 2; 1010 timing.packetization_finish_delta_ms = 3; 1011 timing.pacer_exit_delta_ms = 4; 1012 timing.flags = 1013 VideoSendTiming::kTriggeredByTimer | VideoSendTiming::kTriggeredBySize; 1014 1015 send_packet.SetExtension<VideoTimingExtension>(timing); 1016 1017 // Serialize the packet and then parse it again. 1018 RtpPacketReceived::ExtensionManager extensions; 1019 extensions.Register<VideoTimingExtension>(kVideoTimingExtensionId); 1020 RtpPacketReceived receive_packet(&extensions); 1021 EXPECT_TRUE(receive_packet.Parse(send_packet.Buffer())); 1022 1023 VideoSendTiming receivied_timing; 1024 EXPECT_TRUE( 1025 receive_packet.GetExtension<VideoTimingExtension>(&receivied_timing)); 1026 1027 // Only check first and last timestamp (covered by other tests) plus flags. 1028 EXPECT_EQ(receivied_timing.encode_start_delta_ms, 1029 timing.encode_start_delta_ms); 1030 EXPECT_EQ(receivied_timing.pacer_exit_delta_ms, timing.pacer_exit_delta_ms); 1031 EXPECT_EQ(receivied_timing.flags, timing.flags); 1032 } 1033 1034 TEST(RtpPacketTest, ParseLegacyTimingFrameExtension) { 1035 // Parse the modified packet. 1036 RtpPacketReceived::ExtensionManager extensions; 1037 extensions.Register<VideoTimingExtension>(kVideoTimingExtensionId); 1038 RtpPacketReceived packet(&extensions); 1039 EXPECT_TRUE(packet.Parse(kPacketWithLegacyTimingExtension, 1040 sizeof(kPacketWithLegacyTimingExtension))); 1041 VideoSendTiming receivied_timing; 1042 EXPECT_TRUE(packet.GetExtension<VideoTimingExtension>(&receivied_timing)); 1043 1044 // Check first and last timestamp are still OK. Flags should now be 0. 1045 EXPECT_EQ(receivied_timing.encode_start_delta_ms, 1); 1046 EXPECT_EQ(receivied_timing.pacer_exit_delta_ms, 4); 1047 EXPECT_EQ(receivied_timing.flags, 0); 1048 } 1049 1050 TEST(RtpPacketTest, CreateAndParseColorSpaceExtension) { 1051 TestCreateAndParseColorSpaceExtension(/*with_hdr_metadata=*/true); 1052 } 1053 1054 TEST(RtpPacketTest, CreateAndParseColorSpaceExtensionWithoutHdrMetadata) { 1055 TestCreateAndParseColorSpaceExtension(/*with_hdr_metadata=*/false); 1056 } 1057 1058 TEST(RtpPacketTest, CreateAndParseAbsoluteCaptureTime) { 1059 // Create a packet with absolute capture time extension populated. 1060 RtpPacketToSend::ExtensionManager extensions(/*extmap_allow_mixed=*/true); 1061 extensions.Register<AbsoluteCaptureTimeExtension>(kTwoByteExtensionId); 1062 RtpPacketToSend send_packet(&extensions); 1063 send_packet.SetPayloadType(kPayloadType); 1064 send_packet.SetSequenceNumber(kSeqNum); 1065 send_packet.SetTimestamp(kTimestamp); 1066 send_packet.SetSsrc(kSsrc); 1067 1068 constexpr AbsoluteCaptureTime kAbsoluteCaptureTime{ 1069 .absolute_capture_timestamp = 9876543210123456789ULL, 1070 .estimated_capture_clock_offset = -1234567890987654321LL}; 1071 ASSERT_TRUE(send_packet.SetExtension<AbsoluteCaptureTimeExtension>( 1072 kAbsoluteCaptureTime)); 1073 1074 // Serialize the packet and then parse it again. 1075 RtpPacketReceived receive_packet(&extensions); 1076 EXPECT_TRUE(receive_packet.Parse(send_packet.Buffer())); 1077 1078 AbsoluteCaptureTime received_absolute_capture_time; 1079 EXPECT_TRUE(receive_packet.GetExtension<AbsoluteCaptureTimeExtension>( 1080 &received_absolute_capture_time)); 1081 EXPECT_EQ(kAbsoluteCaptureTime.absolute_capture_timestamp, 1082 received_absolute_capture_time.absolute_capture_timestamp); 1083 EXPECT_EQ(kAbsoluteCaptureTime.estimated_capture_clock_offset, 1084 received_absolute_capture_time.estimated_capture_clock_offset); 1085 } 1086 1087 TEST(RtpPacketTest, 1088 CreateAndParseAbsoluteCaptureTimeWithoutEstimatedCaptureClockOffset) { 1089 // Create a packet with absolute capture time extension populated. 1090 RtpPacketToSend::ExtensionManager extensions(/*extmap_allow_mixed=*/true); 1091 extensions.Register<AbsoluteCaptureTimeExtension>(kTwoByteExtensionId); 1092 RtpPacketToSend send_packet(&extensions); 1093 send_packet.SetPayloadType(kPayloadType); 1094 send_packet.SetSequenceNumber(kSeqNum); 1095 send_packet.SetTimestamp(kTimestamp); 1096 send_packet.SetSsrc(kSsrc); 1097 1098 constexpr AbsoluteCaptureTime kAbsoluteCaptureTime{ 1099 .absolute_capture_timestamp = 9876543210123456789ULL, 1100 .estimated_capture_clock_offset = std::nullopt}; 1101 ASSERT_TRUE(send_packet.SetExtension<AbsoluteCaptureTimeExtension>( 1102 kAbsoluteCaptureTime)); 1103 1104 // Serialize the packet and then parse it again. 1105 RtpPacketReceived receive_packet(&extensions); 1106 EXPECT_TRUE(receive_packet.Parse(send_packet.Buffer())); 1107 1108 AbsoluteCaptureTime received_absolute_capture_time; 1109 EXPECT_TRUE(receive_packet.GetExtension<AbsoluteCaptureTimeExtension>( 1110 &received_absolute_capture_time)); 1111 EXPECT_EQ(kAbsoluteCaptureTime.absolute_capture_timestamp, 1112 received_absolute_capture_time.absolute_capture_timestamp); 1113 EXPECT_EQ(kAbsoluteCaptureTime.estimated_capture_clock_offset, 1114 received_absolute_capture_time.estimated_capture_clock_offset); 1115 } 1116 1117 TEST(RtpPacketTest, CreateAndParseTransportSequenceNumber) { 1118 // Create a packet with transport sequence number extension populated. 1119 RtpPacketToSend::ExtensionManager extensions; 1120 constexpr int kExtensionId = 1; 1121 extensions.Register<TransportSequenceNumber>(kExtensionId); 1122 RtpPacketToSend send_packet(&extensions); 1123 send_packet.SetPayloadType(kPayloadType); 1124 send_packet.SetSequenceNumber(kSeqNum); 1125 send_packet.SetTimestamp(kTimestamp); 1126 send_packet.SetSsrc(kSsrc); 1127 1128 constexpr int kTransportSequenceNumber = 12345; 1129 send_packet.SetExtension<TransportSequenceNumber>(kTransportSequenceNumber); 1130 1131 // Serialize the packet and then parse it again. 1132 RtpPacketReceived receive_packet(&extensions); 1133 EXPECT_TRUE(receive_packet.Parse(send_packet.Buffer())); 1134 1135 uint16_t received_transport_sequeunce_number; 1136 EXPECT_TRUE(receive_packet.GetExtension<TransportSequenceNumber>( 1137 &received_transport_sequeunce_number)); 1138 EXPECT_EQ(received_transport_sequeunce_number, kTransportSequenceNumber); 1139 } 1140 1141 TEST(RtpPacketTest, CreateAndParseTransportSequenceNumberV2) { 1142 // Create a packet with transport sequence number V2 extension populated. 1143 // No feedback request means that the extension will be two bytes unless it's 1144 // pre-allocated. 1145 RtpPacketToSend::ExtensionManager extensions; 1146 constexpr int kExtensionId = 1; 1147 extensions.Register<TransportSequenceNumberV2>(kExtensionId); 1148 RtpPacketToSend send_packet(&extensions); 1149 send_packet.SetPayloadType(kPayloadType); 1150 send_packet.SetSequenceNumber(kSeqNum); 1151 send_packet.SetTimestamp(kTimestamp); 1152 send_packet.SetSsrc(kSsrc); 1153 1154 constexpr int kTransportSequenceNumber = 12345; 1155 send_packet.SetExtension<TransportSequenceNumberV2>(kTransportSequenceNumber, 1156 std::nullopt); 1157 EXPECT_EQ(send_packet.GetRawExtension<TransportSequenceNumberV2>().size(), 1158 2u); 1159 1160 // Serialize the packet and then parse it again. 1161 RtpPacketReceived receive_packet(&extensions); 1162 EXPECT_TRUE(receive_packet.Parse(send_packet.Buffer())); 1163 1164 uint16_t received_transport_sequeunce_number; 1165 std::optional<FeedbackRequest> received_feedback_request; 1166 EXPECT_TRUE(receive_packet.GetExtension<TransportSequenceNumberV2>( 1167 &received_transport_sequeunce_number, &received_feedback_request)); 1168 EXPECT_EQ(received_transport_sequeunce_number, kTransportSequenceNumber); 1169 EXPECT_FALSE(received_feedback_request); 1170 } 1171 1172 TEST(RtpPacketTest, CreateAndParseTransportSequenceNumberV2Preallocated) { 1173 // Create a packet with transport sequence number V2 extension populated. 1174 // No feedback request means that the extension could be two bytes, but since 1175 // it's pre-allocated we don't know if it is with or without feedback request 1176 // therefore the size is four bytes. 1177 RtpPacketToSend::ExtensionManager extensions; 1178 constexpr int kExtensionId = 1; 1179 extensions.Register<TransportSequenceNumberV2>(kExtensionId); 1180 RtpPacketToSend send_packet(&extensions); 1181 send_packet.SetPayloadType(kPayloadType); 1182 send_packet.SetSequenceNumber(kSeqNum); 1183 send_packet.SetTimestamp(kTimestamp); 1184 send_packet.SetSsrc(kSsrc); 1185 1186 constexpr int kTransportSequenceNumber = 12345; 1187 constexpr std::optional<FeedbackRequest> kNoFeedbackRequest = 1188 FeedbackRequest{.include_timestamps = false, .sequence_count = 0}; 1189 send_packet.ReserveExtension<TransportSequenceNumberV2>(); 1190 send_packet.SetExtension<TransportSequenceNumberV2>(kTransportSequenceNumber, 1191 kNoFeedbackRequest); 1192 EXPECT_EQ(send_packet.GetRawExtension<TransportSequenceNumberV2>().size(), 1193 4u); 1194 1195 // Serialize the packet and then parse it again. 1196 RtpPacketReceived receive_packet(&extensions); 1197 EXPECT_TRUE(receive_packet.Parse(send_packet.Buffer())); 1198 1199 uint16_t received_transport_sequeunce_number; 1200 std::optional<FeedbackRequest> received_feedback_request; 1201 EXPECT_TRUE(receive_packet.GetExtension<TransportSequenceNumberV2>( 1202 &received_transport_sequeunce_number, &received_feedback_request)); 1203 EXPECT_EQ(received_transport_sequeunce_number, kTransportSequenceNumber); 1204 EXPECT_FALSE(received_feedback_request); 1205 } 1206 1207 TEST(RtpPacketTest, 1208 CreateAndParseTransportSequenceNumberV2WithFeedbackRequest) { 1209 // Create a packet with TransportSequenceNumberV2 extension populated. 1210 RtpPacketToSend::ExtensionManager extensions; 1211 constexpr int kExtensionId = 1; 1212 extensions.Register<TransportSequenceNumberV2>(kExtensionId); 1213 RtpPacketToSend send_packet(&extensions); 1214 send_packet.SetPayloadType(kPayloadType); 1215 send_packet.SetSequenceNumber(kSeqNum); 1216 send_packet.SetTimestamp(kTimestamp); 1217 send_packet.SetSsrc(kSsrc); 1218 1219 constexpr int kTransportSequenceNumber = 12345; 1220 constexpr std::optional<FeedbackRequest> kFeedbackRequest = 1221 FeedbackRequest{.include_timestamps = true, .sequence_count = 3}; 1222 send_packet.SetExtension<TransportSequenceNumberV2>(kTransportSequenceNumber, 1223 kFeedbackRequest); 1224 1225 // Serialize the packet and then parse it again. 1226 RtpPacketReceived receive_packet(&extensions); 1227 EXPECT_TRUE(receive_packet.Parse(send_packet.Buffer())); 1228 1229 // Parse transport sequence number and feedback request. 1230 uint16_t received_transport_sequeunce_number; 1231 std::optional<FeedbackRequest> received_feedback_request; 1232 EXPECT_TRUE(receive_packet.GetExtension<TransportSequenceNumberV2>( 1233 &received_transport_sequeunce_number, &received_feedback_request)); 1234 EXPECT_EQ(received_transport_sequeunce_number, kTransportSequenceNumber); 1235 ASSERT_TRUE(received_feedback_request); 1236 EXPECT_EQ(received_feedback_request->include_timestamps, 1237 kFeedbackRequest->include_timestamps); 1238 EXPECT_EQ(received_feedback_request->sequence_count, 1239 kFeedbackRequest->sequence_count); 1240 } 1241 1242 TEST(RtpPacketTest, ReservedExtensionsCountedAsSetExtension) { 1243 // Register two extensions. 1244 RtpPacketToSend::ExtensionManager extensions; 1245 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 1246 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 1247 1248 RtpPacketReceived packet(&extensions); 1249 1250 // Reserve slot for only one of them. 1251 EXPECT_TRUE(packet.ReserveExtension<TransmissionOffset>()); 1252 // Non-registered extension cannot be reserved. 1253 EXPECT_FALSE(packet.ReserveExtension<VideoContentTypeExtension>()); 1254 1255 // Only the extension that is both registered and reserved matches 1256 // IsExtensionReserved(). 1257 EXPECT_FALSE(packet.HasExtension<VideoContentTypeExtension>()); 1258 EXPECT_FALSE(packet.HasExtension<AudioLevelExtension>()); 1259 EXPECT_TRUE(packet.HasExtension<TransmissionOffset>()); 1260 } 1261 1262 // Tests that RtpPacket::RemoveExtension can successfully remove extensions. 1263 TEST(RtpPacketTest, RemoveMultipleExtensions) { 1264 RtpPacketToSend::ExtensionManager extensions; 1265 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 1266 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 1267 RtpPacketToSend packet(&extensions); 1268 packet.SetPayloadType(kPayloadType); 1269 packet.SetSequenceNumber(kSeqNum); 1270 packet.SetTimestamp(kTimestamp); 1271 packet.SetSsrc(kSsrc); 1272 packet.SetExtension<TransmissionOffset>(kTimeOffset); 1273 packet.SetExtension<AudioLevelExtension>( 1274 AudioLevel(kVoiceActive, kAudioLevel)); 1275 1276 EXPECT_THAT(kPacketWithTOAndAL, 1277 ElementsAreArray(packet.data(), packet.size())); 1278 1279 // Remove one of two extensions. 1280 EXPECT_TRUE(packet.RemoveExtension(kRtpExtensionAudioLevel)); 1281 1282 EXPECT_THAT(kPacketWithTO, ElementsAreArray(packet.data(), packet.size())); 1283 1284 // Remove remaining extension. 1285 EXPECT_TRUE(packet.RemoveExtension(kRtpExtensionTransmissionTimeOffset)); 1286 1287 EXPECT_THAT(kMinimumPacket, ElementsAreArray(packet.data(), packet.size())); 1288 } 1289 1290 // Tests that RtpPacket::RemoveExtension can successfully remove extension when 1291 // other extensions are present but not registered. 1292 TEST(RtpPacketTest, RemoveExtensionPreservesOtherUnregisteredExtensions) { 1293 RtpPacketToSend::ExtensionManager extensions; 1294 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 1295 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 1296 RtpPacketToSend packet(&extensions); 1297 packet.SetPayloadType(kPayloadType); 1298 packet.SetSequenceNumber(kSeqNum); 1299 packet.SetTimestamp(kTimestamp); 1300 packet.SetSsrc(kSsrc); 1301 packet.SetExtension<TransmissionOffset>(kTimeOffset); 1302 packet.SetExtension<AudioLevelExtension>( 1303 AudioLevel(kVoiceActive, kAudioLevel)); 1304 1305 EXPECT_THAT(kPacketWithTOAndAL, 1306 ElementsAreArray(packet.data(), packet.size())); 1307 1308 // "Unregister" kRtpExtensionTransmissionTimeOffset. 1309 RtpPacketToSend::ExtensionManager extensions1; 1310 extensions1.Register<AudioLevelExtension>(kAudioLevelExtensionId); 1311 packet.IdentifyExtensions(extensions1); 1312 1313 // Make sure we can not delete extension which is set but not registered. 1314 EXPECT_FALSE(packet.RemoveExtension(kRtpExtensionTransmissionTimeOffset)); 1315 1316 // Remove registered extension. 1317 EXPECT_TRUE(packet.RemoveExtension(kRtpExtensionAudioLevel)); 1318 1319 EXPECT_THAT(kPacketWithTO, ElementsAreArray(packet.data(), packet.size())); 1320 } 1321 1322 // Tests that RtpPacket::RemoveExtension fails if extension is not present or 1323 // not registered and does not modify packet. 1324 TEST(RtpPacketTest, RemoveExtensionFailure) { 1325 RtpPacketToSend::ExtensionManager extensions; 1326 extensions.Register<TransmissionOffset>(kTransmissionOffsetExtensionId); 1327 extensions.Register<AudioLevelExtension>(kAudioLevelExtensionId); 1328 RtpPacketToSend packet(&extensions); 1329 packet.SetPayloadType(kPayloadType); 1330 packet.SetSequenceNumber(kSeqNum); 1331 packet.SetTimestamp(kTimestamp); 1332 packet.SetSsrc(kSsrc); 1333 packet.SetExtension<TransmissionOffset>(kTimeOffset); 1334 1335 EXPECT_THAT(kPacketWithTO, ElementsAreArray(packet.data(), packet.size())); 1336 1337 // Try to remove extension, which was registered, but not set. 1338 EXPECT_FALSE(packet.RemoveExtension(kRtpExtensionAudioLevel)); 1339 1340 EXPECT_THAT(kPacketWithTO, ElementsAreArray(packet.data(), packet.size())); 1341 1342 // Try to remove extension, which was not registered. 1343 EXPECT_FALSE(packet.RemoveExtension(kRtpExtensionPlayoutDelay)); 1344 1345 EXPECT_THAT(kPacketWithTO, ElementsAreArray(packet.data(), packet.size())); 1346 } 1347 1348 TEST(RtpPacketTest, SetExtensionWithArray) { 1349 RtpPacketToSend::ExtensionManager extensions; 1350 extensions.Register<RtpDependencyDescriptorExtension>( 1351 kDependencyDescriptorExtensionId); 1352 RtpPacketToSend packet(&extensions); 1353 const uint8_t extension_data[] = {1, 2, 3, 4, 5}; 1354 packet.SetRawExtension<RtpDependencyDescriptorExtension>(extension_data); 1355 EXPECT_THAT(packet.GetRawExtension<RtpDependencyDescriptorExtension>(), 1356 ElementsAreArray(extension_data)); 1357 } 1358 1359 } // namespace 1360 } // namespace webrtc