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