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 "modules/video_coding/frame_buffer2.h"
12 
13 #include <algorithm>
14 #include <cstring>
15 #include <limits>
16 #include <memory>
17 #include <vector>
18 
19 #include "modules/video_coding/frame_object.h"
20 #include "modules/video_coding/jitter_estimator.h"
21 #include "modules/video_coding/timing.h"
22 #include "rtc_base/numerics/sequence_number_util.h"
23 #include "rtc_base/platform_thread.h"
24 #include "rtc_base/random.h"
25 #include "system_wrappers/include/clock.h"
26 #include "test/field_trial.h"
27 #include "test/gmock.h"
28 #include "test/gtest.h"
29 #include "test/time_controller/simulated_time_controller.h"
30 
31 using ::testing::_;
32 using ::testing::Return;
33 
34 namespace webrtc {
35 namespace video_coding {
36 
37 class VCMTimingFake : public VCMTiming {
38  public:
VCMTimingFake(Clock * clock)39   explicit VCMTimingFake(Clock* clock) : VCMTiming(clock) {}
40 
RenderTimeMs(uint32_t frame_timestamp,int64_t now_ms) const41   int64_t RenderTimeMs(uint32_t frame_timestamp,
42                        int64_t now_ms) const override {
43     if (last_ms_ == -1) {
44       last_ms_ = now_ms + kDelayMs;
45       last_timestamp_ = frame_timestamp;
46     }
47 
48     uint32_t diff = MinDiff(frame_timestamp, last_timestamp_);
49     if (AheadOf(frame_timestamp, last_timestamp_))
50       last_ms_ += diff / 90;
51     else
52       last_ms_ -= diff / 90;
53 
54     last_timestamp_ = frame_timestamp;
55     return last_ms_;
56   }
57 
MaxWaitingTime(int64_t render_time_ms,int64_t now_ms) const58   int64_t MaxWaitingTime(int64_t render_time_ms,
59                          int64_t now_ms) const override {
60     return render_time_ms - now_ms - kDecodeTime;
61   }
62 
GetTimings(int * max_decode_ms,int * current_delay_ms,int * target_delay_ms,int * jitter_buffer_ms,int * min_playout_delay_ms,int * render_delay_ms) const63   bool GetTimings(int* max_decode_ms,
64                   int* current_delay_ms,
65                   int* target_delay_ms,
66                   int* jitter_buffer_ms,
67                   int* min_playout_delay_ms,
68                   int* render_delay_ms) const override {
69     return true;
70   }
71 
GetCurrentJitter()72   int GetCurrentJitter() {
73     int max_decode_ms;
74     int current_delay_ms;
75     int target_delay_ms;
76     int jitter_buffer_ms;
77     int min_playout_delay_ms;
78     int render_delay_ms;
79     VCMTiming::GetTimings(&max_decode_ms, &current_delay_ms, &target_delay_ms,
80                           &jitter_buffer_ms, &min_playout_delay_ms,
81                           &render_delay_ms);
82     return jitter_buffer_ms;
83   }
84 
85  private:
86   static constexpr int kDelayMs = 50;
87   static constexpr int kDecodeTime = kDelayMs / 2;
88   mutable uint32_t last_timestamp_ = 0;
89   mutable int64_t last_ms_ = -1;
90 };
91 
92 class FrameObjectFake : public EncodedFrame {
93  public:
ReceivedTime() const94   int64_t ReceivedTime() const override { return 0; }
95 
RenderTime() const96   int64_t RenderTime() const override { return _renderTimeMs; }
97 
delayed_by_retransmission() const98   bool delayed_by_retransmission() const override {
99     return delayed_by_retransmission_;
100   }
set_delayed_by_retransmission(bool delayed)101   void set_delayed_by_retransmission(bool delayed) {
102     delayed_by_retransmission_ = delayed;
103   }
104 
105  private:
106   bool delayed_by_retransmission_ = false;
107 };
108 
109 class VCMReceiveStatisticsCallbackMock : public VCMReceiveStatisticsCallback {
110  public:
111   MOCK_METHOD(void,
112               OnCompleteFrame,
113               (bool is_keyframe,
114                size_t size_bytes,
115                VideoContentType content_type),
116               (override));
117   MOCK_METHOD(void, OnDroppedFrames, (uint32_t frames_dropped), (override));
118   MOCK_METHOD(void,
119               OnFrameBufferTimingsUpdated,
120               (int max_decode_ms,
121                int current_delay_ms,
122                int target_delay_ms,
123                int jitter_buffer_ms,
124                int min_playout_delay_ms,
125                int render_delay_ms),
126               (override));
127   MOCK_METHOD(void,
128               OnTimingFrameInfoUpdated,
129               (const TimingFrameInfo& info),
130               (override));
131 };
132 
133 class TestFrameBuffer2 : public ::testing::Test {
134  protected:
135   static constexpr int kMaxReferences = 5;
136   static constexpr int kFps1 = 1000;
137   static constexpr int kFps10 = kFps1 / 10;
138   static constexpr int kFps20 = kFps1 / 20;
139   static constexpr size_t kFrameSize = 10;
140 
TestFrameBuffer2()141   TestFrameBuffer2()
142       : trial_("WebRTC-AddRttToPlayoutDelay/Enabled/"),
143         time_controller_(Timestamp::Seconds(0)),
144         time_task_queue_(
145             time_controller_.GetTaskQueueFactory()->CreateTaskQueue(
146                 "extract queue",
147                 TaskQueueFactory::Priority::NORMAL)),
148         timing_(time_controller_.GetClock()),
149         buffer_(new FrameBuffer(time_controller_.GetClock(),
150                                 &timing_,
151                                 &stats_callback_)),
152         rand_(0x34678213) {}
153 
154   template <typename... T>
CreateFrame(uint16_t picture_id,uint8_t spatial_layer,int64_t ts_ms,bool inter_layer_predicted,bool last_spatial_layer,size_t frame_size_bytes,T...refs)155   std::unique_ptr<FrameObjectFake> CreateFrame(uint16_t picture_id,
156                                                uint8_t spatial_layer,
157                                                int64_t ts_ms,
158                                                bool inter_layer_predicted,
159                                                bool last_spatial_layer,
160                                                size_t frame_size_bytes,
161                                                T... refs) {
162     static_assert(sizeof...(refs) <= kMaxReferences,
163                   "To many references specified for EncodedFrame.");
164     std::array<uint16_t, sizeof...(refs)> references = {
165         {rtc::checked_cast<uint16_t>(refs)...}};
166 
167     auto frame = std::make_unique<FrameObjectFake>();
168     frame->id.picture_id = picture_id;
169     frame->id.spatial_layer = spatial_layer;
170     frame->SetSpatialIndex(spatial_layer);
171     frame->SetTimestamp(ts_ms * 90);
172     frame->num_references = references.size();
173     frame->inter_layer_predicted = inter_layer_predicted;
174     frame->is_last_spatial_layer = last_spatial_layer;
175     // Add some data to buffer.
176     frame->SetEncodedData(EncodedImageBuffer::Create(frame_size_bytes));
177     for (size_t r = 0; r < references.size(); ++r)
178       frame->references[r] = references[r];
179     return frame;
180   }
181 
182   template <typename... T>
InsertFrame(uint16_t picture_id,uint8_t spatial_layer,int64_t ts_ms,bool inter_layer_predicted,bool last_spatial_layer,size_t frame_size_bytes,T...refs)183   int InsertFrame(uint16_t picture_id,
184                   uint8_t spatial_layer,
185                   int64_t ts_ms,
186                   bool inter_layer_predicted,
187                   bool last_spatial_layer,
188                   size_t frame_size_bytes,
189                   T... refs) {
190     return buffer_->InsertFrame(
191         CreateFrame(picture_id, spatial_layer, ts_ms, inter_layer_predicted,
192                     last_spatial_layer, frame_size_bytes, refs...));
193   }
194 
InsertNackedFrame(uint16_t picture_id,int64_t ts_ms)195   int InsertNackedFrame(uint16_t picture_id, int64_t ts_ms) {
196     std::unique_ptr<FrameObjectFake> frame =
197         CreateFrame(picture_id, 0, ts_ms, false, true, kFrameSize);
198     frame->set_delayed_by_retransmission(true);
199     return buffer_->InsertFrame(std::move(frame));
200   }
201 
ExtractFrame(int64_t max_wait_time=0,bool keyframe_required=false)202   void ExtractFrame(int64_t max_wait_time = 0, bool keyframe_required = false) {
203     time_task_queue_.PostTask([this, max_wait_time, keyframe_required]() {
204       buffer_->NextFrame(
205           max_wait_time, keyframe_required, &time_task_queue_,
206           [this](std::unique_ptr<video_coding::EncodedFrame> frame,
207                  video_coding::FrameBuffer::ReturnReason reason) {
208             if (reason != FrameBuffer::ReturnReason::kStopped) {
209               frames_.emplace_back(std::move(frame));
210             }
211           });
212     });
213     if (max_wait_time == 0) {
214       time_controller_.AdvanceTime(TimeDelta::Millis(0));
215     }
216   }
217 
CheckFrame(size_t index,int picture_id,int spatial_layer)218   void CheckFrame(size_t index, int picture_id, int spatial_layer) {
219     ASSERT_LT(index, frames_.size());
220     ASSERT_TRUE(frames_[index]);
221     ASSERT_EQ(picture_id, frames_[index]->id.picture_id);
222     ASSERT_EQ(spatial_layer, frames_[index]->id.spatial_layer);
223   }
224 
CheckFrameSize(size_t index,size_t size)225   void CheckFrameSize(size_t index, size_t size) {
226     ASSERT_LT(index, frames_.size());
227     ASSERT_TRUE(frames_[index]);
228     ASSERT_EQ(frames_[index]->size(), size);
229   }
230 
CheckNoFrame(size_t index)231   void CheckNoFrame(size_t index) {
232     ASSERT_LT(index, frames_.size());
233     ASSERT_FALSE(frames_[index]);
234   }
235 
Rand()236   uint32_t Rand() { return rand_.Rand<uint32_t>(); }
237 
238   // The ProtectionMode tests depends on rtt-multiplier experiment.
239   test::ScopedFieldTrials trial_;
240   webrtc::GlobalSimulatedTimeController time_controller_;
241   rtc::TaskQueue time_task_queue_;
242   VCMTimingFake timing_;
243   std::unique_ptr<FrameBuffer> buffer_;
244   std::vector<std::unique_ptr<EncodedFrame>> frames_;
245   Random rand_;
246   ::testing::NiceMock<VCMReceiveStatisticsCallbackMock> stats_callback_;
247 };
248 
249 // From https://en.cppreference.com/w/cpp/language/static: "If ... a constexpr
250 // static data member (since C++11) is odr-used, a definition at namespace scope
251 // is still required... This definition is deprecated for constexpr data members
252 // since C++17."
253 // kFrameSize is odr-used since it is passed by reference to EXPECT_EQ().
254 #if __cplusplus < 201703L
255 constexpr size_t TestFrameBuffer2::kFrameSize;
256 #endif
257 
TEST_F(TestFrameBuffer2,WaitForFrame)258 TEST_F(TestFrameBuffer2, WaitForFrame) {
259   uint16_t pid = Rand();
260   uint32_t ts = Rand();
261 
262   ExtractFrame(50);
263   InsertFrame(pid, 0, ts, false, true, kFrameSize);
264   time_controller_.AdvanceTime(TimeDelta::Millis(50));
265   CheckFrame(0, pid, 0);
266 }
267 
TEST_F(TestFrameBuffer2,OneSuperFrame)268 TEST_F(TestFrameBuffer2, OneSuperFrame) {
269   uint16_t pid = Rand();
270   uint32_t ts = Rand();
271 
272   InsertFrame(pid, 0, ts, false, false, kFrameSize);
273   InsertFrame(pid, 1, ts, true, true, kFrameSize);
274   ExtractFrame();
275 
276   CheckFrame(0, pid, 1);
277 }
278 
TEST_F(TestFrameBuffer2,ZeroPlayoutDelay)279 TEST_F(TestFrameBuffer2, ZeroPlayoutDelay) {
280   VCMTiming timing(time_controller_.GetClock());
281   buffer_.reset(
282       new FrameBuffer(time_controller_.GetClock(), &timing, &stats_callback_));
283   const PlayoutDelay kPlayoutDelayMs = {0, 0};
284   std::unique_ptr<FrameObjectFake> test_frame(new FrameObjectFake());
285   test_frame->id.picture_id = 0;
286   test_frame->SetPlayoutDelay(kPlayoutDelayMs);
287   buffer_->InsertFrame(std::move(test_frame));
288   ExtractFrame(0, false);
289   CheckFrame(0, 0, 0);
290   EXPECT_EQ(0, frames_[0]->RenderTimeMs());
291 }
292 
293 // Flaky test, see bugs.webrtc.org/7068.
TEST_F(TestFrameBuffer2,DISABLED_OneUnorderedSuperFrame)294 TEST_F(TestFrameBuffer2, DISABLED_OneUnorderedSuperFrame) {
295   uint16_t pid = Rand();
296   uint32_t ts = Rand();
297 
298   ExtractFrame(50);
299   InsertFrame(pid, 1, ts, true, true, kFrameSize);
300   InsertFrame(pid, 0, ts, false, false, kFrameSize);
301   time_controller_.AdvanceTime(TimeDelta::Millis(0));
302 
303   CheckFrame(0, pid, 0);
304   CheckFrame(1, pid, 1);
305 }
306 
TEST_F(TestFrameBuffer2,DISABLED_OneLayerStreamReordered)307 TEST_F(TestFrameBuffer2, DISABLED_OneLayerStreamReordered) {
308   uint16_t pid = Rand();
309   uint32_t ts = Rand();
310 
311   InsertFrame(pid, 0, ts, false, true, kFrameSize);
312   ExtractFrame();
313   CheckFrame(0, pid, 0);
314   for (int i = 1; i < 10; i += 2) {
315     ExtractFrame(50);
316     InsertFrame(pid + i + 1, 0, ts + (i + 1) * kFps10, false, true, kFrameSize,
317                 pid + i);
318     time_controller_.AdvanceTime(TimeDelta::Millis(kFps10));
319     InsertFrame(pid + i, 0, ts + i * kFps10, false, true, kFrameSize,
320                 pid + i - 1);
321     time_controller_.AdvanceTime(TimeDelta::Millis(kFps10));
322     ExtractFrame();
323     CheckFrame(i, pid + i, 0);
324     CheckFrame(i + 1, pid + i + 1, 0);
325   }
326 }
327 
TEST_F(TestFrameBuffer2,ExtractFromEmptyBuffer)328 TEST_F(TestFrameBuffer2, ExtractFromEmptyBuffer) {
329   ExtractFrame();
330   CheckNoFrame(0);
331 }
332 
TEST_F(TestFrameBuffer2,MissingFrame)333 TEST_F(TestFrameBuffer2, MissingFrame) {
334   uint16_t pid = Rand();
335   uint32_t ts = Rand();
336 
337   InsertFrame(pid, 0, ts, false, true, kFrameSize);
338   InsertFrame(pid + 2, 0, ts, false, true, kFrameSize, pid);
339   InsertFrame(pid + 3, 0, ts, false, true, kFrameSize, pid + 1, pid + 2);
340   ExtractFrame();
341   ExtractFrame();
342   ExtractFrame();
343 
344   CheckFrame(0, pid, 0);
345   CheckFrame(1, pid + 2, 0);
346   CheckNoFrame(2);
347 }
348 
TEST_F(TestFrameBuffer2,OneLayerStream)349 TEST_F(TestFrameBuffer2, OneLayerStream) {
350   uint16_t pid = Rand();
351   uint32_t ts = Rand();
352 
353   InsertFrame(pid, 0, ts, false, true, kFrameSize);
354   ExtractFrame();
355   CheckFrame(0, pid, 0);
356   for (int i = 1; i < 10; ++i) {
357     InsertFrame(pid + i, 0, ts + i * kFps10, false, true, kFrameSize,
358                 pid + i - 1);
359     ExtractFrame();
360     time_controller_.AdvanceTime(TimeDelta::Millis(kFps10));
361     CheckFrame(i, pid + i, 0);
362   }
363 }
364 
TEST_F(TestFrameBuffer2,DropTemporalLayerSlowDecoder)365 TEST_F(TestFrameBuffer2, DropTemporalLayerSlowDecoder) {
366   uint16_t pid = Rand();
367   uint32_t ts = Rand();
368 
369   InsertFrame(pid, 0, ts, false, true, kFrameSize);
370   InsertFrame(pid + 1, 0, ts + kFps20, false, true, kFrameSize, pid);
371   for (int i = 2; i < 10; i += 2) {
372     uint32_t ts_tl0 = ts + i / 2 * kFps10;
373     InsertFrame(pid + i, 0, ts_tl0, false, true, kFrameSize, pid + i - 2);
374     InsertFrame(pid + i + 1, 0, ts_tl0 + kFps20, false, true, kFrameSize,
375                 pid + i, pid + i - 1);
376   }
377 
378   EXPECT_CALL(stats_callback_, OnDroppedFrames(1)).Times(3);
379 
380   for (int i = 0; i < 10; ++i) {
381     ExtractFrame();
382     time_controller_.AdvanceTime(TimeDelta::Millis(70));
383   }
384 
385   CheckFrame(0, pid, 0);
386   CheckFrame(1, pid + 1, 0);
387   CheckFrame(2, pid + 2, 0);
388   CheckFrame(3, pid + 4, 0);
389   CheckFrame(4, pid + 6, 0);
390   CheckFrame(5, pid + 8, 0);
391   CheckNoFrame(6);
392   CheckNoFrame(7);
393   CheckNoFrame(8);
394   CheckNoFrame(9);
395 }
396 
TEST_F(TestFrameBuffer2,DropFramesIfSystemIsStalled)397 TEST_F(TestFrameBuffer2, DropFramesIfSystemIsStalled) {
398   uint16_t pid = Rand();
399   uint32_t ts = Rand();
400 
401   InsertFrame(pid, 0, ts, false, true, kFrameSize);
402   InsertFrame(pid + 1, 0, ts + 1 * kFps10, false, true, kFrameSize, pid);
403   InsertFrame(pid + 2, 0, ts + 2 * kFps10, false, true, kFrameSize, pid + 1);
404   InsertFrame(pid + 3, 0, ts + 3 * kFps10, false, true, kFrameSize);
405 
406   ExtractFrame();
407   // Jump forward in time, simulating the system being stalled for some reason.
408   time_controller_.AdvanceTime(TimeDelta::Millis(3) * kFps10);
409   // Extract one more frame, expect second and third frame to be dropped.
410   EXPECT_CALL(stats_callback_, OnDroppedFrames(2)).Times(1);
411   ExtractFrame();
412 
413   CheckFrame(0, pid + 0, 0);
414   CheckFrame(1, pid + 3, 0);
415 }
416 
TEST_F(TestFrameBuffer2,DroppedFramesCountedOnClear)417 TEST_F(TestFrameBuffer2, DroppedFramesCountedOnClear) {
418   uint16_t pid = Rand();
419   uint32_t ts = Rand();
420 
421   InsertFrame(pid, 0, ts, false, true, kFrameSize);
422   for (int i = 1; i < 5; ++i) {
423     InsertFrame(pid + i, 0, ts + i * kFps10, false, true, kFrameSize,
424                 pid + i - 1);
425   }
426 
427   // All frames should be dropped when Clear is called.
428   EXPECT_CALL(stats_callback_, OnDroppedFrames(5)).Times(1);
429   buffer_->Clear();
430 }
431 
TEST_F(TestFrameBuffer2,InsertLateFrame)432 TEST_F(TestFrameBuffer2, InsertLateFrame) {
433   uint16_t pid = Rand();
434   uint32_t ts = Rand();
435 
436   InsertFrame(pid, 0, ts, false, true, kFrameSize);
437   ExtractFrame();
438   InsertFrame(pid + 2, 0, ts, false, true, kFrameSize);
439   ExtractFrame();
440   InsertFrame(pid + 1, 0, ts, false, true, kFrameSize, pid);
441   ExtractFrame();
442 
443   CheckFrame(0, pid, 0);
444   CheckFrame(1, pid + 2, 0);
445   CheckNoFrame(2);
446 }
447 
TEST_F(TestFrameBuffer2,ProtectionModeNackFEC)448 TEST_F(TestFrameBuffer2, ProtectionModeNackFEC) {
449   uint16_t pid = Rand();
450   uint32_t ts = Rand();
451   constexpr int64_t kRttMs = 200;
452   buffer_->UpdateRtt(kRttMs);
453 
454   // Jitter estimate unaffected by RTT in this protection mode.
455   buffer_->SetProtectionMode(kProtectionNackFEC);
456   InsertNackedFrame(pid, ts);
457   InsertNackedFrame(pid + 1, ts + 100);
458   InsertNackedFrame(pid + 2, ts + 200);
459   InsertFrame(pid + 3, 0, ts + 300, false, true, kFrameSize);
460   ExtractFrame();
461   ExtractFrame();
462   ExtractFrame();
463   ExtractFrame();
464   ASSERT_EQ(4u, frames_.size());
465   EXPECT_LT(timing_.GetCurrentJitter(), kRttMs);
466 }
467 
TEST_F(TestFrameBuffer2,ProtectionModeNack)468 TEST_F(TestFrameBuffer2, ProtectionModeNack) {
469   uint16_t pid = Rand();
470   uint32_t ts = Rand();
471   constexpr int64_t kRttMs = 200;
472 
473   buffer_->UpdateRtt(kRttMs);
474 
475   // Jitter estimate includes RTT (after 3 retransmitted packets)
476   buffer_->SetProtectionMode(kProtectionNack);
477   InsertNackedFrame(pid, ts);
478   InsertNackedFrame(pid + 1, ts + 100);
479   InsertNackedFrame(pid + 2, ts + 200);
480   InsertFrame(pid + 3, 0, ts + 300, false, true, kFrameSize);
481   ExtractFrame();
482   ExtractFrame();
483   ExtractFrame();
484   ExtractFrame();
485   ASSERT_EQ(4u, frames_.size());
486 
487   EXPECT_GT(timing_.GetCurrentJitter(), kRttMs);
488 }
489 
TEST_F(TestFrameBuffer2,NoContinuousFrame)490 TEST_F(TestFrameBuffer2, NoContinuousFrame) {
491   uint16_t pid = Rand();
492   uint32_t ts = Rand();
493 
494   EXPECT_EQ(-1, InsertFrame(pid + 1, 0, ts, false, true, kFrameSize, pid));
495 }
496 
TEST_F(TestFrameBuffer2,LastContinuousFrameSingleLayer)497 TEST_F(TestFrameBuffer2, LastContinuousFrameSingleLayer) {
498   uint16_t pid = Rand();
499   uint32_t ts = Rand();
500 
501   EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, true, kFrameSize));
502   EXPECT_EQ(pid, InsertFrame(pid + 2, 0, ts, false, true, kFrameSize, pid + 1));
503   EXPECT_EQ(pid + 2, InsertFrame(pid + 1, 0, ts, false, true, kFrameSize, pid));
504   EXPECT_EQ(pid + 2,
505             InsertFrame(pid + 4, 0, ts, false, true, kFrameSize, pid + 3));
506   EXPECT_EQ(pid + 5, InsertFrame(pid + 5, 0, ts, false, true, kFrameSize));
507 }
508 
TEST_F(TestFrameBuffer2,LastContinuousFrameTwoLayers)509 TEST_F(TestFrameBuffer2, LastContinuousFrameTwoLayers) {
510   uint16_t pid = Rand();
511   uint32_t ts = Rand();
512 
513   EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, false, kFrameSize));
514   EXPECT_EQ(pid, InsertFrame(pid, 1, ts, true, true, kFrameSize));
515   EXPECT_EQ(pid, InsertFrame(pid + 1, 1, ts, true, true, kFrameSize, pid));
516   EXPECT_EQ(pid,
517             InsertFrame(pid + 2, 0, ts, false, false, kFrameSize, pid + 1));
518   EXPECT_EQ(pid, InsertFrame(pid + 2, 1, ts, true, true, kFrameSize, pid + 1));
519   EXPECT_EQ(pid,
520             InsertFrame(pid + 3, 0, ts, false, false, kFrameSize, pid + 2));
521   EXPECT_EQ(pid + 3,
522             InsertFrame(pid + 1, 0, ts, false, false, kFrameSize, pid));
523   EXPECT_EQ(pid + 3,
524             InsertFrame(pid + 3, 1, ts, true, true, kFrameSize, pid + 2));
525 }
526 
TEST_F(TestFrameBuffer2,PictureIdJumpBack)527 TEST_F(TestFrameBuffer2, PictureIdJumpBack) {
528   uint16_t pid = Rand();
529   uint32_t ts = Rand();
530 
531   EXPECT_EQ(pid, InsertFrame(pid, 0, ts, false, true, kFrameSize));
532   EXPECT_EQ(pid + 1,
533             InsertFrame(pid + 1, 0, ts + 1, false, true, kFrameSize, pid));
534   ExtractFrame();
535   CheckFrame(0, pid, 0);
536 
537   // Jump back in pid but increase ts.
538   EXPECT_EQ(pid - 1, InsertFrame(pid - 1, 0, ts + 2, false, true, kFrameSize));
539   ExtractFrame();
540   ExtractFrame();
541   CheckFrame(1, pid - 1, 0);
542   CheckNoFrame(2);
543 }
544 
TEST_F(TestFrameBuffer2,StatsCallback)545 TEST_F(TestFrameBuffer2, StatsCallback) {
546   uint16_t pid = Rand();
547   uint32_t ts = Rand();
548   const int kFrameSize = 5000;
549 
550   EXPECT_CALL(stats_callback_,
551               OnCompleteFrame(true, kFrameSize, VideoContentType::UNSPECIFIED));
552   EXPECT_CALL(stats_callback_, OnFrameBufferTimingsUpdated(_, _, _, _, _, _));
553 
554   {
555     std::unique_ptr<FrameObjectFake> frame(new FrameObjectFake());
556     frame->SetEncodedData(EncodedImageBuffer::Create(kFrameSize));
557     frame->id.picture_id = pid;
558     frame->id.spatial_layer = 0;
559     frame->SetTimestamp(ts);
560     frame->num_references = 0;
561     frame->inter_layer_predicted = false;
562 
563     EXPECT_EQ(buffer_->InsertFrame(std::move(frame)), pid);
564   }
565 
566   ExtractFrame();
567   CheckFrame(0, pid, 0);
568 }
569 
TEST_F(TestFrameBuffer2,ForwardJumps)570 TEST_F(TestFrameBuffer2, ForwardJumps) {
571   EXPECT_EQ(5453, InsertFrame(5453, 0, 1, false, true, kFrameSize));
572   ExtractFrame();
573   EXPECT_EQ(5454, InsertFrame(5454, 0, 1, false, true, kFrameSize, 5453));
574   ExtractFrame();
575   EXPECT_EQ(15670, InsertFrame(15670, 0, 1, false, true, kFrameSize));
576   ExtractFrame();
577   EXPECT_EQ(29804, InsertFrame(29804, 0, 1, false, true, kFrameSize));
578   ExtractFrame();
579   EXPECT_EQ(29805, InsertFrame(29805, 0, 1, false, true, kFrameSize, 29804));
580   ExtractFrame();
581   EXPECT_EQ(29806, InsertFrame(29806, 0, 1, false, true, kFrameSize, 29805));
582   ExtractFrame();
583   EXPECT_EQ(33819, InsertFrame(33819, 0, 1, false, true, kFrameSize));
584   ExtractFrame();
585   EXPECT_EQ(41248, InsertFrame(41248, 0, 1, false, true, kFrameSize));
586   ExtractFrame();
587 }
588 
TEST_F(TestFrameBuffer2,DuplicateFrames)589 TEST_F(TestFrameBuffer2, DuplicateFrames) {
590   EXPECT_EQ(22256, InsertFrame(22256, 0, 1, false, true, kFrameSize));
591   ExtractFrame();
592   EXPECT_EQ(22256, InsertFrame(22256, 0, 1, false, true, kFrameSize));
593 }
594 
595 // TODO(philipel): implement more unittests related to invalid references.
TEST_F(TestFrameBuffer2,InvalidReferences)596 TEST_F(TestFrameBuffer2, InvalidReferences) {
597   EXPECT_EQ(-1, InsertFrame(0, 0, 1000, false, true, kFrameSize, 2));
598   EXPECT_EQ(1, InsertFrame(1, 0, 2000, false, true, kFrameSize));
599   ExtractFrame();
600   EXPECT_EQ(2, InsertFrame(2, 0, 3000, false, true, kFrameSize, 1));
601 }
602 
TEST_F(TestFrameBuffer2,KeyframeRequired)603 TEST_F(TestFrameBuffer2, KeyframeRequired) {
604   EXPECT_EQ(1, InsertFrame(1, 0, 1000, false, true, kFrameSize));
605   EXPECT_EQ(2, InsertFrame(2, 0, 2000, false, true, kFrameSize, 1));
606   EXPECT_EQ(3, InsertFrame(3, 0, 3000, false, true, kFrameSize));
607   ExtractFrame();
608   ExtractFrame(0, true);
609   ExtractFrame();
610 
611   CheckFrame(0, 1, 0);
612   CheckFrame(1, 3, 0);
613   CheckNoFrame(2);
614 }
615 
TEST_F(TestFrameBuffer2,KeyframeClearsFullBuffer)616 TEST_F(TestFrameBuffer2, KeyframeClearsFullBuffer) {
617   const int kMaxBufferSize = 600;
618 
619   for (int i = 1; i <= kMaxBufferSize; ++i)
620     EXPECT_EQ(-1, InsertFrame(i, 0, i * 1000, false, true, kFrameSize, i - 1));
621   ExtractFrame();
622   CheckNoFrame(0);
623 
624   EXPECT_EQ(kMaxBufferSize + 1,
625             InsertFrame(kMaxBufferSize + 1, 0, (kMaxBufferSize + 1) * 1000,
626                         false, true, kFrameSize));
627   ExtractFrame();
628   CheckFrame(1, kMaxBufferSize + 1, 0);
629 }
630 
TEST_F(TestFrameBuffer2,DontUpdateOnUndecodableFrame)631 TEST_F(TestFrameBuffer2, DontUpdateOnUndecodableFrame) {
632   InsertFrame(1, 0, 0, false, true, kFrameSize);
633   ExtractFrame(0, true);
634   InsertFrame(3, 0, 0, false, true, kFrameSize, 2, 0);
635   InsertFrame(3, 0, 0, false, true, kFrameSize, 0);
636   InsertFrame(2, 0, 0, false, true, kFrameSize);
637   ExtractFrame(0, true);
638   ExtractFrame(0, true);
639 }
640 
TEST_F(TestFrameBuffer2,DontDecodeOlderTimestamp)641 TEST_F(TestFrameBuffer2, DontDecodeOlderTimestamp) {
642   InsertFrame(2, 0, 1, false, true, kFrameSize);
643   InsertFrame(1, 0, 2, false, true,
644               kFrameSize);  // Older picture id but newer timestamp.
645   ExtractFrame(0);
646   ExtractFrame(0);
647   CheckFrame(0, 1, 0);
648   CheckNoFrame(1);
649 
650   InsertFrame(3, 0, 4, false, true, kFrameSize);
651   InsertFrame(4, 0, 3, false, true,
652               kFrameSize);  // Newer picture id but older timestamp.
653   ExtractFrame(0);
654   ExtractFrame(0);
655   CheckFrame(2, 3, 0);
656   CheckNoFrame(3);
657 }
658 
TEST_F(TestFrameBuffer2,CombineFramesToSuperframe)659 TEST_F(TestFrameBuffer2, CombineFramesToSuperframe) {
660   uint16_t pid = Rand();
661   uint32_t ts = Rand();
662 
663   InsertFrame(pid, 0, ts, false, false, kFrameSize);
664   InsertFrame(pid, 1, ts, true, true, 2 * kFrameSize);
665   ExtractFrame(0);
666   ExtractFrame(0);
667   CheckFrame(0, pid, 1);
668   CheckNoFrame(1);
669   // Two frames should be combined and returned together.
670   CheckFrameSize(0, 3 * kFrameSize);
671 
672   EXPECT_EQ(frames_[0]->SpatialIndex(), 1);
673   EXPECT_EQ(frames_[0]->SpatialLayerFrameSize(0), kFrameSize);
674   EXPECT_EQ(frames_[0]->SpatialLayerFrameSize(1), 2 * kFrameSize);
675 }
676 
TEST_F(TestFrameBuffer2,HigherSpatialLayerNonDecodable)677 TEST_F(TestFrameBuffer2, HigherSpatialLayerNonDecodable) {
678   uint16_t pid = Rand();
679   uint32_t ts = Rand();
680 
681   InsertFrame(pid, 0, ts, false, false, kFrameSize);
682   InsertFrame(pid, 1, ts, true, true, kFrameSize);
683 
684   ExtractFrame(0);
685   CheckFrame(0, pid, 1);
686 
687   InsertFrame(pid + 1, 1, ts + kFps20, false, true, kFrameSize, pid);
688   InsertFrame(pid + 2, 0, ts + kFps10, false, false, kFrameSize, pid);
689   InsertFrame(pid + 2, 1, ts + kFps10, true, true, kFrameSize, pid + 1);
690 
691   time_controller_.AdvanceTime(TimeDelta::Millis(1000));
692   // Frame pid+1 is decodable but too late.
693   // In superframe pid+2 frame sid=0 is decodable, but frame sid=1 is not.
694   // Incorrect implementation might skip pid+1 frame and output undecodable
695   // pid+2 instead.
696   ExtractFrame();
697   ExtractFrame();
698   CheckFrame(1, pid + 1, 1);
699   CheckFrame(2, pid + 2, 1);
700 }
701 
702 }  // namespace video_coding
703 }  // namespace webrtc
704