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