1 /*
2 * Copyright (c) 2013 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 #include <algorithm>
11 #include <list>
12 #include <map>
13 #include <memory>
14 #include <sstream>
15 #include <string>
16 #include <vector>
17
18 #include "api/optional.h"
19 #include "api/video_codecs/video_encoder.h"
20 #include "call/call.h"
21 #include "common_video/include/frame_callback.h"
22 #include "logging/rtc_event_log/rtc_event_log.h"
23 #include "media/base/fakevideorenderer.h"
24 #include "media/base/mediaconstants.h"
25 #include "media/engine/internalencoderfactory.h"
26 #include "media/engine/simulcast_encoder_adapter.h"
27 #include "media/engine/webrtcvideoencoderfactory.h"
28 #include "modules/include/module_common_types.h"
29 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
30 #include "modules/rtp_rtcp/source/byte_io.h"
31 #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
32 #include "modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
33 #include "modules/rtp_rtcp/source/rtp_format.h"
34 #include "modules/rtp_rtcp/source/rtp_utility.h"
35 #include "modules/video_coding/codecs/h264/include/h264.h"
36 #include "modules/video_coding/codecs/vp8/include/vp8.h"
37 #include "modules/video_coding/codecs/vp9/include/vp9.h"
38 #include "modules/video_coding/include/video_coding_defines.h"
39 #include "rtc_base/checks.h"
40 #include "rtc_base/event.h"
41 #include "rtc_base/file.h"
42 #include "rtc_base/ptr_util.h"
43 #include "rtc_base/random.h"
44 #include "rtc_base/rate_limiter.h"
45 #include "system_wrappers/include/metrics.h"
46 #include "system_wrappers/include/metrics_default.h"
47 #include "system_wrappers/include/sleep.h"
48 #include "test/call_test.h"
49 #include "test/direct_transport.h"
50 #include "test/encoder_settings.h"
51 #include "test/fake_decoder.h"
52 #include "test/fake_encoder.h"
53 #include "test/field_trial.h"
54 #include "test/frame_generator.h"
55 #include "test/frame_generator_capturer.h"
56 #include "test/gmock.h"
57 #include "test/gtest.h"
58 #include "test/null_transport.h"
59 #include "test/rtcp_packet_parser.h"
60 #include "test/rtp_rtcp_observer.h"
61 #include "test/testsupport/fileutils.h"
62 #include "test/testsupport/perf_test.h"
63 #include "video/transport_adapter.h"
64
65 // Flaky under MemorySanitizer: bugs.webrtc.org/7419
66 #if defined(MEMORY_SANITIZER)
67 #define MAYBE_InitialProbing DISABLED_InitialProbing
68 // Fails on iOS bots: bugs.webrtc.org/7851
69 #elif defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR
70 #define MAYBE_InitialProbing DISABLED_InitialProbing
71 #else
72 #define MAYBE_InitialProbing InitialProbing
73 #endif
74
75 namespace webrtc {
76
77 namespace {
78 constexpr int kSilenceTimeoutMs = 2000;
79 }
80
81 class EndToEndTest : public test::CallTest,
82 public testing::WithParamInterface<std::string> {
83 public:
EndToEndTest()84 EndToEndTest() : field_trial_(GetParam()) {}
85
~EndToEndTest()86 virtual ~EndToEndTest() {
87 EXPECT_EQ(nullptr, video_send_stream_);
88 EXPECT_TRUE(video_receive_streams_.empty());
89 }
90
91 protected:
92 class UnusedTransport : public Transport {
93 private:
SendRtp(const uint8_t * packet,size_t length,const PacketOptions & options)94 bool SendRtp(const uint8_t* packet,
95 size_t length,
96 const PacketOptions& options) override {
97 ADD_FAILURE() << "Unexpected RTP sent.";
98 return false;
99 }
100
SendRtcp(const uint8_t * packet,size_t length)101 bool SendRtcp(const uint8_t* packet, size_t length) override {
102 ADD_FAILURE() << "Unexpected RTCP sent.";
103 return false;
104 }
105 };
106
107 class RequiredTransport : public Transport {
108 public:
RequiredTransport(bool rtp_required,bool rtcp_required)109 RequiredTransport(bool rtp_required, bool rtcp_required)
110 : need_rtp_(rtp_required), need_rtcp_(rtcp_required) {}
~RequiredTransport()111 ~RequiredTransport() {
112 if (need_rtp_) {
113 ADD_FAILURE() << "Expected RTP packet not sent.";
114 }
115 if (need_rtcp_) {
116 ADD_FAILURE() << "Expected RTCP packet not sent.";
117 }
118 }
119
120 private:
SendRtp(const uint8_t * packet,size_t length,const PacketOptions & options)121 bool SendRtp(const uint8_t* packet,
122 size_t length,
123 const PacketOptions& options) override {
124 rtc::CritScope lock(&crit_);
125 need_rtp_ = false;
126 return true;
127 }
128
SendRtcp(const uint8_t * packet,size_t length)129 bool SendRtcp(const uint8_t* packet, size_t length) override {
130 rtc::CritScope lock(&crit_);
131 need_rtcp_ = false;
132 return true;
133 }
134 bool need_rtp_;
135 bool need_rtcp_;
136 rtc::CriticalSection crit_;
137 };
138
139 void DecodesRetransmittedFrame(bool enable_rtx, bool enable_red);
140 void ReceivesPliAndRecovers(int rtp_history_ms);
141 void RespectsRtcpMode(RtcpMode rtcp_mode);
142 void TestSendsSetSsrcs(size_t num_ssrcs, bool send_single_ssrc_first);
143 void TestRtpStatePreservation(bool use_rtx, bool provoke_rtcpsr_before_rtp);
144 void VerifyHistogramStats(bool use_rtx, bool use_fec, bool screenshare);
145 void VerifyNewVideoSendStreamsRespectNetworkState(
146 MediaType network_to_bring_up,
147 VideoEncoder* encoder,
148 Transport* transport);
149 void VerifyNewVideoReceiveStreamsRespectNetworkState(
150 MediaType network_to_bring_up,
151 Transport* transport);
152
153 test::ScopedFieldTrials field_trial_;
154 };
155
TEST_P(EndToEndTest,ReceiverCanBeStartedTwice)156 TEST_P(EndToEndTest, ReceiverCanBeStartedTwice) {
157 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
158
159 test::NullTransport transport;
160 CreateSendConfig(1, 0, 0, &transport);
161 CreateMatchingReceiveConfigs(&transport);
162
163 CreateVideoStreams();
164
165 video_receive_streams_[0]->Start();
166 video_receive_streams_[0]->Start();
167
168 DestroyStreams();
169 }
170
TEST_P(EndToEndTest,ReceiverCanBeStoppedTwice)171 TEST_P(EndToEndTest, ReceiverCanBeStoppedTwice) {
172 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
173
174 test::NullTransport transport;
175 CreateSendConfig(1, 0, 0, &transport);
176 CreateMatchingReceiveConfigs(&transport);
177
178 CreateVideoStreams();
179
180 video_receive_streams_[0]->Stop();
181 video_receive_streams_[0]->Stop();
182
183 DestroyStreams();
184 }
185
TEST_P(EndToEndTest,ReceiverCanBeStoppedAndRestarted)186 TEST_P(EndToEndTest, ReceiverCanBeStoppedAndRestarted) {
187 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
188
189 test::NullTransport transport;
190 CreateSendConfig(1, 0, 0, &transport);
191 CreateMatchingReceiveConfigs(&transport);
192
193 CreateVideoStreams();
194
195 video_receive_streams_[0]->Stop();
196 video_receive_streams_[0]->Start();
197 video_receive_streams_[0]->Stop();
198
199 DestroyStreams();
200 }
201
TEST_P(EndToEndTest,RendersSingleDelayedFrame)202 TEST_P(EndToEndTest, RendersSingleDelayedFrame) {
203 static const int kWidth = 320;
204 static const int kHeight = 240;
205 // This constant is chosen to be higher than the timeout in the video_render
206 // module. This makes sure that frames aren't dropped if there are no other
207 // frames in the queue.
208 static const int kRenderDelayMs = 1000;
209
210 class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
211 public:
212 Renderer() : event_(false, false) {}
213
214 void OnFrame(const VideoFrame& video_frame) override {
215 SleepMs(kRenderDelayMs);
216 event_.Set();
217 }
218
219 bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
220
221 rtc::Event event_;
222 } renderer;
223
224 test::FrameForwarder frame_forwarder;
225 std::unique_ptr<test::DirectTransport> sender_transport;
226 std::unique_ptr<test::DirectTransport> receiver_transport;
227
228 task_queue_.SendTask([this, &renderer, &frame_forwarder, &sender_transport,
229 &receiver_transport]() {
230 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
231
232 sender_transport = rtc::MakeUnique<test::DirectTransport>(
233 &task_queue_, sender_call_.get(), payload_type_map_);
234 receiver_transport = rtc::MakeUnique<test::DirectTransport>(
235 &task_queue_, receiver_call_.get(), payload_type_map_);
236 sender_transport->SetReceiver(receiver_call_->Receiver());
237 receiver_transport->SetReceiver(sender_call_->Receiver());
238
239 CreateSendConfig(1, 0, 0, sender_transport.get());
240 CreateMatchingReceiveConfigs(receiver_transport.get());
241
242 video_receive_configs_[0].renderer = &renderer;
243
244 CreateVideoStreams();
245 Start();
246
247 // Create frames that are smaller than the send width/height, this is done
248 // to check that the callbacks are done after processing video.
249 std::unique_ptr<test::FrameGenerator> frame_generator(
250 test::FrameGenerator::CreateSquareGenerator(kWidth, kHeight));
251 video_send_stream_->SetSource(
252 &frame_forwarder,
253 VideoSendStream::DegradationPreference::kMaintainFramerate);
254
255 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame());
256 });
257
258 EXPECT_TRUE(renderer.Wait())
259 << "Timed out while waiting for the frame to render.";
260
261 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() {
262 Stop();
263 DestroyStreams();
264 sender_transport.reset();
265 receiver_transport.reset();
266 DestroyCalls();
267 });
268 }
269
TEST_P(EndToEndTest,TransmitsFirstFrame)270 TEST_P(EndToEndTest, TransmitsFirstFrame) {
271 class Renderer : public rtc::VideoSinkInterface<VideoFrame> {
272 public:
273 Renderer() : event_(false, false) {}
274
275 void OnFrame(const VideoFrame& video_frame) override { event_.Set(); }
276
277 bool Wait() { return event_.Wait(kDefaultTimeoutMs); }
278
279 rtc::Event event_;
280 } renderer;
281
282 std::unique_ptr<test::FrameGenerator> frame_generator;
283 test::FrameForwarder frame_forwarder;
284
285 std::unique_ptr<test::DirectTransport> sender_transport;
286 std::unique_ptr<test::DirectTransport> receiver_transport;
287
288 task_queue_.SendTask([this, &renderer, &frame_generator, &frame_forwarder,
289 &sender_transport, &receiver_transport]() {
290 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
291
292 sender_transport = rtc::MakeUnique<test::DirectTransport>(
293 &task_queue_, sender_call_.get(), payload_type_map_);
294 receiver_transport = rtc::MakeUnique<test::DirectTransport>(
295 &task_queue_, receiver_call_.get(), payload_type_map_);
296 sender_transport->SetReceiver(receiver_call_->Receiver());
297 receiver_transport->SetReceiver(sender_call_->Receiver());
298
299 CreateSendConfig(1, 0, 0, sender_transport.get());
300 CreateMatchingReceiveConfigs(receiver_transport.get());
301 video_receive_configs_[0].renderer = &renderer;
302
303 CreateVideoStreams();
304 Start();
305
306 frame_generator = test::FrameGenerator::CreateSquareGenerator(
307 kDefaultWidth, kDefaultHeight);
308 video_send_stream_->SetSource(
309 &frame_forwarder,
310 VideoSendStream::DegradationPreference::kMaintainFramerate);
311 frame_forwarder.IncomingCapturedFrame(*frame_generator->NextFrame());
312 });
313
314 EXPECT_TRUE(renderer.Wait())
315 << "Timed out while waiting for the frame to render.";
316
317 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() {
318 Stop();
319 DestroyStreams();
320 sender_transport.reset();
321 receiver_transport.reset();
322 DestroyCalls();
323 });
324 }
325
326 class CodecObserver : public test::EndToEndTest,
327 public rtc::VideoSinkInterface<VideoFrame> {
328 public:
CodecObserver(int no_frames_to_wait_for,VideoRotation rotation_to_test,const std::string & payload_name,std::unique_ptr<webrtc::VideoEncoder> encoder,std::unique_ptr<webrtc::VideoDecoder> decoder)329 CodecObserver(int no_frames_to_wait_for,
330 VideoRotation rotation_to_test,
331 const std::string& payload_name,
332 std::unique_ptr<webrtc::VideoEncoder> encoder,
333 std::unique_ptr<webrtc::VideoDecoder> decoder)
334 : EndToEndTest(4 * webrtc::EndToEndTest::kDefaultTimeoutMs),
335 // TODO(hta): This timeout (120 seconds) is excessive.
336 // https://bugs.webrtc.org/6830
337 no_frames_to_wait_for_(no_frames_to_wait_for),
338 expected_rotation_(rotation_to_test),
339 payload_name_(payload_name),
340 encoder_(std::move(encoder)),
341 decoder_(std::move(decoder)),
342 frame_counter_(0) {}
343
PerformTest()344 void PerformTest() override {
345 EXPECT_TRUE(Wait())
346 << "Timed out while waiting for enough frames to be decoded.";
347 }
348
ModifyVideoConfigs(VideoSendStream::Config * send_config,std::vector<VideoReceiveStream::Config> * receive_configs,VideoEncoderConfig * encoder_config)349 void ModifyVideoConfigs(
350 VideoSendStream::Config* send_config,
351 std::vector<VideoReceiveStream::Config>* receive_configs,
352 VideoEncoderConfig* encoder_config) override {
353 send_config->encoder_settings.encoder = encoder_.get();
354 send_config->encoder_settings.payload_name = payload_name_;
355 send_config->encoder_settings.payload_type =
356 test::CallTest::kVideoSendPayloadType;
357
358 (*receive_configs)[0].renderer = this;
359 (*receive_configs)[0].decoders.resize(1);
360 (*receive_configs)[0].decoders[0].payload_type =
361 send_config->encoder_settings.payload_type;
362 (*receive_configs)[0].decoders[0].payload_name =
363 send_config->encoder_settings.payload_name;
364 (*receive_configs)[0].decoders[0].decoder = decoder_.get();
365 }
366
OnFrame(const VideoFrame & video_frame)367 void OnFrame(const VideoFrame& video_frame) override {
368 EXPECT_EQ(expected_rotation_, video_frame.rotation());
369 if (++frame_counter_ == no_frames_to_wait_for_)
370 observation_complete_.Set();
371 }
372
OnFrameGeneratorCapturerCreated(test::FrameGeneratorCapturer * frame_generator_capturer)373 void OnFrameGeneratorCapturerCreated(
374 test::FrameGeneratorCapturer* frame_generator_capturer) override {
375 frame_generator_capturer->SetFakeRotation(expected_rotation_);
376 }
377
378 private:
379 int no_frames_to_wait_for_;
380 VideoRotation expected_rotation_;
381 std::string payload_name_;
382 std::unique_ptr<webrtc::VideoEncoder> encoder_;
383 std::unique_ptr<webrtc::VideoDecoder> decoder_;
384 int frame_counter_;
385 };
386
TEST_P(EndToEndTest,SendsAndReceivesVP8)387 TEST_P(EndToEndTest, SendsAndReceivesVP8) {
388 CodecObserver test(5, kVideoRotation_0, "VP8", VP8Encoder::Create(),
389 VP8Decoder::Create());
390 RunBaseTest(&test);
391 }
392
TEST_P(EndToEndTest,SendsAndReceivesVP8Rotation90)393 TEST_P(EndToEndTest, SendsAndReceivesVP8Rotation90) {
394 CodecObserver test(5, kVideoRotation_90, "VP8", VP8Encoder::Create(),
395 VP8Decoder::Create());
396 RunBaseTest(&test);
397 }
398
399 #if !defined(RTC_DISABLE_VP9)
TEST_P(EndToEndTest,SendsAndReceivesVP9)400 TEST_P(EndToEndTest, SendsAndReceivesVP9) {
401 CodecObserver test(500, kVideoRotation_0, "VP9", VP9Encoder::Create(),
402 VP9Decoder::Create());
403 RunBaseTest(&test);
404 }
405
TEST_P(EndToEndTest,SendsAndReceivesVP9VideoRotation90)406 TEST_P(EndToEndTest, SendsAndReceivesVP9VideoRotation90) {
407 CodecObserver test(5, kVideoRotation_90, "VP9", VP9Encoder::Create(),
408 VP9Decoder::Create());
409 RunBaseTest(&test);
410 }
411 #endif // !defined(RTC_DISABLE_VP9)
412
413 #if defined(WEBRTC_USE_H264)
414 class EndToEndTestH264 : public EndToEndTest {};
415
416 const auto h264_field_trial_combinations = ::testing::Values(
417 "WebRTC-SpsPpsIdrIsH264Keyframe/Disabled/WebRTC-RoundRobinPacing/Disabled/",
418 "WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/WebRTC-RoundRobinPacing/Disabled/",
419 "WebRTC-SpsPpsIdrIsH264Keyframe/Disabled/WebRTC-RoundRobinPacing/Enabled/",
420 "WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/WebRTC-RoundRobinPacing/Enabled/");
421 INSTANTIATE_TEST_CASE_P(SpsPpsIdrIsKeyframe,
422 EndToEndTestH264,
423 h264_field_trial_combinations);
424
TEST_P(EndToEndTestH264,SendsAndReceivesH264)425 TEST_P(EndToEndTestH264, SendsAndReceivesH264) {
426 CodecObserver test(500, kVideoRotation_0, "H264",
427 H264Encoder::Create(cricket::VideoCodec("H264")),
428 H264Decoder::Create());
429 RunBaseTest(&test);
430 }
431
TEST_P(EndToEndTestH264,SendsAndReceivesH264VideoRotation90)432 TEST_P(EndToEndTestH264, SendsAndReceivesH264VideoRotation90) {
433 CodecObserver test(5, kVideoRotation_90, "H264",
434 H264Encoder::Create(cricket::VideoCodec("H264")),
435 H264Decoder::Create());
436 RunBaseTest(&test);
437 }
438
TEST_P(EndToEndTestH264,SendsAndReceivesH264PacketizationMode0)439 TEST_P(EndToEndTestH264, SendsAndReceivesH264PacketizationMode0) {
440 cricket::VideoCodec codec = cricket::VideoCodec("H264");
441 codec.SetParam(cricket::kH264FmtpPacketizationMode, "0");
442 CodecObserver test(500, kVideoRotation_0, "H264", H264Encoder::Create(codec),
443 H264Decoder::Create());
444 RunBaseTest(&test);
445 }
446
TEST_P(EndToEndTestH264,SendsAndReceivesH264PacketizationMode1)447 TEST_P(EndToEndTestH264, SendsAndReceivesH264PacketizationMode1) {
448 cricket::VideoCodec codec = cricket::VideoCodec("H264");
449 codec.SetParam(cricket::kH264FmtpPacketizationMode, "1");
450 CodecObserver test(500, kVideoRotation_0, "H264", H264Encoder::Create(codec),
451 H264Decoder::Create());
452 RunBaseTest(&test);
453 }
454 #endif // defined(WEBRTC_USE_H264)
455
TEST_P(EndToEndTest,ReceiverUsesLocalSsrc)456 TEST_P(EndToEndTest, ReceiverUsesLocalSsrc) {
457 class SyncRtcpObserver : public test::EndToEndTest {
458 public:
459 SyncRtcpObserver() : EndToEndTest(kDefaultTimeoutMs) {}
460
461 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
462 test::RtcpPacketParser parser;
463 EXPECT_TRUE(parser.Parse(packet, length));
464 EXPECT_EQ(kReceiverLocalVideoSsrc, parser.sender_ssrc());
465 observation_complete_.Set();
466
467 return SEND_PACKET;
468 }
469
470 void PerformTest() override {
471 EXPECT_TRUE(Wait())
472 << "Timed out while waiting for a receiver RTCP packet to be sent.";
473 }
474 } test;
475
476 RunBaseTest(&test);
477 }
478
TEST_P(EndToEndTest,ReceivesAndRetransmitsNack)479 TEST_P(EndToEndTest, ReceivesAndRetransmitsNack) {
480 static const int kNumberOfNacksToObserve = 2;
481 static const int kLossBurstSize = 2;
482 static const int kPacketsBetweenLossBursts = 9;
483 class NackObserver : public test::EndToEndTest {
484 public:
485 NackObserver()
486 : EndToEndTest(kLongTimeoutMs),
487 sent_rtp_packets_(0),
488 packets_left_to_drop_(0),
489 nacks_left_(kNumberOfNacksToObserve) {}
490
491 private:
492 Action OnSendRtp(const uint8_t* packet, size_t length) override {
493 rtc::CritScope lock(&crit_);
494 RTPHeader header;
495 EXPECT_TRUE(parser_->Parse(packet, length, &header));
496
497 // Never drop retransmitted packets.
498 if (dropped_packets_.find(header.sequenceNumber) !=
499 dropped_packets_.end()) {
500 retransmitted_packets_.insert(header.sequenceNumber);
501 return SEND_PACKET;
502 }
503
504 if (nacks_left_ <= 0 &&
505 retransmitted_packets_.size() == dropped_packets_.size()) {
506 observation_complete_.Set();
507 }
508
509 ++sent_rtp_packets_;
510
511 // Enough NACKs received, stop dropping packets.
512 if (nacks_left_ <= 0)
513 return SEND_PACKET;
514
515 // Check if it's time for a new loss burst.
516 if (sent_rtp_packets_ % kPacketsBetweenLossBursts == 0)
517 packets_left_to_drop_ = kLossBurstSize;
518
519 // Never drop padding packets as those won't be retransmitted.
520 if (packets_left_to_drop_ > 0 && header.paddingLength == 0) {
521 --packets_left_to_drop_;
522 dropped_packets_.insert(header.sequenceNumber);
523 return DROP_PACKET;
524 }
525
526 return SEND_PACKET;
527 }
528
529 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
530 rtc::CritScope lock(&crit_);
531 test::RtcpPacketParser parser;
532 EXPECT_TRUE(parser.Parse(packet, length));
533 nacks_left_ -= parser.nack()->num_packets();
534 return SEND_PACKET;
535 }
536
537 void ModifyVideoConfigs(
538 VideoSendStream::Config* send_config,
539 std::vector<VideoReceiveStream::Config>* receive_configs,
540 VideoEncoderConfig* encoder_config) override {
541 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
542 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
543 }
544
545 void PerformTest() override {
546 EXPECT_TRUE(Wait())
547 << "Timed out waiting for packets to be NACKed, retransmitted and "
548 "rendered.";
549 }
550
551 rtc::CriticalSection crit_;
552 std::set<uint16_t> dropped_packets_;
553 std::set<uint16_t> retransmitted_packets_;
554 uint64_t sent_rtp_packets_;
555 int packets_left_to_drop_;
556 int nacks_left_ RTC_GUARDED_BY(&crit_);
557 } test;
558
559 RunBaseTest(&test);
560 }
561
TEST_P(EndToEndTest,ReceivesNackAndRetransmitsAudio)562 TEST_P(EndToEndTest, ReceivesNackAndRetransmitsAudio) {
563 class NackObserver : public test::EndToEndTest {
564 public:
565 NackObserver()
566 : EndToEndTest(kLongTimeoutMs),
567 local_ssrc_(0),
568 remote_ssrc_(0),
569 receive_transport_(nullptr) {}
570
571 private:
572 size_t GetNumVideoStreams() const override { return 0; }
573 size_t GetNumAudioStreams() const override { return 1; }
574
575 test::PacketTransport* CreateReceiveTransport(
576 test::SingleThreadedTaskQueueForTesting* task_queue) override {
577 test::PacketTransport* receive_transport = new test::PacketTransport(
578 task_queue, nullptr, this, test::PacketTransport::kReceiver,
579 payload_type_map_, FakeNetworkPipe::Config());
580 receive_transport_ = receive_transport;
581 return receive_transport;
582 }
583
584 Action OnSendRtp(const uint8_t* packet, size_t length) override {
585 RTPHeader header;
586 EXPECT_TRUE(parser_->Parse(packet, length, &header));
587
588 if (!sequence_number_to_retransmit_) {
589 sequence_number_to_retransmit_ =
590 rtc::Optional<uint16_t>(header.sequenceNumber);
591
592 // Don't ask for retransmission straight away, may be deduped in pacer.
593 } else if (header.sequenceNumber == *sequence_number_to_retransmit_) {
594 observation_complete_.Set();
595 } else {
596 // Send a NACK as often as necessary until retransmission is received.
597 rtcp::Nack nack;
598 nack.SetSenderSsrc(local_ssrc_);
599 nack.SetMediaSsrc(remote_ssrc_);
600 uint16_t nack_list[] = {*sequence_number_to_retransmit_};
601 nack.SetPacketIds(nack_list, 1);
602 rtc::Buffer buffer = nack.Build();
603
604 EXPECT_TRUE(receive_transport_->SendRtcp(buffer.data(), buffer.size()));
605 }
606
607 return SEND_PACKET;
608 }
609
610 void ModifyAudioConfigs(
611 AudioSendStream::Config* send_config,
612 std::vector<AudioReceiveStream::Config>* receive_configs) override {
613 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
614 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
615 local_ssrc_ = (*receive_configs)[0].rtp.local_ssrc;
616 remote_ssrc_ = (*receive_configs)[0].rtp.remote_ssrc;
617 }
618
619 void PerformTest() override {
620 EXPECT_TRUE(Wait())
621 << "Timed out waiting for packets to be NACKed, retransmitted and "
622 "rendered.";
623 }
624
625 uint32_t local_ssrc_;
626 uint32_t remote_ssrc_;
627 Transport* receive_transport_;
628 rtc::Optional<uint16_t> sequence_number_to_retransmit_;
629 } test;
630
631 RunBaseTest(&test);
632 }
633
TEST_P(EndToEndTest,ReceivesUlpfec)634 TEST_P(EndToEndTest, ReceivesUlpfec) {
635 class UlpfecRenderObserver : public test::EndToEndTest,
636 public rtc::VideoSinkInterface<VideoFrame> {
637 public:
638 UlpfecRenderObserver()
639 : EndToEndTest(kDefaultTimeoutMs),
640 encoder_(VP8Encoder::Create()),
641 random_(0xcafef00d1),
642 num_packets_sent_(0) {}
643
644 private:
645 Action OnSendRtp(const uint8_t* packet, size_t length) override {
646 rtc::CritScope lock(&crit_);
647 RTPHeader header;
648 EXPECT_TRUE(parser_->Parse(packet, length, &header));
649
650 EXPECT_TRUE(header.payloadType == kVideoSendPayloadType ||
651 header.payloadType == kRedPayloadType)
652 << "Unknown payload type received.";
653 EXPECT_EQ(kVideoSendSsrcs[0], header.ssrc) << "Unknown SSRC received.";
654
655 // Parse RED header.
656 int encapsulated_payload_type = -1;
657 if (header.payloadType == kRedPayloadType) {
658 encapsulated_payload_type =
659 static_cast<int>(packet[header.headerLength]);
660
661 EXPECT_TRUE(encapsulated_payload_type == kVideoSendPayloadType ||
662 encapsulated_payload_type == kUlpfecPayloadType)
663 << "Unknown encapsulated payload type received.";
664 }
665
666 // To minimize test flakiness, always let ULPFEC packets through.
667 if (encapsulated_payload_type == kUlpfecPayloadType) {
668 return SEND_PACKET;
669 }
670
671 // Simulate 5% video packet loss after rampup period. Record the
672 // corresponding timestamps that were dropped.
673 if (num_packets_sent_++ > 100 && random_.Rand(1, 100) <= 5) {
674 if (encapsulated_payload_type == kVideoSendPayloadType) {
675 dropped_sequence_numbers_.insert(header.sequenceNumber);
676 dropped_timestamps_.insert(header.timestamp);
677 }
678 return DROP_PACKET;
679 }
680
681 return SEND_PACKET;
682 }
683
684 void OnFrame(const VideoFrame& video_frame) override {
685 rtc::CritScope lock(&crit_);
686 // Rendering frame with timestamp of packet that was dropped -> FEC
687 // protection worked.
688 auto it = dropped_timestamps_.find(video_frame.timestamp());
689 if (it != dropped_timestamps_.end()) {
690 observation_complete_.Set();
691 }
692 }
693
694 void ModifyVideoConfigs(
695 VideoSendStream::Config* send_config,
696 std::vector<VideoReceiveStream::Config>* receive_configs,
697 VideoEncoderConfig* encoder_config) override {
698 // Use VP8 instead of FAKE, since the latter does not have PictureID
699 // in the packetization headers.
700 send_config->encoder_settings.encoder = encoder_.get();
701 send_config->encoder_settings.payload_name = "VP8";
702 send_config->encoder_settings.payload_type = kVideoSendPayloadType;
703 VideoReceiveStream::Decoder decoder =
704 test::CreateMatchingDecoder(send_config->encoder_settings);
705 decoder_.reset(decoder.decoder);
706 (*receive_configs)[0].decoders.clear();
707 (*receive_configs)[0].decoders.push_back(decoder);
708
709 // Enable ULPFEC over RED.
710 send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
711 send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
712 (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
713 (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
714
715 (*receive_configs)[0].renderer = this;
716 }
717
718 void PerformTest() override {
719 EXPECT_TRUE(Wait())
720 << "Timed out waiting for dropped frames to be rendered.";
721 }
722
723 rtc::CriticalSection crit_;
724 std::unique_ptr<VideoEncoder> encoder_;
725 std::unique_ptr<VideoDecoder> decoder_;
726 std::set<uint32_t> dropped_sequence_numbers_ RTC_GUARDED_BY(crit_);
727 // Several packets can have the same timestamp.
728 std::multiset<uint32_t> dropped_timestamps_ RTC_GUARDED_BY(crit_);
729 Random random_;
730 int num_packets_sent_ RTC_GUARDED_BY(crit_);
731 } test;
732
733 RunBaseTest(&test);
734 }
735
736 class FlexfecRenderObserver : public test::EndToEndTest,
737 public rtc::VideoSinkInterface<VideoFrame> {
738 public:
739 static constexpr uint32_t kVideoLocalSsrc = 123;
740 static constexpr uint32_t kFlexfecLocalSsrc = 456;
741
FlexfecRenderObserver(bool enable_nack,bool expect_flexfec_rtcp)742 explicit FlexfecRenderObserver(bool enable_nack, bool expect_flexfec_rtcp)
743 : test::EndToEndTest(test::CallTest::kDefaultTimeoutMs),
744 enable_nack_(enable_nack),
745 expect_flexfec_rtcp_(expect_flexfec_rtcp),
746 received_flexfec_rtcp_(false),
747 random_(0xcafef00d1),
748 num_packets_sent_(0) {}
749
GetNumFlexfecStreams() const750 size_t GetNumFlexfecStreams() const override { return 1; }
751
752 private:
OnSendRtp(const uint8_t * packet,size_t length)753 Action OnSendRtp(const uint8_t* packet, size_t length) override {
754 rtc::CritScope lock(&crit_);
755 RTPHeader header;
756 EXPECT_TRUE(parser_->Parse(packet, length, &header));
757
758 EXPECT_TRUE(header.payloadType ==
759 test::CallTest::kFakeVideoSendPayloadType ||
760 header.payloadType == test::CallTest::kFlexfecPayloadType ||
761 (enable_nack_ &&
762 header.payloadType == test::CallTest::kSendRtxPayloadType))
763 << "Unknown payload type received.";
764 EXPECT_TRUE(
765 header.ssrc == test::CallTest::kVideoSendSsrcs[0] ||
766 header.ssrc == test::CallTest::kFlexfecSendSsrc ||
767 (enable_nack_ && header.ssrc == test::CallTest::kSendRtxSsrcs[0]))
768 << "Unknown SSRC received.";
769
770 // To reduce test flakiness, always let FlexFEC packets through.
771 if (header.payloadType == test::CallTest::kFlexfecPayloadType) {
772 EXPECT_EQ(test::CallTest::kFlexfecSendSsrc, header.ssrc);
773
774 return SEND_PACKET;
775 }
776
777 // To reduce test flakiness, always let RTX packets through.
778 if (header.payloadType == test::CallTest::kSendRtxPayloadType) {
779 EXPECT_EQ(test::CallTest::kSendRtxSsrcs[0], header.ssrc);
780
781 // Parse RTX header.
782 uint16_t original_sequence_number =
783 ByteReader<uint16_t>::ReadBigEndian(&packet[header.headerLength]);
784
785 // From the perspective of FEC, a retransmitted packet is no longer
786 // dropped, so remove it from list of dropped packets.
787 auto seq_num_it =
788 dropped_sequence_numbers_.find(original_sequence_number);
789 if (seq_num_it != dropped_sequence_numbers_.end()) {
790 dropped_sequence_numbers_.erase(seq_num_it);
791 auto ts_it = dropped_timestamps_.find(header.timestamp);
792 EXPECT_NE(ts_it, dropped_timestamps_.end());
793 dropped_timestamps_.erase(ts_it);
794 }
795
796 return SEND_PACKET;
797 }
798
799 // Simulate 5% video packet loss after rampup period. Record the
800 // corresponding timestamps that were dropped.
801 if (num_packets_sent_++ > 100 && random_.Rand(1, 100) <= 5) {
802 EXPECT_EQ(test::CallTest::kFakeVideoSendPayloadType, header.payloadType);
803 EXPECT_EQ(test::CallTest::kVideoSendSsrcs[0], header.ssrc);
804
805 dropped_sequence_numbers_.insert(header.sequenceNumber);
806 dropped_timestamps_.insert(header.timestamp);
807
808 return DROP_PACKET;
809 }
810
811 return SEND_PACKET;
812 }
813
OnReceiveRtcp(const uint8_t * data,size_t length)814 Action OnReceiveRtcp(const uint8_t* data, size_t length) override {
815 test::RtcpPacketParser parser;
816
817 parser.Parse(data, length);
818 if (parser.sender_ssrc() == kFlexfecLocalSsrc) {
819 EXPECT_EQ(1, parser.receiver_report()->num_packets());
820 const std::vector<rtcp::ReportBlock>& report_blocks =
821 parser.receiver_report()->report_blocks();
822 if (!report_blocks.empty()) {
823 EXPECT_EQ(1U, report_blocks.size());
824 EXPECT_EQ(test::CallTest::kFlexfecSendSsrc,
825 report_blocks[0].source_ssrc());
826 rtc::CritScope lock(&crit_);
827 received_flexfec_rtcp_ = true;
828 }
829 }
830
831 return SEND_PACKET;
832 }
833
CreateSendTransport(test::SingleThreadedTaskQueueForTesting * task_queue,Call * sender_call)834 test::PacketTransport* CreateSendTransport(
835 test::SingleThreadedTaskQueueForTesting* task_queue,
836 Call* sender_call) override {
837 // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
838 const int kNetworkDelayMs = 100;
839 FakeNetworkPipe::Config config;
840 config.queue_delay_ms = kNetworkDelayMs;
841 return new test::PacketTransport(task_queue, sender_call, this,
842 test::PacketTransport::kSender,
843 test::CallTest::payload_type_map_, config);
844 }
845
OnFrame(const VideoFrame & video_frame)846 void OnFrame(const VideoFrame& video_frame) override {
847 EXPECT_EQ(kVideoRotation_90, video_frame.rotation());
848
849 rtc::CritScope lock(&crit_);
850 // Rendering frame with timestamp of packet that was dropped -> FEC
851 // protection worked.
852 auto it = dropped_timestamps_.find(video_frame.timestamp());
853 if (it != dropped_timestamps_.end()) {
854 if (!expect_flexfec_rtcp_ || received_flexfec_rtcp_) {
855 observation_complete_.Set();
856 }
857 }
858 }
859
ModifyVideoConfigs(VideoSendStream::Config * send_config,std::vector<VideoReceiveStream::Config> * receive_configs,VideoEncoderConfig * encoder_config)860 void ModifyVideoConfigs(
861 VideoSendStream::Config* send_config,
862 std::vector<VideoReceiveStream::Config>* receive_configs,
863 VideoEncoderConfig* encoder_config) override {
864 (*receive_configs)[0].rtp.local_ssrc = kVideoLocalSsrc;
865 (*receive_configs)[0].renderer = this;
866
867 if (enable_nack_) {
868 send_config->rtp.nack.rtp_history_ms = test::CallTest::kNackRtpHistoryMs;
869 send_config->rtp.rtx.ssrcs.push_back(test::CallTest::kSendRtxSsrcs[0]);
870 send_config->rtp.rtx.payload_type = test::CallTest::kSendRtxPayloadType;
871
872 (*receive_configs)[0].rtp.nack.rtp_history_ms =
873 test::CallTest::kNackRtpHistoryMs;
874 (*receive_configs)[0].rtp.rtx_ssrc = test::CallTest::kSendRtxSsrcs[0];
875 (*receive_configs)[0]
876 .rtp
877 .rtx_associated_payload_types[test::CallTest::kSendRtxPayloadType] =
878 test::CallTest::kVideoSendPayloadType;
879 }
880 }
881
OnFrameGeneratorCapturerCreated(test::FrameGeneratorCapturer * frame_generator_capturer)882 void OnFrameGeneratorCapturerCreated(
883 test::FrameGeneratorCapturer* frame_generator_capturer) override {
884 frame_generator_capturer->SetFakeRotation(kVideoRotation_90);
885 }
886
ModifyFlexfecConfigs(std::vector<FlexfecReceiveStream::Config> * receive_configs)887 void ModifyFlexfecConfigs(
888 std::vector<FlexfecReceiveStream::Config>* receive_configs) override {
889 (*receive_configs)[0].local_ssrc = kFlexfecLocalSsrc;
890 }
891
PerformTest()892 void PerformTest() override {
893 EXPECT_TRUE(Wait())
894 << "Timed out waiting for dropped frames to be rendered.";
895 }
896
897 rtc::CriticalSection crit_;
898 std::set<uint32_t> dropped_sequence_numbers_ RTC_GUARDED_BY(crit_);
899 // Several packets can have the same timestamp.
900 std::multiset<uint32_t> dropped_timestamps_ RTC_GUARDED_BY(crit_);
901 const bool enable_nack_;
902 const bool expect_flexfec_rtcp_;
903 bool received_flexfec_rtcp_ RTC_GUARDED_BY(crit_);
904 Random random_;
905 int num_packets_sent_;
906 };
907
TEST_P(EndToEndTest,RecoversWithFlexfec)908 TEST_P(EndToEndTest, RecoversWithFlexfec) {
909 FlexfecRenderObserver test(false, false);
910 RunBaseTest(&test);
911 }
912
TEST_P(EndToEndTest,RecoversWithFlexfecAndNack)913 TEST_P(EndToEndTest, RecoversWithFlexfecAndNack) {
914 FlexfecRenderObserver test(true, false);
915 RunBaseTest(&test);
916 }
917
TEST_P(EndToEndTest,RecoversWithFlexfecAndSendsCorrespondingRtcp)918 TEST_P(EndToEndTest, RecoversWithFlexfecAndSendsCorrespondingRtcp) {
919 FlexfecRenderObserver test(false, true);
920 RunBaseTest(&test);
921 }
922
TEST_P(EndToEndTest,ReceivedUlpfecPacketsNotNacked)923 TEST_P(EndToEndTest, ReceivedUlpfecPacketsNotNacked) {
924 class UlpfecNackObserver : public test::EndToEndTest {
925 public:
926 UlpfecNackObserver()
927 : EndToEndTest(kDefaultTimeoutMs),
928 state_(kFirstPacket),
929 ulpfec_sequence_number_(0),
930 has_last_sequence_number_(false),
931 last_sequence_number_(0),
932 encoder_(VP8Encoder::Create()),
933 decoder_(VP8Decoder::Create()) {}
934
935 private:
936 Action OnSendRtp(const uint8_t* packet, size_t length) override {
937 rtc::CritScope lock_(&crit_);
938 RTPHeader header;
939 EXPECT_TRUE(parser_->Parse(packet, length, &header));
940
941 int encapsulated_payload_type = -1;
942 if (header.payloadType == kRedPayloadType) {
943 encapsulated_payload_type =
944 static_cast<int>(packet[header.headerLength]);
945 if (encapsulated_payload_type != kFakeVideoSendPayloadType)
946 EXPECT_EQ(kUlpfecPayloadType, encapsulated_payload_type);
947 } else {
948 EXPECT_EQ(kFakeVideoSendPayloadType, header.payloadType);
949 }
950
951 if (has_last_sequence_number_ &&
952 !IsNewerSequenceNumber(header.sequenceNumber,
953 last_sequence_number_)) {
954 // Drop retransmitted packets.
955 return DROP_PACKET;
956 }
957 last_sequence_number_ = header.sequenceNumber;
958 has_last_sequence_number_ = true;
959
960 bool ulpfec_packet = encapsulated_payload_type == kUlpfecPayloadType;
961 switch (state_) {
962 case kFirstPacket:
963 state_ = kDropEveryOtherPacketUntilUlpfec;
964 break;
965 case kDropEveryOtherPacketUntilUlpfec:
966 if (ulpfec_packet) {
967 state_ = kDropAllMediaPacketsUntilUlpfec;
968 } else if (header.sequenceNumber % 2 == 0) {
969 return DROP_PACKET;
970 }
971 break;
972 case kDropAllMediaPacketsUntilUlpfec:
973 if (!ulpfec_packet)
974 return DROP_PACKET;
975 ulpfec_sequence_number_ = header.sequenceNumber;
976 state_ = kDropOneMediaPacket;
977 break;
978 case kDropOneMediaPacket:
979 if (ulpfec_packet)
980 return DROP_PACKET;
981 state_ = kPassOneMediaPacket;
982 return DROP_PACKET;
983 break;
984 case kPassOneMediaPacket:
985 if (ulpfec_packet)
986 return DROP_PACKET;
987 // Pass one media packet after dropped packet after last FEC,
988 // otherwise receiver might never see a seq_no after
989 // |ulpfec_sequence_number_|
990 state_ = kVerifyUlpfecPacketNotInNackList;
991 break;
992 case kVerifyUlpfecPacketNotInNackList:
993 // Continue to drop packets. Make sure no frame can be decoded.
994 if (ulpfec_packet || header.sequenceNumber % 2 == 0)
995 return DROP_PACKET;
996 break;
997 }
998 return SEND_PACKET;
999 }
1000
1001 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
1002 rtc::CritScope lock_(&crit_);
1003 if (state_ == kVerifyUlpfecPacketNotInNackList) {
1004 test::RtcpPacketParser rtcp_parser;
1005 rtcp_parser.Parse(packet, length);
1006 const std::vector<uint16_t>& nacks = rtcp_parser.nack()->packet_ids();
1007 EXPECT_TRUE(std::find(nacks.begin(), nacks.end(),
1008 ulpfec_sequence_number_) == nacks.end())
1009 << "Got nack for ULPFEC packet";
1010 if (!nacks.empty() &&
1011 IsNewerSequenceNumber(nacks.back(), ulpfec_sequence_number_)) {
1012 observation_complete_.Set();
1013 }
1014 }
1015 return SEND_PACKET;
1016 }
1017
1018 test::PacketTransport* CreateSendTransport(
1019 test::SingleThreadedTaskQueueForTesting* task_queue,
1020 Call* sender_call) override {
1021 // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
1022 // Configure some network delay.
1023 const int kNetworkDelayMs = 50;
1024 FakeNetworkPipe::Config config;
1025 config.queue_delay_ms = kNetworkDelayMs;
1026 return new test::PacketTransport(task_queue, sender_call, this,
1027 test::PacketTransport::kSender,
1028 payload_type_map_, config);
1029 }
1030
1031 // TODO(holmer): Investigate why we don't send FEC packets when the bitrate
1032 // is 10 kbps.
1033 Call::Config GetSenderCallConfig() override {
1034 Call::Config config(event_log_.get());
1035 const int kMinBitrateBps = 30000;
1036 config.bitrate_config.min_bitrate_bps = kMinBitrateBps;
1037 return config;
1038 }
1039
1040 void ModifyVideoConfigs(
1041 VideoSendStream::Config* send_config,
1042 std::vector<VideoReceiveStream::Config>* receive_configs,
1043 VideoEncoderConfig* encoder_config) override {
1044 // Configure hybrid NACK/FEC.
1045 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1046 send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
1047 send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
1048 // Set codec to VP8, otherwise NACK/FEC hybrid will be disabled.
1049 send_config->encoder_settings.encoder = encoder_.get();
1050 send_config->encoder_settings.payload_name = "VP8";
1051 send_config->encoder_settings.payload_type = kFakeVideoSendPayloadType;
1052
1053 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1054 (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
1055 (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
1056
1057 (*receive_configs)[0].decoders.resize(1);
1058 (*receive_configs)[0].decoders[0].payload_type =
1059 send_config->encoder_settings.payload_type;
1060 (*receive_configs)[0].decoders[0].payload_name =
1061 send_config->encoder_settings.payload_name;
1062 (*receive_configs)[0].decoders[0].decoder = decoder_.get();
1063 }
1064
1065 void PerformTest() override {
1066 EXPECT_TRUE(Wait())
1067 << "Timed out while waiting for FEC packets to be received.";
1068 }
1069
1070 enum {
1071 kFirstPacket,
1072 kDropEveryOtherPacketUntilUlpfec,
1073 kDropAllMediaPacketsUntilUlpfec,
1074 kDropOneMediaPacket,
1075 kPassOneMediaPacket,
1076 kVerifyUlpfecPacketNotInNackList,
1077 } state_;
1078
1079 rtc::CriticalSection crit_;
1080 uint16_t ulpfec_sequence_number_ RTC_GUARDED_BY(&crit_);
1081 bool has_last_sequence_number_;
1082 uint16_t last_sequence_number_;
1083 std::unique_ptr<webrtc::VideoEncoder> encoder_;
1084 std::unique_ptr<webrtc::VideoDecoder> decoder_;
1085 } test;
1086
1087 RunBaseTest(&test);
1088 }
1089
1090 // This test drops second RTP packet with a marker bit set, makes sure it's
1091 // retransmitted and renders. Retransmission SSRCs are also checked.
DecodesRetransmittedFrame(bool enable_rtx,bool enable_red)1092 void EndToEndTest::DecodesRetransmittedFrame(bool enable_rtx, bool enable_red) {
1093 static const int kDroppedFrameNumber = 10;
1094 class RetransmissionObserver : public test::EndToEndTest,
1095 public rtc::VideoSinkInterface<VideoFrame> {
1096 public:
1097 RetransmissionObserver(bool enable_rtx, bool enable_red)
1098 : EndToEndTest(kDefaultTimeoutMs),
1099 payload_type_(GetPayloadType(false, enable_red)),
1100 retransmission_ssrc_(enable_rtx ? kSendRtxSsrcs[0]
1101 : kVideoSendSsrcs[0]),
1102 retransmission_payload_type_(GetPayloadType(enable_rtx, enable_red)),
1103 encoder_(VP8Encoder::Create()),
1104 marker_bits_observed_(0),
1105 retransmitted_timestamp_(0) {}
1106
1107 private:
1108 Action OnSendRtp(const uint8_t* packet, size_t length) override {
1109 rtc::CritScope lock(&crit_);
1110 RTPHeader header;
1111 EXPECT_TRUE(parser_->Parse(packet, length, &header));
1112
1113 // Ignore padding-only packets over RTX.
1114 if (header.payloadType != payload_type_) {
1115 EXPECT_EQ(retransmission_ssrc_, header.ssrc);
1116 if (length == header.headerLength + header.paddingLength)
1117 return SEND_PACKET;
1118 }
1119
1120 if (header.timestamp == retransmitted_timestamp_) {
1121 EXPECT_EQ(retransmission_ssrc_, header.ssrc);
1122 EXPECT_EQ(retransmission_payload_type_, header.payloadType);
1123 return SEND_PACKET;
1124 }
1125
1126 // Found the final packet of the frame to inflict loss to, drop this and
1127 // expect a retransmission.
1128 if (header.payloadType == payload_type_ && header.markerBit &&
1129 ++marker_bits_observed_ == kDroppedFrameNumber) {
1130 // This should be the only dropped packet.
1131 EXPECT_EQ(0u, retransmitted_timestamp_);
1132 retransmitted_timestamp_ = header.timestamp;
1133 if (std::find(rendered_timestamps_.begin(), rendered_timestamps_.end(),
1134 retransmitted_timestamp_) != rendered_timestamps_.end()) {
1135 // Frame was rendered before last packet was scheduled for sending.
1136 // This is extremly rare but possible scenario because prober able to
1137 // resend packet before it was send.
1138 // TODO(danilchap): Remove this corner case when prober would not be
1139 // able to sneak in between packet saved to history for resending and
1140 // pacer notified about existance of that packet for sending.
1141 // See https://bugs.chromium.org/p/webrtc/issues/detail?id=5540 for
1142 // details.
1143 observation_complete_.Set();
1144 }
1145 return DROP_PACKET;
1146 }
1147
1148 return SEND_PACKET;
1149 }
1150
1151 void OnFrame(const VideoFrame& frame) override {
1152 EXPECT_EQ(kVideoRotation_90, frame.rotation());
1153 {
1154 rtc::CritScope lock(&crit_);
1155 if (frame.timestamp() == retransmitted_timestamp_)
1156 observation_complete_.Set();
1157 rendered_timestamps_.push_back(frame.timestamp());
1158 }
1159 orig_renderer_->OnFrame(frame);
1160 }
1161
1162 void ModifyVideoConfigs(
1163 VideoSendStream::Config* send_config,
1164 std::vector<VideoReceiveStream::Config>* receive_configs,
1165 VideoEncoderConfig* encoder_config) override {
1166 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1167
1168 // Insert ourselves into the rendering pipeline.
1169 RTC_DCHECK(!orig_renderer_);
1170 orig_renderer_ = (*receive_configs)[0].renderer;
1171 RTC_DCHECK(orig_renderer_);
1172 (*receive_configs)[0].disable_prerenderer_smoothing = true;
1173 (*receive_configs)[0].renderer = this;
1174
1175 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1176
1177 if (payload_type_ == kRedPayloadType) {
1178 send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
1179 send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
1180 if (retransmission_ssrc_ == kSendRtxSsrcs[0])
1181 send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType;
1182 (*receive_configs)[0].rtp.ulpfec_payload_type =
1183 send_config->rtp.ulpfec.ulpfec_payload_type;
1184 (*receive_configs)[0].rtp.red_payload_type =
1185 send_config->rtp.ulpfec.red_payload_type;
1186 }
1187
1188 if (retransmission_ssrc_ == kSendRtxSsrcs[0]) {
1189 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
1190 send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
1191 (*receive_configs)[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
1192 (*receive_configs)[0]
1193 .rtp.rtx_associated_payload_types[(payload_type_ == kRedPayloadType)
1194 ? kRtxRedPayloadType
1195 : kSendRtxPayloadType] =
1196 payload_type_;
1197 }
1198 // Configure encoding and decoding with VP8, since generic packetization
1199 // doesn't support FEC with NACK.
1200 RTC_DCHECK_EQ(1, (*receive_configs)[0].decoders.size());
1201 send_config->encoder_settings.encoder = encoder_.get();
1202 send_config->encoder_settings.payload_name = "VP8";
1203 (*receive_configs)[0].decoders[0].payload_name = "VP8";
1204 }
1205
1206 void OnFrameGeneratorCapturerCreated(
1207 test::FrameGeneratorCapturer* frame_generator_capturer) override {
1208 frame_generator_capturer->SetFakeRotation(kVideoRotation_90);
1209 }
1210
1211 void PerformTest() override {
1212 EXPECT_TRUE(Wait())
1213 << "Timed out while waiting for retransmission to render.";
1214 }
1215
1216 int GetPayloadType(bool use_rtx, bool use_fec) {
1217 if (use_fec) {
1218 if (use_rtx)
1219 return kRtxRedPayloadType;
1220 return kRedPayloadType;
1221 }
1222 if (use_rtx)
1223 return kSendRtxPayloadType;
1224 return kFakeVideoSendPayloadType;
1225 }
1226
1227 rtc::CriticalSection crit_;
1228 rtc::VideoSinkInterface<VideoFrame>* orig_renderer_ = nullptr;
1229 const int payload_type_;
1230 const uint32_t retransmission_ssrc_;
1231 const int retransmission_payload_type_;
1232 std::unique_ptr<VideoEncoder> encoder_;
1233 const std::string payload_name_;
1234 int marker_bits_observed_;
1235 uint32_t retransmitted_timestamp_ RTC_GUARDED_BY(&crit_);
1236 std::vector<uint32_t> rendered_timestamps_ RTC_GUARDED_BY(&crit_);
1237 } test(enable_rtx, enable_red);
1238
1239 RunBaseTest(&test);
1240 }
1241
TEST_P(EndToEndTest,DecodesRetransmittedFrame)1242 TEST_P(EndToEndTest, DecodesRetransmittedFrame) {
1243 DecodesRetransmittedFrame(false, false);
1244 }
1245
TEST_P(EndToEndTest,DecodesRetransmittedFrameOverRtx)1246 TEST_P(EndToEndTest, DecodesRetransmittedFrameOverRtx) {
1247 DecodesRetransmittedFrame(true, false);
1248 }
1249
TEST_P(EndToEndTest,DecodesRetransmittedFrameByRed)1250 TEST_P(EndToEndTest, DecodesRetransmittedFrameByRed) {
1251 DecodesRetransmittedFrame(false, true);
1252 }
1253
TEST_P(EndToEndTest,DecodesRetransmittedFrameByRedOverRtx)1254 TEST_P(EndToEndTest, DecodesRetransmittedFrameByRedOverRtx) {
1255 DecodesRetransmittedFrame(true, true);
1256 }
1257
ReceivesPliAndRecovers(int rtp_history_ms)1258 void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
1259 static const int kPacketsToDrop = 1;
1260
1261 class PliObserver : public test::EndToEndTest,
1262 public rtc::VideoSinkInterface<VideoFrame> {
1263 public:
1264 explicit PliObserver(int rtp_history_ms)
1265 : EndToEndTest(kLongTimeoutMs),
1266 rtp_history_ms_(rtp_history_ms),
1267 nack_enabled_(rtp_history_ms > 0),
1268 highest_dropped_timestamp_(0),
1269 frames_to_drop_(0),
1270 received_pli_(false) {}
1271
1272 private:
1273 Action OnSendRtp(const uint8_t* packet, size_t length) override {
1274 rtc::CritScope lock(&crit_);
1275 RTPHeader header;
1276 EXPECT_TRUE(parser_->Parse(packet, length, &header));
1277
1278 // Drop all retransmitted packets to force a PLI.
1279 if (header.timestamp <= highest_dropped_timestamp_)
1280 return DROP_PACKET;
1281
1282 if (frames_to_drop_ > 0) {
1283 highest_dropped_timestamp_ = header.timestamp;
1284 --frames_to_drop_;
1285 return DROP_PACKET;
1286 }
1287
1288 return SEND_PACKET;
1289 }
1290
1291 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
1292 rtc::CritScope lock(&crit_);
1293 test::RtcpPacketParser parser;
1294 EXPECT_TRUE(parser.Parse(packet, length));
1295 if (!nack_enabled_)
1296 EXPECT_EQ(0, parser.nack()->num_packets());
1297 if (parser.pli()->num_packets() > 0)
1298 received_pli_ = true;
1299 return SEND_PACKET;
1300 }
1301
1302 void OnFrame(const VideoFrame& video_frame) override {
1303 rtc::CritScope lock(&crit_);
1304 if (received_pli_ &&
1305 video_frame.timestamp() > highest_dropped_timestamp_) {
1306 observation_complete_.Set();
1307 }
1308 if (!received_pli_)
1309 frames_to_drop_ = kPacketsToDrop;
1310 }
1311
1312 void ModifyVideoConfigs(
1313 VideoSendStream::Config* send_config,
1314 std::vector<VideoReceiveStream::Config>* receive_configs,
1315 VideoEncoderConfig* encoder_config) override {
1316 send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
1317 (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
1318 (*receive_configs)[0].renderer = this;
1319 }
1320
1321 void PerformTest() override {
1322 EXPECT_TRUE(Wait()) << "Timed out waiting for PLI to be "
1323 "received and a frame to be "
1324 "rendered afterwards.";
1325 }
1326
1327 rtc::CriticalSection crit_;
1328 int rtp_history_ms_;
1329 bool nack_enabled_;
1330 uint32_t highest_dropped_timestamp_ RTC_GUARDED_BY(&crit_);
1331 int frames_to_drop_ RTC_GUARDED_BY(&crit_);
1332 bool received_pli_ RTC_GUARDED_BY(&crit_);
1333 } test(rtp_history_ms);
1334
1335 RunBaseTest(&test);
1336 }
1337
TEST_P(EndToEndTest,ReceivesPliAndRecoversWithNack)1338 TEST_P(EndToEndTest, ReceivesPliAndRecoversWithNack) {
1339 ReceivesPliAndRecovers(1000);
1340 }
1341
TEST_P(EndToEndTest,ReceivesPliAndRecoversWithoutNack)1342 TEST_P(EndToEndTest, ReceivesPliAndRecoversWithoutNack) {
1343 ReceivesPliAndRecovers(0);
1344 }
1345
TEST_P(EndToEndTest,UnknownRtpPacketGivesUnknownSsrcReturnCode)1346 TEST_P(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) {
1347 class PacketInputObserver : public PacketReceiver {
1348 public:
1349 explicit PacketInputObserver(PacketReceiver* receiver)
1350 : receiver_(receiver), delivered_packet_(false, false) {}
1351
1352 bool Wait() { return delivered_packet_.Wait(kDefaultTimeoutMs); }
1353
1354 private:
1355 DeliveryStatus DeliverPacket(MediaType media_type,
1356 const uint8_t* packet,
1357 size_t length,
1358 const PacketTime& packet_time) override {
1359 if (RtpHeaderParser::IsRtcp(packet, length)) {
1360 return receiver_->DeliverPacket(media_type, packet, length,
1361 packet_time);
1362 } else {
1363 DeliveryStatus delivery_status =
1364 receiver_->DeliverPacket(media_type, packet, length, packet_time);
1365 EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status);
1366 delivered_packet_.Set();
1367 return delivery_status;
1368 }
1369 }
1370
1371 PacketReceiver* receiver_;
1372 rtc::Event delivered_packet_;
1373 };
1374
1375 std::unique_ptr<test::DirectTransport> send_transport;
1376 std::unique_ptr<test::DirectTransport> receive_transport;
1377 std::unique_ptr<PacketInputObserver> input_observer;
1378
1379 task_queue_.SendTask([this, &send_transport, &receive_transport,
1380 &input_observer]() {
1381 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
1382
1383 send_transport = rtc::MakeUnique<test::DirectTransport>(
1384 &task_queue_, sender_call_.get(), payload_type_map_);
1385 receive_transport = rtc::MakeUnique<test::DirectTransport>(
1386 &task_queue_, receiver_call_.get(), payload_type_map_);
1387 input_observer =
1388 rtc::MakeUnique<PacketInputObserver>(receiver_call_->Receiver());
1389 send_transport->SetReceiver(input_observer.get());
1390 receive_transport->SetReceiver(sender_call_->Receiver());
1391
1392 CreateSendConfig(1, 0, 0, send_transport.get());
1393 CreateMatchingReceiveConfigs(receive_transport.get());
1394
1395 CreateVideoStreams();
1396 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
1397 kDefaultHeight);
1398 Start();
1399
1400 receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
1401 video_receive_streams_.clear();
1402 });
1403
1404 // Wait() waits for a received packet.
1405 EXPECT_TRUE(input_observer->Wait());
1406
1407 task_queue_.SendTask([this, &send_transport, &receive_transport]() {
1408 Stop();
1409 DestroyStreams();
1410 send_transport.reset();
1411 receive_transport.reset();
1412 DestroyCalls();
1413 });
1414 }
1415
RespectsRtcpMode(RtcpMode rtcp_mode)1416 void EndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
1417 static const int kNumCompoundRtcpPacketsToObserve = 10;
1418 class RtcpModeObserver : public test::EndToEndTest {
1419 public:
1420 explicit RtcpModeObserver(RtcpMode rtcp_mode)
1421 : EndToEndTest(kDefaultTimeoutMs),
1422 rtcp_mode_(rtcp_mode),
1423 sent_rtp_(0),
1424 sent_rtcp_(0) {}
1425
1426 private:
1427 Action OnSendRtp(const uint8_t* packet, size_t length) override {
1428 rtc::CritScope lock(&crit_);
1429 if (++sent_rtp_ % 3 == 0)
1430 return DROP_PACKET;
1431
1432 return SEND_PACKET;
1433 }
1434
1435 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
1436 rtc::CritScope lock(&crit_);
1437 ++sent_rtcp_;
1438 test::RtcpPacketParser parser;
1439 EXPECT_TRUE(parser.Parse(packet, length));
1440
1441 EXPECT_EQ(0, parser.sender_report()->num_packets());
1442
1443 switch (rtcp_mode_) {
1444 case RtcpMode::kCompound:
1445 // TODO(holmer): We shouldn't send transport feedback alone if
1446 // compound RTCP is negotiated.
1447 if (parser.receiver_report()->num_packets() == 0 &&
1448 parser.transport_feedback()->num_packets() == 0) {
1449 ADD_FAILURE() << "Received RTCP packet without receiver report for "
1450 "RtcpMode::kCompound.";
1451 observation_complete_.Set();
1452 }
1453
1454 if (sent_rtcp_ >= kNumCompoundRtcpPacketsToObserve)
1455 observation_complete_.Set();
1456
1457 break;
1458 case RtcpMode::kReducedSize:
1459 if (parser.receiver_report()->num_packets() == 0)
1460 observation_complete_.Set();
1461 break;
1462 case RtcpMode::kOff:
1463 RTC_NOTREACHED();
1464 break;
1465 }
1466
1467 return SEND_PACKET;
1468 }
1469
1470 void ModifyVideoConfigs(
1471 VideoSendStream::Config* send_config,
1472 std::vector<VideoReceiveStream::Config>* receive_configs,
1473 VideoEncoderConfig* encoder_config) override {
1474 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1475 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1476 (*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
1477 }
1478
1479 void PerformTest() override {
1480 EXPECT_TRUE(Wait())
1481 << (rtcp_mode_ == RtcpMode::kCompound
1482 ? "Timed out before observing enough compound packets."
1483 : "Timed out before receiving a non-compound RTCP packet.");
1484 }
1485
1486 RtcpMode rtcp_mode_;
1487 rtc::CriticalSection crit_;
1488 // Must be protected since RTCP can be sent by both the process thread
1489 // and the pacer thread.
1490 int sent_rtp_ RTC_GUARDED_BY(&crit_);
1491 int sent_rtcp_ RTC_GUARDED_BY(&crit_);
1492 } test(rtcp_mode);
1493
1494 RunBaseTest(&test);
1495 }
1496
TEST_P(EndToEndTest,UsesRtcpCompoundMode)1497 TEST_P(EndToEndTest, UsesRtcpCompoundMode) {
1498 RespectsRtcpMode(RtcpMode::kCompound);
1499 }
1500
TEST_P(EndToEndTest,UsesRtcpReducedSizeMode)1501 TEST_P(EndToEndTest, UsesRtcpReducedSizeMode) {
1502 RespectsRtcpMode(RtcpMode::kReducedSize);
1503 }
1504
1505 // Test sets up a Call multiple senders with different resolutions and SSRCs.
1506 // Another is set up to receive all three of these with different renderers.
1507 class MultiStreamTest {
1508 public:
1509 static constexpr size_t kNumStreams = 3;
1510 const uint8_t kVideoPayloadType = 124;
1511 const std::map<uint8_t, MediaType> payload_type_map_ = {
1512 {kVideoPayloadType, MediaType::VIDEO}};
1513
1514 struct CodecSettings {
1515 uint32_t ssrc;
1516 int width;
1517 int height;
1518 } codec_settings[kNumStreams];
1519
MultiStreamTest(test::SingleThreadedTaskQueueForTesting * task_queue)1520 explicit MultiStreamTest(test::SingleThreadedTaskQueueForTesting* task_queue)
1521 : task_queue_(task_queue) {
1522 // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
1523 codec_settings[0] = {1, 640, 480};
1524 codec_settings[1] = {2, 320, 240};
1525 codec_settings[2] = {3, 240, 160};
1526 }
1527
~MultiStreamTest()1528 virtual ~MultiStreamTest() {}
1529
RunTest()1530 void RunTest() {
1531 webrtc::RtcEventLogNullImpl event_log;
1532 Call::Config config(&event_log);
1533 std::unique_ptr<Call> sender_call;
1534 std::unique_ptr<Call> receiver_call;
1535 std::unique_ptr<test::DirectTransport> sender_transport;
1536 std::unique_ptr<test::DirectTransport> receiver_transport;
1537
1538 VideoSendStream* send_streams[kNumStreams];
1539 VideoReceiveStream* receive_streams[kNumStreams];
1540 test::FrameGeneratorCapturer* frame_generators[kNumStreams];
1541 std::vector<std::unique_ptr<VideoDecoder>> allocated_decoders;
1542 std::unique_ptr<VideoEncoder> encoders[kNumStreams];
1543
1544 task_queue_->SendTask([&]() {
1545 sender_call = rtc::WrapUnique(Call::Create(config));
1546 receiver_call = rtc::WrapUnique(Call::Create(config));
1547 sender_transport =
1548 rtc::WrapUnique(CreateSendTransport(task_queue_, sender_call.get()));
1549 receiver_transport = rtc::WrapUnique(
1550 CreateReceiveTransport(task_queue_, receiver_call.get()));
1551
1552 sender_transport->SetReceiver(receiver_call->Receiver());
1553 receiver_transport->SetReceiver(sender_call->Receiver());
1554
1555 for (size_t i = 0; i < kNumStreams; ++i)
1556 encoders[i] = VP8Encoder::Create();
1557
1558 for (size_t i = 0; i < kNumStreams; ++i) {
1559 uint32_t ssrc = codec_settings[i].ssrc;
1560 int width = codec_settings[i].width;
1561 int height = codec_settings[i].height;
1562
1563 VideoSendStream::Config send_config(sender_transport.get());
1564 send_config.rtp.ssrcs.push_back(ssrc);
1565 send_config.encoder_settings.encoder = encoders[i].get();
1566 send_config.encoder_settings.payload_name = "VP8";
1567 send_config.encoder_settings.payload_type = kVideoPayloadType;
1568 VideoEncoderConfig encoder_config;
1569 test::FillEncoderConfiguration(1, &encoder_config);
1570 encoder_config.max_bitrate_bps = 100000;
1571
1572 UpdateSendConfig(i, &send_config, &encoder_config,
1573 &frame_generators[i]);
1574
1575 send_streams[i] = sender_call->CreateVideoSendStream(
1576 send_config.Copy(), encoder_config.Copy());
1577 send_streams[i]->Start();
1578
1579 VideoReceiveStream::Config receive_config(receiver_transport.get());
1580 receive_config.rtp.remote_ssrc = ssrc;
1581 receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc;
1582 VideoReceiveStream::Decoder decoder =
1583 test::CreateMatchingDecoder(send_config.encoder_settings);
1584 allocated_decoders.push_back(
1585 std::unique_ptr<VideoDecoder>(decoder.decoder));
1586 receive_config.decoders.push_back(decoder);
1587
1588 UpdateReceiveConfig(i, &receive_config);
1589
1590 receive_streams[i] =
1591 receiver_call->CreateVideoReceiveStream(std::move(receive_config));
1592 receive_streams[i]->Start();
1593
1594 frame_generators[i] = test::FrameGeneratorCapturer::Create(
1595 width, height, 30, Clock::GetRealTimeClock());
1596 send_streams[i]->SetSource(
1597 frame_generators[i],
1598 VideoSendStream::DegradationPreference::kMaintainFramerate);
1599 frame_generators[i]->Start();
1600 }
1601 });
1602
1603 Wait();
1604
1605 task_queue_->SendTask([&]() {
1606 for (size_t i = 0; i < kNumStreams; ++i) {
1607 frame_generators[i]->Stop();
1608 sender_call->DestroyVideoSendStream(send_streams[i]);
1609 receiver_call->DestroyVideoReceiveStream(receive_streams[i]);
1610 delete frame_generators[i];
1611 }
1612
1613 sender_transport.reset();
1614 receiver_transport.reset();
1615
1616 sender_call.reset();
1617 receiver_call.reset();
1618 });
1619 }
1620
1621 protected:
1622 virtual void Wait() = 0;
1623 // Note: frame_generator is a point-to-pointer, since the actual instance
1624 // hasn't been created at the time of this call. Only when packets/frames
1625 // start flowing should this be dereferenced.
UpdateSendConfig(size_t stream_index,VideoSendStream::Config * send_config,VideoEncoderConfig * encoder_config,test::FrameGeneratorCapturer ** frame_generator)1626 virtual void UpdateSendConfig(
1627 size_t stream_index,
1628 VideoSendStream::Config* send_config,
1629 VideoEncoderConfig* encoder_config,
1630 test::FrameGeneratorCapturer** frame_generator) {}
UpdateReceiveConfig(size_t stream_index,VideoReceiveStream::Config * receive_config)1631 virtual void UpdateReceiveConfig(size_t stream_index,
1632 VideoReceiveStream::Config* receive_config) {
1633 }
CreateSendTransport(test::SingleThreadedTaskQueueForTesting * task_queue,Call * sender_call)1634 virtual test::DirectTransport* CreateSendTransport(
1635 test::SingleThreadedTaskQueueForTesting* task_queue,
1636 Call* sender_call) {
1637 return new test::DirectTransport(task_queue, sender_call,
1638 payload_type_map_);
1639 }
CreateReceiveTransport(test::SingleThreadedTaskQueueForTesting * task_queue,Call * receiver_call)1640 virtual test::DirectTransport* CreateReceiveTransport(
1641 test::SingleThreadedTaskQueueForTesting* task_queue,
1642 Call* receiver_call) {
1643 return new test::DirectTransport(task_queue, receiver_call,
1644 payload_type_map_);
1645 }
1646
1647 test::SingleThreadedTaskQueueForTesting* const task_queue_;
1648 };
1649
1650 // Each renderer verifies that it receives the expected resolution, and as soon
1651 // as every renderer has received a frame, the test finishes.
TEST_P(EndToEndTest,SendsAndReceivesMultipleStreams)1652 TEST_P(EndToEndTest, SendsAndReceivesMultipleStreams) {
1653 class VideoOutputObserver : public rtc::VideoSinkInterface<VideoFrame> {
1654 public:
1655 VideoOutputObserver(const MultiStreamTest::CodecSettings& settings,
1656 uint32_t ssrc,
1657 test::FrameGeneratorCapturer** frame_generator)
1658 : settings_(settings),
1659 ssrc_(ssrc),
1660 frame_generator_(frame_generator),
1661 done_(false, false) {}
1662
1663 void OnFrame(const VideoFrame& video_frame) override {
1664 EXPECT_EQ(settings_.width, video_frame.width());
1665 EXPECT_EQ(settings_.height, video_frame.height());
1666 (*frame_generator_)->Stop();
1667 done_.Set();
1668 }
1669
1670 uint32_t Ssrc() { return ssrc_; }
1671
1672 bool Wait() { return done_.Wait(kDefaultTimeoutMs); }
1673
1674 private:
1675 const MultiStreamTest::CodecSettings& settings_;
1676 const uint32_t ssrc_;
1677 test::FrameGeneratorCapturer** const frame_generator_;
1678 rtc::Event done_;
1679 };
1680
1681 class Tester : public MultiStreamTest {
1682 public:
1683 explicit Tester(test::SingleThreadedTaskQueueForTesting* task_queue)
1684 : MultiStreamTest(task_queue) {}
1685 virtual ~Tester() {}
1686
1687 protected:
1688 void Wait() override {
1689 for (const auto& observer : observers_) {
1690 EXPECT_TRUE(observer->Wait()) << "Time out waiting for from on ssrc "
1691 << observer->Ssrc();
1692 }
1693 }
1694
1695 void UpdateSendConfig(
1696 size_t stream_index,
1697 VideoSendStream::Config* send_config,
1698 VideoEncoderConfig* encoder_config,
1699 test::FrameGeneratorCapturer** frame_generator) override {
1700 observers_[stream_index].reset(new VideoOutputObserver(
1701 codec_settings[stream_index], send_config->rtp.ssrcs.front(),
1702 frame_generator));
1703 }
1704
1705 void UpdateReceiveConfig(
1706 size_t stream_index,
1707 VideoReceiveStream::Config* receive_config) override {
1708 receive_config->renderer = observers_[stream_index].get();
1709 }
1710
1711 private:
1712 std::unique_ptr<VideoOutputObserver> observers_[kNumStreams];
1713 } tester(&task_queue_);
1714
1715 tester.RunTest();
1716 }
1717
TEST_P(EndToEndTest,AssignsTransportSequenceNumbers)1718 TEST_P(EndToEndTest, AssignsTransportSequenceNumbers) {
1719 static const int kExtensionId = 5;
1720
1721 class RtpExtensionHeaderObserver : public test::DirectTransport {
1722 public:
1723 RtpExtensionHeaderObserver(
1724 test::SingleThreadedTaskQueueForTesting* task_queue,
1725 Call* sender_call,
1726 const uint32_t& first_media_ssrc,
1727 const std::map<uint32_t, uint32_t>& ssrc_map,
1728 const std::map<uint8_t, MediaType>& payload_type_map)
1729 : DirectTransport(task_queue, sender_call, payload_type_map),
1730 done_(false, false),
1731 parser_(RtpHeaderParser::Create()),
1732 first_media_ssrc_(first_media_ssrc),
1733 rtx_to_media_ssrcs_(ssrc_map),
1734 padding_observed_(false),
1735 rtx_padding_observed_(false),
1736 retransmit_observed_(false),
1737 started_(false) {
1738 parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
1739 kExtensionId);
1740 }
1741 virtual ~RtpExtensionHeaderObserver() {}
1742
1743 bool SendRtp(const uint8_t* data,
1744 size_t length,
1745 const PacketOptions& options) override {
1746 {
1747 rtc::CritScope cs(&lock_);
1748
1749 if (IsDone())
1750 return false;
1751
1752 if (started_) {
1753 RTPHeader header;
1754 EXPECT_TRUE(parser_->Parse(data, length, &header));
1755 bool drop_packet = false;
1756
1757 EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
1758 EXPECT_EQ(options.packet_id,
1759 header.extension.transportSequenceNumber);
1760 if (!streams_observed_.empty()) {
1761 // Unwrap packet id and verify uniqueness.
1762 int64_t packet_id = unwrapper_.Unwrap(options.packet_id);
1763 EXPECT_TRUE(received_packed_ids_.insert(packet_id).second);
1764 }
1765
1766 // Drop (up to) every 17th packet, so we get retransmits.
1767 // Only drop media, and not on the first stream (otherwise it will be
1768 // hard to distinguish from padding, which is always sent on the first
1769 // stream).
1770 if (header.payloadType != kSendRtxPayloadType &&
1771 header.ssrc != first_media_ssrc_ &&
1772 header.extension.transportSequenceNumber % 17 == 0) {
1773 dropped_seq_[header.ssrc].insert(header.sequenceNumber);
1774 drop_packet = true;
1775 }
1776
1777 if (header.payloadType == kSendRtxPayloadType) {
1778 uint16_t original_sequence_number =
1779 ByteReader<uint16_t>::ReadBigEndian(&data[header.headerLength]);
1780 uint32_t original_ssrc =
1781 rtx_to_media_ssrcs_.find(header.ssrc)->second;
1782 std::set<uint16_t>* seq_no_map = &dropped_seq_[original_ssrc];
1783 auto it = seq_no_map->find(original_sequence_number);
1784 if (it != seq_no_map->end()) {
1785 retransmit_observed_ = true;
1786 seq_no_map->erase(it);
1787 } else {
1788 rtx_padding_observed_ = true;
1789 }
1790 } else {
1791 streams_observed_.insert(header.ssrc);
1792 }
1793
1794 if (IsDone())
1795 done_.Set();
1796
1797 if (drop_packet)
1798 return true;
1799 }
1800 }
1801
1802 return test::DirectTransport::SendRtp(data, length, options);
1803 }
1804
1805 bool IsDone() {
1806 bool observed_types_ok =
1807 streams_observed_.size() == MultiStreamTest::kNumStreams &&
1808 retransmit_observed_ && rtx_padding_observed_;
1809 if (!observed_types_ok)
1810 return false;
1811 // We should not have any gaps in the sequence number range.
1812 size_t seqno_range =
1813 *received_packed_ids_.rbegin() - *received_packed_ids_.begin() + 1;
1814 return seqno_range == received_packed_ids_.size();
1815 }
1816
1817 bool Wait() {
1818 {
1819 // Can't be sure until this point that rtx_to_media_ssrcs_ etc have
1820 // been initialized and are OK to read.
1821 rtc::CritScope cs(&lock_);
1822 started_ = true;
1823 }
1824 return done_.Wait(kDefaultTimeoutMs);
1825 }
1826
1827 rtc::CriticalSection lock_;
1828 rtc::Event done_;
1829 std::unique_ptr<RtpHeaderParser> parser_;
1830 SequenceNumberUnwrapper unwrapper_;
1831 std::set<int64_t> received_packed_ids_;
1832 std::set<uint32_t> streams_observed_;
1833 std::map<uint32_t, std::set<uint16_t>> dropped_seq_;
1834 const uint32_t& first_media_ssrc_;
1835 const std::map<uint32_t, uint32_t>& rtx_to_media_ssrcs_;
1836 bool padding_observed_;
1837 bool rtx_padding_observed_;
1838 bool retransmit_observed_;
1839 bool started_;
1840 };
1841
1842 class TransportSequenceNumberTester : public MultiStreamTest {
1843 public:
1844 explicit TransportSequenceNumberTester(
1845 test::SingleThreadedTaskQueueForTesting* task_queue)
1846 : MultiStreamTest(task_queue),
1847 first_media_ssrc_(0),
1848 observer_(nullptr) {}
1849 virtual ~TransportSequenceNumberTester() {}
1850
1851 protected:
1852 void Wait() override {
1853 RTC_DCHECK(observer_);
1854 EXPECT_TRUE(observer_->Wait());
1855 }
1856
1857 void UpdateSendConfig(
1858 size_t stream_index,
1859 VideoSendStream::Config* send_config,
1860 VideoEncoderConfig* encoder_config,
1861 test::FrameGeneratorCapturer** frame_generator) override {
1862 send_config->rtp.extensions.clear();
1863 send_config->rtp.extensions.push_back(RtpExtension(
1864 RtpExtension::kTransportSequenceNumberUri, kExtensionId));
1865
1866 // Force some padding to be sent. Note that since we do send media
1867 // packets we can not guarantee that a padding only packet is sent.
1868 // Instead, padding will most likely be send as an RTX packet.
1869 const int kPaddingBitrateBps = 50000;
1870 encoder_config->max_bitrate_bps = 200000;
1871 encoder_config->min_transmit_bitrate_bps =
1872 encoder_config->max_bitrate_bps + kPaddingBitrateBps;
1873
1874 // Configure RTX for redundant payload padding.
1875 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1876 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[stream_index]);
1877 send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
1878 rtx_to_media_ssrcs_[kSendRtxSsrcs[stream_index]] =
1879 send_config->rtp.ssrcs[0];
1880
1881 if (stream_index == 0)
1882 first_media_ssrc_ = send_config->rtp.ssrcs[0];
1883 }
1884
1885 void UpdateReceiveConfig(
1886 size_t stream_index,
1887 VideoReceiveStream::Config* receive_config) override {
1888 receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
1889 receive_config->rtp.extensions.clear();
1890 receive_config->rtp.extensions.push_back(RtpExtension(
1891 RtpExtension::kTransportSequenceNumberUri, kExtensionId));
1892 receive_config->renderer = &fake_renderer_;
1893 }
1894
1895 test::DirectTransport* CreateSendTransport(
1896 test::SingleThreadedTaskQueueForTesting* task_queue,
1897 Call* sender_call) override {
1898 std::map<uint8_t, MediaType> payload_type_map =
1899 MultiStreamTest::payload_type_map_;
1900 RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) ==
1901 payload_type_map.end());
1902 payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO;
1903 observer_ = new RtpExtensionHeaderObserver(
1904 task_queue, sender_call, first_media_ssrc_, rtx_to_media_ssrcs_,
1905 payload_type_map);
1906 return observer_;
1907 }
1908
1909 private:
1910 test::FakeVideoRenderer fake_renderer_;
1911 uint32_t first_media_ssrc_;
1912 std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_;
1913 RtpExtensionHeaderObserver* observer_;
1914 } tester(&task_queue_);
1915
1916 tester.RunTest();
1917 }
1918
1919 class TransportFeedbackTester : public test::EndToEndTest {
1920 public:
TransportFeedbackTester(bool feedback_enabled,size_t num_video_streams,size_t num_audio_streams)1921 TransportFeedbackTester(bool feedback_enabled,
1922 size_t num_video_streams,
1923 size_t num_audio_streams)
1924 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs),
1925 feedback_enabled_(feedback_enabled),
1926 num_video_streams_(num_video_streams),
1927 num_audio_streams_(num_audio_streams),
1928 receiver_call_(nullptr) {
1929 // Only one stream of each supported for now.
1930 EXPECT_LE(num_video_streams, 1u);
1931 EXPECT_LE(num_audio_streams, 1u);
1932 }
1933
1934 protected:
OnSendRtcp(const uint8_t * data,size_t length)1935 Action OnSendRtcp(const uint8_t* data, size_t length) override {
1936 EXPECT_FALSE(HasTransportFeedback(data, length));
1937 return SEND_PACKET;
1938 }
1939
OnReceiveRtcp(const uint8_t * data,size_t length)1940 Action OnReceiveRtcp(const uint8_t* data, size_t length) override {
1941 if (HasTransportFeedback(data, length))
1942 observation_complete_.Set();
1943 return SEND_PACKET;
1944 }
1945
HasTransportFeedback(const uint8_t * data,size_t length) const1946 bool HasTransportFeedback(const uint8_t* data, size_t length) const {
1947 test::RtcpPacketParser parser;
1948 EXPECT_TRUE(parser.Parse(data, length));
1949 return parser.transport_feedback()->num_packets() > 0;
1950 }
1951
PerformTest()1952 void PerformTest() override {
1953 const int64_t kDisabledFeedbackTimeoutMs = 5000;
1954 EXPECT_EQ(feedback_enabled_,
1955 observation_complete_.Wait(feedback_enabled_
1956 ? test::CallTest::kDefaultTimeoutMs
1957 : kDisabledFeedbackTimeoutMs));
1958 }
1959
OnCallsCreated(Call * sender_call,Call * receiver_call)1960 void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
1961 receiver_call_ = receiver_call;
1962 }
1963
GetNumVideoStreams() const1964 size_t GetNumVideoStreams() const override { return num_video_streams_; }
GetNumAudioStreams() const1965 size_t GetNumAudioStreams() const override { return num_audio_streams_; }
1966
ModifyVideoConfigs(VideoSendStream::Config * send_config,std::vector<VideoReceiveStream::Config> * receive_configs,VideoEncoderConfig * encoder_config)1967 void ModifyVideoConfigs(
1968 VideoSendStream::Config* send_config,
1969 std::vector<VideoReceiveStream::Config>* receive_configs,
1970 VideoEncoderConfig* encoder_config) override {
1971 (*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
1972 }
1973
ModifyAudioConfigs(AudioSendStream::Config * send_config,std::vector<AudioReceiveStream::Config> * receive_configs)1974 void ModifyAudioConfigs(
1975 AudioSendStream::Config* send_config,
1976 std::vector<AudioReceiveStream::Config>* receive_configs) override {
1977 send_config->rtp.extensions.clear();
1978 send_config->rtp.extensions.push_back(
1979 RtpExtension(RtpExtension::kTransportSequenceNumberUri, kExtensionId));
1980 (*receive_configs)[0].rtp.extensions.clear();
1981 (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
1982 (*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
1983 }
1984
1985 private:
1986 static const int kExtensionId = 5;
1987 const bool feedback_enabled_;
1988 const size_t num_video_streams_;
1989 const size_t num_audio_streams_;
1990 Call* receiver_call_;
1991 };
1992
TEST_P(EndToEndTest,VideoReceivesTransportFeedback)1993 TEST_P(EndToEndTest, VideoReceivesTransportFeedback) {
1994 TransportFeedbackTester test(true, 1, 0);
1995 RunBaseTest(&test);
1996 }
1997
TEST_P(EndToEndTest,VideoTransportFeedbackNotConfigured)1998 TEST_P(EndToEndTest, VideoTransportFeedbackNotConfigured) {
1999 TransportFeedbackTester test(false, 1, 0);
2000 RunBaseTest(&test);
2001 }
2002
TEST_P(EndToEndTest,AudioReceivesTransportFeedback)2003 TEST_P(EndToEndTest, AudioReceivesTransportFeedback) {
2004 TransportFeedbackTester test(true, 0, 1);
2005 RunBaseTest(&test);
2006 }
2007
TEST_P(EndToEndTest,AudioTransportFeedbackNotConfigured)2008 TEST_P(EndToEndTest, AudioTransportFeedbackNotConfigured) {
2009 TransportFeedbackTester test(false, 0, 1);
2010 RunBaseTest(&test);
2011 }
2012
TEST_P(EndToEndTest,AudioVideoReceivesTransportFeedback)2013 TEST_P(EndToEndTest, AudioVideoReceivesTransportFeedback) {
2014 TransportFeedbackTester test(true, 1, 1);
2015 RunBaseTest(&test);
2016 }
2017
TEST_P(EndToEndTest,StopsSendingMediaWithoutFeedback)2018 TEST_P(EndToEndTest, StopsSendingMediaWithoutFeedback) {
2019 test::ScopedFieldTrials override_field_trials(
2020 "WebRTC-CwndExperiment/Enabled-250/");
2021
2022 class TransportFeedbackTester : public test::EndToEndTest {
2023 public:
2024 TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams)
2025 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs),
2026 num_video_streams_(num_video_streams),
2027 num_audio_streams_(num_audio_streams),
2028 media_sent_(0),
2029 padding_sent_(0) {
2030 // Only one stream of each supported for now.
2031 EXPECT_LE(num_video_streams, 1u);
2032 EXPECT_LE(num_audio_streams, 1u);
2033 }
2034
2035 protected:
2036 Action OnSendRtp(const uint8_t* packet, size_t length) override {
2037 RTPHeader header;
2038 EXPECT_TRUE(parser_->Parse(packet, length, &header));
2039 const bool only_padding =
2040 header.headerLength + header.paddingLength == length;
2041 rtc::CritScope lock(&crit_);
2042 if (only_padding) {
2043 ++padding_sent_;
2044 } else {
2045 ++media_sent_;
2046 EXPECT_LT(media_sent_, 40) << "Media sent without feedback.";
2047 }
2048
2049 return SEND_PACKET;
2050 }
2051
2052 Action OnReceiveRtcp(const uint8_t* data, size_t length) override {
2053 rtc::CritScope lock(&crit_);
2054 if (media_sent_ > 20 && HasTransportFeedback(data, length)) {
2055 return DROP_PACKET;
2056 }
2057 return SEND_PACKET;
2058 }
2059
2060 bool HasTransportFeedback(const uint8_t* data, size_t length) const {
2061 test::RtcpPacketParser parser;
2062 EXPECT_TRUE(parser.Parse(data, length));
2063 return parser.transport_feedback()->num_packets() > 0;
2064 }
2065
2066 Call::Config GetSenderCallConfig() override {
2067 Call::Config config = EndToEndTest::GetSenderCallConfig();
2068 config.bitrate_config.max_bitrate_bps = 300000;
2069 return config;
2070 }
2071
2072 void PerformTest() override {
2073 const int64_t kDisabledFeedbackTimeoutMs = 10000;
2074 observation_complete_.Wait(kDisabledFeedbackTimeoutMs);
2075 rtc::CritScope lock(&crit_);
2076 EXPECT_GT(padding_sent_, 0);
2077 }
2078
2079 size_t GetNumVideoStreams() const override { return num_video_streams_; }
2080 size_t GetNumAudioStreams() const override { return num_audio_streams_; }
2081
2082 private:
2083 const size_t num_video_streams_;
2084 const size_t num_audio_streams_;
2085 rtc::CriticalSection crit_;
2086 int media_sent_ RTC_GUARDED_BY(crit_);
2087 int padding_sent_ RTC_GUARDED_BY(crit_);
2088 } test(1, 0);
2089 RunBaseTest(&test);
2090 }
2091
TEST_P(EndToEndTest,ObserversEncodedFrames)2092 TEST_P(EndToEndTest, ObserversEncodedFrames) {
2093 class EncodedFrameTestObserver : public EncodedFrameObserver {
2094 public:
2095 EncodedFrameTestObserver()
2096 : length_(0), frame_type_(kEmptyFrame), called_(false, false) {}
2097 virtual ~EncodedFrameTestObserver() {}
2098
2099 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
2100 frame_type_ = encoded_frame.frame_type_;
2101 length_ = encoded_frame.length_;
2102 buffer_.reset(new uint8_t[length_]);
2103 memcpy(buffer_.get(), encoded_frame.data_, length_);
2104 called_.Set();
2105 }
2106
2107 bool Wait() { return called_.Wait(kDefaultTimeoutMs); }
2108
2109 void ExpectEqualFrames(const EncodedFrameTestObserver& observer) {
2110 ASSERT_EQ(length_, observer.length_)
2111 << "Observed frames are of different lengths.";
2112 EXPECT_EQ(frame_type_, observer.frame_type_)
2113 << "Observed frames have different frame types.";
2114 EXPECT_EQ(0, memcmp(buffer_.get(), observer.buffer_.get(), length_))
2115 << "Observed encoded frames have different content.";
2116 }
2117
2118 private:
2119 std::unique_ptr<uint8_t[]> buffer_;
2120 size_t length_;
2121 FrameType frame_type_;
2122 rtc::Event called_;
2123 };
2124
2125 EncodedFrameTestObserver post_encode_observer;
2126 EncodedFrameTestObserver pre_decode_observer;
2127 test::FrameForwarder forwarder;
2128 std::unique_ptr<test::FrameGenerator> frame_generator;
2129
2130 std::unique_ptr<test::DirectTransport> sender_transport;
2131 std::unique_ptr<test::DirectTransport> receiver_transport;
2132
2133 task_queue_.SendTask([&]() {
2134 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
2135
2136 sender_transport = rtc::MakeUnique<test::DirectTransport>(
2137 &task_queue_, sender_call_.get(), payload_type_map_);
2138 receiver_transport = rtc::MakeUnique<test::DirectTransport>(
2139 &task_queue_, receiver_call_.get(), payload_type_map_);
2140 sender_transport->SetReceiver(receiver_call_->Receiver());
2141 receiver_transport->SetReceiver(sender_call_->Receiver());
2142
2143 CreateSendConfig(1, 0, 0, sender_transport.get());
2144 CreateMatchingReceiveConfigs(receiver_transport.get());
2145 video_send_config_.post_encode_callback = &post_encode_observer;
2146 video_receive_configs_[0].pre_decode_callback = &pre_decode_observer;
2147
2148 CreateVideoStreams();
2149 Start();
2150
2151 frame_generator = test::FrameGenerator::CreateSquareGenerator(
2152 kDefaultWidth, kDefaultHeight);
2153 video_send_stream_->SetSource(
2154 &forwarder, VideoSendStream::DegradationPreference::kMaintainFramerate);
2155 forwarder.IncomingCapturedFrame(*frame_generator->NextFrame());
2156 });
2157
2158 EXPECT_TRUE(post_encode_observer.Wait())
2159 << "Timed out while waiting for send-side encoded-frame callback.";
2160
2161 EXPECT_TRUE(pre_decode_observer.Wait())
2162 << "Timed out while waiting for pre-decode encoded-frame callback.";
2163
2164 post_encode_observer.ExpectEqualFrames(pre_decode_observer);
2165
2166 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() {
2167 Stop();
2168 DestroyStreams();
2169 sender_transport.reset();
2170 receiver_transport.reset();
2171 DestroyCalls();
2172 });
2173 }
2174
TEST_P(EndToEndTest,ReceiveStreamSendsRemb)2175 TEST_P(EndToEndTest, ReceiveStreamSendsRemb) {
2176 class RembObserver : public test::EndToEndTest {
2177 public:
2178 RembObserver() : EndToEndTest(kDefaultTimeoutMs) {}
2179
2180 void ModifyVideoConfigs(
2181 VideoSendStream::Config* send_config,
2182 std::vector<VideoReceiveStream::Config>* receive_configs,
2183 VideoEncoderConfig* encoder_config) override {
2184 send_config->rtp.extensions.clear();
2185 send_config->rtp.extensions.push_back(RtpExtension(
2186 RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
2187 (*receive_configs)[0].rtp.remb = true;
2188 (*receive_configs)[0].rtp.transport_cc = false;
2189 }
2190
2191 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
2192 test::RtcpPacketParser parser;
2193 EXPECT_TRUE(parser.Parse(packet, length));
2194
2195 if (parser.remb()->num_packets() > 0) {
2196 EXPECT_EQ(kReceiverLocalVideoSsrc, parser.remb()->sender_ssrc());
2197 EXPECT_LT(0U, parser.remb()->bitrate_bps());
2198 EXPECT_EQ(1U, parser.remb()->ssrcs().size());
2199 EXPECT_EQ(kVideoSendSsrcs[0], parser.remb()->ssrcs()[0]);
2200 observation_complete_.Set();
2201 }
2202
2203 return SEND_PACKET;
2204 }
2205 void PerformTest() override {
2206 EXPECT_TRUE(Wait()) << "Timed out while waiting for a "
2207 "receiver RTCP REMB packet to be "
2208 "sent.";
2209 }
2210 } test;
2211
2212 RunBaseTest(&test);
2213 }
2214
2215 class BandwidthStatsTest : public test::EndToEndTest {
2216 public:
BandwidthStatsTest(bool send_side_bwe)2217 explicit BandwidthStatsTest(bool send_side_bwe)
2218 : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
2219 sender_call_(nullptr),
2220 receiver_call_(nullptr),
2221 has_seen_pacer_delay_(false),
2222 send_side_bwe_(send_side_bwe) {}
2223
ModifyVideoConfigs(VideoSendStream::Config * send_config,std::vector<VideoReceiveStream::Config> * receive_configs,VideoEncoderConfig * encoder_config)2224 void ModifyVideoConfigs(
2225 VideoSendStream::Config* send_config,
2226 std::vector<VideoReceiveStream::Config>* receive_configs,
2227 VideoEncoderConfig* encoder_config) override {
2228 if (!send_side_bwe_) {
2229 send_config->rtp.extensions.clear();
2230 send_config->rtp.extensions.push_back(RtpExtension(
2231 RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
2232 (*receive_configs)[0].rtp.remb = true;
2233 (*receive_configs)[0].rtp.transport_cc = false;
2234 }
2235 }
2236
OnSendRtp(const uint8_t * packet,size_t length)2237 Action OnSendRtp(const uint8_t* packet, size_t length) override {
2238 Call::Stats sender_stats = sender_call_->GetStats();
2239 Call::Stats receiver_stats = receiver_call_->GetStats();
2240 if (!has_seen_pacer_delay_)
2241 has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0;
2242 if (sender_stats.send_bandwidth_bps > 0 && has_seen_pacer_delay_) {
2243 if (send_side_bwe_ || receiver_stats.recv_bandwidth_bps > 0)
2244 observation_complete_.Set();
2245 }
2246 return SEND_PACKET;
2247 }
2248
OnCallsCreated(Call * sender_call,Call * receiver_call)2249 void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
2250 sender_call_ = sender_call;
2251 receiver_call_ = receiver_call;
2252 }
2253
PerformTest()2254 void PerformTest() override {
2255 EXPECT_TRUE(Wait()) << "Timed out while waiting for "
2256 "non-zero bandwidth stats.";
2257 }
2258
2259 private:
2260 Call* sender_call_;
2261 Call* receiver_call_;
2262 bool has_seen_pacer_delay_;
2263 const bool send_side_bwe_;
2264 };
2265
TEST_P(EndToEndTest,VerifySendSideBweStats)2266 TEST_P(EndToEndTest, VerifySendSideBweStats) {
2267 BandwidthStatsTest test(true);
2268 RunBaseTest(&test);
2269 }
2270
TEST_P(EndToEndTest,VerifyRecvSideBweStats)2271 TEST_P(EndToEndTest, VerifyRecvSideBweStats) {
2272 BandwidthStatsTest test(false);
2273 RunBaseTest(&test);
2274 }
2275
2276 // Verifies that it's possible to limit the send BWE by sending a REMB.
2277 // This is verified by allowing the send BWE to ramp-up to >1000 kbps,
2278 // then have the test generate a REMB of 500 kbps and verify that the send BWE
2279 // is reduced to exactly 500 kbps. Then a REMB of 1000 kbps is generated and the
2280 // test verifies that the send BWE ramps back up to exactly 1000 kbps.
TEST_P(EndToEndTest,RembWithSendSideBwe)2281 TEST_P(EndToEndTest, RembWithSendSideBwe) {
2282 class BweObserver : public test::EndToEndTest {
2283 public:
2284 BweObserver()
2285 : EndToEndTest(kDefaultTimeoutMs),
2286 sender_call_(nullptr),
2287 clock_(Clock::GetRealTimeClock()),
2288 sender_ssrc_(0),
2289 remb_bitrate_bps_(1000000),
2290 receive_transport_(nullptr),
2291 stop_event_(false, false),
2292 poller_thread_(&BitrateStatsPollingThread,
2293 this,
2294 "BitrateStatsPollingThread"),
2295 state_(kWaitForFirstRampUp),
2296 retransmission_rate_limiter_(clock_, 1000) {}
2297
2298 ~BweObserver() {}
2299
2300 test::PacketTransport* CreateReceiveTransport(
2301 test::SingleThreadedTaskQueueForTesting* task_queue) override {
2302 receive_transport_ = new test::PacketTransport(
2303 task_queue, nullptr, this, test::PacketTransport::kReceiver,
2304 payload_type_map_, FakeNetworkPipe::Config());
2305 return receive_transport_;
2306 }
2307
2308 Call::Config GetSenderCallConfig() override {
2309 Call::Config config(event_log_.get());
2310 // Set a high start bitrate to reduce the test completion time.
2311 config.bitrate_config.start_bitrate_bps = remb_bitrate_bps_;
2312 return config;
2313 }
2314
2315 void ModifyVideoConfigs(
2316 VideoSendStream::Config* send_config,
2317 std::vector<VideoReceiveStream::Config>* receive_configs,
2318 VideoEncoderConfig* encoder_config) override {
2319 ASSERT_EQ(1u, send_config->rtp.ssrcs.size());
2320 sender_ssrc_ = send_config->rtp.ssrcs[0];
2321
2322 encoder_config->max_bitrate_bps = 2000000;
2323
2324 ASSERT_EQ(1u, receive_configs->size());
2325 RtpRtcp::Configuration config;
2326 config.receiver_only = true;
2327 config.clock = clock_;
2328 config.outgoing_transport = receive_transport_;
2329 config.retransmission_rate_limiter = &retransmission_rate_limiter_;
2330 rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
2331 rtp_rtcp_->SetRemoteSSRC((*receive_configs)[0].rtp.remote_ssrc);
2332 rtp_rtcp_->SetSSRC((*receive_configs)[0].rtp.local_ssrc);
2333 rtp_rtcp_->SetRTCPStatus(RtcpMode::kReducedSize);
2334 }
2335
2336 void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
2337 sender_call_ = sender_call;
2338 }
2339
2340 static void BitrateStatsPollingThread(void* obj) {
2341 static_cast<BweObserver*>(obj)->PollStats();
2342 }
2343
2344 void PollStats() {
2345 do {
2346 if (sender_call_) {
2347 Call::Stats stats = sender_call_->GetStats();
2348 switch (state_) {
2349 case kWaitForFirstRampUp:
2350 if (stats.send_bandwidth_bps >= remb_bitrate_bps_) {
2351 state_ = kWaitForRemb;
2352 remb_bitrate_bps_ /= 2;
2353 rtp_rtcp_->SetRemb(
2354 remb_bitrate_bps_,
2355 std::vector<uint32_t>(&sender_ssrc_, &sender_ssrc_ + 1));
2356 rtp_rtcp_->SendRTCP(kRtcpRr);
2357 }
2358 break;
2359
2360 case kWaitForRemb:
2361 if (stats.send_bandwidth_bps == remb_bitrate_bps_) {
2362 state_ = kWaitForSecondRampUp;
2363 remb_bitrate_bps_ *= 2;
2364 rtp_rtcp_->SetRemb(
2365 remb_bitrate_bps_,
2366 std::vector<uint32_t>(&sender_ssrc_, &sender_ssrc_ + 1));
2367 rtp_rtcp_->SendRTCP(kRtcpRr);
2368 }
2369 break;
2370
2371 case kWaitForSecondRampUp:
2372 if (stats.send_bandwidth_bps == remb_bitrate_bps_) {
2373 observation_complete_.Set();
2374 }
2375 break;
2376 }
2377 }
2378 } while (!stop_event_.Wait(1000));
2379 }
2380
2381 void PerformTest() override {
2382 poller_thread_.Start();
2383 EXPECT_TRUE(Wait())
2384 << "Timed out while waiting for bitrate to change according to REMB.";
2385 stop_event_.Set();
2386 poller_thread_.Stop();
2387 }
2388
2389 private:
2390 enum TestState { kWaitForFirstRampUp, kWaitForRemb, kWaitForSecondRampUp };
2391
2392 Call* sender_call_;
2393 Clock* const clock_;
2394 uint32_t sender_ssrc_;
2395 int remb_bitrate_bps_;
2396 std::unique_ptr<RtpRtcp> rtp_rtcp_;
2397 test::PacketTransport* receive_transport_;
2398 rtc::Event stop_event_;
2399 rtc::PlatformThread poller_thread_;
2400 TestState state_;
2401 RateLimiter retransmission_rate_limiter_;
2402 } test;
2403
2404 RunBaseTest(&test);
2405 }
2406
TEST_P(EndToEndTest,StopSendingKeyframeRequestsForInactiveStream)2407 TEST_P(EndToEndTest, StopSendingKeyframeRequestsForInactiveStream) {
2408 class KeyframeRequestObserver : public test::EndToEndTest {
2409 public:
2410 explicit KeyframeRequestObserver(
2411 test::SingleThreadedTaskQueueForTesting* task_queue)
2412 : clock_(Clock::GetRealTimeClock()), task_queue_(task_queue) {}
2413
2414 void OnVideoStreamsCreated(
2415 VideoSendStream* send_stream,
2416 const std::vector<VideoReceiveStream*>& receive_streams) override {
2417 RTC_DCHECK_EQ(1, receive_streams.size());
2418 send_stream_ = send_stream;
2419 receive_stream_ = receive_streams[0];
2420 }
2421
2422 void PerformTest() override {
2423 bool frame_decoded = false;
2424 int64_t start_time = clock_->TimeInMilliseconds();
2425 while (clock_->TimeInMilliseconds() - start_time <= 5000) {
2426 if (receive_stream_->GetStats().frames_decoded > 0) {
2427 frame_decoded = true;
2428 break;
2429 }
2430 SleepMs(100);
2431 }
2432 ASSERT_TRUE(frame_decoded);
2433 task_queue_->SendTask([this]() { send_stream_->Stop(); });
2434 SleepMs(10000);
2435 ASSERT_EQ(
2436 1U, receive_stream_->GetStats().rtcp_packet_type_counts.pli_packets);
2437 }
2438
2439 private:
2440 Clock* clock_;
2441 VideoSendStream* send_stream_;
2442 VideoReceiveStream* receive_stream_;
2443 test::SingleThreadedTaskQueueForTesting* const task_queue_;
2444 } test(&task_queue_);
2445
2446 RunBaseTest(&test);
2447 }
2448
2449 class ProbingTest : public test::EndToEndTest {
2450 public:
ProbingTest(int start_bitrate_bps)2451 explicit ProbingTest(int start_bitrate_bps)
2452 : clock_(Clock::GetRealTimeClock()),
2453 start_bitrate_bps_(start_bitrate_bps),
2454 state_(0),
2455 sender_call_(nullptr) {}
2456
~ProbingTest()2457 ~ProbingTest() {}
2458
GetSenderCallConfig()2459 Call::Config GetSenderCallConfig() override {
2460 Call::Config config(event_log_.get());
2461 config.bitrate_config.start_bitrate_bps = start_bitrate_bps_;
2462 return config;
2463 }
2464
OnCallsCreated(Call * sender_call,Call * receiver_call)2465 void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
2466 sender_call_ = sender_call;
2467 }
2468
2469 protected:
2470 Clock* const clock_;
2471 const int start_bitrate_bps_;
2472 int state_;
2473 Call* sender_call_;
2474 };
2475
TEST_P(EndToEndTest,MAYBE_InitialProbing)2476 TEST_P(EndToEndTest, MAYBE_InitialProbing) {
2477 class InitialProbingTest : public ProbingTest {
2478 public:
2479 explicit InitialProbingTest(bool* success)
2480 : ProbingTest(300000), success_(success) {
2481 *success_ = false;
2482 }
2483
2484 void PerformTest() override {
2485 int64_t start_time_ms = clock_->TimeInMilliseconds();
2486 do {
2487 if (clock_->TimeInMilliseconds() - start_time_ms > kTimeoutMs)
2488 break;
2489
2490 Call::Stats stats = sender_call_->GetStats();
2491 // Initial probing is done with a x3 and x6 multiplier of the start
2492 // bitrate, so a x4 multiplier is a high enough threshold.
2493 if (stats.send_bandwidth_bps > 4 * 300000) {
2494 *success_ = true;
2495 break;
2496 }
2497 } while (!observation_complete_.Wait(20));
2498 }
2499
2500 private:
2501 const int kTimeoutMs = 1000;
2502 bool* const success_;
2503 };
2504
2505 bool success = false;
2506 const int kMaxAttempts = 3;
2507 for (int i = 0; i < kMaxAttempts; ++i) {
2508 InitialProbingTest test(&success);
2509 RunBaseTest(&test);
2510 if (success)
2511 return;
2512 }
2513 EXPECT_TRUE(success) << "Failed to perform mid initial probing ("
2514 << kMaxAttempts << " attempts).";
2515 }
2516
2517 // Fails on Linux MSan: bugs.webrtc.org/7428
2518 #if defined(MEMORY_SANITIZER)
TEST_P(EndToEndTest,DISABLED_TriggerMidCallProbing)2519 TEST_P(EndToEndTest, DISABLED_TriggerMidCallProbing) {
2520 // Fails on iOS bots: bugs.webrtc.org/7851
2521 #elif defined(TARGET_IPHONE_SIMULATOR) && TARGET_IPHONE_SIMULATOR
2522 TEST_P(EndToEndTest, DISABLED_TriggerMidCallProbing) {
2523 #else
2524 TEST_P(EndToEndTest, TriggerMidCallProbing) {
2525 #endif
2526
2527 class TriggerMidCallProbingTest : public ProbingTest {
2528 public:
2529 TriggerMidCallProbingTest(
2530 test::SingleThreadedTaskQueueForTesting* task_queue,
2531 bool* success)
2532 : ProbingTest(300000), success_(success), task_queue_(task_queue) {}
2533
2534 void PerformTest() override {
2535 *success_ = false;
2536 int64_t start_time_ms = clock_->TimeInMilliseconds();
2537 do {
2538 if (clock_->TimeInMilliseconds() - start_time_ms > kTimeoutMs)
2539 break;
2540
2541 Call::Stats stats = sender_call_->GetStats();
2542
2543 switch (state_) {
2544 case 0:
2545 if (stats.send_bandwidth_bps > 5 * 300000) {
2546 Call::Config::BitrateConfig bitrate_config;
2547 bitrate_config.max_bitrate_bps = 100000;
2548 task_queue_->SendTask([this, &bitrate_config]() {
2549 sender_call_->SetBitrateConfig(bitrate_config);
2550 });
2551 ++state_;
2552 }
2553 break;
2554 case 1:
2555 if (stats.send_bandwidth_bps < 110000) {
2556 Call::Config::BitrateConfig bitrate_config;
2557 bitrate_config.max_bitrate_bps = 2500000;
2558 task_queue_->SendTask([this, &bitrate_config]() {
2559 sender_call_->SetBitrateConfig(bitrate_config);
2560 });
2561 ++state_;
2562 }
2563 break;
2564 case 2:
2565 // During high cpu load the pacer will not be able to pace packets
2566 // at the correct speed, but if we go from 110 to 1250 kbps
2567 // in 5 seconds then it is due to probing.
2568 if (stats.send_bandwidth_bps > 1250000) {
2569 *success_ = true;
2570 observation_complete_.Set();
2571 }
2572 break;
2573 }
2574 } while (!observation_complete_.Wait(20));
2575 }
2576
2577 private:
2578 const int kTimeoutMs = 5000;
2579 bool* const success_;
2580 test::SingleThreadedTaskQueueForTesting* const task_queue_;
2581 };
2582
2583 bool success = false;
2584 const int kMaxAttempts = 3;
2585 for (int i = 0; i < kMaxAttempts; ++i) {
2586 TriggerMidCallProbingTest test(&task_queue_, &success);
2587 RunBaseTest(&test);
2588 if (success)
2589 return;
2590 }
2591 EXPECT_TRUE(success) << "Failed to perform mid call probing (" << kMaxAttempts
2592 << " attempts).";
2593 }
2594
2595 TEST_P(EndToEndTest, VerifyNackStats) {
2596 static const int kPacketNumberToDrop = 200;
2597 class NackObserver : public test::EndToEndTest {
2598 public:
2599 NackObserver()
2600 : EndToEndTest(kLongTimeoutMs),
2601 sent_rtp_packets_(0),
2602 dropped_rtp_packet_(0),
2603 dropped_rtp_packet_requested_(false),
2604 send_stream_(nullptr),
2605 start_runtime_ms_(-1) {}
2606
2607 private:
2608 Action OnSendRtp(const uint8_t* packet, size_t length) override {
2609 rtc::CritScope lock(&crit_);
2610 if (++sent_rtp_packets_ == kPacketNumberToDrop) {
2611 std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
2612 RTPHeader header;
2613 EXPECT_TRUE(parser->Parse(packet, length, &header));
2614 dropped_rtp_packet_ = header.sequenceNumber;
2615 return DROP_PACKET;
2616 }
2617 VerifyStats();
2618 return SEND_PACKET;
2619 }
2620
2621 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
2622 rtc::CritScope lock(&crit_);
2623 test::RtcpPacketParser rtcp_parser;
2624 rtcp_parser.Parse(packet, length);
2625 const std::vector<uint16_t>& nacks = rtcp_parser.nack()->packet_ids();
2626 if (!nacks.empty() && std::find(
2627 nacks.begin(), nacks.end(), dropped_rtp_packet_) != nacks.end()) {
2628 dropped_rtp_packet_requested_ = true;
2629 }
2630 return SEND_PACKET;
2631 }
2632
2633 void VerifyStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
2634 if (!dropped_rtp_packet_requested_)
2635 return;
2636 int send_stream_nack_packets = 0;
2637 int receive_stream_nack_packets = 0;
2638 VideoSendStream::Stats stats = send_stream_->GetStats();
2639 for (std::map<uint32_t, VideoSendStream::StreamStats>::const_iterator it =
2640 stats.substreams.begin(); it != stats.substreams.end(); ++it) {
2641 const VideoSendStream::StreamStats& stream_stats = it->second;
2642 send_stream_nack_packets +=
2643 stream_stats.rtcp_packet_type_counts.nack_packets;
2644 }
2645 for (size_t i = 0; i < receive_streams_.size(); ++i) {
2646 VideoReceiveStream::Stats stats = receive_streams_[i]->GetStats();
2647 receive_stream_nack_packets +=
2648 stats.rtcp_packet_type_counts.nack_packets;
2649 }
2650 if (send_stream_nack_packets >= 1 && receive_stream_nack_packets >= 1) {
2651 // NACK packet sent on receive stream and received on sent stream.
2652 if (MinMetricRunTimePassed())
2653 observation_complete_.Set();
2654 }
2655 }
2656
2657 bool MinMetricRunTimePassed() {
2658 int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds();
2659 if (start_runtime_ms_ == -1) {
2660 start_runtime_ms_ = now;
2661 return false;
2662 }
2663 int64_t elapsed_sec = (now - start_runtime_ms_) / 1000;
2664 return elapsed_sec > metrics::kMinRunTimeInSeconds;
2665 }
2666
2667 void ModifyVideoConfigs(
2668 VideoSendStream::Config* send_config,
2669 std::vector<VideoReceiveStream::Config>* receive_configs,
2670 VideoEncoderConfig* encoder_config) override {
2671 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
2672 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
2673 (*receive_configs)[0].renderer = &fake_renderer_;
2674 }
2675
2676 void OnVideoStreamsCreated(
2677 VideoSendStream* send_stream,
2678 const std::vector<VideoReceiveStream*>& receive_streams) override {
2679 send_stream_ = send_stream;
2680 receive_streams_ = receive_streams;
2681 }
2682
2683 void PerformTest() override {
2684 EXPECT_TRUE(Wait()) << "Timed out waiting for packet to be NACKed.";
2685 }
2686
2687 test::FakeVideoRenderer fake_renderer_;
2688 rtc::CriticalSection crit_;
2689 uint64_t sent_rtp_packets_;
2690 uint16_t dropped_rtp_packet_ RTC_GUARDED_BY(&crit_);
2691 bool dropped_rtp_packet_requested_ RTC_GUARDED_BY(&crit_);
2692 std::vector<VideoReceiveStream*> receive_streams_;
2693 VideoSendStream* send_stream_;
2694 int64_t start_runtime_ms_;
2695 } test;
2696
2697 metrics::Reset();
2698 RunBaseTest(&test);
2699
2700 EXPECT_EQ(
2701 1, metrics::NumSamples("WebRTC.Video.UniqueNackRequestsSentInPercent"));
2702 EXPECT_EQ(1, metrics::NumSamples(
2703 "WebRTC.Video.UniqueNackRequestsReceivedInPercent"));
2704 EXPECT_GT(metrics::MinSample("WebRTC.Video.NackPacketsSentPerMinute"), 0);
2705 }
2706
2707 void EndToEndTest::VerifyHistogramStats(bool use_rtx,
2708 bool use_fec,
2709 bool screenshare) {
2710 class StatsObserver : public test::EndToEndTest,
2711 public rtc::VideoSinkInterface<VideoFrame> {
2712 public:
2713 StatsObserver(bool use_rtx, bool use_fec, bool screenshare)
2714 : EndToEndTest(kLongTimeoutMs),
2715 use_rtx_(use_rtx),
2716 use_fec_(use_fec),
2717 screenshare_(screenshare),
2718 // This test uses NACK, so to send FEC we can't use a fake encoder.
2719 vp8_encoder_(use_fec ? VP8Encoder::Create() : nullptr),
2720 sender_call_(nullptr),
2721 receiver_call_(nullptr),
2722 start_runtime_ms_(-1),
2723 num_frames_received_(0) {}
2724
2725 private:
2726 void OnFrame(const VideoFrame& video_frame) override {
2727 // The RTT is needed to estimate |ntp_time_ms| which is used by
2728 // end-to-end delay stats. Therefore, start counting received frames once
2729 // |ntp_time_ms| is valid.
2730 if (video_frame.ntp_time_ms() > 0 &&
2731 Clock::GetRealTimeClock()->CurrentNtpInMilliseconds() >=
2732 video_frame.ntp_time_ms()) {
2733 rtc::CritScope lock(&crit_);
2734 ++num_frames_received_;
2735 }
2736 }
2737
2738 Action OnSendRtp(const uint8_t* packet, size_t length) override {
2739 if (MinMetricRunTimePassed() && MinNumberOfFramesReceived())
2740 observation_complete_.Set();
2741
2742 return SEND_PACKET;
2743 }
2744
2745 bool MinMetricRunTimePassed() {
2746 int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds();
2747 if (start_runtime_ms_ == -1) {
2748 start_runtime_ms_ = now;
2749 return false;
2750 }
2751 int64_t elapsed_sec = (now - start_runtime_ms_) / 1000;
2752 return elapsed_sec > metrics::kMinRunTimeInSeconds * 2;
2753 }
2754
2755 bool MinNumberOfFramesReceived() const {
2756 const int kMinRequiredHistogramSamples = 200;
2757 rtc::CritScope lock(&crit_);
2758 return num_frames_received_ > kMinRequiredHistogramSamples;
2759 }
2760
2761 void ModifyVideoConfigs(
2762 VideoSendStream::Config* send_config,
2763 std::vector<VideoReceiveStream::Config>* receive_configs,
2764 VideoEncoderConfig* encoder_config) override {
2765 // NACK
2766 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
2767 (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
2768 (*receive_configs)[0].renderer = this;
2769 // FEC
2770 if (use_fec_) {
2771 send_config->rtp.ulpfec.ulpfec_payload_type = kUlpfecPayloadType;
2772 send_config->rtp.ulpfec.red_payload_type = kRedPayloadType;
2773 send_config->encoder_settings.encoder = vp8_encoder_.get();
2774 send_config->encoder_settings.payload_name = "VP8";
2775 (*receive_configs)[0].decoders[0].payload_name = "VP8";
2776 (*receive_configs)[0].rtp.red_payload_type = kRedPayloadType;
2777 (*receive_configs)[0].rtp.ulpfec_payload_type = kUlpfecPayloadType;
2778 }
2779 // RTX
2780 if (use_rtx_) {
2781 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
2782 send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
2783 (*receive_configs)[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
2784 (*receive_configs)[0]
2785 .rtp.rtx_associated_payload_types[kSendRtxPayloadType] =
2786 kFakeVideoSendPayloadType;
2787 if (use_fec_) {
2788 send_config->rtp.ulpfec.red_rtx_payload_type = kRtxRedPayloadType;
2789 (*receive_configs)[0]
2790 .rtp.rtx_associated_payload_types[kRtxRedPayloadType] =
2791 kSendRtxPayloadType;
2792 }
2793 }
2794 // RTT needed for RemoteNtpTimeEstimator for the receive stream.
2795 (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true;
2796 encoder_config->content_type =
2797 screenshare_ ? VideoEncoderConfig::ContentType::kScreen
2798 : VideoEncoderConfig::ContentType::kRealtimeVideo;
2799 }
2800
2801 void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
2802 sender_call_ = sender_call;
2803 receiver_call_ = receiver_call;
2804 }
2805
2806 void PerformTest() override {
2807 EXPECT_TRUE(Wait()) << "Timed out waiting for packet to be NACKed.";
2808 }
2809
2810 rtc::CriticalSection crit_;
2811 const bool use_rtx_;
2812 const bool use_fec_;
2813 const bool screenshare_;
2814 const std::unique_ptr<VideoEncoder> vp8_encoder_;
2815 Call* sender_call_;
2816 Call* receiver_call_;
2817 int64_t start_runtime_ms_;
2818 int num_frames_received_ RTC_GUARDED_BY(&crit_);
2819 } test(use_rtx, use_fec, screenshare);
2820
2821 metrics::Reset();
2822 RunBaseTest(&test);
2823
2824 std::string video_prefix =
2825 screenshare ? "WebRTC.Video.Screenshare." : "WebRTC.Video.";
2826 // The content type extension is disabled in non screenshare test,
2827 // therefore no slicing on simulcast id should be present.
2828 std::string video_suffix = screenshare ? ".S0" : "";
2829 // Verify that stats have been updated once.
2830 EXPECT_EQ(2, metrics::NumSamples("WebRTC.Call.LifetimeInSeconds"));
2831 EXPECT_EQ(1, metrics::NumSamples(
2832 "WebRTC.Call.TimeReceivingVideoRtpPacketsInSeconds"));
2833 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.VideoBitrateReceivedInKbps"));
2834 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.RtcpBitrateReceivedInBps"));
2835 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.BitrateReceivedInKbps"));
2836 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.EstimatedSendBitrateInKbps"));
2837 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Call.PacerBitrateInKbps"));
2838
2839 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.SendStreamLifetimeInSeconds"));
2840 EXPECT_EQ(1,
2841 metrics::NumSamples("WebRTC.Video.ReceiveStreamLifetimeInSeconds"));
2842
2843 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.NackPacketsSentPerMinute"));
2844 EXPECT_EQ(1,
2845 metrics::NumSamples(video_prefix + "NackPacketsReceivedPerMinute"));
2846 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FirPacketsSentPerMinute"));
2847 EXPECT_EQ(1,
2848 metrics::NumSamples(video_prefix + "FirPacketsReceivedPerMinute"));
2849 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.PliPacketsSentPerMinute"));
2850 EXPECT_EQ(1,
2851 metrics::NumSamples(video_prefix + "PliPacketsReceivedPerMinute"));
2852
2853 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "KeyFramesSentInPermille"));
2854 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
2855
2856 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentPacketsLostInPercent"));
2857 EXPECT_EQ(1,
2858 metrics::NumSamples("WebRTC.Video.ReceivedPacketsLostInPercent"));
2859
2860 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputWidthInPixels"));
2861 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputHeightInPixels"));
2862 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentWidthInPixels"));
2863 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentHeightInPixels"));
2864 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "ReceivedWidthInPixels"));
2865 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "ReceivedHeightInPixels"));
2866
2867 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "InputWidthInPixels",
2868 kDefaultWidth));
2869 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "InputHeightInPixels",
2870 kDefaultHeight));
2871 EXPECT_EQ(
2872 1, metrics::NumEvents(video_prefix + "SentWidthInPixels", kDefaultWidth));
2873 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "SentHeightInPixels",
2874 kDefaultHeight));
2875 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "ReceivedWidthInPixels",
2876 kDefaultWidth));
2877 EXPECT_EQ(1, metrics::NumEvents(video_prefix + "ReceivedHeightInPixels",
2878 kDefaultHeight));
2879
2880 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InputFramesPerSecond"));
2881 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SentFramesPerSecond"));
2882 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DecodedFramesPerSecond"));
2883 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RenderFramesPerSecond"));
2884
2885 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.JitterBufferDelayInMs"));
2886 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.TargetDelayInMs"));
2887 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.CurrentDelayInMs"));
2888 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.OnewayDelayInMs"));
2889
2890 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "EndToEndDelayInMs" +
2891 video_suffix));
2892 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "EndToEndDelayMaxInMs" +
2893 video_suffix));
2894 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InterframeDelayInMs" +
2895 video_suffix));
2896 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "InterframeDelayMaxInMs" +
2897 video_suffix));
2898
2899 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RenderSqrtPixelsPerSecond"));
2900
2901 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "EncodeTimeInMs"));
2902 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.DecodeTimeInMs"));
2903
2904 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "NumberOfPauseEvents"));
2905 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "PausedTimeInPercent"));
2906
2907 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "BitrateSentInKbps"));
2908 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.BitrateReceivedInKbps"));
2909 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "MediaBitrateSentInKbps"));
2910 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.MediaBitrateReceivedInKbps"));
2911 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "PaddingBitrateSentInKbps"));
2912 EXPECT_EQ(1,
2913 metrics::NumSamples("WebRTC.Video.PaddingBitrateReceivedInKbps"));
2914 EXPECT_EQ(
2915 1, metrics::NumSamples(video_prefix + "RetransmittedBitrateSentInKbps"));
2916 EXPECT_EQ(1, metrics::NumSamples(
2917 "WebRTC.Video.RetransmittedBitrateReceivedInKbps"));
2918
2919 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.SendDelayInMs"));
2920 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SendSideDelayInMs"));
2921 EXPECT_EQ(1, metrics::NumSamples(video_prefix + "SendSideDelayMaxInMs"));
2922
2923 int num_rtx_samples = use_rtx ? 1 : 0;
2924 EXPECT_EQ(num_rtx_samples,
2925 metrics::NumSamples("WebRTC.Video.RtxBitrateSentInKbps"));
2926 EXPECT_EQ(num_rtx_samples,
2927 metrics::NumSamples("WebRTC.Video.RtxBitrateReceivedInKbps"));
2928
2929 int num_red_samples = use_fec ? 1 : 0;
2930 EXPECT_EQ(num_red_samples,
2931 metrics::NumSamples("WebRTC.Video.FecBitrateSentInKbps"));
2932 EXPECT_EQ(num_red_samples,
2933 metrics::NumSamples("WebRTC.Video.FecBitrateReceivedInKbps"));
2934 EXPECT_EQ(num_red_samples,
2935 metrics::NumSamples("WebRTC.Video.ReceivedFecPacketsInPercent"));
2936 }
2937
2938 #if defined(WEBRTC_WIN)
2939 // Disabled due to flakiness on Windows (bugs.webrtc.org/7483).
2940 #define MAYBE_ContentTypeSwitches DISABLED_ContentTypeSwitches
2941 #else
2942 #define MAYBE_ContentTypeSwitches ContentTypeSwitches
2943 #endif
2944 TEST_P(EndToEndTest, MAYBE_ContentTypeSwitches) {
2945 class StatsObserver : public test::BaseTest,
2946 public rtc::VideoSinkInterface<VideoFrame> {
2947 public:
2948 StatsObserver() : BaseTest(kLongTimeoutMs), num_frames_received_(0) {}
2949
2950 bool ShouldCreateReceivers() const override { return true; }
2951
2952 void OnFrame(const VideoFrame& video_frame) override {
2953 // The RTT is needed to estimate |ntp_time_ms| which is used by
2954 // end-to-end delay stats. Therefore, start counting received frames once
2955 // |ntp_time_ms| is valid.
2956 if (video_frame.ntp_time_ms() > 0 &&
2957 Clock::GetRealTimeClock()->CurrentNtpInMilliseconds() >=
2958 video_frame.ntp_time_ms()) {
2959 rtc::CritScope lock(&crit_);
2960 ++num_frames_received_;
2961 }
2962 }
2963
2964 Action OnSendRtp(const uint8_t* packet, size_t length) override {
2965 if (MinNumberOfFramesReceived())
2966 observation_complete_.Set();
2967 return SEND_PACKET;
2968 }
2969
2970 bool MinNumberOfFramesReceived() const {
2971 // Have some room for frames with wrong content type during switch.
2972 const int kMinRequiredHistogramSamples = 200+50;
2973 rtc::CritScope lock(&crit_);
2974 return num_frames_received_ > kMinRequiredHistogramSamples;
2975 }
2976
2977 // May be called several times.
2978 void PerformTest() override {
2979 EXPECT_TRUE(Wait()) << "Timed out waiting for enough packets.";
2980 // Reset frame counter so next PerformTest() call will do something.
2981 {
2982 rtc::CritScope lock(&crit_);
2983 num_frames_received_ = 0;
2984 }
2985 }
2986
2987 rtc::CriticalSection crit_;
2988 int num_frames_received_ RTC_GUARDED_BY(&crit_);
2989 } test;
2990
2991 metrics::Reset();
2992
2993 Call::Config send_config(test.GetSenderCallConfig());
2994 Call::Config recv_config(test.GetReceiverCallConfig());
2995 VideoEncoderConfig encoder_config_with_screenshare;
2996
2997 task_queue_.SendTask([this, &test, &send_config,
2998 &recv_config, &encoder_config_with_screenshare]() {
2999 CreateSenderCall(send_config);
3000 CreateReceiverCall(recv_config);
3001
3002 receive_transport_.reset(test.CreateReceiveTransport(&task_queue_));
3003 send_transport_.reset(
3004 test.CreateSendTransport(&task_queue_, sender_call_.get()));
3005 send_transport_->SetReceiver(receiver_call_->Receiver());
3006 receive_transport_->SetReceiver(sender_call_->Receiver());
3007
3008 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
3009 CreateSendConfig(1, 0, 0, send_transport_.get());
3010 CreateMatchingReceiveConfigs(receive_transport_.get());
3011
3012 // Modify send and receive configs.
3013 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
3014 video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
3015 video_receive_configs_[0].renderer = &test;
3016 // RTT needed for RemoteNtpTimeEstimator for the receive stream.
3017 video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = true;
3018 // Start with realtime video.
3019 video_encoder_config_.content_type =
3020 VideoEncoderConfig::ContentType::kRealtimeVideo;
3021 // Second encoder config for the second part of the test uses screenshare
3022 encoder_config_with_screenshare = video_encoder_config_.Copy();
3023 encoder_config_with_screenshare.content_type =
3024 VideoEncoderConfig::ContentType::kScreen;
3025
3026 CreateVideoStreams();
3027 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
3028 kDefaultHeight);
3029 Start();
3030 });
3031
3032 test.PerformTest();
3033
3034 // Replace old send stream.
3035 task_queue_.SendTask([this, &encoder_config_with_screenshare]() {
3036 sender_call_->DestroyVideoSendStream(video_send_stream_);
3037 video_send_stream_ = sender_call_->CreateVideoSendStream(
3038 video_send_config_.Copy(), encoder_config_with_screenshare.Copy());
3039 video_send_stream_->SetSource(
3040 frame_generator_capturer_.get(),
3041 VideoSendStream::DegradationPreference::kBalanced);
3042 video_send_stream_->Start();
3043 });
3044
3045 // Continue to run test but now with screenshare.
3046 test.PerformTest();
3047
3048 task_queue_.SendTask([this]() {
3049 Stop();
3050 DestroyStreams();
3051 send_transport_.reset();
3052 receive_transport_.reset();
3053 DestroyCalls();
3054 });
3055
3056 // Verify that stats have been updated for both screenshare and video.
3057 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.EndToEndDelayInMs"));
3058 EXPECT_EQ(1,
3059 metrics::NumSamples("WebRTC.Video.Screenshare.EndToEndDelayInMs"));
3060 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.EndToEndDelayMaxInMs"));
3061 EXPECT_EQ(
3062 1, metrics::NumSamples("WebRTC.Video.Screenshare.EndToEndDelayMaxInMs"));
3063 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.InterframeDelayInMs"));
3064 EXPECT_EQ(1,
3065 metrics::NumSamples(
3066 "WebRTC.Video.Screenshare.InterframeDelayInMs"));
3067 EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.InterframeDelayMaxInMs"));
3068 EXPECT_EQ(1,
3069 metrics::NumSamples(
3070 "WebRTC.Video.Screenshare.InterframeDelayMaxInMs"));
3071 }
3072
3073 TEST_P(EndToEndTest, VerifyHistogramStatsWithRtx) {
3074 const bool kEnabledRtx = true;
3075 const bool kEnabledRed = false;
3076 const bool kScreenshare = false;
3077 VerifyHistogramStats(kEnabledRtx, kEnabledRed, kScreenshare);
3078 }
3079
3080 TEST_P(EndToEndTest, VerifyHistogramStatsWithRed) {
3081 const bool kEnabledRtx = false;
3082 const bool kEnabledRed = true;
3083 const bool kScreenshare = false;
3084 VerifyHistogramStats(kEnabledRtx, kEnabledRed, kScreenshare);
3085 }
3086
3087 TEST_P(EndToEndTest, VerifyHistogramStatsWithScreenshare) {
3088 const bool kEnabledRtx = false;
3089 const bool kEnabledRed = false;
3090 const bool kScreenshare = true;
3091 VerifyHistogramStats(kEnabledRtx, kEnabledRed, kScreenshare);
3092 }
3093
3094 void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
3095 bool send_single_ssrc_first) {
3096 class SendsSetSsrcs : public test::EndToEndTest {
3097 public:
3098 SendsSetSsrcs(const uint32_t* ssrcs,
3099 size_t num_ssrcs,
3100 bool send_single_ssrc_first)
3101 : EndToEndTest(kDefaultTimeoutMs),
3102 num_ssrcs_(num_ssrcs),
3103 send_single_ssrc_first_(send_single_ssrc_first),
3104 ssrcs_to_observe_(num_ssrcs),
3105 expect_single_ssrc_(send_single_ssrc_first),
3106 send_stream_(nullptr) {
3107 for (size_t i = 0; i < num_ssrcs; ++i)
3108 valid_ssrcs_[ssrcs[i]] = true;
3109 }
3110
3111 private:
3112 Action OnSendRtp(const uint8_t* packet, size_t length) override {
3113 RTPHeader header;
3114 EXPECT_TRUE(parser_->Parse(packet, length, &header));
3115
3116 EXPECT_TRUE(valid_ssrcs_[header.ssrc])
3117 << "Received unknown SSRC: " << header.ssrc;
3118
3119 if (!valid_ssrcs_[header.ssrc])
3120 observation_complete_.Set();
3121
3122 if (!is_observed_[header.ssrc]) {
3123 is_observed_[header.ssrc] = true;
3124 --ssrcs_to_observe_;
3125 if (expect_single_ssrc_) {
3126 expect_single_ssrc_ = false;
3127 observation_complete_.Set();
3128 }
3129 }
3130
3131 if (ssrcs_to_observe_ == 0)
3132 observation_complete_.Set();
3133
3134 return SEND_PACKET;
3135 }
3136
3137 size_t GetNumVideoStreams() const override { return num_ssrcs_; }
3138
3139 // This test use other VideoStream settings than the the default settings
3140 // implemented in DefaultVideoStreamFactory. Therefore this test implement
3141 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created
3142 // in ModifyVideoConfigs.
3143 class VideoStreamFactory
3144 : public VideoEncoderConfig::VideoStreamFactoryInterface {
3145 public:
3146 VideoStreamFactory() {}
3147
3148 private:
3149 std::vector<VideoStream> CreateEncoderStreams(
3150 int width,
3151 int height,
3152 const VideoEncoderConfig& encoder_config) override {
3153 std::vector<VideoStream> streams =
3154 test::CreateVideoStreams(width, height, encoder_config);
3155 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
3156 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
3157 streams[i].min_bitrate_bps = 10000;
3158 streams[i].target_bitrate_bps = 15000;
3159 streams[i].max_bitrate_bps = 20000;
3160 }
3161 return streams;
3162 }
3163 };
3164
3165 void ModifyVideoConfigs(
3166 VideoSendStream::Config* send_config,
3167 std::vector<VideoReceiveStream::Config>* receive_configs,
3168 VideoEncoderConfig* encoder_config) override {
3169 encoder_config->video_stream_factory =
3170 new rtc::RefCountedObject<VideoStreamFactory>();
3171 video_encoder_config_all_streams_ = encoder_config->Copy();
3172 if (send_single_ssrc_first_)
3173 encoder_config->number_of_streams = 1;
3174 }
3175
3176 void OnVideoStreamsCreated(
3177 VideoSendStream* send_stream,
3178 const std::vector<VideoReceiveStream*>& receive_streams) override {
3179 send_stream_ = send_stream;
3180 }
3181
3182 void PerformTest() override {
3183 EXPECT_TRUE(Wait()) << "Timed out while waiting for "
3184 << (send_single_ssrc_first_ ? "first SSRC."
3185 : "SSRCs.");
3186
3187 if (send_single_ssrc_first_) {
3188 // Set full simulcast and continue with the rest of the SSRCs.
3189 send_stream_->ReconfigureVideoEncoder(
3190 std::move(video_encoder_config_all_streams_));
3191 EXPECT_TRUE(Wait()) << "Timed out while waiting on additional SSRCs.";
3192 }
3193 }
3194
3195 private:
3196 std::map<uint32_t, bool> valid_ssrcs_;
3197 std::map<uint32_t, bool> is_observed_;
3198
3199 const size_t num_ssrcs_;
3200 const bool send_single_ssrc_first_;
3201
3202 size_t ssrcs_to_observe_;
3203 bool expect_single_ssrc_;
3204
3205 VideoSendStream* send_stream_;
3206 VideoEncoderConfig video_encoder_config_all_streams_;
3207 } test(kVideoSendSsrcs, num_ssrcs, send_single_ssrc_first);
3208
3209 RunBaseTest(&test);
3210 }
3211
3212 TEST_P(EndToEndTest, ReportsSetEncoderRates) {
3213 class EncoderRateStatsTest : public test::EndToEndTest,
3214 public test::FakeEncoder {
3215 public:
3216 explicit EncoderRateStatsTest(
3217 test::SingleThreadedTaskQueueForTesting* task_queue)
3218 : EndToEndTest(kDefaultTimeoutMs),
3219 FakeEncoder(Clock::GetRealTimeClock()),
3220 task_queue_(task_queue),
3221 send_stream_(nullptr),
3222 bitrate_kbps_(0) {}
3223
3224 void OnVideoStreamsCreated(
3225 VideoSendStream* send_stream,
3226 const std::vector<VideoReceiveStream*>& receive_streams) override {
3227 send_stream_ = send_stream;
3228 }
3229
3230 void ModifyVideoConfigs(
3231 VideoSendStream::Config* send_config,
3232 std::vector<VideoReceiveStream::Config>* receive_configs,
3233 VideoEncoderConfig* encoder_config) override {
3234 send_config->encoder_settings.encoder = this;
3235 RTC_DCHECK_EQ(1, encoder_config->number_of_streams);
3236 }
3237
3238 int32_t SetRateAllocation(const BitrateAllocation& rate_allocation,
3239 uint32_t framerate) override {
3240 // Make sure not to trigger on any default zero bitrates.
3241 if (rate_allocation.get_sum_bps() == 0)
3242 return 0;
3243 rtc::CritScope lock(&crit_);
3244 bitrate_kbps_ = rate_allocation.get_sum_kbps();
3245 observation_complete_.Set();
3246 return 0;
3247 }
3248
3249 void PerformTest() override {
3250 ASSERT_TRUE(Wait())
3251 << "Timed out while waiting for encoder SetRates() call.";
3252
3253 task_queue_->SendTask([this]() {
3254 WaitForEncoderTargetBitrateMatchStats();
3255 send_stream_->Stop();
3256 WaitForStatsReportZeroTargetBitrate();
3257 send_stream_->Start();
3258 WaitForEncoderTargetBitrateMatchStats();
3259 });
3260 }
3261
3262 void WaitForEncoderTargetBitrateMatchStats() {
3263 for (int i = 0; i < kDefaultTimeoutMs; ++i) {
3264 VideoSendStream::Stats stats = send_stream_->GetStats();
3265 {
3266 rtc::CritScope lock(&crit_);
3267 if ((stats.target_media_bitrate_bps + 500) / 1000 ==
3268 static_cast<int>(bitrate_kbps_)) {
3269 return;
3270 }
3271 }
3272 SleepMs(1);
3273 }
3274 FAIL()
3275 << "Timed out waiting for stats reporting the currently set bitrate.";
3276 }
3277
3278 void WaitForStatsReportZeroTargetBitrate() {
3279 for (int i = 0; i < kDefaultTimeoutMs; ++i) {
3280 if (send_stream_->GetStats().target_media_bitrate_bps == 0) {
3281 return;
3282 }
3283 SleepMs(1);
3284 }
3285 FAIL() << "Timed out waiting for stats reporting zero bitrate.";
3286 }
3287
3288 private:
3289 test::SingleThreadedTaskQueueForTesting* const task_queue_;
3290 rtc::CriticalSection crit_;
3291 VideoSendStream* send_stream_;
3292 uint32_t bitrate_kbps_ RTC_GUARDED_BY(crit_);
3293 } test(&task_queue_);
3294
3295 RunBaseTest(&test);
3296 }
3297
3298 TEST_P(EndToEndTest, GetStats) {
3299 static const int kStartBitrateBps = 3000000;
3300 static const int kExpectedRenderDelayMs = 20;
3301
3302 class ReceiveStreamRenderer : public rtc::VideoSinkInterface<VideoFrame> {
3303 public:
3304 ReceiveStreamRenderer() {}
3305
3306 private:
3307 void OnFrame(const VideoFrame& video_frame) override {}
3308 };
3309
3310 class StatsObserver : public test::EndToEndTest,
3311 public rtc::VideoSinkInterface<VideoFrame> {
3312 public:
3313 StatsObserver()
3314 : EndToEndTest(kLongTimeoutMs),
3315 encoder_(Clock::GetRealTimeClock(), 10),
3316 send_stream_(nullptr),
3317 expected_send_ssrcs_(),
3318 check_stats_event_(false, false) {}
3319
3320 private:
3321 Action OnSendRtp(const uint8_t* packet, size_t length) override {
3322 // Drop every 25th packet => 4% loss.
3323 static const int kPacketLossFrac = 25;
3324 RTPHeader header;
3325 RtpUtility::RtpHeaderParser parser(packet, length);
3326 if (parser.Parse(&header) &&
3327 expected_send_ssrcs_.find(header.ssrc) !=
3328 expected_send_ssrcs_.end() &&
3329 header.sequenceNumber % kPacketLossFrac == 0) {
3330 return DROP_PACKET;
3331 }
3332 check_stats_event_.Set();
3333 return SEND_PACKET;
3334 }
3335
3336 Action OnSendRtcp(const uint8_t* packet, size_t length) override {
3337 check_stats_event_.Set();
3338 return SEND_PACKET;
3339 }
3340
3341 Action OnReceiveRtp(const uint8_t* packet, size_t length) override {
3342 check_stats_event_.Set();
3343 return SEND_PACKET;
3344 }
3345
3346 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
3347 check_stats_event_.Set();
3348 return SEND_PACKET;
3349 }
3350
3351 void OnFrame(const VideoFrame& video_frame) override {
3352 // Ensure that we have at least 5ms send side delay.
3353 SleepMs(5);
3354 }
3355
3356 bool CheckReceiveStats() {
3357 for (size_t i = 0; i < receive_streams_.size(); ++i) {
3358 VideoReceiveStream::Stats stats = receive_streams_[i]->GetStats();
3359 EXPECT_EQ(expected_receive_ssrcs_[i], stats.ssrc);
3360
3361 // Make sure all fields have been populated.
3362 // TODO(pbos): Use CompoundKey if/when we ever know that all stats are
3363 // always filled for all receivers.
3364 receive_stats_filled_["IncomingRate"] |=
3365 stats.network_frame_rate != 0 || stats.total_bitrate_bps != 0;
3366
3367 send_stats_filled_["DecoderImplementationName"] |=
3368 stats.decoder_implementation_name ==
3369 test::FakeDecoder::kImplementationName;
3370 receive_stats_filled_["RenderDelayAsHighAsExpected"] |=
3371 stats.render_delay_ms >= kExpectedRenderDelayMs;
3372
3373 receive_stats_filled_["FrameCallback"] |= stats.decode_frame_rate != 0;
3374
3375 receive_stats_filled_["FrameRendered"] |= stats.render_frame_rate != 0;
3376
3377 receive_stats_filled_["StatisticsUpdated"] |=
3378 stats.rtcp_stats.packets_lost != 0 ||
3379 stats.rtcp_stats.extended_highest_sequence_number != 0 ||
3380 stats.rtcp_stats.fraction_lost != 0 || stats.rtcp_stats.jitter != 0;
3381
3382 receive_stats_filled_["DataCountersUpdated"] |=
3383 stats.rtp_stats.transmitted.payload_bytes != 0 ||
3384 stats.rtp_stats.fec.packets != 0 ||
3385 stats.rtp_stats.transmitted.header_bytes != 0 ||
3386 stats.rtp_stats.transmitted.packets != 0 ||
3387 stats.rtp_stats.transmitted.padding_bytes != 0 ||
3388 stats.rtp_stats.retransmitted.packets != 0;
3389
3390 receive_stats_filled_["CodecStats"] |=
3391 stats.target_delay_ms != 0 || stats.discarded_packets != 0;
3392
3393 receive_stats_filled_["FrameCounts"] |=
3394 stats.frame_counts.key_frames != 0 ||
3395 stats.frame_counts.delta_frames != 0;
3396
3397 receive_stats_filled_["CName"] |= !stats.c_name.empty();
3398
3399 receive_stats_filled_["RtcpPacketTypeCount"] |=
3400 stats.rtcp_packet_type_counts.fir_packets != 0 ||
3401 stats.rtcp_packet_type_counts.nack_packets != 0 ||
3402 stats.rtcp_packet_type_counts.pli_packets != 0 ||
3403 stats.rtcp_packet_type_counts.nack_requests != 0 ||
3404 stats.rtcp_packet_type_counts.unique_nack_requests != 0;
3405
3406 assert(stats.current_payload_type == -1 ||
3407 stats.current_payload_type == kFakeVideoSendPayloadType);
3408 receive_stats_filled_["IncomingPayloadType"] |=
3409 stats.current_payload_type == kFakeVideoSendPayloadType;
3410 }
3411
3412 return AllStatsFilled(receive_stats_filled_);
3413 }
3414
3415 bool CheckSendStats() {
3416 RTC_DCHECK(send_stream_);
3417 VideoSendStream::Stats stats = send_stream_->GetStats();
3418
3419 size_t expected_num_streams = kNumSsrcs + expected_send_ssrcs_.size();
3420 send_stats_filled_["NumStreams"] |=
3421 stats.substreams.size() == expected_num_streams;
3422
3423 send_stats_filled_["CpuOveruseMetrics"] |=
3424 stats.avg_encode_time_ms != 0 && stats.encode_usage_percent != 0;
3425
3426 send_stats_filled_["EncoderImplementationName"] |=
3427 stats.encoder_implementation_name ==
3428 test::FakeEncoder::kImplementationName;
3429
3430 send_stats_filled_["EncoderPreferredBitrate"] |=
3431 stats.preferred_media_bitrate_bps > 0;
3432
3433 for (std::map<uint32_t, VideoSendStream::StreamStats>::const_iterator it =
3434 stats.substreams.begin();
3435 it != stats.substreams.end(); ++it) {
3436 if (expected_send_ssrcs_.find(it->first) == expected_send_ssrcs_.end())
3437 continue; // Probably RTX.
3438
3439 send_stats_filled_[CompoundKey("CapturedFrameRate", it->first)] |=
3440 stats.input_frame_rate != 0;
3441
3442 const VideoSendStream::StreamStats& stream_stats = it->second;
3443
3444 send_stats_filled_[CompoundKey("StatisticsUpdated", it->first)] |=
3445 stream_stats.rtcp_stats.packets_lost != 0 ||
3446 stream_stats.rtcp_stats.extended_highest_sequence_number != 0 ||
3447 stream_stats.rtcp_stats.fraction_lost != 0;
3448
3449 send_stats_filled_[CompoundKey("DataCountersUpdated", it->first)] |=
3450 stream_stats.rtp_stats.fec.packets != 0 ||
3451 stream_stats.rtp_stats.transmitted.padding_bytes != 0 ||
3452 stream_stats.rtp_stats.retransmitted.packets != 0 ||
3453 stream_stats.rtp_stats.transmitted.packets != 0;
3454
3455 send_stats_filled_[CompoundKey("BitrateStatisticsObserver.Total",
3456 it->first)] |=
3457 stream_stats.total_bitrate_bps != 0;
3458
3459 send_stats_filled_[CompoundKey("BitrateStatisticsObserver.Retransmit",
3460 it->first)] |=
3461 stream_stats.retransmit_bitrate_bps != 0;
3462
3463 send_stats_filled_[CompoundKey("FrameCountObserver", it->first)] |=
3464 stream_stats.frame_counts.delta_frames != 0 ||
3465 stream_stats.frame_counts.key_frames != 0;
3466
3467 send_stats_filled_[CompoundKey("OutgoingRate", it->first)] |=
3468 stats.encode_frame_rate != 0;
3469
3470 send_stats_filled_[CompoundKey("Delay", it->first)] |=
3471 stream_stats.avg_delay_ms != 0 || stream_stats.max_delay_ms != 0;
3472
3473 // TODO(pbos): Use CompoundKey when the test makes sure that all SSRCs
3474 // report dropped packets.
3475 send_stats_filled_["RtcpPacketTypeCount"] |=
3476 stream_stats.rtcp_packet_type_counts.fir_packets != 0 ||
3477 stream_stats.rtcp_packet_type_counts.nack_packets != 0 ||
3478 stream_stats.rtcp_packet_type_counts.pli_packets != 0 ||
3479 stream_stats.rtcp_packet_type_counts.nack_requests != 0 ||
3480 stream_stats.rtcp_packet_type_counts.unique_nack_requests != 0;
3481 }
3482
3483 return AllStatsFilled(send_stats_filled_);
3484 }
3485
3486 std::string CompoundKey(const char* name, uint32_t ssrc) {
3487 std::ostringstream oss;
3488 oss << name << "_" << ssrc;
3489 return oss.str();
3490 }
3491
3492 bool AllStatsFilled(const std::map<std::string, bool>& stats_map) {
3493 for (const auto& stat : stats_map) {
3494 if (!stat.second)
3495 return false;
3496 }
3497 return true;
3498 }
3499
3500 test::PacketTransport* CreateSendTransport(
3501 test::SingleThreadedTaskQueueForTesting* task_queue,
3502 Call* sender_call) override {
3503 FakeNetworkPipe::Config network_config;
3504 network_config.loss_percent = 5;
3505 return new test::PacketTransport(task_queue, sender_call, this,
3506 test::PacketTransport::kSender,
3507 payload_type_map_, network_config);
3508 }
3509
3510 Call::Config GetSenderCallConfig() override {
3511 Call::Config config = EndToEndTest::GetSenderCallConfig();
3512 config.bitrate_config.start_bitrate_bps = kStartBitrateBps;
3513 return config;
3514 }
3515
3516 // This test use other VideoStream settings than the the default settings
3517 // implemented in DefaultVideoStreamFactory. Therefore this test implement
3518 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created
3519 // in ModifyVideoConfigs.
3520 class VideoStreamFactory
3521 : public VideoEncoderConfig::VideoStreamFactoryInterface {
3522 public:
3523 VideoStreamFactory() {}
3524
3525 private:
3526 std::vector<VideoStream> CreateEncoderStreams(
3527 int width,
3528 int height,
3529 const VideoEncoderConfig& encoder_config) override {
3530 std::vector<VideoStream> streams =
3531 test::CreateVideoStreams(width, height, encoder_config);
3532 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
3533 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
3534 streams[i].min_bitrate_bps = 10000;
3535 streams[i].target_bitrate_bps = 15000;
3536 streams[i].max_bitrate_bps = 20000;
3537 }
3538 return streams;
3539 }
3540 };
3541
3542 void ModifyVideoConfigs(
3543 VideoSendStream::Config* send_config,
3544 std::vector<VideoReceiveStream::Config>* receive_configs,
3545 VideoEncoderConfig* encoder_config) override {
3546 encoder_config->video_stream_factory =
3547 new rtc::RefCountedObject<VideoStreamFactory>();
3548 send_config->pre_encode_callback = this; // Used to inject delay.
3549 expected_cname_ = send_config->rtp.c_name = "SomeCName";
3550
3551 send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
3552 send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
3553
3554 const std::vector<uint32_t>& ssrcs = send_config->rtp.ssrcs;
3555 for (size_t i = 0; i < ssrcs.size(); ++i) {
3556 expected_send_ssrcs_.insert(ssrcs[i]);
3557 expected_receive_ssrcs_.push_back(
3558 (*receive_configs)[i].rtp.remote_ssrc);
3559 (*receive_configs)[i].render_delay_ms = kExpectedRenderDelayMs;
3560 (*receive_configs)[i].renderer = &receive_stream_renderer_;
3561 (*receive_configs)[i].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
3562
3563 (*receive_configs)[i].rtp.rtx_ssrc = kSendRtxSsrcs[i];
3564 (*receive_configs)[i]
3565 .rtp.rtx_associated_payload_types[kSendRtxPayloadType] =
3566 kFakeVideoSendPayloadType;
3567 }
3568
3569 for (size_t i = 0; i < kNumSsrcs; ++i)
3570 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
3571
3572 // Use a delayed encoder to make sure we see CpuOveruseMetrics stats that
3573 // are non-zero.
3574 send_config->encoder_settings.encoder = &encoder_;
3575 }
3576
3577 size_t GetNumVideoStreams() const override { return kNumSsrcs; }
3578
3579 void OnVideoStreamsCreated(
3580 VideoSendStream* send_stream,
3581 const std::vector<VideoReceiveStream*>& receive_streams) override {
3582 send_stream_ = send_stream;
3583 receive_streams_ = receive_streams;
3584 }
3585
3586 void PerformTest() override {
3587 Clock* clock = Clock::GetRealTimeClock();
3588 int64_t now = clock->TimeInMilliseconds();
3589 int64_t stop_time = now + test::CallTest::kLongTimeoutMs;
3590 bool receive_ok = false;
3591 bool send_ok = false;
3592
3593 while (now < stop_time) {
3594 if (!receive_ok)
3595 receive_ok = CheckReceiveStats();
3596 if (!send_ok)
3597 send_ok = CheckSendStats();
3598
3599 if (receive_ok && send_ok)
3600 return;
3601
3602 int64_t time_until_timout_ = stop_time - now;
3603 if (time_until_timout_ > 0)
3604 check_stats_event_.Wait(time_until_timout_);
3605 now = clock->TimeInMilliseconds();
3606 }
3607
3608 ADD_FAILURE() << "Timed out waiting for filled stats.";
3609 for (std::map<std::string, bool>::const_iterator it =
3610 receive_stats_filled_.begin();
3611 it != receive_stats_filled_.end(); ++it) {
3612 if (!it->second) {
3613 ADD_FAILURE() << "Missing receive stats: " << it->first;
3614 }
3615 }
3616
3617 for (std::map<std::string, bool>::const_iterator it =
3618 send_stats_filled_.begin();
3619 it != send_stats_filled_.end(); ++it) {
3620 if (!it->second) {
3621 ADD_FAILURE() << "Missing send stats: " << it->first;
3622 }
3623 }
3624 }
3625
3626 test::DelayedEncoder encoder_;
3627 std::vector<VideoReceiveStream*> receive_streams_;
3628 std::map<std::string, bool> receive_stats_filled_;
3629
3630 VideoSendStream* send_stream_;
3631 std::map<std::string, bool> send_stats_filled_;
3632
3633 std::vector<uint32_t> expected_receive_ssrcs_;
3634 std::set<uint32_t> expected_send_ssrcs_;
3635 std::string expected_cname_;
3636
3637 rtc::Event check_stats_event_;
3638 ReceiveStreamRenderer receive_stream_renderer_;
3639 } test;
3640
3641 RunBaseTest(&test);
3642 }
3643
3644 TEST_P(EndToEndTest, TimingFramesAreReported) {
3645 static const int kExtensionId = 5;
3646
3647 class StatsObserver : public test::EndToEndTest {
3648 public:
3649 StatsObserver() : EndToEndTest(kLongTimeoutMs) {}
3650
3651 private:
3652 void ModifyVideoConfigs(
3653 VideoSendStream::Config* send_config,
3654 std::vector<VideoReceiveStream::Config>* receive_configs,
3655 VideoEncoderConfig* encoder_config) override {
3656 send_config->rtp.extensions.clear();
3657 send_config->rtp.extensions.push_back(
3658 RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId));
3659 for (size_t i = 0; i < receive_configs->size(); ++i) {
3660 (*receive_configs)[i].rtp.extensions.clear();
3661 (*receive_configs)[i].rtp.extensions.push_back(
3662 RtpExtension(RtpExtension::kVideoTimingUri, kExtensionId));
3663 }
3664 }
3665
3666 void OnVideoStreamsCreated(
3667 VideoSendStream* send_stream,
3668 const std::vector<VideoReceiveStream*>& receive_streams) override {
3669 receive_streams_ = receive_streams;
3670 }
3671
3672 void PerformTest() override {
3673 // No frames reported initially.
3674 for (size_t i = 0; i < receive_streams_.size(); ++i) {
3675 EXPECT_FALSE(receive_streams_[i]->GetStats().timing_frame_info);
3676 }
3677 // Wait for at least one timing frame to be sent with 100ms grace period.
3678 SleepMs(kDefaultTimingFramesDelayMs + 100);
3679 // Check that timing frames are reported for each stream.
3680 for (size_t i = 0; i < receive_streams_.size(); ++i) {
3681 EXPECT_TRUE(receive_streams_[i]->GetStats().timing_frame_info);
3682 }
3683 }
3684
3685 std::vector<VideoReceiveStream*> receive_streams_;
3686 } test;
3687
3688 RunBaseTest(&test);
3689 }
3690
3691 class RtcpXrObserver : public test::EndToEndTest {
3692 public:
3693 RtcpXrObserver(bool enable_rrtr, bool enable_target_bitrate,
3694 bool enable_zero_target_bitrate)
3695 : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
3696 enable_rrtr_(enable_rrtr),
3697 enable_target_bitrate_(enable_target_bitrate),
3698 enable_zero_target_bitrate_(enable_zero_target_bitrate),
3699 sent_rtcp_sr_(0),
3700 sent_rtcp_rr_(0),
3701 sent_rtcp_rrtr_(0),
3702 sent_rtcp_target_bitrate_(false),
3703 sent_zero_rtcp_target_bitrate_(false),
3704 sent_rtcp_dlrr_(0) {}
3705
3706 private:
3707 // Receive stream should send RR packets (and RRTR packets if enabled).
3708 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
3709 rtc::CritScope lock(&crit_);
3710 test::RtcpPacketParser parser;
3711 EXPECT_TRUE(parser.Parse(packet, length));
3712
3713 sent_rtcp_rr_ += parser.receiver_report()->num_packets();
3714 EXPECT_EQ(0, parser.sender_report()->num_packets());
3715 EXPECT_GE(1, parser.xr()->num_packets());
3716 if (parser.xr()->num_packets() > 0) {
3717 if (parser.xr()->rrtr())
3718 ++sent_rtcp_rrtr_;
3719 EXPECT_FALSE(parser.xr()->dlrr());
3720 }
3721
3722 return SEND_PACKET;
3723 }
3724 // Send stream should send SR packets (and DLRR packets if enabled).
3725 Action OnSendRtcp(const uint8_t* packet, size_t length) override {
3726 rtc::CritScope lock(&crit_);
3727 test::RtcpPacketParser parser;
3728 EXPECT_TRUE(parser.Parse(packet, length));
3729
3730 sent_rtcp_sr_ += parser.sender_report()->num_packets();
3731 EXPECT_LE(parser.xr()->num_packets(), 1);
3732 if (parser.xr()->num_packets() > 0) {
3733 EXPECT_FALSE(parser.xr()->rrtr());
3734 if (parser.xr()->dlrr())
3735 ++sent_rtcp_dlrr_;
3736 if (parser.xr()->target_bitrate()) {
3737 sent_rtcp_target_bitrate_ = true;
3738 for (const rtcp::TargetBitrate::BitrateItem& item :
3739 parser.xr()->target_bitrate()->GetTargetBitrates()) {
3740 if (item.target_bitrate_kbps == 0) {
3741 sent_zero_rtcp_target_bitrate_ = true;
3742 break;
3743 }
3744 }
3745 }
3746 }
3747
3748 if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&
3749 sent_rtcp_rr_ > kNumRtcpReportPacketsToObserve &&
3750 (sent_rtcp_target_bitrate_ || !enable_target_bitrate_) &&
3751 (sent_zero_rtcp_target_bitrate_ || !enable_zero_target_bitrate_)) {
3752 if (enable_rrtr_) {
3753 EXPECT_GT(sent_rtcp_rrtr_, 0);
3754 EXPECT_GT(sent_rtcp_dlrr_, 0);
3755 } else {
3756 EXPECT_EQ(sent_rtcp_rrtr_, 0);
3757 EXPECT_EQ(sent_rtcp_dlrr_, 0);
3758 }
3759 EXPECT_EQ(enable_target_bitrate_, sent_rtcp_target_bitrate_);
3760 EXPECT_EQ(enable_zero_target_bitrate_, sent_zero_rtcp_target_bitrate_);
3761 observation_complete_.Set();
3762 }
3763 return SEND_PACKET;
3764 }
3765
3766 size_t GetNumVideoStreams() const override {
3767 // When sending a zero target bitrate, we use two spatial layers so that
3768 // we'll still have a layer with non-zero bitrate.
3769 return enable_zero_target_bitrate_ ? 2 : 1;
3770 }
3771
3772 // This test uses VideoStream settings different from the the default one
3773 // implemented in DefaultVideoStreamFactory, so it implements its own
3774 // VideoEncoderConfig::VideoStreamFactoryInterface which is created
3775 // in ModifyVideoConfigs.
3776 class ZeroTargetVideoStreamFactory
3777 : public VideoEncoderConfig::VideoStreamFactoryInterface {
3778 public:
3779 ZeroTargetVideoStreamFactory() {}
3780
3781 private:
3782 std::vector<VideoStream> CreateEncoderStreams(
3783 int width,
3784 int height,
3785 const VideoEncoderConfig& encoder_config) override {
3786 std::vector<VideoStream> streams =
3787 test::CreateVideoStreams(width, height, encoder_config);
3788 // Set one of the streams' target bitrates to zero to test that a
3789 // bitrate of 0 can be signalled.
3790 streams[encoder_config.number_of_streams-1].min_bitrate_bps = 0;
3791 streams[encoder_config.number_of_streams-1].target_bitrate_bps = 0;
3792 streams[encoder_config.number_of_streams-1].max_bitrate_bps = 0;
3793 return streams;
3794 }
3795 };
3796
3797 void ModifyVideoConfigs(
3798 VideoSendStream::Config* send_config,
3799 std::vector<VideoReceiveStream::Config>* receive_configs,
3800 VideoEncoderConfig* encoder_config) override {
3801 if (enable_zero_target_bitrate_) {
3802 encoder_config->video_stream_factory =
3803 new rtc::RefCountedObject<ZeroTargetVideoStreamFactory>();
3804
3805 // Configure VP8 to be able to use simulcast.
3806 send_config->encoder_settings.payload_name = "VP8";
3807 (*receive_configs)[0].decoders.resize(1);
3808 (*receive_configs)[0].decoders[0].payload_type =
3809 send_config->encoder_settings.payload_type;
3810 (*receive_configs)[0].decoders[0].payload_name =
3811 send_config->encoder_settings.payload_name;
3812 }
3813 if (enable_target_bitrate_) {
3814 // TargetBitrate only signaled for screensharing.
3815 encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
3816 }
3817 (*receive_configs)[0].rtp.rtcp_mode = RtcpMode::kReducedSize;
3818 (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report =
3819 enable_rrtr_;
3820 }
3821
3822 void PerformTest() override {
3823 EXPECT_TRUE(Wait())
3824 << "Timed out while waiting for RTCP SR/RR packets to be sent.";
3825 }
3826
3827 static const int kNumRtcpReportPacketsToObserve = 5;
3828
3829 rtc::CriticalSection crit_;
3830 const bool enable_rrtr_;
3831 const bool enable_target_bitrate_;
3832 const bool enable_zero_target_bitrate_;
3833 int sent_rtcp_sr_;
3834 int sent_rtcp_rr_ RTC_GUARDED_BY(&crit_);
3835 int sent_rtcp_rrtr_ RTC_GUARDED_BY(&crit_);
3836 bool sent_rtcp_target_bitrate_ RTC_GUARDED_BY(&crit_);
3837 bool sent_zero_rtcp_target_bitrate_ RTC_GUARDED_BY(&crit_);
3838 int sent_rtcp_dlrr_;
3839 };
3840
3841 TEST_P(EndToEndTest, TestExtendedReportsWithRrtrWithoutTargetBitrate) {
3842 RtcpXrObserver test(/*enable_rrtr=*/true, /*enable_target_bitrate=*/false,
3843 /*enable_zero_target_bitrate=*/false);
3844 RunBaseTest(&test);
3845 }
3846
3847 TEST_P(EndToEndTest, TestExtendedReportsWithoutRrtrWithoutTargetBitrate) {
3848 RtcpXrObserver test(/*enable_rrtr=*/false, /*enable_target_bitrate=*/false,
3849 /*enable_zero_target_bitrate=*/false);
3850 RunBaseTest(&test);
3851 }
3852
3853 TEST_P(EndToEndTest, TestExtendedReportsWithRrtrWithTargetBitrate) {
3854 RtcpXrObserver test(/*enable_rrtr=*/true, /*enable_target_bitrate=*/true,
3855 /*enable_zero_target_bitrate=*/false);
3856 RunBaseTest(&test);
3857 }
3858
3859 TEST_P(EndToEndTest, TestExtendedReportsWithoutRrtrWithTargetBitrate) {
3860 RtcpXrObserver test(/*enable_rrtr=*/false, /*enable_target_bitrate=*/true,
3861 /*enable_zero_target_bitrate=*/false);
3862 RunBaseTest(&test);
3863 }
3864
3865 TEST_P(EndToEndTest, TestExtendedReportsCanSignalZeroTargetBitrate) {
3866 RtcpXrObserver test(/*enable_rrtr=*/false, /*enable_target_bitrate=*/true,
3867 /*enable_zero_target_bitrate=*/true);
3868 RunBaseTest(&test);
3869 }
3870
3871 TEST_P(EndToEndTest, TestReceivedRtpPacketStats) {
3872 static const size_t kNumRtpPacketsToSend = 5;
3873 class ReceivedRtpStatsObserver : public test::EndToEndTest {
3874 public:
3875 ReceivedRtpStatsObserver()
3876 : EndToEndTest(kDefaultTimeoutMs),
3877 receive_stream_(nullptr),
3878 sent_rtp_(0) {}
3879
3880 private:
3881 void OnVideoStreamsCreated(
3882 VideoSendStream* send_stream,
3883 const std::vector<VideoReceiveStream*>& receive_streams) override {
3884 receive_stream_ = receive_streams[0];
3885 }
3886
3887 Action OnSendRtp(const uint8_t* packet, size_t length) override {
3888 if (sent_rtp_ >= kNumRtpPacketsToSend) {
3889 VideoReceiveStream::Stats stats = receive_stream_->GetStats();
3890 if (kNumRtpPacketsToSend == stats.rtp_stats.transmitted.packets) {
3891 observation_complete_.Set();
3892 }
3893 return DROP_PACKET;
3894 }
3895 ++sent_rtp_;
3896 return SEND_PACKET;
3897 }
3898
3899 void PerformTest() override {
3900 EXPECT_TRUE(Wait())
3901 << "Timed out while verifying number of received RTP packets.";
3902 }
3903
3904 VideoReceiveStream* receive_stream_;
3905 uint32_t sent_rtp_;
3906 } test;
3907
3908 RunBaseTest(&test);
3909 }
3910
3911 TEST_P(EndToEndTest, SendsSetSsrc) {
3912 TestSendsSetSsrcs(1, false);
3913 }
3914
3915 TEST_P(EndToEndTest, SendsSetSimulcastSsrcs) {
3916 TestSendsSetSsrcs(kNumSsrcs, false);
3917 }
3918
3919 TEST_P(EndToEndTest, CanSwitchToUseAllSsrcs) {
3920 TestSendsSetSsrcs(kNumSsrcs, true);
3921 }
3922
3923 TEST_P(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
3924 class ObserveRedundantPayloads: public test::EndToEndTest {
3925 public:
3926 ObserveRedundantPayloads()
3927 : EndToEndTest(kDefaultTimeoutMs), ssrcs_to_observe_(kNumSsrcs) {
3928 for (size_t i = 0; i < kNumSsrcs; ++i) {
3929 registered_rtx_ssrc_[kSendRtxSsrcs[i]] = true;
3930 }
3931 }
3932
3933 private:
3934 Action OnSendRtp(const uint8_t* packet, size_t length) override {
3935 RTPHeader header;
3936 EXPECT_TRUE(parser_->Parse(packet, length, &header));
3937
3938 if (!registered_rtx_ssrc_[header.ssrc])
3939 return SEND_PACKET;
3940
3941 EXPECT_LE(header.headerLength + header.paddingLength, length);
3942 const bool packet_is_redundant_payload =
3943 header.headerLength + header.paddingLength < length;
3944
3945 if (!packet_is_redundant_payload)
3946 return SEND_PACKET;
3947
3948 if (!observed_redundant_retransmission_[header.ssrc]) {
3949 observed_redundant_retransmission_[header.ssrc] = true;
3950 if (--ssrcs_to_observe_ == 0)
3951 observation_complete_.Set();
3952 }
3953
3954 return SEND_PACKET;
3955 }
3956
3957 size_t GetNumVideoStreams() const override { return kNumSsrcs; }
3958
3959 // This test use other VideoStream settings than the the default settings
3960 // implemented in DefaultVideoStreamFactory. Therefore this test implement
3961 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created
3962 // in ModifyVideoConfigs.
3963 class VideoStreamFactory
3964 : public VideoEncoderConfig::VideoStreamFactoryInterface {
3965 public:
3966 VideoStreamFactory() {}
3967
3968 private:
3969 std::vector<VideoStream> CreateEncoderStreams(
3970 int width,
3971 int height,
3972 const VideoEncoderConfig& encoder_config) override {
3973 std::vector<VideoStream> streams =
3974 test::CreateVideoStreams(width, height, encoder_config);
3975 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
3976 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
3977 streams[i].min_bitrate_bps = 10000;
3978 streams[i].target_bitrate_bps = 15000;
3979 streams[i].max_bitrate_bps = 20000;
3980 }
3981 return streams;
3982 }
3983 };
3984
3985 void ModifyVideoConfigs(
3986 VideoSendStream::Config* send_config,
3987 std::vector<VideoReceiveStream::Config>* receive_configs,
3988 VideoEncoderConfig* encoder_config) override {
3989 // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
3990 encoder_config->video_stream_factory =
3991 new rtc::RefCountedObject<VideoStreamFactory>();
3992 send_config->rtp.rtx.payload_type = kSendRtxPayloadType;
3993
3994 for (size_t i = 0; i < kNumSsrcs; ++i)
3995 send_config->rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
3996
3997 // Significantly higher than max bitrates for all video streams -> forcing
3998 // padding to trigger redundant padding on all RTX SSRCs.
3999 encoder_config->min_transmit_bitrate_bps = 100000;
4000 }
4001
4002 void PerformTest() override {
4003 EXPECT_TRUE(Wait())
4004 << "Timed out while waiting for redundant payloads on all SSRCs.";
4005 }
4006
4007 private:
4008 size_t ssrcs_to_observe_;
4009 std::map<uint32_t, bool> observed_redundant_retransmission_;
4010 std::map<uint32_t, bool> registered_rtx_ssrc_;
4011 } test;
4012
4013 RunBaseTest(&test);
4014 }
4015
4016 void EndToEndTest::TestRtpStatePreservation(bool use_rtx,
4017 bool provoke_rtcpsr_before_rtp) {
4018 // This test uses other VideoStream settings than the the default settings
4019 // implemented in DefaultVideoStreamFactory. Therefore this test implements
4020 // its own VideoEncoderConfig::VideoStreamFactoryInterface which is created
4021 // in ModifyVideoConfigs.
4022 class VideoStreamFactory
4023 : public VideoEncoderConfig::VideoStreamFactoryInterface {
4024 public:
4025 VideoStreamFactory() {}
4026
4027 private:
4028 std::vector<VideoStream> CreateEncoderStreams(
4029 int width,
4030 int height,
4031 const VideoEncoderConfig& encoder_config) override {
4032 std::vector<VideoStream> streams =
4033 test::CreateVideoStreams(width, height, encoder_config);
4034
4035 if (encoder_config.number_of_streams > 1) {
4036 // Lower bitrates so that all streams send initially.
4037 RTC_DCHECK_EQ(3, encoder_config.number_of_streams);
4038 for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
4039 streams[i].min_bitrate_bps = 10000;
4040 streams[i].target_bitrate_bps = 15000;
4041 streams[i].max_bitrate_bps = 20000;
4042 }
4043 } else {
4044 // Use the same total bitrates when sending a single stream to avoid
4045 // lowering
4046 // the bitrate estimate and requiring a subsequent rampup.
4047 streams[0].min_bitrate_bps = 3 * 10000;
4048 streams[0].target_bitrate_bps = 3 * 15000;
4049 streams[0].max_bitrate_bps = 3 * 20000;
4050 }
4051 return streams;
4052 }
4053 };
4054
4055 class RtpSequenceObserver : public test::RtpRtcpObserver {
4056 public:
4057 explicit RtpSequenceObserver(bool use_rtx)
4058 : test::RtpRtcpObserver(kDefaultTimeoutMs),
4059 ssrcs_to_observe_(kNumSsrcs) {
4060 for (size_t i = 0; i < kNumSsrcs; ++i) {
4061 ssrc_is_rtx_[kVideoSendSsrcs[i]] = false;
4062 if (use_rtx)
4063 ssrc_is_rtx_[kSendRtxSsrcs[i]] = true;
4064 }
4065 }
4066
4067 void ResetExpectedSsrcs(size_t num_expected_ssrcs) {
4068 rtc::CritScope lock(&crit_);
4069 ssrc_observed_.clear();
4070 ssrcs_to_observe_ = num_expected_ssrcs;
4071 }
4072
4073 private:
4074 void ValidateTimestampGap(uint32_t ssrc,
4075 uint32_t timestamp,
4076 bool only_padding)
4077 RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
4078 static const int32_t kMaxTimestampGap = kDefaultTimeoutMs * 90;
4079 auto timestamp_it = last_observed_timestamp_.find(ssrc);
4080 if (timestamp_it == last_observed_timestamp_.end()) {
4081 EXPECT_FALSE(only_padding);
4082 last_observed_timestamp_[ssrc] = timestamp;
4083 } else {
4084 // Verify timestamps are reasonably close.
4085 uint32_t latest_observed = timestamp_it->second;
4086 // Wraparound handling is unnecessary here as long as an int variable
4087 // is used to store the result.
4088 int32_t timestamp_gap = timestamp - latest_observed;
4089 EXPECT_LE(std::abs(timestamp_gap), kMaxTimestampGap)
4090 << "Gap in timestamps (" << latest_observed << " -> " << timestamp
4091 << ") too large for SSRC: " << ssrc << ".";
4092 timestamp_it->second = timestamp;
4093 }
4094 }
4095
4096 Action OnSendRtp(const uint8_t* packet, size_t length) override {
4097 RTPHeader header;
4098 EXPECT_TRUE(parser_->Parse(packet, length, &header));
4099 const uint32_t ssrc = header.ssrc;
4100 const int64_t sequence_number =
4101 seq_numbers_unwrapper_.Unwrap(header.sequenceNumber);
4102 const uint32_t timestamp = header.timestamp;
4103 const bool only_padding =
4104 header.headerLength + header.paddingLength == length;
4105
4106 EXPECT_TRUE(ssrc_is_rtx_.find(ssrc) != ssrc_is_rtx_.end())
4107 << "Received SSRC that wasn't configured: " << ssrc;
4108
4109 static const int64_t kMaxSequenceNumberGap = 100;
4110 std::list<int64_t>* seq_numbers = &last_observed_seq_numbers_[ssrc];
4111 if (seq_numbers->empty()) {
4112 seq_numbers->push_back(sequence_number);
4113 } else {
4114 // We shouldn't get replays of previous sequence numbers.
4115 for (int64_t observed : *seq_numbers) {
4116 EXPECT_NE(observed, sequence_number)
4117 << "Received sequence number " << sequence_number
4118 << " for SSRC " << ssrc << " 2nd time.";
4119 }
4120 // Verify sequence numbers are reasonably close.
4121 int64_t latest_observed = seq_numbers->back();
4122 int64_t sequence_number_gap = sequence_number - latest_observed;
4123 EXPECT_LE(std::abs(sequence_number_gap), kMaxSequenceNumberGap)
4124 << "Gap in sequence numbers (" << latest_observed << " -> "
4125 << sequence_number << ") too large for SSRC: " << ssrc << ".";
4126 seq_numbers->push_back(sequence_number);
4127 if (seq_numbers->size() >= kMaxSequenceNumberGap) {
4128 seq_numbers->pop_front();
4129 }
4130 }
4131
4132 if (!ssrc_is_rtx_[ssrc]) {
4133 rtc::CritScope lock(&crit_);
4134 ValidateTimestampGap(ssrc, timestamp, only_padding);
4135
4136 // Wait for media packets on all ssrcs.
4137 if (!ssrc_observed_[ssrc] && !only_padding) {
4138 ssrc_observed_[ssrc] = true;
4139 if (--ssrcs_to_observe_ == 0)
4140 observation_complete_.Set();
4141 }
4142 }
4143
4144 return SEND_PACKET;
4145 }
4146
4147 Action OnSendRtcp(const uint8_t* packet, size_t length) override {
4148 test::RtcpPacketParser rtcp_parser;
4149 rtcp_parser.Parse(packet, length);
4150 if (rtcp_parser.sender_report()->num_packets() > 0) {
4151 uint32_t ssrc = rtcp_parser.sender_report()->sender_ssrc();
4152 uint32_t rtcp_timestamp = rtcp_parser.sender_report()->rtp_timestamp();
4153
4154 rtc::CritScope lock(&crit_);
4155 ValidateTimestampGap(ssrc, rtcp_timestamp, false);
4156 }
4157 return SEND_PACKET;
4158 }
4159
4160 SequenceNumberUnwrapper seq_numbers_unwrapper_;
4161 std::map<uint32_t, std::list<int64_t>> last_observed_seq_numbers_;
4162 std::map<uint32_t, uint32_t> last_observed_timestamp_;
4163 std::map<uint32_t, bool> ssrc_is_rtx_;
4164
4165 rtc::CriticalSection crit_;
4166 size_t ssrcs_to_observe_ RTC_GUARDED_BY(crit_);
4167 std::map<uint32_t, bool> ssrc_observed_ RTC_GUARDED_BY(crit_);
4168 } observer(use_rtx);
4169
4170 std::unique_ptr<test::PacketTransport> send_transport;
4171 std::unique_ptr<test::PacketTransport> receive_transport;
4172
4173 Call::Config config(event_log_.get());
4174 VideoEncoderConfig one_stream;
4175
4176 task_queue_.SendTask([this, &observer, &send_transport, &receive_transport,
4177 &config, &one_stream, use_rtx]() {
4178 CreateCalls(config, config);
4179
4180 send_transport = rtc::MakeUnique<test::PacketTransport>(
4181 &task_queue_, sender_call_.get(), &observer,
4182 test::PacketTransport::kSender, payload_type_map_,
4183 FakeNetworkPipe::Config());
4184 receive_transport = rtc::MakeUnique<test::PacketTransport>(
4185 &task_queue_, nullptr, &observer, test::PacketTransport::kReceiver,
4186 payload_type_map_, FakeNetworkPipe::Config());
4187 send_transport->SetReceiver(receiver_call_->Receiver());
4188 receive_transport->SetReceiver(sender_call_->Receiver());
4189
4190 CreateSendConfig(kNumSsrcs, 0, 0, send_transport.get());
4191
4192 if (use_rtx) {
4193 for (size_t i = 0; i < kNumSsrcs; ++i) {
4194 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[i]);
4195 }
4196 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
4197 }
4198
4199 video_encoder_config_.video_stream_factory =
4200 new rtc::RefCountedObject<VideoStreamFactory>();
4201 // Use the same total bitrates when sending a single stream to avoid
4202 // lowering the bitrate estimate and requiring a subsequent rampup.
4203 one_stream = video_encoder_config_.Copy();
4204 // one_stream.streams.resize(1);
4205 one_stream.number_of_streams = 1;
4206 CreateMatchingReceiveConfigs(receive_transport.get());
4207
4208 CreateVideoStreams();
4209 CreateFrameGeneratorCapturer(30, 1280, 720);
4210
4211 Start();
4212 });
4213
4214 EXPECT_TRUE(observer.Wait())
4215 << "Timed out waiting for all SSRCs to send packets.";
4216
4217 // Test stream resetting more than once to make sure that the state doesn't
4218 // get set once (this could be due to using std::map::insert for instance).
4219 for (size_t i = 0; i < 3; ++i) {
4220 task_queue_.SendTask([&]() {
4221 frame_generator_capturer_->Stop();
4222 sender_call_->DestroyVideoSendStream(video_send_stream_);
4223
4224 // Re-create VideoSendStream with only one stream.
4225 video_send_stream_ = sender_call_->CreateVideoSendStream(
4226 video_send_config_.Copy(), one_stream.Copy());
4227 video_send_stream_->Start();
4228 if (provoke_rtcpsr_before_rtp) {
4229 // Rapid Resync Request forces sending RTCP Sender Report back.
4230 // Using this request speeds up this test because then there is no need
4231 // to wait for a second for periodic Sender Report.
4232 rtcp::RapidResyncRequest force_send_sr_back_request;
4233 rtc::Buffer packet = force_send_sr_back_request.Build();
4234 static_cast<webrtc::test::DirectTransport*>(receive_transport.get())
4235 ->SendRtcp(packet.data(), packet.size());
4236 }
4237 CreateFrameGeneratorCapturer(30, 1280, 720);
4238 frame_generator_capturer_->Start();
4239 });
4240
4241 observer.ResetExpectedSsrcs(1);
4242 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
4243
4244 // Reconfigure back to use all streams.
4245 task_queue_.SendTask([this]() {
4246 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy());
4247 });
4248 observer.ResetExpectedSsrcs(kNumSsrcs);
4249 EXPECT_TRUE(observer.Wait())
4250 << "Timed out waiting for all SSRCs to send packets.";
4251
4252 // Reconfigure down to one stream.
4253 task_queue_.SendTask([this, &one_stream]() {
4254 video_send_stream_->ReconfigureVideoEncoder(one_stream.Copy());
4255 });
4256 observer.ResetExpectedSsrcs(1);
4257 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for single RTP packet.";
4258
4259 // Reconfigure back to use all streams.
4260 task_queue_.SendTask([this]() {
4261 video_send_stream_->ReconfigureVideoEncoder(video_encoder_config_.Copy());
4262 });
4263 observer.ResetExpectedSsrcs(kNumSsrcs);
4264 EXPECT_TRUE(observer.Wait())
4265 << "Timed out waiting for all SSRCs to send packets.";
4266 }
4267
4268 task_queue_.SendTask([this, &send_transport, &receive_transport]() {
4269 Stop();
4270 DestroyStreams();
4271 send_transport.reset();
4272 receive_transport.reset();
4273 DestroyCalls();
4274 });
4275 }
4276
4277 TEST_P(EndToEndTest, RestartingSendStreamPreservesRtpState) {
4278 TestRtpStatePreservation(false, false);
4279 }
4280
4281 TEST_P(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) {
4282 TestRtpStatePreservation(true, false);
4283 }
4284
4285 TEST_P(EndToEndTest, RestartingSendStreamKeepsRtpAndRtcpTimestampsSynced) {
4286 TestRtpStatePreservation(true, true);
4287 }
4288
4289 // This test is flaky on linux_memcheck. Disable on all linux bots until
4290 // flakyness has been fixed.
4291 // https://bugs.chromium.org/p/webrtc/issues/detail?id=7737
4292 #if defined(WEBRTC_LINUX)
4293 TEST_P(EndToEndTest, DISABLED_TestFlexfecRtpStatePreservation) {
4294 #else
4295 TEST_P(EndToEndTest, TestFlexfecRtpStatePreservation) {
4296 #endif
4297 class RtpSequenceObserver : public test::RtpRtcpObserver {
4298 public:
4299 RtpSequenceObserver()
4300 : test::RtpRtcpObserver(kDefaultTimeoutMs),
4301 num_flexfec_packets_sent_(0) {}
4302
4303 void ResetPacketCount() {
4304 rtc::CritScope lock(&crit_);
4305 num_flexfec_packets_sent_ = 0;
4306 }
4307
4308 private:
4309 Action OnSendRtp(const uint8_t* packet, size_t length) override {
4310 rtc::CritScope lock(&crit_);
4311
4312 RTPHeader header;
4313 EXPECT_TRUE(parser_->Parse(packet, length, &header));
4314 const uint16_t sequence_number = header.sequenceNumber;
4315 const uint32_t timestamp = header.timestamp;
4316 const uint32_t ssrc = header.ssrc;
4317
4318 if (ssrc == kVideoSendSsrcs[0] || ssrc == kSendRtxSsrcs[0]) {
4319 return SEND_PACKET;
4320 }
4321 EXPECT_EQ(kFlexfecSendSsrc, ssrc) << "Unknown SSRC sent.";
4322
4323 ++num_flexfec_packets_sent_;
4324
4325 // If this is the first packet, we have nothing to compare to.
4326 if (!last_observed_sequence_number_) {
4327 last_observed_sequence_number_.emplace(sequence_number);
4328 last_observed_timestamp_.emplace(timestamp);
4329
4330 return SEND_PACKET;
4331 }
4332
4333 // Verify continuity and monotonicity of RTP sequence numbers.
4334 EXPECT_EQ(static_cast<uint16_t>(*last_observed_sequence_number_ + 1),
4335 sequence_number);
4336 last_observed_sequence_number_.emplace(sequence_number);
4337
4338 // Timestamps should be non-decreasing...
4339 const bool timestamp_is_same_or_newer =
4340 timestamp == *last_observed_timestamp_ ||
4341 IsNewerTimestamp(timestamp, *last_observed_timestamp_);
4342 EXPECT_TRUE(timestamp_is_same_or_newer);
4343 // ...but reasonably close in time.
4344 const int k10SecondsInRtpTimestampBase = 10 * kVideoPayloadTypeFrequency;
4345 EXPECT_TRUE(IsNewerTimestamp(
4346 *last_observed_timestamp_ + k10SecondsInRtpTimestampBase, timestamp));
4347 last_observed_timestamp_.emplace(timestamp);
4348
4349 // Pass test when enough packets have been let through.
4350 if (num_flexfec_packets_sent_ >= 10) {
4351 observation_complete_.Set();
4352 }
4353
4354 return SEND_PACKET;
4355 }
4356
4357 rtc::Optional<uint16_t> last_observed_sequence_number_
4358 RTC_GUARDED_BY(crit_);
4359 rtc::Optional<uint32_t> last_observed_timestamp_ RTC_GUARDED_BY(crit_);
4360 size_t num_flexfec_packets_sent_ RTC_GUARDED_BY(crit_);
4361 rtc::CriticalSection crit_;
4362 } observer;
4363
4364 static constexpr int kFrameMaxWidth = 320;
4365 static constexpr int kFrameMaxHeight = 180;
4366 static constexpr int kFrameRate = 15;
4367
4368 Call::Config config(event_log_.get());
4369
4370 std::unique_ptr<test::PacketTransport> send_transport;
4371 std::unique_ptr<test::PacketTransport> receive_transport;
4372 std::unique_ptr<VideoEncoder> encoder;
4373
4374 task_queue_.SendTask([&]() {
4375 CreateCalls(config, config);
4376
4377 FakeNetworkPipe::Config lossy_delayed_link;
4378 lossy_delayed_link.loss_percent = 2;
4379 lossy_delayed_link.queue_delay_ms = 50;
4380
4381 send_transport = rtc::MakeUnique<test::PacketTransport>(
4382 &task_queue_, sender_call_.get(), &observer,
4383 test::PacketTransport::kSender, payload_type_map_, lossy_delayed_link);
4384 send_transport->SetReceiver(receiver_call_->Receiver());
4385
4386 FakeNetworkPipe::Config flawless_link;
4387 receive_transport = rtc::MakeUnique<test::PacketTransport>(
4388 &task_queue_, nullptr, &observer, test::PacketTransport::kReceiver,
4389 payload_type_map_, flawless_link);
4390 receive_transport->SetReceiver(sender_call_->Receiver());
4391
4392 // For reduced flakyness, we use a real VP8 encoder together with NACK
4393 // and RTX.
4394 const int kNumVideoStreams = 1;
4395 const int kNumFlexfecStreams = 1;
4396 CreateSendConfig(kNumVideoStreams, 0, kNumFlexfecStreams,
4397 send_transport.get());
4398 encoder = VP8Encoder::Create();
4399 video_send_config_.encoder_settings.encoder = encoder.get();
4400 video_send_config_.encoder_settings.payload_name = "VP8";
4401 video_send_config_.encoder_settings.payload_type = kVideoSendPayloadType;
4402 video_send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
4403 video_send_config_.rtp.rtx.ssrcs.push_back(kSendRtxSsrcs[0]);
4404 video_send_config_.rtp.rtx.payload_type = kSendRtxPayloadType;
4405
4406 CreateMatchingReceiveConfigs(receive_transport.get());
4407 video_receive_configs_[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
4408 video_receive_configs_[0].rtp.rtx_ssrc = kSendRtxSsrcs[0];
4409 video_receive_configs_[0]
4410 .rtp.rtx_associated_payload_types[kSendRtxPayloadType] =
4411 kVideoSendPayloadType;
4412
4413 // The matching FlexFEC receive config is not created by
4414 // CreateMatchingReceiveConfigs since this is not a test::BaseTest.
4415 // Set up the receive config manually instead.
4416 FlexfecReceiveStream::Config flexfec_receive_config(
4417 receive_transport.get());
4418 flexfec_receive_config.payload_type =
4419 video_send_config_.rtp.flexfec.payload_type;
4420 flexfec_receive_config.remote_ssrc = video_send_config_.rtp.flexfec.ssrc;
4421 flexfec_receive_config.protected_media_ssrcs =
4422 video_send_config_.rtp.flexfec.protected_media_ssrcs;
4423 flexfec_receive_config.local_ssrc = kReceiverLocalVideoSsrc;
4424 flexfec_receive_config.transport_cc = true;
4425 flexfec_receive_config.rtp_header_extensions.emplace_back(
4426 RtpExtension::kTransportSequenceNumberUri,
4427 test::kTransportSequenceNumberExtensionId);
4428 flexfec_receive_configs_.push_back(flexfec_receive_config);
4429
4430 CreateFlexfecStreams();
4431 CreateVideoStreams();
4432
4433 // RTCP might be disabled if the network is "down".
4434 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
4435 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
4436
4437 CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
4438
4439 Start();
4440 });
4441
4442 // Initial test.
4443 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
4444
4445 task_queue_.SendTask([this, &observer]() {
4446 // Ensure monotonicity when the VideoSendStream is restarted.
4447 Stop();
4448 observer.ResetPacketCount();
4449 Start();
4450 });
4451
4452 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
4453
4454 task_queue_.SendTask([this, &observer]() {
4455 // Ensure monotonicity when the VideoSendStream is recreated.
4456 frame_generator_capturer_->Stop();
4457 sender_call_->DestroyVideoSendStream(video_send_stream_);
4458 observer.ResetPacketCount();
4459 video_send_stream_ = sender_call_->CreateVideoSendStream(
4460 video_send_config_.Copy(), video_encoder_config_.Copy());
4461 video_send_stream_->Start();
4462 CreateFrameGeneratorCapturer(kFrameRate, kFrameMaxWidth, kFrameMaxHeight);
4463 frame_generator_capturer_->Start();
4464 });
4465
4466 EXPECT_TRUE(observer.Wait()) << "Timed out waiting for packets.";
4467
4468 // Cleanup.
4469 task_queue_.SendTask([this, &send_transport, &receive_transport]() {
4470 Stop();
4471 DestroyStreams();
4472 send_transport.reset();
4473 receive_transport.reset();
4474 DestroyCalls();
4475 });
4476 }
4477
4478 TEST_P(EndToEndTest, RespectsNetworkState) {
4479 // TODO(pbos): Remove accepted downtime packets etc. when signaling network
4480 // down blocks until no more packets will be sent.
4481
4482 // Pacer will send from its packet list and then send required padding before
4483 // checking paused_ again. This should be enough for one round of pacing,
4484 // otherwise increase.
4485 static const int kNumAcceptedDowntimeRtp = 5;
4486 // A single RTCP may be in the pipeline.
4487 static const int kNumAcceptedDowntimeRtcp = 1;
4488 class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
4489 public:
4490 explicit NetworkStateTest(
4491 test::SingleThreadedTaskQueueForTesting* task_queue)
4492 : EndToEndTest(kDefaultTimeoutMs),
4493 FakeEncoder(Clock::GetRealTimeClock()),
4494 task_queue_(task_queue),
4495 encoded_frames_(false, false),
4496 packet_event_(false, false),
4497 sender_call_(nullptr),
4498 receiver_call_(nullptr),
4499 sender_state_(kNetworkUp),
4500 sender_rtp_(0),
4501 sender_padding_(0),
4502 sender_rtcp_(0),
4503 receiver_rtcp_(0),
4504 down_frames_(0) {}
4505
4506 Action OnSendRtp(const uint8_t* packet, size_t length) override {
4507 rtc::CritScope lock(&test_crit_);
4508 RTPHeader header;
4509 EXPECT_TRUE(parser_->Parse(packet, length, &header));
4510 if (length == header.headerLength + header.paddingLength)
4511 ++sender_padding_;
4512 ++sender_rtp_;
4513 packet_event_.Set();
4514 return SEND_PACKET;
4515 }
4516
4517 Action OnSendRtcp(const uint8_t* packet, size_t length) override {
4518 rtc::CritScope lock(&test_crit_);
4519 ++sender_rtcp_;
4520 packet_event_.Set();
4521 return SEND_PACKET;
4522 }
4523
4524 Action OnReceiveRtp(const uint8_t* packet, size_t length) override {
4525 ADD_FAILURE() << "Unexpected receiver RTP, should not be sending.";
4526 return SEND_PACKET;
4527 }
4528
4529 Action OnReceiveRtcp(const uint8_t* packet, size_t length) override {
4530 rtc::CritScope lock(&test_crit_);
4531 ++receiver_rtcp_;
4532 packet_event_.Set();
4533 return SEND_PACKET;
4534 }
4535
4536 void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
4537 sender_call_ = sender_call;
4538 receiver_call_ = receiver_call;
4539 }
4540
4541 void ModifyVideoConfigs(
4542 VideoSendStream::Config* send_config,
4543 std::vector<VideoReceiveStream::Config>* receive_configs,
4544 VideoEncoderConfig* encoder_config) override {
4545 send_config->encoder_settings.encoder = this;
4546 }
4547
4548 void PerformTest() override {
4549 EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs))
4550 << "No frames received by the encoder.";
4551
4552 task_queue_->SendTask([this]() {
4553 // Wait for packets from both sender/receiver.
4554 WaitForPacketsOrSilence(false, false);
4555
4556 // Sender-side network down for audio; there should be no effect on
4557 // video
4558 sender_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkDown);
4559 WaitForPacketsOrSilence(false, false);
4560
4561 // Receiver-side network down for audio; no change expected
4562 receiver_call_->SignalChannelNetworkState(MediaType::AUDIO,
4563 kNetworkDown);
4564 WaitForPacketsOrSilence(false, false);
4565
4566 // Sender-side network down.
4567 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown);
4568 {
4569 rtc::CritScope lock(&test_crit_);
4570 // After network goes down we shouldn't be encoding more frames.
4571 sender_state_ = kNetworkDown;
4572 }
4573 // Wait for receiver-packets and no sender packets.
4574 WaitForPacketsOrSilence(true, false);
4575
4576 // Receiver-side network down.
4577 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO,
4578 kNetworkDown);
4579 WaitForPacketsOrSilence(true, true);
4580
4581 // Network up for audio for both sides; video is still not expected to
4582 // start
4583 sender_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
4584 receiver_call_->SignalChannelNetworkState(MediaType::AUDIO, kNetworkUp);
4585 WaitForPacketsOrSilence(true, true);
4586
4587 // Network back up again for both.
4588 {
4589 rtc::CritScope lock(&test_crit_);
4590 // It's OK to encode frames again, as we're about to bring up the
4591 // network.
4592 sender_state_ = kNetworkUp;
4593 }
4594 sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
4595 receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
4596 WaitForPacketsOrSilence(false, false);
4597
4598 // TODO(skvlad): add tests to verify that the audio streams are stopped
4599 // when the network goes down for audio once the workaround in
4600 // paced_sender.cc is removed.
4601 });
4602 }
4603
4604 int32_t Encode(const VideoFrame& input_image,
4605 const CodecSpecificInfo* codec_specific_info,
4606 const std::vector<FrameType>* frame_types) override {
4607 {
4608 rtc::CritScope lock(&test_crit_);
4609 if (sender_state_ == kNetworkDown) {
4610 ++down_frames_;
4611 EXPECT_LE(down_frames_, 1)
4612 << "Encoding more than one frame while network is down.";
4613 if (down_frames_ > 1)
4614 encoded_frames_.Set();
4615 } else {
4616 encoded_frames_.Set();
4617 }
4618 }
4619 return test::FakeEncoder::Encode(
4620 input_image, codec_specific_info, frame_types);
4621 }
4622
4623 private:
4624 void WaitForPacketsOrSilence(bool sender_down, bool receiver_down) {
4625 int64_t initial_time_ms = clock_->TimeInMilliseconds();
4626 int initial_sender_rtp;
4627 int initial_sender_rtcp;
4628 int initial_receiver_rtcp;
4629 {
4630 rtc::CritScope lock(&test_crit_);
4631 initial_sender_rtp = sender_rtp_;
4632 initial_sender_rtcp = sender_rtcp_;
4633 initial_receiver_rtcp = receiver_rtcp_;
4634 }
4635 bool sender_done = false;
4636 bool receiver_done = false;
4637 while (!sender_done || !receiver_done) {
4638 packet_event_.Wait(kSilenceTimeoutMs);
4639 int64_t time_now_ms = clock_->TimeInMilliseconds();
4640 rtc::CritScope lock(&test_crit_);
4641 if (sender_down) {
4642 ASSERT_LE(sender_rtp_ - initial_sender_rtp - sender_padding_,
4643 kNumAcceptedDowntimeRtp)
4644 << "RTP sent during sender-side downtime.";
4645 ASSERT_LE(sender_rtcp_ - initial_sender_rtcp,
4646 kNumAcceptedDowntimeRtcp)
4647 << "RTCP sent during sender-side downtime.";
4648 if (time_now_ms - initial_time_ms >=
4649 static_cast<int64_t>(kSilenceTimeoutMs)) {
4650 sender_done = true;
4651 }
4652 } else {
4653 if (sender_rtp_ > initial_sender_rtp + kNumAcceptedDowntimeRtp)
4654 sender_done = true;
4655 }
4656 if (receiver_down) {
4657 ASSERT_LE(receiver_rtcp_ - initial_receiver_rtcp,
4658 kNumAcceptedDowntimeRtcp)
4659 << "RTCP sent during receiver-side downtime.";
4660 if (time_now_ms - initial_time_ms >=
4661 static_cast<int64_t>(kSilenceTimeoutMs)) {
4662 receiver_done = true;
4663 }
4664 } else {
4665 if (receiver_rtcp_ > initial_receiver_rtcp + kNumAcceptedDowntimeRtcp)
4666 receiver_done = true;
4667 }
4668 }
4669 }
4670
4671 test::SingleThreadedTaskQueueForTesting* const task_queue_;
4672 rtc::CriticalSection test_crit_;
4673 rtc::Event encoded_frames_;
4674 rtc::Event packet_event_;
4675 Call* sender_call_;
4676 Call* receiver_call_;
4677 NetworkState sender_state_ RTC_GUARDED_BY(test_crit_);
4678 int sender_rtp_ RTC_GUARDED_BY(test_crit_);
4679 int sender_padding_ RTC_GUARDED_BY(test_crit_);
4680 int sender_rtcp_ RTC_GUARDED_BY(test_crit_);
4681 int receiver_rtcp_ RTC_GUARDED_BY(test_crit_);
4682 int down_frames_ RTC_GUARDED_BY(test_crit_);
4683 } test(&task_queue_);
4684
4685 RunBaseTest(&test);
4686 }
4687
4688 TEST_P(EndToEndTest, CallReportsRttForSender) {
4689 static const int kSendDelayMs = 30;
4690 static const int kReceiveDelayMs = 70;
4691
4692 std::unique_ptr<test::DirectTransport> sender_transport;
4693 std::unique_ptr<test::DirectTransport> receiver_transport;
4694
4695 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() {
4696 FakeNetworkPipe::Config config;
4697 config.queue_delay_ms = kSendDelayMs;
4698 CreateCalls(Call::Config(event_log_.get()), Call::Config(event_log_.get()));
4699 sender_transport = rtc::MakeUnique<test::DirectTransport>(
4700 &task_queue_, config, sender_call_.get(), payload_type_map_);
4701 config.queue_delay_ms = kReceiveDelayMs;
4702 receiver_transport = rtc::MakeUnique<test::DirectTransport>(
4703 &task_queue_, config, receiver_call_.get(), payload_type_map_);
4704 sender_transport->SetReceiver(receiver_call_->Receiver());
4705 receiver_transport->SetReceiver(sender_call_->Receiver());
4706
4707 CreateSendConfig(1, 0, 0, sender_transport.get());
4708 CreateMatchingReceiveConfigs(receiver_transport.get());
4709
4710 CreateVideoStreams();
4711 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
4712 kDefaultHeight);
4713 Start();
4714 });
4715
4716 int64_t start_time_ms = clock_->TimeInMilliseconds();
4717 while (true) {
4718 Call::Stats stats = sender_call_->GetStats();
4719 ASSERT_GE(start_time_ms + kDefaultTimeoutMs,
4720 clock_->TimeInMilliseconds())
4721 << "No RTT stats before timeout!";
4722 if (stats.rtt_ms != -1) {
4723 // To avoid failures caused by rounding or minor ntp clock adjustments,
4724 // relax expectation by 1ms.
4725 constexpr int kAllowedErrorMs = 1;
4726 EXPECT_GE(stats.rtt_ms, kSendDelayMs + kReceiveDelayMs - kAllowedErrorMs);
4727 break;
4728 }
4729 SleepMs(10);
4730 }
4731
4732 task_queue_.SendTask([this, &sender_transport, &receiver_transport]() {
4733 Stop();
4734 DestroyStreams();
4735 sender_transport.reset();
4736 receiver_transport.reset();
4737 DestroyCalls();
4738 });
4739 }
4740
4741 void EndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
4742 MediaType network_to_bring_up,
4743 VideoEncoder* encoder,
4744 Transport* transport) {
4745 task_queue_.SendTask([this, network_to_bring_up, encoder, transport]() {
4746 CreateSenderCall(Call::Config(event_log_.get()));
4747 sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
4748
4749 CreateSendConfig(1, 0, 0, transport);
4750 video_send_config_.encoder_settings.encoder = encoder;
4751 CreateVideoStreams();
4752 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
4753 kDefaultHeight);
4754
4755 Start();
4756 });
4757
4758 SleepMs(kSilenceTimeoutMs);
4759
4760 task_queue_.SendTask([this]() {
4761 Stop();
4762 DestroyStreams();
4763 DestroyCalls();
4764 });
4765 }
4766
4767 void EndToEndTest::VerifyNewVideoReceiveStreamsRespectNetworkState(
4768 MediaType network_to_bring_up,
4769 Transport* transport) {
4770 std::unique_ptr<test::DirectTransport> sender_transport;
4771
4772 task_queue_.SendTask([this, &sender_transport, network_to_bring_up,
4773 transport]() {
4774 Call::Config config(event_log_.get());
4775 CreateCalls(config, config);
4776 receiver_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
4777 sender_transport = rtc::MakeUnique<test::DirectTransport>(
4778 &task_queue_, sender_call_.get(), payload_type_map_);
4779 sender_transport->SetReceiver(receiver_call_->Receiver());
4780 CreateSendConfig(1, 0, 0, sender_transport.get());
4781 CreateMatchingReceiveConfigs(transport);
4782 CreateVideoStreams();
4783 CreateFrameGeneratorCapturer(kDefaultFramerate, kDefaultWidth,
4784 kDefaultHeight);
4785 Start();
4786 });
4787
4788 SleepMs(kSilenceTimeoutMs);
4789
4790 task_queue_.SendTask([this, &sender_transport]() {
4791 Stop();
4792 DestroyStreams();
4793 sender_transport.reset();
4794 DestroyCalls();
4795 });
4796 }
4797
4798 TEST_P(EndToEndTest, NewVideoSendStreamsRespectVideoNetworkDown) {
4799 class UnusedEncoder : public test::FakeEncoder {
4800 public:
4801 UnusedEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {}
4802
4803 int32_t InitEncode(const VideoCodec* config,
4804 int32_t number_of_cores,
4805 size_t max_payload_size) override {
4806 EXPECT_GT(config->startBitrate, 0u);
4807 return 0;
4808 }
4809 int32_t Encode(const VideoFrame& input_image,
4810 const CodecSpecificInfo* codec_specific_info,
4811 const std::vector<FrameType>* frame_types) override {
4812 ADD_FAILURE() << "Unexpected frame encode.";
4813 return test::FakeEncoder::Encode(input_image, codec_specific_info,
4814 frame_types);
4815 }
4816 };
4817
4818 UnusedEncoder unused_encoder;
4819 UnusedTransport unused_transport;
4820 VerifyNewVideoSendStreamsRespectNetworkState(
4821 MediaType::AUDIO, &unused_encoder, &unused_transport);
4822 }
4823
4824 TEST_P(EndToEndTest, NewVideoSendStreamsIgnoreAudioNetworkDown) {
4825 class RequiredEncoder : public test::FakeEncoder {
4826 public:
4827 RequiredEncoder()
4828 : FakeEncoder(Clock::GetRealTimeClock()), encoded_frame_(false) {}
4829 ~RequiredEncoder() {
4830 if (!encoded_frame_) {
4831 ADD_FAILURE() << "Didn't encode an expected frame";
4832 }
4833 }
4834 int32_t Encode(const VideoFrame& input_image,
4835 const CodecSpecificInfo* codec_specific_info,
4836 const std::vector<FrameType>* frame_types) override {
4837 encoded_frame_ = true;
4838 return test::FakeEncoder::Encode(input_image, codec_specific_info,
4839 frame_types);
4840 }
4841
4842 private:
4843 bool encoded_frame_;
4844 };
4845
4846 RequiredTransport required_transport(true /*rtp*/, false /*rtcp*/);
4847 RequiredEncoder required_encoder;
4848 VerifyNewVideoSendStreamsRespectNetworkState(
4849 MediaType::VIDEO, &required_encoder, &required_transport);
4850 }
4851
4852 TEST_P(EndToEndTest, NewVideoReceiveStreamsRespectVideoNetworkDown) {
4853 UnusedTransport transport;
4854 VerifyNewVideoReceiveStreamsRespectNetworkState(MediaType::AUDIO, &transport);
4855 }
4856
4857 TEST_P(EndToEndTest, NewVideoReceiveStreamsIgnoreAudioNetworkDown) {
4858 RequiredTransport transport(false /*rtp*/, true /*rtcp*/);
4859 VerifyNewVideoReceiveStreamsRespectNetworkState(MediaType::VIDEO, &transport);
4860 }
4861
4862 void VerifyEmptyNackConfig(const NackConfig& config) {
4863 EXPECT_EQ(0, config.rtp_history_ms)
4864 << "Enabling NACK requires rtcp-fb: nack negotiation.";
4865 }
4866
4867 void VerifyEmptyUlpfecConfig(const UlpfecConfig& config) {
4868 EXPECT_EQ(-1, config.ulpfec_payload_type)
4869 << "Enabling ULPFEC requires rtpmap: ulpfec negotiation.";
4870 EXPECT_EQ(-1, config.red_payload_type)
4871 << "Enabling ULPFEC requires rtpmap: red negotiation.";
4872 EXPECT_EQ(-1, config.red_rtx_payload_type)
4873 << "Enabling RTX in ULPFEC requires rtpmap: rtx negotiation.";
4874 }
4875
4876 void VerifyEmptyFlexfecConfig(
4877 const VideoSendStream::Config::Rtp::Flexfec& config) {
4878 EXPECT_EQ(-1, config.payload_type)
4879 << "Enabling FlexFEC requires rtpmap: flexfec negotiation.";
4880 EXPECT_EQ(0U, config.ssrc)
4881 << "Enabling FlexFEC requires ssrc-group: FEC-FR negotiation.";
4882 EXPECT_TRUE(config.protected_media_ssrcs.empty())
4883 << "Enabling FlexFEC requires ssrc-group: FEC-FR negotiation.";
4884 }
4885
4886 TEST_P(EndToEndTest, VerifyDefaultSendConfigParameters) {
4887 VideoSendStream::Config default_send_config(nullptr);
4888 EXPECT_EQ(0, default_send_config.rtp.nack.rtp_history_ms)
4889 << "Enabling NACK require rtcp-fb: nack negotiation.";
4890 EXPECT_TRUE(default_send_config.rtp.rtx.ssrcs.empty())
4891 << "Enabling RTX requires rtpmap: rtx negotiation.";
4892 EXPECT_TRUE(default_send_config.rtp.extensions.empty())
4893 << "Enabling RTP extensions require negotiation.";
4894
4895 VerifyEmptyNackConfig(default_send_config.rtp.nack);
4896 VerifyEmptyUlpfecConfig(default_send_config.rtp.ulpfec);
4897 VerifyEmptyFlexfecConfig(default_send_config.rtp.flexfec);
4898 }
4899
4900 TEST_P(EndToEndTest, VerifyDefaultVideoReceiveConfigParameters) {
4901 VideoReceiveStream::Config default_receive_config(nullptr);
4902 EXPECT_EQ(RtcpMode::kCompound, default_receive_config.rtp.rtcp_mode)
4903 << "Reduced-size RTCP require rtcp-rsize to be negotiated.";
4904 EXPECT_FALSE(default_receive_config.rtp.remb)
4905 << "REMB require rtcp-fb: goog-remb to be negotiated.";
4906 EXPECT_FALSE(
4907 default_receive_config.rtp.rtcp_xr.receiver_reference_time_report)
4908 << "RTCP XR settings require rtcp-xr to be negotiated.";
4909 EXPECT_EQ(0U, default_receive_config.rtp.rtx_ssrc)
4910 << "Enabling RTX requires ssrc-group: FID negotiation";
4911 EXPECT_TRUE(default_receive_config.rtp.rtx_associated_payload_types.empty())
4912 << "Enabling RTX requires rtpmap: rtx negotiation.";
4913 EXPECT_TRUE(default_receive_config.rtp.extensions.empty())
4914 << "Enabling RTP extensions require negotiation.";
4915
4916 VerifyEmptyNackConfig(default_receive_config.rtp.nack);
4917 EXPECT_EQ(-1, default_receive_config.rtp.ulpfec_payload_type)
4918 << "Enabling ULPFEC requires rtpmap: ulpfec negotiation.";
4919 EXPECT_EQ(-1, default_receive_config.rtp.red_payload_type)
4920 << "Enabling ULPFEC requires rtpmap: red negotiation.";
4921 }
4922
4923 TEST_P(EndToEndTest, VerifyDefaultFlexfecReceiveConfigParameters) {
4924 test::NullTransport rtcp_send_transport;
4925 FlexfecReceiveStream::Config default_receive_config(&rtcp_send_transport);
4926 EXPECT_EQ(-1, default_receive_config.payload_type)
4927 << "Enabling FlexFEC requires rtpmap: flexfec negotiation.";
4928 EXPECT_EQ(0U, default_receive_config.remote_ssrc)
4929 << "Enabling FlexFEC requires ssrc-group: FEC-FR negotiation.";
4930 EXPECT_TRUE(default_receive_config.protected_media_ssrcs.empty())
4931 << "Enabling FlexFEC requires ssrc-group: FEC-FR negotiation.";
4932 }
4933
4934 TEST_P(EndToEndTest, TransportSeqNumOnAudioAndVideo) {
4935 static constexpr int kExtensionId = 8;
4936 static constexpr size_t kMinPacketsToWaitFor = 50;
4937 class TransportSequenceNumberTest : public test::EndToEndTest {
4938 public:
4939 TransportSequenceNumberTest()
4940 : EndToEndTest(kDefaultTimeoutMs),
4941 video_observed_(false),
4942 audio_observed_(false) {
4943 parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
4944 kExtensionId);
4945 }
4946
4947 size_t GetNumVideoStreams() const override { return 1; }
4948 size_t GetNumAudioStreams() const override { return 1; }
4949
4950 void ModifyAudioConfigs(
4951 AudioSendStream::Config* send_config,
4952 std::vector<AudioReceiveStream::Config>* receive_configs) override {
4953 send_config->rtp.extensions.clear();
4954 send_config->rtp.extensions.push_back(RtpExtension(
4955 RtpExtension::kTransportSequenceNumberUri, kExtensionId));
4956 (*receive_configs)[0].rtp.extensions.clear();
4957 (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions;
4958 }
4959
4960 Action OnSendRtp(const uint8_t* packet, size_t length) override {
4961 RTPHeader header;
4962 EXPECT_TRUE(parser_->Parse(packet, length, &header));
4963 EXPECT_TRUE(header.extension.hasTransportSequenceNumber);
4964 // Unwrap packet id and verify uniqueness.
4965 int64_t packet_id =
4966 unwrapper_.Unwrap(header.extension.transportSequenceNumber);
4967 EXPECT_TRUE(received_packet_ids_.insert(packet_id).second);
4968
4969 if (header.ssrc == kVideoSendSsrcs[0])
4970 video_observed_ = true;
4971 if (header.ssrc == kAudioSendSsrc)
4972 audio_observed_ = true;
4973 if (audio_observed_ && video_observed_ &&
4974 received_packet_ids_.size() >= kMinPacketsToWaitFor) {
4975 size_t packet_id_range =
4976 *received_packet_ids_.rbegin() - *received_packet_ids_.begin() + 1;
4977 EXPECT_EQ(received_packet_ids_.size(), packet_id_range);
4978 observation_complete_.Set();
4979 }
4980 return SEND_PACKET;
4981 }
4982
4983 void PerformTest() override {
4984 EXPECT_TRUE(Wait()) << "Timed out while waiting for audio and video "
4985 "packets with transport sequence number.";
4986 }
4987
4988 void ExpectSuccessful() {
4989 EXPECT_TRUE(video_observed_);
4990 EXPECT_TRUE(audio_observed_);
4991 EXPECT_GE(received_packet_ids_.size(), kMinPacketsToWaitFor);
4992 }
4993
4994 private:
4995 bool video_observed_;
4996 bool audio_observed_;
4997 SequenceNumberUnwrapper unwrapper_;
4998 std::set<int64_t> received_packet_ids_;
4999 } test;
5000
5001 RunBaseTest(&test);
5002 // Double check conditions for successful test to produce better error
5003 // message when the test fail.
5004 test.ExpectSuccessful();
5005 }
5006
5007 class EndToEndLogTest : public EndToEndTest {
5008 void SetUp() { paths_.clear(); }
5009 void TearDown() {
5010 for (const auto& path : paths_) {
5011 rtc::RemoveFile(path);
5012 }
5013 }
5014
5015 public:
5016 int AddFile() {
5017 paths_.push_back(test::TempFilename(test::OutputPath(), "test_file"));
5018 return static_cast<int>(paths_.size()) - 1;
5019 }
5020
5021 rtc::PlatformFile OpenFile(int idx) {
5022 return rtc::OpenPlatformFile(paths_[idx]);
5023 }
5024
5025 void LogSend(bool open) {
5026 if (open) {
5027 video_send_stream_->EnableEncodedFrameRecording(
5028 std::vector<rtc::PlatformFile>(1, OpenFile(AddFile())), 0);
5029 } else {
5030 video_send_stream_->DisableEncodedFrameRecording();
5031 }
5032 }
5033 void LogReceive(bool open) {
5034 if (open) {
5035 video_receive_streams_[0]->EnableEncodedFrameRecording(
5036 OpenFile(AddFile()), 0);
5037 } else {
5038 video_receive_streams_[0]->DisableEncodedFrameRecording();
5039 }
5040 }
5041
5042 std::vector<std::string> paths_;
5043 };
5044
5045 TEST_P(EndToEndLogTest, LogsEncodedFramesWhenRequested) {
5046 static const int kNumFramesToRecord = 10;
5047 class LogEncodingObserver : public test::EndToEndTest,
5048 public EncodedFrameObserver {
5049 public:
5050 explicit LogEncodingObserver(EndToEndLogTest* fixture)
5051 : EndToEndTest(kDefaultTimeoutMs),
5052 fixture_(fixture),
5053 recorded_frames_(0) {}
5054
5055 void PerformTest() override {
5056 fixture_->LogSend(true);
5057 fixture_->LogReceive(true);
5058 ASSERT_TRUE(Wait()) << "Timed out while waiting for frame logging.";
5059 }
5060
5061 void ModifyVideoConfigs(
5062 VideoSendStream::Config* send_config,
5063 std::vector<VideoReceiveStream::Config>* receive_configs,
5064 VideoEncoderConfig* encoder_config) override {
5065 encoder_ = VP8Encoder::Create();
5066 decoder_ = VP8Decoder::Create();
5067
5068 send_config->post_encode_callback = this;
5069 send_config->encoder_settings.payload_name = "VP8";
5070 send_config->encoder_settings.encoder = encoder_.get();
5071
5072 (*receive_configs)[0].decoders.resize(1);
5073 (*receive_configs)[0].decoders[0].payload_type =
5074 send_config->encoder_settings.payload_type;
5075 (*receive_configs)[0].decoders[0].payload_name =
5076 send_config->encoder_settings.payload_name;
5077 (*receive_configs)[0].decoders[0].decoder = decoder_.get();
5078 }
5079
5080 void EncodedFrameCallback(const EncodedFrame& encoded_frame) override {
5081 rtc::CritScope lock(&crit_);
5082 if (recorded_frames_++ > kNumFramesToRecord) {
5083 fixture_->LogSend(false);
5084 fixture_->LogReceive(false);
5085 rtc::File send_file(fixture_->OpenFile(0));
5086 rtc::File receive_file(fixture_->OpenFile(1));
5087 uint8_t out[100];
5088 // If logging has worked correctly neither file should be empty, i.e.
5089 // we should be able to read something from them.
5090 EXPECT_LT(0u, send_file.Read(out, 100));
5091 EXPECT_LT(0u, receive_file.Read(out, 100));
5092 observation_complete_.Set();
5093 }
5094 }
5095
5096 private:
5097 EndToEndLogTest* const fixture_;
5098 std::unique_ptr<VideoEncoder> encoder_;
5099 std::unique_ptr<VideoDecoder> decoder_;
5100 rtc::CriticalSection crit_;
5101 int recorded_frames_ RTC_GUARDED_BY(crit_);
5102 } test(this);
5103
5104 RunBaseTest(&test);
5105 }
5106
5107 INSTANTIATE_TEST_CASE_P(RoundRobin,
5108 EndToEndTest,
5109 ::testing::Values("WebRTC-RoundRobinPacing/Disabled/",
5110 "WebRTC-RoundRobinPacing/Enabled/"));
5111
5112 } // namespace webrtc
5113