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