1 /*
2 * Copyright (c) 2015 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 "video/video_quality_test.h"
11
12 #include <stdio.h>
13
14 #if defined(WEBRTC_WIN)
15 #include <conio.h>
16 #endif
17
18 #include <algorithm>
19 #include <deque>
20 #include <map>
21 #include <memory>
22 #include <string>
23 #include <vector>
24
25 #include "api/fec_controller_override.h"
26 #include "api/rtc_event_log_output_file.h"
27 #include "api/task_queue/default_task_queue_factory.h"
28 #include "api/task_queue/task_queue_base.h"
29 #include "api/test/create_frame_generator.h"
30 #include "api/video/builtin_video_bitrate_allocator_factory.h"
31 #include "api/video_codecs/video_encoder.h"
32 #include "call/fake_network_pipe.h"
33 #include "call/simulated_network.h"
34 #include "media/base/media_constants.h"
35 #include "media/engine/adm_helpers.h"
36 #include "media/engine/encoder_simulcast_proxy.h"
37 #include "media/engine/fake_video_codec_factory.h"
38 #include "media/engine/internal_encoder_factory.h"
39 #include "media/engine/webrtc_video_engine.h"
40 #include "modules/audio_device/include/audio_device.h"
41 #include "modules/audio_mixer/audio_mixer_impl.h"
42 #include "modules/video_coding/codecs/h264/include/h264.h"
43 #include "modules/video_coding/codecs/multiplex/include/multiplex_decoder_adapter.h"
44 #include "modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h"
45 #include "modules/video_coding/codecs/vp8/include/vp8.h"
46 #include "modules/video_coding/codecs/vp9/include/vp9.h"
47 #include "modules/video_coding/utility/ivf_file_writer.h"
48 #include "rtc_base/strings/string_builder.h"
49 #include "rtc_base/task_queue_for_test.h"
50 #include "test/platform_video_capturer.h"
51 #include "test/testsupport/file_utils.h"
52 #include "test/video_renderer.h"
53 #include "video/frame_dumping_decoder.h"
54 #ifdef WEBRTC_WIN
55 #include "modules/audio_device/include/audio_device_factory.h"
56 #endif
57
58 namespace webrtc {
59
60 namespace {
61 enum : int { // The first valid value is 1.
62 kAbsSendTimeExtensionId = 1,
63 kGenericFrameDescriptorExtensionId00,
64 kGenericFrameDescriptorExtensionId01,
65 kTransportSequenceNumberExtensionId,
66 kVideoContentTypeExtensionId,
67 kVideoTimingExtensionId,
68 };
69
70 constexpr char kSyncGroup[] = "av_sync";
71 constexpr int kOpusMinBitrateBps = 6000;
72 constexpr int kOpusBitrateFbBps = 32000;
73 constexpr int kFramesSentInQuickTest = 1;
74 constexpr uint32_t kThumbnailSendSsrcStart = 0xE0000;
75 constexpr uint32_t kThumbnailRtxSsrcStart = 0xF0000;
76
77 constexpr int kDefaultMaxQp = cricket::WebRtcVideoChannel::kDefaultQpMax;
78
79 const VideoEncoder::Capabilities kCapabilities(false);
80
GetMinMaxBitratesBps(const VideoCodec & codec,size_t spatial_idx)81 std::pair<uint32_t, uint32_t> GetMinMaxBitratesBps(const VideoCodec& codec,
82 size_t spatial_idx) {
83 uint32_t min_bitrate = codec.minBitrate;
84 uint32_t max_bitrate = codec.maxBitrate;
85 if (spatial_idx < codec.numberOfSimulcastStreams) {
86 min_bitrate =
87 std::max(min_bitrate, codec.simulcastStream[spatial_idx].minBitrate);
88 max_bitrate =
89 std::min(max_bitrate, codec.simulcastStream[spatial_idx].maxBitrate);
90 }
91 if (codec.codecType == VideoCodecType::kVideoCodecVP9 &&
92 spatial_idx < codec.VP9().numberOfSpatialLayers) {
93 min_bitrate =
94 std::max(min_bitrate, codec.spatialLayers[spatial_idx].minBitrate);
95 max_bitrate =
96 std::min(max_bitrate, codec.spatialLayers[spatial_idx].maxBitrate);
97 }
98 max_bitrate = std::max(max_bitrate, min_bitrate);
99 return {min_bitrate * 1000, max_bitrate * 1000};
100 }
101
102 class VideoStreamFactory
103 : public VideoEncoderConfig::VideoStreamFactoryInterface {
104 public:
VideoStreamFactory(const std::vector<VideoStream> & streams)105 explicit VideoStreamFactory(const std::vector<VideoStream>& streams)
106 : streams_(streams) {}
107
108 private:
CreateEncoderStreams(int width,int height,const VideoEncoderConfig & encoder_config)109 std::vector<VideoStream> CreateEncoderStreams(
110 int width,
111 int height,
112 const VideoEncoderConfig& encoder_config) override {
113 // The highest layer must match the incoming resolution.
114 std::vector<VideoStream> streams = streams_;
115 streams[streams_.size() - 1].height = height;
116 streams[streams_.size() - 1].width = width;
117
118 streams[0].bitrate_priority = encoder_config.bitrate_priority;
119 return streams;
120 }
121
122 std::vector<VideoStream> streams_;
123 };
124
125 // This wrapper provides two features needed by the video quality tests:
126 // 1. Invoke VideoAnalyzer callbacks before and after encoding each frame.
127 // 2. Write the encoded frames to file, one file per simulcast layer.
128 class QualityTestVideoEncoder : public VideoEncoder,
129 private EncodedImageCallback {
130 public:
QualityTestVideoEncoder(std::unique_ptr<VideoEncoder> encoder,VideoAnalyzer * analyzer,std::vector<FileWrapper> files,double overshoot_factor)131 QualityTestVideoEncoder(std::unique_ptr<VideoEncoder> encoder,
132 VideoAnalyzer* analyzer,
133 std::vector<FileWrapper> files,
134 double overshoot_factor)
135 : encoder_(std::move(encoder)),
136 overshoot_factor_(overshoot_factor),
137 analyzer_(analyzer) {
138 for (FileWrapper& file : files) {
139 writers_.push_back(
140 IvfFileWriter::Wrap(std::move(file), /* byte_limit= */ 100000000));
141 }
142 }
143
144 // Implement VideoEncoder
SetFecControllerOverride(FecControllerOverride * fec_controller_override)145 void SetFecControllerOverride(
146 FecControllerOverride* fec_controller_override) {
147 // Ignored.
148 }
149
InitEncode(const VideoCodec * codec_settings,const Settings & settings)150 int32_t InitEncode(const VideoCodec* codec_settings,
151 const Settings& settings) override {
152 codec_settings_ = *codec_settings;
153 return encoder_->InitEncode(codec_settings, settings);
154 }
155
RegisterEncodeCompleteCallback(EncodedImageCallback * callback)156 int32_t RegisterEncodeCompleteCallback(
157 EncodedImageCallback* callback) override {
158 callback_ = callback;
159 return encoder_->RegisterEncodeCompleteCallback(this);
160 }
161
Release()162 int32_t Release() override { return encoder_->Release(); }
163
Encode(const VideoFrame & frame,const std::vector<VideoFrameType> * frame_types)164 int32_t Encode(const VideoFrame& frame,
165 const std::vector<VideoFrameType>* frame_types) {
166 if (analyzer_) {
167 analyzer_->PreEncodeOnFrame(frame);
168 }
169 return encoder_->Encode(frame, frame_types);
170 }
171
SetRates(const RateControlParameters & parameters)172 void SetRates(const RateControlParameters& parameters) override {
173 RTC_DCHECK_GT(overshoot_factor_, 0.0);
174 if (overshoot_factor_ == 1.0) {
175 encoder_->SetRates(parameters);
176 return;
177 }
178
179 // Simulating encoder overshooting target bitrate, by configuring actual
180 // encoder too high. Take care not to adjust past limits of config,
181 // otherwise encoders may crash on DCHECK.
182 VideoBitrateAllocation overshot_allocation;
183 for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
184 const uint32_t spatial_layer_bitrate_bps =
185 parameters.bitrate.GetSpatialLayerSum(si);
186 if (spatial_layer_bitrate_bps == 0) {
187 continue;
188 }
189
190 uint32_t min_bitrate_bps;
191 uint32_t max_bitrate_bps;
192 std::tie(min_bitrate_bps, max_bitrate_bps) =
193 GetMinMaxBitratesBps(codec_settings_, si);
194 double overshoot_factor = overshoot_factor_;
195 const uint32_t corrected_bitrate = rtc::checked_cast<uint32_t>(
196 overshoot_factor * spatial_layer_bitrate_bps);
197 if (corrected_bitrate < min_bitrate_bps) {
198 overshoot_factor = min_bitrate_bps / spatial_layer_bitrate_bps;
199 } else if (corrected_bitrate > max_bitrate_bps) {
200 overshoot_factor = max_bitrate_bps / spatial_layer_bitrate_bps;
201 }
202
203 for (size_t ti = 0; ti < kMaxTemporalStreams; ++ti) {
204 if (parameters.bitrate.HasBitrate(si, ti)) {
205 overshot_allocation.SetBitrate(
206 si, ti,
207 rtc::checked_cast<uint32_t>(
208 overshoot_factor * parameters.bitrate.GetBitrate(si, ti)));
209 }
210 }
211 }
212
213 return encoder_->SetRates(
214 RateControlParameters(overshot_allocation, parameters.framerate_fps,
215 parameters.bandwidth_allocation));
216 }
217
OnPacketLossRateUpdate(float packet_loss_rate)218 void OnPacketLossRateUpdate(float packet_loss_rate) override {
219 encoder_->OnPacketLossRateUpdate(packet_loss_rate);
220 }
221
OnRttUpdate(int64_t rtt_ms)222 void OnRttUpdate(int64_t rtt_ms) override { encoder_->OnRttUpdate(rtt_ms); }
223
OnLossNotification(const LossNotification & loss_notification)224 void OnLossNotification(const LossNotification& loss_notification) override {
225 encoder_->OnLossNotification(loss_notification);
226 }
227
GetEncoderInfo() const228 EncoderInfo GetEncoderInfo() const override {
229 EncoderInfo info = encoder_->GetEncoderInfo();
230 if (overshoot_factor_ != 1.0) {
231 // We're simulating bad encoder, don't forward trusted setting
232 // from eg libvpx.
233 info.has_trusted_rate_controller = false;
234 }
235 return info;
236 }
237
238 private:
239 // Implement EncodedImageCallback
OnEncodedImage(const EncodedImage & encoded_image,const CodecSpecificInfo * codec_specific_info)240 Result OnEncodedImage(const EncodedImage& encoded_image,
241 const CodecSpecificInfo* codec_specific_info) override {
242 if (codec_specific_info) {
243 int simulcast_index;
244 if (codec_specific_info->codecType == kVideoCodecVP9) {
245 simulcast_index = 0;
246 } else {
247 simulcast_index = encoded_image.SpatialIndex().value_or(0);
248 }
249 RTC_DCHECK_GE(simulcast_index, 0);
250 if (analyzer_) {
251 analyzer_->PostEncodeOnFrame(simulcast_index,
252 encoded_image.Timestamp());
253 }
254 if (static_cast<size_t>(simulcast_index) < writers_.size()) {
255 writers_[simulcast_index]->WriteFrame(encoded_image,
256 codec_specific_info->codecType);
257 }
258 }
259
260 return callback_->OnEncodedImage(encoded_image, codec_specific_info);
261 }
262
OnDroppedFrame(DropReason reason)263 void OnDroppedFrame(DropReason reason) override {
264 callback_->OnDroppedFrame(reason);
265 }
266
267 const std::unique_ptr<VideoEncoder> encoder_;
268 const double overshoot_factor_;
269 VideoAnalyzer* const analyzer_;
270 std::vector<std::unique_ptr<IvfFileWriter>> writers_;
271 EncodedImageCallback* callback_ = nullptr;
272 VideoCodec codec_settings_;
273 };
274
275 #if defined(WEBRTC_WIN) && !defined(WINUWP)
PressEnterToContinue(TaskQueueBase * task_queue)276 void PressEnterToContinue(TaskQueueBase* task_queue) {
277 puts(">> Press ENTER to continue...");
278
279 while (!_kbhit() || _getch() != '\r') {
280 // Drive the message loop for the thread running the task_queue
281 SendTask(RTC_FROM_HERE, task_queue, [&]() {
282 MSG msg;
283 if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
284 TranslateMessage(&msg);
285 DispatchMessage(&msg);
286 }
287 });
288 }
289 }
290 #else
PressEnterToContinue(TaskQueueBase *)291 void PressEnterToContinue(TaskQueueBase* /*task_queue*/) {
292 puts(">> Press ENTER to continue...");
293 while (getc(stdin) != '\n' && !feof(stdin))
294 ; // NOLINT
295 }
296 #endif
297
298 } // namespace
299
CreateVideoDecoder(const SdpVideoFormat & format)300 std::unique_ptr<VideoDecoder> VideoQualityTest::CreateVideoDecoder(
301 const SdpVideoFormat& format) {
302 std::unique_ptr<VideoDecoder> decoder;
303 if (format.name == "multiplex") {
304 decoder = std::make_unique<MultiplexDecoderAdapter>(
305 decoder_factory_.get(), SdpVideoFormat(cricket::kVp9CodecName));
306 } else if (format.name == "FakeCodec") {
307 decoder = webrtc::FakeVideoDecoderFactory::CreateVideoDecoder();
308 } else {
309 decoder = decoder_factory_->CreateVideoDecoder(format);
310 }
311 if (!params_.logging.encoded_frame_base_path.empty()) {
312 rtc::StringBuilder str;
313 str << receive_logs_++;
314 std::string path =
315 params_.logging.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
316 decoder = CreateFrameDumpingDecoderWrapper(
317 std::move(decoder), FileWrapper::OpenWriteOnly(path));
318 }
319 return decoder;
320 }
321
CreateVideoEncoder(const SdpVideoFormat & format,VideoAnalyzer * analyzer)322 std::unique_ptr<VideoEncoder> VideoQualityTest::CreateVideoEncoder(
323 const SdpVideoFormat& format,
324 VideoAnalyzer* analyzer) {
325 std::unique_ptr<VideoEncoder> encoder;
326 if (format.name == "VP8") {
327 encoder =
328 std::make_unique<EncoderSimulcastProxy>(encoder_factory_.get(), format);
329 } else if (format.name == "multiplex") {
330 encoder = std::make_unique<MultiplexEncoderAdapter>(
331 encoder_factory_.get(), SdpVideoFormat(cricket::kVp9CodecName));
332 } else if (format.name == "FakeCodec") {
333 encoder = webrtc::FakeVideoEncoderFactory::CreateVideoEncoder();
334 } else {
335 encoder = encoder_factory_->CreateVideoEncoder(format);
336 }
337
338 std::vector<FileWrapper> encoded_frame_dump_files;
339 if (!params_.logging.encoded_frame_base_path.empty()) {
340 char ss_buf[100];
341 rtc::SimpleStringBuilder sb(ss_buf);
342 sb << send_logs_++;
343 std::string prefix =
344 params_.logging.encoded_frame_base_path + "." + sb.str() + ".send.";
345 encoded_frame_dump_files.push_back(
346 FileWrapper::OpenWriteOnly(prefix + "1.ivf"));
347 encoded_frame_dump_files.push_back(
348 FileWrapper::OpenWriteOnly(prefix + "2.ivf"));
349 encoded_frame_dump_files.push_back(
350 FileWrapper::OpenWriteOnly(prefix + "3.ivf"));
351 }
352
353 double overshoot_factor = 1.0;
354 // Match format to either of the streams in dual-stream mode in order to get
355 // the overshoot factor. This is not very robust but we can't know for sure
356 // which stream this encoder is meant for, from within the factory.
357 if (format ==
358 SdpVideoFormat(params_.video[0].codec, params_.video[0].sdp_params)) {
359 overshoot_factor = params_.video[0].encoder_overshoot_factor;
360 } else if (format == SdpVideoFormat(params_.video[1].codec,
361 params_.video[1].sdp_params)) {
362 overshoot_factor = params_.video[1].encoder_overshoot_factor;
363 }
364 if (overshoot_factor == 0.0) {
365 // If params were zero-initialized, set to 1.0 instead.
366 overshoot_factor = 1.0;
367 }
368
369 if (analyzer || !encoded_frame_dump_files.empty() || overshoot_factor > 1.0) {
370 encoder = std::make_unique<QualityTestVideoEncoder>(
371 std::move(encoder), analyzer, std::move(encoded_frame_dump_files),
372 overshoot_factor);
373 }
374
375 return encoder;
376 }
377
VideoQualityTest(std::unique_ptr<InjectionComponents> injection_components)378 VideoQualityTest::VideoQualityTest(
379 std::unique_ptr<InjectionComponents> injection_components)
380 : clock_(Clock::GetRealTimeClock()),
381 task_queue_factory_(CreateDefaultTaskQueueFactory()),
382 rtc_event_log_factory_(task_queue_factory_.get()),
383 video_decoder_factory_([this](const SdpVideoFormat& format) {
384 return this->CreateVideoDecoder(format);
385 }),
__anonb99766bd0502(const SdpVideoFormat& format) 386 video_encoder_factory_([this](const SdpVideoFormat& format) {
387 return this->CreateVideoEncoder(format, nullptr);
388 }),
389 video_encoder_factory_with_analyzer_(
__anonb99766bd0602(const SdpVideoFormat& format) 390 [this](const SdpVideoFormat& format) {
391 return this->CreateVideoEncoder(format, analyzer_.get());
392 }),
393 video_bitrate_allocator_factory_(
394 CreateBuiltinVideoBitrateAllocatorFactory()),
395 receive_logs_(0),
396 send_logs_(0),
397 injection_components_(std::move(injection_components)),
398 num_video_streams_(0) {
399 if (injection_components_ == nullptr) {
400 injection_components_ = std::make_unique<InjectionComponents>();
401 }
402 if (injection_components_->video_decoder_factory != nullptr) {
403 decoder_factory_ = std::move(injection_components_->video_decoder_factory);
404 } else {
405 decoder_factory_ = std::make_unique<InternalDecoderFactory>();
406 }
407 if (injection_components_->video_encoder_factory != nullptr) {
408 encoder_factory_ = std::move(injection_components_->video_encoder_factory);
409 } else {
410 encoder_factory_ = std::make_unique<InternalEncoderFactory>();
411 }
412
413 payload_type_map_ = test::CallTest::payload_type_map_;
414 RTC_DCHECK(payload_type_map_.find(kPayloadTypeH264) ==
415 payload_type_map_.end());
416 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) ==
417 payload_type_map_.end());
418 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) ==
419 payload_type_map_.end());
420 RTC_DCHECK(payload_type_map_.find(kPayloadTypeGeneric) ==
421 payload_type_map_.end());
422 payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO;
423 payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO;
424 payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO;
425 payload_type_map_[kPayloadTypeGeneric] = webrtc::MediaType::VIDEO;
426
427 fec_controller_factory_ =
428 std::move(injection_components_->fec_controller_factory);
429 network_state_predictor_factory_ =
430 std::move(injection_components_->network_state_predictor_factory);
431 network_controller_factory_ =
432 std::move(injection_components_->network_controller_factory);
433 }
434
435 VideoQualityTest::InjectionComponents::InjectionComponents() = default;
436
437 VideoQualityTest::InjectionComponents::~InjectionComponents() = default;
438
TestBody()439 void VideoQualityTest::TestBody() {}
440
GenerateGraphTitle() const441 std::string VideoQualityTest::GenerateGraphTitle() const {
442 rtc::StringBuilder ss;
443 ss << params_.video[0].codec;
444 ss << " (" << params_.video[0].target_bitrate_bps / 1000 << "kbps";
445 ss << ", " << params_.video[0].fps << " FPS";
446 if (params_.screenshare[0].scroll_duration)
447 ss << ", " << params_.screenshare[0].scroll_duration << "s scroll";
448 if (params_.ss[0].streams.size() > 1)
449 ss << ", Stream #" << params_.ss[0].selected_stream;
450 if (params_.ss[0].num_spatial_layers > 1)
451 ss << ", Layer #" << params_.ss[0].selected_sl;
452 ss << ")";
453 return ss.Release();
454 }
455
CheckParamsAndInjectionComponents()456 void VideoQualityTest::CheckParamsAndInjectionComponents() {
457 if (injection_components_ == nullptr) {
458 injection_components_ = std::make_unique<InjectionComponents>();
459 }
460 if (!params_.config && injection_components_->sender_network == nullptr &&
461 injection_components_->receiver_network == nullptr) {
462 params_.config = BuiltInNetworkBehaviorConfig();
463 }
464 RTC_CHECK(
465 (params_.config && injection_components_->sender_network == nullptr &&
466 injection_components_->receiver_network == nullptr) ||
467 (!params_.config && injection_components_->sender_network != nullptr &&
468 injection_components_->receiver_network != nullptr));
469 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
470 // Iterate over primary and secondary video streams.
471 if (!params_.video[video_idx].enabled)
472 return;
473 // Add a default stream in none specified.
474 if (params_.ss[video_idx].streams.empty())
475 params_.ss[video_idx].streams.push_back(
476 VideoQualityTest::DefaultVideoStream(params_, video_idx));
477 if (params_.ss[video_idx].num_spatial_layers == 0)
478 params_.ss[video_idx].num_spatial_layers = 1;
479
480 if (params_.config) {
481 if (params_.config->loss_percent != 0 ||
482 params_.config->queue_length_packets != 0) {
483 // Since LayerFilteringTransport changes the sequence numbers, we can't
484 // use that feature with pack loss, since the NACK request would end up
485 // retransmitting the wrong packets.
486 RTC_CHECK(params_.ss[video_idx].selected_sl == -1 ||
487 params_.ss[video_idx].selected_sl ==
488 params_.ss[video_idx].num_spatial_layers - 1);
489 RTC_CHECK(params_.video[video_idx].selected_tl == -1 ||
490 params_.video[video_idx].selected_tl ==
491 params_.video[video_idx].num_temporal_layers - 1);
492 }
493 }
494
495 // TODO(ivica): Should max_bitrate_bps == -1 represent inf max bitrate, as
496 // it does in some parts of the code?
497 RTC_CHECK_GE(params_.video[video_idx].max_bitrate_bps,
498 params_.video[video_idx].target_bitrate_bps);
499 RTC_CHECK_GE(params_.video[video_idx].target_bitrate_bps,
500 params_.video[video_idx].min_bitrate_bps);
501 int selected_stream = params_.ss[video_idx].selected_stream;
502 if (params_.video[video_idx].selected_tl > -1) {
503 RTC_CHECK_LT(selected_stream, params_.ss[video_idx].streams.size())
504 << "Can not use --selected_tl when --selected_stream is all streams";
505 int stream_tl = params_.ss[video_idx]
506 .streams[selected_stream]
507 .num_temporal_layers.value_or(1);
508 RTC_CHECK_LT(params_.video[video_idx].selected_tl, stream_tl);
509 }
510 RTC_CHECK_LE(params_.ss[video_idx].selected_stream,
511 params_.ss[video_idx].streams.size());
512 for (const VideoStream& stream : params_.ss[video_idx].streams) {
513 RTC_CHECK_GE(stream.min_bitrate_bps, 0);
514 RTC_CHECK_GE(stream.target_bitrate_bps, stream.min_bitrate_bps);
515 RTC_CHECK_GE(stream.max_bitrate_bps, stream.target_bitrate_bps);
516 }
517 // TODO(ivica): Should we check if the sum of all streams/layers is equal to
518 // the total bitrate? We anyway have to update them in the case bitrate
519 // estimator changes the total bitrates.
520 RTC_CHECK_GE(params_.ss[video_idx].num_spatial_layers, 1);
521 RTC_CHECK_LE(params_.ss[video_idx].selected_sl,
522 params_.ss[video_idx].num_spatial_layers);
523 RTC_CHECK(
524 params_.ss[video_idx].spatial_layers.empty() ||
525 params_.ss[video_idx].spatial_layers.size() ==
526 static_cast<size_t>(params_.ss[video_idx].num_spatial_layers));
527 if (params_.video[video_idx].codec == "VP8") {
528 RTC_CHECK_EQ(params_.ss[video_idx].num_spatial_layers, 1);
529 } else if (params_.video[video_idx].codec == "VP9") {
530 RTC_CHECK_EQ(params_.ss[video_idx].streams.size(), 1);
531 }
532 RTC_CHECK_GE(params_.call.num_thumbnails, 0);
533 if (params_.call.num_thumbnails > 0) {
534 RTC_CHECK_EQ(params_.ss[video_idx].num_spatial_layers, 1);
535 RTC_CHECK_EQ(params_.ss[video_idx].streams.size(), 3);
536 RTC_CHECK_EQ(params_.video[video_idx].num_temporal_layers, 3);
537 RTC_CHECK_EQ(params_.video[video_idx].codec, "VP8");
538 }
539 // Dual streams with FEC not supported in tests yet.
540 RTC_CHECK(!params_.video[video_idx].flexfec || num_video_streams_ == 1);
541 RTC_CHECK(!params_.video[video_idx].ulpfec || num_video_streams_ == 1);
542 }
543 }
544
545 // Static.
ParseCSV(const std::string & str)546 std::vector<int> VideoQualityTest::ParseCSV(const std::string& str) {
547 // Parse comma separated nonnegative integers, where some elements may be
548 // empty. The empty values are replaced with -1.
549 // E.g. "10,-20,,30,40" --> {10, 20, -1, 30,40}
550 // E.g. ",,10,,20," --> {-1, -1, 10, -1, 20, -1}
551 std::vector<int> result;
552 if (str.empty())
553 return result;
554
555 const char* p = str.c_str();
556 int value = -1;
557 int pos;
558 while (*p) {
559 if (*p == ',') {
560 result.push_back(value);
561 value = -1;
562 ++p;
563 continue;
564 }
565 RTC_CHECK_EQ(sscanf(p, "%d%n", &value, &pos), 1)
566 << "Unexpected non-number value.";
567 p += pos;
568 }
569 result.push_back(value);
570 return result;
571 }
572
573 // Static.
DefaultVideoStream(const Params & params,size_t video_idx)574 VideoStream VideoQualityTest::DefaultVideoStream(const Params& params,
575 size_t video_idx) {
576 VideoStream stream;
577 stream.width = params.video[video_idx].width;
578 stream.height = params.video[video_idx].height;
579 stream.max_framerate = params.video[video_idx].fps;
580 stream.min_bitrate_bps = params.video[video_idx].min_bitrate_bps;
581 stream.target_bitrate_bps = params.video[video_idx].target_bitrate_bps;
582 stream.max_bitrate_bps = params.video[video_idx].max_bitrate_bps;
583 stream.max_qp = kDefaultMaxQp;
584 stream.num_temporal_layers = params.video[video_idx].num_temporal_layers;
585 stream.active = true;
586 return stream;
587 }
588
589 // Static.
DefaultThumbnailStream()590 VideoStream VideoQualityTest::DefaultThumbnailStream() {
591 VideoStream stream;
592 stream.width = 320;
593 stream.height = 180;
594 stream.max_framerate = 7;
595 stream.min_bitrate_bps = 7500;
596 stream.target_bitrate_bps = 37500;
597 stream.max_bitrate_bps = 50000;
598 stream.max_qp = kDefaultMaxQp;
599 return stream;
600 }
601
602 // Static.
FillScalabilitySettings(Params * params,size_t video_idx,const std::vector<std::string> & stream_descriptors,int num_streams,size_t selected_stream,int num_spatial_layers,int selected_sl,InterLayerPredMode inter_layer_pred,const std::vector<std::string> & sl_descriptors)603 void VideoQualityTest::FillScalabilitySettings(
604 Params* params,
605 size_t video_idx,
606 const std::vector<std::string>& stream_descriptors,
607 int num_streams,
608 size_t selected_stream,
609 int num_spatial_layers,
610 int selected_sl,
611 InterLayerPredMode inter_layer_pred,
612 const std::vector<std::string>& sl_descriptors) {
613 if (params->ss[video_idx].streams.empty() &&
614 params->ss[video_idx].infer_streams) {
615 webrtc::VideoEncoderConfig encoder_config;
616 encoder_config.codec_type =
617 PayloadStringToCodecType(params->video[video_idx].codec);
618 encoder_config.content_type =
619 params->screenshare[video_idx].enabled
620 ? webrtc::VideoEncoderConfig::ContentType::kScreen
621 : webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
622 encoder_config.max_bitrate_bps = params->video[video_idx].max_bitrate_bps;
623 encoder_config.min_transmit_bitrate_bps =
624 params->video[video_idx].min_transmit_bps;
625 encoder_config.number_of_streams = num_streams;
626 encoder_config.spatial_layers = params->ss[video_idx].spatial_layers;
627 encoder_config.simulcast_layers = std::vector<VideoStream>(num_streams);
628 encoder_config.video_stream_factory =
629 new rtc::RefCountedObject<cricket::EncoderStreamFactory>(
630 params->video[video_idx].codec, kDefaultMaxQp,
631 params->screenshare[video_idx].enabled, true);
632 params->ss[video_idx].streams =
633 encoder_config.video_stream_factory->CreateEncoderStreams(
634 static_cast<int>(params->video[video_idx].width),
635 static_cast<int>(params->video[video_idx].height), encoder_config);
636 } else {
637 // Read VideoStream and SpatialLayer elements from a list of comma separated
638 // lists. To use a default value for an element, use -1 or leave empty.
639 // Validity checks performed in CheckParamsAndInjectionComponents.
640 RTC_CHECK(params->ss[video_idx].streams.empty());
641 for (const auto& descriptor : stream_descriptors) {
642 if (descriptor.empty())
643 continue;
644 VideoStream stream =
645 VideoQualityTest::DefaultVideoStream(*params, video_idx);
646 std::vector<int> v = VideoQualityTest::ParseCSV(descriptor);
647 if (v[0] != -1)
648 stream.width = static_cast<size_t>(v[0]);
649 if (v[1] != -1)
650 stream.height = static_cast<size_t>(v[1]);
651 if (v[2] != -1)
652 stream.max_framerate = v[2];
653 if (v[3] != -1)
654 stream.min_bitrate_bps = v[3];
655 if (v[4] != -1)
656 stream.target_bitrate_bps = v[4];
657 if (v[5] != -1)
658 stream.max_bitrate_bps = v[5];
659 if (v.size() > 6 && v[6] != -1)
660 stream.max_qp = v[6];
661 if (v.size() > 7 && v[7] != -1) {
662 stream.num_temporal_layers = v[7];
663 } else {
664 // Automatic TL thresholds for more than two layers not supported.
665 RTC_CHECK_LE(params->video[video_idx].num_temporal_layers, 2);
666 }
667 params->ss[video_idx].streams.push_back(stream);
668 }
669 }
670
671 params->ss[video_idx].num_spatial_layers = std::max(1, num_spatial_layers);
672 params->ss[video_idx].selected_stream = selected_stream;
673
674 params->ss[video_idx].selected_sl = selected_sl;
675 params->ss[video_idx].inter_layer_pred = inter_layer_pred;
676 RTC_CHECK(params->ss[video_idx].spatial_layers.empty());
677 for (const auto& descriptor : sl_descriptors) {
678 if (descriptor.empty())
679 continue;
680 std::vector<int> v = VideoQualityTest::ParseCSV(descriptor);
681 RTC_CHECK_EQ(v.size(), 8);
682
683 SpatialLayer layer = {0};
684 layer.width = v[0];
685 layer.height = v[1];
686 layer.maxFramerate = v[2];
687 layer.numberOfTemporalLayers = v[3];
688 layer.maxBitrate = v[4];
689 layer.minBitrate = v[5];
690 layer.targetBitrate = v[6];
691 layer.qpMax = v[7];
692 layer.active = true;
693
694 params->ss[video_idx].spatial_layers.push_back(layer);
695 }
696 }
697
SetupVideo(Transport * send_transport,Transport * recv_transport)698 void VideoQualityTest::SetupVideo(Transport* send_transport,
699 Transport* recv_transport) {
700 size_t total_streams_used = 0;
701 video_receive_configs_.clear();
702 video_send_configs_.clear();
703 video_encoder_configs_.clear();
704 bool decode_all_receive_streams = true;
705 size_t num_video_substreams = params_.ss[0].streams.size();
706 RTC_CHECK(num_video_streams_ > 0);
707 video_encoder_configs_.resize(num_video_streams_);
708 std::string generic_codec_name;
709 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
710 video_send_configs_.push_back(VideoSendStream::Config(send_transport));
711 video_encoder_configs_.push_back(VideoEncoderConfig());
712 num_video_substreams = params_.ss[video_idx].streams.size();
713 RTC_CHECK_GT(num_video_substreams, 0);
714 for (size_t i = 0; i < num_video_substreams; ++i)
715 video_send_configs_[video_idx].rtp.ssrcs.push_back(
716 kVideoSendSsrcs[total_streams_used + i]);
717
718 int payload_type;
719 if (params_.video[video_idx].codec == "H264") {
720 payload_type = kPayloadTypeH264;
721 } else if (params_.video[video_idx].codec == "VP8") {
722 payload_type = kPayloadTypeVP8;
723 } else if (params_.video[video_idx].codec == "VP9") {
724 payload_type = kPayloadTypeVP9;
725 } else if (params_.video[video_idx].codec == "multiplex") {
726 payload_type = kPayloadTypeVP9;
727 } else if (params_.video[video_idx].codec == "FakeCodec") {
728 payload_type = kFakeVideoSendPayloadType;
729 } else {
730 RTC_CHECK(generic_codec_name.empty() ||
731 generic_codec_name == params_.video[video_idx].codec)
732 << "Supplying multiple generic codecs is unsupported.";
733 RTC_LOG(LS_INFO) << "Treating codec " << params_.video[video_idx].codec
734 << " as generic.";
735 payload_type = kPayloadTypeGeneric;
736 generic_codec_name = params_.video[video_idx].codec;
737 }
738 video_send_configs_[video_idx].encoder_settings.encoder_factory =
739 (video_idx == 0) ? &video_encoder_factory_with_analyzer_
740 : &video_encoder_factory_;
741 video_send_configs_[video_idx].encoder_settings.bitrate_allocator_factory =
742 video_bitrate_allocator_factory_.get();
743
744 video_send_configs_[video_idx].rtp.payload_name =
745 params_.video[video_idx].codec;
746 video_send_configs_[video_idx].rtp.payload_type = payload_type;
747 video_send_configs_[video_idx].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
748 video_send_configs_[video_idx].rtp.rtx.payload_type = kSendRtxPayloadType;
749 for (size_t i = 0; i < num_video_substreams; ++i) {
750 video_send_configs_[video_idx].rtp.rtx.ssrcs.push_back(
751 kSendRtxSsrcs[i + total_streams_used]);
752 }
753 video_send_configs_[video_idx].rtp.extensions.clear();
754 if (params_.call.send_side_bwe) {
755 video_send_configs_[video_idx].rtp.extensions.emplace_back(
756 RtpExtension::kTransportSequenceNumberUri,
757 kTransportSequenceNumberExtensionId);
758 } else {
759 video_send_configs_[video_idx].rtp.extensions.emplace_back(
760 RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId);
761 }
762
763 if (params_.call.generic_descriptor) {
764 video_send_configs_[video_idx].rtp.extensions.emplace_back(
765 RtpExtension::kGenericFrameDescriptorUri00,
766 kGenericFrameDescriptorExtensionId00);
767 }
768
769 video_send_configs_[video_idx].rtp.extensions.emplace_back(
770 RtpExtension::kVideoContentTypeUri, kVideoContentTypeExtensionId);
771 video_send_configs_[video_idx].rtp.extensions.emplace_back(
772 RtpExtension::kVideoTimingUri, kVideoTimingExtensionId);
773
774 video_encoder_configs_[video_idx].video_format.name =
775 params_.video[video_idx].codec;
776
777 video_encoder_configs_[video_idx].video_format.parameters =
778 params_.video[video_idx].sdp_params;
779
780 video_encoder_configs_[video_idx].codec_type =
781 PayloadStringToCodecType(params_.video[video_idx].codec);
782
783 video_encoder_configs_[video_idx].min_transmit_bitrate_bps =
784 params_.video[video_idx].min_transmit_bps;
785
786 video_send_configs_[video_idx].suspend_below_min_bitrate =
787 params_.video[video_idx].suspend_below_min_bitrate;
788
789 video_encoder_configs_[video_idx].number_of_streams =
790 params_.ss[video_idx].streams.size();
791 video_encoder_configs_[video_idx].max_bitrate_bps = 0;
792 for (size_t i = 0; i < params_.ss[video_idx].streams.size(); ++i) {
793 video_encoder_configs_[video_idx].max_bitrate_bps +=
794 params_.ss[video_idx].streams[i].max_bitrate_bps;
795 }
796 video_encoder_configs_[video_idx].simulcast_layers =
797 std::vector<VideoStream>(params_.ss[video_idx].streams.size());
798 if (!params_.ss[video_idx].infer_streams) {
799 video_encoder_configs_[video_idx].simulcast_layers =
800 params_.ss[video_idx].streams;
801 }
802 video_encoder_configs_[video_idx].video_stream_factory =
803 new rtc::RefCountedObject<cricket::EncoderStreamFactory>(
804 params_.video[video_idx].codec,
805 params_.ss[video_idx].streams[0].max_qp,
806 params_.screenshare[video_idx].enabled, true);
807
808 video_encoder_configs_[video_idx].spatial_layers =
809 params_.ss[video_idx].spatial_layers;
810 decode_all_receive_streams = params_.ss[video_idx].selected_stream ==
811 params_.ss[video_idx].streams.size();
812 absl::optional<int> decode_sub_stream;
813 if (!decode_all_receive_streams)
814 decode_sub_stream = params_.ss[video_idx].selected_stream;
815 CreateMatchingVideoReceiveConfigs(
816 video_send_configs_[video_idx], recv_transport,
817 params_.call.send_side_bwe, &video_decoder_factory_, decode_sub_stream,
818 true, kNackRtpHistoryMs);
819
820 if (params_.screenshare[video_idx].enabled) {
821 // Fill out codec settings.
822 video_encoder_configs_[video_idx].content_type =
823 VideoEncoderConfig::ContentType::kScreen;
824 degradation_preference_ = DegradationPreference::MAINTAIN_RESOLUTION;
825 if (params_.video[video_idx].codec == "VP8") {
826 VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
827 vp8_settings.denoisingOn = false;
828 vp8_settings.frameDroppingOn = false;
829 vp8_settings.numberOfTemporalLayers = static_cast<unsigned char>(
830 params_.video[video_idx].num_temporal_layers);
831 video_encoder_configs_[video_idx].encoder_specific_settings =
832 new rtc::RefCountedObject<
833 VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
834 } else if (params_.video[video_idx].codec == "VP9") {
835 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
836 vp9_settings.denoisingOn = false;
837 vp9_settings.frameDroppingOn = false;
838 vp9_settings.automaticResizeOn = false;
839 vp9_settings.numberOfTemporalLayers = static_cast<unsigned char>(
840 params_.video[video_idx].num_temporal_layers);
841 vp9_settings.numberOfSpatialLayers = static_cast<unsigned char>(
842 params_.ss[video_idx].num_spatial_layers);
843 vp9_settings.interLayerPred = params_.ss[video_idx].inter_layer_pred;
844 // High FPS vp9 screenshare requires flexible mode.
845 if (params_.ss[video_idx].num_spatial_layers > 1) {
846 vp9_settings.flexibleMode = true;
847 }
848 video_encoder_configs_[video_idx].encoder_specific_settings =
849 new rtc::RefCountedObject<
850 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
851 }
852 } else if (params_.ss[video_idx].num_spatial_layers > 1) {
853 // If SVC mode without screenshare, still need to set codec specifics.
854 RTC_CHECK(params_.video[video_idx].codec == "VP9");
855 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
856 vp9_settings.numberOfTemporalLayers = static_cast<unsigned char>(
857 params_.video[video_idx].num_temporal_layers);
858 vp9_settings.numberOfSpatialLayers =
859 static_cast<unsigned char>(params_.ss[video_idx].num_spatial_layers);
860 vp9_settings.interLayerPred = params_.ss[video_idx].inter_layer_pred;
861 vp9_settings.automaticResizeOn = false;
862 video_encoder_configs_[video_idx].encoder_specific_settings =
863 new rtc::RefCountedObject<
864 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
865 } else if (params_.video[video_idx].automatic_scaling) {
866 if (params_.video[video_idx].codec == "VP8") {
867 VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
868 vp8_settings.automaticResizeOn = true;
869 video_encoder_configs_[video_idx].encoder_specific_settings =
870 new rtc::RefCountedObject<
871 VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
872 } else if (params_.video[video_idx].codec == "VP9") {
873 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
874 // Only enable quality scaler for single spatial layer.
875 vp9_settings.automaticResizeOn =
876 params_.ss[video_idx].num_spatial_layers == 1;
877 video_encoder_configs_[video_idx].encoder_specific_settings =
878 new rtc::RefCountedObject<
879 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
880 } else if (params_.video[video_idx].codec == "H264") {
881 // Quality scaling is always on for H.264.
882 } else if (params_.video[video_idx].codec == cricket::kAv1CodecName) {
883 // TODO(bugs.webrtc.org/11404): Propagate the flag to
884 // aom_codec_enc_cfg_t::rc_resize_mode in Av1 encoder wrapper.
885 // Until then do nothing, specially do not crash.
886 } else {
887 RTC_NOTREACHED() << "Automatic scaling not supported for codec "
888 << params_.video[video_idx].codec << ", stream "
889 << video_idx;
890 }
891 } else {
892 // Default mode. Single SL, no automatic_scaling,
893 if (params_.video[video_idx].codec == "VP8") {
894 VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
895 vp8_settings.automaticResizeOn = false;
896 video_encoder_configs_[video_idx].encoder_specific_settings =
897 new rtc::RefCountedObject<
898 VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
899 } else if (params_.video[video_idx].codec == "VP9") {
900 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
901 vp9_settings.automaticResizeOn = false;
902 video_encoder_configs_[video_idx].encoder_specific_settings =
903 new rtc::RefCountedObject<
904 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
905 } else if (params_.video[video_idx].codec == "H264") {
906 VideoCodecH264 h264_settings = VideoEncoder::GetDefaultH264Settings();
907 video_encoder_configs_[video_idx].encoder_specific_settings =
908 new rtc::RefCountedObject<
909 VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
910 }
911 }
912 total_streams_used += num_video_substreams;
913 }
914
915 // FEC supported only for single video stream mode yet.
916 if (params_.video[0].flexfec) {
917 if (decode_all_receive_streams) {
918 SetSendFecConfig(GetVideoSendConfig()->rtp.ssrcs);
919 } else {
920 SetSendFecConfig({kVideoSendSsrcs[params_.ss[0].selected_stream]});
921 }
922
923 CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig());
924 GetFlexFecConfig()->transport_cc = params_.call.send_side_bwe;
925 if (params_.call.send_side_bwe) {
926 GetFlexFecConfig()->rtp_header_extensions.push_back(
927 RtpExtension(RtpExtension::kTransportSequenceNumberUri,
928 kTransportSequenceNumberExtensionId));
929 } else {
930 GetFlexFecConfig()->rtp_header_extensions.push_back(
931 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
932 }
933 }
934
935 if (params_.video[0].ulpfec) {
936 SetSendUlpFecConfig(GetVideoSendConfig());
937 if (decode_all_receive_streams) {
938 for (auto& receive_config : video_receive_configs_) {
939 SetReceiveUlpFecConfig(&receive_config);
940 }
941 } else {
942 SetReceiveUlpFecConfig(
943 &video_receive_configs_[params_.ss[0].selected_stream]);
944 }
945 }
946 }
947
SetupThumbnails(Transport * send_transport,Transport * recv_transport)948 void VideoQualityTest::SetupThumbnails(Transport* send_transport,
949 Transport* recv_transport) {
950 for (int i = 0; i < params_.call.num_thumbnails; ++i) {
951 // Thumbnails will be send in the other way: from receiver_call to
952 // sender_call.
953 VideoSendStream::Config thumbnail_send_config(recv_transport);
954 thumbnail_send_config.rtp.ssrcs.push_back(kThumbnailSendSsrcStart + i);
955 // TODO(nisse): Could use a simpler VP8-only encoder factory.
956 thumbnail_send_config.encoder_settings.encoder_factory =
957 &video_encoder_factory_;
958 thumbnail_send_config.encoder_settings.bitrate_allocator_factory =
959 video_bitrate_allocator_factory_.get();
960 thumbnail_send_config.rtp.payload_name = params_.video[0].codec;
961 thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8;
962 thumbnail_send_config.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
963 thumbnail_send_config.rtp.rtx.payload_type = kSendRtxPayloadType;
964 thumbnail_send_config.rtp.rtx.ssrcs.push_back(kThumbnailRtxSsrcStart + i);
965 thumbnail_send_config.rtp.extensions.clear();
966 if (params_.call.send_side_bwe) {
967 thumbnail_send_config.rtp.extensions.push_back(
968 RtpExtension(RtpExtension::kTransportSequenceNumberUri,
969 kTransportSequenceNumberExtensionId));
970 } else {
971 thumbnail_send_config.rtp.extensions.push_back(
972 RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
973 }
974
975 VideoEncoderConfig thumbnail_encoder_config;
976 thumbnail_encoder_config.codec_type = kVideoCodecVP8;
977 thumbnail_encoder_config.video_format.name = "VP8";
978 thumbnail_encoder_config.min_transmit_bitrate_bps = 7500;
979 thumbnail_send_config.suspend_below_min_bitrate =
980 params_.video[0].suspend_below_min_bitrate;
981 thumbnail_encoder_config.number_of_streams = 1;
982 thumbnail_encoder_config.max_bitrate_bps = 50000;
983 std::vector<VideoStream> streams{params_.ss[0].streams[0]};
984 thumbnail_encoder_config.video_stream_factory =
985 new rtc::RefCountedObject<VideoStreamFactory>(streams);
986 thumbnail_encoder_config.spatial_layers = params_.ss[0].spatial_layers;
987
988 thumbnail_encoder_configs_.push_back(thumbnail_encoder_config.Copy());
989 thumbnail_send_configs_.push_back(thumbnail_send_config.Copy());
990
991 AddMatchingVideoReceiveConfigs(
992 &thumbnail_receive_configs_, thumbnail_send_config, send_transport,
993 params_.call.send_side_bwe, &video_decoder_factory_, absl::nullopt,
994 false, kNackRtpHistoryMs);
995 }
996 for (size_t i = 0; i < thumbnail_send_configs_.size(); ++i) {
997 thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream(
998 thumbnail_send_configs_[i].Copy(),
999 thumbnail_encoder_configs_[i].Copy()));
1000 }
1001 for (size_t i = 0; i < thumbnail_receive_configs_.size(); ++i) {
1002 thumbnail_receive_streams_.push_back(sender_call_->CreateVideoReceiveStream(
1003 thumbnail_receive_configs_[i].Copy()));
1004 }
1005 }
1006
DestroyThumbnailStreams()1007 void VideoQualityTest::DestroyThumbnailStreams() {
1008 for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_) {
1009 receiver_call_->DestroyVideoSendStream(thumbnail_send_stream);
1010 }
1011 thumbnail_send_streams_.clear();
1012 for (VideoReceiveStream* thumbnail_receive_stream :
1013 thumbnail_receive_streams_) {
1014 sender_call_->DestroyVideoReceiveStream(thumbnail_receive_stream);
1015 }
1016 thumbnail_send_streams_.clear();
1017 thumbnail_receive_streams_.clear();
1018 for (std::unique_ptr<rtc::VideoSourceInterface<VideoFrame>>& video_capturer :
1019 thumbnail_capturers_) {
1020 video_capturer.reset();
1021 }
1022 }
1023
SetupThumbnailCapturers(size_t num_thumbnail_streams)1024 void VideoQualityTest::SetupThumbnailCapturers(size_t num_thumbnail_streams) {
1025 VideoStream thumbnail = DefaultThumbnailStream();
1026 for (size_t i = 0; i < num_thumbnail_streams; ++i) {
1027 auto frame_generator_capturer =
1028 std::make_unique<test::FrameGeneratorCapturer>(
1029 clock_,
1030 test::CreateSquareFrameGenerator(static_cast<int>(thumbnail.width),
1031 static_cast<int>(thumbnail.height),
1032 absl::nullopt, absl::nullopt),
1033 thumbnail.max_framerate, *task_queue_factory_);
1034 EXPECT_TRUE(frame_generator_capturer->Init());
1035 thumbnail_capturers_.push_back(std::move(frame_generator_capturer));
1036 }
1037 }
1038
1039 std::unique_ptr<test::FrameGeneratorInterface>
CreateFrameGenerator(size_t video_idx)1040 VideoQualityTest::CreateFrameGenerator(size_t video_idx) {
1041 // Setup frame generator.
1042 const size_t kWidth = 1850;
1043 const size_t kHeight = 1110;
1044 std::unique_ptr<test::FrameGeneratorInterface> frame_generator;
1045 if (params_.screenshare[video_idx].generate_slides) {
1046 frame_generator = test::CreateSlideFrameGenerator(
1047 kWidth, kHeight,
1048 params_.screenshare[video_idx].slide_change_interval *
1049 params_.video[video_idx].fps);
1050 } else {
1051 std::vector<std::string> slides = params_.screenshare[video_idx].slides;
1052 if (slides.empty()) {
1053 slides.push_back(test::ResourcePath("web_screenshot_1850_1110", "yuv"));
1054 slides.push_back(test::ResourcePath("presentation_1850_1110", "yuv"));
1055 slides.push_back(test::ResourcePath("photo_1850_1110", "yuv"));
1056 slides.push_back(test::ResourcePath("difficult_photo_1850_1110", "yuv"));
1057 }
1058 if (params_.screenshare[video_idx].scroll_duration == 0) {
1059 // Cycle image every slide_change_interval seconds.
1060 frame_generator = test::CreateFromYuvFileFrameGenerator(
1061 slides, kWidth, kHeight,
1062 params_.screenshare[video_idx].slide_change_interval *
1063 params_.video[video_idx].fps);
1064 } else {
1065 RTC_CHECK_LE(params_.video[video_idx].width, kWidth);
1066 RTC_CHECK_LE(params_.video[video_idx].height, kHeight);
1067 RTC_CHECK_GT(params_.screenshare[video_idx].slide_change_interval, 0);
1068 const int kPauseDurationMs =
1069 (params_.screenshare[video_idx].slide_change_interval -
1070 params_.screenshare[video_idx].scroll_duration) *
1071 1000;
1072 RTC_CHECK_LE(params_.screenshare[video_idx].scroll_duration,
1073 params_.screenshare[video_idx].slide_change_interval);
1074
1075 frame_generator = test::CreateScrollingInputFromYuvFilesFrameGenerator(
1076 clock_, slides, kWidth, kHeight, params_.video[video_idx].width,
1077 params_.video[video_idx].height,
1078 params_.screenshare[video_idx].scroll_duration * 1000,
1079 kPauseDurationMs);
1080 }
1081 }
1082 return frame_generator;
1083 }
1084
CreateCapturers()1085 void VideoQualityTest::CreateCapturers() {
1086 RTC_DCHECK(video_sources_.empty());
1087 video_sources_.resize(num_video_streams_);
1088 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
1089 std::unique_ptr<test::FrameGeneratorInterface> frame_generator;
1090 if (params_.screenshare[video_idx].enabled) {
1091 frame_generator = CreateFrameGenerator(video_idx);
1092 } else if (params_.video[video_idx].clip_path == "Generator") {
1093 frame_generator = test::CreateSquareFrameGenerator(
1094 static_cast<int>(params_.video[video_idx].width),
1095 static_cast<int>(params_.video[video_idx].height), absl::nullopt,
1096 absl::nullopt);
1097 } else if (params_.video[video_idx].clip_path == "GeneratorI420A") {
1098 frame_generator = test::CreateSquareFrameGenerator(
1099 static_cast<int>(params_.video[video_idx].width),
1100 static_cast<int>(params_.video[video_idx].height),
1101 test::FrameGeneratorInterface::OutputType::kI420A, absl::nullopt);
1102 } else if (params_.video[video_idx].clip_path == "GeneratorI010") {
1103 frame_generator = test::CreateSquareFrameGenerator(
1104 static_cast<int>(params_.video[video_idx].width),
1105 static_cast<int>(params_.video[video_idx].height),
1106 test::FrameGeneratorInterface::OutputType::kI010, absl::nullopt);
1107 } else if (params_.video[video_idx].clip_path.empty()) {
1108 video_sources_[video_idx] = test::CreateVideoCapturer(
1109 params_.video[video_idx].width, params_.video[video_idx].height,
1110 params_.video[video_idx].fps,
1111 params_.video[video_idx].capture_device_index);
1112 if (video_sources_[video_idx]) {
1113 continue;
1114 } else {
1115 // Failed to get actual camera, use chroma generator as backup.
1116 frame_generator = test::CreateSquareFrameGenerator(
1117 static_cast<int>(params_.video[video_idx].width),
1118 static_cast<int>(params_.video[video_idx].height), absl::nullopt,
1119 absl::nullopt);
1120 }
1121 } else {
1122 frame_generator = test::CreateFromYuvFileFrameGenerator(
1123 {params_.video[video_idx].clip_path}, params_.video[video_idx].width,
1124 params_.video[video_idx].height, 1);
1125 ASSERT_TRUE(frame_generator) << "Could not create capturer for "
1126 << params_.video[video_idx].clip_path
1127 << ".yuv. Is this file present?";
1128 }
1129 ASSERT_TRUE(frame_generator);
1130 auto frame_generator_capturer =
1131 std::make_unique<test::FrameGeneratorCapturer>(
1132 clock_, std::move(frame_generator), params_.video[video_idx].fps,
1133 *task_queue_factory_);
1134 EXPECT_TRUE(frame_generator_capturer->Init());
1135 video_sources_[video_idx] = std::move(frame_generator_capturer);
1136 }
1137 }
1138
StartAudioStreams()1139 void VideoQualityTest::StartAudioStreams() {
1140 audio_send_stream_->Start();
1141 for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_)
1142 audio_recv_stream->Start();
1143 }
1144
StartThumbnails()1145 void VideoQualityTest::StartThumbnails() {
1146 for (VideoSendStream* send_stream : thumbnail_send_streams_)
1147 send_stream->Start();
1148 for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
1149 receive_stream->Start();
1150 }
1151
StopThumbnails()1152 void VideoQualityTest::StopThumbnails() {
1153 for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
1154 receive_stream->Stop();
1155 for (VideoSendStream* send_stream : thumbnail_send_streams_)
1156 send_stream->Stop();
1157 }
1158
1159 std::unique_ptr<test::LayerFilteringTransport>
CreateSendTransport()1160 VideoQualityTest::CreateSendTransport() {
1161 std::unique_ptr<NetworkBehaviorInterface> network_behavior = nullptr;
1162 if (injection_components_->sender_network == nullptr) {
1163 network_behavior = std::make_unique<SimulatedNetwork>(*params_.config);
1164 } else {
1165 network_behavior = std::move(injection_components_->sender_network);
1166 }
1167 return std::make_unique<test::LayerFilteringTransport>(
1168 task_queue(),
1169 std::make_unique<FakeNetworkPipe>(clock_, std::move(network_behavior)),
1170 sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
1171 params_.video[0].selected_tl, params_.ss[0].selected_sl,
1172 payload_type_map_, kVideoSendSsrcs[0],
1173 static_cast<uint32_t>(kVideoSendSsrcs[0] + params_.ss[0].streams.size() -
1174 1));
1175 }
1176
1177 std::unique_ptr<test::DirectTransport>
CreateReceiveTransport()1178 VideoQualityTest::CreateReceiveTransport() {
1179 std::unique_ptr<NetworkBehaviorInterface> network_behavior = nullptr;
1180 if (injection_components_->receiver_network == nullptr) {
1181 network_behavior = std::make_unique<SimulatedNetwork>(*params_.config);
1182 } else {
1183 network_behavior = std::move(injection_components_->receiver_network);
1184 }
1185 return std::make_unique<test::DirectTransport>(
1186 task_queue(),
1187 std::make_unique<FakeNetworkPipe>(clock_, std::move(network_behavior)),
1188 receiver_call_.get(), payload_type_map_);
1189 }
1190
RunWithAnalyzer(const Params & params)1191 void VideoQualityTest::RunWithAnalyzer(const Params& params) {
1192 num_video_streams_ = params.call.dual_video ? 2 : 1;
1193 std::unique_ptr<test::LayerFilteringTransport> send_transport;
1194 std::unique_ptr<test::DirectTransport> recv_transport;
1195 FILE* graph_data_output_file = nullptr;
1196
1197 params_ = params;
1198 // TODO(ivica): Merge with RunWithRenderer and use a flag / argument to
1199 // differentiate between the analyzer and the renderer case.
1200 CheckParamsAndInjectionComponents();
1201
1202 if (!params_.analyzer.graph_data_output_filename.empty()) {
1203 graph_data_output_file =
1204 fopen(params_.analyzer.graph_data_output_filename.c_str(), "w");
1205 RTC_CHECK(graph_data_output_file)
1206 << "Can't open the file " << params_.analyzer.graph_data_output_filename
1207 << "!";
1208 }
1209
1210 if (!params.logging.rtc_event_log_name.empty()) {
1211 send_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
1212 RtcEventLog::EncodingType::Legacy);
1213 recv_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
1214 RtcEventLog::EncodingType::Legacy);
1215 std::unique_ptr<RtcEventLogOutputFile> send_output(
1216 std::make_unique<RtcEventLogOutputFile>(
1217 params.logging.rtc_event_log_name + "_send",
1218 RtcEventLog::kUnlimitedOutput));
1219 std::unique_ptr<RtcEventLogOutputFile> recv_output(
1220 std::make_unique<RtcEventLogOutputFile>(
1221 params.logging.rtc_event_log_name + "_recv",
1222 RtcEventLog::kUnlimitedOutput));
1223 bool event_log_started =
1224 send_event_log_->StartLogging(std::move(send_output),
1225 RtcEventLog::kImmediateOutput) &&
1226 recv_event_log_->StartLogging(std::move(recv_output),
1227 RtcEventLog::kImmediateOutput);
1228 RTC_DCHECK(event_log_started);
1229 } else {
1230 send_event_log_ = std::make_unique<RtcEventLogNull>();
1231 recv_event_log_ = std::make_unique<RtcEventLogNull>();
1232 }
1233
1234 SendTask(RTC_FROM_HERE, task_queue(),
1235 [this, ¶ms, &send_transport, &recv_transport]() {
1236 Call::Config send_call_config(send_event_log_.get());
1237 Call::Config recv_call_config(recv_event_log_.get());
1238 send_call_config.bitrate_config = params.call.call_bitrate_config;
1239 recv_call_config.bitrate_config = params.call.call_bitrate_config;
1240 if (params_.audio.enabled)
1241 InitializeAudioDevice(&send_call_config, &recv_call_config,
1242 params_.audio.use_real_adm);
1243
1244 CreateCalls(send_call_config, recv_call_config);
1245 send_transport = CreateSendTransport();
1246 recv_transport = CreateReceiveTransport();
1247 });
1248
1249 std::string graph_title = params_.analyzer.graph_title;
1250 if (graph_title.empty())
1251 graph_title = VideoQualityTest::GenerateGraphTitle();
1252 bool is_quick_test_enabled = field_trial::IsEnabled("WebRTC-QuickPerfTest");
1253 analyzer_ = std::make_unique<VideoAnalyzer>(
1254 send_transport.get(), params_.analyzer.test_label,
1255 params_.analyzer.avg_psnr_threshold, params_.analyzer.avg_ssim_threshold,
1256 is_quick_test_enabled
1257 ? kFramesSentInQuickTest
1258 : params_.analyzer.test_durations_secs * params_.video[0].fps,
1259 is_quick_test_enabled
1260 ? TimeDelta::Millis(1)
1261 : TimeDelta::Seconds(params_.analyzer.test_durations_secs),
1262 graph_data_output_file, graph_title,
1263 kVideoSendSsrcs[params_.ss[0].selected_stream],
1264 kSendRtxSsrcs[params_.ss[0].selected_stream],
1265 static_cast<size_t>(params_.ss[0].selected_stream),
1266 params.ss[0].selected_sl, params_.video[0].selected_tl,
1267 is_quick_test_enabled, clock_, params_.logging.rtp_dump_name,
1268 task_queue());
1269
1270 SendTask(RTC_FROM_HERE, task_queue(), [&]() {
1271 analyzer_->SetCall(sender_call_.get());
1272 analyzer_->SetReceiver(receiver_call_->Receiver());
1273 send_transport->SetReceiver(analyzer_.get());
1274 recv_transport->SetReceiver(sender_call_->Receiver());
1275
1276 SetupVideo(analyzer_.get(), recv_transport.get());
1277 SetupThumbnails(analyzer_.get(), recv_transport.get());
1278 video_receive_configs_[params_.ss[0].selected_stream].renderer =
1279 analyzer_.get();
1280
1281 CreateFlexfecStreams();
1282 CreateVideoStreams();
1283 analyzer_->SetSendStream(video_send_streams_[0]);
1284 analyzer_->SetReceiveStream(
1285 video_receive_streams_[params_.ss[0].selected_stream]);
1286
1287 GetVideoSendStream()->SetSource(analyzer_->OutputInterface(),
1288 degradation_preference_);
1289 SetupThumbnailCapturers(params_.call.num_thumbnails);
1290 for (size_t i = 0; i < thumbnail_send_streams_.size(); ++i) {
1291 thumbnail_send_streams_[i]->SetSource(thumbnail_capturers_[i].get(),
1292 degradation_preference_);
1293 }
1294
1295 CreateCapturers();
1296
1297 analyzer_->SetSource(video_sources_[0].get(), true);
1298
1299 for (size_t video_idx = 1; video_idx < num_video_streams_; ++video_idx) {
1300 video_send_streams_[video_idx]->SetSource(video_sources_[video_idx].get(),
1301 degradation_preference_);
1302 }
1303
1304 if (params_.audio.enabled) {
1305 SetupAudio(send_transport.get());
1306 StartAudioStreams();
1307 analyzer_->SetAudioReceiveStream(audio_receive_streams_[0]);
1308 }
1309 StartVideoStreams();
1310 StartThumbnails();
1311 analyzer_->StartMeasuringCpuProcessTime();
1312 });
1313
1314 analyzer_->Wait();
1315
1316 SendTask(RTC_FROM_HERE, task_queue(), [&]() {
1317 StopThumbnails();
1318 Stop();
1319
1320 DestroyStreams();
1321 DestroyThumbnailStreams();
1322
1323 if (graph_data_output_file)
1324 fclose(graph_data_output_file);
1325
1326 send_transport.reset();
1327 recv_transport.reset();
1328
1329 DestroyCalls();
1330 });
1331 analyzer_ = nullptr;
1332 }
1333
CreateAudioDevice()1334 rtc::scoped_refptr<AudioDeviceModule> VideoQualityTest::CreateAudioDevice() {
1335 #ifdef WEBRTC_WIN
1336 RTC_LOG(INFO) << "Using latest version of ADM on Windows";
1337 // We must initialize the COM library on a thread before we calling any of
1338 // the library functions. All COM functions in the ADM will return
1339 // CO_E_NOTINITIALIZED otherwise. The legacy ADM for Windows used internal
1340 // COM initialization but the new ADM requires COM to be initialized
1341 // externally.
1342 com_initializer_ = std::make_unique<webrtc_win::ScopedCOMInitializer>(
1343 webrtc_win::ScopedCOMInitializer::kMTA);
1344 RTC_CHECK(com_initializer_->Succeeded());
1345 RTC_CHECK(webrtc_win::core_audio_utility::IsSupported());
1346 RTC_CHECK(webrtc_win::core_audio_utility::IsMMCSSSupported());
1347 return CreateWindowsCoreAudioAudioDeviceModule(task_queue_factory_.get());
1348 #else
1349 // Use legacy factory method on all platforms except Windows.
1350 return AudioDeviceModule::Create(AudioDeviceModule::kPlatformDefaultAudio,
1351 task_queue_factory_.get());
1352 #endif
1353 }
1354
InitializeAudioDevice(Call::Config * send_call_config,Call::Config * recv_call_config,bool use_real_adm)1355 void VideoQualityTest::InitializeAudioDevice(Call::Config* send_call_config,
1356 Call::Config* recv_call_config,
1357 bool use_real_adm) {
1358 rtc::scoped_refptr<AudioDeviceModule> audio_device;
1359 if (use_real_adm) {
1360 // Run test with real ADM (using default audio devices) if user has
1361 // explicitly set the --audio and --use_real_adm command-line flags.
1362 audio_device = CreateAudioDevice();
1363 } else {
1364 // By default, create a test ADM which fakes audio.
1365 audio_device = TestAudioDeviceModule::Create(
1366 task_queue_factory_.get(),
1367 TestAudioDeviceModule::CreatePulsedNoiseCapturer(32000, 48000),
1368 TestAudioDeviceModule::CreateDiscardRenderer(48000), 1.f);
1369 }
1370 RTC_CHECK(audio_device);
1371
1372 AudioState::Config audio_state_config;
1373 audio_state_config.audio_mixer = AudioMixerImpl::Create();
1374 audio_state_config.audio_processing = AudioProcessingBuilder().Create();
1375 audio_state_config.audio_device_module = audio_device;
1376 send_call_config->audio_state = AudioState::Create(audio_state_config);
1377 recv_call_config->audio_state = AudioState::Create(audio_state_config);
1378 if (use_real_adm) {
1379 // The real ADM requires extra initialization: setting default devices,
1380 // setting up number of channels etc. Helper class also calls
1381 // AudioDeviceModule::Init().
1382 webrtc::adm_helpers::Init(audio_device.get());
1383 } else {
1384 audio_device->Init();
1385 }
1386 // Always initialize the ADM before injecting a valid audio transport.
1387 RTC_CHECK(audio_device->RegisterAudioCallback(
1388 send_call_config->audio_state->audio_transport()) == 0);
1389 }
1390
SetupAudio(Transport * transport)1391 void VideoQualityTest::SetupAudio(Transport* transport) {
1392 AudioSendStream::Config audio_send_config(transport);
1393 audio_send_config.rtp.ssrc = kAudioSendSsrc;
1394
1395 // Add extension to enable audio send side BWE, and allow audio bit rate
1396 // adaptation.
1397 audio_send_config.rtp.extensions.clear();
1398 audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
1399 kAudioSendPayloadType,
1400 {"OPUS",
1401 48000,
1402 2,
1403 {{"usedtx", (params_.audio.dtx ? "1" : "0")}, {"stereo", "1"}}});
1404
1405 if (params_.call.send_side_bwe) {
1406 audio_send_config.rtp.extensions.push_back(
1407 webrtc::RtpExtension(webrtc::RtpExtension::kTransportSequenceNumberUri,
1408 kTransportSequenceNumberExtensionId));
1409 audio_send_config.min_bitrate_bps = kOpusMinBitrateBps;
1410 audio_send_config.max_bitrate_bps = kOpusBitrateFbBps;
1411 audio_send_config.send_codec_spec->transport_cc_enabled = true;
1412 // Only allow ANA when send-side BWE is enabled.
1413 audio_send_config.audio_network_adaptor_config = params_.audio.ana_config;
1414 }
1415 audio_send_config.encoder_factory = audio_encoder_factory_;
1416 SetAudioConfig(audio_send_config);
1417
1418 std::string sync_group;
1419 if (params_.video[0].enabled && params_.audio.sync_video)
1420 sync_group = kSyncGroup;
1421
1422 CreateMatchingAudioConfigs(transport, sync_group);
1423 CreateAudioStreams();
1424 }
1425
RunWithRenderers(const Params & params)1426 void VideoQualityTest::RunWithRenderers(const Params& params) {
1427 RTC_LOG(INFO) << __FUNCTION__;
1428 num_video_streams_ = params.call.dual_video ? 2 : 1;
1429 std::unique_ptr<test::LayerFilteringTransport> send_transport;
1430 std::unique_ptr<test::DirectTransport> recv_transport;
1431 std::unique_ptr<test::VideoRenderer> local_preview;
1432 std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers;
1433
1434 if (!params.logging.rtc_event_log_name.empty()) {
1435 send_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
1436 RtcEventLog::EncodingType::Legacy);
1437 recv_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
1438 RtcEventLog::EncodingType::Legacy);
1439 std::unique_ptr<RtcEventLogOutputFile> send_output(
1440 std::make_unique<RtcEventLogOutputFile>(
1441 params.logging.rtc_event_log_name + "_send",
1442 RtcEventLog::kUnlimitedOutput));
1443 std::unique_ptr<RtcEventLogOutputFile> recv_output(
1444 std::make_unique<RtcEventLogOutputFile>(
1445 params.logging.rtc_event_log_name + "_recv",
1446 RtcEventLog::kUnlimitedOutput));
1447 bool event_log_started =
1448 send_event_log_->StartLogging(std::move(send_output),
1449 /*output_period_ms=*/5000) &&
1450 recv_event_log_->StartLogging(std::move(recv_output),
1451 /*output_period_ms=*/5000);
1452 RTC_DCHECK(event_log_started);
1453 } else {
1454 send_event_log_ = std::make_unique<RtcEventLogNull>();
1455 recv_event_log_ = std::make_unique<RtcEventLogNull>();
1456 }
1457
1458 SendTask(RTC_FROM_HERE, task_queue(), [&]() {
1459 params_ = params;
1460 CheckParamsAndInjectionComponents();
1461
1462 // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to
1463 // match the full stack tests.
1464 Call::Config send_call_config(send_event_log_.get());
1465 send_call_config.bitrate_config = params_.call.call_bitrate_config;
1466 Call::Config recv_call_config(recv_event_log_.get());
1467
1468 if (params_.audio.enabled)
1469 InitializeAudioDevice(&send_call_config, &recv_call_config,
1470 params_.audio.use_real_adm);
1471
1472 CreateCalls(send_call_config, recv_call_config);
1473
1474 // TODO(minyue): consider if this is a good transport even for audio only
1475 // calls.
1476 send_transport = CreateSendTransport();
1477
1478 recv_transport = CreateReceiveTransport();
1479
1480 // TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
1481 // least share as much code as possible. That way this test would also match
1482 // the full stack tests better.
1483 send_transport->SetReceiver(receiver_call_->Receiver());
1484 recv_transport->SetReceiver(sender_call_->Receiver());
1485
1486 if (params_.video[0].enabled) {
1487 // Create video renderers.
1488 SetupVideo(send_transport.get(), recv_transport.get());
1489 size_t num_streams_processed = 0;
1490 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
1491 const size_t selected_stream_id = params_.ss[video_idx].selected_stream;
1492 const size_t num_streams = params_.ss[video_idx].streams.size();
1493 if (selected_stream_id == num_streams) {
1494 for (size_t stream_id = 0; stream_id < num_streams; ++stream_id) {
1495 rtc::StringBuilder oss;
1496 oss << "Loopback Video #" << video_idx << " - Stream #"
1497 << static_cast<int>(stream_id);
1498 loopback_renderers.emplace_back(test::VideoRenderer::Create(
1499 oss.str().c_str(),
1500 params_.ss[video_idx].streams[stream_id].width,
1501 params_.ss[video_idx].streams[stream_id].height));
1502 video_receive_configs_[stream_id + num_streams_processed].renderer =
1503 loopback_renderers.back().get();
1504 if (params_.audio.enabled && params_.audio.sync_video)
1505 video_receive_configs_[stream_id + num_streams_processed]
1506 .sync_group = kSyncGroup;
1507 }
1508 } else {
1509 rtc::StringBuilder oss;
1510 oss << "Loopback Video #" << video_idx;
1511 loopback_renderers.emplace_back(test::VideoRenderer::Create(
1512 oss.str().c_str(),
1513 params_.ss[video_idx].streams[selected_stream_id].width,
1514 params_.ss[video_idx].streams[selected_stream_id].height));
1515 video_receive_configs_[selected_stream_id + num_streams_processed]
1516 .renderer = loopback_renderers.back().get();
1517 if (params_.audio.enabled && params_.audio.sync_video)
1518 video_receive_configs_[num_streams_processed + selected_stream_id]
1519 .sync_group = kSyncGroup;
1520 }
1521 num_streams_processed += num_streams;
1522 }
1523 CreateFlexfecStreams();
1524 CreateVideoStreams();
1525
1526 CreateCapturers();
1527 if (params_.video[0].enabled) {
1528 // Create local preview
1529 local_preview.reset(test::VideoRenderer::Create(
1530 "Local Preview", params_.video[0].width, params_.video[0].height));
1531
1532 video_sources_[0]->AddOrUpdateSink(local_preview.get(),
1533 rtc::VideoSinkWants());
1534 }
1535 ConnectVideoSourcesToStreams();
1536 }
1537
1538 if (params_.audio.enabled) {
1539 SetupAudio(send_transport.get());
1540 }
1541
1542 Start();
1543 });
1544
1545 PressEnterToContinue(task_queue());
1546
1547 SendTask(RTC_FROM_HERE, task_queue(), [&]() {
1548 Stop();
1549 DestroyStreams();
1550
1551 send_transport.reset();
1552 recv_transport.reset();
1553
1554 local_preview.reset();
1555 loopback_renderers.clear();
1556
1557 DestroyCalls();
1558 });
1559 }
1560
1561 } // namespace webrtc
1562