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