xref: /aosp_15_r20/external/webrtc/modules/video_coding/jitter_buffer_unittest.cc (revision d9f758449e529ab9291ac668be2861e7a55c2422) 
1 /*
2  *  Copyright (c) 2011 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 "modules/video_coding/jitter_buffer.h"
12 
13 #include <list>
14 #include <memory>
15 #include <string>
16 #include <vector>
17 
18 #include "absl/memory/memory.h"
19 #include "common_video/h264/h264_common.h"
20 #include "modules/video_coding/frame_buffer.h"
21 #include "modules/video_coding/media_opt_util.h"
22 #include "modules/video_coding/packet.h"
23 #include "modules/video_coding/test/stream_generator.h"
24 #include "system_wrappers/include/clock.h"
25 #include "system_wrappers/include/metrics.h"
26 #include "test/gmock.h"
27 #include "test/gtest.h"
28 #include "test/scoped_key_value_config.h"
29 
30 namespace webrtc {
31 
32 class TestBasicJitterBuffer : public ::testing::Test {
33  protected:
TestBasicJitterBuffer()34   TestBasicJitterBuffer() {}
SetUp()35   void SetUp() override {
36     clock_.reset(new SimulatedClock(0));
37     jitter_buffer_.reset(new VCMJitterBuffer(
38         clock_.get(), absl::WrapUnique(EventWrapper::Create()), field_trials_));
39     jitter_buffer_->Start();
40     seq_num_ = 1234;
41     timestamp_ = 0;
42     size_ = 1400;
43     // Data vector -  0, 0, 0x80, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0x80, 3....
44     data_[0] = 0;
45     data_[1] = 0;
46     data_[2] = 0x80;
47     int count = 3;
48     for (unsigned int i = 3; i < sizeof(data_) - 3; ++i) {
49       data_[i] = count;
50       count++;
51       if (count == 10) {
52         data_[i + 1] = 0;
53         data_[i + 2] = 0;
54         data_[i + 3] = 0x80;
55         count = 3;
56         i += 3;
57       }
58     }
59     RTPHeader rtp_header;
60     RTPVideoHeader video_header;
61     rtp_header.sequenceNumber = seq_num_;
62     rtp_header.timestamp = timestamp_;
63     rtp_header.markerBit = true;
64     video_header.codec = kVideoCodecGeneric;
65     video_header.is_first_packet_in_frame = true;
66     video_header.frame_type = VideoFrameType::kVideoFrameDelta;
67     packet_.reset(new VCMPacket(data_, size_, rtp_header, video_header,
68                                 /*ntp_time_ms=*/0, clock_->CurrentTime()));
69   }
70 
DecodeCompleteFrame()71   VCMEncodedFrame* DecodeCompleteFrame() {
72     VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(10);
73     if (!found_frame)
74       return nullptr;
75     return jitter_buffer_->ExtractAndSetDecode(found_frame->Timestamp());
76   }
77 
CheckOutFrame(VCMEncodedFrame * frame_out,unsigned int size,bool startCode)78   void CheckOutFrame(VCMEncodedFrame* frame_out,
79                      unsigned int size,
80                      bool startCode) {
81     ASSERT_TRUE(frame_out);
82 
83     const uint8_t* outData = frame_out->data();
84     unsigned int i = 0;
85 
86     if (startCode) {
87       EXPECT_EQ(0, outData[0]);
88       EXPECT_EQ(0, outData[1]);
89       EXPECT_EQ(0, outData[2]);
90       EXPECT_EQ(1, outData[3]);
91       i += 4;
92     }
93 
94     EXPECT_EQ(size, frame_out->size());
95     int count = 3;
96     for (; i < size; i++) {
97       if (outData[i] == 0 && outData[i + 1] == 0 && outData[i + 2] == 0x80) {
98         i += 2;
99       } else if (startCode && outData[i] == 0 && outData[i + 1] == 0) {
100         EXPECT_EQ(0, outData[0]);
101         EXPECT_EQ(0, outData[1]);
102         EXPECT_EQ(0, outData[2]);
103         EXPECT_EQ(1, outData[3]);
104         i += 3;
105       } else {
106         EXPECT_EQ(count, outData[i]);
107         count++;
108         if (count == 10) {
109           count = 3;
110         }
111       }
112     }
113   }
114 
115   uint16_t seq_num_;
116   uint32_t timestamp_;
117   int size_;
118   uint8_t data_[1500];
119   test::ScopedKeyValueConfig field_trials_;
120   std::unique_ptr<VCMPacket> packet_;
121   std::unique_ptr<SimulatedClock> clock_;
122   std::unique_ptr<VCMJitterBuffer> jitter_buffer_;
123 };
124 
125 class TestRunningJitterBuffer : public ::testing::Test {
126  protected:
127   enum { kDataBufferSize = 10 };
128 
SetUp()129   virtual void SetUp() {
130     clock_.reset(new SimulatedClock(0));
131     max_nack_list_size_ = 150;
132     oldest_packet_to_nack_ = 250;
133     jitter_buffer_ = new VCMJitterBuffer(
134         clock_.get(), absl::WrapUnique(EventWrapper::Create()), field_trials_);
135     stream_generator_ = new StreamGenerator(0, clock_->TimeInMilliseconds());
136     jitter_buffer_->Start();
137     jitter_buffer_->SetNackSettings(max_nack_list_size_, oldest_packet_to_nack_,
138                                     0);
139     memset(data_buffer_, 0, kDataBufferSize);
140   }
141 
TearDown()142   virtual void TearDown() {
143     jitter_buffer_->Stop();
144     delete stream_generator_;
145     delete jitter_buffer_;
146   }
147 
InsertPacketAndPop(int index)148   VCMFrameBufferEnum InsertPacketAndPop(int index) {
149     VCMPacket packet;
150     packet.dataPtr = data_buffer_;
151     bool packet_available = stream_generator_->PopPacket(&packet, index);
152     EXPECT_TRUE(packet_available);
153     if (!packet_available)
154       return kGeneralError;  // Return here to avoid crashes below.
155     bool retransmitted = false;
156     return jitter_buffer_->InsertPacket(packet, &retransmitted);
157   }
158 
InsertPacket(int index)159   VCMFrameBufferEnum InsertPacket(int index) {
160     VCMPacket packet;
161     packet.dataPtr = data_buffer_;
162     bool packet_available = stream_generator_->GetPacket(&packet, index);
163     EXPECT_TRUE(packet_available);
164     if (!packet_available)
165       return kGeneralError;  // Return here to avoid crashes below.
166     bool retransmitted = false;
167     return jitter_buffer_->InsertPacket(packet, &retransmitted);
168   }
169 
InsertFrame(VideoFrameType frame_type)170   VCMFrameBufferEnum InsertFrame(VideoFrameType frame_type) {
171     stream_generator_->GenerateFrame(
172         frame_type, (frame_type != VideoFrameType::kEmptyFrame) ? 1 : 0,
173         (frame_type == VideoFrameType::kEmptyFrame) ? 1 : 0,
174         clock_->TimeInMilliseconds());
175     VCMFrameBufferEnum ret = InsertPacketAndPop(0);
176     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
177     return ret;
178   }
179 
InsertFrames(int num_frames,VideoFrameType frame_type)180   VCMFrameBufferEnum InsertFrames(int num_frames, VideoFrameType frame_type) {
181     VCMFrameBufferEnum ret_for_all = kNoError;
182     for (int i = 0; i < num_frames; ++i) {
183       VCMFrameBufferEnum ret = InsertFrame(frame_type);
184       if (ret < kNoError) {
185         ret_for_all = ret;
186       } else if (ret_for_all >= kNoError) {
187         ret_for_all = ret;
188       }
189     }
190     return ret_for_all;
191   }
192 
DropFrame(int num_packets)193   void DropFrame(int num_packets) {
194     stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta,
195                                      num_packets, 0,
196                                      clock_->TimeInMilliseconds());
197     for (int i = 0; i < num_packets; ++i)
198       stream_generator_->DropLastPacket();
199     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
200   }
201 
DecodeCompleteFrame()202   bool DecodeCompleteFrame() {
203     VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(0);
204     if (!found_frame)
205       return false;
206 
207     VCMEncodedFrame* frame =
208         jitter_buffer_->ExtractAndSetDecode(found_frame->Timestamp());
209     bool ret = (frame != NULL);
210     jitter_buffer_->ReleaseFrame(frame);
211     return ret;
212   }
213 
214   test::ScopedKeyValueConfig field_trials_;
215   VCMJitterBuffer* jitter_buffer_;
216   StreamGenerator* stream_generator_;
217   std::unique_ptr<SimulatedClock> clock_;
218   size_t max_nack_list_size_;
219   int oldest_packet_to_nack_;
220   uint8_t data_buffer_[kDataBufferSize];
221 };
222 
223 class TestJitterBufferNack : public TestRunningJitterBuffer {
224  protected:
TestJitterBufferNack()225   TestJitterBufferNack() {}
SetUp()226   virtual void SetUp() { TestRunningJitterBuffer::SetUp(); }
227 
TearDown()228   virtual void TearDown() { TestRunningJitterBuffer::TearDown(); }
229 };
230 
TEST_F(TestBasicJitterBuffer,StopRunning)231 TEST_F(TestBasicJitterBuffer, StopRunning) {
232   jitter_buffer_->Stop();
233   EXPECT_TRUE(NULL == DecodeCompleteFrame());
234   jitter_buffer_->Start();
235 
236   // No packets inserted.
237   EXPECT_TRUE(NULL == DecodeCompleteFrame());
238 }
239 
TEST_F(TestBasicJitterBuffer,SinglePacketFrame)240 TEST_F(TestBasicJitterBuffer, SinglePacketFrame) {
241   // Always start with a complete key frame when not allowing errors.
242   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
243   packet_->video_header.is_first_packet_in_frame = true;
244   packet_->markerBit = true;
245   packet_->timestamp += 123 * 90;
246 
247   // Insert the packet to the jitter buffer and get a frame.
248   bool retransmitted = false;
249   EXPECT_EQ(kCompleteSession,
250             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
251   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
252   CheckOutFrame(frame_out, size_, false);
253   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
254   jitter_buffer_->ReleaseFrame(frame_out);
255 }
256 
TEST_F(TestBasicJitterBuffer,DualPacketFrame)257 TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
258   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
259   packet_->video_header.is_first_packet_in_frame = true;
260   packet_->markerBit = false;
261 
262   bool retransmitted = false;
263   EXPECT_EQ(kIncomplete,
264             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
265   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
266   // Should not be complete.
267   EXPECT_TRUE(frame_out == NULL);
268 
269   ++seq_num_;
270   packet_->video_header.is_first_packet_in_frame = false;
271   packet_->markerBit = true;
272   packet_->seqNum = seq_num_;
273 
274   EXPECT_EQ(kCompleteSession,
275             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
276 
277   frame_out = DecodeCompleteFrame();
278   CheckOutFrame(frame_out, 2 * size_, false);
279 
280   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
281   jitter_buffer_->ReleaseFrame(frame_out);
282 }
283 
284 TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) {
285   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
286   packet_->video_header.is_first_packet_in_frame = true;
287   packet_->markerBit = false;
288 
289   bool retransmitted = false;
290   EXPECT_EQ(kIncomplete,
291             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
292 
293   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
294 
295   // Frame should not be complete.
296   EXPECT_TRUE(frame_out == NULL);
297 
298   // Insert 98 frames.
299   int loop = 0;
300   do {
301     seq_num_++;
302     packet_->video_header.is_first_packet_in_frame = false;
303     packet_->markerBit = false;
304     packet_->seqNum = seq_num_;
305 
306     EXPECT_EQ(kIncomplete,
307               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
308     loop++;
309   } while (loop < 98);
310 
311   // Insert last packet.
312   ++seq_num_;
313   packet_->video_header.is_first_packet_in_frame = false;
314   packet_->markerBit = true;
315   packet_->seqNum = seq_num_;
316 
317   EXPECT_EQ(kCompleteSession,
318             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
319 
320   frame_out = DecodeCompleteFrame();
321 
322   CheckOutFrame(frame_out, 100 * size_, false);
323   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
324   jitter_buffer_->ReleaseFrame(frame_out);
325 }
326 
327 TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
328   // Always start with a complete key frame.
329   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
330   packet_->video_header.is_first_packet_in_frame = true;
331   packet_->markerBit = true;
332 
333   bool retransmitted = false;
334   EXPECT_EQ(kCompleteSession,
335             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
336   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
337   EXPECT_FALSE(frame_out == NULL);
338   jitter_buffer_->ReleaseFrame(frame_out);
339 
340   ++seq_num_;
341   packet_->seqNum = seq_num_;
342   packet_->markerBit = false;
343   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
344   packet_->timestamp += 33 * 90;
345 
346   EXPECT_EQ(kIncomplete,
347             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
348 
349   frame_out = DecodeCompleteFrame();
350 
351   // Frame should not be complete.
352   EXPECT_TRUE(frame_out == NULL);
353 
354   packet_->video_header.is_first_packet_in_frame = false;
355   // Insert 98 frames.
356   int loop = 0;
357   do {
358     ++seq_num_;
359     packet_->seqNum = seq_num_;
360 
361     // Insert a packet into a frame.
362     EXPECT_EQ(kIncomplete,
363               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
364     loop++;
365   } while (loop < 98);
366 
367   // Insert the last packet.
368   ++seq_num_;
369   packet_->video_header.is_first_packet_in_frame = false;
370   packet_->markerBit = true;
371   packet_->seqNum = seq_num_;
372 
373   EXPECT_EQ(kCompleteSession,
374             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
375 
376   frame_out = DecodeCompleteFrame();
377 
378   CheckOutFrame(frame_out, 100 * size_, false);
379   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
380   jitter_buffer_->ReleaseFrame(frame_out);
381 }
382 
TEST_F(TestBasicJitterBuffer,PacketReorderingReverseOrder)383 TEST_F(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
384   // Insert the "first" packet last.
385   seq_num_ += 100;
386   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
387   packet_->video_header.is_first_packet_in_frame = false;
388   packet_->markerBit = true;
389   packet_->seqNum = seq_num_;
390   packet_->timestamp = timestamp_;
391 
392   bool retransmitted = false;
393   EXPECT_EQ(kIncomplete,
394             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
395 
396   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
397 
398   EXPECT_TRUE(frame_out == NULL);
399 
400   // Insert 98 packets.
401   int loop = 0;
402   do {
403     seq_num_--;
404     packet_->video_header.is_first_packet_in_frame = false;
405     packet_->markerBit = false;
406     packet_->seqNum = seq_num_;
407 
408     EXPECT_EQ(kIncomplete,
409               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
410     loop++;
411   } while (loop < 98);
412 
413   // Insert the last packet.
414   seq_num_--;
415   packet_->video_header.is_first_packet_in_frame = true;
416   packet_->markerBit = false;
417   packet_->seqNum = seq_num_;
418 
419   EXPECT_EQ(kCompleteSession,
420             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
421 
422   frame_out = DecodeCompleteFrame();
423 
424   CheckOutFrame(frame_out, 100 * size_, false);
425 
426   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
427   jitter_buffer_->ReleaseFrame(frame_out);
428 }
429 
TEST_F(TestBasicJitterBuffer,FrameReordering2Frames2PacketsEach)430 TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
431   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
432   packet_->video_header.is_first_packet_in_frame = true;
433   packet_->markerBit = false;
434 
435   bool retransmitted = false;
436   EXPECT_EQ(kIncomplete,
437             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
438 
439   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
440 
441   EXPECT_TRUE(frame_out == NULL);
442 
443   seq_num_++;
444   packet_->video_header.is_first_packet_in_frame = false;
445   packet_->markerBit = true;
446   packet_->seqNum = seq_num_;
447 
448   EXPECT_EQ(kCompleteSession,
449             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
450 
451   // check that we fail to get frame since seqnum is not continuous
452   frame_out = DecodeCompleteFrame();
453   EXPECT_TRUE(frame_out == NULL);
454 
455   seq_num_ -= 3;
456   timestamp_ -= 33 * 90;
457   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
458   packet_->video_header.is_first_packet_in_frame = true;
459   packet_->markerBit = false;
460   packet_->seqNum = seq_num_;
461   packet_->timestamp = timestamp_;
462 
463   EXPECT_EQ(kIncomplete,
464             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
465 
466   frame_out = DecodeCompleteFrame();
467 
468   // It should not be complete.
469   EXPECT_TRUE(frame_out == NULL);
470 
471   seq_num_++;
472   packet_->video_header.is_first_packet_in_frame = false;
473   packet_->markerBit = true;
474   packet_->seqNum = seq_num_;
475 
476   EXPECT_EQ(kCompleteSession,
477             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
478 
479   frame_out = DecodeCompleteFrame();
480   CheckOutFrame(frame_out, 2 * size_, false);
481   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
482   jitter_buffer_->ReleaseFrame(frame_out);
483 
484   frame_out = DecodeCompleteFrame();
485   CheckOutFrame(frame_out, 2 * size_, false);
486   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
487   jitter_buffer_->ReleaseFrame(frame_out);
488 }
489 
TEST_F(TestBasicJitterBuffer,TestReorderingWithPadding)490 TEST_F(TestBasicJitterBuffer, TestReorderingWithPadding) {
491   jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0);
492   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
493   packet_->video_header.is_first_packet_in_frame = true;
494   packet_->markerBit = true;
495 
496   // Send in an initial good packet/frame (Frame A) to start things off.
497   bool retransmitted = false;
498   EXPECT_EQ(kCompleteSession,
499             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
500   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
501   EXPECT_TRUE(frame_out != NULL);
502   jitter_buffer_->ReleaseFrame(frame_out);
503 
504   // Now send in a complete delta frame (Frame C), but with a sequence number
505   // gap. No pic index either, so no temporal scalability cheating :)
506   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
507   // Leave a gap of 2 sequence numbers and two frames.
508   packet_->seqNum = seq_num_ + 3;
509   packet_->timestamp = timestamp_ + (66 * 90);
510   // Still isFirst = marker = true.
511   // Session should be complete (frame is complete), but there's nothing to
512   // decode yet.
513   EXPECT_EQ(kCompleteSession,
514             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
515   frame_out = DecodeCompleteFrame();
516   EXPECT_TRUE(frame_out == NULL);
517 
518   // Now send in a complete delta frame (Frame B) that is continuous from A, but
519   // doesn't fill the full gap to C. The rest of the gap is going to be padding.
520   packet_->seqNum = seq_num_ + 1;
521   packet_->timestamp = timestamp_ + (33 * 90);
522   // Still isFirst = marker = true.
523   EXPECT_EQ(kCompleteSession,
524             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
525   frame_out = DecodeCompleteFrame();
526   EXPECT_TRUE(frame_out != NULL);
527   jitter_buffer_->ReleaseFrame(frame_out);
528 
529   // But Frame C isn't continuous yet.
530   frame_out = DecodeCompleteFrame();
531   EXPECT_TRUE(frame_out == NULL);
532 
533   // Add in the padding. These are empty packets (data length is 0) with no
534   // marker bit and matching the timestamp of Frame B.
535   RTPHeader rtp_header;
536   RTPVideoHeader video_header;
537   rtp_header.sequenceNumber = seq_num_ + 2;
538   rtp_header.timestamp = timestamp_ + (33 * 90);
539   rtp_header.markerBit = false;
540   video_header.codec = kVideoCodecGeneric;
541   video_header.frame_type = VideoFrameType::kEmptyFrame;
542   VCMPacket empty_packet(data_, 0, rtp_header, video_header,
543                          /*ntp_time_ms=*/0, clock_->CurrentTime());
544   EXPECT_EQ(kOldPacket,
545             jitter_buffer_->InsertPacket(empty_packet, &retransmitted));
546   empty_packet.seqNum += 1;
547   EXPECT_EQ(kOldPacket,
548             jitter_buffer_->InsertPacket(empty_packet, &retransmitted));
549 
550   // But now Frame C should be ready!
551   frame_out = DecodeCompleteFrame();
552   EXPECT_TRUE(frame_out != NULL);
553   jitter_buffer_->ReleaseFrame(frame_out);
554 }
555 
TEST_F(TestBasicJitterBuffer,DuplicatePackets)556 TEST_F(TestBasicJitterBuffer, DuplicatePackets) {
557   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
558   packet_->video_header.is_first_packet_in_frame = true;
559   packet_->markerBit = false;
560   packet_->seqNum = seq_num_;
561   packet_->timestamp = timestamp_;
562   EXPECT_EQ(0, jitter_buffer_->num_packets());
563   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
564 
565   bool retransmitted = false;
566   EXPECT_EQ(kIncomplete,
567             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
568 
569   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
570 
571   EXPECT_TRUE(frame_out == NULL);
572   EXPECT_EQ(1, jitter_buffer_->num_packets());
573   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
574 
575   // Insert a packet into a frame.
576   EXPECT_EQ(kDuplicatePacket,
577             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
578   EXPECT_EQ(2, jitter_buffer_->num_packets());
579   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
580 
581   seq_num_++;
582   packet_->seqNum = seq_num_;
583   packet_->markerBit = true;
584   packet_->video_header.is_first_packet_in_frame = false;
585 
586   EXPECT_EQ(kCompleteSession,
587             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
588 
589   frame_out = DecodeCompleteFrame();
590   ASSERT_TRUE(frame_out != NULL);
591   CheckOutFrame(frame_out, 2 * size_, false);
592 
593   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
594   EXPECT_EQ(3, jitter_buffer_->num_packets());
595   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
596   jitter_buffer_->ReleaseFrame(frame_out);
597 }
598 
TEST_F(TestBasicJitterBuffer,DuplicatePreviousDeltaFramePacket)599 TEST_F(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) {
600   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
601   packet_->video_header.is_first_packet_in_frame = true;
602   packet_->markerBit = true;
603   packet_->seqNum = seq_num_;
604   packet_->timestamp = timestamp_;
605   EXPECT_EQ(0, jitter_buffer_->num_packets());
606   EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
607 
608   bool retransmitted = false;
609   // Insert first complete frame.
610   EXPECT_EQ(kCompleteSession,
611             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
612 
613   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
614   ASSERT_TRUE(frame_out != NULL);
615   CheckOutFrame(frame_out, size_, false);
616   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
617   jitter_buffer_->ReleaseFrame(frame_out);
618 
619   // Insert 3 delta frames.
620   for (uint16_t i = 1; i <= 3; ++i) {
621     packet_->seqNum = seq_num_ + i;
622     packet_->timestamp = timestamp_ + (i * 33) * 90;
623     packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
624     EXPECT_EQ(kCompleteSession,
625               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
626     EXPECT_EQ(i + 1, jitter_buffer_->num_packets());
627     EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets());
628   }
629 
630   // Retransmit second delta frame.
631   packet_->seqNum = seq_num_ + 2;
632   packet_->timestamp = timestamp_ + 66 * 90;
633 
634   EXPECT_EQ(kDuplicatePacket,
635             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
636 
637   EXPECT_EQ(5, jitter_buffer_->num_packets());
638   EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets());
639 
640   // Should be able to decode 3 delta frames, key frame already decoded.
641   for (size_t i = 0; i < 3; ++i) {
642     frame_out = DecodeCompleteFrame();
643     ASSERT_TRUE(frame_out != NULL);
644     CheckOutFrame(frame_out, size_, false);
645     EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
646     jitter_buffer_->ReleaseFrame(frame_out);
647   }
648 }
649 
TEST_F(TestBasicJitterBuffer,TestSkipForwardVp9)650 TEST_F(TestBasicJitterBuffer, TestSkipForwardVp9) {
651   // Verify that JB skips forward to next base layer frame.
652   //  -------------------------------------------------
653   // | 65485 | 65486 | 65487 | 65488 | 65489 | ...
654   // | pid:5 | pid:6 | pid:7 | pid:8 | pid:9 | ...
655   // | tid:0 | tid:2 | tid:1 | tid:2 | tid:0 | ...
656   // |  ss   |   x   |   x   |   x   |       |
657   //  -------------------------------------------------
658   // |<----------tl0idx:200--------->|<---tl0idx:201---
659 
660   jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0);
661   auto& vp9_header =
662       packet_->video_header.video_type_header.emplace<RTPVideoHeaderVP9>();
663 
664   bool re = false;
665   packet_->video_header.codec = kVideoCodecVP9;
666   packet_->video_header.is_first_packet_in_frame = true;
667   packet_->markerBit = true;
668   vp9_header.flexible_mode = false;
669   vp9_header.spatial_idx = 0;
670   vp9_header.beginning_of_frame = true;
671   vp9_header.end_of_frame = true;
672   vp9_header.temporal_up_switch = false;
673 
674   packet_->seqNum = 65485;
675   packet_->timestamp = 1000;
676   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
677   vp9_header.picture_id = 5;
678   vp9_header.tl0_pic_idx = 200;
679   vp9_header.temporal_idx = 0;
680   vp9_header.ss_data_available = true;
681   vp9_header.gof.SetGofInfoVP9(
682       kTemporalStructureMode3);  // kTemporalStructureMode3: 0-2-1-2..
683   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
684 
685   // Insert next temporal layer 0.
686   packet_->seqNum = 65489;
687   packet_->timestamp = 13000;
688   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
689   vp9_header.picture_id = 9;
690   vp9_header.tl0_pic_idx = 201;
691   vp9_header.temporal_idx = 0;
692   vp9_header.ss_data_available = false;
693   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
694 
695   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
696   EXPECT_EQ(1000U, frame_out->Timestamp());
697   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
698   jitter_buffer_->ReleaseFrame(frame_out);
699 
700   frame_out = DecodeCompleteFrame();
701   EXPECT_EQ(13000U, frame_out->Timestamp());
702   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
703   jitter_buffer_->ReleaseFrame(frame_out);
704 }
705 
TEST_F(TestBasicJitterBuffer,ReorderedVp9SsData_3TlLayers)706 TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
707   // Verify that frames are updated with SS data when SS packet is reordered.
708   //  --------------------------------
709   // | 65486 | 65487 | 65485 |...
710   // | pid:6 | pid:7 | pid:5 |...
711   // | tid:2 | tid:1 | tid:0 |...
712   // |       |       |  ss   |
713   //  --------------------------------
714   // |<--------tl0idx:200--------->|
715 
716   auto& vp9_header =
717       packet_->video_header.video_type_header.emplace<RTPVideoHeaderVP9>();
718 
719   bool re = false;
720   packet_->video_header.codec = kVideoCodecVP9;
721   packet_->video_header.is_first_packet_in_frame = true;
722   packet_->markerBit = true;
723   vp9_header.flexible_mode = false;
724   vp9_header.spatial_idx = 0;
725   vp9_header.beginning_of_frame = true;
726   vp9_header.end_of_frame = true;
727   vp9_header.tl0_pic_idx = 200;
728 
729   packet_->seqNum = 65486;
730   packet_->timestamp = 6000;
731   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
732   vp9_header.picture_id = 6;
733   vp9_header.temporal_idx = 2;
734   vp9_header.temporal_up_switch = true;
735   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
736 
737   packet_->seqNum = 65487;
738   packet_->timestamp = 9000;
739   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
740   vp9_header.picture_id = 7;
741   vp9_header.temporal_idx = 1;
742   vp9_header.temporal_up_switch = true;
743   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
744 
745   // Insert first frame with SS data.
746   packet_->seqNum = 65485;
747   packet_->timestamp = 3000;
748   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
749   packet_->video_header.width = 352;
750   packet_->video_header.height = 288;
751   vp9_header.picture_id = 5;
752   vp9_header.temporal_idx = 0;
753   vp9_header.temporal_up_switch = false;
754   vp9_header.ss_data_available = true;
755   vp9_header.gof.SetGofInfoVP9(
756       kTemporalStructureMode3);  // kTemporalStructureMode3: 0-2-1-2..
757   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
758 
759   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
760   EXPECT_EQ(3000U, frame_out->Timestamp());
761   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
762   EXPECT_EQ(0, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
763   EXPECT_FALSE(
764       frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
765   jitter_buffer_->ReleaseFrame(frame_out);
766 
767   frame_out = DecodeCompleteFrame();
768   EXPECT_EQ(6000U, frame_out->Timestamp());
769   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
770   EXPECT_EQ(2, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
771   EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
772   jitter_buffer_->ReleaseFrame(frame_out);
773 
774   frame_out = DecodeCompleteFrame();
775   EXPECT_EQ(9000U, frame_out->Timestamp());
776   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
777   EXPECT_EQ(1, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
778   EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
779   jitter_buffer_->ReleaseFrame(frame_out);
780 }
781 
TEST_F(TestBasicJitterBuffer,ReorderedVp9SsData_2Tl2SLayers)782 TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) {
783   // Verify that frames are updated with SS data when SS packet is reordered.
784   //  -----------------------------------------
785   // | 65486  | 65487  | 65485  | 65484  |...
786   // | pid:6  | pid:6  | pid:5  | pid:5  |...
787   // | tid:1  | tid:1  | tid:0  | tid:0  |...
788   // | sid:0  | sid:1  | sid:1  | sid:0  |...
789   // | t:6000 | t:6000 | t:3000 | t:3000 |
790   // |        |        |        |  ss    |
791   //  -----------------------------------------
792   // |<-----------tl0idx:200------------>|
793 
794   auto& vp9_header =
795       packet_->video_header.video_type_header.emplace<RTPVideoHeaderVP9>();
796 
797   bool re = false;
798   packet_->video_header.codec = kVideoCodecVP9;
799   vp9_header.flexible_mode = false;
800   vp9_header.beginning_of_frame = true;
801   vp9_header.end_of_frame = true;
802   vp9_header.tl0_pic_idx = 200;
803 
804   packet_->video_header.is_first_packet_in_frame = true;
805   packet_->markerBit = false;
806   packet_->seqNum = 65486;
807   packet_->timestamp = 6000;
808   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
809   vp9_header.spatial_idx = 0;
810   vp9_header.picture_id = 6;
811   vp9_header.temporal_idx = 1;
812   vp9_header.temporal_up_switch = true;
813   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re));
814 
815   packet_->video_header.is_first_packet_in_frame = false;
816   packet_->markerBit = true;
817   packet_->seqNum = 65487;
818   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
819   vp9_header.spatial_idx = 1;
820   vp9_header.picture_id = 6;
821   vp9_header.temporal_idx = 1;
822   vp9_header.temporal_up_switch = true;
823   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
824 
825   packet_->video_header.is_first_packet_in_frame = false;
826   packet_->markerBit = true;
827   packet_->seqNum = 65485;
828   packet_->timestamp = 3000;
829   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
830   vp9_header.spatial_idx = 1;
831   vp9_header.picture_id = 5;
832   vp9_header.temporal_idx = 0;
833   vp9_header.temporal_up_switch = false;
834   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re));
835 
836   // Insert first frame with SS data.
837   packet_->video_header.is_first_packet_in_frame = true;
838   packet_->markerBit = false;
839   packet_->seqNum = 65484;
840   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
841   packet_->video_header.width = 352;
842   packet_->video_header.height = 288;
843   vp9_header.spatial_idx = 0;
844   vp9_header.picture_id = 5;
845   vp9_header.temporal_idx = 0;
846   vp9_header.temporal_up_switch = false;
847   vp9_header.ss_data_available = true;
848   vp9_header.gof.SetGofInfoVP9(
849       kTemporalStructureMode2);  // kTemporalStructureMode3: 0-1-0-1..
850   EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re));
851 
852   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
853   EXPECT_EQ(3000U, frame_out->Timestamp());
854   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
855   EXPECT_EQ(0, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
856   EXPECT_FALSE(
857       frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
858   jitter_buffer_->ReleaseFrame(frame_out);
859 
860   frame_out = DecodeCompleteFrame();
861   EXPECT_EQ(6000U, frame_out->Timestamp());
862   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
863   EXPECT_EQ(1, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx);
864   EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch);
865   jitter_buffer_->ReleaseFrame(frame_out);
866 }
867 
TEST_F(TestBasicJitterBuffer,H264InsertStartCode)868 TEST_F(TestBasicJitterBuffer, H264InsertStartCode) {
869   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
870   packet_->video_header.is_first_packet_in_frame = true;
871   packet_->markerBit = false;
872   packet_->seqNum = seq_num_;
873   packet_->timestamp = timestamp_;
874   packet_->insertStartCode = true;
875 
876   bool retransmitted = false;
877   EXPECT_EQ(kIncomplete,
878             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
879 
880   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
881 
882   // Frame should not be complete.
883   EXPECT_TRUE(frame_out == NULL);
884 
885   seq_num_++;
886   packet_->video_header.is_first_packet_in_frame = false;
887   packet_->markerBit = true;
888   packet_->seqNum = seq_num_;
889 
890   EXPECT_EQ(kCompleteSession,
891             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
892 
893   frame_out = DecodeCompleteFrame();
894   CheckOutFrame(frame_out, size_ * 2 + 4 * 2, true);
895   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
896   jitter_buffer_->ReleaseFrame(frame_out);
897 }
898 
TEST_F(TestBasicJitterBuffer,SpsAndPpsHandling)899 TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) {
900   auto& h264_header =
901       packet_->video_header.video_type_header.emplace<RTPVideoHeaderH264>();
902   packet_->timestamp = timestamp_;
903   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
904   packet_->video_header.is_first_packet_in_frame = true;
905   packet_->markerBit = true;
906   packet_->video_header.codec = kVideoCodecH264;
907   h264_header.nalu_type = H264::NaluType::kIdr;
908   h264_header.nalus[0].type = H264::NaluType::kIdr;
909   h264_header.nalus[0].sps_id = -1;
910   h264_header.nalus[0].pps_id = 0;
911   h264_header.nalus_length = 1;
912   bool retransmitted = false;
913   EXPECT_EQ(kCompleteSession,
914             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
915   // Not decodable since sps and pps are missing.
916   EXPECT_EQ(nullptr, DecodeCompleteFrame());
917 
918   timestamp_ += 3000;
919   packet_->timestamp = timestamp_;
920   ++seq_num_;
921   packet_->seqNum = seq_num_;
922   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
923   packet_->video_header.is_first_packet_in_frame = true;
924   packet_->markerBit = false;
925   packet_->video_header.codec = kVideoCodecH264;
926   h264_header.nalu_type = H264::NaluType::kStapA;
927   h264_header.nalus[0].type = H264::NaluType::kSps;
928   h264_header.nalus[0].sps_id = 0;
929   h264_header.nalus[0].pps_id = -1;
930   h264_header.nalus[1].type = H264::NaluType::kPps;
931   h264_header.nalus[1].sps_id = 0;
932   h264_header.nalus[1].pps_id = 0;
933   h264_header.nalus_length = 2;
934   // Not complete since the marker bit hasn't been received.
935   EXPECT_EQ(kIncomplete,
936             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
937 
938   ++seq_num_;
939   packet_->seqNum = seq_num_;
940   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
941   packet_->video_header.is_first_packet_in_frame = false;
942   packet_->markerBit = true;
943   packet_->video_header.codec = kVideoCodecH264;
944   h264_header.nalu_type = H264::NaluType::kIdr;
945   h264_header.nalus[0].type = H264::NaluType::kIdr;
946   h264_header.nalus[0].sps_id = -1;
947   h264_header.nalus[0].pps_id = 0;
948   h264_header.nalus_length = 1;
949   // Complete and decodable since the pps and sps are received in the first
950   // packet of this frame.
951   EXPECT_EQ(kCompleteSession,
952             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
953   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
954   ASSERT_NE(nullptr, frame_out);
955   jitter_buffer_->ReleaseFrame(frame_out);
956 
957   timestamp_ += 3000;
958   packet_->timestamp = timestamp_;
959   ++seq_num_;
960   packet_->seqNum = seq_num_;
961   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
962   packet_->video_header.is_first_packet_in_frame = true;
963   packet_->markerBit = true;
964   packet_->video_header.codec = kVideoCodecH264;
965   h264_header.nalu_type = H264::NaluType::kSlice;
966   h264_header.nalus[0].type = H264::NaluType::kSlice;
967   h264_header.nalus[0].sps_id = -1;
968   h264_header.nalus[0].pps_id = 0;
969   h264_header.nalus_length = 1;
970   // Complete and decodable since sps, pps and key frame has been received.
971   EXPECT_EQ(kCompleteSession,
972             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
973   frame_out = DecodeCompleteFrame();
974   ASSERT_NE(nullptr, frame_out);
975   jitter_buffer_->ReleaseFrame(frame_out);
976 }
977 
TEST_F(TestBasicJitterBuffer,DeltaFrame100PacketsWithSeqNumWrap)978 TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
979   seq_num_ = 0xfff0;
980   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
981   packet_->video_header.is_first_packet_in_frame = true;
982   packet_->markerBit = false;
983   packet_->seqNum = seq_num_;
984   packet_->timestamp = timestamp_;
985 
986   bool retransmitted = false;
987   EXPECT_EQ(kIncomplete,
988             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
989 
990   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
991 
992   EXPECT_TRUE(frame_out == NULL);
993 
994   int loop = 0;
995   do {
996     seq_num_++;
997     packet_->video_header.is_first_packet_in_frame = false;
998     packet_->markerBit = false;
999     packet_->seqNum = seq_num_;
1000 
1001     EXPECT_EQ(kIncomplete,
1002               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1003 
1004     frame_out = DecodeCompleteFrame();
1005 
1006     EXPECT_TRUE(frame_out == NULL);
1007 
1008     loop++;
1009   } while (loop < 98);
1010 
1011   seq_num_++;
1012   packet_->video_header.is_first_packet_in_frame = false;
1013   packet_->markerBit = true;
1014   packet_->seqNum = seq_num_;
1015 
1016   EXPECT_EQ(kCompleteSession,
1017             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1018 
1019   frame_out = DecodeCompleteFrame();
1020 
1021   CheckOutFrame(frame_out, 100 * size_, false);
1022 
1023   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
1024   jitter_buffer_->ReleaseFrame(frame_out);
1025 }
1026 
TEST_F(TestBasicJitterBuffer,PacketReorderingReverseWithNegSeqNumWrap)1027 TEST_F(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
1028   // Insert "first" packet last seqnum.
1029   seq_num_ = 10;
1030   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1031   packet_->video_header.is_first_packet_in_frame = false;
1032   packet_->markerBit = true;
1033   packet_->seqNum = seq_num_;
1034 
1035   bool retransmitted = false;
1036   EXPECT_EQ(kIncomplete,
1037             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1038   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1039 
1040   // Should not be complete.
1041   EXPECT_TRUE(frame_out == NULL);
1042 
1043   // Insert 98 frames.
1044   int loop = 0;
1045   do {
1046     seq_num_--;
1047     packet_->video_header.is_first_packet_in_frame = false;
1048     packet_->markerBit = false;
1049     packet_->seqNum = seq_num_;
1050 
1051     EXPECT_EQ(kIncomplete,
1052               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1053 
1054     frame_out = DecodeCompleteFrame();
1055 
1056     EXPECT_TRUE(frame_out == NULL);
1057 
1058     loop++;
1059   } while (loop < 98);
1060 
1061   // Insert last packet.
1062   seq_num_--;
1063   packet_->video_header.is_first_packet_in_frame = true;
1064   packet_->markerBit = false;
1065   packet_->seqNum = seq_num_;
1066 
1067   EXPECT_EQ(kCompleteSession,
1068             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1069 
1070   frame_out = DecodeCompleteFrame();
1071   CheckOutFrame(frame_out, 100 * size_, false);
1072   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
1073   jitter_buffer_->ReleaseFrame(frame_out);
1074 }
1075 
TEST_F(TestBasicJitterBuffer,TestInsertOldFrame)1076 TEST_F(TestBasicJitterBuffer, TestInsertOldFrame) {
1077   //   -------      -------
1078   //  |   2   |    |   1   |
1079   //   -------      -------
1080   //  t = 3000     t = 2000
1081   seq_num_ = 2;
1082   timestamp_ = 3000;
1083   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1084   packet_->video_header.is_first_packet_in_frame = true;
1085   packet_->markerBit = true;
1086   packet_->timestamp = timestamp_;
1087   packet_->seqNum = seq_num_;
1088 
1089   bool retransmitted = false;
1090   EXPECT_EQ(kCompleteSession,
1091             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1092 
1093   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1094   EXPECT_EQ(3000u, frame_out->Timestamp());
1095   CheckOutFrame(frame_out, size_, false);
1096   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
1097   jitter_buffer_->ReleaseFrame(frame_out);
1098 
1099   seq_num_--;
1100   timestamp_ = 2000;
1101   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
1102   packet_->video_header.is_first_packet_in_frame = true;
1103   packet_->markerBit = true;
1104   packet_->seqNum = seq_num_;
1105   packet_->timestamp = timestamp_;
1106 
1107   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1108 }
1109 
TEST_F(TestBasicJitterBuffer,TestInsertOldFrameWithSeqNumWrap)1110 TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
1111   //   -------      -------
1112   //  |   2   |    |   1   |
1113   //   -------      -------
1114   //  t = 3000     t = 0xffffff00
1115 
1116   seq_num_ = 2;
1117   timestamp_ = 3000;
1118   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1119   packet_->video_header.is_first_packet_in_frame = true;
1120   packet_->markerBit = true;
1121   packet_->seqNum = seq_num_;
1122   packet_->timestamp = timestamp_;
1123 
1124   bool retransmitted = false;
1125   EXPECT_EQ(kCompleteSession,
1126             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1127 
1128   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1129   EXPECT_EQ(timestamp_, frame_out->Timestamp());
1130 
1131   CheckOutFrame(frame_out, size_, false);
1132 
1133   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
1134 
1135   jitter_buffer_->ReleaseFrame(frame_out);
1136 
1137   seq_num_--;
1138   timestamp_ = 0xffffff00;
1139   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
1140   packet_->video_header.is_first_packet_in_frame = true;
1141   packet_->markerBit = true;
1142   packet_->seqNum = seq_num_;
1143   packet_->timestamp = timestamp_;
1144 
1145   // This timestamp is old.
1146   EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1147 }
1148 
TEST_F(TestBasicJitterBuffer,TimestampWrap)1149 TEST_F(TestBasicJitterBuffer, TimestampWrap) {
1150   //  ---------------     ---------------
1151   // |   1   |   2   |   |   3   |   4   |
1152   //  ---------------     ---------------
1153   //  t = 0xffffff00        t = 33*90
1154 
1155   timestamp_ = 0xffffff00;
1156   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1157   packet_->video_header.is_first_packet_in_frame = true;
1158   packet_->markerBit = false;
1159   packet_->seqNum = seq_num_;
1160   packet_->timestamp = timestamp_;
1161 
1162   bool retransmitted = false;
1163   EXPECT_EQ(kIncomplete,
1164             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1165 
1166   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1167   EXPECT_TRUE(frame_out == NULL);
1168 
1169   seq_num_++;
1170   packet_->video_header.is_first_packet_in_frame = false;
1171   packet_->markerBit = true;
1172   packet_->seqNum = seq_num_;
1173 
1174   EXPECT_EQ(kCompleteSession,
1175             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1176 
1177   frame_out = DecodeCompleteFrame();
1178   CheckOutFrame(frame_out, 2 * size_, false);
1179   jitter_buffer_->ReleaseFrame(frame_out);
1180 
1181   seq_num_++;
1182   timestamp_ += 33 * 90;
1183   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
1184   packet_->video_header.is_first_packet_in_frame = true;
1185   packet_->markerBit = false;
1186   packet_->seqNum = seq_num_;
1187   packet_->timestamp = timestamp_;
1188 
1189   EXPECT_EQ(kIncomplete,
1190             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1191 
1192   frame_out = DecodeCompleteFrame();
1193   EXPECT_TRUE(frame_out == NULL);
1194 
1195   seq_num_++;
1196   packet_->video_header.is_first_packet_in_frame = false;
1197   packet_->markerBit = true;
1198   packet_->seqNum = seq_num_;
1199 
1200   EXPECT_EQ(kCompleteSession,
1201             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1202 
1203   frame_out = DecodeCompleteFrame();
1204   CheckOutFrame(frame_out, 2 * size_, false);
1205   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType());
1206   jitter_buffer_->ReleaseFrame(frame_out);
1207 }
1208 
1209 TEST_F(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
1210   //   -------          -------
1211   //  |   1   |        |   2   |
1212   //   -------          -------
1213   // t = 0xffffff00    t = 2700
1214 
1215   timestamp_ = 0xffffff00;
1216   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1217   packet_->video_header.is_first_packet_in_frame = true;
1218   packet_->markerBit = true;
1219   packet_->timestamp = timestamp_;
1220 
1221   bool retransmitted = false;
1222   // Insert first frame (session will be complete).
1223   EXPECT_EQ(kCompleteSession,
1224             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1225 
1226   // Insert next frame.
1227   seq_num_++;
1228   timestamp_ = 2700;
1229   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
1230   packet_->video_header.is_first_packet_in_frame = true;
1231   packet_->markerBit = true;
1232   packet_->seqNum = seq_num_;
1233   packet_->timestamp = timestamp_;
1234 
1235   EXPECT_EQ(kCompleteSession,
1236             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1237 
1238   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1239   EXPECT_EQ(0xffffff00, frame_out->Timestamp());
1240   CheckOutFrame(frame_out, size_, false);
1241   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
1242   jitter_buffer_->ReleaseFrame(frame_out);
1243 
1244   VCMEncodedFrame* frame_out2 = DecodeCompleteFrame();
1245   EXPECT_EQ(2700u, frame_out2->Timestamp());
1246   CheckOutFrame(frame_out2, size_, false);
1247   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out2->FrameType());
1248   jitter_buffer_->ReleaseFrame(frame_out2);
1249 }
1250 
TEST_F(TestBasicJitterBuffer,Insert2FramesReOrderedWithTimestampWrap)1251 TEST_F(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
1252   //   -------          -------
1253   //  |   2   |        |   1   |
1254   //   -------          -------
1255   //  t = 2700        t = 0xffffff00
1256 
1257   seq_num_ = 2;
1258   timestamp_ = 2700;
1259   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
1260   packet_->video_header.is_first_packet_in_frame = true;
1261   packet_->markerBit = true;
1262   packet_->seqNum = seq_num_;
1263   packet_->timestamp = timestamp_;
1264 
1265   bool retransmitted = false;
1266   EXPECT_EQ(kCompleteSession,
1267             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1268 
1269   // Insert second frame
1270   seq_num_--;
1271   timestamp_ = 0xffffff00;
1272   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1273   packet_->video_header.is_first_packet_in_frame = true;
1274   packet_->markerBit = true;
1275   packet_->seqNum = seq_num_;
1276   packet_->timestamp = timestamp_;
1277 
1278   EXPECT_EQ(kCompleteSession,
1279             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1280 
1281   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1282   EXPECT_EQ(0xffffff00, frame_out->Timestamp());
1283   CheckOutFrame(frame_out, size_, false);
1284   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
1285   jitter_buffer_->ReleaseFrame(frame_out);
1286 
1287   VCMEncodedFrame* frame_out2 = DecodeCompleteFrame();
1288   EXPECT_EQ(2700u, frame_out2->Timestamp());
1289   CheckOutFrame(frame_out2, size_, false);
1290   EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out2->FrameType());
1291   jitter_buffer_->ReleaseFrame(frame_out2);
1292 }
1293 
TEST_F(TestBasicJitterBuffer,DeltaFrameWithMoreThanMaxNumberOfPackets)1294 TEST_F(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
1295   int loop = 0;
1296   bool firstPacket = true;
1297   bool retransmitted = false;
1298   // Insert kMaxPacketsInJitterBuffer into frame.
1299   do {
1300     seq_num_++;
1301     packet_->video_header.is_first_packet_in_frame = false;
1302     packet_->markerBit = false;
1303     packet_->seqNum = seq_num_;
1304 
1305     if (firstPacket) {
1306       EXPECT_EQ(kIncomplete,
1307                 jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1308       firstPacket = false;
1309     } else {
1310       EXPECT_EQ(kIncomplete,
1311                 jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1312     }
1313 
1314     loop++;
1315   } while (loop < kMaxPacketsInSession);
1316 
1317   // Max number of packets inserted.
1318   // Insert one more packet.
1319   seq_num_++;
1320   packet_->video_header.is_first_packet_in_frame = false;
1321   packet_->markerBit = true;
1322   packet_->seqNum = seq_num_;
1323 
1324   // Insert the packet -> frame recycled.
1325   EXPECT_EQ(kSizeError, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1326   EXPECT_TRUE(NULL == DecodeCompleteFrame());
1327 }
1328 
TEST_F(TestBasicJitterBuffer,ExceedNumOfFrameWithSeqNumWrap)1329 TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
1330   // TEST fill JB with more than max number of frame (50 delta frames +
1331   // 51 key frames) with wrap in seq_num_
1332   //
1333   //  --------------------------------------------------------------
1334   // | 65485 | 65486 | 65487 | .... | 65535 | 0 | 1 | 2 | .....| 50 |
1335   //  --------------------------------------------------------------
1336   // |<-----------delta frames------------->|<------key frames----->|
1337 
1338   // Make sure the jitter doesn't request a keyframe after too much non-
1339   // decodable frames.
1340   jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0);
1341 
1342   int loop = 0;
1343   seq_num_ = 65485;
1344   uint32_t first_key_frame_timestamp = 0;
1345   bool retransmitted = false;
1346   // Insert MAX_NUMBER_OF_FRAMES frames.
1347   do {
1348     timestamp_ += 33 * 90;
1349     seq_num_++;
1350     packet_->video_header.is_first_packet_in_frame = true;
1351     packet_->markerBit = true;
1352     packet_->seqNum = seq_num_;
1353     packet_->timestamp = timestamp_;
1354 
1355     if (loop == 50) {
1356       first_key_frame_timestamp = packet_->timestamp;
1357       packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1358     }
1359 
1360     // Insert frame.
1361     EXPECT_EQ(kCompleteSession,
1362               jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1363 
1364     loop++;
1365   } while (loop < kMaxNumberOfFrames);
1366 
1367   // Max number of frames inserted.
1368 
1369   // Insert one more frame.
1370   timestamp_ += 33 * 90;
1371   seq_num_++;
1372   packet_->video_header.is_first_packet_in_frame = true;
1373   packet_->markerBit = true;
1374   packet_->seqNum = seq_num_;
1375   packet_->timestamp = timestamp_;
1376 
1377   // Now, no free frame - frames will be recycled until first key frame.
1378   EXPECT_EQ(kFlushIndicator,
1379             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1380 
1381   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1382   EXPECT_EQ(first_key_frame_timestamp, frame_out->Timestamp());
1383   CheckOutFrame(frame_out, size_, false);
1384   EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType());
1385   jitter_buffer_->ReleaseFrame(frame_out);
1386 }
1387 
TEST_F(TestBasicJitterBuffer,EmptyLastFrame)1388 TEST_F(TestBasicJitterBuffer, EmptyLastFrame) {
1389   seq_num_ = 3;
1390   // Insert one empty packet per frame, should never return the last timestamp
1391   // inserted. Only return empty frames in the presence of subsequent frames.
1392   int maxSize = 1000;
1393   bool retransmitted = false;
1394   for (int i = 0; i < maxSize + 10; i++) {
1395     timestamp_ += 33 * 90;
1396     seq_num_++;
1397     packet_->video_header.is_first_packet_in_frame = false;
1398     packet_->markerBit = false;
1399     packet_->seqNum = seq_num_;
1400     packet_->timestamp = timestamp_;
1401     packet_->video_header.frame_type = VideoFrameType::kEmptyFrame;
1402 
1403     EXPECT_EQ(kNoError, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1404   }
1405 }
1406 
TEST_F(TestBasicJitterBuffer,NextFrameWhenIncomplete)1407 TEST_F(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
1408   // Test that a we cannot get incomplete frames from the JB if we haven't
1409   // received the marker bit, unless we have received a packet from a later
1410   // timestamp.
1411   // Start with a complete key frame - insert and decode.
1412   jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0);
1413   packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey;
1414   packet_->video_header.is_first_packet_in_frame = true;
1415   packet_->markerBit = true;
1416   bool retransmitted = false;
1417 
1418   EXPECT_EQ(kCompleteSession,
1419             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1420   VCMEncodedFrame* frame_out = DecodeCompleteFrame();
1421   EXPECT_TRUE(frame_out != NULL);
1422   jitter_buffer_->ReleaseFrame(frame_out);
1423 
1424   packet_->seqNum += 2;
1425   packet_->timestamp += 33 * 90;
1426   packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta;
1427   packet_->video_header.is_first_packet_in_frame = false;
1428   packet_->markerBit = false;
1429 
1430   EXPECT_EQ(kIncomplete,
1431             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1432 
1433   packet_->seqNum += 2;
1434   packet_->timestamp += 33 * 90;
1435   packet_->video_header.is_first_packet_in_frame = true;
1436 
1437   EXPECT_EQ(kIncomplete,
1438             jitter_buffer_->InsertPacket(*packet_, &retransmitted));
1439 }
1440 
TEST_F(TestRunningJitterBuffer,Full)1441 TEST_F(TestRunningJitterBuffer, Full) {
1442   // Make sure the jitter doesn't request a keyframe after too much non-
1443   // decodable frames.
1444   jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0);
1445   // Insert a key frame and decode it.
1446   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError);
1447   EXPECT_TRUE(DecodeCompleteFrame());
1448   DropFrame(1);
1449   // Fill the jitter buffer.
1450   EXPECT_GE(InsertFrames(kMaxNumberOfFrames, VideoFrameType::kVideoFrameDelta),
1451             kNoError);
1452   // Make sure we can't decode these frames.
1453   EXPECT_FALSE(DecodeCompleteFrame());
1454   // This frame will make the jitter buffer recycle frames until a key frame.
1455   // Since none is found it will have to wait until the next key frame before
1456   // decoding.
1457   EXPECT_EQ(kFlushIndicator, InsertFrame(VideoFrameType::kVideoFrameDelta));
1458   EXPECT_FALSE(DecodeCompleteFrame());
1459 }
1460 
TEST_F(TestRunningJitterBuffer,EmptyPackets)1461 TEST_F(TestRunningJitterBuffer, EmptyPackets) {
1462   // Make sure a frame can get complete even though empty packets are missing.
1463   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 3,
1464                                    clock_->TimeInMilliseconds());
1465   bool request_key_frame = false;
1466   // Insert empty packet.
1467   EXPECT_EQ(kNoError, InsertPacketAndPop(4));
1468   EXPECT_FALSE(request_key_frame);
1469   // Insert 3 media packets.
1470   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1471   EXPECT_FALSE(request_key_frame);
1472   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1473   EXPECT_FALSE(request_key_frame);
1474   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
1475   EXPECT_FALSE(request_key_frame);
1476   // Insert empty packet.
1477   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
1478   EXPECT_FALSE(request_key_frame);
1479 }
1480 
TEST_F(TestRunningJitterBuffer,SkipToKeyFrame)1481 TEST_F(TestRunningJitterBuffer, SkipToKeyFrame) {
1482   // Insert delta frames.
1483   EXPECT_GE(InsertFrames(5, VideoFrameType::kVideoFrameDelta), kNoError);
1484   // Can't decode without a key frame.
1485   EXPECT_FALSE(DecodeCompleteFrame());
1486   InsertFrame(VideoFrameType::kVideoFrameKey);
1487   // Skip to the next key frame.
1488   EXPECT_TRUE(DecodeCompleteFrame());
1489 }
1490 
TEST_F(TestRunningJitterBuffer,DontSkipToKeyFrameIfDecodable)1491 TEST_F(TestRunningJitterBuffer, DontSkipToKeyFrameIfDecodable) {
1492   InsertFrame(VideoFrameType::kVideoFrameKey);
1493   EXPECT_TRUE(DecodeCompleteFrame());
1494   const int kNumDeltaFrames = 5;
1495   EXPECT_GE(InsertFrames(kNumDeltaFrames, VideoFrameType::kVideoFrameDelta),
1496             kNoError);
1497   InsertFrame(VideoFrameType::kVideoFrameKey);
1498   for (int i = 0; i < kNumDeltaFrames + 1; ++i) {
1499     EXPECT_TRUE(DecodeCompleteFrame());
1500   }
1501 }
1502 
TEST_F(TestRunningJitterBuffer,KeyDeltaKeyDelta)1503 TEST_F(TestRunningJitterBuffer, KeyDeltaKeyDelta) {
1504   InsertFrame(VideoFrameType::kVideoFrameKey);
1505   EXPECT_TRUE(DecodeCompleteFrame());
1506   const int kNumDeltaFrames = 5;
1507   EXPECT_GE(InsertFrames(kNumDeltaFrames, VideoFrameType::kVideoFrameDelta),
1508             kNoError);
1509   InsertFrame(VideoFrameType::kVideoFrameKey);
1510   EXPECT_GE(InsertFrames(kNumDeltaFrames, VideoFrameType::kVideoFrameDelta),
1511             kNoError);
1512   InsertFrame(VideoFrameType::kVideoFrameKey);
1513   for (int i = 0; i < 2 * (kNumDeltaFrames + 1); ++i) {
1514     EXPECT_TRUE(DecodeCompleteFrame());
1515   }
1516 }
1517 
TEST_F(TestRunningJitterBuffer,TwoPacketsNonContinuous)1518 TEST_F(TestRunningJitterBuffer, TwoPacketsNonContinuous) {
1519   InsertFrame(VideoFrameType::kVideoFrameKey);
1520   EXPECT_TRUE(DecodeCompleteFrame());
1521   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 1, 0,
1522                                    clock_->TimeInMilliseconds());
1523   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
1524   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 2, 0,
1525                                    clock_->TimeInMilliseconds());
1526   EXPECT_EQ(kIncomplete, InsertPacketAndPop(1));
1527   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(1));
1528   EXPECT_FALSE(DecodeCompleteFrame());
1529   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
1530   EXPECT_TRUE(DecodeCompleteFrame());
1531   EXPECT_TRUE(DecodeCompleteFrame());
1532 }
1533 
TEST_F(TestJitterBufferNack,EmptyPackets)1534 TEST_F(TestJitterBufferNack, EmptyPackets) {
1535   // Make sure empty packets doesn't clog the jitter buffer.
1536   EXPECT_GE(InsertFrames(kMaxNumberOfFrames, VideoFrameType::kEmptyFrame),
1537             kNoError);
1538   InsertFrame(VideoFrameType::kVideoFrameKey);
1539   EXPECT_TRUE(DecodeCompleteFrame());
1540 }
1541 
TEST_F(TestJitterBufferNack,NackTooOldPackets)1542 TEST_F(TestJitterBufferNack, NackTooOldPackets) {
1543   // Insert a key frame and decode it.
1544   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError);
1545   EXPECT_TRUE(DecodeCompleteFrame());
1546 
1547   // Drop one frame and insert `kNackHistoryLength` to trigger NACKing a too
1548   // old packet.
1549   DropFrame(1);
1550   // Insert a frame which should trigger a recycle until the next key frame.
1551   EXPECT_EQ(kFlushIndicator, InsertFrames(oldest_packet_to_nack_ + 1,
1552                                           VideoFrameType::kVideoFrameDelta));
1553   EXPECT_FALSE(DecodeCompleteFrame());
1554 
1555   bool request_key_frame = false;
1556   std::vector<uint16_t> nack_list =
1557       jitter_buffer_->GetNackList(&request_key_frame);
1558   // No key frame will be requested since the jitter buffer is empty.
1559   EXPECT_FALSE(request_key_frame);
1560   EXPECT_EQ(0u, nack_list.size());
1561 
1562   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameDelta), kNoError);
1563   // Waiting for a key frame.
1564   EXPECT_FALSE(DecodeCompleteFrame());
1565 
1566   // The next complete continuous frame isn't a key frame, but we're waiting
1567   // for one.
1568   EXPECT_FALSE(DecodeCompleteFrame());
1569   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError);
1570   // Skipping ahead to the key frame.
1571   EXPECT_TRUE(DecodeCompleteFrame());
1572 }
1573 
TEST_F(TestJitterBufferNack,NackLargeJitterBuffer)1574 TEST_F(TestJitterBufferNack, NackLargeJitterBuffer) {
1575   // Insert a key frame and decode it.
1576   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError);
1577   EXPECT_TRUE(DecodeCompleteFrame());
1578 
1579   // Insert a frame which should trigger a recycle until the next key frame.
1580   EXPECT_GE(
1581       InsertFrames(oldest_packet_to_nack_, VideoFrameType::kVideoFrameDelta),
1582       kNoError);
1583 
1584   bool request_key_frame = false;
1585   std::vector<uint16_t> nack_list =
1586       jitter_buffer_->GetNackList(&request_key_frame);
1587   // Verify that the jitter buffer does not request a key frame.
1588   EXPECT_FALSE(request_key_frame);
1589   // Verify that no packets are NACKed.
1590   EXPECT_EQ(0u, nack_list.size());
1591   // Verify that we can decode the next frame.
1592   EXPECT_TRUE(DecodeCompleteFrame());
1593 }
1594 
TEST_F(TestJitterBufferNack,NackListFull)1595 TEST_F(TestJitterBufferNack, NackListFull) {
1596   // Insert a key frame and decode it.
1597   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError);
1598   EXPECT_TRUE(DecodeCompleteFrame());
1599 
1600   // Generate and drop `kNackHistoryLength` packets to fill the NACK list.
1601   DropFrame(max_nack_list_size_ + 1);
1602   // Insert a frame which should trigger a recycle until the next key frame.
1603   EXPECT_EQ(kFlushIndicator, InsertFrame(VideoFrameType::kVideoFrameDelta));
1604   EXPECT_FALSE(DecodeCompleteFrame());
1605 
1606   bool request_key_frame = false;
1607   jitter_buffer_->GetNackList(&request_key_frame);
1608   // The jitter buffer is empty, so we won't request key frames until we get a
1609   // packet.
1610   EXPECT_FALSE(request_key_frame);
1611 
1612   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameDelta), kNoError);
1613   // Now we have a packet in the jitter buffer, a key frame will be requested
1614   // since it's not a key frame.
1615   jitter_buffer_->GetNackList(&request_key_frame);
1616   // The jitter buffer is empty, so we won't request key frames until we get a
1617   // packet.
1618   EXPECT_TRUE(request_key_frame);
1619   // The next complete continuous frame isn't a key frame, but we're waiting
1620   // for one.
1621   EXPECT_FALSE(DecodeCompleteFrame());
1622   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError);
1623   // Skipping ahead to the key frame.
1624   EXPECT_TRUE(DecodeCompleteFrame());
1625 }
1626 
TEST_F(TestJitterBufferNack,NoNackListReturnedBeforeFirstDecode)1627 TEST_F(TestJitterBufferNack, NoNackListReturnedBeforeFirstDecode) {
1628   DropFrame(10);
1629   // Insert a frame and try to generate a NACK list. Shouldn't get one.
1630   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameDelta), kNoError);
1631   bool request_key_frame = false;
1632   std::vector<uint16_t> nack_list =
1633       jitter_buffer_->GetNackList(&request_key_frame);
1634   // No list generated, and a key frame request is signaled.
1635   EXPECT_EQ(0u, nack_list.size());
1636   EXPECT_TRUE(request_key_frame);
1637 }
1638 
TEST_F(TestJitterBufferNack,NackListBuiltBeforeFirstDecode)1639 TEST_F(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) {
1640   stream_generator_->Init(0, clock_->TimeInMilliseconds());
1641   InsertFrame(VideoFrameType::kVideoFrameKey);
1642   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 2, 0,
1643                                    clock_->TimeInMilliseconds());
1644   stream_generator_->NextPacket(NULL);  // Drop packet.
1645   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1646   EXPECT_TRUE(DecodeCompleteFrame());
1647   bool extended = false;
1648   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
1649   EXPECT_EQ(1u, nack_list.size());
1650 }
1651 
TEST_F(TestJitterBufferNack,VerifyRetransmittedFlag)1652 TEST_F(TestJitterBufferNack, VerifyRetransmittedFlag) {
1653   stream_generator_->Init(0, clock_->TimeInMilliseconds());
1654   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 0,
1655                                    clock_->TimeInMilliseconds());
1656   VCMPacket packet;
1657   stream_generator_->PopPacket(&packet, 0);
1658   bool retransmitted = false;
1659   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(packet, &retransmitted));
1660   EXPECT_FALSE(retransmitted);
1661   // Drop second packet.
1662   stream_generator_->PopPacket(&packet, 1);
1663   EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(packet, &retransmitted));
1664   EXPECT_FALSE(retransmitted);
1665   EXPECT_FALSE(DecodeCompleteFrame());
1666   bool extended = false;
1667   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
1668   uint16_t seq_num;
1669   EXPECT_EQ(1u, nack_list.size());
1670   seq_num = nack_list[0];
1671   stream_generator_->PopPacket(&packet, 0);
1672   EXPECT_EQ(packet.seqNum, seq_num);
1673   EXPECT_EQ(kCompleteSession,
1674             jitter_buffer_->InsertPacket(packet, &retransmitted));
1675   EXPECT_TRUE(retransmitted);
1676   EXPECT_TRUE(DecodeCompleteFrame());
1677 }
1678 
TEST_F(TestJitterBufferNack,UseNackToRecoverFirstKeyFrame)1679 TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrame) {
1680   stream_generator_->Init(0, clock_->TimeInMilliseconds());
1681   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 0,
1682                                    clock_->TimeInMilliseconds());
1683   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1684   // Drop second packet.
1685   EXPECT_EQ(kIncomplete, InsertPacketAndPop(1));
1686   EXPECT_FALSE(DecodeCompleteFrame());
1687   bool extended = false;
1688   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
1689   uint16_t seq_num;
1690   ASSERT_EQ(1u, nack_list.size());
1691   seq_num = nack_list[0];
1692   VCMPacket packet;
1693   stream_generator_->GetPacket(&packet, 0);
1694   EXPECT_EQ(packet.seqNum, seq_num);
1695 }
1696 
TEST_F(TestJitterBufferNack,UseNackToRecoverFirstKeyFrameSecondInQueue)1697 TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrameSecondInQueue) {
1698   VCMPacket packet;
1699   stream_generator_->Init(0, clock_->TimeInMilliseconds());
1700   // First frame is delta.
1701   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 3, 0,
1702                                    clock_->TimeInMilliseconds());
1703   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1704   // Drop second packet in frame.
1705   ASSERT_TRUE(stream_generator_->PopPacket(&packet, 0));
1706   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1707   // Second frame is key.
1708   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 0,
1709                                    clock_->TimeInMilliseconds() + 10);
1710   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1711   // Drop second packet in frame.
1712   EXPECT_EQ(kIncomplete, InsertPacketAndPop(1));
1713   EXPECT_FALSE(DecodeCompleteFrame());
1714   bool extended = false;
1715   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
1716   uint16_t seq_num;
1717   ASSERT_EQ(1u, nack_list.size());
1718   seq_num = nack_list[0];
1719   stream_generator_->GetPacket(&packet, 0);
1720   EXPECT_EQ(packet.seqNum, seq_num);
1721 }
1722 
TEST_F(TestJitterBufferNack,NormalOperation)1723 TEST_F(TestJitterBufferNack, NormalOperation) {
1724   EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError);
1725   EXPECT_TRUE(DecodeCompleteFrame());
1726 
1727   //  ----------------------------------------------------------------
1728   // | 1 | 2 | .. | 8 | 9 | x | 11 | 12 | .. | 19 | x | 21 | .. | 100 |
1729   //  ----------------------------------------------------------------
1730   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 100, 0,
1731                                    clock_->TimeInMilliseconds());
1732   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
1733   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1734   // Verify that the frame is incomplete.
1735   EXPECT_FALSE(DecodeCompleteFrame());
1736   while (stream_generator_->PacketsRemaining() > 1) {
1737     if (stream_generator_->NextSequenceNumber() % 10 != 0) {
1738       EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1739     } else {
1740       stream_generator_->NextPacket(NULL);  // Drop packet
1741     }
1742   }
1743   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1744   EXPECT_EQ(0, stream_generator_->PacketsRemaining());
1745   EXPECT_FALSE(DecodeCompleteFrame());
1746   bool request_key_frame = false;
1747 
1748   // Verify the NACK list.
1749   std::vector<uint16_t> nack_list =
1750       jitter_buffer_->GetNackList(&request_key_frame);
1751   const size_t kExpectedNackSize = 9;
1752   ASSERT_EQ(kExpectedNackSize, nack_list.size());
1753   for (size_t i = 0; i < nack_list.size(); ++i)
1754     EXPECT_EQ((1 + i) * 10, nack_list[i]);
1755 }
1756 
TEST_F(TestJitterBufferNack,NormalOperationWrap)1757 TEST_F(TestJitterBufferNack, NormalOperationWrap) {
1758   bool request_key_frame = false;
1759   //  -------   ------------------------------------------------------------
1760   // | 65532 | | 65533 | 65534 | 65535 | x | 1 | .. | 9 | x | 11 |.....| 96 |
1761   //  -------   ------------------------------------------------------------
1762   stream_generator_->Init(65532, clock_->TimeInMilliseconds());
1763   InsertFrame(VideoFrameType::kVideoFrameKey);
1764   EXPECT_FALSE(request_key_frame);
1765   EXPECT_TRUE(DecodeCompleteFrame());
1766   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 100, 0,
1767                                    clock_->TimeInMilliseconds());
1768   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1769   while (stream_generator_->PacketsRemaining() > 1) {
1770     if (stream_generator_->NextSequenceNumber() % 10 != 0) {
1771       EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1772       EXPECT_FALSE(request_key_frame);
1773     } else {
1774       stream_generator_->NextPacket(NULL);  // Drop packet
1775     }
1776   }
1777   EXPECT_EQ(kIncomplete, InsertPacketAndPop(0));
1778   EXPECT_FALSE(request_key_frame);
1779   EXPECT_EQ(0, stream_generator_->PacketsRemaining());
1780   EXPECT_FALSE(DecodeCompleteFrame());
1781   EXPECT_FALSE(DecodeCompleteFrame());
1782   bool extended = false;
1783   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
1784   // Verify the NACK list.
1785   const size_t kExpectedNackSize = 10;
1786   ASSERT_EQ(kExpectedNackSize, nack_list.size());
1787   for (size_t i = 0; i < nack_list.size(); ++i)
1788     EXPECT_EQ(i * 10, nack_list[i]);
1789 }
1790 
TEST_F(TestJitterBufferNack,NormalOperationWrap2)1791 TEST_F(TestJitterBufferNack, NormalOperationWrap2) {
1792   bool request_key_frame = false;
1793   //  -----------------------------------
1794   // | 65532 | 65533 | 65534 | x | 0 | 1 |
1795   //  -----------------------------------
1796   stream_generator_->Init(65532, clock_->TimeInMilliseconds());
1797   InsertFrame(VideoFrameType::kVideoFrameKey);
1798   EXPECT_FALSE(request_key_frame);
1799   EXPECT_TRUE(DecodeCompleteFrame());
1800   stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 1, 0,
1801                                    clock_->TimeInMilliseconds());
1802   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
1803   for (int i = 0; i < 5; ++i) {
1804     if (stream_generator_->NextSequenceNumber() != 65535) {
1805       EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
1806       EXPECT_FALSE(request_key_frame);
1807     } else {
1808       stream_generator_->NextPacket(NULL);  // Drop packet
1809     }
1810     stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 1, 0,
1811                                      clock_->TimeInMilliseconds());
1812     clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
1813   }
1814   EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0));
1815   EXPECT_FALSE(request_key_frame);
1816   bool extended = false;
1817   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
1818   // Verify the NACK list.
1819   ASSERT_EQ(1u, nack_list.size());
1820   EXPECT_EQ(65535, nack_list[0]);
1821 }
1822 
TEST_F(TestJitterBufferNack,ResetByFutureKeyFrameDoesntError)1823 TEST_F(TestJitterBufferNack, ResetByFutureKeyFrameDoesntError) {
1824   stream_generator_->Init(0, clock_->TimeInMilliseconds());
1825   InsertFrame(VideoFrameType::kVideoFrameKey);
1826   EXPECT_TRUE(DecodeCompleteFrame());
1827   bool extended = false;
1828   std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
1829   EXPECT_EQ(0u, nack_list.size());
1830 
1831   // Far-into-the-future video frame, could be caused by resetting the encoder
1832   // or otherwise restarting. This should not fail when error when the packet is
1833   // a keyframe, even if all of the nack list needs to be flushed.
1834   stream_generator_->Init(10000, clock_->TimeInMilliseconds());
1835   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
1836   InsertFrame(VideoFrameType::kVideoFrameKey);
1837   EXPECT_TRUE(DecodeCompleteFrame());
1838   nack_list = jitter_buffer_->GetNackList(&extended);
1839   EXPECT_EQ(0u, nack_list.size());
1840 
1841   // Stream should be decodable from this point.
1842   clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs);
1843   InsertFrame(VideoFrameType::kVideoFrameDelta);
1844   EXPECT_TRUE(DecodeCompleteFrame());
1845   nack_list = jitter_buffer_->GetNackList(&extended);
1846   EXPECT_EQ(0u, nack_list.size());
1847 }
1848 }  // namespace webrtc
1849