OLD | NEW |
---|---|
(Empty) | |
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 "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h" | |
11 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" | |
12 | |
13 #include "testing/gmock/include/gmock/gmock.h" | |
14 #include "testing/gtest/include/gtest/gtest.h" | |
15 #include "webrtc/base/random.h" | |
16 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h" | |
17 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h" | |
18 | |
19 using testing::ElementsAreArray; | |
20 using testing::make_tuple; | |
21 | |
22 namespace webrtc { | |
23 namespace { | |
24 const int8_t kPayloadType = 100; | |
25 const uint32_t kSsrc = 0x12345678; | |
26 const uint16_t kSeqNum = 88; | |
27 const uint32_t kTimestamp = 0x65431278; | |
28 const uint8_t kTransmissionOffsetExtensionId = 1; | |
29 const uint8_t kAudioLevelExtensionId = 9; | |
30 const int32_t kTimeOffset = 0x56ce; | |
31 const bool kVoiceActive = true; | |
32 const uint8_t kAudioLevel = 0x5a; | |
33 // const size_t kMaxPaddingSize = 224u; | |
sprang_webrtc
2016/04/20 07:49:35
Unused?
danilchap
2016/04/20 08:52:54
Oops, made used.
| |
34 const uint8_t kMinimumPacket[] = {0x80, kPayloadType, 0x00, kSeqNum, | |
35 0x65, 0x43, 0x12, 0x78, | |
36 0x12, 0x34, 0x56, 0x78}; | |
37 const uint8_t kPacketWithTO[] = { | |
38 0x90, kPayloadType, 0x00, kSeqNum, | |
39 0x65, 0x43, 0x12, 0x78, | |
40 0x12, 0x34, 0x56, 0x78, | |
41 0xbe, 0xde, 0x00, 0x01, | |
42 0x12, 0x00, 0x56, 0xce}; | |
43 | |
44 const uint8_t kPacketWithTOAndAL[] = { | |
45 0x90, kPayloadType, 0x00, kSeqNum, | |
46 0x65, 0x43, 0x12, 0x78, | |
47 0x12, 0x34, 0x56, 0x78, | |
48 0xbe, 0xde, 0x00, 0x02, | |
49 0x12, 0x00, 0x56, 0xce, | |
50 0x90, 0x80|kAudioLevel, 0x00, 0x00}; | |
51 | |
52 const uint32_t kCsrcs[] = {0x34567890, 0x32435465}; | |
53 const uint8_t kPayload[] = {'p', 'a', 'y', 'l', 'o', 'a', 'd'}; | |
54 const uint8_t kPacketPaddingSize = 8; | |
55 const uint8_t kPacket[] = { | |
56 0xb2, kPayloadType, 0x00, kSeqNum, | |
57 0x65, 0x43, 0x12, 0x78, | |
58 0x12, 0x34, 0x56, 0x78, | |
59 0x34, 0x56, 0x78, 0x90, | |
60 0x32, 0x43, 0x54, 0x65, | |
61 0xbe, 0xde, 0x00, 0x01, | |
62 0x12, 0x00, 0x56, 0xce, | |
63 'p', 'a', 'y', 'l', 'o', 'a', 'd', | |
64 'p', 'a', 'd', 'd', 'i', 'n', 'g', kPacketPaddingSize}; | |
65 | |
66 } // namespace | |
67 | |
68 TEST(RtpPacketTest, CreateMinimum) { | |
69 RtpPacketToSend packet(nullptr); | |
70 packet.SetPayloadType(kPayloadType); | |
71 packet.SetSequenceNumber(kSeqNum); | |
72 packet.SetTimestamp(kTimestamp); | |
73 packet.SetSsrc(kSsrc); | |
74 EXPECT_THAT(kMinimumPacket, ElementsAreArray(packet.data(), packet.size())); | |
75 } | |
76 | |
77 TEST(RtpPacketTest, CreateWithExtension) { | |
78 RtpPacketToSend::ExtensionManager extensions; | |
79 extensions.Register(kRtpExtensionTransmissionTimeOffset, | |
80 kTransmissionOffsetExtensionId); | |
81 RtpPacketToSend packet(&extensions); | |
82 packet.SetPayloadType(kPayloadType); | |
83 packet.SetSequenceNumber(kSeqNum); | |
84 packet.SetTimestamp(kTimestamp); | |
85 packet.SetSsrc(kSsrc); | |
86 packet.SetExtension<TransmissionOffset>(kTimeOffset); | |
87 EXPECT_THAT(kPacketWithTO, ElementsAreArray(packet.data(), packet.size())); | |
88 } | |
89 | |
90 TEST(RtpPacketTest, CreateWith2Extensions) { | |
91 RtpPacketToSend::ExtensionManager extensions; | |
92 extensions.Register(kRtpExtensionTransmissionTimeOffset, | |
93 kTransmissionOffsetExtensionId); | |
94 extensions.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId); | |
95 RtpPacketToSend packet(&extensions); | |
96 packet.SetPayloadType(kPayloadType); | |
97 packet.SetSequenceNumber(kSeqNum); | |
98 packet.SetTimestamp(kTimestamp); | |
99 packet.SetSsrc(kSsrc); | |
100 packet.SetExtension<TransmissionOffset>(kTimeOffset); | |
101 packet.SetExtension<AudioLevel>(kVoiceActive, kAudioLevel); | |
102 EXPECT_THAT(kPacketWithTOAndAL, | |
103 ElementsAreArray(packet.data(), packet.size())); | |
104 } | |
105 | |
106 TEST(RtpPacketTest, SetReservedExtensionsAfterPayload) { | |
107 const size_t kPayloadSize = 4; | |
108 RtpPacketToSend::ExtensionManager extensions; | |
109 extensions.Register(kRtpExtensionTransmissionTimeOffset, | |
110 kTransmissionOffsetExtensionId); | |
111 extensions.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId); | |
112 RtpPacketToSend packet(&extensions); | |
113 | |
114 EXPECT_TRUE(packet.ReserveExtension<TransmissionOffset>()); | |
115 packet.AllocatePayload(kPayloadSize); | |
116 // Can't set extension after payload. | |
117 EXPECT_FALSE(packet.SetExtension<AudioLevel>(kVoiceActive, kAudioLevel)); | |
118 // Unless reserved. | |
119 EXPECT_TRUE(packet.SetExtension<TransmissionOffset>(kTimeOffset)); | |
120 } | |
121 | |
122 TEST(RtpPacketTest, CreatePurePadding) { | |
123 const uint8_t kPaddingSize = 0xfe; | |
124 RtpPacketToSend packet(nullptr, 12 + kPaddingSize); | |
125 packet.SetPayloadType(kPayloadType); | |
126 packet.SetSequenceNumber(kSeqNum); | |
127 packet.SetTimestamp(kTimestamp); | |
128 packet.SetSsrc(kSsrc); | |
129 Random random(0x123456789); | |
130 | |
131 EXPECT_LT(packet.size(), packet.capacity()); | |
132 EXPECT_FALSE(packet.SetPadding(kPaddingSize + 1, &random)); | |
133 EXPECT_TRUE(packet.SetPadding(kPaddingSize, &random)); | |
134 EXPECT_EQ(packet.size(), packet.capacity()); | |
135 } | |
136 | |
137 TEST(RtpPacketTest, CreateUnalignedPadding) { | |
138 const size_t kPayloadSize = 3; // Make padding start at unaligned address. | |
139 const uint8_t kPaddingSize = 0xfe; | |
140 RtpPacketToSend packet(nullptr, 12 + kPayloadSize + kPaddingSize); | |
141 packet.SetPayloadType(kPayloadType); | |
142 packet.SetSequenceNumber(kSeqNum); | |
143 packet.SetTimestamp(kTimestamp); | |
144 packet.SetSsrc(kSsrc); | |
145 packet.AllocatePayload(kPayloadSize); | |
146 Random r(0x123456789); | |
147 | |
148 EXPECT_LT(packet.size(), packet.capacity()); | |
149 EXPECT_TRUE(packet.SetPadding(kPaddingSize, &r)); | |
150 EXPECT_EQ(packet.size(), packet.capacity()); | |
151 } | |
152 | |
153 TEST(RtpPacketTest, ParseMinimum) { | |
154 RtpPacketReceived packet; | |
155 EXPECT_TRUE(packet.Parse(kMinimumPacket, sizeof(kMinimumPacket))); | |
156 EXPECT_EQ(kPayloadType, packet.PayloadType()); | |
157 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); | |
158 EXPECT_EQ(kTimestamp, packet.Timestamp()); | |
159 EXPECT_EQ(kSsrc, packet.Ssrc()); | |
160 EXPECT_EQ(0u, packet.padding_size()); | |
161 EXPECT_EQ(0u, packet.payload_size()); | |
162 } | |
163 | |
164 TEST(RtpPacketTest, ParseBuffer) { | |
165 rtc::Buffer unparsed(kMinimumPacket); | |
166 const uint8_t* raw = unparsed.data(); | |
167 | |
168 RtpPacketReceived packet; | |
169 EXPECT_TRUE(packet.Parse(std::move(unparsed))); | |
170 EXPECT_EQ(raw, packet.data()); // Expect packet took over the buffer. | |
171 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); | |
172 EXPECT_EQ(kTimestamp, packet.Timestamp()); | |
173 EXPECT_EQ(kSsrc, packet.Ssrc()); | |
174 EXPECT_EQ(0u, packet.padding_size()); | |
175 EXPECT_EQ(0u, packet.payload_size()); | |
176 } | |
177 | |
178 TEST(RtpPacketTest, ParseWithExtension) { | |
179 RtpPacketToSend::ExtensionManager extensions; | |
180 extensions.Register(kRtpExtensionTransmissionTimeOffset, | |
181 kTransmissionOffsetExtensionId); | |
182 | |
183 RtpPacketReceived packet(&extensions); | |
184 EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO))); | |
185 EXPECT_EQ(kPayloadType, packet.PayloadType()); | |
186 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); | |
187 EXPECT_EQ(kTimestamp, packet.Timestamp()); | |
188 EXPECT_EQ(kSsrc, packet.Ssrc()); | |
189 int32_t time_offset; | |
190 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); | |
191 EXPECT_EQ(kTimeOffset, time_offset); | |
192 EXPECT_EQ(0u, packet.payload_size()); | |
193 EXPECT_EQ(0u, packet.padding_size()); | |
194 } | |
195 | |
196 TEST(RtpPacketTest, ParseWith2Extensions) { | |
197 RtpPacketToSend::ExtensionManager extensions; | |
198 extensions.Register(kRtpExtensionTransmissionTimeOffset, | |
199 kTransmissionOffsetExtensionId); | |
200 extensions.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId); | |
201 RtpPacketReceived packet(&extensions); | |
202 EXPECT_TRUE(packet.Parse(kPacketWithTOAndAL, sizeof(kPacketWithTOAndAL))); | |
203 int32_t time_offset; | |
204 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); | |
205 EXPECT_EQ(kTimeOffset, time_offset); | |
206 bool voice_active; | |
207 uint8_t audio_level; | |
208 EXPECT_TRUE(packet.GetExtension<AudioLevel>(&voice_active, &audio_level)); | |
209 EXPECT_EQ(kVoiceActive, voice_active); | |
210 EXPECT_EQ(kAudioLevel, audio_level); | |
211 } | |
212 | |
213 TEST(RtpPacketTest, ParseWithAllFeatures) { | |
214 RtpPacketToSend::ExtensionManager extensions; | |
215 extensions.Register(kRtpExtensionTransmissionTimeOffset, | |
216 kTransmissionOffsetExtensionId); | |
217 RtpPacketReceived packet(&extensions); | |
218 EXPECT_TRUE(packet.Parse(kPacket, sizeof(kPacket))); | |
219 EXPECT_EQ(kPayloadType, packet.PayloadType()); | |
220 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); | |
221 EXPECT_EQ(kTimestamp, packet.Timestamp()); | |
222 EXPECT_EQ(kSsrc, packet.Ssrc()); | |
223 EXPECT_THAT(packet.Csrcs(), ElementsAreArray(kCsrcs)); | |
224 EXPECT_THAT(make_tuple(packet.payload(), packet.payload_size()), | |
225 ElementsAreArray(kPayload)); | |
226 EXPECT_EQ(kPacketPaddingSize, packet.padding_size()); | |
227 int32_t time_offset; | |
228 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); | |
229 } | |
230 | |
231 TEST(RtpPacketTest, ParseWithExtensionDelayed) { | |
232 RtpPacketReceived packet; | |
233 EXPECT_TRUE(packet.Parse(kPacketWithTO, sizeof(kPacketWithTO))); | |
234 EXPECT_EQ(kPayloadType, packet.PayloadType()); | |
235 EXPECT_EQ(kSeqNum, packet.SequenceNumber()); | |
236 EXPECT_EQ(kTimestamp, packet.Timestamp()); | |
237 EXPECT_EQ(kSsrc, packet.Ssrc()); | |
238 | |
239 RtpPacketToSend::ExtensionManager extensions; | |
240 extensions.Register(kRtpExtensionTransmissionTimeOffset, | |
241 kTransmissionOffsetExtensionId); | |
242 | |
243 int32_t time_offset; | |
244 EXPECT_FALSE(packet.GetExtension<TransmissionOffset>(&time_offset)); | |
245 packet.IdentifyExtensions(&extensions); | |
246 EXPECT_TRUE(packet.GetExtension<TransmissionOffset>(&time_offset)); | |
247 EXPECT_EQ(kTimeOffset, time_offset); | |
248 EXPECT_EQ(0u, packet.payload_size()); | |
249 EXPECT_EQ(0u, packet.padding_size()); | |
250 } | |
251 | |
252 } // namespace webrtc | |
OLD | NEW |