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