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, &params, &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