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