OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2014 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 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
42 | 42 |
43 static const size_t kNalHeaderSize = 1; | 43 static const size_t kNalHeaderSize = 1; |
44 static const size_t kFuAHeaderSize = 2; | 44 static const size_t kFuAHeaderSize = 2; |
45 | 45 |
46 // Bit masks for FU (A and B) indicators. | 46 // Bit masks for FU (A and B) indicators. |
47 enum NalDefs { kFBit = 0x80, kNriMask = 0x60, kTypeMask = 0x1F }; | 47 enum NalDefs { kFBit = 0x80, kNriMask = 0x60, kTypeMask = 0x1F }; |
48 | 48 |
49 // Bit masks for FU (A and B) headers. | 49 // Bit masks for FU (A and B) headers. |
50 enum FuDefs { kSBit = 0x80, kEBit = 0x40, kRBit = 0x20 }; | 50 enum FuDefs { kSBit = 0x80, kEBit = 0x40, kRBit = 0x20 }; |
51 | 51 |
| 52 void CreateThreeFragments(RTPFragmentationHeader* fragmentation, |
| 53 size_t frameSize, |
| 54 size_t payloadOffset) { |
| 55 fragmentation->VerifyAndAllocateFragmentationHeader(3); |
| 56 fragmentation->fragmentationOffset[0] = 0; |
| 57 fragmentation->fragmentationLength[0] = 2; |
| 58 fragmentation->fragmentationOffset[1] = 2; |
| 59 fragmentation->fragmentationLength[1] = 2; |
| 60 fragmentation->fragmentationOffset[2] = 4; |
| 61 fragmentation->fragmentationLength[2] = |
| 62 kNalHeaderSize + frameSize - payloadOffset; |
| 63 } |
| 64 |
| 65 RtpPacketizer* CreateH264Packetizer(H264PacketizationMode mode, |
| 66 size_t max_payload_size) { |
| 67 RTPVideoTypeHeader type_header; |
| 68 type_header.H264.packetization_mode = mode; |
| 69 return RtpPacketizer::Create(kRtpVideoH264, max_payload_size, &type_header, |
| 70 kEmptyFrame); |
| 71 } |
| 72 |
52 void VerifyFua(size_t fua_index, | 73 void VerifyFua(size_t fua_index, |
53 const uint8_t* expected_payload, | 74 const uint8_t* expected_payload, |
54 int offset, | 75 int offset, |
55 rtc::ArrayView<const uint8_t> packet, | 76 rtc::ArrayView<const uint8_t> packet, |
56 const std::vector<size_t>& expected_sizes) { | 77 const std::vector<size_t>& expected_sizes) { |
57 ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, packet.size()) | 78 ASSERT_EQ(expected_sizes[fua_index] + kFuAHeaderSize, packet.size()) |
58 << "FUA index: " << fua_index; | 79 << "FUA index: " << fua_index; |
59 const uint8_t kFuIndicator = 0x1C; // F=0, NRI=0, Type=28. | 80 const uint8_t kFuIndicator = 0x1C; // F=0, NRI=0, Type=28. |
60 EXPECT_EQ(kFuIndicator, packet[0]) << "FUA index: " << fua_index; | 81 EXPECT_EQ(kFuIndicator, packet[0]) << "FUA index: " << fua_index; |
61 bool should_be_last_fua = (fua_index == expected_sizes.size() - 1); | 82 bool should_be_last_fua = (fua_index == expected_sizes.size() - 1); |
(...skipping 19 matching lines...) Expand all Loading... |
81 std::unique_ptr<uint8_t[]> frame; | 102 std::unique_ptr<uint8_t[]> frame; |
82 frame.reset(new uint8_t[frame_size]); | 103 frame.reset(new uint8_t[frame_size]); |
83 frame[0] = 0x05; // F=0, NRI=0, Type=5. | 104 frame[0] = 0x05; // F=0, NRI=0, Type=5. |
84 for (size_t i = 0; i < frame_size - kNalHeaderSize; ++i) { | 105 for (size_t i = 0; i < frame_size - kNalHeaderSize; ++i) { |
85 frame[i + kNalHeaderSize] = i; | 106 frame[i + kNalHeaderSize] = i; |
86 } | 107 } |
87 RTPFragmentationHeader fragmentation; | 108 RTPFragmentationHeader fragmentation; |
88 fragmentation.VerifyAndAllocateFragmentationHeader(1); | 109 fragmentation.VerifyAndAllocateFragmentationHeader(1); |
89 fragmentation.fragmentationOffset[0] = 0; | 110 fragmentation.fragmentationOffset[0] = 0; |
90 fragmentation.fragmentationLength[0] = frame_size; | 111 fragmentation.fragmentationLength[0] = frame_size; |
91 std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create( | 112 std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer( |
92 kRtpVideoH264, max_payload_size, NULL, kEmptyFrame)); | 113 H264PacketizationMode::NonInterleaved, max_payload_size)); |
93 packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation); | 114 packetizer->SetPayloadData(frame.get(), frame_size, &fragmentation); |
94 | 115 |
95 RtpPacketToSend packet(kNoExtensions); | 116 RtpPacketToSend packet(kNoExtensions); |
96 ASSERT_LE(max_payload_size, packet.FreeCapacity()); | 117 ASSERT_LE(max_payload_size, packet.FreeCapacity()); |
97 bool last = false; | 118 bool last = false; |
98 size_t offset = kNalHeaderSize; | 119 size_t offset = kNalHeaderSize; |
99 for (size_t i = 0; i < expected_sizes.size(); ++i) { | 120 for (size_t i = 0; i < expected_sizes.size(); ++i) { |
100 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); | 121 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
101 VerifyFua(i, frame.get(), offset, packet.payload(), expected_sizes); | 122 VerifyFua(i, frame.get(), offset, packet.payload(), expected_sizes); |
102 EXPECT_EQ(i == expected_sizes.size() - 1, last) << "FUA index: " << i; | 123 EXPECT_EQ(i == expected_sizes.size() - 1, last) << "FUA index: " << i; |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
142 void VerifySingleNaluPayload(const RTPFragmentationHeader& fragmentation, | 163 void VerifySingleNaluPayload(const RTPFragmentationHeader& fragmentation, |
143 size_t nalu_index, | 164 size_t nalu_index, |
144 rtc::ArrayView<const uint8_t> frame, | 165 rtc::ArrayView<const uint8_t> frame, |
145 rtc::ArrayView<const uint8_t> packet) { | 166 rtc::ArrayView<const uint8_t> packet) { |
146 auto fragment = frame.subview(fragmentation.fragmentationOffset[nalu_index], | 167 auto fragment = frame.subview(fragmentation.fragmentationOffset[nalu_index], |
147 fragmentation.fragmentationLength[nalu_index]); | 168 fragmentation.fragmentationLength[nalu_index]); |
148 EXPECT_THAT(packet, ElementsAreArray(fragment.begin(), fragment.end())); | 169 EXPECT_THAT(packet, ElementsAreArray(fragment.begin(), fragment.end())); |
149 } | 170 } |
150 } // namespace | 171 } // namespace |
151 | 172 |
152 TEST(RtpPacketizerH264Test, TestSingleNalu) { | 173 // Tests that should work with both packetization mode 0 and |
| 174 // packetization mode 1. |
| 175 class RtpPacketizerH264ModeTest |
| 176 : public ::testing::TestWithParam<H264PacketizationMode> {}; |
| 177 |
| 178 TEST_P(RtpPacketizerH264ModeTest, TestSingleNalu) { |
153 const uint8_t frame[2] = {0x05, 0xFF}; // F=0, NRI=0, Type=5. | 179 const uint8_t frame[2] = {0x05, 0xFF}; // F=0, NRI=0, Type=5. |
154 RTPFragmentationHeader fragmentation; | 180 RTPFragmentationHeader fragmentation; |
155 fragmentation.VerifyAndAllocateFragmentationHeader(1); | 181 fragmentation.VerifyAndAllocateFragmentationHeader(1); |
156 fragmentation.fragmentationOffset[0] = 0; | 182 fragmentation.fragmentationOffset[0] = 0; |
157 fragmentation.fragmentationLength[0] = sizeof(frame); | 183 fragmentation.fragmentationLength[0] = sizeof(frame); |
158 std::unique_ptr<RtpPacketizer> packetizer( | 184 std::unique_ptr<RtpPacketizer> packetizer( |
159 RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); | 185 CreateH264Packetizer(GetParam(), kMaxPayloadSize)); |
160 packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation); | 186 packetizer->SetPayloadData(frame, sizeof(frame), &fragmentation); |
161 RtpPacketToSend packet(kNoExtensions); | 187 RtpPacketToSend packet(kNoExtensions); |
162 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); | 188 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
163 bool last = false; | 189 bool last = false; |
164 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); | 190 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
165 EXPECT_EQ(2u, packet.payload_size()); | 191 EXPECT_EQ(2u, packet.payload_size()); |
166 EXPECT_TRUE(last); | 192 EXPECT_TRUE(last); |
167 VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload()); | 193 VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload()); |
168 EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); | 194 EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
169 } | 195 } |
170 | 196 |
171 TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) { | 197 TEST_P(RtpPacketizerH264ModeTest, TestSingleNaluTwoPackets) { |
172 const size_t kFrameSize = kMaxPayloadSize + 100; | 198 const size_t kFrameSize = kMaxPayloadSize + 100; |
173 uint8_t frame[kFrameSize] = {0}; | 199 uint8_t frame[kFrameSize] = {0}; |
174 for (size_t i = 0; i < kFrameSize; ++i) | 200 for (size_t i = 0; i < kFrameSize; ++i) |
175 frame[i] = i; | 201 frame[i] = i; |
176 RTPFragmentationHeader fragmentation; | 202 RTPFragmentationHeader fragmentation; |
177 fragmentation.VerifyAndAllocateFragmentationHeader(2); | 203 fragmentation.VerifyAndAllocateFragmentationHeader(2); |
178 fragmentation.fragmentationOffset[0] = 0; | 204 fragmentation.fragmentationOffset[0] = 0; |
179 fragmentation.fragmentationLength[0] = kMaxPayloadSize; | 205 fragmentation.fragmentationLength[0] = kMaxPayloadSize; |
180 fragmentation.fragmentationOffset[1] = kMaxPayloadSize; | 206 fragmentation.fragmentationOffset[1] = kMaxPayloadSize; |
181 fragmentation.fragmentationLength[1] = 100; | 207 fragmentation.fragmentationLength[1] = 100; |
182 // Set NAL headers. | 208 // Set NAL headers. |
183 frame[fragmentation.fragmentationOffset[0]] = 0x01; | 209 frame[fragmentation.fragmentationOffset[0]] = 0x01; |
184 frame[fragmentation.fragmentationOffset[1]] = 0x01; | 210 frame[fragmentation.fragmentationOffset[1]] = 0x01; |
185 | 211 |
186 std::unique_ptr<RtpPacketizer> packetizer( | 212 std::unique_ptr<RtpPacketizer> packetizer( |
187 RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); | 213 CreateH264Packetizer(GetParam(), kMaxPayloadSize)); |
188 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); | 214 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
189 | 215 |
190 RtpPacketToSend packet(kNoExtensions); | 216 RtpPacketToSend packet(kNoExtensions); |
191 bool last = false; | 217 bool last = false; |
192 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); | 218 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
193 ASSERT_EQ(fragmentation.fragmentationOffset[1], packet.payload_size()); | 219 ASSERT_EQ(fragmentation.fragmentationOffset[1], packet.payload_size()); |
194 VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload()); | 220 VerifySingleNaluPayload(fragmentation, 0, frame, packet.payload()); |
195 | 221 |
196 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); | 222 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
197 ASSERT_EQ(fragmentation.fragmentationLength[1], packet.payload_size()); | 223 ASSERT_EQ(fragmentation.fragmentationLength[1], packet.payload_size()); |
198 VerifySingleNaluPayload(fragmentation, 1, frame, packet.payload()); | 224 VerifySingleNaluPayload(fragmentation, 1, frame, packet.payload()); |
199 EXPECT_TRUE(last); | 225 EXPECT_TRUE(last); |
200 | 226 |
201 EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); | 227 EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
202 } | 228 } |
203 | 229 |
| 230 INSTANTIATE_TEST_CASE_P( |
| 231 PacketMode, |
| 232 RtpPacketizerH264ModeTest, |
| 233 ::testing::Values(H264PacketizationMode::SingleNalUnit, |
| 234 H264PacketizationMode::NonInterleaved)); |
| 235 |
204 TEST(RtpPacketizerH264Test, TestStapA) { | 236 TEST(RtpPacketizerH264Test, TestStapA) { |
205 const size_t kFrameSize = | 237 const size_t kFrameSize = |
206 kMaxPayloadSize - 3 * kLengthFieldLength - kNalHeaderSize; | 238 kMaxPayloadSize - 3 * kLengthFieldLength - kNalHeaderSize; |
207 uint8_t frame[kFrameSize] = {0x07, 0xFF, // F=0, NRI=0, Type=7 (SPS). | 239 uint8_t frame[kFrameSize] = {0x07, 0xFF, // F=0, NRI=0, Type=7 (SPS). |
208 0x08, 0xFF, // F=0, NRI=0, Type=8 (PPS). | 240 0x08, 0xFF, // F=0, NRI=0, Type=8 (PPS). |
209 0x05}; // F=0, NRI=0, Type=5 (IDR). | 241 0x05}; // F=0, NRI=0, Type=5 (IDR). |
210 const size_t kPayloadOffset = 5; | 242 const size_t kPayloadOffset = 5; |
211 for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i) | 243 for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i) |
212 frame[i + kPayloadOffset] = i; | 244 frame[i + kPayloadOffset] = i; |
213 RTPFragmentationHeader fragmentation; | 245 RTPFragmentationHeader fragmentation; |
214 fragmentation.VerifyAndAllocateFragmentationHeader(3); | 246 CreateThreeFragments(&fragmentation, kFrameSize, kPayloadOffset); |
215 fragmentation.fragmentationOffset[0] = 0; | 247 std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer( |
216 fragmentation.fragmentationLength[0] = 2; | 248 H264PacketizationMode::NonInterleaved, kMaxPayloadSize)); |
217 fragmentation.fragmentationOffset[1] = 2; | |
218 fragmentation.fragmentationLength[1] = 2; | |
219 fragmentation.fragmentationOffset[2] = 4; | |
220 fragmentation.fragmentationLength[2] = | |
221 kNalHeaderSize + kFrameSize - kPayloadOffset; | |
222 std::unique_ptr<RtpPacketizer> packetizer( | |
223 RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); | |
224 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); | 249 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
225 | 250 |
226 RtpPacketToSend packet(kNoExtensions); | 251 RtpPacketToSend packet(kNoExtensions); |
227 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); | 252 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
228 bool last = false; | 253 bool last = false; |
229 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); | 254 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
230 size_t expected_packet_size = | 255 size_t expected_packet_size = |
231 kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize; | 256 kNalHeaderSize + 3 * kLengthFieldLength + kFrameSize; |
232 ASSERT_EQ(expected_packet_size, packet.payload_size()); | 257 ASSERT_EQ(expected_packet_size, packet.payload_size()); |
233 EXPECT_TRUE(last); | 258 EXPECT_TRUE(last); |
234 for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) | 259 for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) |
235 VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload()); | 260 VerifyStapAPayload(fragmentation, 0, i, frame, packet.payload()); |
236 | 261 |
237 EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); | 262 EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
238 } | 263 } |
239 | 264 |
| 265 TEST(RtpPacketizerH264Test, TestSingleNalUnitModeHasNoStapA) { |
| 266 // This is the same setup as for the TestStapA test. |
| 267 const size_t kFrameSize = |
| 268 kMaxPayloadSize - 3 * kLengthFieldLength - kNalHeaderSize; |
| 269 uint8_t frame[kFrameSize] = {0x07, 0xFF, // F=0, NRI=0, Type=7 (SPS). |
| 270 0x08, 0xFF, // F=0, NRI=0, Type=8 (PPS). |
| 271 0x05}; // F=0, NRI=0, Type=5 (IDR). |
| 272 const size_t kPayloadOffset = 5; |
| 273 for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i) |
| 274 frame[i + kPayloadOffset] = i; |
| 275 RTPFragmentationHeader fragmentation; |
| 276 CreateThreeFragments(&fragmentation, kFrameSize, kPayloadOffset); |
| 277 std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer( |
| 278 H264PacketizationMode::SingleNalUnit, kMaxPayloadSize)); |
| 279 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
| 280 |
| 281 RtpPacketToSend packet(kNoExtensions); |
| 282 bool last = false; |
| 283 // The three fragments should be returned as three packets. |
| 284 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
| 285 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
| 286 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
| 287 EXPECT_FALSE(packetizer->NextPacket(&packet, &last)); |
| 288 } |
| 289 |
240 TEST(RtpPacketizerH264Test, TestTooSmallForStapAHeaders) { | 290 TEST(RtpPacketizerH264Test, TestTooSmallForStapAHeaders) { |
241 const size_t kFrameSize = kMaxPayloadSize - 1; | 291 const size_t kFrameSize = kMaxPayloadSize - 1; |
242 uint8_t frame[kFrameSize] = {0x07, 0xFF, // F=0, NRI=0, Type=7. | 292 uint8_t frame[kFrameSize] = {0x07, 0xFF, // F=0, NRI=0, Type=7. |
243 0x08, 0xFF, // F=0, NRI=0, Type=8. | 293 0x08, 0xFF, // F=0, NRI=0, Type=8. |
244 0x05}; // F=0, NRI=0, Type=5. | 294 0x05}; // F=0, NRI=0, Type=5. |
245 const size_t kPayloadOffset = 5; | 295 const size_t kPayloadOffset = 5; |
246 for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i) | 296 for (size_t i = 0; i < kFrameSize - kPayloadOffset; ++i) |
247 frame[i + kPayloadOffset] = i; | 297 frame[i + kPayloadOffset] = i; |
248 RTPFragmentationHeader fragmentation; | 298 RTPFragmentationHeader fragmentation; |
249 fragmentation.VerifyAndAllocateFragmentationHeader(3); | 299 fragmentation.VerifyAndAllocateFragmentationHeader(3); |
250 fragmentation.fragmentationOffset[0] = 0; | 300 fragmentation.fragmentationOffset[0] = 0; |
251 fragmentation.fragmentationLength[0] = 2; | 301 fragmentation.fragmentationLength[0] = 2; |
252 fragmentation.fragmentationOffset[1] = 2; | 302 fragmentation.fragmentationOffset[1] = 2; |
253 fragmentation.fragmentationLength[1] = 2; | 303 fragmentation.fragmentationLength[1] = 2; |
254 fragmentation.fragmentationOffset[2] = 4; | 304 fragmentation.fragmentationOffset[2] = 4; |
255 fragmentation.fragmentationLength[2] = | 305 fragmentation.fragmentationLength[2] = |
256 kNalHeaderSize + kFrameSize - kPayloadOffset; | 306 kNalHeaderSize + kFrameSize - kPayloadOffset; |
257 std::unique_ptr<RtpPacketizer> packetizer( | 307 std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer( |
258 RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); | 308 H264PacketizationMode::NonInterleaved, kMaxPayloadSize)); |
259 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); | 309 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
260 | 310 |
261 RtpPacketToSend packet(kNoExtensions); | 311 RtpPacketToSend packet(kNoExtensions); |
262 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); | 312 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
263 bool last = false; | 313 bool last = false; |
264 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); | 314 ASSERT_TRUE(packetizer->NextPacket(&packet, &last)); |
265 size_t expected_packet_size = kNalHeaderSize; | 315 size_t expected_packet_size = kNalHeaderSize; |
266 for (size_t i = 0; i < 2; ++i) { | 316 for (size_t i = 0; i < 2; ++i) { |
267 expected_packet_size += | 317 expected_packet_size += |
268 kLengthFieldLength + fragmentation.fragmentationLength[i]; | 318 kLengthFieldLength + fragmentation.fragmentationLength[i]; |
(...skipping 26 matching lines...) Expand all Loading... |
295 const size_t kFrameSize = kFuaNaluSize + 2 * kStapANaluSize; | 345 const size_t kFrameSize = kFuaNaluSize + 2 * kStapANaluSize; |
296 uint8_t frame[kFrameSize]; | 346 uint8_t frame[kFrameSize]; |
297 size_t nalu_offset = 0; | 347 size_t nalu_offset = 0; |
298 for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) { | 348 for (size_t i = 0; i < fragmentation.fragmentationVectorSize; ++i) { |
299 nalu_offset = fragmentation.fragmentationOffset[i]; | 349 nalu_offset = fragmentation.fragmentationOffset[i]; |
300 frame[nalu_offset] = 0x05; // F=0, NRI=0, Type=5. | 350 frame[nalu_offset] = 0x05; // F=0, NRI=0, Type=5. |
301 for (size_t j = 1; j < fragmentation.fragmentationLength[i]; ++j) { | 351 for (size_t j = 1; j < fragmentation.fragmentationLength[i]; ++j) { |
302 frame[nalu_offset + j] = i + j; | 352 frame[nalu_offset + j] = i + j; |
303 } | 353 } |
304 } | 354 } |
305 std::unique_ptr<RtpPacketizer> packetizer( | 355 std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer( |
306 RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize, NULL, kEmptyFrame)); | 356 H264PacketizationMode::NonInterleaved, kMaxPayloadSize)); |
307 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); | 357 packetizer->SetPayloadData(frame, kFrameSize, &fragmentation); |
308 | 358 |
309 // First expecting two FU-A packets. | 359 // First expecting two FU-A packets. |
310 std::vector<size_t> fua_sizes; | 360 std::vector<size_t> fua_sizes; |
311 fua_sizes.push_back(1100); | 361 fua_sizes.push_back(1100); |
312 fua_sizes.push_back(1099); | 362 fua_sizes.push_back(1099); |
313 RtpPacketToSend packet(kNoExtensions); | 363 RtpPacketToSend packet(kNoExtensions); |
314 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); | 364 ASSERT_LE(kMaxPayloadSize, packet.FreeCapacity()); |
315 bool last = false; | 365 bool last = false; |
316 int fua_offset = kNalHeaderSize; | 366 int fua_offset = kNalHeaderSize; |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
369 // Generate 10 full sized packets, leave room for FU-A headers minus the NALU | 419 // Generate 10 full sized packets, leave room for FU-A headers minus the NALU |
370 // header. | 420 // header. |
371 TestFua( | 421 TestFua( |
372 10 * (kMaxPayloadSize - kFuAHeaderSize) + kNalHeaderSize, | 422 10 * (kMaxPayloadSize - kFuAHeaderSize) + kNalHeaderSize, |
373 kMaxPayloadSize, | 423 kMaxPayloadSize, |
374 std::vector<size_t>(kExpectedPayloadSizes, | 424 std::vector<size_t>(kExpectedPayloadSizes, |
375 kExpectedPayloadSizes + | 425 kExpectedPayloadSizes + |
376 sizeof(kExpectedPayloadSizes) / sizeof(size_t))); | 426 sizeof(kExpectedPayloadSizes) / sizeof(size_t))); |
377 } | 427 } |
378 | 428 |
| 429 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| 430 |
| 431 TEST(RtpPacketizerH264DeathTest, SendOverlongDataInPacketizationMode0) { |
| 432 const size_t kFrameSize = kMaxPayloadSize + 1; |
| 433 uint8_t frame[kFrameSize] = {0}; |
| 434 for (size_t i = 0; i < kFrameSize; ++i) |
| 435 frame[i] = i; |
| 436 RTPFragmentationHeader fragmentation; |
| 437 fragmentation.VerifyAndAllocateFragmentationHeader(1); |
| 438 fragmentation.fragmentationOffset[0] = 0; |
| 439 fragmentation.fragmentationLength[0] = kFrameSize; |
| 440 // Set NAL headers. |
| 441 frame[fragmentation.fragmentationOffset[0]] = 0x01; |
| 442 |
| 443 std::unique_ptr<RtpPacketizer> packetizer(CreateH264Packetizer( |
| 444 H264PacketizationMode::SingleNalUnit, kMaxPayloadSize)); |
| 445 EXPECT_DEATH(packetizer->SetPayloadData(frame, kFrameSize, &fragmentation), |
| 446 "payload_size"); |
| 447 } |
| 448 |
| 449 #endif // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| 450 |
379 namespace { | 451 namespace { |
380 const uint8_t kStartSequence[] = {0x00, 0x00, 0x00, 0x01}; | 452 const uint8_t kStartSequence[] = {0x00, 0x00, 0x00, 0x01}; |
381 const uint8_t kOriginalSps[] = {kSps, 0x00, 0x00, 0x03, 0x03, | 453 const uint8_t kOriginalSps[] = {kSps, 0x00, 0x00, 0x03, 0x03, |
382 0xF4, 0x05, 0x03, 0xC7, 0xC0}; | 454 0xF4, 0x05, 0x03, 0xC7, 0xC0}; |
383 const uint8_t kRewrittenSps[] = {kSps, 0x00, 0x00, 0x03, 0x03, 0xF4, 0x05, 0x03, | 455 const uint8_t kRewrittenSps[] = {kSps, 0x00, 0x00, 0x03, 0x03, 0xF4, 0x05, 0x03, |
384 0xC7, 0xE0, 0x1B, 0x41, 0x10, 0x8D, 0x00}; | 456 0xC7, 0xE0, 0x1B, 0x41, 0x10, 0x8D, 0x00}; |
385 const uint8_t kIdrOne[] = {kIdr, 0xFF, 0x00, 0x00, 0x04}; | 457 const uint8_t kIdrOne[] = {kIdr, 0xFF, 0x00, 0x00, 0x04}; |
386 const uint8_t kIdrTwo[] = {kIdr, 0xFF, 0x00, 0x11}; | 458 const uint8_t kIdrTwo[] = {kIdr, 0xFF, 0x00, 0x11}; |
387 } | 459 } |
388 | 460 |
(...skipping 20 matching lines...) Expand all Loading... |
409 protected: | 481 protected: |
410 rtc::Buffer in_buffer_; | 482 rtc::Buffer in_buffer_; |
411 RTPFragmentationHeader fragmentation_header_; | 483 RTPFragmentationHeader fragmentation_header_; |
412 std::unique_ptr<RtpPacketizer> packetizer_; | 484 std::unique_ptr<RtpPacketizer> packetizer_; |
413 }; | 485 }; |
414 | 486 |
415 TEST_F(RtpPacketizerH264TestSpsRewriting, FuASps) { | 487 TEST_F(RtpPacketizerH264TestSpsRewriting, FuASps) { |
416 const size_t kHeaderOverhead = kFuAHeaderSize + 1; | 488 const size_t kHeaderOverhead = kFuAHeaderSize + 1; |
417 | 489 |
418 // Set size to fragment SPS into two FU-A packets. | 490 // Set size to fragment SPS into two FU-A packets. |
419 packetizer_.reset(RtpPacketizer::Create( | 491 packetizer_.reset( |
420 kRtpVideoH264, sizeof(kOriginalSps) - 2 + kHeaderOverhead, nullptr, | 492 CreateH264Packetizer(H264PacketizationMode::NonInterleaved, |
421 kEmptyFrame)); | 493 sizeof(kOriginalSps) - 2 + kHeaderOverhead)); |
422 | 494 |
423 packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(), | 495 packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(), |
424 &fragmentation_header_); | 496 &fragmentation_header_); |
425 | 497 |
426 bool last_packet = true; | 498 bool last_packet = true; |
427 RtpPacketToSend packet(kNoExtensions); | 499 RtpPacketToSend packet(kNoExtensions); |
428 ASSERT_LE(sizeof(kOriginalSps) + kHeaderOverhead, packet.FreeCapacity()); | 500 ASSERT_LE(sizeof(kOriginalSps) + kHeaderOverhead, packet.FreeCapacity()); |
429 | 501 |
430 EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet)); | 502 EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet)); |
431 size_t offset = H264::kNaluTypeSize; | 503 size_t offset = H264::kNaluTypeSize; |
(...skipping 11 matching lines...) Expand all Loading... |
443 EXPECT_EQ(offset, sizeof(kRewrittenSps)); | 515 EXPECT_EQ(offset, sizeof(kRewrittenSps)); |
444 } | 516 } |
445 | 517 |
446 TEST_F(RtpPacketizerH264TestSpsRewriting, StapASps) { | 518 TEST_F(RtpPacketizerH264TestSpsRewriting, StapASps) { |
447 const size_t kHeaderOverhead = kFuAHeaderSize + 1; | 519 const size_t kHeaderOverhead = kFuAHeaderSize + 1; |
448 const size_t kExpectedTotalSize = H264::kNaluTypeSize + // Stap-A type. | 520 const size_t kExpectedTotalSize = H264::kNaluTypeSize + // Stap-A type. |
449 sizeof(kRewrittenSps) + sizeof(kIdrOne) + | 521 sizeof(kRewrittenSps) + sizeof(kIdrOne) + |
450 sizeof(kIdrTwo) + (kLengthFieldLength * 3); | 522 sizeof(kIdrTwo) + (kLengthFieldLength * 3); |
451 | 523 |
452 // Set size to include SPS and the rest of the packets in a Stap-A package. | 524 // Set size to include SPS and the rest of the packets in a Stap-A package. |
453 packetizer_.reset(RtpPacketizer::Create(kRtpVideoH264, | 525 packetizer_.reset(CreateH264Packetizer(H264PacketizationMode::NonInterleaved, |
454 kExpectedTotalSize + kHeaderOverhead, | 526 kExpectedTotalSize + kHeaderOverhead)); |
455 nullptr, kEmptyFrame)); | |
456 | 527 |
457 packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(), | 528 packetizer_->SetPayloadData(in_buffer_.data(), in_buffer_.size(), |
458 &fragmentation_header_); | 529 &fragmentation_header_); |
459 | 530 |
460 bool last_packet = true; | 531 bool last_packet = true; |
461 RtpPacketToSend packet(kNoExtensions); | 532 RtpPacketToSend packet(kNoExtensions); |
462 ASSERT_LE(kExpectedTotalSize + kHeaderOverhead, packet.FreeCapacity()); | 533 ASSERT_LE(kExpectedTotalSize + kHeaderOverhead, packet.FreeCapacity()); |
463 | 534 |
464 EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet)); | 535 EXPECT_TRUE(packetizer_->NextPacket(&packet, &last_packet)); |
465 EXPECT_EQ(kExpectedTotalSize, packet.payload_size()); | 536 EXPECT_EQ(kExpectedTotalSize, packet.payload_size()); |
(...skipping 352 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
818 const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264; | 889 const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264; |
819 EXPECT_EQ(kH264SingleNalu, h264.packetization_type); | 890 EXPECT_EQ(kH264SingleNalu, h264.packetization_type); |
820 EXPECT_EQ(kSei, h264.nalu_type); | 891 EXPECT_EQ(kSei, h264.nalu_type); |
821 ASSERT_EQ(1u, h264.nalus_length); | 892 ASSERT_EQ(1u, h264.nalus_length); |
822 EXPECT_EQ(static_cast<H264::NaluType>(kSei), h264.nalus[0].type); | 893 EXPECT_EQ(static_cast<H264::NaluType>(kSei), h264.nalus[0].type); |
823 EXPECT_EQ(-1, h264.nalus[0].sps_id); | 894 EXPECT_EQ(-1, h264.nalus[0].sps_id); |
824 EXPECT_EQ(-1, h264.nalus[0].pps_id); | 895 EXPECT_EQ(-1, h264.nalus[0].pps_id); |
825 } | 896 } |
826 | 897 |
827 } // namespace webrtc | 898 } // namespace webrtc |
OLD | NEW |