OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <memory> | 11 #include <memory> |
12 | 12 |
13 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h" | 13 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8.h" |
14 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h" | 14 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp8_test_helper.h" |
| 15 #include "webrtc/modules/rtp_rtcp/source/rtp_packet_to_send.h" |
15 #include "webrtc/test/gmock.h" | 16 #include "webrtc/test/gmock.h" |
16 #include "webrtc/test/gtest.h" | 17 #include "webrtc/test/gtest.h" |
17 #include "webrtc/typedefs.h" | 18 #include "webrtc/typedefs.h" |
18 | 19 |
19 #define CHECK_ARRAY_SIZE(expected_size, array) \ | 20 #define CHECK_ARRAY_SIZE(expected_size, array) \ |
20 static_assert(expected_size == sizeof(array) / sizeof(array[0]), \ | 21 static_assert(expected_size == sizeof(array) / sizeof(array[0]), \ |
21 "check array size"); | 22 "check array size"); |
22 | 23 |
23 namespace webrtc { | 24 namespace webrtc { |
24 namespace { | 25 namespace { |
| 26 |
| 27 using ::testing::ElementsAreArray; |
| 28 using ::testing::make_tuple; |
| 29 |
| 30 constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr; |
25 // Payload descriptor | 31 // Payload descriptor |
26 // 0 1 2 3 4 5 6 7 | 32 // 0 1 2 3 4 5 6 7 |
27 // +-+-+-+-+-+-+-+-+ | 33 // +-+-+-+-+-+-+-+-+ |
28 // |X|R|N|S|PartID | (REQUIRED) | 34 // |X|R|N|S|PartID | (REQUIRED) |
29 // +-+-+-+-+-+-+-+-+ | 35 // +-+-+-+-+-+-+-+-+ |
30 // X: |I|L|T|K| RSV | (OPTIONAL) | 36 // X: |I|L|T|K| RSV | (OPTIONAL) |
31 // +-+-+-+-+-+-+-+-+ | 37 // +-+-+-+-+-+-+-+-+ |
32 // I: | PictureID | (OPTIONAL) | 38 // I: | PictureID | (OPTIONAL) |
33 // +-+-+-+-+-+-+-+-+ | 39 // +-+-+-+-+-+-+-+-+ |
34 // L: | TL0PICIDX | (OPTIONAL) | 40 // L: | TL0PICIDX | (OPTIONAL) |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
93 RTPVideoHeaderVP8 hdr_info_; | 99 RTPVideoHeaderVP8 hdr_info_; |
94 test::RtpFormatVp8TestHelper* helper_; | 100 test::RtpFormatVp8TestHelper* helper_; |
95 }; | 101 }; |
96 | 102 |
97 TEST_F(RtpPacketizerVp8Test, TestStrictMode) { | 103 TEST_F(RtpPacketizerVp8Test, TestStrictMode) { |
98 const size_t kSizeVector[] = {10, 8, 27}; | 104 const size_t kSizeVector[] = {10, 8, 27}; |
99 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 105 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
100 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 106 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
101 | 107 |
102 hdr_info_.pictureId = 200; // > 0x7F should produce 2-byte PictureID. | 108 hdr_info_.pictureId = 200; // > 0x7F should produce 2-byte PictureID. |
103 const size_t kMaxSize = 13; | 109 const size_t kMaxPayloadSize = 13; |
104 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kStrict); | 110 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kStrict); |
105 packetizer.SetPayloadData(helper_->payload_data(), | 111 packetizer.SetPayloadData(helper_->payload_data(), |
106 helper_->payload_size(), | 112 helper_->payload_size(), |
107 helper_->fragmentation()); | 113 helper_->fragmentation()); |
108 | 114 |
109 // The expected sizes are obtained by running a verified good implementation. | 115 // The expected sizes are obtained by running a verified good implementation. |
110 const size_t kExpectedSizes[] = {9, 9, 12, 11, 11, 11, 10}; | 116 const size_t kExpectedSizes[] = {9, 9, 12, 11, 11, 11, 10}; |
111 const int kExpectedPart[] = {0, 0, 1, 2, 2, 2, 2}; | 117 const int kExpectedPart[] = {0, 0, 1, 2, 2, 2, 2}; |
112 const bool kExpectedFragStart[] = {true, false, true, true, | 118 const bool kExpectedFragStart[] = {true, false, true, true, |
113 false, false, false}; | 119 false, false, false}; |
114 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 120 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
115 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 121 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
116 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 122 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
117 | 123 |
118 helper_->GetAllPacketsAndCheck(&packetizer, | 124 helper_->GetAllPacketsAndCheck(&packetizer, |
119 kExpectedSizes, | 125 kExpectedSizes, |
120 kExpectedPart, | 126 kExpectedPart, |
121 kExpectedFragStart, | 127 kExpectedFragStart, |
122 kExpectedNum); | 128 kExpectedNum); |
123 } | 129 } |
124 | 130 |
125 // Verify that we get a minimal number of packets if the partition plus header | 131 // Verify that we get a minimal number of packets if the partition plus header |
126 // size fits exactly in the maximum packet size. | 132 // size fits exactly in the maximum packet size. |
127 // Test is disabled: https://code.google.com/p/webrtc/issues/detail?id=4019. | 133 // Test is disabled: https://code.google.com/p/webrtc/issues/detail?id=4019. |
128 TEST_F(RtpPacketizerVp8Test, DISABLED_TestStrictEqualTightPartitions) { | 134 TEST_F(RtpPacketizerVp8Test, DISABLED_TestStrictEqualTightPartitions) { |
129 const size_t kSizeVector[] = {10, 10, 10}; | 135 const size_t kSizeVector[] = {10, 10, 10}; |
130 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 136 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
131 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 137 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
132 | 138 |
133 hdr_info_.pictureId = 200; // > 0x7F should produce 2-byte PictureID. | 139 hdr_info_.pictureId = 200; // > 0x7F should produce 2-byte PictureID. |
134 const int kMaxSize = 14; | 140 const int kMaxPayloadSize = 14; |
135 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kStrict); | 141 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kStrict); |
136 packetizer.SetPayloadData(helper_->payload_data(), helper_->payload_size(), | 142 packetizer.SetPayloadData(helper_->payload_data(), helper_->payload_size(), |
137 helper_->fragmentation()); | 143 helper_->fragmentation()); |
138 | 144 |
139 // The expected sizes are obtained by running a verified good implementation. | 145 // The expected sizes are obtained by running a verified good implementation. |
140 const size_t kExpectedSizes[] = {14, 14, 14}; | 146 const size_t kExpectedSizes[] = {14, 14, 14}; |
141 const int kExpectedPart[] = {0, 1, 2}; | 147 const int kExpectedPart[] = {0, 1, 2}; |
142 const bool kExpectedFragStart[] = {true, true, true}; | 148 const bool kExpectedFragStart[] = {true, true, true}; |
143 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 149 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
144 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 150 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
145 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 151 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
146 | 152 |
147 helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart, | 153 helper_->GetAllPacketsAndCheck(&packetizer, kExpectedSizes, kExpectedPart, |
148 kExpectedFragStart, kExpectedNum); | 154 kExpectedFragStart, kExpectedNum); |
149 } | 155 } |
150 | 156 |
151 TEST_F(RtpPacketizerVp8Test, TestAggregateMode) { | 157 TEST_F(RtpPacketizerVp8Test, TestAggregateMode) { |
152 const size_t kSizeVector[] = {60, 10, 10}; | 158 const size_t kSizeVector[] = {60, 10, 10}; |
153 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 159 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
154 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 160 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
155 | 161 |
156 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. | 162 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. |
157 const size_t kMaxSize = 25; | 163 const size_t kMaxPayloadSize = 25; |
158 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate); | 164 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate); |
159 packetizer.SetPayloadData(helper_->payload_data(), | 165 packetizer.SetPayloadData(helper_->payload_data(), |
160 helper_->payload_size(), | 166 helper_->payload_size(), |
161 helper_->fragmentation()); | 167 helper_->fragmentation()); |
162 | 168 |
163 // The expected sizes are obtained by running a verified good implementation. | 169 // The expected sizes are obtained by running a verified good implementation. |
164 const size_t kExpectedSizes[] = {23, 23, 23, 23}; | 170 const size_t kExpectedSizes[] = {23, 23, 23, 23}; |
165 const int kExpectedPart[] = {0, 0, 0, 1}; | 171 const int kExpectedPart[] = {0, 0, 0, 1}; |
166 const bool kExpectedFragStart[] = {true, false, false, true}; | 172 const bool kExpectedFragStart[] = {true, false, false, true}; |
167 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 173 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
168 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 174 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
169 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 175 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
170 | 176 |
171 helper_->GetAllPacketsAndCheck(&packetizer, | 177 helper_->GetAllPacketsAndCheck(&packetizer, |
172 kExpectedSizes, | 178 kExpectedSizes, |
173 kExpectedPart, | 179 kExpectedPart, |
174 kExpectedFragStart, | 180 kExpectedFragStart, |
175 kExpectedNum); | 181 kExpectedNum); |
176 } | 182 } |
177 | 183 |
178 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions1) { | 184 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions1) { |
179 const size_t kSizeVector[] = {1600, 200, 200, 200, 200, 200, 200, 200, 200}; | 185 const size_t kSizeVector[] = {1600, 200, 200, 200, 200, 200, 200, 200, 200}; |
180 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 186 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
181 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 187 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
182 | 188 |
183 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. | 189 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. |
184 const size_t kMaxSize = 1500; | 190 const size_t kMaxPayloadSize = 1000; |
185 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate); | 191 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate); |
186 packetizer.SetPayloadData(helper_->payload_data(), | 192 packetizer.SetPayloadData(helper_->payload_data(), |
187 helper_->payload_size(), | 193 helper_->payload_size(), |
188 helper_->fragmentation()); | 194 helper_->fragmentation()); |
189 | 195 |
190 // The expected sizes are obtained by running a verified good implementation. | 196 // The expected sizes are obtained by running a verified good implementation. |
191 const size_t kExpectedSizes[] = {803, 803, 803, 803}; | 197 const size_t kExpectedSizes[] = {803, 803, 803, 803}; |
192 const int kExpectedPart[] = {0, 0, 1, 5}; | 198 const int kExpectedPart[] = {0, 0, 1, 5}; |
193 const bool kExpectedFragStart[] = {true, false, true, true}; | 199 const bool kExpectedFragStart[] = {true, false, true, true}; |
194 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 200 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
195 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 201 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
196 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 202 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
197 | 203 |
198 helper_->GetAllPacketsAndCheck(&packetizer, | 204 helper_->GetAllPacketsAndCheck(&packetizer, |
199 kExpectedSizes, | 205 kExpectedSizes, |
200 kExpectedPart, | 206 kExpectedPart, |
201 kExpectedFragStart, | 207 kExpectedFragStart, |
202 kExpectedNum); | 208 kExpectedNum); |
203 } | 209 } |
204 | 210 |
205 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions2) { | 211 TEST_F(RtpPacketizerVp8Test, TestAggregateModeManyPartitions2) { |
206 const size_t kSizeVector[] = {1599, 200, 200, 200, 1600, 200, 200, 200, 200}; | 212 const size_t kSizeVector[] = {1599, 200, 200, 200, 1600, 200, 200, 200, 200}; |
207 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 213 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
208 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 214 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
209 | 215 |
210 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. | 216 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. |
211 const size_t kMaxSize = 1500; | 217 const size_t kMaxPayloadSize = 1000; |
212 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate); | 218 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate); |
213 packetizer.SetPayloadData(helper_->payload_data(), | 219 packetizer.SetPayloadData(helper_->payload_data(), |
214 helper_->payload_size(), | 220 helper_->payload_size(), |
215 helper_->fragmentation()); | 221 helper_->fragmentation()); |
216 | 222 |
217 // The expected sizes are obtained by running a verified good implementation. | 223 // The expected sizes are obtained by running a verified good implementation. |
218 const size_t kExpectedSizes[] = {803, 802, 603, 803, 803, 803}; | 224 const size_t kExpectedSizes[] = {803, 802, 603, 803, 803, 803}; |
219 const int kExpectedPart[] = {0, 0, 1, 4, 4, 5}; | 225 const int kExpectedPart[] = {0, 0, 1, 4, 4, 5}; |
220 const bool kExpectedFragStart[] = {true, false, true, true, false, true}; | 226 const bool kExpectedFragStart[] = {true, false, true, true, false, true}; |
221 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 227 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
222 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 228 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
223 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 229 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
224 | 230 |
225 helper_->GetAllPacketsAndCheck(&packetizer, | 231 helper_->GetAllPacketsAndCheck(&packetizer, |
226 kExpectedSizes, | 232 kExpectedSizes, |
227 kExpectedPart, | 233 kExpectedPart, |
228 kExpectedFragStart, | 234 kExpectedFragStart, |
229 kExpectedNum); | 235 kExpectedNum); |
230 } | 236 } |
231 | 237 |
232 TEST_F(RtpPacketizerVp8Test, TestAggregateModeTwoLargePartitions) { | 238 TEST_F(RtpPacketizerVp8Test, TestAggregateModeTwoLargePartitions) { |
233 const size_t kSizeVector[] = {1654, 2268}; | 239 const size_t kSizeVector[] = {1654, 2268}; |
234 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 240 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
235 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 241 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
236 | 242 |
237 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. | 243 hdr_info_.pictureId = 20; // <= 0x7F should produce 1-byte PictureID. |
238 const size_t kMaxSize = 1460; | 244 const size_t kMaxPayloadSize = 1460; |
239 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate); | 245 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate); |
240 packetizer.SetPayloadData(helper_->payload_data(), | 246 packetizer.SetPayloadData(helper_->payload_data(), |
241 helper_->payload_size(), | 247 helper_->payload_size(), |
242 helper_->fragmentation()); | 248 helper_->fragmentation()); |
243 | 249 |
244 // The expected sizes are obtained by running a verified good implementation. | 250 // The expected sizes are obtained by running a verified good implementation. |
245 const size_t kExpectedSizes[] = {830, 830, 1137, 1137}; | 251 const size_t kExpectedSizes[] = {830, 830, 1137, 1137}; |
246 const int kExpectedPart[] = {0, 0, 1, 1}; | 252 const int kExpectedPart[] = {0, 0, 1, 1}; |
247 const bool kExpectedFragStart[] = {true, false, true, false}; | 253 const bool kExpectedFragStart[] = {true, false, true, false}; |
248 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 254 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
249 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 255 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
250 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 256 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
251 | 257 |
252 helper_->GetAllPacketsAndCheck(&packetizer, | 258 helper_->GetAllPacketsAndCheck(&packetizer, |
253 kExpectedSizes, | 259 kExpectedSizes, |
254 kExpectedPart, | 260 kExpectedPart, |
255 kExpectedFragStart, | 261 kExpectedFragStart, |
256 kExpectedNum); | 262 kExpectedNum); |
257 } | 263 } |
258 | 264 |
259 // Verify that EqualSize mode is forced if fragmentation info is missing. | 265 // Verify that EqualSize mode is forced if fragmentation info is missing. |
260 TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) { | 266 TEST_F(RtpPacketizerVp8Test, TestEqualSizeModeFallback) { |
261 const size_t kSizeVector[] = {10, 10, 10}; | 267 const size_t kSizeVector[] = {10, 10, 10}; |
262 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 268 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
263 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 269 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
264 | 270 |
265 hdr_info_.pictureId = 200; // > 0x7F should produce 2-byte PictureID | 271 hdr_info_.pictureId = 200; // > 0x7F should produce 2-byte PictureID |
266 const size_t kMaxSize = 12; // Small enough to produce 4 packets. | 272 const size_t kMaxPayloadSize = 12; // Small enough to produce 4 packets. |
267 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize); | 273 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize); |
268 packetizer.SetPayloadData( | 274 packetizer.SetPayloadData( |
269 helper_->payload_data(), helper_->payload_size(), NULL); | 275 helper_->payload_data(), helper_->payload_size(), NULL); |
270 | 276 |
271 // Expecting three full packets, and one with the remainder. | 277 // Expecting three full packets, and one with the remainder. |
272 const size_t kExpectedSizes[] = {12, 11, 12, 11}; | 278 const size_t kExpectedSizes[] = {12, 11, 12, 11}; |
273 const int kExpectedPart[] = {0, 0, 0, 0}; // Always 0 for equal size mode. | 279 const int kExpectedPart[] = {0, 0, 0, 0}; // Always 0 for equal size mode. |
274 // Frag start only true for first packet in equal size mode. | 280 // Frag start only true for first packet in equal size mode. |
275 const bool kExpectedFragStart[] = {true, false, false, false}; | 281 const bool kExpectedFragStart[] = {true, false, false, false}; |
276 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 282 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
277 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 283 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
278 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 284 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
279 | 285 |
280 helper_->set_sloppy_partitioning(true); | 286 helper_->set_sloppy_partitioning(true); |
281 helper_->GetAllPacketsAndCheck(&packetizer, | 287 helper_->GetAllPacketsAndCheck(&packetizer, |
282 kExpectedSizes, | 288 kExpectedSizes, |
283 kExpectedPart, | 289 kExpectedPart, |
284 kExpectedFragStart, | 290 kExpectedFragStart, |
285 kExpectedNum); | 291 kExpectedNum); |
286 } | 292 } |
287 | 293 |
288 // Verify that non-reference bit is set. EqualSize mode fallback is expected. | 294 // Verify that non-reference bit is set. EqualSize mode fallback is expected. |
289 TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) { | 295 TEST_F(RtpPacketizerVp8Test, TestNonReferenceBit) { |
290 const size_t kSizeVector[] = {10, 10, 10}; | 296 const size_t kSizeVector[] = {10, 10, 10}; |
291 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 297 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
292 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 298 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
293 | 299 |
294 hdr_info_.nonReference = true; | 300 hdr_info_.nonReference = true; |
295 const size_t kMaxSize = 25; // Small enough to produce two packets. | 301 const size_t kMaxPayloadSize = 25; // Small enough to produce two packets. |
296 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize); | 302 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize); |
297 packetizer.SetPayloadData( | 303 packetizer.SetPayloadData( |
298 helper_->payload_data(), helper_->payload_size(), NULL); | 304 helper_->payload_data(), helper_->payload_size(), NULL); |
299 | 305 |
300 // EqualSize mode => First packet full; other not. | 306 // EqualSize mode => First packet full; other not. |
301 const size_t kExpectedSizes[] = {16, 16}; | 307 const size_t kExpectedSizes[] = {16, 16}; |
302 const int kExpectedPart[] = {0, 0}; // Always 0 for equal size mode. | 308 const int kExpectedPart[] = {0, 0}; // Always 0 for equal size mode. |
303 // Frag start only true for first packet in equal size mode. | 309 // Frag start only true for first packet in equal size mode. |
304 const bool kExpectedFragStart[] = {true, false}; | 310 const bool kExpectedFragStart[] = {true, false}; |
305 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 311 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
306 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 312 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
307 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 313 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
308 | 314 |
309 helper_->set_sloppy_partitioning(true); | 315 helper_->set_sloppy_partitioning(true); |
310 helper_->GetAllPacketsAndCheck(&packetizer, | 316 helper_->GetAllPacketsAndCheck(&packetizer, |
311 kExpectedSizes, | 317 kExpectedSizes, |
312 kExpectedPart, | 318 kExpectedPart, |
313 kExpectedFragStart, | 319 kExpectedFragStart, |
314 kExpectedNum); | 320 kExpectedNum); |
315 } | 321 } |
316 | 322 |
317 // Verify Tl0PicIdx and TID fields, and layerSync bit. | 323 // Verify Tl0PicIdx and TID fields, and layerSync bit. |
318 TEST_F(RtpPacketizerVp8Test, TestTl0PicIdxAndTID) { | 324 TEST_F(RtpPacketizerVp8Test, TestTl0PicIdxAndTID) { |
319 const size_t kSizeVector[] = {10, 10, 10}; | 325 const size_t kSizeVector[] = {10, 10, 10}; |
320 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 326 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
321 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 327 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
322 | 328 |
323 hdr_info_.tl0PicIdx = 117; | 329 hdr_info_.tl0PicIdx = 117; |
324 hdr_info_.temporalIdx = 2; | 330 hdr_info_.temporalIdx = 2; |
325 hdr_info_.layerSync = true; | 331 hdr_info_.layerSync = true; |
326 // kMaxSize is only limited by allocated buffer size. | 332 // kMaxPayloadSize is only limited by allocated buffer size. |
327 const size_t kMaxSize = helper_->buffer_size(); | 333 const size_t kMaxPayloadSize = helper_->buffer_size(); |
328 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate); | 334 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate); |
329 packetizer.SetPayloadData(helper_->payload_data(), | 335 packetizer.SetPayloadData(helper_->payload_data(), |
330 helper_->payload_size(), | 336 helper_->payload_size(), |
331 helper_->fragmentation()); | 337 helper_->fragmentation()); |
332 | 338 |
333 // Expect one single packet of payload_size() + 4 bytes header. | 339 // Expect one single packet of payload_size() + 4 bytes header. |
334 const size_t kExpectedSizes[1] = {helper_->payload_size() + 4}; | 340 const size_t kExpectedSizes[1] = {helper_->payload_size() + 4}; |
335 const int kExpectedPart[1] = {0}; // Packet starts with partition 0. | 341 const int kExpectedPart[1] = {0}; // Packet starts with partition 0. |
336 const bool kExpectedFragStart[1] = {true}; | 342 const bool kExpectedFragStart[1] = {true}; |
337 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 343 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
338 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 344 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
339 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 345 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
340 | 346 |
341 helper_->GetAllPacketsAndCheck(&packetizer, | 347 helper_->GetAllPacketsAndCheck(&packetizer, |
342 kExpectedSizes, | 348 kExpectedSizes, |
343 kExpectedPart, | 349 kExpectedPart, |
344 kExpectedFragStart, | 350 kExpectedFragStart, |
345 kExpectedNum); | 351 kExpectedNum); |
346 } | 352 } |
347 | 353 |
348 // Verify KeyIdx field. | 354 // Verify KeyIdx field. |
349 TEST_F(RtpPacketizerVp8Test, TestKeyIdx) { | 355 TEST_F(RtpPacketizerVp8Test, TestKeyIdx) { |
350 const size_t kSizeVector[] = {10, 10, 10}; | 356 const size_t kSizeVector[] = {10, 10, 10}; |
351 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 357 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
352 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 358 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
353 | 359 |
354 hdr_info_.keyIdx = 17; | 360 hdr_info_.keyIdx = 17; |
355 // kMaxSize is only limited by allocated buffer size. | 361 // kMaxPayloadSize is only limited by allocated buffer size. |
356 const size_t kMaxSize = helper_->buffer_size(); | 362 const size_t kMaxPayloadSize = helper_->buffer_size(); |
357 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate); | 363 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate); |
358 packetizer.SetPayloadData(helper_->payload_data(), | 364 packetizer.SetPayloadData(helper_->payload_data(), |
359 helper_->payload_size(), | 365 helper_->payload_size(), |
360 helper_->fragmentation()); | 366 helper_->fragmentation()); |
361 | 367 |
362 // Expect one single packet of payload_size() + 3 bytes header. | 368 // Expect one single packet of payload_size() + 3 bytes header. |
363 const size_t kExpectedSizes[1] = {helper_->payload_size() + 3}; | 369 const size_t kExpectedSizes[1] = {helper_->payload_size() + 3}; |
364 const int kExpectedPart[1] = {0}; // Packet starts with partition 0. | 370 const int kExpectedPart[1] = {0}; // Packet starts with partition 0. |
365 const bool kExpectedFragStart[1] = {true}; | 371 const bool kExpectedFragStart[1] = {true}; |
366 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 372 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
367 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 373 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
368 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); | 374 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedFragStart); |
369 | 375 |
370 helper_->GetAllPacketsAndCheck(&packetizer, | 376 helper_->GetAllPacketsAndCheck(&packetizer, |
371 kExpectedSizes, | 377 kExpectedSizes, |
372 kExpectedPart, | 378 kExpectedPart, |
373 kExpectedFragStart, | 379 kExpectedFragStart, |
374 kExpectedNum); | 380 kExpectedNum); |
375 } | 381 } |
376 | 382 |
377 // Verify TID field and KeyIdx field in combination. | 383 // Verify TID field and KeyIdx field in combination. |
378 TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) { | 384 TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) { |
379 const size_t kSizeVector[] = {10, 10, 10}; | 385 const size_t kSizeVector[] = {10, 10, 10}; |
380 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); | 386 const size_t kNumPartitions = GTEST_ARRAY_SIZE_(kSizeVector); |
381 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); | 387 ASSERT_TRUE(Init(kSizeVector, kNumPartitions)); |
382 | 388 |
383 hdr_info_.temporalIdx = 1; | 389 hdr_info_.temporalIdx = 1; |
384 hdr_info_.keyIdx = 5; | 390 hdr_info_.keyIdx = 5; |
385 // kMaxSize is only limited by allocated buffer size. | 391 // kMaxPayloadSize is only limited by allocated buffer size. |
386 const size_t kMaxSize = helper_->buffer_size(); | 392 const size_t kMaxPayloadSize = helper_->buffer_size(); |
387 RtpPacketizerVp8 packetizer(hdr_info_, kMaxSize, kAggregate); | 393 RtpPacketizerVp8 packetizer(hdr_info_, kMaxPayloadSize, kAggregate); |
388 packetizer.SetPayloadData(helper_->payload_data(), | 394 packetizer.SetPayloadData(helper_->payload_data(), |
389 helper_->payload_size(), | 395 helper_->payload_size(), |
390 helper_->fragmentation()); | 396 helper_->fragmentation()); |
391 | 397 |
392 // Expect one single packet of payload_size() + 3 bytes header. | 398 // Expect one single packet of payload_size() + 3 bytes header. |
393 const size_t kExpectedSizes[1] = {helper_->payload_size() + 3}; | 399 const size_t kExpectedSizes[1] = {helper_->payload_size() + 3}; |
394 const int kExpectedPart[1] = {0}; // Packet starts with partition 0. | 400 const int kExpectedPart[1] = {0}; // Packet starts with partition 0. |
395 const bool kExpectedFragStart[1] = {true}; | 401 const bool kExpectedFragStart[1] = {true}; |
396 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); | 402 const size_t kExpectedNum = GTEST_ARRAY_SIZE_(kExpectedSizes); |
397 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); | 403 CHECK_ARRAY_SIZE(kExpectedNum, kExpectedPart); |
(...skipping 27 matching lines...) Expand all Loading... |
425 TEST_F(RtpDepacketizerVp8Test, BasicHeader) { | 431 TEST_F(RtpDepacketizerVp8Test, BasicHeader) { |
426 const uint8_t kHeaderLength = 1; | 432 const uint8_t kHeaderLength = 1; |
427 uint8_t packet[4] = {0}; | 433 uint8_t packet[4] = {0}; |
428 packet[0] = 0x14; // Binary 0001 0100; S = 1, PartID = 4. | 434 packet[0] = 0x14; // Binary 0001 0100; S = 1, PartID = 4. |
429 packet[1] = 0x01; // P frame. | 435 packet[1] = 0x01; // P frame. |
430 RtpDepacketizer::ParsedPayload payload; | 436 RtpDepacketizer::ParsedPayload payload; |
431 | 437 |
432 ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); | 438 ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); |
433 ExpectPacket( | 439 ExpectPacket( |
434 &payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength); | 440 &payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength); |
| 441 |
435 EXPECT_EQ(kVideoFrameDelta, payload.frame_type); | 442 EXPECT_EQ(kVideoFrameDelta, payload.frame_type); |
436 EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec); | 443 EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec); |
437 VerifyBasicHeader(&payload.type, 0, 1, 4); | 444 VerifyBasicHeader(&payload.type, 0, 1, 4); |
438 VerifyExtensions( | 445 VerifyExtensions( |
439 &payload.type, kNoPictureId, kNoTl0PicIdx, kNoTemporalIdx, kNoKeyIdx); | 446 &payload.type, kNoPictureId, kNoTl0PicIdx, kNoTemporalIdx, kNoKeyIdx); |
440 } | 447 } |
441 | 448 |
442 TEST_F(RtpDepacketizerVp8Test, PictureID) { | 449 TEST_F(RtpDepacketizerVp8Test, PictureID) { |
443 const uint8_t kHeaderLength1 = 3; | 450 const uint8_t kHeaderLength1 = 3; |
444 const uint8_t kHeaderLength2 = 4; | 451 const uint8_t kHeaderLength2 = 4; |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
557 packet[2] = 0x80 | 17; // ... but only 2 bytes PictureID is provided. | 564 packet[2] = 0x80 | 17; // ... but only 2 bytes PictureID is provided. |
558 packet[3] = 17; // PictureID, low 8 bits. | 565 packet[3] = 17; // PictureID, low 8 bits. |
559 RtpDepacketizer::ParsedPayload payload; | 566 RtpDepacketizer::ParsedPayload payload; |
560 | 567 |
561 EXPECT_FALSE(depacketizer_->Parse(&payload, packet, sizeof(packet))); | 568 EXPECT_FALSE(depacketizer_->Parse(&payload, packet, sizeof(packet))); |
562 } | 569 } |
563 | 570 |
564 TEST_F(RtpDepacketizerVp8Test, TestWithPacketizer) { | 571 TEST_F(RtpDepacketizerVp8Test, TestWithPacketizer) { |
565 const uint8_t kHeaderLength = 5; | 572 const uint8_t kHeaderLength = 5; |
566 uint8_t data[10] = {0}; | 573 uint8_t data[10] = {0}; |
567 uint8_t packet[20] = {0}; | 574 RtpPacketToSend packet(kNoExtensions); |
568 RTPVideoHeaderVP8 input_header; | 575 RTPVideoHeaderVP8 input_header; |
569 input_header.nonReference = true; | 576 input_header.nonReference = true; |
570 input_header.pictureId = 300; | 577 input_header.pictureId = 300; |
571 input_header.temporalIdx = 1; | 578 input_header.temporalIdx = 1; |
572 input_header.layerSync = false; | 579 input_header.layerSync = false; |
573 input_header.tl0PicIdx = kNoTl0PicIdx; // Disable. | 580 input_header.tl0PicIdx = kNoTl0PicIdx; // Disable. |
574 input_header.keyIdx = 31; | 581 input_header.keyIdx = 31; |
575 RtpPacketizerVp8 packetizer(input_header, 20); | 582 RtpPacketizerVp8 packetizer(input_header, 20); |
576 packetizer.SetPayloadData(data, 10, NULL); | 583 packetizer.SetPayloadData(data, 10, NULL); |
577 bool last; | 584 bool last; |
578 size_t send_bytes; | 585 ASSERT_TRUE(packetizer.NextPacket(&packet, &last)); |
579 ASSERT_TRUE(packetizer.NextPacket(packet, &send_bytes, &last)); | 586 EXPECT_TRUE(last); |
580 ASSERT_TRUE(last); | 587 EXPECT_TRUE(packet.Marker()); |
| 588 |
| 589 auto rtp_payload = packet.payload(); |
581 RtpDepacketizer::ParsedPayload payload; | 590 RtpDepacketizer::ParsedPayload payload; |
582 | 591 ASSERT_TRUE( |
583 ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); | 592 depacketizer_->Parse(&payload, rtp_payload.data(), rtp_payload.size())); |
584 ExpectPacket( | 593 auto vp8_payload = rtp_payload.subview(kHeaderLength); |
585 &payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength); | 594 ExpectPacket(&payload, vp8_payload.data(), vp8_payload.size()); |
586 EXPECT_EQ(kVideoFrameKey, payload.frame_type); | 595 EXPECT_EQ(kVideoFrameKey, payload.frame_type); |
587 EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec); | 596 EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec); |
588 VerifyBasicHeader(&payload.type, 1, 1, 0); | 597 VerifyBasicHeader(&payload.type, 1, 1, 0); |
589 VerifyExtensions(&payload.type, | 598 VerifyExtensions(&payload.type, |
590 input_header.pictureId, | 599 input_header.pictureId, |
591 input_header.tl0PicIdx, | 600 input_header.tl0PicIdx, |
592 input_header.temporalIdx, | 601 input_header.temporalIdx, |
593 input_header.keyIdx); | 602 input_header.keyIdx); |
594 EXPECT_EQ(payload.type.Video.codecHeader.VP8.layerSync, | 603 EXPECT_EQ(payload.type.Video.codecHeader.VP8.layerSync, |
595 input_header.layerSync); | 604 input_header.layerSync); |
596 } | 605 } |
597 | 606 |
598 TEST_F(RtpDepacketizerVp8Test, TestEmptyPayload) { | 607 TEST_F(RtpDepacketizerVp8Test, TestEmptyPayload) { |
599 // Using a wild pointer to crash on accesses from inside the depacketizer. | 608 // Using a wild pointer to crash on accesses from inside the depacketizer. |
600 uint8_t* garbage_ptr = reinterpret_cast<uint8_t*>(0x4711); | 609 uint8_t* garbage_ptr = reinterpret_cast<uint8_t*>(0x4711); |
601 RtpDepacketizer::ParsedPayload payload; | 610 RtpDepacketizer::ParsedPayload payload; |
602 EXPECT_FALSE(depacketizer_->Parse(&payload, garbage_ptr, 0)); | 611 EXPECT_FALSE(depacketizer_->Parse(&payload, garbage_ptr, 0)); |
603 } | 612 } |
604 } // namespace webrtc | 613 } // namespace webrtc |
OLD | NEW |