1 /*
2 * Copyright 2017 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 "video/video_receive_stream.h"
12
13 #include <algorithm>
14 #include <memory>
15 #include <utility>
16 #include <vector>
17
18 #include "api/task_queue/default_task_queue_factory.h"
19 #include "api/test/video/function_video_decoder_factory.h"
20 #include "api/video_codecs/video_decoder.h"
21 #include "call/rtp_stream_receiver_controller.h"
22 #include "common_video/test/utilities.h"
23 #include "media/base/fake_video_renderer.h"
24 #include "modules/pacing/packet_router.h"
25 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
26 #include "modules/utility/include/process_thread.h"
27 #include "modules/video_coding/encoded_frame.h"
28 #include "rtc_base/event.h"
29 #include "system_wrappers/include/clock.h"
30 #include "test/fake_decoder.h"
31 #include "test/field_trial.h"
32 #include "test/gmock.h"
33 #include "test/gtest.h"
34 #include "test/time_controller/simulated_time_controller.h"
35 #include "test/video_decoder_proxy_factory.h"
36 #include "video/call_stats.h"
37
38 namespace webrtc {
39 namespace {
40
41 using ::testing::_;
42 using ::testing::ElementsAreArray;
43 using ::testing::Invoke;
44 using ::testing::IsEmpty;
45 using ::testing::SizeIs;
46
47 constexpr int kDefaultTimeOutMs = 50;
48
49 class MockTransport : public Transport {
50 public:
51 MOCK_METHOD(bool,
52 SendRtp,
53 (const uint8_t*, size_t length, const PacketOptions& options),
54 (override));
55 MOCK_METHOD(bool, SendRtcp, (const uint8_t*, size_t length), (override));
56 };
57
58 class MockVideoDecoder : public VideoDecoder {
59 public:
60 MOCK_METHOD(int32_t,
61 InitDecode,
62 (const VideoCodec*, int32_t number_of_cores),
63 (override));
64 MOCK_METHOD(int32_t,
65 Decode,
66 (const EncodedImage& input,
67 bool missing_frames,
68 int64_t render_time_ms),
69 (override));
70 MOCK_METHOD(int32_t,
71 RegisterDecodeCompleteCallback,
72 (DecodedImageCallback*),
73 (override));
74 MOCK_METHOD(int32_t, Release, (), (override));
ImplementationName() const75 const char* ImplementationName() const { return "MockVideoDecoder"; }
76 };
77
78 class FrameObjectFake : public video_coding::EncodedFrame {
79 public:
SetPayloadType(uint8_t payload_type)80 void SetPayloadType(uint8_t payload_type) { _payloadType = payload_type; }
81
SetRotation(const VideoRotation & rotation)82 void SetRotation(const VideoRotation& rotation) { rotation_ = rotation; }
83
SetNtpTime(int64_t ntp_time_ms)84 void SetNtpTime(int64_t ntp_time_ms) { ntp_time_ms_ = ntp_time_ms; }
85
ReceivedTime() const86 int64_t ReceivedTime() const override { return 0; }
87
RenderTime() const88 int64_t RenderTime() const override { return _renderTimeMs; }
89 };
90
91 } // namespace
92
93 class VideoReceiveStreamTest : public ::testing::Test {
94 public:
VideoReceiveStreamTest()95 VideoReceiveStreamTest()
96 : process_thread_(ProcessThread::Create("TestThread")),
97 task_queue_factory_(CreateDefaultTaskQueueFactory()),
98 config_(&mock_transport_),
99 call_stats_(Clock::GetRealTimeClock(), process_thread_.get()),
100 h264_decoder_factory_(&mock_h264_video_decoder_) {}
101
SetUp()102 void SetUp() {
103 constexpr int kDefaultNumCpuCores = 2;
104 config_.rtp.remote_ssrc = 1111;
105 config_.rtp.local_ssrc = 2222;
106 config_.renderer = &fake_renderer_;
107 config_.decoder_factory = &h264_decoder_factory_;
108 VideoReceiveStream::Decoder h264_decoder;
109 h264_decoder.payload_type = 99;
110 h264_decoder.video_format = SdpVideoFormat("H264");
111 h264_decoder.video_format.parameters.insert(
112 {"sprop-parameter-sets", "Z0IACpZTBYmI,aMljiA=="});
113 config_.decoders.push_back(h264_decoder);
114
115 clock_ = Clock::GetRealTimeClock();
116 timing_ = new VCMTiming(clock_);
117
118 video_receive_stream_ =
119 std::make_unique<webrtc::internal::VideoReceiveStream>(
120 task_queue_factory_.get(), &rtp_stream_receiver_controller_,
121 kDefaultNumCpuCores, &packet_router_, config_.Copy(),
122 process_thread_.get(), &call_stats_, clock_, timing_);
123 }
124
125 protected:
126 std::unique_ptr<ProcessThread> process_thread_;
127 const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
128 VideoReceiveStream::Config config_;
129 CallStats call_stats_;
130 MockVideoDecoder mock_h264_video_decoder_;
131 test::VideoDecoderProxyFactory h264_decoder_factory_;
132 cricket::FakeVideoRenderer fake_renderer_;
133 MockTransport mock_transport_;
134 PacketRouter packet_router_;
135 RtpStreamReceiverController rtp_stream_receiver_controller_;
136 std::unique_ptr<webrtc::internal::VideoReceiveStream> video_receive_stream_;
137 Clock* clock_;
138 VCMTiming* timing_;
139 };
140
TEST_F(VideoReceiveStreamTest,CreateFrameFromH264FmtpSpropAndIdr)141 TEST_F(VideoReceiveStreamTest, CreateFrameFromH264FmtpSpropAndIdr) {
142 constexpr uint8_t idr_nalu[] = {0x05, 0xFF, 0xFF, 0xFF};
143 RtpPacketToSend rtppacket(nullptr);
144 uint8_t* payload = rtppacket.AllocatePayload(sizeof(idr_nalu));
145 memcpy(payload, idr_nalu, sizeof(idr_nalu));
146 rtppacket.SetMarker(true);
147 rtppacket.SetSsrc(1111);
148 rtppacket.SetPayloadType(99);
149 rtppacket.SetSequenceNumber(1);
150 rtppacket.SetTimestamp(0);
151 rtc::Event init_decode_event_;
152 EXPECT_CALL(mock_h264_video_decoder_, InitDecode(_, _))
153 .WillOnce(Invoke([&init_decode_event_](const VideoCodec* config,
154 int32_t number_of_cores) {
155 init_decode_event_.Set();
156 return 0;
157 }));
158 EXPECT_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback(_));
159 video_receive_stream_->Start();
160 EXPECT_CALL(mock_h264_video_decoder_, Decode(_, false, _));
161 RtpPacketReceived parsed_packet;
162 ASSERT_TRUE(parsed_packet.Parse(rtppacket.data(), rtppacket.size()));
163 rtp_stream_receiver_controller_.OnRtpPacket(parsed_packet);
164 EXPECT_CALL(mock_h264_video_decoder_, Release());
165 // Make sure the decoder thread had a chance to run.
166 init_decode_event_.Wait(kDefaultTimeOutMs);
167 }
168
TEST_F(VideoReceiveStreamTest,PlayoutDelay)169 TEST_F(VideoReceiveStreamTest, PlayoutDelay) {
170 const VideoPlayoutDelay kPlayoutDelayMs = {123, 321};
171 std::unique_ptr<FrameObjectFake> test_frame(new FrameObjectFake());
172 test_frame->id.picture_id = 0;
173 test_frame->SetPlayoutDelay(kPlayoutDelayMs);
174
175 video_receive_stream_->OnCompleteFrame(std::move(test_frame));
176 EXPECT_EQ(kPlayoutDelayMs.min_ms, timing_->min_playout_delay());
177 EXPECT_EQ(kPlayoutDelayMs.max_ms, timing_->max_playout_delay());
178
179 // Check that the biggest minimum delay is chosen.
180 video_receive_stream_->SetMinimumPlayoutDelay(400);
181 EXPECT_EQ(400, timing_->min_playout_delay());
182
183 // Check base minimum delay validation.
184 EXPECT_FALSE(video_receive_stream_->SetBaseMinimumPlayoutDelayMs(12345));
185 EXPECT_FALSE(video_receive_stream_->SetBaseMinimumPlayoutDelayMs(-1));
186 EXPECT_TRUE(video_receive_stream_->SetBaseMinimumPlayoutDelayMs(500));
187 EXPECT_EQ(500, timing_->min_playout_delay());
188
189 // Check that intermidiate values are remembered and the biggest remembered
190 // is chosen.
191 video_receive_stream_->SetBaseMinimumPlayoutDelayMs(0);
192 EXPECT_EQ(400, timing_->min_playout_delay());
193
194 video_receive_stream_->SetMinimumPlayoutDelay(0);
195 EXPECT_EQ(123, timing_->min_playout_delay());
196 }
197
TEST_F(VideoReceiveStreamTest,PlayoutDelayPreservesDefaultMaxValue)198 TEST_F(VideoReceiveStreamTest, PlayoutDelayPreservesDefaultMaxValue) {
199 const int default_max_playout_latency = timing_->max_playout_delay();
200 const VideoPlayoutDelay kPlayoutDelayMs = {123, -1};
201
202 std::unique_ptr<FrameObjectFake> test_frame(new FrameObjectFake());
203 test_frame->id.picture_id = 0;
204 test_frame->SetPlayoutDelay(kPlayoutDelayMs);
205
206 video_receive_stream_->OnCompleteFrame(std::move(test_frame));
207
208 // Ensure that -1 preserves default maximum value from |timing_|.
209 EXPECT_EQ(kPlayoutDelayMs.min_ms, timing_->min_playout_delay());
210 EXPECT_NE(kPlayoutDelayMs.max_ms, timing_->max_playout_delay());
211 EXPECT_EQ(default_max_playout_latency, timing_->max_playout_delay());
212 }
213
TEST_F(VideoReceiveStreamTest,PlayoutDelayPreservesDefaultMinValue)214 TEST_F(VideoReceiveStreamTest, PlayoutDelayPreservesDefaultMinValue) {
215 const int default_min_playout_latency = timing_->min_playout_delay();
216 const VideoPlayoutDelay kPlayoutDelayMs = {-1, 321};
217
218 std::unique_ptr<FrameObjectFake> test_frame(new FrameObjectFake());
219 test_frame->id.picture_id = 0;
220 test_frame->SetPlayoutDelay(kPlayoutDelayMs);
221
222 video_receive_stream_->OnCompleteFrame(std::move(test_frame));
223
224 // Ensure that -1 preserves default minimum value from |timing_|.
225 EXPECT_NE(kPlayoutDelayMs.min_ms, timing_->min_playout_delay());
226 EXPECT_EQ(kPlayoutDelayMs.max_ms, timing_->max_playout_delay());
227 EXPECT_EQ(default_min_playout_latency, timing_->min_playout_delay());
228 }
229
230 class VideoReceiveStreamTestWithFakeDecoder : public ::testing::Test {
231 public:
VideoReceiveStreamTestWithFakeDecoder()232 VideoReceiveStreamTestWithFakeDecoder()
233 : fake_decoder_factory_(
234 []() { return std::make_unique<test::FakeDecoder>(); }),
235 process_thread_(ProcessThread::Create("TestThread")),
236 task_queue_factory_(CreateDefaultTaskQueueFactory()),
237 config_(&mock_transport_),
238 call_stats_(Clock::GetRealTimeClock(), process_thread_.get()) {}
239
SetUp()240 void SetUp() {
241 config_.rtp.remote_ssrc = 1111;
242 config_.rtp.local_ssrc = 2222;
243 config_.renderer = &fake_renderer_;
244 config_.decoder_factory = &fake_decoder_factory_;
245 VideoReceiveStream::Decoder fake_decoder;
246 fake_decoder.payload_type = 99;
247 fake_decoder.video_format = SdpVideoFormat("VP8");
248 config_.decoders.push_back(fake_decoder);
249 clock_ = Clock::GetRealTimeClock();
250 ReCreateReceiveStream(VideoReceiveStream::RecordingState());
251 }
252
ReCreateReceiveStream(VideoReceiveStream::RecordingState state)253 void ReCreateReceiveStream(VideoReceiveStream::RecordingState state) {
254 constexpr int kDefaultNumCpuCores = 2;
255 video_receive_stream_ = nullptr;
256 timing_ = new VCMTiming(clock_);
257 video_receive_stream_.reset(new webrtc::internal::VideoReceiveStream(
258 task_queue_factory_.get(), &rtp_stream_receiver_controller_,
259 kDefaultNumCpuCores, &packet_router_, config_.Copy(),
260 process_thread_.get(), &call_stats_, clock_, timing_));
261 video_receive_stream_->SetAndGetRecordingState(std::move(state), false);
262 }
263
264 protected:
265 test::FunctionVideoDecoderFactory fake_decoder_factory_;
266 std::unique_ptr<ProcessThread> process_thread_;
267 const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
268 VideoReceiveStream::Config config_;
269 CallStats call_stats_;
270 cricket::FakeVideoRenderer fake_renderer_;
271 MockTransport mock_transport_;
272 PacketRouter packet_router_;
273 RtpStreamReceiverController rtp_stream_receiver_controller_;
274 std::unique_ptr<webrtc::internal::VideoReceiveStream> video_receive_stream_;
275 Clock* clock_;
276 VCMTiming* timing_;
277 };
278
TEST_F(VideoReceiveStreamTestWithFakeDecoder,PassesNtpTime)279 TEST_F(VideoReceiveStreamTestWithFakeDecoder, PassesNtpTime) {
280 const int64_t kNtpTimestamp = 12345;
281 auto test_frame = std::make_unique<FrameObjectFake>();
282 test_frame->SetPayloadType(99);
283 test_frame->id.picture_id = 0;
284 test_frame->SetNtpTime(kNtpTimestamp);
285
286 video_receive_stream_->Start();
287 video_receive_stream_->OnCompleteFrame(std::move(test_frame));
288 EXPECT_TRUE(fake_renderer_.WaitForRenderedFrame(kDefaultTimeOutMs));
289 EXPECT_EQ(kNtpTimestamp, fake_renderer_.ntp_time_ms());
290 }
291
TEST_F(VideoReceiveStreamTestWithFakeDecoder,PassesRotation)292 TEST_F(VideoReceiveStreamTestWithFakeDecoder, PassesRotation) {
293 const webrtc::VideoRotation kRotation = webrtc::kVideoRotation_180;
294 auto test_frame = std::make_unique<FrameObjectFake>();
295 test_frame->SetPayloadType(99);
296 test_frame->id.picture_id = 0;
297 test_frame->SetRotation(kRotation);
298
299 video_receive_stream_->Start();
300 video_receive_stream_->OnCompleteFrame(std::move(test_frame));
301 EXPECT_TRUE(fake_renderer_.WaitForRenderedFrame(kDefaultTimeOutMs));
302
303 EXPECT_EQ(kRotation, fake_renderer_.rotation());
304 }
305
TEST_F(VideoReceiveStreamTestWithFakeDecoder,PassesPacketInfos)306 TEST_F(VideoReceiveStreamTestWithFakeDecoder, PassesPacketInfos) {
307 auto test_frame = std::make_unique<FrameObjectFake>();
308 test_frame->SetPayloadType(99);
309 test_frame->id.picture_id = 0;
310 RtpPacketInfos packet_infos = CreatePacketInfos(3);
311 test_frame->SetPacketInfos(packet_infos);
312
313 video_receive_stream_->Start();
314 video_receive_stream_->OnCompleteFrame(std::move(test_frame));
315 EXPECT_TRUE(fake_renderer_.WaitForRenderedFrame(kDefaultTimeOutMs));
316
317 EXPECT_THAT(fake_renderer_.packet_infos(), ElementsAreArray(packet_infos));
318 }
319
TEST_F(VideoReceiveStreamTestWithFakeDecoder,RenderedFrameUpdatesGetSources)320 TEST_F(VideoReceiveStreamTestWithFakeDecoder, RenderedFrameUpdatesGetSources) {
321 constexpr uint32_t kSsrc = 1111;
322 constexpr uint32_t kCsrc = 9001;
323 constexpr uint32_t kRtpTimestamp = 12345;
324
325 // Prepare one video frame with per-packet information.
326 auto test_frame = std::make_unique<FrameObjectFake>();
327 test_frame->SetPayloadType(99);
328 test_frame->id.picture_id = 0;
329 RtpPacketInfos packet_infos;
330 {
331 RtpPacketInfos::vector_type infos;
332
333 RtpPacketInfo info;
334 info.set_ssrc(kSsrc);
335 info.set_csrcs({kCsrc});
336 info.set_rtp_timestamp(kRtpTimestamp);
337
338 info.set_receive_time_ms(clock_->TimeInMilliseconds() - 5000);
339 infos.push_back(info);
340
341 info.set_receive_time_ms(clock_->TimeInMilliseconds() - 3000);
342 infos.push_back(info);
343
344 info.set_receive_time_ms(clock_->TimeInMilliseconds() - 2000);
345 infos.push_back(info);
346
347 info.set_receive_time_ms(clock_->TimeInMilliseconds() - 4000);
348 infos.push_back(info);
349
350 packet_infos = RtpPacketInfos(std::move(infos));
351 }
352 test_frame->SetPacketInfos(packet_infos);
353
354 // Start receive stream.
355 video_receive_stream_->Start();
356 EXPECT_THAT(video_receive_stream_->GetSources(), IsEmpty());
357
358 // Render one video frame.
359 int64_t timestamp_ms_min = clock_->TimeInMilliseconds();
360 video_receive_stream_->OnCompleteFrame(std::move(test_frame));
361 EXPECT_TRUE(fake_renderer_.WaitForRenderedFrame(kDefaultTimeOutMs));
362 int64_t timestamp_ms_max = clock_->TimeInMilliseconds();
363
364 // Verify that the per-packet information is passed to the renderer.
365 EXPECT_THAT(fake_renderer_.packet_infos(), ElementsAreArray(packet_infos));
366
367 // Verify that the per-packet information also updates |GetSources()|.
368 std::vector<RtpSource> sources = video_receive_stream_->GetSources();
369 ASSERT_THAT(sources, SizeIs(2));
370 {
371 auto it = std::find_if(sources.begin(), sources.end(),
372 [](const RtpSource& source) {
373 return source.source_type() == RtpSourceType::SSRC;
374 });
375 ASSERT_NE(it, sources.end());
376
377 EXPECT_EQ(it->source_id(), kSsrc);
378 EXPECT_EQ(it->source_type(), RtpSourceType::SSRC);
379 EXPECT_EQ(it->rtp_timestamp(), kRtpTimestamp);
380 EXPECT_GE(it->timestamp_ms(), timestamp_ms_min);
381 EXPECT_LE(it->timestamp_ms(), timestamp_ms_max);
382 }
383 {
384 auto it = std::find_if(sources.begin(), sources.end(),
385 [](const RtpSource& source) {
386 return source.source_type() == RtpSourceType::CSRC;
387 });
388 ASSERT_NE(it, sources.end());
389
390 EXPECT_EQ(it->source_id(), kCsrc);
391 EXPECT_EQ(it->source_type(), RtpSourceType::CSRC);
392 EXPECT_EQ(it->rtp_timestamp(), kRtpTimestamp);
393 EXPECT_GE(it->timestamp_ms(), timestamp_ms_min);
394 EXPECT_LE(it->timestamp_ms(), timestamp_ms_max);
395 }
396 }
397
MakeFrame(VideoFrameType frame_type,int picture_id)398 std::unique_ptr<FrameObjectFake> MakeFrame(VideoFrameType frame_type,
399 int picture_id) {
400 auto frame = std::make_unique<FrameObjectFake>();
401 frame->SetPayloadType(99);
402 frame->id.picture_id = picture_id;
403 frame->SetFrameType(frame_type);
404 return frame;
405 }
406
TEST_F(VideoReceiveStreamTestWithFakeDecoder,PassesFrameWhenEncodedFramesCallbackSet)407 TEST_F(VideoReceiveStreamTestWithFakeDecoder,
408 PassesFrameWhenEncodedFramesCallbackSet) {
409 testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
410 video_receive_stream_->Start();
411 // Expect a keyframe request to be generated
412 EXPECT_CALL(mock_transport_, SendRtcp);
413 EXPECT_CALL(callback, Call);
414 video_receive_stream_->SetAndGetRecordingState(
415 VideoReceiveStream::RecordingState(callback.AsStdFunction()), true);
416 video_receive_stream_->OnCompleteFrame(
417 MakeFrame(VideoFrameType::kVideoFrameKey, 0));
418 EXPECT_TRUE(fake_renderer_.WaitForRenderedFrame(kDefaultTimeOutMs));
419 video_receive_stream_->Stop();
420 }
421
TEST_F(VideoReceiveStreamTestWithFakeDecoder,MovesEncodedFrameDispatchStateWhenReCreating)422 TEST_F(VideoReceiveStreamTestWithFakeDecoder,
423 MovesEncodedFrameDispatchStateWhenReCreating) {
424 testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
425 video_receive_stream_->Start();
426 // Expect a key frame request over RTCP.
427 EXPECT_CALL(mock_transport_, SendRtcp).Times(1);
428 video_receive_stream_->SetAndGetRecordingState(
429 VideoReceiveStream::RecordingState(callback.AsStdFunction()), true);
430 video_receive_stream_->Stop();
431 VideoReceiveStream::RecordingState old_state =
432 video_receive_stream_->SetAndGetRecordingState(
433 VideoReceiveStream::RecordingState(), false);
434 ReCreateReceiveStream(std::move(old_state));
435 video_receive_stream_->Stop();
436 }
437
438 class VideoReceiveStreamTestWithSimulatedClock : public ::testing::Test {
439 public:
440 class FakeDecoder2 : public test::FakeDecoder {
441 public:
FakeDecoder2(std::function<void ()> decode_callback)442 explicit FakeDecoder2(std::function<void()> decode_callback)
443 : callback_(decode_callback) {}
444
Decode(const EncodedImage & input,bool missing_frames,int64_t render_time_ms)445 int32_t Decode(const EncodedImage& input,
446 bool missing_frames,
447 int64_t render_time_ms) override {
448 int32_t result =
449 FakeDecoder::Decode(input, missing_frames, render_time_ms);
450 callback_();
451 return result;
452 }
453
454 private:
455 std::function<void()> callback_;
456 };
457
GetConfig(Transport * transport,VideoDecoderFactory * decoder_factory,rtc::VideoSinkInterface<webrtc::VideoFrame> * renderer)458 static VideoReceiveStream::Config GetConfig(
459 Transport* transport,
460 VideoDecoderFactory* decoder_factory,
461 rtc::VideoSinkInterface<webrtc::VideoFrame>* renderer) {
462 VideoReceiveStream::Config config(transport);
463 config.rtp.remote_ssrc = 1111;
464 config.rtp.local_ssrc = 2222;
465 config.renderer = renderer;
466 config.decoder_factory = decoder_factory;
467 VideoReceiveStream::Decoder fake_decoder;
468 fake_decoder.payload_type = 99;
469 fake_decoder.video_format = SdpVideoFormat("VP8");
470 config.decoders.push_back(fake_decoder);
471 return config;
472 }
473
VideoReceiveStreamTestWithSimulatedClock()474 VideoReceiveStreamTestWithSimulatedClock()
475 : time_controller_(Timestamp::Millis(4711)),
476 fake_decoder_factory_([this] {
477 return std::make_unique<FakeDecoder2>([this] { OnFrameDecoded(); });
478 }),
479 process_thread_(time_controller_.CreateProcessThread("ProcessThread")),
480 config_(GetConfig(&mock_transport_,
481 &fake_decoder_factory_,
482 &fake_renderer_)),
483 call_stats_(time_controller_.GetClock(), process_thread_.get()),
484 video_receive_stream_(time_controller_.GetTaskQueueFactory(),
485 &rtp_stream_receiver_controller_,
486 /*num_cores=*/2,
487 &packet_router_,
488 config_.Copy(),
489 process_thread_.get(),
490 &call_stats_,
491 time_controller_.GetClock(),
492 new VCMTiming(time_controller_.GetClock())) {
493 video_receive_stream_.Start();
494 }
495
OnFrameDecoded()496 void OnFrameDecoded() { event_->Set(); }
497
PassEncodedFrameAndWait(std::unique_ptr<video_coding::EncodedFrame> frame)498 void PassEncodedFrameAndWait(
499 std::unique_ptr<video_coding::EncodedFrame> frame) {
500 event_ = std::make_unique<rtc::Event>();
501 // This call will eventually end up in the Decoded method where the
502 // event is set.
503 video_receive_stream_.OnCompleteFrame(std::move(frame));
504 event_->Wait(rtc::Event::kForever);
505 }
506
507 protected:
508 GlobalSimulatedTimeController time_controller_;
509 test::FunctionVideoDecoderFactory fake_decoder_factory_;
510 std::unique_ptr<ProcessThread> process_thread_;
511 MockTransport mock_transport_;
512 cricket::FakeVideoRenderer fake_renderer_;
513 VideoReceiveStream::Config config_;
514 CallStats call_stats_;
515 PacketRouter packet_router_;
516 RtpStreamReceiverController rtp_stream_receiver_controller_;
517 webrtc::internal::VideoReceiveStream video_receive_stream_;
518 std::unique_ptr<rtc::Event> event_;
519 };
520
TEST_F(VideoReceiveStreamTestWithSimulatedClock,RequestsKeyFramesUntilKeyFrameReceived)521 TEST_F(VideoReceiveStreamTestWithSimulatedClock,
522 RequestsKeyFramesUntilKeyFrameReceived) {
523 auto tick = TimeDelta::Millis(
524 internal::VideoReceiveStream::kMaxWaitForKeyFrameMs / 2);
525 EXPECT_CALL(mock_transport_, SendRtcp).Times(1);
526 video_receive_stream_.GenerateKeyFrame();
527 PassEncodedFrameAndWait(MakeFrame(VideoFrameType::kVideoFrameDelta, 0));
528 time_controller_.AdvanceTime(tick);
529 PassEncodedFrameAndWait(MakeFrame(VideoFrameType::kVideoFrameDelta, 1));
530 testing::Mock::VerifyAndClearExpectations(&mock_transport_);
531
532 // T+200ms: still no key frame received, expect key frame request sent again.
533 EXPECT_CALL(mock_transport_, SendRtcp).Times(1);
534 time_controller_.AdvanceTime(tick);
535 PassEncodedFrameAndWait(MakeFrame(VideoFrameType::kVideoFrameDelta, 2));
536 testing::Mock::VerifyAndClearExpectations(&mock_transport_);
537
538 // T+200ms: now send a key frame - we should not observe new key frame
539 // requests after this.
540 EXPECT_CALL(mock_transport_, SendRtcp).Times(0);
541 PassEncodedFrameAndWait(MakeFrame(VideoFrameType::kVideoFrameKey, 3));
542 time_controller_.AdvanceTime(2 * tick);
543 PassEncodedFrameAndWait(MakeFrame(VideoFrameType::kVideoFrameDelta, 4));
544 }
545
546 } // namespace webrtc
547