xref: /aosp_15_r20/external/webrtc/modules/rtp_rtcp/source/rtp_packet_unittest.cc (revision d9f758449e529ab9291ac668be2861e7a55c2422)
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