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
11 #include <cstring>
12 #include <map>
13 #include <set>
14 #include <utility>
15
16 #include "common_video/h264/h264_common.h"
17 #include "modules/video_coding/frame_object.h"
18 #include "modules/video_coding/packet_buffer.h"
19 #include "rtc_base/random.h"
20 #include "system_wrappers/include/clock.h"
21 #include "test/field_trial.h"
22 #include "test/gtest.h"
23
24 namespace webrtc {
25 namespace video_coding {
26
27 class TestPacketBuffer : public ::testing::Test,
28 public OnReceivedFrameCallback {
29 protected:
TestPacketBuffer()30 TestPacketBuffer() : TestPacketBuffer("") {}
TestPacketBuffer(std::string field_trials)31 explicit TestPacketBuffer(std::string field_trials)
32 : scoped_field_trials_(field_trials),
33 rand_(0x7732213),
34 clock_(new SimulatedClock(0)),
35 packet_buffer_(
36 PacketBuffer::Create(clock_.get(), kStartSize, kMaxSize, this)) {}
37
Rand()38 uint16_t Rand() { return rand_.Rand<uint16_t>(); }
39
OnReceivedFrame(std::unique_ptr<RtpFrameObject> frame)40 void OnReceivedFrame(std::unique_ptr<RtpFrameObject> frame) override {
41 uint16_t first_seq_num = frame->first_seq_num();
42 if (frames_from_callback_.find(first_seq_num) !=
43 frames_from_callback_.end()) {
44 ADD_FAILURE() << "Already received frame with first sequence number "
45 << first_seq_num << ".";
46 return;
47 }
48
49 frames_from_callback_.insert(
50 std::make_pair(frame->first_seq_num(), std::move(frame)));
51 }
52
53 enum IsKeyFrame { kKeyFrame, kDeltaFrame };
54 enum IsFirst { kFirst, kNotFirst };
55 enum IsLast { kLast, kNotLast };
56
Insert(uint16_t seq_num,IsKeyFrame keyframe,IsFirst first,IsLast last,int data_size=0,uint8_t * data=nullptr)57 bool Insert(uint16_t seq_num, // packet sequence number
58 IsKeyFrame keyframe, // is keyframe
59 IsFirst first, // is first packet of frame
60 IsLast last, // is last packet of frame
61 int data_size = 0, // size of data
62 uint8_t* data = nullptr) { // data pointer
63 VCMPacket packet;
64 packet.codec = kVideoCodecGeneric;
65 packet.seqNum = seq_num;
66 packet.frameType =
67 keyframe == kKeyFrame ? kVideoFrameKey : kVideoFrameDelta;
68 packet.is_first_packet_in_frame = first == kFirst;
69 packet.markerBit = last == kLast;
70 packet.sizeBytes = data_size;
71 packet.dataPtr = data;
72
73 return packet_buffer_->InsertPacket(&packet);
74 }
75
CheckFrame(uint16_t first_seq_num)76 void CheckFrame(uint16_t first_seq_num) {
77 auto frame_it = frames_from_callback_.find(first_seq_num);
78 ASSERT_FALSE(frame_it == frames_from_callback_.end())
79 << "Could not find frame with first sequence number " << first_seq_num
80 << ".";
81 }
82
83 static constexpr int kStartSize = 16;
84 static constexpr int kMaxSize = 64;
85
86 const test::ScopedFieldTrials scoped_field_trials_;
87
88 Random rand_;
89 std::unique_ptr<SimulatedClock> clock_;
90 rtc::scoped_refptr<PacketBuffer> packet_buffer_;
91 std::map<uint16_t, std::unique_ptr<RtpFrameObject>> frames_from_callback_;
92 };
93
TEST_F(TestPacketBuffer,InsertOnePacket)94 TEST_F(TestPacketBuffer, InsertOnePacket) {
95 const uint16_t seq_num = Rand();
96 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
97 }
98
TEST_F(TestPacketBuffer,InsertMultiplePackets)99 TEST_F(TestPacketBuffer, InsertMultiplePackets) {
100 const uint16_t seq_num = Rand();
101 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
102 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kFirst, kLast));
103 EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kFirst, kLast));
104 EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kFirst, kLast));
105 }
106
TEST_F(TestPacketBuffer,InsertDuplicatePacket)107 TEST_F(TestPacketBuffer, InsertDuplicatePacket) {
108 const uint16_t seq_num = Rand();
109 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
110 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
111 }
112
TEST_F(TestPacketBuffer,SeqNumWrapOneFrame)113 TEST_F(TestPacketBuffer, SeqNumWrapOneFrame) {
114 EXPECT_TRUE(Insert(0xFFFF, kKeyFrame, kFirst, kNotLast));
115 EXPECT_TRUE(Insert(0x0, kKeyFrame, kNotFirst, kLast));
116
117 CheckFrame(0xFFFF);
118 }
119
TEST_F(TestPacketBuffer,SeqNumWrapTwoFrames)120 TEST_F(TestPacketBuffer, SeqNumWrapTwoFrames) {
121 EXPECT_TRUE(Insert(0xFFFF, kKeyFrame, kFirst, kLast));
122 EXPECT_TRUE(Insert(0x0, kKeyFrame, kFirst, kLast));
123
124 CheckFrame(0xFFFF);
125 CheckFrame(0x0);
126 }
127
TEST_F(TestPacketBuffer,InsertOldPackets)128 TEST_F(TestPacketBuffer, InsertOldPackets) {
129 const uint16_t seq_num = Rand();
130
131 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
132 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
133 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast));
134 ASSERT_EQ(2UL, frames_from_callback_.size());
135
136 frames_from_callback_.erase(seq_num + 2);
137 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
138 ASSERT_EQ(1UL, frames_from_callback_.size());
139
140 frames_from_callback_.erase(frames_from_callback_.find(seq_num));
141 ASSERT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
142 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
143
144 packet_buffer_->ClearTo(seq_num + 2);
145 EXPECT_FALSE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
146 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast));
147 ASSERT_EQ(2UL, frames_from_callback_.size());
148 }
149
TEST_F(TestPacketBuffer,NackCount)150 TEST_F(TestPacketBuffer, NackCount) {
151 const uint16_t seq_num = Rand();
152
153 VCMPacket packet;
154 packet.codec = kVideoCodecGeneric;
155 packet.seqNum = seq_num;
156 packet.frameType = kVideoFrameKey;
157 packet.is_first_packet_in_frame = true;
158 packet.markerBit = false;
159 packet.timesNacked = 0;
160
161 packet_buffer_->InsertPacket(&packet);
162
163 packet.seqNum++;
164 packet.is_first_packet_in_frame = false;
165 packet.timesNacked = 1;
166 packet_buffer_->InsertPacket(&packet);
167
168 packet.seqNum++;
169 packet.timesNacked = 3;
170 packet_buffer_->InsertPacket(&packet);
171
172 packet.seqNum++;
173 packet.markerBit = true;
174 packet.timesNacked = 1;
175 packet_buffer_->InsertPacket(&packet);
176
177 ASSERT_EQ(1UL, frames_from_callback_.size());
178 RtpFrameObject* frame = frames_from_callback_.begin()->second.get();
179 EXPECT_EQ(3, frame->times_nacked());
180 }
181
TEST_F(TestPacketBuffer,FrameSize)182 TEST_F(TestPacketBuffer, FrameSize) {
183 const uint16_t seq_num = Rand();
184 uint8_t* data1 = new uint8_t[5]();
185 uint8_t* data2 = new uint8_t[5]();
186 uint8_t* data3 = new uint8_t[5]();
187 uint8_t* data4 = new uint8_t[5]();
188
189 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast, 5, data1));
190 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast, 5, data2));
191 EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kNotFirst, kNotLast, 5, data3));
192 EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kNotFirst, kLast, 5, data4));
193
194 ASSERT_EQ(1UL, frames_from_callback_.size());
195 EXPECT_EQ(20UL, frames_from_callback_.begin()->second->size());
196 }
197
TEST_F(TestPacketBuffer,ExpandBuffer)198 TEST_F(TestPacketBuffer, ExpandBuffer) {
199 const uint16_t seq_num = Rand();
200
201 for (int i = 0; i < kStartSize + 1; ++i) {
202 EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kFirst, kLast));
203 }
204 }
205
TEST_F(TestPacketBuffer,SingleFrameExpandsBuffer)206 TEST_F(TestPacketBuffer, SingleFrameExpandsBuffer) {
207 const uint16_t seq_num = Rand();
208
209 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
210 for (int i = 1; i < kStartSize; ++i)
211 EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kNotFirst, kNotLast));
212 EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kNotFirst, kLast));
213
214 ASSERT_EQ(1UL, frames_from_callback_.size());
215 CheckFrame(seq_num);
216 }
217
TEST_F(TestPacketBuffer,ExpandBufferOverflow)218 TEST_F(TestPacketBuffer, ExpandBufferOverflow) {
219 const uint16_t seq_num = Rand();
220
221 for (int i = 0; i < kMaxSize; ++i)
222 EXPECT_TRUE(Insert(seq_num + i, kKeyFrame, kFirst, kLast));
223 EXPECT_TRUE(Insert(seq_num + kMaxSize + 1, kKeyFrame, kFirst, kLast));
224 }
225
TEST_F(TestPacketBuffer,OnePacketOneFrame)226 TEST_F(TestPacketBuffer, OnePacketOneFrame) {
227 const uint16_t seq_num = Rand();
228 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
229 ASSERT_EQ(1UL, frames_from_callback_.size());
230 CheckFrame(seq_num);
231 }
232
TEST_F(TestPacketBuffer,TwoPacketsTwoFrames)233 TEST_F(TestPacketBuffer, TwoPacketsTwoFrames) {
234 const uint16_t seq_num = Rand();
235
236 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
237 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kFirst, kLast));
238
239 EXPECT_EQ(2UL, frames_from_callback_.size());
240 CheckFrame(seq_num);
241 CheckFrame(seq_num + 1);
242 }
243
TEST_F(TestPacketBuffer,TwoPacketsOneFrames)244 TEST_F(TestPacketBuffer, TwoPacketsOneFrames) {
245 const uint16_t seq_num = Rand();
246
247 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
248 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kLast));
249
250 EXPECT_EQ(1UL, frames_from_callback_.size());
251 CheckFrame(seq_num);
252 }
253
TEST_F(TestPacketBuffer,ThreePacketReorderingOneFrame)254 TEST_F(TestPacketBuffer, ThreePacketReorderingOneFrame) {
255 const uint16_t seq_num = Rand();
256
257 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
258 EXPECT_TRUE(Insert(seq_num + 2, kKeyFrame, kNotFirst, kLast));
259 EXPECT_TRUE(Insert(seq_num + 1, kKeyFrame, kNotFirst, kNotLast));
260
261 EXPECT_EQ(1UL, frames_from_callback_.size());
262 CheckFrame(seq_num);
263 }
264
TEST_F(TestPacketBuffer,Frames)265 TEST_F(TestPacketBuffer, Frames) {
266 const uint16_t seq_num = Rand();
267
268 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
269 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast));
270 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
271 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast));
272
273 ASSERT_EQ(4UL, frames_from_callback_.size());
274 CheckFrame(seq_num);
275 CheckFrame(seq_num + 1);
276 CheckFrame(seq_num + 2);
277 CheckFrame(seq_num + 3);
278 }
279
TEST_F(TestPacketBuffer,ClearSinglePacket)280 TEST_F(TestPacketBuffer, ClearSinglePacket) {
281 const uint16_t seq_num = Rand();
282
283 for (int i = 0; i < kMaxSize; ++i)
284 EXPECT_TRUE(Insert(seq_num + i, kDeltaFrame, kFirst, kLast));
285
286 packet_buffer_->ClearTo(seq_num);
287 EXPECT_TRUE(Insert(seq_num + kMaxSize, kDeltaFrame, kFirst, kLast));
288 }
289
TEST_F(TestPacketBuffer,ClearFullBuffer)290 TEST_F(TestPacketBuffer, ClearFullBuffer) {
291 for (int i = 0; i < kMaxSize; ++i)
292 EXPECT_TRUE(Insert(i, kDeltaFrame, kFirst, kLast));
293
294 packet_buffer_->ClearTo(kMaxSize - 1);
295
296 for (int i = kMaxSize; i < 2 * kMaxSize; ++i)
297 EXPECT_TRUE(Insert(i, kDeltaFrame, kFirst, kLast));
298 }
299
TEST_F(TestPacketBuffer,DontClearNewerPacket)300 TEST_F(TestPacketBuffer, DontClearNewerPacket) {
301 EXPECT_TRUE(Insert(0, kKeyFrame, kFirst, kLast));
302 packet_buffer_->ClearTo(0);
303 EXPECT_TRUE(Insert(2 * kStartSize, kKeyFrame, kFirst, kLast));
304 EXPECT_TRUE(Insert(3 * kStartSize + 1, kKeyFrame, kFirst, kNotLast));
305 packet_buffer_->ClearTo(2 * kStartSize);
306 EXPECT_TRUE(Insert(3 * kStartSize + 2, kKeyFrame, kNotFirst, kLast));
307
308 ASSERT_EQ(3UL, frames_from_callback_.size());
309 CheckFrame(0);
310 CheckFrame(2 * kStartSize);
311 CheckFrame(3 * kStartSize + 1);
312 }
313
TEST_F(TestPacketBuffer,OneIncompleteFrame)314 TEST_F(TestPacketBuffer, OneIncompleteFrame) {
315 const uint16_t seq_num = Rand();
316
317 EXPECT_TRUE(Insert(seq_num, kDeltaFrame, kFirst, kNotLast));
318 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kLast));
319 EXPECT_TRUE(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast));
320
321 ASSERT_EQ(1UL, frames_from_callback_.size());
322 CheckFrame(seq_num);
323 }
324
TEST_F(TestPacketBuffer,TwoIncompleteFramesFullBuffer)325 TEST_F(TestPacketBuffer, TwoIncompleteFramesFullBuffer) {
326 const uint16_t seq_num = Rand();
327
328 for (int i = 1; i < kMaxSize - 1; ++i)
329 EXPECT_TRUE(Insert(seq_num + i, kDeltaFrame, kNotFirst, kNotLast));
330 EXPECT_TRUE(Insert(seq_num, kDeltaFrame, kFirst, kNotLast));
331 EXPECT_TRUE(Insert(seq_num - 1, kDeltaFrame, kNotFirst, kLast));
332
333 ASSERT_EQ(0UL, frames_from_callback_.size());
334 }
335
TEST_F(TestPacketBuffer,FramesReordered)336 TEST_F(TestPacketBuffer, FramesReordered) {
337 const uint16_t seq_num = Rand();
338
339 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kFirst, kLast));
340 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
341 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kFirst, kLast));
342 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kFirst, kLast));
343
344 ASSERT_EQ(4UL, frames_from_callback_.size());
345 CheckFrame(seq_num);
346 CheckFrame(seq_num + 1);
347 CheckFrame(seq_num + 2);
348 CheckFrame(seq_num + 3);
349 }
350
TEST_F(TestPacketBuffer,GetBitstream)351 TEST_F(TestPacketBuffer, GetBitstream) {
352 // "many bitstream, such data" with null termination.
353 uint8_t many_data[] = {0x6d, 0x61, 0x6e, 0x79, 0x20};
354 uint8_t bitstream_data[] = {0x62, 0x69, 0x74, 0x73, 0x74, 0x72,
355 0x65, 0x61, 0x6d, 0x2c, 0x20};
356 uint8_t such_data[] = {0x73, 0x75, 0x63, 0x68, 0x20};
357 uint8_t data_data[] = {0x64, 0x61, 0x74, 0x61, 0x0};
358
359 uint8_t* many = new uint8_t[sizeof(many_data)];
360 uint8_t* bitstream = new uint8_t[sizeof(bitstream_data)];
361 uint8_t* such = new uint8_t[sizeof(such_data)];
362 uint8_t* data = new uint8_t[sizeof(data_data)];
363
364 memcpy(many, many_data, sizeof(many_data));
365 memcpy(bitstream, bitstream_data, sizeof(bitstream_data));
366 memcpy(such, such_data, sizeof(such_data));
367 memcpy(data, data_data, sizeof(data_data));
368
369 uint8_t result[sizeof(many_data) + sizeof(bitstream_data) +
370 sizeof(such_data) + sizeof(data_data)];
371
372 const uint16_t seq_num = Rand();
373
374 EXPECT_TRUE(
375 Insert(seq_num, kKeyFrame, kFirst, kNotLast, sizeof(many_data), many));
376 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast,
377 sizeof(bitstream_data), bitstream));
378 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kNotLast,
379 sizeof(such_data), such));
380 EXPECT_TRUE(Insert(seq_num + 3, kDeltaFrame, kNotFirst, kLast,
381 sizeof(data_data), data));
382
383 ASSERT_EQ(1UL, frames_from_callback_.size());
384 CheckFrame(seq_num);
385 EXPECT_EQ(frames_from_callback_[seq_num]->size(), sizeof(result));
386 EXPECT_TRUE(frames_from_callback_[seq_num]->GetBitstream(result));
387 EXPECT_EQ(memcmp(result, "many bitstream, such data", sizeof(result)), 0);
388 }
389
TEST_F(TestPacketBuffer,GetBitstreamOneFrameOnePacket)390 TEST_F(TestPacketBuffer, GetBitstreamOneFrameOnePacket) {
391 uint8_t bitstream_data[] = "All the bitstream data for this frame!";
392 uint8_t result[sizeof(bitstream_data)];
393 uint8_t* data = new uint8_t[sizeof(bitstream_data)];
394 memcpy(data, bitstream_data, sizeof(bitstream_data));
395
396 EXPECT_TRUE(
397 Insert(0, kKeyFrame, kFirst, kLast, sizeof(bitstream_data), data));
398
399 ASSERT_EQ(1UL, frames_from_callback_.size());
400 CheckFrame(0);
401 EXPECT_EQ(frames_from_callback_[0]->size(), sizeof(bitstream_data));
402 EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result));
403 EXPECT_EQ(memcmp(result, data, sizeof(bitstream_data)), 0);
404 }
405
TEST_F(TestPacketBuffer,GetBitstreamOneFrameFullBuffer)406 TEST_F(TestPacketBuffer, GetBitstreamOneFrameFullBuffer) {
407 uint8_t* data_arr[kStartSize];
408 uint8_t expected[kStartSize];
409 uint8_t result[kStartSize];
410
411 for (uint8_t i = 0; i < kStartSize; ++i) {
412 data_arr[i] = new uint8_t[1];
413 data_arr[i][0] = i;
414 expected[i] = i;
415 }
416
417 EXPECT_TRUE(Insert(0, kKeyFrame, kFirst, kNotLast, 1, data_arr[0]));
418 for (uint8_t i = 1; i < kStartSize - 1; ++i)
419 EXPECT_TRUE(Insert(i, kKeyFrame, kNotFirst, kNotLast, 1, data_arr[i]));
420 EXPECT_TRUE(Insert(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1,
421 data_arr[kStartSize - 1]));
422
423 ASSERT_EQ(1UL, frames_from_callback_.size());
424 CheckFrame(0);
425 EXPECT_EQ(frames_from_callback_[0]->size(), static_cast<size_t>(kStartSize));
426 EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result));
427 EXPECT_EQ(memcmp(result, expected, kStartSize), 0);
428 }
429
430 // If |sps_pps_idr_is_keyframe| is true, we require keyframes to contain
431 // SPS/PPS/IDR and the keyframes we create as part of the test do contain
432 // SPS/PPS/IDR. If |sps_pps_idr_is_keyframe| is false, we only require and
433 // create keyframes containing only IDR.
434 class TestPacketBufferH264 : public TestPacketBuffer {
435 protected:
TestPacketBufferH264(bool sps_pps_idr_is_keyframe)436 explicit TestPacketBufferH264(bool sps_pps_idr_is_keyframe)
437 : TestPacketBuffer(sps_pps_idr_is_keyframe
438 ? "WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/"
439 : ""),
440 sps_pps_idr_is_keyframe_(sps_pps_idr_is_keyframe) {}
441
InsertH264(uint16_t seq_num,IsKeyFrame keyframe,IsFirst first,IsLast last,uint32_t timestamp,int data_size=0,uint8_t * data=nullptr)442 bool InsertH264(uint16_t seq_num, // packet sequence number
443 IsKeyFrame keyframe, // is keyframe
444 IsFirst first, // is first packet of frame
445 IsLast last, // is last packet of frame
446 uint32_t timestamp, // rtp timestamp
447 int data_size = 0, // size of data
448 uint8_t* data = nullptr) { // data pointer
449 VCMPacket packet;
450 packet.codec = kVideoCodecH264;
451 packet.seqNum = seq_num;
452 packet.timestamp = timestamp;
453 if (keyframe == kKeyFrame) {
454 if (sps_pps_idr_is_keyframe_) {
455 packet.video_header.codecHeader.H264.nalus[0].type =
456 H264::NaluType::kSps;
457 packet.video_header.codecHeader.H264.nalus[1].type =
458 H264::NaluType::kPps;
459 packet.video_header.codecHeader.H264.nalus[2].type =
460 H264::NaluType::kIdr;
461 packet.video_header.codecHeader.H264.nalus_length = 3;
462 } else {
463 packet.video_header.codecHeader.H264.nalus[0].type =
464 H264::NaluType::kIdr;
465 packet.video_header.codecHeader.H264.nalus_length = 1;
466 }
467 }
468 packet.is_first_packet_in_frame = first == kFirst;
469 packet.markerBit = last == kLast;
470 packet.sizeBytes = data_size;
471 packet.dataPtr = data;
472
473 return packet_buffer_->InsertPacket(&packet);
474 }
475
476 const bool sps_pps_idr_is_keyframe_;
477 };
478
479 // This fixture is used to test the general behaviour of the packet buffer
480 // in both configurations.
481 class TestPacketBufferH264Parameterized
482 : public ::testing::WithParamInterface<bool>,
483 public TestPacketBufferH264 {
484 protected:
TestPacketBufferH264Parameterized()485 TestPacketBufferH264Parameterized() : TestPacketBufferH264(GetParam()) {}
486 };
487
488 INSTANTIATE_TEST_CASE_P(SpsPpsIdrIsKeyframe,
489 TestPacketBufferH264Parameterized,
490 ::testing::Values(false, true));
491
TEST_P(TestPacketBufferH264Parameterized,DontRemoveMissingPacketOnClearTo)492 TEST_P(TestPacketBufferH264Parameterized, DontRemoveMissingPacketOnClearTo) {
493 EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kLast, 0));
494 EXPECT_TRUE(InsertH264(2, kDeltaFrame, kFirst, kNotLast, 2));
495 packet_buffer_->ClearTo(0);
496 EXPECT_TRUE(InsertH264(3, kDeltaFrame, kNotFirst, kLast, 2));
497
498 ASSERT_EQ(1UL, frames_from_callback_.size());
499 CheckFrame(0);
500 }
501
TEST_P(TestPacketBufferH264Parameterized,GetBitstreamOneFrameFullBuffer)502 TEST_P(TestPacketBufferH264Parameterized, GetBitstreamOneFrameFullBuffer) {
503 uint8_t* data_arr[kStartSize];
504 uint8_t expected[kStartSize];
505 uint8_t result[kStartSize];
506
507 for (uint8_t i = 0; i < kStartSize; ++i) {
508 data_arr[i] = new uint8_t[1];
509 data_arr[i][0] = i;
510 expected[i] = i;
511 }
512
513 EXPECT_TRUE(InsertH264(0, kKeyFrame, kFirst, kNotLast, 1, 1, data_arr[0]));
514 for (uint8_t i = 1; i < kStartSize - 1; ++i) {
515 EXPECT_TRUE(
516 InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1, 1, data_arr[i]));
517 }
518 EXPECT_TRUE(InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1, 1,
519 data_arr[kStartSize - 1]));
520
521 ASSERT_EQ(1UL, frames_from_callback_.size());
522 CheckFrame(0);
523 EXPECT_EQ(frames_from_callback_[0]->size(), static_cast<size_t>(kStartSize));
524 EXPECT_TRUE(frames_from_callback_[0]->GetBitstream(result));
525 EXPECT_EQ(memcmp(result, expected, kStartSize), 0);
526 }
527
TEST_P(TestPacketBufferH264Parameterized,GetBitstreamBufferPadding)528 TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) {
529 uint16_t seq_num = Rand();
530 uint8_t data_data[] = "some plain old data";
531 uint8_t* data = new uint8_t[sizeof(data_data)];
532 memcpy(data, data_data, sizeof(data_data));
533
534 // EncodedImage::kBufferPaddingBytesH264 is unknown at compile time.
535 std::unique_ptr<uint8_t[]> result(
536 new uint8_t[sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264]);
537
538 VCMPacket packet;
539 packet.video_header.codecHeader.H264.nalus_length = 1;
540 packet.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
541 packet.seqNum = seq_num;
542 packet.codec = kVideoCodecH264;
543 packet.insertStartCode = true;
544 packet.video_header.codecHeader.H264.packetization_type = kH264SingleNalu;
545 packet.dataPtr = data;
546 packet.sizeBytes = sizeof(data_data);
547 packet.is_first_packet_in_frame = true;
548 packet.markerBit = true;
549 packet_buffer_->InsertPacket(&packet);
550
551 ASSERT_EQ(1UL, frames_from_callback_.size());
552 EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage()._length,
553 sizeof(data_data));
554 EXPECT_EQ(frames_from_callback_[seq_num]->EncodedImage()._size,
555 sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264);
556 EXPECT_TRUE(frames_from_callback_[seq_num]->GetBitstream(result.get()));
557 EXPECT_EQ(memcmp(result.get(), data, sizeof(data_data)), 0);
558 }
559
TEST_F(TestPacketBuffer,FreeSlotsOnFrameDestruction)560 TEST_F(TestPacketBuffer, FreeSlotsOnFrameDestruction) {
561 const uint16_t seq_num = Rand();
562
563 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
564 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast));
565 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast));
566 EXPECT_EQ(1UL, frames_from_callback_.size());
567 CheckFrame(seq_num);
568
569 frames_from_callback_.clear();
570
571 // Insert frame that fills the whole buffer.
572 EXPECT_TRUE(Insert(seq_num + 3, kKeyFrame, kFirst, kNotLast));
573 for (int i = 0; i < kMaxSize - 2; ++i)
574 EXPECT_TRUE(Insert(seq_num + i + 4, kDeltaFrame, kNotFirst, kNotLast));
575 EXPECT_TRUE(Insert(seq_num + kMaxSize + 2, kKeyFrame, kNotFirst, kLast));
576 EXPECT_EQ(1UL, frames_from_callback_.size());
577 CheckFrame(seq_num + 3);
578 }
579
TEST_F(TestPacketBuffer,Clear)580 TEST_F(TestPacketBuffer, Clear) {
581 const uint16_t seq_num = Rand();
582
583 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kNotLast));
584 EXPECT_TRUE(Insert(seq_num + 1, kDeltaFrame, kNotFirst, kNotLast));
585 EXPECT_TRUE(Insert(seq_num + 2, kDeltaFrame, kNotFirst, kLast));
586 EXPECT_EQ(1UL, frames_from_callback_.size());
587 CheckFrame(seq_num);
588
589 packet_buffer_->Clear();
590
591 EXPECT_TRUE(Insert(seq_num + kStartSize, kKeyFrame, kFirst, kNotLast));
592 EXPECT_TRUE(
593 Insert(seq_num + kStartSize + 1, kDeltaFrame, kNotFirst, kNotLast));
594 EXPECT_TRUE(Insert(seq_num + kStartSize + 2, kDeltaFrame, kNotFirst, kLast));
595 EXPECT_EQ(2UL, frames_from_callback_.size());
596 CheckFrame(seq_num + kStartSize);
597 }
598
TEST_F(TestPacketBuffer,InvalidateFrameByClearing)599 TEST_F(TestPacketBuffer, InvalidateFrameByClearing) {
600 const uint16_t seq_num = Rand();
601
602 EXPECT_TRUE(Insert(seq_num, kKeyFrame, kFirst, kLast));
603 ASSERT_EQ(1UL, frames_from_callback_.size());
604
605 packet_buffer_->Clear();
606 EXPECT_FALSE(frames_from_callback_.begin()->second->GetBitstream(nullptr));
607 }
608
TEST_F(TestPacketBuffer,FramesAfterClear)609 TEST_F(TestPacketBuffer, FramesAfterClear) {
610 Insert(9025, kDeltaFrame, kFirst, kLast);
611 Insert(9024, kKeyFrame, kFirst, kLast);
612 packet_buffer_->ClearTo(9025);
613 Insert(9057, kDeltaFrame, kFirst, kLast);
614 Insert(9026, kDeltaFrame, kFirst, kLast);
615
616 CheckFrame(9024);
617 CheckFrame(9025);
618 CheckFrame(9026);
619 CheckFrame(9057);
620 }
621
TEST_F(TestPacketBuffer,DontLeakPayloadData)622 TEST_F(TestPacketBuffer, DontLeakPayloadData) {
623 // NOTE! Any eventual leak is suppose to be detected by valgrind
624 // or any other similar tool.
625 uint8_t* data1 = new uint8_t[5];
626 uint8_t* data2 = new uint8_t[5];
627 uint8_t* data3 = new uint8_t[5];
628 uint8_t* data4 = new uint8_t[5];
629
630 // Expected to free data1 upon PacketBuffer destruction.
631 EXPECT_TRUE(Insert(2, kKeyFrame, kFirst, kNotLast, 5, data1));
632
633 // Expect to free data2 upon insertion.
634 EXPECT_TRUE(Insert(2, kKeyFrame, kFirst, kNotLast, 5, data2));
635
636 // Expect to free data3 upon insertion (old packet).
637 packet_buffer_->ClearTo(1);
638 EXPECT_FALSE(Insert(1, kKeyFrame, kFirst, kNotLast, 5, data3));
639
640 // Expect to free data4 upon insertion (packet buffer is full).
641 EXPECT_TRUE(Insert(2 + kMaxSize, kKeyFrame, kFirst, kNotLast, 5, data4));
642 }
643
TEST_F(TestPacketBuffer,ContinuousSeqNumDoubleMarkerBit)644 TEST_F(TestPacketBuffer, ContinuousSeqNumDoubleMarkerBit) {
645 Insert(2, kKeyFrame, kNotFirst, kNotLast);
646 Insert(1, kKeyFrame, kFirst, kLast);
647 frames_from_callback_.clear();
648 Insert(3, kKeyFrame, kNotFirst, kLast);
649
650 EXPECT_EQ(0UL, frames_from_callback_.size());
651 }
652
TEST_F(TestPacketBuffer,PacketTimestamps)653 TEST_F(TestPacketBuffer, PacketTimestamps) {
654 rtc::Optional<int64_t> packet_ms;
655 rtc::Optional<int64_t> packet_keyframe_ms;
656
657 packet_ms = packet_buffer_->LastReceivedPacketMs();
658 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
659 EXPECT_FALSE(packet_ms);
660 EXPECT_FALSE(packet_keyframe_ms);
661
662 int64_t keyframe_ms = clock_->TimeInMilliseconds();
663 EXPECT_TRUE(Insert(100, kKeyFrame, kFirst, kLast));
664 packet_ms = packet_buffer_->LastReceivedPacketMs();
665 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
666 EXPECT_TRUE(packet_ms);
667 EXPECT_TRUE(packet_keyframe_ms);
668 EXPECT_EQ(keyframe_ms, *packet_ms);
669 EXPECT_EQ(keyframe_ms, *packet_keyframe_ms);
670
671 clock_->AdvanceTimeMilliseconds(100);
672 int64_t delta_ms = clock_->TimeInMilliseconds();
673 EXPECT_TRUE(Insert(101, kDeltaFrame, kFirst, kLast));
674 packet_ms = packet_buffer_->LastReceivedPacketMs();
675 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
676 EXPECT_TRUE(packet_ms);
677 EXPECT_TRUE(packet_keyframe_ms);
678 EXPECT_EQ(delta_ms, *packet_ms);
679 EXPECT_EQ(keyframe_ms, *packet_keyframe_ms);
680
681 packet_buffer_->Clear();
682 packet_ms = packet_buffer_->LastReceivedPacketMs();
683 packet_keyframe_ms = packet_buffer_->LastReceivedKeyframePacketMs();
684 EXPECT_FALSE(packet_ms);
685 EXPECT_FALSE(packet_keyframe_ms);
686 }
687
TEST_P(TestPacketBufferH264Parameterized,OneFrameFillBuffer)688 TEST_P(TestPacketBufferH264Parameterized, OneFrameFillBuffer) {
689 InsertH264(0, kKeyFrame, kFirst, kNotLast, 1000);
690 for (int i = 1; i < kStartSize - 1; ++i)
691 InsertH264(i, kKeyFrame, kNotFirst, kNotLast, 1000);
692 InsertH264(kStartSize - 1, kKeyFrame, kNotFirst, kLast, 1000);
693
694 EXPECT_EQ(1UL, frames_from_callback_.size());
695 CheckFrame(0);
696 }
697
TEST_P(TestPacketBufferH264Parameterized,CreateFramesAfterFilledBuffer)698 TEST_P(TestPacketBufferH264Parameterized, CreateFramesAfterFilledBuffer) {
699 InsertH264(kStartSize - 2, kKeyFrame, kFirst, kLast, 0);
700 ASSERT_EQ(1UL, frames_from_callback_.size());
701 frames_from_callback_.clear();
702
703 InsertH264(kStartSize, kDeltaFrame, kFirst, kNotLast, 2000);
704 for (int i = 1; i < kStartSize; ++i)
705 InsertH264(kStartSize + i, kDeltaFrame, kNotFirst, kNotLast, 2000);
706 InsertH264(kStartSize + kStartSize, kDeltaFrame, kNotFirst, kLast, 2000);
707 ASSERT_EQ(0UL, frames_from_callback_.size());
708
709 InsertH264(kStartSize - 1, kKeyFrame, kFirst, kLast, 1000);
710 ASSERT_EQ(2UL, frames_from_callback_.size());
711 CheckFrame(kStartSize - 1);
712 CheckFrame(kStartSize);
713 }
714
TEST_P(TestPacketBufferH264Parameterized,OneFrameMaxSeqNum)715 TEST_P(TestPacketBufferH264Parameterized, OneFrameMaxSeqNum) {
716 InsertH264(65534, kKeyFrame, kFirst, kNotLast, 1000);
717 InsertH264(65535, kKeyFrame, kNotFirst, kLast, 1000);
718
719 EXPECT_EQ(1UL, frames_from_callback_.size());
720 CheckFrame(65534);
721 }
722
TEST_P(TestPacketBufferH264Parameterized,ClearMissingPacketsOnKeyframe)723 TEST_P(TestPacketBufferH264Parameterized, ClearMissingPacketsOnKeyframe) {
724 InsertH264(0, kKeyFrame, kFirst, kLast, 1000);
725 InsertH264(2, kKeyFrame, kFirst, kLast, 3000);
726 InsertH264(3, kDeltaFrame, kFirst, kNotLast, 4000);
727 InsertH264(4, kDeltaFrame, kNotFirst, kLast, 4000);
728
729 ASSERT_EQ(3UL, frames_from_callback_.size());
730
731 InsertH264(kStartSize + 1, kKeyFrame, kFirst, kLast, 18000);
732
733 ASSERT_EQ(4UL, frames_from_callback_.size());
734 CheckFrame(0);
735 CheckFrame(2);
736 CheckFrame(3);
737 CheckFrame(kStartSize + 1);
738 }
739
TEST_P(TestPacketBufferH264Parameterized,FindFramesOnPadding)740 TEST_P(TestPacketBufferH264Parameterized, FindFramesOnPadding) {
741 InsertH264(0, kKeyFrame, kFirst, kLast, 1000);
742 InsertH264(2, kDeltaFrame, kFirst, kLast, 1000);
743
744 ASSERT_EQ(1UL, frames_from_callback_.size());
745 packet_buffer_->PaddingReceived(1);
746 ASSERT_EQ(2UL, frames_from_callback_.size());
747 CheckFrame(0);
748 CheckFrame(2);
749 }
750
751 class TestPacketBufferH264XIsKeyframe : public TestPacketBufferH264 {
752 protected:
753 const uint16_t kSeqNum = 5;
754
TestPacketBufferH264XIsKeyframe(bool sps_pps_idr_is_keyframe)755 explicit TestPacketBufferH264XIsKeyframe(bool sps_pps_idr_is_keyframe)
756 : TestPacketBufferH264(sps_pps_idr_is_keyframe) {
757 packet_.codec = kVideoCodecH264;
758 packet_.seqNum = kSeqNum;
759
760 packet_.is_first_packet_in_frame = true;
761 packet_.markerBit = true;
762 }
763
764 VCMPacket packet_;
765 };
766
767 class TestPacketBufferH264IdrIsKeyframe
768 : public TestPacketBufferH264XIsKeyframe {
769 protected:
TestPacketBufferH264IdrIsKeyframe()770 TestPacketBufferH264IdrIsKeyframe()
771 : TestPacketBufferH264XIsKeyframe(false) {}
772 };
773
TEST_F(TestPacketBufferH264IdrIsKeyframe,IdrIsKeyframe)774 TEST_F(TestPacketBufferH264IdrIsKeyframe, IdrIsKeyframe) {
775 packet_.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
776 packet_.video_header.codecHeader.H264.nalus_length = 1;
777
778 packet_buffer_->InsertPacket(&packet_);
779
780 ASSERT_EQ(1u, frames_from_callback_.size());
781 EXPECT_EQ(kVideoFrameKey, frames_from_callback_[kSeqNum]->frame_type());
782 }
783
TEST_F(TestPacketBufferH264IdrIsKeyframe,SpsPpsIdrIsKeyframe)784 TEST_F(TestPacketBufferH264IdrIsKeyframe, SpsPpsIdrIsKeyframe) {
785 packet_.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kSps;
786 packet_.video_header.codecHeader.H264.nalus[1].type = H264::NaluType::kPps;
787 packet_.video_header.codecHeader.H264.nalus[2].type = H264::NaluType::kIdr;
788 packet_.video_header.codecHeader.H264.nalus_length = 3;
789
790 packet_buffer_->InsertPacket(&packet_);
791
792 ASSERT_EQ(1u, frames_from_callback_.size());
793 EXPECT_EQ(kVideoFrameKey, frames_from_callback_[kSeqNum]->frame_type());
794 }
795
796 class TestPacketBufferH264SpsPpsIdrIsKeyframe
797 : public TestPacketBufferH264XIsKeyframe {
798 protected:
TestPacketBufferH264SpsPpsIdrIsKeyframe()799 TestPacketBufferH264SpsPpsIdrIsKeyframe()
800 : TestPacketBufferH264XIsKeyframe(true) {}
801 };
802
TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe,IdrIsNotKeyframe)803 TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, IdrIsNotKeyframe) {
804 packet_.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
805 packet_.video_header.codecHeader.H264.nalus_length = 1;
806
807 packet_buffer_->InsertPacket(&packet_);
808
809 ASSERT_EQ(1u, frames_from_callback_.size());
810 EXPECT_EQ(kVideoFrameDelta, frames_from_callback_[5]->frame_type());
811 }
812
TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe,SpsPpsIsNotKeyframe)813 TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, SpsPpsIsNotKeyframe) {
814 packet_.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kSps;
815 packet_.video_header.codecHeader.H264.nalus[1].type = H264::NaluType::kPps;
816 packet_.video_header.codecHeader.H264.nalus_length = 2;
817
818 packet_buffer_->InsertPacket(&packet_);
819
820 ASSERT_EQ(1u, frames_from_callback_.size());
821 EXPECT_EQ(kVideoFrameDelta, frames_from_callback_[kSeqNum]->frame_type());
822 }
823
TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe,SpsPpsIdrIsKeyframe)824 TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, SpsPpsIdrIsKeyframe) {
825 packet_.video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kSps;
826 packet_.video_header.codecHeader.H264.nalus[1].type = H264::NaluType::kPps;
827 packet_.video_header.codecHeader.H264.nalus[2].type = H264::NaluType::kIdr;
828 packet_.video_header.codecHeader.H264.nalus_length = 3;
829
830 packet_buffer_->InsertPacket(&packet_);
831
832 ASSERT_EQ(1u, frames_from_callback_.size());
833 EXPECT_EQ(kVideoFrameKey, frames_from_callback_[kSeqNum]->frame_type());
834 }
835
836 } // namespace video_coding
837 } // namespace webrtc
838