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