blob: b5290d8463945dd20d0c54ee79ce1d94bc542809 [file] [log] [blame]
ivica5d6a06c2015-09-17 05:30:24 -07001/*
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 */
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020010#include "video/video_quality_test.h"
perkj9fdbda62016-09-15 09:19:20 -070011
perkja49cbd32016-09-16 07:53:41 -070012#include <stdio.h>
ivica5d6a06c2015-09-17 05:30:24 -070013#include <algorithm>
14#include <deque>
15#include <map>
mflodmand1590b22015-12-09 07:07:59 -080016#include <string>
ivica5d6a06c2015-09-17 05:30:24 -070017#include <vector>
18
Florent Castellie7862cc2018-12-06 13:38:24 +010019#include "absl/memory/memory.h"
Jiawei Ouc2ebe212018-11-08 10:02:56 -080020#include "api/video/builtin_video_bitrate_allocator_factory.h"
Artem Titovdd2eebe2018-08-20 13:27:45 +020021#include "call/fake_network_pipe.h"
22#include "call/simulated_network.h"
Elad Alon83ccca12017-10-04 13:18:26 +020023#include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
henrika255750b2018-08-27 16:13:37 +020024#include "media/engine/adm_helpers.h"
Florent Castellie7862cc2018-12-06 13:38:24 +010025#include "media/engine/encoder_simulcast_proxy.h"
Magnus Jedvert46a27652017-11-13 14:10:02 +010026#include "media/engine/internalencoderfactory.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020027#include "media/engine/webrtcvideoengine.h"
henrika255750b2018-08-27 16:13:37 +020028#include "modules/audio_device/include/audio_device.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020029#include "modules/audio_mixer/audio_mixer_impl.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020030#include "modules/video_coding/codecs/h264/include/h264.h"
Niels Möllercbcbc222018-09-28 09:07:24 +020031#include "modules/video_coding/codecs/multiplex/include/multiplex_decoder_adapter.h"
Emircan Uysaler03e6ec92018-03-09 15:03:26 -080032#include "modules/video_coding/codecs/multiplex/include/multiplex_encoder_adapter.h"
Niels Möller4db138e2018-04-19 09:04:13 +020033#include "modules/video_coding/codecs/vp8/include/vp8.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020034#include "modules/video_coding/codecs/vp9/include/vp9.h"
Niels Möller1beef1a2018-09-03 14:21:44 +020035#include "modules/video_coding/utility/ivf_file_writer.h"
36#include "rtc_base/strings/string_builder.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020037#include "test/run_loop.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020038#include "test/testsupport/fileutils.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020039#include "test/video_renderer.h"
Erik Språng96965ae2018-10-23 15:42:37 +020040#include "video/frame_dumping_decoder.h"
henrika255750b2018-08-27 16:13:37 +020041#ifdef WEBRTC_WIN
42#include "modules/audio_device/include/audio_device_factory.h"
43#endif
ilnikee42d192017-08-22 07:16:20 -070044
Niels Möller1beef1a2018-09-03 14:21:44 +020045namespace webrtc {
46
minyue73208662016-08-18 06:28:55 -070047namespace {
minyue73208662016-08-18 06:28:55 -070048constexpr char kSyncGroup[] = "av_sync";
minyue10cbb462016-11-07 09:29:22 -080049constexpr int kOpusMinBitrateBps = 6000;
50constexpr int kOpusBitrateFbBps = 32000;
ilnik9ae0d762017-02-15 00:53:12 -080051constexpr int kFramesSentInQuickTest = 1;
ilnika014cc52017-03-07 04:21:04 -080052constexpr uint32_t kThumbnailSendSsrcStart = 0xE0000;
53constexpr uint32_t kThumbnailRtxSsrcStart = 0xF0000;
minyue73208662016-08-18 06:28:55 -070054
sprang1168fd42017-06-21 09:00:17 -070055constexpr int kDefaultMaxQp = cricket::WebRtcVideoChannel::kDefaultQpMax;
56
perkjfa10b552016-10-02 23:45:26 -070057class VideoStreamFactory
Niels Möller1beef1a2018-09-03 14:21:44 +020058 : public VideoEncoderConfig::VideoStreamFactoryInterface {
perkjfa10b552016-10-02 23:45:26 -070059 public:
Niels Möller1beef1a2018-09-03 14:21:44 +020060 explicit VideoStreamFactory(const std::vector<VideoStream>& streams)
perkjfa10b552016-10-02 23:45:26 -070061 : streams_(streams) {}
62
63 private:
Niels Möller1beef1a2018-09-03 14:21:44 +020064 std::vector<VideoStream> CreateEncoderStreams(
perkjfa10b552016-10-02 23:45:26 -070065 int width,
66 int height,
Niels Möller1beef1a2018-09-03 14:21:44 +020067 const VideoEncoderConfig& encoder_config) override {
mflodmand79f97b2016-12-15 07:24:33 -080068 // The highest layer must match the incoming resolution.
Niels Möller1beef1a2018-09-03 14:21:44 +020069 std::vector<VideoStream> streams = streams_;
mflodmand79f97b2016-12-15 07:24:33 -080070 streams[streams_.size() - 1].height = height;
71 streams[streams_.size() - 1].width = width;
Seth Hampson24722b32017-12-22 09:36:42 -080072
73 streams[0].bitrate_priority = encoder_config.bitrate_priority;
mflodmand79f97b2016-12-15 07:24:33 -080074 return streams;
perkjfa10b552016-10-02 23:45:26 -070075 }
76
Niels Möller1beef1a2018-09-03 14:21:44 +020077 std::vector<VideoStream> streams_;
perkjfa10b552016-10-02 23:45:26 -070078};
ivica5d6a06c2015-09-17 05:30:24 -070079
Niels Möller88be9722018-10-10 10:58:52 +020080// This wrapper provides two features needed by the video quality tests:
81// 1. Invoke VideoAnalyzer callbacks before and after encoding each frame.
82// 2. Write the encoded frames to file, one file per simulcast layer.
83class QualityTestVideoEncoder : public VideoEncoder,
84 private EncodedImageCallback {
Niels Möller1beef1a2018-09-03 14:21:44 +020085 public:
Niels Möller88be9722018-10-10 10:58:52 +020086 QualityTestVideoEncoder(std::unique_ptr<VideoEncoder> encoder,
87 VideoAnalyzer* analyzer,
88 std::vector<rtc::PlatformFile> files)
89 : encoder_(std::move(encoder)), analyzer_(analyzer) {
Niels Möller1beef1a2018-09-03 14:21:44 +020090 for (rtc::PlatformFile file : files) {
91 writers_.push_back(
Niels Möller5ca29122018-10-02 09:55:01 +020092 IvfFileWriter::Wrap(rtc::File(file), /* byte_limit= */ 100000000));
Niels Möller1beef1a2018-09-03 14:21:44 +020093 }
94 }
95 // Implement VideoEncoder
96 int32_t InitEncode(const VideoCodec* codec_settings,
97 int32_t number_of_cores,
98 size_t max_payload_size) override {
99 return encoder_->InitEncode(codec_settings, number_of_cores,
100 max_payload_size);
101 }
102 int32_t RegisterEncodeCompleteCallback(
103 EncodedImageCallback* callback) override {
104 callback_ = callback;
105 return encoder_->RegisterEncodeCompleteCallback(this);
106 }
107 int32_t Release() override { return encoder_->Release(); }
108 int32_t Encode(const VideoFrame& frame,
109 const CodecSpecificInfo* codec_specific_info,
110 const std::vector<FrameType>* frame_types) {
Niels Möller88be9722018-10-10 10:58:52 +0200111 if (analyzer_) {
112 analyzer_->PreEncodeOnFrame(frame);
113 }
Niels Möller1beef1a2018-09-03 14:21:44 +0200114 return encoder_->Encode(frame, codec_specific_info, frame_types);
115 }
Niels Möller1beef1a2018-09-03 14:21:44 +0200116 int32_t SetRates(uint32_t bitrate, uint32_t framerate) override {
117 return encoder_->SetRates(bitrate, framerate);
118 }
119 int32_t SetRateAllocation(const VideoBitrateAllocation& allocation,
120 uint32_t framerate) override {
121 return encoder_->SetRateAllocation(allocation, framerate);
122 }
Erik Språng189013b2018-11-01 15:03:57 +0100123 EncoderInfo GetEncoderInfo() const override {
124 return encoder_->GetEncoderInfo();
Niels Möller1beef1a2018-09-03 14:21:44 +0200125 }
126
127 private:
128 // Implement EncodedImageCallback
129 Result OnEncodedImage(const EncodedImage& encoded_image,
130 const CodecSpecificInfo* codec_specific_info,
131 const RTPFragmentationHeader* fragmentation) override {
132 if (codec_specific_info) {
133 int simulcast_index;
134 if (codec_specific_info->codecType == kVideoCodecVP9) {
135 simulcast_index = 0;
136 } else {
137 simulcast_index = encoded_image.SpatialIndex().value_or(0);
138 }
139 RTC_DCHECK_GE(simulcast_index, 0);
Niels Möller88be9722018-10-10 10:58:52 +0200140 if (analyzer_) {
141 analyzer_->PostEncodeOnFrame(simulcast_index,
142 encoded_image.Timestamp());
143 }
Niels Möller1beef1a2018-09-03 14:21:44 +0200144 if (static_cast<size_t>(simulcast_index) < writers_.size()) {
145 writers_[simulcast_index]->WriteFrame(encoded_image,
146 codec_specific_info->codecType);
147 }
148 }
149
150 return callback_->OnEncodedImage(encoded_image, codec_specific_info,
151 fragmentation);
152 }
153
154 void OnDroppedFrame(DropReason reason) override {
155 callback_->OnDroppedFrame(reason);
156 }
157
158 std::unique_ptr<VideoEncoder> encoder_;
159 EncodedImageCallback* callback_ = nullptr;
Niels Möller88be9722018-10-10 10:58:52 +0200160 VideoAnalyzer* const analyzer_;
Niels Möller1beef1a2018-09-03 14:21:44 +0200161 std::vector<std::unique_ptr<IvfFileWriter>> writers_;
162};
163
164} // namespace
ivica5d6a06c2015-09-17 05:30:24 -0700165
Niels Möllercbcbc222018-09-28 09:07:24 +0200166std::unique_ptr<VideoDecoder> VideoQualityTest::CreateVideoDecoder(
167 const SdpVideoFormat& format) {
168 std::unique_ptr<VideoDecoder> decoder;
169 if (format.name == "multiplex") {
170 decoder = absl::make_unique<MultiplexDecoderAdapter>(
171 &internal_decoder_factory_, SdpVideoFormat(cricket::kVp9CodecName));
172 } else {
173 decoder = internal_decoder_factory_.CreateVideoDecoder(format);
174 }
Niels Möller5ca29122018-10-02 09:55:01 +0200175 if (!params_.logging.encoded_frame_base_path.empty()) {
176 rtc::StringBuilder str;
177 str << receive_logs_++;
178 std::string path =
179 params_.logging.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
180 decoder = absl::make_unique<FrameDumpingDecoder>(
181 std::move(decoder), rtc::CreatePlatformFile(path));
182 }
Niels Möllercbcbc222018-09-28 09:07:24 +0200183 return decoder;
184}
185
Sebastian Janssone6d7c3e2018-07-11 15:00:41 +0200186std::unique_ptr<VideoEncoder> VideoQualityTest::CreateVideoEncoder(
Niels Möller88be9722018-10-10 10:58:52 +0200187 const SdpVideoFormat& format,
188 VideoAnalyzer* analyzer) {
Niels Möller1beef1a2018-09-03 14:21:44 +0200189 std::unique_ptr<VideoEncoder> encoder;
Niels Möller4db138e2018-04-19 09:04:13 +0200190 if (format.name == "VP8") {
Florent Castellie7862cc2018-12-06 13:38:24 +0100191 encoder = absl::make_unique<EncoderSimulcastProxy>(
Karl Wiberg918f50c2018-07-05 11:40:33 +0200192 &internal_encoder_factory_, format);
Niels Möller4db138e2018-04-19 09:04:13 +0200193 } else if (format.name == "multiplex") {
Niels Möller1beef1a2018-09-03 14:21:44 +0200194 encoder = absl::make_unique<MultiplexEncoderAdapter>(
Niels Möller4db138e2018-04-19 09:04:13 +0200195 &internal_encoder_factory_, SdpVideoFormat(cricket::kVp9CodecName));
Niels Möller1beef1a2018-09-03 14:21:44 +0200196 } else {
197 encoder = internal_encoder_factory_.CreateVideoEncoder(format);
Niels Möller4db138e2018-04-19 09:04:13 +0200198 }
Niels Möller1beef1a2018-09-03 14:21:44 +0200199 if (!params_.logging.encoded_frame_base_path.empty()) {
200 char ss_buf[100];
201 rtc::SimpleStringBuilder sb(ss_buf);
202 sb << send_logs_++;
203 std::string prefix =
204 params_.logging.encoded_frame_base_path + "." + sb.str() + ".send.";
Niels Möller88be9722018-10-10 10:58:52 +0200205 encoder = absl::make_unique<QualityTestVideoEncoder>(
206 std::move(encoder), analyzer,
207 std::vector<rtc::PlatformFile>(
208 {rtc::CreatePlatformFile(prefix + "1.ivf"),
209 rtc::CreatePlatformFile(prefix + "2.ivf"),
210 rtc::CreatePlatformFile(prefix + "3.ivf")}));
211 } else if (analyzer) {
212 encoder = absl::make_unique<QualityTestVideoEncoder>(
213 std::move(encoder), analyzer, std::vector<rtc::PlatformFile>());
Niels Möller1beef1a2018-09-03 14:21:44 +0200214 }
Niels Möller88be9722018-10-10 10:58:52 +0200215
Niels Möller1beef1a2018-09-03 14:21:44 +0200216 return encoder;
Niels Möller4db138e2018-04-19 09:04:13 +0200217}
218
Patrik Höglundb6b29e02018-06-21 16:58:01 +0200219VideoQualityTest::VideoQualityTest(
Artem Titove269cb42018-08-29 09:59:23 +0200220 std::unique_ptr<InjectionComponents> injection_components)
Sebastian Janssone6d7c3e2018-07-11 15:00:41 +0200221 : clock_(Clock::GetRealTimeClock()),
Niels Möllercbcbc222018-09-28 09:07:24 +0200222 video_decoder_factory_([this](const SdpVideoFormat& format) {
223 return this->CreateVideoDecoder(format);
224 }),
Sebastian Janssone6d7c3e2018-07-11 15:00:41 +0200225 video_encoder_factory_([this](const SdpVideoFormat& format) {
Niels Möller88be9722018-10-10 10:58:52 +0200226 return this->CreateVideoEncoder(format, nullptr);
Sebastian Janssone6d7c3e2018-07-11 15:00:41 +0200227 }),
Niels Möller88be9722018-10-10 10:58:52 +0200228 video_encoder_factory_with_analyzer_(
229 [this](const SdpVideoFormat& format) {
230 return this->CreateVideoEncoder(format, analyzer_.get());
231 }),
Jiawei Ouc2ebe212018-11-08 10:02:56 -0800232 video_bitrate_allocator_factory_(
233 CreateBuiltinVideoBitrateAllocatorFactory()),
Sebastian Janssone6d7c3e2018-07-11 15:00:41 +0200234 receive_logs_(0),
Artem Titove269cb42018-08-29 09:59:23 +0200235 send_logs_(0),
Erik Språng96965ae2018-10-23 15:42:37 +0200236 injection_components_(std::move(injection_components)),
237 num_video_streams_(0) {
Artem Titove269cb42018-08-29 09:59:23 +0200238 if (injection_components_ == nullptr) {
239 injection_components_ = absl::make_unique<InjectionComponents>();
240 }
241
minyue20c84cc2017-04-10 16:57:57 -0700242 payload_type_map_ = test::CallTest::payload_type_map_;
243 RTC_DCHECK(payload_type_map_.find(kPayloadTypeH264) ==
244 payload_type_map_.end());
245 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP8) ==
246 payload_type_map_.end());
247 RTC_DCHECK(payload_type_map_.find(kPayloadTypeVP9) ==
248 payload_type_map_.end());
249 payload_type_map_[kPayloadTypeH264] = webrtc::MediaType::VIDEO;
250 payload_type_map_[kPayloadTypeVP8] = webrtc::MediaType::VIDEO;
251 payload_type_map_[kPayloadTypeVP9] = webrtc::MediaType::VIDEO;
ivica5d6a06c2015-09-17 05:30:24 -0700252
Artem Titove269cb42018-08-29 09:59:23 +0200253 fec_controller_factory_ =
254 std::move(injection_components_->fec_controller_factory);
Ying Wang3b790f32018-01-19 17:58:57 +0100255}
256
minyue626bc952016-10-31 05:47:02 -0700257VideoQualityTest::Params::Params()
philipel569397f2018-09-26 12:25:31 +0200258 : call({false, false, BitrateConstraints(), 0}),
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100259 video{{false, 640, 480, 30, 50, 800, 800, false, "VP8", 1, -1, 0, false,
Niels Möller6aa415e2018-06-07 11:14:13 +0200260 false, false, ""},
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100261 {false, 640, 480, 30, 50, 800, 800, false, "VP8", 1, -1, 0, false,
Niels Möller6aa415e2018-06-07 11:14:13 +0200262 false, false, ""}},
henrika255750b2018-08-27 16:13:37 +0200263 audio({false, false, false, false}),
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100264 screenshare{{false, false, 10, 0}, {false, false, 10, 0}},
minyue626bc952016-10-31 05:47:02 -0700265 analyzer({"", 0.0, 0.0, 0, "", ""}),
Artem Titovf18b3522018-08-28 16:54:24 +0200266 config(absl::nullopt),
Sergey Silkin57027362018-05-15 09:12:05 +0200267 ss{{std::vector<VideoStream>(), 0, 0, -1, InterLayerPredMode::kOn,
268 std::vector<SpatialLayer>()},
269 {std::vector<VideoStream>(), 0, 0, -1, InterLayerPredMode::kOn,
270 std::vector<SpatialLayer>()}},
Mirko Bonadei45a4c412018-07-31 15:07:28 +0200271 logging({"", "", ""}) {}
minyue626bc952016-10-31 05:47:02 -0700272
273VideoQualityTest::Params::~Params() = default;
274
Artem Titove269cb42018-08-29 09:59:23 +0200275VideoQualityTest::InjectionComponents::InjectionComponents() = default;
276
277VideoQualityTest::InjectionComponents::~InjectionComponents() = default;
278
ivica5d6a06c2015-09-17 05:30:24 -0700279void VideoQualityTest::TestBody() {}
280
sprangce4aef12015-11-02 07:23:20 -0800281std::string VideoQualityTest::GenerateGraphTitle() const {
Jonas Olsson366a50c2018-09-06 13:41:30 +0200282 rtc::StringBuilder ss;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100283 ss << params_.video[0].codec;
284 ss << " (" << params_.video[0].target_bitrate_bps / 1000 << "kbps";
285 ss << ", " << params_.video[0].fps << " FPS";
286 if (params_.screenshare[0].scroll_duration)
287 ss << ", " << params_.screenshare[0].scroll_duration << "s scroll";
288 if (params_.ss[0].streams.size() > 1)
289 ss << ", Stream #" << params_.ss[0].selected_stream;
290 if (params_.ss[0].num_spatial_layers > 1)
291 ss << ", Layer #" << params_.ss[0].selected_sl;
sprangce4aef12015-11-02 07:23:20 -0800292 ss << ")";
Jonas Olsson84df1c72018-09-14 16:59:32 +0200293 return ss.Release();
sprangce4aef12015-11-02 07:23:20 -0800294}
295
Artem Titove269cb42018-08-29 09:59:23 +0200296void VideoQualityTest::CheckParamsAndInjectionComponents() {
297 if (injection_components_ == nullptr) {
298 injection_components_ = absl::make_unique<InjectionComponents>();
299 }
300 if (!params_.config && injection_components_->sender_network == nullptr &&
301 injection_components_->receiver_network == nullptr) {
Artem Titov62ae1782018-10-24 14:14:49 +0200302 params_.config = BuiltInNetworkBehaviorConfig();
Artem Titovf18b3522018-08-28 16:54:24 +0200303 }
Artem Titove269cb42018-08-29 09:59:23 +0200304 RTC_CHECK(
305 (params_.config && injection_components_->sender_network == nullptr &&
306 injection_components_->receiver_network == nullptr) ||
307 (!params_.config && injection_components_->sender_network != nullptr &&
308 injection_components_->receiver_network != nullptr));
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100309 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
310 // Iterate over primary and secondary video streams.
311 if (!params_.video[video_idx].enabled)
312 return;
313 // Add a default stream in none specified.
314 if (params_.ss[video_idx].streams.empty())
315 params_.ss[video_idx].streams.push_back(
316 VideoQualityTest::DefaultVideoStream(params_, video_idx));
317 if (params_.ss[video_idx].num_spatial_layers == 0)
318 params_.ss[video_idx].num_spatial_layers = 1;
sprangce4aef12015-11-02 07:23:20 -0800319
Artem Titove269cb42018-08-29 09:59:23 +0200320 if (params_.config) {
321 if (params_.config->loss_percent != 0 ||
322 params_.config->queue_length_packets != 0) {
323 // Since LayerFilteringTransport changes the sequence numbers, we can't
324 // use that feature with pack loss, since the NACK request would end up
325 // retransmitting the wrong packets.
326 RTC_CHECK(params_.ss[video_idx].selected_sl == -1 ||
327 params_.ss[video_idx].selected_sl ==
328 params_.ss[video_idx].num_spatial_layers - 1);
329 RTC_CHECK(params_.video[video_idx].selected_tl == -1 ||
330 params_.video[video_idx].selected_tl ==
331 params_.video[video_idx].num_temporal_layers - 1);
332 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100333 }
sprangce4aef12015-11-02 07:23:20 -0800334
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100335 // TODO(ivica): Should max_bitrate_bps == -1 represent inf max bitrate, as
336 // it does in some parts of the code?
337 RTC_CHECK_GE(params_.video[video_idx].max_bitrate_bps,
338 params_.video[video_idx].target_bitrate_bps);
339 RTC_CHECK_GE(params_.video[video_idx].target_bitrate_bps,
340 params_.video[video_idx].min_bitrate_bps);
341 RTC_CHECK_LT(params_.video[video_idx].selected_tl,
342 params_.video[video_idx].num_temporal_layers);
343 RTC_CHECK_LE(params_.ss[video_idx].selected_stream,
344 params_.ss[video_idx].streams.size());
345 for (const VideoStream& stream : params_.ss[video_idx].streams) {
346 RTC_CHECK_GE(stream.min_bitrate_bps, 0);
347 RTC_CHECK_GE(stream.target_bitrate_bps, stream.min_bitrate_bps);
348 RTC_CHECK_GE(stream.max_bitrate_bps, stream.target_bitrate_bps);
349 }
350 // TODO(ivica): Should we check if the sum of all streams/layers is equal to
351 // the total bitrate? We anyway have to update them in the case bitrate
352 // estimator changes the total bitrates.
353 RTC_CHECK_GE(params_.ss[video_idx].num_spatial_layers, 1);
354 RTC_CHECK_LE(params_.ss[video_idx].selected_sl,
355 params_.ss[video_idx].num_spatial_layers);
356 RTC_CHECK(
357 params_.ss[video_idx].spatial_layers.empty() ||
358 params_.ss[video_idx].spatial_layers.size() ==
359 static_cast<size_t>(params_.ss[video_idx].num_spatial_layers));
360 if (params_.video[video_idx].codec == "VP8") {
361 RTC_CHECK_EQ(params_.ss[video_idx].num_spatial_layers, 1);
362 } else if (params_.video[video_idx].codec == "VP9") {
363 RTC_CHECK_EQ(params_.ss[video_idx].streams.size(), 1);
364 }
365 RTC_CHECK_GE(params_.call.num_thumbnails, 0);
366 if (params_.call.num_thumbnails > 0) {
367 RTC_CHECK_EQ(params_.ss[video_idx].num_spatial_layers, 1);
368 RTC_CHECK_EQ(params_.ss[video_idx].streams.size(), 3);
369 RTC_CHECK_EQ(params_.video[video_idx].num_temporal_layers, 3);
370 RTC_CHECK_EQ(params_.video[video_idx].codec, "VP8");
371 }
372 // Dual streams with FEC not supported in tests yet.
373 RTC_CHECK(!params_.video[video_idx].flexfec || num_video_streams_ == 1);
374 RTC_CHECK(!params_.video[video_idx].ulpfec || num_video_streams_ == 1);
ilnika014cc52017-03-07 04:21:04 -0800375 }
sprangce4aef12015-11-02 07:23:20 -0800376}
377
378// Static.
379std::vector<int> VideoQualityTest::ParseCSV(const std::string& str) {
380 // Parse comma separated nonnegative integers, where some elements may be
381 // empty. The empty values are replaced with -1.
382 // E.g. "10,-20,,30,40" --> {10, 20, -1, 30,40}
383 // E.g. ",,10,,20," --> {-1, -1, 10, -1, 20, -1}
384 std::vector<int> result;
385 if (str.empty())
386 return result;
387
388 const char* p = str.c_str();
389 int value = -1;
390 int pos;
391 while (*p) {
392 if (*p == ',') {
393 result.push_back(value);
394 value = -1;
395 ++p;
396 continue;
397 }
398 RTC_CHECK_EQ(sscanf(p, "%d%n", &value, &pos), 1)
399 << "Unexpected non-number value.";
400 p += pos;
401 }
402 result.push_back(value);
403 return result;
404}
405
406// Static.
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100407VideoStream VideoQualityTest::DefaultVideoStream(const Params& params,
408 size_t video_idx) {
sprangce4aef12015-11-02 07:23:20 -0800409 VideoStream stream;
Danil Chapovalov350531e2018-06-08 11:04:04 +0000410 stream.width = params.video[video_idx].width;
411 stream.height = params.video[video_idx].height;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100412 stream.max_framerate = params.video[video_idx].fps;
413 stream.min_bitrate_bps = params.video[video_idx].min_bitrate_bps;
414 stream.target_bitrate_bps = params.video[video_idx].target_bitrate_bps;
415 stream.max_bitrate_bps = params.video[video_idx].max_bitrate_bps;
sprang1168fd42017-06-21 09:00:17 -0700416 stream.max_qp = kDefaultMaxQp;
Sergey Silkina796a7e2018-03-01 15:11:29 +0100417 stream.num_temporal_layers = params.video[video_idx].num_temporal_layers;
Seth Hampson46e31ba2018-01-18 10:39:54 -0800418 stream.active = true;
ilnika014cc52017-03-07 04:21:04 -0800419 return stream;
420}
421
422// Static.
423VideoStream VideoQualityTest::DefaultThumbnailStream() {
424 VideoStream stream;
425 stream.width = 320;
426 stream.height = 180;
427 stream.max_framerate = 7;
428 stream.min_bitrate_bps = 7500;
429 stream.target_bitrate_bps = 37500;
430 stream.max_bitrate_bps = 50000;
sprang1168fd42017-06-21 09:00:17 -0700431 stream.max_qp = kDefaultMaxQp;
sprangce4aef12015-11-02 07:23:20 -0800432 return stream;
433}
434
435// Static.
436void VideoQualityTest::FillScalabilitySettings(
437 Params* params,
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100438 size_t video_idx,
sprangce4aef12015-11-02 07:23:20 -0800439 const std::vector<std::string>& stream_descriptors,
sprang1168fd42017-06-21 09:00:17 -0700440 int num_streams,
sprangce4aef12015-11-02 07:23:20 -0800441 size_t selected_stream,
442 int num_spatial_layers,
443 int selected_sl,
Sergey Silkin57027362018-05-15 09:12:05 +0200444 InterLayerPredMode inter_layer_pred,
sprangce4aef12015-11-02 07:23:20 -0800445 const std::vector<std::string>& sl_descriptors) {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100446 if (params->ss[video_idx].streams.empty() &&
447 params->ss[video_idx].infer_streams) {
sprang1168fd42017-06-21 09:00:17 -0700448 webrtc::VideoEncoderConfig encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +0200449 encoder_config.codec_type =
450 PayloadStringToCodecType(params->video[video_idx].codec);
sprang1168fd42017-06-21 09:00:17 -0700451 encoder_config.content_type =
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100452 params->screenshare[video_idx].enabled
sprang1168fd42017-06-21 09:00:17 -0700453 ? webrtc::VideoEncoderConfig::ContentType::kScreen
454 : webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100455 encoder_config.max_bitrate_bps = params->video[video_idx].max_bitrate_bps;
456 encoder_config.min_transmit_bitrate_bps =
457 params->video[video_idx].min_transmit_bps;
sprang1168fd42017-06-21 09:00:17 -0700458 encoder_config.number_of_streams = num_streams;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100459 encoder_config.spatial_layers = params->ss[video_idx].spatial_layers;
Seth Hampson8234ead2018-02-02 15:16:24 -0800460 encoder_config.simulcast_layers = std::vector<VideoStream>(num_streams);
sprang1168fd42017-06-21 09:00:17 -0700461 encoder_config.video_stream_factory =
462 new rtc::RefCountedObject<cricket::EncoderStreamFactory>(
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100463 params->video[video_idx].codec, kDefaultMaxQp,
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100464 params->screenshare[video_idx].enabled, true);
465 params->ss[video_idx].streams =
sprang1168fd42017-06-21 09:00:17 -0700466 encoder_config.video_stream_factory->CreateEncoderStreams(
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100467 static_cast<int>(params->video[video_idx].width),
468 static_cast<int>(params->video[video_idx].height), encoder_config);
sprang1168fd42017-06-21 09:00:17 -0700469 } else {
470 // Read VideoStream and SpatialLayer elements from a list of comma separated
471 // lists. To use a default value for an element, use -1 or leave empty.
Artem Titove269cb42018-08-29 09:59:23 +0200472 // Validity checks performed in CheckParamsAndInjectionComponents.
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100473 RTC_CHECK(params->ss[video_idx].streams.empty());
sprang1168fd42017-06-21 09:00:17 -0700474 for (auto descriptor : stream_descriptors) {
475 if (descriptor.empty())
476 continue;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100477 VideoStream stream =
478 VideoQualityTest::DefaultVideoStream(*params, video_idx);
sprang1168fd42017-06-21 09:00:17 -0700479 std::vector<int> v = VideoQualityTest::ParseCSV(descriptor);
480 if (v[0] != -1)
481 stream.width = static_cast<size_t>(v[0]);
482 if (v[1] != -1)
483 stream.height = static_cast<size_t>(v[1]);
484 if (v[2] != -1)
485 stream.max_framerate = v[2];
486 if (v[3] != -1)
487 stream.min_bitrate_bps = v[3];
488 if (v[4] != -1)
489 stream.target_bitrate_bps = v[4];
490 if (v[5] != -1)
491 stream.max_bitrate_bps = v[5];
492 if (v.size() > 6 && v[6] != -1)
493 stream.max_qp = v[6];
Sergey Silkina796a7e2018-03-01 15:11:29 +0100494 if (v.size() > 7 && v[7] != -1) {
495 stream.num_temporal_layers = v[7];
sprang1168fd42017-06-21 09:00:17 -0700496 } else {
497 // Automatic TL thresholds for more than two layers not supported.
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100498 RTC_CHECK_LE(params->video[video_idx].num_temporal_layers, 2);
sprang1168fd42017-06-21 09:00:17 -0700499 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100500 params->ss[video_idx].streams.push_back(stream);
sprangce4aef12015-11-02 07:23:20 -0800501 }
sprangce4aef12015-11-02 07:23:20 -0800502 }
sprangce4aef12015-11-02 07:23:20 -0800503
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100504 params->ss[video_idx].num_spatial_layers = std::max(1, num_spatial_layers);
505 params->ss[video_idx].selected_stream = selected_stream;
sprang1168fd42017-06-21 09:00:17 -0700506
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100507 params->ss[video_idx].selected_sl = selected_sl;
Sergey Silkin57027362018-05-15 09:12:05 +0200508 params->ss[video_idx].inter_layer_pred = inter_layer_pred;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100509 RTC_CHECK(params->ss[video_idx].spatial_layers.empty());
sprangce4aef12015-11-02 07:23:20 -0800510 for (auto descriptor : sl_descriptors) {
511 if (descriptor.empty())
512 continue;
513 std::vector<int> v = VideoQualityTest::ParseCSV(descriptor);
Sergey Silkin13e74342018-03-02 12:28:00 +0100514 RTC_CHECK_EQ(v.size(), 7);
sprangce4aef12015-11-02 07:23:20 -0800515
Sergey Silkin13e74342018-03-02 12:28:00 +0100516 SpatialLayer layer = {0};
517 layer.width = v[0];
518 layer.height = v[1];
519 layer.numberOfTemporalLayers = v[2];
520 layer.maxBitrate = v[3];
521 layer.minBitrate = v[4];
522 layer.targetBitrate = v[5];
523 layer.qpMax = v[6];
524 layer.active = true;
525
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100526 params->ss[video_idx].spatial_layers.push_back(layer);
sprangce4aef12015-11-02 07:23:20 -0800527 }
528}
529
minyuea27172d2016-11-01 05:59:29 -0700530void VideoQualityTest::SetupVideo(Transport* send_transport,
531 Transport* recv_transport) {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100532 size_t total_streams_used = 0;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100533 video_receive_configs_.clear();
534 video_send_configs_.clear();
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100535 video_encoder_configs_.clear();
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100536 bool decode_all_receive_streams = true;
537 size_t num_video_substreams = params_.ss[0].streams.size();
538 RTC_CHECK(num_video_streams_ > 0);
539 video_encoder_configs_.resize(num_video_streams_);
540 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
541 video_send_configs_.push_back(VideoSendStream::Config(send_transport));
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100542 video_encoder_configs_.push_back(VideoEncoderConfig());
543 num_video_substreams = params_.ss[video_idx].streams.size();
544 RTC_CHECK_GT(num_video_substreams, 0);
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200545 for (size_t i = 0; i < num_video_substreams; ++i)
546 video_send_configs_[video_idx].rtp.ssrcs.push_back(
547 kVideoSendSsrcs[total_streams_used + i]);
Qingsi Wang2d82ade2018-07-11 06:04:44 +0000548
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100549 int payload_type;
550 if (params_.video[video_idx].codec == "H264") {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100551 payload_type = kPayloadTypeH264;
552 } else if (params_.video[video_idx].codec == "VP8") {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100553 payload_type = kPayloadTypeVP8;
554 } else if (params_.video[video_idx].codec == "VP9") {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100555 payload_type = kPayloadTypeVP9;
Emircan Uysaler03e6ec92018-03-09 15:03:26 -0800556 } else if (params_.video[video_idx].codec == "multiplex") {
Emircan Uysaler03e6ec92018-03-09 15:03:26 -0800557 payload_type = kPayloadTypeVP9;
ilnikcb8c1462017-03-09 09:23:30 -0800558 } else {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100559 RTC_NOTREACHED() << "Codec not supported!";
560 return;
ilnikcb8c1462017-03-09 09:23:30 -0800561 }
Niels Möller4db138e2018-04-19 09:04:13 +0200562 video_send_configs_[video_idx].encoder_settings.encoder_factory =
Niels Möller88be9722018-10-10 10:58:52 +0200563 (video_idx == 0) ? &video_encoder_factory_with_analyzer_
564 : &video_encoder_factory_;
Jiawei Ouc2ebe212018-11-08 10:02:56 -0800565 video_send_configs_[video_idx].encoder_settings.bitrate_allocator_factory =
566 video_bitrate_allocator_factory_.get();
Niels Möller4db138e2018-04-19 09:04:13 +0200567
Niels Möller259a4972018-04-05 15:36:51 +0200568 video_send_configs_[video_idx].rtp.payload_name =
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100569 params_.video[video_idx].codec;
Niels Möller259a4972018-04-05 15:36:51 +0200570 video_send_configs_[video_idx].rtp.payload_type = payload_type;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100571 video_send_configs_[video_idx].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
572 video_send_configs_[video_idx].rtp.rtx.payload_type = kSendRtxPayloadType;
573 for (size_t i = 0; i < num_video_substreams; ++i) {
574 video_send_configs_[video_idx].rtp.rtx.ssrcs.push_back(
575 kSendRtxSsrcs[i + total_streams_used]);
ilnik9fd9f6c2017-03-02 08:10:10 -0800576 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100577 video_send_configs_[video_idx].rtp.extensions.clear();
578 if (params_.call.send_side_bwe) {
philipel569397f2018-09-26 12:25:31 +0200579 video_send_configs_[video_idx].rtp.extensions.emplace_back(
580 RtpExtension::kTransportSequenceNumberUri,
581 test::kTransportSequenceNumberExtensionId);
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100582 } else {
philipel569397f2018-09-26 12:25:31 +0200583 video_send_configs_[video_idx].rtp.extensions.emplace_back(
584 RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId);
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100585 }
philipel569397f2018-09-26 12:25:31 +0200586
587 if (params_.call.generic_descriptor) {
588 // The generic descriptor is currently behind a field trial, so it needs
589 // to be set for this flag to have any effect.
590 // TODO(philipel): Remove this check when the experiment is removed.
591 RTC_CHECK(field_trial::IsEnabled("WebRTC-GenericDescriptor"));
592
593 video_send_configs_[video_idx].rtp.extensions.emplace_back(
594 RtpExtension::kGenericFrameDescriptorUri,
595 test::kGenericDescriptorExtensionId);
596 }
597
598 video_send_configs_[video_idx].rtp.extensions.emplace_back(
599 RtpExtension::kVideoContentTypeUri, test::kVideoContentTypeExtensionId);
600 video_send_configs_[video_idx].rtp.extensions.emplace_back(
601 RtpExtension::kVideoTimingUri, test::kVideoTimingExtensionId);
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100602
Niels Möller4db138e2018-04-19 09:04:13 +0200603 video_encoder_configs_[video_idx].video_format.name =
604 params_.video[video_idx].codec;
605
Emircan Uysaler0823eec2018-07-13 17:10:00 -0700606 video_encoder_configs_[video_idx].video_format.parameters =
607 params_.video[video_idx].sdp_params;
608
Niels Möller259a4972018-04-05 15:36:51 +0200609 video_encoder_configs_[video_idx].codec_type =
610 PayloadStringToCodecType(params_.video[video_idx].codec);
611
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100612 video_encoder_configs_[video_idx].min_transmit_bitrate_bps =
613 params_.video[video_idx].min_transmit_bps;
614
615 video_send_configs_[video_idx].suspend_below_min_bitrate =
616 params_.video[video_idx].suspend_below_min_bitrate;
617
618 video_encoder_configs_[video_idx].number_of_streams =
619 params_.ss[video_idx].streams.size();
620 video_encoder_configs_[video_idx].max_bitrate_bps = 0;
621 for (size_t i = 0; i < params_.ss[video_idx].streams.size(); ++i) {
622 video_encoder_configs_[video_idx].max_bitrate_bps +=
623 params_.ss[video_idx].streams[i].max_bitrate_bps;
624 }
625 if (params_.ss[video_idx].infer_streams) {
Seth Hampson8234ead2018-02-02 15:16:24 -0800626 video_encoder_configs_[video_idx].simulcast_layers =
627 std::vector<VideoStream>(params_.ss[video_idx].streams.size());
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100628 video_encoder_configs_[video_idx].video_stream_factory =
629 new rtc::RefCountedObject<cricket::EncoderStreamFactory>(
630 params_.video[video_idx].codec,
631 params_.ss[video_idx].streams[0].max_qp,
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100632 params_.screenshare[video_idx].enabled, true);
633 } else {
634 video_encoder_configs_[video_idx].video_stream_factory =
635 new rtc::RefCountedObject<VideoStreamFactory>(
636 params_.ss[video_idx].streams);
637 }
638
639 video_encoder_configs_[video_idx].spatial_layers =
640 params_.ss[video_idx].spatial_layers;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100641 decode_all_receive_streams = params_.ss[video_idx].selected_stream ==
642 params_.ss[video_idx].streams.size();
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200643 absl::optional<int> decode_sub_stream;
644 if (!decode_all_receive_streams)
645 decode_sub_stream = params_.ss[video_idx].selected_stream;
646 CreateMatchingVideoReceiveConfigs(
647 video_send_configs_[video_idx], recv_transport,
Niels Möllercbcbc222018-09-28 09:07:24 +0200648 params_.call.send_side_bwe, &video_decoder_factory_, decode_sub_stream,
649 true, kNackRtpHistoryMs);
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100650
651 if (params_.screenshare[video_idx].enabled) {
652 // Fill out codec settings.
653 video_encoder_configs_[video_idx].content_type =
654 VideoEncoderConfig::ContentType::kScreen;
Taylor Brandstetter49fcc102018-05-16 14:20:41 -0700655 degradation_preference_ = DegradationPreference::MAINTAIN_RESOLUTION;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100656 if (params_.video[video_idx].codec == "VP8") {
657 VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
658 vp8_settings.denoisingOn = false;
659 vp8_settings.frameDroppingOn = false;
660 vp8_settings.numberOfTemporalLayers = static_cast<unsigned char>(
661 params_.video[video_idx].num_temporal_layers);
662 video_encoder_configs_[video_idx].encoder_specific_settings =
663 new rtc::RefCountedObject<
664 VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
665 } else if (params_.video[video_idx].codec == "VP9") {
666 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
667 vp9_settings.denoisingOn = false;
668 vp9_settings.frameDroppingOn = false;
669 vp9_settings.numberOfTemporalLayers = static_cast<unsigned char>(
670 params_.video[video_idx].num_temporal_layers);
671 vp9_settings.numberOfSpatialLayers = static_cast<unsigned char>(
672 params_.ss[video_idx].num_spatial_layers);
Sergey Silkin57027362018-05-15 09:12:05 +0200673 vp9_settings.interLayerPred = params_.ss[video_idx].inter_layer_pred;
Ilya Nikolaevskiy5546aef2018-12-04 15:54:52 +0100674 // High FPS vp9 screenshare requires flexible mode.
675 if (params_.video[video_idx].fps > 5) {
676 vp9_settings.flexibleMode = true;
677 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100678 video_encoder_configs_[video_idx].encoder_specific_settings =
679 new rtc::RefCountedObject<
680 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
681 }
682 } else if (params_.ss[video_idx].num_spatial_layers > 1) {
683 // If SVC mode without screenshare, still need to set codec specifics.
684 RTC_CHECK(params_.video[video_idx].codec == "VP9");
685 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
686 vp9_settings.numberOfTemporalLayers = static_cast<unsigned char>(
687 params_.video[video_idx].num_temporal_layers);
688 vp9_settings.numberOfSpatialLayers =
689 static_cast<unsigned char>(params_.ss[video_idx].num_spatial_layers);
Sergey Silkin57027362018-05-15 09:12:05 +0200690 vp9_settings.interLayerPred = params_.ss[video_idx].inter_layer_pred;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100691 video_encoder_configs_[video_idx].encoder_specific_settings =
692 new rtc::RefCountedObject<
693 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
Niels Möller6aa415e2018-06-07 11:14:13 +0200694 } else if (params_.video[video_idx].automatic_scaling) {
695 if (params_.video[video_idx].codec == "VP8") {
696 VideoCodecVP8 vp8_settings = VideoEncoder::GetDefaultVp8Settings();
697 vp8_settings.automaticResizeOn = true;
698 video_encoder_configs_[video_idx].encoder_specific_settings =
699 new rtc::RefCountedObject<
700 VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
701 } else if (params_.video[video_idx].codec == "VP9") {
702 VideoCodecVP9 vp9_settings = VideoEncoder::GetDefaultVp9Settings();
703 vp9_settings.automaticResizeOn = true;
704 video_encoder_configs_[video_idx].encoder_specific_settings =
705 new rtc::RefCountedObject<
706 VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings);
707 } else {
708 RTC_NOTREACHED() << "Automatic scaling not supported for codec "
Yves Gerey665174f2018-06-19 15:03:05 +0200709 << params_.video[video_idx].codec << ", stream "
710 << video_idx;
Niels Möller6aa415e2018-06-07 11:14:13 +0200711 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100712 }
713 total_streams_used += num_video_substreams;
sprangce4aef12015-11-02 07:23:20 -0800714 }
brandtr1293aca2016-11-16 22:47:29 -0800715
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100716 // FEC supported only for single video stream mode yet.
717 if (params_.video[0].flexfec) {
sprang1168fd42017-06-21 09:00:17 -0700718 if (decode_all_receive_streams) {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200719 SetSendFecConfig(GetVideoSendConfig()->rtp.ssrcs);
sprang1168fd42017-06-21 09:00:17 -0700720 } else {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200721 SetSendFecConfig({kVideoSendSsrcs[params_.ss[0].selected_stream]});
sprang1168fd42017-06-21 09:00:17 -0700722 }
brandtr1293aca2016-11-16 22:47:29 -0800723
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200724 CreateMatchingFecConfig(recv_transport, *GetVideoSendConfig());
725 GetFlexFecConfig()->transport_cc = params_.call.send_side_bwe;
brandtrb29e6522016-12-21 06:37:18 -0800726 if (params_.call.send_side_bwe) {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200727 GetFlexFecConfig()->rtp_header_extensions.push_back(
brandtrb29e6522016-12-21 06:37:18 -0800728 RtpExtension(RtpExtension::kTransportSequenceNumberUri,
729 test::kTransportSequenceNumberExtensionId));
730 } else {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200731 GetFlexFecConfig()->rtp_header_extensions.push_back(RtpExtension(
brandtrb29e6522016-12-21 06:37:18 -0800732 RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
733 }
brandtr1293aca2016-11-16 22:47:29 -0800734 }
735
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100736 if (params_.video[0].ulpfec) {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200737 SetSendUlpFecConfig(GetVideoSendConfig());
sprang1168fd42017-06-21 09:00:17 -0700738 if (decode_all_receive_streams) {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200739 for (auto& receive_config : video_receive_configs_) {
740 SetReceiveUlpFecConfig(&receive_config);
sprang1168fd42017-06-21 09:00:17 -0700741 }
742 } else {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200743 SetReceiveUlpFecConfig(
744 &video_receive_configs_[params_.ss[0].selected_stream]);
sprang1168fd42017-06-21 09:00:17 -0700745 }
brandtr1293aca2016-11-16 22:47:29 -0800746 }
ivica5d6a06c2015-09-17 05:30:24 -0700747}
748
ilnika014cc52017-03-07 04:21:04 -0800749void VideoQualityTest::SetupThumbnails(Transport* send_transport,
750 Transport* recv_transport) {
ilnik98436952017-07-13 00:47:03 -0700751 for (int i = 0; i < params_.call.num_thumbnails; ++i) {
ilnika014cc52017-03-07 04:21:04 -0800752 // Thumbnails will be send in the other way: from receiver_call to
753 // sender_call.
754 VideoSendStream::Config thumbnail_send_config(recv_transport);
755 thumbnail_send_config.rtp.ssrcs.push_back(kThumbnailSendSsrcStart + i);
Niels Möller4db138e2018-04-19 09:04:13 +0200756 // TODO(nisse): Could use a simpler VP8-only encoder factory.
757 thumbnail_send_config.encoder_settings.encoder_factory =
758 &video_encoder_factory_;
Jiawei Ouc2ebe212018-11-08 10:02:56 -0800759 thumbnail_send_config.encoder_settings.bitrate_allocator_factory =
760 video_bitrate_allocator_factory_.get();
Niels Möller259a4972018-04-05 15:36:51 +0200761 thumbnail_send_config.rtp.payload_name = params_.video[0].codec;
762 thumbnail_send_config.rtp.payload_type = kPayloadTypeVP8;
ilnika014cc52017-03-07 04:21:04 -0800763 thumbnail_send_config.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
764 thumbnail_send_config.rtp.rtx.payload_type = kSendRtxPayloadType;
765 thumbnail_send_config.rtp.rtx.ssrcs.push_back(kThumbnailRtxSsrcStart + i);
766 thumbnail_send_config.rtp.extensions.clear();
767 if (params_.call.send_side_bwe) {
768 thumbnail_send_config.rtp.extensions.push_back(
769 RtpExtension(RtpExtension::kTransportSequenceNumberUri,
770 test::kTransportSequenceNumberExtensionId));
771 } else {
772 thumbnail_send_config.rtp.extensions.push_back(RtpExtension(
773 RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
774 }
775
776 VideoEncoderConfig thumbnail_encoder_config;
Niels Möller259a4972018-04-05 15:36:51 +0200777 thumbnail_encoder_config.codec_type = kVideoCodecVP8;
Niels Möller4db138e2018-04-19 09:04:13 +0200778 thumbnail_encoder_config.video_format.name = "VP8";
ilnika014cc52017-03-07 04:21:04 -0800779 thumbnail_encoder_config.min_transmit_bitrate_bps = 7500;
780 thumbnail_send_config.suspend_below_min_bitrate =
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100781 params_.video[0].suspend_below_min_bitrate;
ilnika014cc52017-03-07 04:21:04 -0800782 thumbnail_encoder_config.number_of_streams = 1;
783 thumbnail_encoder_config.max_bitrate_bps = 50000;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100784 if (params_.ss[0].infer_streams) {
ilnik6b826ef2017-06-16 06:53:48 -0700785 thumbnail_encoder_config.video_stream_factory =
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100786 new rtc::RefCountedObject<VideoStreamFactory>(params_.ss[0].streams);
ilnik6b826ef2017-06-16 06:53:48 -0700787 } else {
Seth Hampson8234ead2018-02-02 15:16:24 -0800788 thumbnail_encoder_config.simulcast_layers = std::vector<VideoStream>(1);
ilnik6b826ef2017-06-16 06:53:48 -0700789 thumbnail_encoder_config.video_stream_factory =
790 new rtc::RefCountedObject<cricket::EncoderStreamFactory>(
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100791 params_.video[0].codec, params_.ss[0].streams[0].max_qp,
Åsa Persson8c1bf952018-09-13 10:42:19 +0200792 params_.screenshare[0].enabled, true);
ilnik6b826ef2017-06-16 06:53:48 -0700793 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100794 thumbnail_encoder_config.spatial_layers = params_.ss[0].spatial_layers;
ilnika014cc52017-03-07 04:21:04 -0800795
ilnika014cc52017-03-07 04:21:04 -0800796 thumbnail_encoder_configs_.push_back(thumbnail_encoder_config.Copy());
797 thumbnail_send_configs_.push_back(thumbnail_send_config.Copy());
ilnika014cc52017-03-07 04:21:04 -0800798
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200799 AddMatchingVideoReceiveConfigs(
800 &thumbnail_receive_configs_, thumbnail_send_config, send_transport,
Niels Möllercbcbc222018-09-28 09:07:24 +0200801 params_.call.send_side_bwe, &video_decoder_factory_, absl::nullopt,
802 false, kNackRtpHistoryMs);
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200803 }
804 for (size_t i = 0; i < thumbnail_send_configs_.size(); ++i) {
ilnika014cc52017-03-07 04:21:04 -0800805 thumbnail_send_streams_.push_back(receiver_call_->CreateVideoSendStream(
806 thumbnail_send_configs_[i].Copy(),
807 thumbnail_encoder_configs_[i].Copy()));
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200808 }
809 for (size_t i = 0; i < thumbnail_receive_configs_.size(); ++i) {
ilnika014cc52017-03-07 04:21:04 -0800810 thumbnail_receive_streams_.push_back(sender_call_->CreateVideoReceiveStream(
811 thumbnail_receive_configs_[i].Copy()));
812 }
813}
814
815void VideoQualityTest::DestroyThumbnailStreams() {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100816 for (VideoSendStream* thumbnail_send_stream : thumbnail_send_streams_) {
ilnika014cc52017-03-07 04:21:04 -0800817 receiver_call_->DestroyVideoSendStream(thumbnail_send_stream);
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100818 }
ilnika014cc52017-03-07 04:21:04 -0800819 thumbnail_send_streams_.clear();
820 for (VideoReceiveStream* thumbnail_receive_stream :
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100821 thumbnail_receive_streams_) {
ilnika014cc52017-03-07 04:21:04 -0800822 sender_call_->DestroyVideoReceiveStream(thumbnail_receive_stream);
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100823 }
ilnika014cc52017-03-07 04:21:04 -0800824 thumbnail_send_streams_.clear();
825 thumbnail_receive_streams_.clear();
Sebastian Janssonf1f363f2018-08-13 14:24:58 +0200826 for (std::unique_ptr<test::TestVideoCapturer>& video_caputurer :
eladalon413ee9a2017-08-22 04:02:52 -0700827 thumbnail_capturers_) {
828 video_caputurer.reset();
829 }
ilnika014cc52017-03-07 04:21:04 -0800830}
831
ilnika014cc52017-03-07 04:21:04 -0800832void VideoQualityTest::SetupThumbnailCapturers(size_t num_thumbnail_streams) {
833 VideoStream thumbnail = DefaultThumbnailStream();
834 for (size_t i = 0; i < num_thumbnail_streams; ++i) {
835 thumbnail_capturers_.emplace_back(test::FrameGeneratorCapturer::Create(
836 static_cast<int>(thumbnail.width), static_cast<int>(thumbnail.height),
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200837 absl::nullopt, absl::nullopt, thumbnail.max_framerate, clock_));
ilnikf89a7382017-03-07 06:15:27 -0800838 RTC_DCHECK(thumbnail_capturers_.back());
ilnika014cc52017-03-07 04:21:04 -0800839 }
840}
841
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100842std::unique_ptr<test::FrameGenerator> VideoQualityTest::CreateFrameGenerator(
843 size_t video_idx) {
844 // Setup frame generator.
845 const size_t kWidth = 1850;
846 const size_t kHeight = 1110;
847 std::unique_ptr<test::FrameGenerator> frame_generator;
848 if (params_.screenshare[video_idx].generate_slides) {
849 frame_generator = test::FrameGenerator::CreateSlideGenerator(
850 kWidth, kHeight,
851 params_.screenshare[video_idx].slide_change_interval *
852 params_.video[video_idx].fps);
ivica5d6a06c2015-09-17 05:30:24 -0700853 } else {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100854 std::vector<std::string> slides = params_.screenshare[video_idx].slides;
855 if (slides.size() == 0) {
856 slides.push_back(test::ResourcePath("web_screenshot_1850_1110", "yuv"));
857 slides.push_back(test::ResourcePath("presentation_1850_1110", "yuv"));
858 slides.push_back(test::ResourcePath("photo_1850_1110", "yuv"));
859 slides.push_back(test::ResourcePath("difficult_photo_1850_1110", "yuv"));
860 }
861 if (params_.screenshare[video_idx].scroll_duration == 0) {
862 // Cycle image every slide_change_interval seconds.
863 frame_generator = test::FrameGenerator::CreateFromYuvFile(
864 slides, kWidth, kHeight,
865 params_.screenshare[video_idx].slide_change_interval *
866 params_.video[video_idx].fps);
ivica5d6a06c2015-09-17 05:30:24 -0700867 } else {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100868 RTC_CHECK_LE(params_.video[video_idx].width, kWidth);
869 RTC_CHECK_LE(params_.video[video_idx].height, kHeight);
870 RTC_CHECK_GT(params_.screenshare[video_idx].slide_change_interval, 0);
871 const int kPauseDurationMs =
872 (params_.screenshare[video_idx].slide_change_interval -
873 params_.screenshare[video_idx].scroll_duration) *
874 1000;
875 RTC_CHECK_LE(params_.screenshare[video_idx].scroll_duration,
876 params_.screenshare[video_idx].slide_change_interval);
877
878 frame_generator = test::FrameGenerator::CreateScrollingInputFromYuvFiles(
879 clock_, slides, kWidth, kHeight, params_.video[video_idx].width,
880 params_.video[video_idx].height,
881 params_.screenshare[video_idx].scroll_duration * 1000,
882 kPauseDurationMs);
ivica5d6a06c2015-09-17 05:30:24 -0700883 }
884 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100885 return frame_generator;
886}
887
888void VideoQualityTest::CreateCapturers() {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200889 RTC_DCHECK(video_sources_.empty());
890 RTC_DCHECK(video_capturers_.empty());
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100891 video_capturers_.resize(num_video_streams_);
892 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
893 if (params_.screenshare[video_idx].enabled) {
894 std::unique_ptr<test::FrameGenerator> frame_generator =
895 CreateFrameGenerator(video_idx);
896 test::FrameGeneratorCapturer* frame_generator_capturer =
897 new test::FrameGeneratorCapturer(clock_, std::move(frame_generator),
898 params_.video[video_idx].fps);
899 EXPECT_TRUE(frame_generator_capturer->Init());
900 video_capturers_[video_idx].reset(frame_generator_capturer);
901 } else {
902 if (params_.video[video_idx].clip_name == "Generator") {
903 video_capturers_[video_idx].reset(test::FrameGeneratorCapturer::Create(
904 static_cast<int>(params_.video[video_idx].width),
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200905 static_cast<int>(params_.video[video_idx].height), absl::nullopt,
906 absl::nullopt, params_.video[video_idx].fps, clock_));
Emircan Uysaler03e6ec92018-03-09 15:03:26 -0800907 } else if (params_.video[video_idx].clip_name == "GeneratorI420A") {
908 video_capturers_[video_idx].reset(test::FrameGeneratorCapturer::Create(
909 static_cast<int>(params_.video[video_idx].width),
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100910 static_cast<int>(params_.video[video_idx].height),
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200911 test::FrameGenerator::OutputType::I420A, absl::nullopt,
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100912 params_.video[video_idx].fps, clock_));
Emircan Uysaler0823eec2018-07-13 17:10:00 -0700913 } else if (params_.video[video_idx].clip_name == "GeneratorI010") {
914 video_capturers_[video_idx].reset(test::FrameGeneratorCapturer::Create(
915 static_cast<int>(params_.video[video_idx].width),
916 static_cast<int>(params_.video[video_idx].height),
917 test::FrameGenerator::OutputType::I010, absl::nullopt,
918 params_.video[video_idx].fps, clock_));
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100919 } else if (params_.video[video_idx].clip_name.empty()) {
920 video_capturers_[video_idx].reset(test::VcmCapturer::Create(
921 params_.video[video_idx].width, params_.video[video_idx].height,
922 params_.video[video_idx].fps,
923 params_.video[video_idx].capture_device_index));
924 if (!video_capturers_[video_idx]) {
925 // Failed to get actual camera, use chroma generator as backup.
926 video_capturers_[video_idx].reset(
927 test::FrameGeneratorCapturer::Create(
928 static_cast<int>(params_.video[video_idx].width),
929 static_cast<int>(params_.video[video_idx].height),
Danil Chapovalovb9b146c2018-06-15 12:28:07 +0200930 absl::nullopt, absl::nullopt, params_.video[video_idx].fps,
Emircan Uysaler03e6ec92018-03-09 15:03:26 -0800931 clock_));
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100932 }
933 } else {
934 video_capturers_[video_idx].reset(
935 test::FrameGeneratorCapturer::CreateFromYuvFile(
936 test::ResourcePath(params_.video[video_idx].clip_name, "yuv"),
937 params_.video[video_idx].width, params_.video[video_idx].height,
938 params_.video[video_idx].fps, clock_));
939 ASSERT_TRUE(video_capturers_[video_idx])
940 << "Could not create capturer for "
941 << params_.video[video_idx].clip_name
942 << ".yuv. Is this resource file present?";
943 }
944 }
945 RTC_DCHECK(video_capturers_[video_idx].get());
Sebastian Jansson3bd2c792018-07-13 13:29:03 +0200946 video_sources_.push_back(video_capturers_[video_idx].get());
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100947 }
ivica5d6a06c2015-09-17 05:30:24 -0700948}
949
Christoffer Rodbro39a44b22018-08-07 17:07:24 +0200950void VideoQualityTest::StartAudioStreams() {
951 audio_send_stream_->Start();
952 for (AudioReceiveStream* audio_recv_stream : audio_receive_streams_)
953 audio_recv_stream->Start();
954}
955
956void VideoQualityTest::StartThumbnailCapture() {
Sebastian Janssonf1f363f2018-08-13 14:24:58 +0200957 for (std::unique_ptr<test::TestVideoCapturer>& capturer :
958 thumbnail_capturers_)
Christoffer Rodbro39a44b22018-08-07 17:07:24 +0200959 capturer->Start();
960}
961
962void VideoQualityTest::StopThumbnailCapture() {
Sebastian Janssonf1f363f2018-08-13 14:24:58 +0200963 for (std::unique_ptr<test::TestVideoCapturer>& capturer :
964 thumbnail_capturers_)
Christoffer Rodbro39a44b22018-08-07 17:07:24 +0200965 capturer->Stop();
966}
967
Christoffer Rodbroc2a02882018-08-07 14:10:56 +0200968void VideoQualityTest::StartThumbnails() {
969 for (VideoSendStream* send_stream : thumbnail_send_streams_)
970 send_stream->Start();
971 for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
972 receive_stream->Start();
Christoffer Rodbroc2a02882018-08-07 14:10:56 +0200973}
974
975void VideoQualityTest::StopThumbnails() {
Christoffer Rodbroc2a02882018-08-07 14:10:56 +0200976 for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
977 receive_stream->Stop();
978 for (VideoSendStream* send_stream : thumbnail_send_streams_)
979 send_stream->Stop();
980}
981
Christoffer Rodbrob4bb4eb2017-11-13 13:03:52 +0100982std::unique_ptr<test::LayerFilteringTransport>
983VideoQualityTest::CreateSendTransport() {
Artem Titov8ea1e9d2018-10-04 14:46:31 +0200984 std::unique_ptr<NetworkBehaviorInterface> network_behavior = nullptr;
Artem Titove269cb42018-08-29 09:59:23 +0200985 if (injection_components_->sender_network == nullptr) {
Artem Titov8ea1e9d2018-10-04 14:46:31 +0200986 network_behavior = absl::make_unique<SimulatedNetwork>(*params_.config);
Artem Titove269cb42018-08-29 09:59:23 +0200987 } else {
Artem Titov8ea1e9d2018-10-04 14:46:31 +0200988 network_behavior = std::move(injection_components_->sender_network);
Artem Titove269cb42018-08-29 09:59:23 +0200989 }
Karl Wiberg918f50c2018-07-05 11:40:33 +0200990 return absl::make_unique<test::LayerFilteringTransport>(
Artem Titov4e199e92018-08-20 13:30:39 +0200991 &task_queue_,
Artem Titove269cb42018-08-29 09:59:23 +0200992 absl::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
Artem Titov8ea1e9d2018-10-04 14:46:31 +0200993 std::move(network_behavior)),
Artem Titov4e199e92018-08-20 13:30:39 +0200994 sender_call_.get(), kPayloadTypeVP8, kPayloadTypeVP9,
995 params_.video[0].selected_tl, params_.ss[0].selected_sl,
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +0100996 payload_type_map_, kVideoSendSsrcs[0],
997 static_cast<uint32_t>(kVideoSendSsrcs[0] + params_.ss[0].streams.size() -
998 1));
Christoffer Rodbrob4bb4eb2017-11-13 13:03:52 +0100999}
1000
1001std::unique_ptr<test::DirectTransport>
1002VideoQualityTest::CreateReceiveTransport() {
Artem Titov8ea1e9d2018-10-04 14:46:31 +02001003 std::unique_ptr<NetworkBehaviorInterface> network_behavior = nullptr;
Artem Titove269cb42018-08-29 09:59:23 +02001004 if (injection_components_->receiver_network == nullptr) {
Artem Titov8ea1e9d2018-10-04 14:46:31 +02001005 network_behavior = absl::make_unique<SimulatedNetwork>(*params_.config);
Artem Titove269cb42018-08-29 09:59:23 +02001006 } else {
Artem Titov8ea1e9d2018-10-04 14:46:31 +02001007 network_behavior = std::move(injection_components_->receiver_network);
Artem Titove269cb42018-08-29 09:59:23 +02001008 }
Karl Wiberg918f50c2018-07-05 11:40:33 +02001009 return absl::make_unique<test::DirectTransport>(
Artem Titovdd2eebe2018-08-20 13:27:45 +02001010 &task_queue_,
Artem Titove269cb42018-08-29 09:59:23 +02001011 absl::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
Artem Titov8ea1e9d2018-10-04 14:46:31 +02001012 std::move(network_behavior)),
Artem Titovdd2eebe2018-08-20 13:27:45 +02001013 receiver_call_.get(), payload_type_map_);
Christoffer Rodbrob4bb4eb2017-11-13 13:03:52 +01001014}
1015
sprang7a975f72015-10-12 06:33:21 -07001016void VideoQualityTest::RunWithAnalyzer(const Params& params) {
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001017 num_video_streams_ = params.call.dual_video ? 2 : 1;
eladalon413ee9a2017-08-22 04:02:52 -07001018 std::unique_ptr<test::LayerFilteringTransport> send_transport;
1019 std::unique_ptr<test::DirectTransport> recv_transport;
1020 FILE* graph_data_output_file = nullptr;
eladalon413ee9a2017-08-22 04:02:52 -07001021
sprangce4aef12015-11-02 07:23:20 -08001022 params_ = params;
ivica5d6a06c2015-09-17 05:30:24 -07001023 // TODO(ivica): Merge with RunWithRenderer and use a flag / argument to
1024 // differentiate between the analyzer and the renderer case.
Artem Titove269cb42018-08-29 09:59:23 +02001025 CheckParamsAndInjectionComponents();
ivica5d6a06c2015-09-17 05:30:24 -07001026
sprangce4aef12015-11-02 07:23:20 -08001027 if (!params_.analyzer.graph_data_output_filename.empty()) {
ivica5d6a06c2015-09-17 05:30:24 -07001028 graph_data_output_file =
sprangce4aef12015-11-02 07:23:20 -08001029 fopen(params_.analyzer.graph_data_output_filename.c_str(), "w");
Peter Boström74f6e9e2016-04-04 17:56:10 +02001030 RTC_CHECK(graph_data_output_file)
sprangce4aef12015-11-02 07:23:20 -08001031 << "Can't open the file " << params_.analyzer.graph_data_output_filename
1032 << "!";
ivica87f83a92015-10-08 05:13:32 -07001033 }
sprang7a975f72015-10-12 06:33:21 -07001034
ilnik98436952017-07-13 00:47:03 -07001035 if (!params.logging.rtc_event_log_name.empty()) {
Bjorn Terelius0a6a2b72018-01-19 17:52:38 +01001036 send_event_log_ = RtcEventLog::Create(RtcEventLog::EncodingType::Legacy);
1037 recv_event_log_ = RtcEventLog::Create(RtcEventLog::EncodingType::Legacy);
Ilya Nikolaevskiya4259f62017-12-05 13:19:45 +01001038 std::unique_ptr<RtcEventLogOutputFile> send_output(
Karl Wiberg918f50c2018-07-05 11:40:33 +02001039 absl::make_unique<RtcEventLogOutputFile>(
Ilya Nikolaevskiya4259f62017-12-05 13:19:45 +01001040 params.logging.rtc_event_log_name + "_send",
1041 RtcEventLog::kUnlimitedOutput));
1042 std::unique_ptr<RtcEventLogOutputFile> recv_output(
Karl Wiberg918f50c2018-07-05 11:40:33 +02001043 absl::make_unique<RtcEventLogOutputFile>(
Ilya Nikolaevskiya4259f62017-12-05 13:19:45 +01001044 params.logging.rtc_event_log_name + "_recv",
1045 RtcEventLog::kUnlimitedOutput));
1046 bool event_log_started =
1047 send_event_log_->StartLogging(std::move(send_output),
1048 RtcEventLog::kImmediateOutput) &&
1049 recv_event_log_->StartLogging(std::move(recv_output),
1050 RtcEventLog::kImmediateOutput);
ilnik98436952017-07-13 00:47:03 -07001051 RTC_DCHECK(event_log_started);
Ilya Nikolaevskiya4259f62017-12-05 13:19:45 +01001052 } else {
1053 send_event_log_ = RtcEventLog::CreateNull();
1054 recv_event_log_ = RtcEventLog::CreateNull();
ilnik98436952017-07-13 00:47:03 -07001055 }
1056
Ilya Nikolaevskiya4259f62017-12-05 13:19:45 +01001057 Call::Config send_call_config(send_event_log_.get());
1058 Call::Config recv_call_config(recv_event_log_.get());
1059 send_call_config.bitrate_config = params.call.call_bitrate_config;
1060 recv_call_config.bitrate_config = params.call.call_bitrate_config;
stefanf116bd02015-10-27 08:29:42 -07001061
Ilya Nikolaevskiya4259f62017-12-05 13:19:45 +01001062 task_queue_.SendTask([this, &send_call_config, &recv_call_config,
1063 &send_transport, &recv_transport]() {
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001064 if (params_.audio.enabled)
henrika255750b2018-08-27 16:13:37 +02001065 InitializeAudioDevice(
1066 &send_call_config, &recv_call_config, params_.audio.use_real_adm);
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001067
Ilya Nikolaevskiya4259f62017-12-05 13:19:45 +01001068 CreateCalls(send_call_config, recv_call_config);
1069 send_transport = CreateSendTransport();
1070 recv_transport = CreateReceiveTransport();
1071 });
stefanf116bd02015-10-27 08:29:42 -07001072
sprangce4aef12015-11-02 07:23:20 -08001073 std::string graph_title = params_.analyzer.graph_title;
1074 if (graph_title.empty())
1075 graph_title = VideoQualityTest::GenerateGraphTitle();
sprangc1b57a12017-02-28 08:50:47 -08001076 bool is_quick_test_enabled = field_trial::IsEnabled("WebRTC-QuickPerfTest");
Niels Möller88be9722018-10-10 10:58:52 +02001077 analyzer_ = absl::make_unique<VideoAnalyzer>(
eladalon413ee9a2017-08-22 04:02:52 -07001078 send_transport.get(), params_.analyzer.test_label,
ilnik2a8c2f52017-02-15 02:23:28 -08001079 params_.analyzer.avg_psnr_threshold, params_.analyzer.avg_ssim_threshold,
ilnik9ae0d762017-02-15 00:53:12 -08001080 is_quick_test_enabled
1081 ? kFramesSentInQuickTest
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001082 : params_.analyzer.test_durations_secs * params_.video[0].fps,
sprangce4aef12015-11-02 07:23:20 -08001083 graph_data_output_file, graph_title,
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001084 kVideoSendSsrcs[params_.ss[0].selected_stream],
1085 kSendRtxSsrcs[params_.ss[0].selected_stream],
1086 static_cast<size_t>(params_.ss[0].selected_stream),
1087 params.ss[0].selected_sl, params_.video[0].selected_tl,
1088 is_quick_test_enabled, clock_, params_.logging.rtp_dump_name);
ivica5d6a06c2015-09-17 05:30:24 -07001089
eladalon413ee9a2017-08-22 04:02:52 -07001090 task_queue_.SendTask([&]() {
Niels Möller88be9722018-10-10 10:58:52 +02001091 analyzer_->SetCall(sender_call_.get());
1092 analyzer_->SetReceiver(receiver_call_->Receiver());
1093 send_transport->SetReceiver(analyzer_.get());
eladalon413ee9a2017-08-22 04:02:52 -07001094 recv_transport->SetReceiver(sender_call_->Receiver());
ivica5d6a06c2015-09-17 05:30:24 -07001095
Niels Möller88be9722018-10-10 10:58:52 +02001096 SetupVideo(analyzer_.get(), recv_transport.get());
1097 SetupThumbnails(analyzer_.get(), recv_transport.get());
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001098 video_receive_configs_[params_.ss[0].selected_stream].renderer =
Niels Möller88be9722018-10-10 10:58:52 +02001099 analyzer_.get();
kthelgason2bc68642017-02-07 07:02:22 -08001100
eladalon413ee9a2017-08-22 04:02:52 -07001101 CreateFlexfecStreams();
1102 CreateVideoStreams();
Niels Möller88be9722018-10-10 10:58:52 +02001103 analyzer_->SetSendStream(video_send_streams_[0]);
eladalon413ee9a2017-08-22 04:02:52 -07001104 if (video_receive_streams_.size() == 1)
Niels Möller88be9722018-10-10 10:58:52 +02001105 analyzer_->SetReceiveStream(video_receive_streams_[0]);
ivica5d6a06c2015-09-17 05:30:24 -07001106
Niels Möller88be9722018-10-10 10:58:52 +02001107 GetVideoSendStream()->SetSource(analyzer_->OutputInterface(),
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001108 degradation_preference_);
eladalon413ee9a2017-08-22 04:02:52 -07001109 SetupThumbnailCapturers(params_.call.num_thumbnails);
1110 for (size_t i = 0; i < thumbnail_send_streams_.size(); ++i) {
1111 thumbnail_send_streams_[i]->SetSource(thumbnail_capturers_[i].get(),
1112 degradation_preference_);
1113 }
ilnika014cc52017-03-07 04:21:04 -08001114
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001115 CreateCapturers();
ivicac1cc8542015-10-08 03:44:06 -07001116
Niels Möller88be9722018-10-10 10:58:52 +02001117 analyzer_->SetSource(video_capturers_[0].get(),
1118 params_.ss[0].infer_streams);
ilnika014cc52017-03-07 04:21:04 -08001119
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001120 for (size_t video_idx = 1; video_idx < num_video_streams_; ++video_idx) {
1121 video_send_streams_[video_idx]->SetSource(
1122 video_capturers_[video_idx].get(), degradation_preference_);
1123 }
1124
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001125 if (params_.audio.enabled) {
1126 SetupAudio(send_transport.get());
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001127 StartAudioStreams();
Niels Möller88be9722018-10-10 10:58:52 +02001128 analyzer_->SetAudioReceiveStream(audio_receive_streams_[0]);
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001129 }
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001130 StartVideoStreams();
1131 StartThumbnails();
Niels Möller88be9722018-10-10 10:58:52 +02001132 analyzer_->StartMeasuringCpuProcessTime();
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001133 StartVideoCapture();
1134 StartThumbnailCapture();
eladalon413ee9a2017-08-22 04:02:52 -07001135 });
ivica5d6a06c2015-09-17 05:30:24 -07001136
Niels Möller88be9722018-10-10 10:58:52 +02001137 analyzer_->Wait();
ivica5d6a06c2015-09-17 05:30:24 -07001138
eladalon413ee9a2017-08-22 04:02:52 -07001139 task_queue_.SendTask([&]() {
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001140 StopThumbnailCapture();
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001141 StopThumbnails();
1142 Stop();
ivica5d6a06c2015-09-17 05:30:24 -07001143
eladalon413ee9a2017-08-22 04:02:52 -07001144 DestroyStreams();
1145 DestroyThumbnailStreams();
ivica5d6a06c2015-09-17 05:30:24 -07001146
eladalon413ee9a2017-08-22 04:02:52 -07001147 if (graph_data_output_file)
1148 fclose(graph_data_output_file);
1149
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001150 video_capturers_.clear();
eladalon413ee9a2017-08-22 04:02:52 -07001151 send_transport.reset();
1152 recv_transport.reset();
1153
1154 DestroyCalls();
1155 });
Niels Möller88be9722018-10-10 10:58:52 +02001156 analyzer_ = nullptr;
ivica5d6a06c2015-09-17 05:30:24 -07001157}
1158
henrika255750b2018-08-27 16:13:37 +02001159rtc::scoped_refptr<AudioDeviceModule> VideoQualityTest::CreateAudioDevice() {
1160#ifdef WEBRTC_WIN
1161 RTC_LOG(INFO) << "Using latest version of ADM on Windows";
1162 // We must initialize the COM library on a thread before we calling any of
1163 // the library functions. All COM functions in the ADM will return
1164 // CO_E_NOTINITIALIZED otherwise. The legacy ADM for Windows used internal
1165 // COM initialization but the new ADM requires COM to be initialized
1166 // externally.
1167 com_initializer_ = absl::make_unique<webrtc_win::ScopedCOMInitializer>(
1168 webrtc_win::ScopedCOMInitializer::kMTA);
1169 RTC_CHECK(com_initializer_->Succeeded());
1170 RTC_CHECK(webrtc_win::core_audio_utility::IsSupported());
1171 RTC_CHECK(webrtc_win::core_audio_utility::IsMMCSSSupported());
1172 return CreateWindowsCoreAudioAudioDeviceModule();
1173#else
1174 // Use legacy factory method on all platforms except Windows.
1175 return AudioDeviceModule::Create(AudioDeviceModule::kPlatformDefaultAudio);
1176#endif
1177}
1178
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001179void VideoQualityTest::InitializeAudioDevice(Call::Config* send_call_config,
henrika255750b2018-08-27 16:13:37 +02001180 Call::Config* recv_call_config,
1181 bool use_real_adm) {
1182 rtc::scoped_refptr<AudioDeviceModule> audio_device;
1183 if (use_real_adm) {
1184 // Run test with real ADM (using default audio devices) if user has
1185 // explicitly set the --audio and --use_real_adm command-line flags.
1186 audio_device = CreateAudioDevice();
1187 } else {
1188 // By default, create a test ADM which fakes audio.
1189 audio_device = TestAudioDeviceModule::CreateTestAudioDeviceModule(
1190 TestAudioDeviceModule::CreatePulsedNoiseCapturer(32000, 48000),
1191 TestAudioDeviceModule::CreateDiscardRenderer(48000), 1.f);
1192 }
1193 RTC_CHECK(audio_device);
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001194
1195 AudioState::Config audio_state_config;
1196 audio_state_config.audio_mixer = AudioMixerImpl::Create();
1197 audio_state_config.audio_processing = AudioProcessingBuilder().Create();
henrika255750b2018-08-27 16:13:37 +02001198 audio_state_config.audio_device_module = audio_device;
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001199 send_call_config->audio_state = AudioState::Create(audio_state_config);
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001200 recv_call_config->audio_state = AudioState::Create(audio_state_config);
henrika255750b2018-08-27 16:13:37 +02001201 if (use_real_adm) {
1202 // The real ADM requires extra initialization: setting default devices,
1203 // setting up number of channels etc. Helper class also calls
1204 // AudioDeviceModule::Init().
1205 webrtc::adm_helpers::Init(audio_device.get());
1206 } else {
1207 audio_device->Init();
1208 }
1209 // Always initialize the ADM before injecting a valid audio transport.
1210 RTC_CHECK(audio_device->RegisterAudioCallback(
1211 send_call_config->audio_state->audio_transport()) == 0);
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001212}
1213
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001214void VideoQualityTest::SetupAudio(Transport* transport) {
Niels Möller7d76a312018-10-26 12:57:07 +02001215 AudioSendStream::Config audio_send_config(transport,
1216 /*media_transport=*/nullptr);
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001217 audio_send_config.rtp.ssrc = kAudioSendSsrc;
minyuea27172d2016-11-01 05:59:29 -07001218
1219 // Add extension to enable audio send side BWE, and allow audio bit rate
1220 // adaptation.
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001221 audio_send_config.rtp.extensions.clear();
1222 audio_send_config.send_codec_spec = AudioSendStream::Config::SendCodecSpec(
Oskar Sundbom8e07c132018-01-08 16:45:42 +01001223 kAudioSendPayloadType,
Yves Gerey665174f2018-06-19 15:03:05 +02001224 {"OPUS",
1225 48000,
1226 2,
1227 {{"usedtx", (params_.audio.dtx ? "1" : "0")}, {"stereo", "1"}}});
minyuea27172d2016-11-01 05:59:29 -07001228
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001229 if (params_.call.send_side_bwe) {
1230 audio_send_config.rtp.extensions.push_back(
1231 webrtc::RtpExtension(webrtc::RtpExtension::kTransportSequenceNumberUri,
1232 test::kTransportSequenceNumberExtensionId));
1233 audio_send_config.min_bitrate_bps = kOpusMinBitrateBps;
1234 audio_send_config.max_bitrate_bps = kOpusBitrateFbBps;
1235 audio_send_config.send_codec_spec->transport_cc_enabled = true;
1236 }
1237 audio_send_config.encoder_factory = audio_encoder_factory_;
1238 SetAudioConfig(audio_send_config);
1239
Christoffer Rodbroc2a02882018-08-07 14:10:56 +02001240 std::string sync_group;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001241 if (params_.video[0].enabled && params_.audio.sync_video)
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001242 sync_group = kSyncGroup;
minyuea27172d2016-11-01 05:59:29 -07001243
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001244 CreateMatchingAudioConfigs(transport, sync_group);
1245 CreateAudioStreams();
minyuea27172d2016-11-01 05:59:29 -07001246}
1247
minyue73208662016-08-18 06:28:55 -07001248void VideoQualityTest::RunWithRenderers(const Params& params) {
henrika255750b2018-08-27 16:13:37 +02001249 RTC_LOG(INFO) << __FUNCTION__;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001250 num_video_streams_ = params.call.dual_video ? 2 : 1;
eladalon413ee9a2017-08-22 04:02:52 -07001251 std::unique_ptr<test::LayerFilteringTransport> send_transport;
1252 std::unique_ptr<test::DirectTransport> recv_transport;
minyuea27172d2016-11-01 05:59:29 -07001253 std::unique_ptr<test::VideoRenderer> local_preview;
eladalon413ee9a2017-08-22 04:02:52 -07001254 std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers;
Ilya Nikolaevskiy42e7d9c2018-11-02 13:14:37 +01001255
1256 if (!params.logging.rtc_event_log_name.empty()) {
1257 send_event_log_ = RtcEventLog::Create(RtcEventLog::EncodingType::Legacy);
1258 recv_event_log_ = RtcEventLog::Create(RtcEventLog::EncodingType::Legacy);
1259 std::unique_ptr<RtcEventLogOutputFile> send_output(
1260 absl::make_unique<RtcEventLogOutputFile>(
1261 params.logging.rtc_event_log_name + "_send",
1262 RtcEventLog::kUnlimitedOutput));
1263 std::unique_ptr<RtcEventLogOutputFile> recv_output(
1264 absl::make_unique<RtcEventLogOutputFile>(
1265 params.logging.rtc_event_log_name + "_recv",
1266 RtcEventLog::kUnlimitedOutput));
1267 bool event_log_started =
1268 send_event_log_->StartLogging(std::move(send_output),
1269 /*output_period_ms=*/5000) &&
1270 recv_event_log_->StartLogging(std::move(recv_output),
1271 /*output_period_ms=*/5000);
1272 RTC_DCHECK(event_log_started);
1273 } else {
1274 send_event_log_ = RtcEventLog::CreateNull();
1275 recv_event_log_ = RtcEventLog::CreateNull();
1276 }
minyue73208662016-08-18 06:28:55 -07001277
eladalon413ee9a2017-08-22 04:02:52 -07001278 task_queue_.SendTask([&]() {
1279 params_ = params;
Artem Titove269cb42018-08-29 09:59:23 +02001280 CheckParamsAndInjectionComponents();
palmkviste75f2042016-09-28 06:19:48 -07001281
eladalon413ee9a2017-08-22 04:02:52 -07001282 // TODO(ivica): Remove bitrate_config and use the default Call::Config(), to
1283 // match the full stack tests.
Ilya Nikolaevskiy42e7d9c2018-11-02 13:14:37 +01001284 Call::Config send_call_config(send_event_log_.get());
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001285 send_call_config.bitrate_config = params_.call.call_bitrate_config;
Ilya Nikolaevskiy42e7d9c2018-11-02 13:14:37 +01001286 Call::Config recv_call_config(recv_event_log_.get());
ivica5d6a06c2015-09-17 05:30:24 -07001287
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001288 if (params_.audio.enabled)
henrika255750b2018-08-27 16:13:37 +02001289 InitializeAudioDevice(
1290 &send_call_config, &recv_call_config, params_.audio.use_real_adm);
minyue73208662016-08-18 06:28:55 -07001291
Christoffer Rodbro39a44b22018-08-07 17:07:24 +02001292 CreateCalls(send_call_config, recv_call_config);
eladalon413ee9a2017-08-22 04:02:52 -07001293
1294 // TODO(minyue): consider if this is a good transport even for audio only
1295 // calls.
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001296 send_transport = CreateSendTransport();
eladalon413ee9a2017-08-22 04:02:52 -07001297
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001298 recv_transport = CreateReceiveTransport();
eladalon413ee9a2017-08-22 04:02:52 -07001299
1300 // TODO(ivica): Use two calls to be able to merge with RunWithAnalyzer or at
1301 // least share as much code as possible. That way this test would also match
1302 // the full stack tests better.
1303 send_transport->SetReceiver(receiver_call_->Receiver());
1304 recv_transport->SetReceiver(sender_call_->Receiver());
1305
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001306 if (params_.video[0].enabled) {
eladalon413ee9a2017-08-22 04:02:52 -07001307 // Create video renderers.
1308 local_preview.reset(test::VideoRenderer::Create(
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001309 "Local Preview", params_.video[0].width, params_.video[0].height));
eladalon413ee9a2017-08-22 04:02:52 -07001310
1311 SetupVideo(send_transport.get(), recv_transport.get());
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001312 GetVideoSendConfig()->pre_encode_callback = local_preview.get();
eladalon413ee9a2017-08-22 04:02:52 -07001313
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001314 size_t num_streams_processed = 0;
1315 for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
1316 const size_t selected_stream_id = params_.ss[video_idx].selected_stream;
1317 const size_t num_streams = params_.ss[video_idx].streams.size();
1318 if (selected_stream_id == num_streams) {
1319 for (size_t stream_id = 0; stream_id < num_streams; ++stream_id) {
Jonas Olsson366a50c2018-09-06 13:41:30 +02001320 rtc::StringBuilder oss;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001321 oss << "Loopback Video #" << video_idx << " - Stream #"
1322 << static_cast<int>(stream_id);
1323 loopback_renderers.emplace_back(test::VideoRenderer::Create(
1324 oss.str().c_str(),
1325 params_.ss[video_idx].streams[stream_id].width,
1326 params_.ss[video_idx].streams[stream_id].height));
1327 video_receive_configs_[stream_id + num_streams_processed].renderer =
1328 loopback_renderers.back().get();
1329 if (params_.audio.enabled && params_.audio.sync_video)
1330 video_receive_configs_[stream_id + num_streams_processed]
1331 .sync_group = kSyncGroup;
1332 }
1333 } else {
Jonas Olsson366a50c2018-09-06 13:41:30 +02001334 rtc::StringBuilder oss;
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001335 oss << "Loopback Video #" << video_idx;
1336 loopback_renderers.emplace_back(test::VideoRenderer::Create(
1337 oss.str().c_str(),
1338 params_.ss[video_idx].streams[selected_stream_id].width,
1339 params_.ss[video_idx].streams[selected_stream_id].height));
1340 video_receive_configs_[selected_stream_id + num_streams_processed]
1341 .renderer = loopback_renderers.back().get();
eladalon413ee9a2017-08-22 04:02:52 -07001342 if (params_.audio.enabled && params_.audio.sync_video)
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001343 video_receive_configs_[num_streams_processed + selected_stream_id]
1344 .sync_group = kSyncGroup;
eladalon413ee9a2017-08-22 04:02:52 -07001345 }
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001346 num_streams_processed += num_streams;
eladalon413ee9a2017-08-22 04:02:52 -07001347 }
eladalon413ee9a2017-08-22 04:02:52 -07001348 CreateFlexfecStreams();
1349 CreateVideoStreams();
1350
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001351 CreateCapturers();
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001352 ConnectVideoSourcesToStreams();
eladalon413ee9a2017-08-22 04:02:52 -07001353 }
1354
1355 if (params_.audio.enabled) {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001356 SetupAudio(send_transport.get());
eladalon413ee9a2017-08-22 04:02:52 -07001357 }
1358
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001359 Start();
eladalon413ee9a2017-08-22 04:02:52 -07001360 });
minyue73208662016-08-18 06:28:55 -07001361
Danail Kirov6fcf6ca2018-10-25 10:45:47 -07001362 test::PressEnterToContinue(task_queue_);
ivica5d6a06c2015-09-17 05:30:24 -07001363
eladalon413ee9a2017-08-22 04:02:52 -07001364 task_queue_.SendTask([&]() {
Sebastian Jansson3bd2c792018-07-13 13:29:03 +02001365 Stop();
1366 DestroyStreams();
minyue73208662016-08-18 06:28:55 -07001367
Ilya Nikolaevskiy255d1cd2017-12-21 18:02:59 +01001368 video_capturers_.clear();
eladalon413ee9a2017-08-22 04:02:52 -07001369 send_transport.reset();
1370 recv_transport.reset();
sprang1168fd42017-06-21 09:00:17 -07001371
eladalon413ee9a2017-08-22 04:02:52 -07001372 local_preview.reset();
1373 loopback_renderers.clear();
1374
1375 DestroyCalls();
1376 });
ivica5d6a06c2015-09-17 05:30:24 -07001377}
1378
ivica5d6a06c2015-09-17 05:30:24 -07001379} // namespace webrtc