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, ¤t_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