pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 10 | #include <memory> |
| 11 | #include <string> |
| 12 | #include <utility> |
| 13 | #include <vector> |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 14 | |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 15 | #include "absl/memory/memory.h" |
| 16 | #include "absl/types/optional.h" |
| 17 | #include "api/test/simulated_network.h" |
Patrik Höglund | d8f3c17 | 2018-09-26 14:39:17 +0200 | [diff] [blame] | 18 | #include "api/test/test_dependency_factory.h" |
Yves Gerey | 3e70781 | 2018-11-28 16:47:49 +0100 | [diff] [blame] | 19 | #include "api/test/video_quality_test_fixture.h" |
| 20 | #include "api/video_codecs/sdp_video_format.h" |
| 21 | #include "api/video_codecs/video_codec.h" |
| 22 | #include "api/video_codecs/video_encoder_config.h" |
| 23 | #include "common_types.h" // NOLINT(build/include) |
Emircan Uysaler | 0823eec | 2018-07-13 17:10:00 -0700 | [diff] [blame] | 24 | #include "media/base/vp9_profile.h" |
| 25 | #include "modules/video_coding/codecs/vp9/include/vp9.h" |
Sebastian Jansson | f851888 | 2018-05-31 14:52:59 +0200 | [diff] [blame] | 26 | #include "rtc_base/flags.h" |
Mirko Bonadei | 17f4878 | 2018-09-28 08:51:10 +0200 | [diff] [blame] | 27 | #include "system_wrappers/include/field_trial.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 28 | #include "test/field_trial.h" |
| 29 | #include "test/gtest.h" |
| 30 | #include "video/video_quality_test.h" |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 31 | |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 32 | namespace webrtc { |
Sebastian Jansson | f851888 | 2018-05-31 14:52:59 +0200 | [diff] [blame] | 33 | namespace flags { |
| 34 | |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 35 | WEBRTC_DEFINE_string(rtc_event_log_name, |
| 36 | "", |
| 37 | "Filename for rtc event log. Two files " |
| 38 | "with \"_send\" and \"_recv\" suffixes will be created."); |
Sebastian Jansson | f851888 | 2018-05-31 14:52:59 +0200 | [diff] [blame] | 39 | std::string RtcEventLogName() { |
| 40 | return static_cast<std::string>(FLAG_rtc_event_log_name); |
| 41 | } |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 42 | WEBRTC_DEFINE_string(rtp_dump_name, |
| 43 | "", |
| 44 | "Filename for dumped received RTP stream."); |
Sebastian Jansson | f851888 | 2018-05-31 14:52:59 +0200 | [diff] [blame] | 45 | std::string RtpDumpName() { |
| 46 | return static_cast<std::string>(FLAG_rtp_dump_name); |
| 47 | } |
Mirko Bonadei | 2dfa998 | 2018-10-18 11:35:32 +0200 | [diff] [blame] | 48 | WEBRTC_DEFINE_string( |
| 49 | encoded_frame_path, |
| 50 | "", |
| 51 | "The base path for encoded frame logs. Created files will have " |
| 52 | "the form <encoded_frame_path>.<n>.(recv|send.<m>).ivf"); |
Sebastian Jansson | f851888 | 2018-05-31 14:52:59 +0200 | [diff] [blame] | 53 | std::string EncodedFramePath() { |
| 54 | return static_cast<std::string>(FLAG_encoded_frame_path); |
| 55 | } |
| 56 | } // namespace flags |
| 57 | } // namespace webrtc |
| 58 | |
| 59 | namespace webrtc { |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 60 | |
sprang | 89c4a7e | 2017-06-30 13:27:40 -0700 | [diff] [blame] | 61 | namespace { |
brandtr | dd369c6 | 2016-11-16 23:56:57 -0800 | [diff] [blame] | 62 | static const int kFullStackTestDurationSecs = 45; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 63 | const char kPacerPushBackExperiment[] = |
| 64 | "WebRTC-PacerPushbackExperiment/Enabled/"; |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 65 | const char kVp8TrustedRateControllerFieldTrial[] = |
| 66 | "WebRTC-LibvpxVp8TrustedRateController/Enabled/"; |
pbos@webrtc.org | b613b5a | 2013-12-03 10:13:04 +0000 | [diff] [blame] | 67 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 68 | struct ParamsWithLogging : public VideoQualityTest::Params { |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 69 | public: |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 70 | ParamsWithLogging() { |
| 71 | // Use these logging flags by default, for everything. |
Mirko Bonadei | 45a4c41 | 2018-07-31 15:07:28 +0200 | [diff] [blame] | 72 | logging = {flags::RtcEventLogName(), flags::RtpDumpName(), |
| 73 | flags::EncodedFramePath()}; |
Artem Titov | 75e3647 | 2018-10-08 12:28:56 +0200 | [diff] [blame] | 74 | this->config = BuiltInNetworkBehaviorConfig(); |
pbos@webrtc.org | 9401524 | 2013-10-16 11:05:37 +0000 | [diff] [blame] | 75 | } |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 76 | }; |
| 77 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 78 | std::unique_ptr<VideoQualityTestFixtureInterface> |
| 79 | CreateVideoQualityTestFixture() { |
Patrik Höglund | d8f3c17 | 2018-09-26 14:39:17 +0200 | [diff] [blame] | 80 | // The components will normally be nullptr (= use defaults), but it's possible |
| 81 | // for external test runners to override the list of injected components. |
| 82 | auto components = TestDependencyFactory::GetInstance().CreateComponents(); |
| 83 | return absl::make_unique<VideoQualityTest>(std::move(components)); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 84 | } |
| 85 | |
Erik Språng | b6b1cac | 2018-08-09 16:12:54 +0200 | [diff] [blame] | 86 | // Takes the current active field trials set, and appends some new trials. |
| 87 | std::string AppendFieldTrials(std::string new_trial_string) { |
| 88 | return std::string(field_trial::GetFieldTrialString()) + new_trial_string; |
| 89 | } |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 90 | } // namespace |
| 91 | |
sprang | ce4aef1 | 2015-11-02 07:23:20 -0800 | [diff] [blame] | 92 | // VideoQualityTest::Params params = { |
| 93 | // { ... }, // Common. |
| 94 | // { ... }, // Video-specific settings. |
| 95 | // { ... }, // Screenshare-specific settings. |
| 96 | // { ... }, // Analyzer settings. |
| 97 | // pipe, // FakeNetworkPipe::Config |
| 98 | // { ... }, // Spatial scalability. |
| 99 | // logs // bool |
| 100 | // }; |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 101 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 102 | class GenericDescriptorTest : public ::testing::TestWithParam<std::string> { |
| 103 | public: |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 104 | GenericDescriptorTest() |
| 105 | : field_trial_(GetParam()), |
| 106 | generic_descriptor_enabled_( |
| 107 | field_trial::IsEnabled("WebRTC-GenericDescriptor")) {} |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 108 | |
| 109 | std::string GetTestName(std::string base) { |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 110 | if (generic_descriptor_enabled_) |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 111 | base += "_generic_descriptor"; |
| 112 | return base; |
| 113 | } |
| 114 | |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 115 | bool GenericDescriptorEnabled() const { return generic_descriptor_enabled_; } |
| 116 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 117 | private: |
| 118 | test::ScopedFieldTrials field_trial_; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 119 | bool generic_descriptor_enabled_; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 120 | }; |
| 121 | |
Mirko Bonadei | 8ef5793 | 2018-11-16 14:38:03 +0100 | [diff] [blame] | 122 | #if defined(RTC_ENABLE_VP9) |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 123 | TEST(FullStackTest, ForemanCifWithoutPacketLossVp9) { |
| 124 | auto fixture = CreateVideoQualityTestFixture(); |
| 125 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 126 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 127 | foreman_cif.video[0] = {true, 352, 288, 30, 700000, |
| 128 | 700000, 700000, false, "VP9", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 129 | 0, 0, false, false, false, "foreman_cif"}; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 130 | foreman_cif.analyzer = {"foreman_cif_net_delay_0_0_plr_0_VP9", 0.0, 0.0, |
| 131 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 132 | fixture->RunWithAnalyzer(foreman_cif); |
asapersson | 88b0a22 | 2016-02-12 13:16:43 -0800 | [diff] [blame] | 133 | } |
| 134 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 135 | TEST_P(GenericDescriptorTest, ForemanCifPlr5Vp9) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 136 | auto fixture = CreateVideoQualityTestFixture(); |
| 137 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 138 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 139 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 140 | 500000, 2000000, false, "VP9", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 141 | 0, 0, false, false, false, "foreman_cif"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 142 | foreman_cif.analyzer = {GetTestName("foreman_cif_delay_50_0_plr_5_VP9"), 0.0, |
| 143 | 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 144 | foreman_cif.config->loss_percent = 5; |
| 145 | foreman_cif.config->queue_delay_ms = 50; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 146 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 147 | fixture->RunWithAnalyzer(foreman_cif); |
asapersson | 88b0a22 | 2016-02-12 13:16:43 -0800 | [diff] [blame] | 148 | } |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 149 | |
Emircan Uysaler | 0823eec | 2018-07-13 17:10:00 -0700 | [diff] [blame] | 150 | TEST(FullStackTest, GeneratorWithoutPacketLossVp9Profile2) { |
| 151 | // Profile 2 might not be available on some platforms until |
| 152 | // https://bugs.chromium.org/p/webm/issues/detail?id=1544 is solved. |
| 153 | bool profile_2_is_supported = false; |
| 154 | for (const auto& codec : SupportedVP9Codecs()) { |
| 155 | if (ParseSdpForVP9Profile(codec.parameters) |
| 156 | .value_or(VP9Profile::kProfile0) == VP9Profile::kProfile2) { |
| 157 | profile_2_is_supported = true; |
| 158 | } |
| 159 | } |
| 160 | if (!profile_2_is_supported) |
| 161 | return; |
| 162 | auto fixture = CreateVideoQualityTestFixture(); |
| 163 | |
| 164 | SdpVideoFormat::Parameters vp92 = { |
| 165 | {kVP9FmtpProfileId, VP9ProfileToString(VP9Profile::kProfile2)}}; |
| 166 | ParamsWithLogging generator; |
| 167 | generator.call.send_side_bwe = true; |
| 168 | generator.video[0] = { |
| 169 | true, 352, 288, 30, 700000, 700000, 700000, false, "VP9", |
| 170 | 1, 0, 0, false, false, false, "GeneratorI010", 0, vp92}; |
| 171 | generator.analyzer = {"generator_net_delay_0_0_plr_0_VP9Profile2", 0.0, 0.0, |
| 172 | kFullStackTestDurationSecs}; |
| 173 | fixture->RunWithAnalyzer(generator); |
| 174 | } |
| 175 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 176 | TEST(FullStackTest, ForemanCifWithoutPacketLossMultiplexI420Frame) { |
| 177 | auto fixture = CreateVideoQualityTestFixture(); |
| 178 | ParamsWithLogging foreman_cif; |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 179 | foreman_cif.call.send_side_bwe = true; |
| 180 | foreman_cif.video[0] = {true, 352, 288, 30, 700000, |
| 181 | 700000, 700000, false, "multiplex", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 182 | 0, 0, false, false, false, |
| 183 | "foreman_cif"}; |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 184 | foreman_cif.analyzer = {"foreman_cif_net_delay_0_0_plr_0_Multiplex", 0.0, 0.0, |
| 185 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 186 | fixture->RunWithAnalyzer(foreman_cif); |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 187 | } |
| 188 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 189 | TEST(FullStackTest, GeneratorWithoutPacketLossMultiplexI420AFrame) { |
| 190 | auto fixture = CreateVideoQualityTestFixture(); |
| 191 | |
| 192 | ParamsWithLogging generator; |
Emircan Uysaler | f1ff3bd | 2018-03-12 11:53:21 -0700 | [diff] [blame] | 193 | generator.call.send_side_bwe = true; |
| 194 | generator.video[0] = {true, 352, 288, 30, 700000, |
| 195 | 700000, 700000, false, "multiplex", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 196 | 0, 0, false, false, false, |
| 197 | "GeneratorI420A"}; |
Emircan Uysaler | f1ff3bd | 2018-03-12 11:53:21 -0700 | [diff] [blame] | 198 | generator.analyzer = {"generator_net_delay_0_0_plr_0_Multiplex", 0.0, 0.0, |
| 199 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 200 | fixture->RunWithAnalyzer(generator); |
Emircan Uysaler | 03e6ec9 | 2018-03-09 15:03:26 -0800 | [diff] [blame] | 201 | } |
| 202 | |
Mirko Bonadei | 8ef5793 | 2018-11-16 14:38:03 +0100 | [diff] [blame] | 203 | #endif // defined(RTC_ENABLE_VP9) |
asapersson | 88b0a22 | 2016-02-12 13:16:43 -0800 | [diff] [blame] | 204 | |
Patrik Höglund | 11bf2fa | 2018-04-09 12:20:50 +0200 | [diff] [blame] | 205 | #if defined(WEBRTC_LINUX) |
| 206 | // Crashes on the linux trusty perf bot: bugs.webrtc.org/9129. |
| 207 | #define MAYBE_ParisQcifWithoutPacketLoss DISABLED_ParisQcifWithoutPacketLoss |
| 208 | #else |
| 209 | #define MAYBE_ParisQcifWithoutPacketLoss ParisQcifWithoutPacketLoss |
| 210 | #endif |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 211 | TEST(FullStackTest, MAYBE_ParisQcifWithoutPacketLoss) { |
| 212 | auto fixture = CreateVideoQualityTestFixture(); |
| 213 | ParamsWithLogging paris_qcif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 214 | paris_qcif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 215 | paris_qcif.video[0] = {true, 176, 144, 30, 300000, |
| 216 | 300000, 300000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 217 | 0, 0, false, false, false, "paris_qcif"}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 218 | paris_qcif.analyzer = {"net_delay_0_0_plr_0", 36.0, 0.96, |
| 219 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 220 | fixture->RunWithAnalyzer(paris_qcif); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 221 | } |
| 222 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 223 | TEST_P(GenericDescriptorTest, ForemanCifWithoutPacketLoss) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 224 | auto fixture = CreateVideoQualityTestFixture(); |
stefan@webrtc.org | b8e9e44 | 2014-07-09 11:29:06 +0000 | [diff] [blame] | 225 | // TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif. |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 226 | ParamsWithLogging foreman_cif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 227 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 228 | foreman_cif.video[0] = {true, 352, 288, 30, 700000, |
| 229 | 700000, 700000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 230 | 0, 0, false, false, false, "foreman_cif"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 231 | foreman_cif.analyzer = {GetTestName("foreman_cif_net_delay_0_0_plr_0"), 0.0, |
| 232 | 0.0, kFullStackTestDurationSecs}; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 233 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 234 | fixture->RunWithAnalyzer(foreman_cif); |
pbos@webrtc.org | 994d0b7 | 2014-06-27 08:47:52 +0000 | [diff] [blame] | 235 | } |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 236 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 237 | TEST_P(GenericDescriptorTest, ForemanCif30kbpsWithoutPacketLoss) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 238 | auto fixture = CreateVideoQualityTestFixture(); |
| 239 | ParamsWithLogging foreman_cif; |
asapersson | fb6ad3b | 2016-12-16 06:54:01 -0800 | [diff] [blame] | 240 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 241 | foreman_cif.video[0] = {true, 352, 288, 10, 30000, |
| 242 | 30000, 30000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 243 | 0, 0, false, false, false, "foreman_cif"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 244 | foreman_cif.analyzer = {GetTestName("foreman_cif_30kbps_net_delay_0_0_plr_0"), |
| 245 | 0.0, 0.0, kFullStackTestDurationSecs}; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 246 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 247 | fixture->RunWithAnalyzer(foreman_cif); |
asapersson | fb6ad3b | 2016-12-16 06:54:01 -0800 | [diff] [blame] | 248 | } |
| 249 | |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 250 | // TODO(webrtc:9722): Remove when experiment is cleaned up. |
| 251 | TEST_P(GenericDescriptorTest, |
| 252 | ForemanCif30kbpsWithoutPacketLossTrustedRateControl) { |
| 253 | test::ScopedFieldTrials override_field_trials( |
| 254 | AppendFieldTrials(kVp8TrustedRateControllerFieldTrial)); |
| 255 | auto fixture = CreateVideoQualityTestFixture(); |
| 256 | |
| 257 | ParamsWithLogging foreman_cif; |
| 258 | foreman_cif.call.send_side_bwe = true; |
| 259 | foreman_cif.video[0] = {true, 352, 288, 10, 30000, 30000, 30000, |
| 260 | false, "VP8", 1, 0, 0, false, false, |
| 261 | false, "foreman_cif"}; |
| 262 | foreman_cif.analyzer = { |
| 263 | GetTestName("foreman_cif_30kbps_net_delay_0_0_plr_0_trusted_rate_ctrl"), |
| 264 | 0.0, 0.0, kFullStackTestDurationSecs}; |
| 265 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
| 266 | fixture->RunWithAnalyzer(foreman_cif); |
| 267 | } |
| 268 | |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 269 | // Link capacity below default start rate. Automatic down scaling enabled. |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 270 | TEST(FullStackTest, ForemanCifLink150kbpsWithoutPacketLoss) { |
| 271 | auto fixture = CreateVideoQualityTestFixture(); |
Niels Möller | 0e90982 | 2018-08-21 17:34:35 +0200 | [diff] [blame] | 272 | ParamsWithLogging foreman_cif; |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 273 | foreman_cif.call.send_side_bwe = true; |
| 274 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 275 | 500000, 2000000, false, "VP8", 1, |
| 276 | 0, 0, false, false, true, "foreman_cif"}; |
| 277 | foreman_cif.analyzer = {"foreman_cif_link_150kbps_net_delay_0_0_plr_0", |
| 278 | 0.0, 0.0, |
| 279 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 280 | foreman_cif.config->link_capacity_kbps = 150; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 281 | fixture->RunWithAnalyzer(foreman_cif); |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 282 | } |
| 283 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 284 | TEST_P(GenericDescriptorTest, ForemanCifPlr5) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 285 | auto fixture = CreateVideoQualityTestFixture(); |
| 286 | ParamsWithLogging foreman_cif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 287 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 288 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 289 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 290 | 0, 0, false, false, false, "foreman_cif"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 291 | foreman_cif.analyzer = {GetTestName("foreman_cif_delay_50_0_plr_5"), 0.0, 0.0, |
Lu Liu | 6f68324 | 2018-09-25 18:48:48 +0000 | [diff] [blame] | 292 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 293 | foreman_cif.config->loss_percent = 5; |
| 294 | foreman_cif.config->queue_delay_ms = 50; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 295 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 296 | fixture->RunWithAnalyzer(foreman_cif); |
stefan@webrtc.org | c216b9a | 2014-10-14 10:38:49 +0000 | [diff] [blame] | 297 | } |
| 298 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 299 | TEST_P(GenericDescriptorTest, ForemanCifPlr5Ulpfec) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 300 | auto fixture = CreateVideoQualityTestFixture(); |
| 301 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 302 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 303 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 304 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 305 | 0, 0, true, false, false, "foreman_cif"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 306 | foreman_cif.analyzer = {GetTestName("foreman_cif_delay_50_0_plr_5_ulpfec"), |
| 307 | 0.0, 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 308 | foreman_cif.config->loss_percent = 5; |
| 309 | foreman_cif.config->queue_delay_ms = 50; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 310 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 311 | fixture->RunWithAnalyzer(foreman_cif); |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 312 | } |
| 313 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 314 | TEST(FullStackTest, ForemanCifPlr5Flexfec) { |
| 315 | auto fixture = CreateVideoQualityTestFixture(); |
| 316 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 317 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 318 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 319 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 320 | 0, 0, false, true, false, "foreman_cif"}; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 321 | foreman_cif.analyzer = {"foreman_cif_delay_50_0_plr_5_flexfec", 0.0, 0.0, |
| 322 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 323 | foreman_cif.config->loss_percent = 5; |
| 324 | foreman_cif.config->queue_delay_ms = 50; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 325 | fixture->RunWithAnalyzer(foreman_cif); |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 326 | } |
| 327 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 328 | TEST(FullStackTest, ForemanCif500kbpsPlr3Flexfec) { |
| 329 | auto fixture = CreateVideoQualityTestFixture(); |
| 330 | ParamsWithLogging foreman_cif; |
stefan | 889d965 | 2017-07-05 03:03:02 -0700 | [diff] [blame] | 331 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 332 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 333 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 334 | 0, 0, false, true, false, "foreman_cif"}; |
stefan | 889d965 | 2017-07-05 03:03:02 -0700 | [diff] [blame] | 335 | foreman_cif.analyzer = {"foreman_cif_500kbps_delay_50_0_plr_3_flexfec", 0.0, |
| 336 | 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 337 | foreman_cif.config->loss_percent = 3; |
| 338 | foreman_cif.config->link_capacity_kbps = 500; |
| 339 | foreman_cif.config->queue_delay_ms = 50; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 340 | fixture->RunWithAnalyzer(foreman_cif); |
stefan | 889d965 | 2017-07-05 03:03:02 -0700 | [diff] [blame] | 341 | } |
| 342 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 343 | TEST(FullStackTest, ForemanCif500kbpsPlr3Ulpfec) { |
| 344 | auto fixture = CreateVideoQualityTestFixture(); |
| 345 | ParamsWithLogging foreman_cif; |
stefan | 889d965 | 2017-07-05 03:03:02 -0700 | [diff] [blame] | 346 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 347 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 348 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 349 | 0, 0, true, false, false, "foreman_cif"}; |
stefan | 889d965 | 2017-07-05 03:03:02 -0700 | [diff] [blame] | 350 | foreman_cif.analyzer = {"foreman_cif_500kbps_delay_50_0_plr_3_ulpfec", 0.0, |
| 351 | 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 352 | foreman_cif.config->loss_percent = 3; |
| 353 | foreman_cif.config->link_capacity_kbps = 500; |
| 354 | foreman_cif.config->queue_delay_ms = 50; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 355 | fixture->RunWithAnalyzer(foreman_cif); |
stefan | 889d965 | 2017-07-05 03:03:02 -0700 | [diff] [blame] | 356 | } |
| 357 | |
brandtr | dd369c6 | 2016-11-16 23:56:57 -0800 | [diff] [blame] | 358 | #if defined(WEBRTC_USE_H264) |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 359 | TEST(FullStackTest, ForemanCifWithoutPacketlossH264) { |
| 360 | auto fixture = CreateVideoQualityTestFixture(); |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 361 | // TODO(pbos): Decide on psnr/ssim thresholds for foreman_cif. |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 362 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 363 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 364 | foreman_cif.video[0] = {true, 352, 288, 30, 700000, |
| 365 | 700000, 700000, false, "H264", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 366 | 0, 0, false, false, false, "foreman_cif"}; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 367 | foreman_cif.analyzer = {"foreman_cif_net_delay_0_0_plr_0_H264", 0.0, 0.0, |
| 368 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 369 | fixture->RunWithAnalyzer(foreman_cif); |
brandtr | dd369c6 | 2016-11-16 23:56:57 -0800 | [diff] [blame] | 370 | } |
| 371 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 372 | TEST(FullStackTest, ForemanCif30kbpsWithoutPacketlossH264) { |
| 373 | auto fixture = CreateVideoQualityTestFixture(); |
| 374 | ParamsWithLogging foreman_cif; |
asapersson | fb6ad3b | 2016-12-16 06:54:01 -0800 | [diff] [blame] | 375 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 376 | foreman_cif.video[0] = {true, 352, 288, 10, 30000, |
| 377 | 30000, 30000, false, "H264", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 378 | 0, 0, false, false, false, "foreman_cif"}; |
asapersson | fb6ad3b | 2016-12-16 06:54:01 -0800 | [diff] [blame] | 379 | foreman_cif.analyzer = {"foreman_cif_30kbps_net_delay_0_0_plr_0_H264", 0.0, |
| 380 | 0.0, kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 381 | fixture->RunWithAnalyzer(foreman_cif); |
asapersson | fb6ad3b | 2016-12-16 06:54:01 -0800 | [diff] [blame] | 382 | } |
| 383 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 384 | TEST_P(GenericDescriptorTest, ForemanCifPlr5H264) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 385 | auto fixture = CreateVideoQualityTestFixture(); |
| 386 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 387 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 388 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 389 | 500000, 2000000, false, "H264", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 390 | 0, 0, false, false, false, "foreman_cif"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 391 | foreman_cif.analyzer = {GetTestName("foreman_cif_delay_50_0_plr_5_H264"), 0.0, |
| 392 | 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 393 | foreman_cif.config->loss_percent = 5; |
| 394 | foreman_cif.config->queue_delay_ms = 50; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 395 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 396 | fixture->RunWithAnalyzer(foreman_cif); |
brandtr | dd369c6 | 2016-11-16 23:56:57 -0800 | [diff] [blame] | 397 | } |
| 398 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 399 | TEST(FullStackTest, ForemanCifPlr5H264SpsPpsIdrIsKeyframe) { |
Rasmus Brandt | 88f080a | 2017-11-02 14:28:06 +0100 | [diff] [blame] | 400 | test::ScopedFieldTrials override_field_trials( |
Erik Språng | b6b1cac | 2018-08-09 16:12:54 +0200 | [diff] [blame] | 401 | AppendFieldTrials("WebRTC-SpsPpsIdrIsH264Keyframe/Enabled/")); |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 402 | auto fixture = CreateVideoQualityTestFixture(); |
Rasmus Brandt | 88f080a | 2017-11-02 14:28:06 +0100 | [diff] [blame] | 403 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 404 | ParamsWithLogging foreman_cif; |
Rasmus Brandt | 88f080a | 2017-11-02 14:28:06 +0100 | [diff] [blame] | 405 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 406 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 407 | 500000, 2000000, false, "H264", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 408 | 0, 0, false, false, false, "foreman_cif"}; |
Rasmus Brandt | 88f080a | 2017-11-02 14:28:06 +0100 | [diff] [blame] | 409 | foreman_cif.analyzer = {"foreman_cif_delay_50_0_plr_5_H264_sps_pps_idr", 0.0, |
| 410 | 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 411 | foreman_cif.config->loss_percent = 5; |
| 412 | foreman_cif.config->queue_delay_ms = 50; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 413 | fixture->RunWithAnalyzer(foreman_cif); |
Rasmus Brandt | 88f080a | 2017-11-02 14:28:06 +0100 | [diff] [blame] | 414 | } |
| 415 | |
brandtr | dd369c6 | 2016-11-16 23:56:57 -0800 | [diff] [blame] | 416 | // Verify that this is worth the bot time, before enabling. |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 417 | TEST(FullStackTest, ForemanCifPlr5H264Flexfec) { |
| 418 | auto fixture = CreateVideoQualityTestFixture(); |
| 419 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 420 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 421 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 422 | 500000, 2000000, false, "H264", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 423 | 0, 0, false, true, false, "foreman_cif"}; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 424 | foreman_cif.analyzer = {"foreman_cif_delay_50_0_plr_5_H264_flexfec", 0.0, 0.0, |
| 425 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 426 | foreman_cif.config->loss_percent = 5; |
| 427 | foreman_cif.config->queue_delay_ms = 50; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 428 | fixture->RunWithAnalyzer(foreman_cif); |
brandtr | dd369c6 | 2016-11-16 23:56:57 -0800 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | // Ulpfec with H264 is an unsupported combination, so this test is only useful |
| 432 | // for debugging. It is therefore disabled by default. |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 433 | TEST(FullStackTest, DISABLED_ForemanCifPlr5H264Ulpfec) { |
| 434 | auto fixture = CreateVideoQualityTestFixture(); |
| 435 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 436 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 437 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 438 | 500000, 2000000, false, "H264", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 439 | 0, 0, true, false, false, "foreman_cif"}; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 440 | foreman_cif.analyzer = {"foreman_cif_delay_50_0_plr_5_H264_ulpfec", 0.0, 0.0, |
| 441 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 442 | foreman_cif.config->loss_percent = 5; |
| 443 | foreman_cif.config->queue_delay_ms = 50; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 444 | fixture->RunWithAnalyzer(foreman_cif); |
brandtr | dd369c6 | 2016-11-16 23:56:57 -0800 | [diff] [blame] | 445 | } |
| 446 | #endif // defined(WEBRTC_USE_H264) |
| 447 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 448 | TEST(FullStackTest, ForemanCif500kbps) { |
| 449 | auto fixture = CreateVideoQualityTestFixture(); |
| 450 | ParamsWithLogging foreman_cif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 451 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 452 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 453 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 454 | 0, 0, false, false, false, "foreman_cif"}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 455 | foreman_cif.analyzer = {"foreman_cif_500kbps", 0.0, 0.0, |
| 456 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 457 | foreman_cif.config->queue_length_packets = 0; |
| 458 | foreman_cif.config->queue_delay_ms = 0; |
| 459 | foreman_cif.config->link_capacity_kbps = 500; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 460 | fixture->RunWithAnalyzer(foreman_cif); |
stefan@webrtc.org | b8e9e44 | 2014-07-09 11:29:06 +0000 | [diff] [blame] | 461 | } |
| 462 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 463 | TEST(FullStackTest, ForemanCif500kbpsLimitedQueue) { |
| 464 | auto fixture = CreateVideoQualityTestFixture(); |
| 465 | ParamsWithLogging foreman_cif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 466 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 467 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 468 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 469 | 0, 0, false, false, false, "foreman_cif"}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 470 | foreman_cif.analyzer = {"foreman_cif_500kbps_32pkts_queue", 0.0, 0.0, |
| 471 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 472 | foreman_cif.config->queue_length_packets = 32; |
| 473 | foreman_cif.config->queue_delay_ms = 0; |
| 474 | foreman_cif.config->link_capacity_kbps = 500; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 475 | fixture->RunWithAnalyzer(foreman_cif); |
stefan@webrtc.org | b8e9e44 | 2014-07-09 11:29:06 +0000 | [diff] [blame] | 476 | } |
| 477 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 478 | TEST(FullStackTest, ForemanCif500kbps100ms) { |
| 479 | auto fixture = CreateVideoQualityTestFixture(); |
| 480 | ParamsWithLogging foreman_cif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 481 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 482 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 483 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 484 | 0, 0, false, false, false, "foreman_cif"}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 485 | foreman_cif.analyzer = {"foreman_cif_500kbps_100ms", 0.0, 0.0, |
| 486 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 487 | foreman_cif.config->queue_length_packets = 0; |
| 488 | foreman_cif.config->queue_delay_ms = 100; |
| 489 | foreman_cif.config->link_capacity_kbps = 500; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 490 | fixture->RunWithAnalyzer(foreman_cif); |
stefan@webrtc.org | b8e9e44 | 2014-07-09 11:29:06 +0000 | [diff] [blame] | 491 | } |
| 492 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 493 | TEST_P(GenericDescriptorTest, ForemanCif500kbps100msLimitedQueue) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 494 | auto fixture = CreateVideoQualityTestFixture(); |
| 495 | ParamsWithLogging foreman_cif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 496 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 497 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 498 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 499 | 0, 0, false, false, false, "foreman_cif"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 500 | foreman_cif.analyzer = {GetTestName("foreman_cif_500kbps_100ms_32pkts_queue"), |
| 501 | 0.0, 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 502 | foreman_cif.config->queue_length_packets = 32; |
| 503 | foreman_cif.config->queue_delay_ms = 100; |
| 504 | foreman_cif.config->link_capacity_kbps = 500; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 505 | foreman_cif.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 506 | fixture->RunWithAnalyzer(foreman_cif); |
stefan | b179767 | 2016-08-11 07:00:57 -0700 | [diff] [blame] | 507 | } |
| 508 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 509 | TEST(FullStackTest, ForemanCif500kbps100msLimitedQueueRecvBwe) { |
| 510 | auto fixture = CreateVideoQualityTestFixture(); |
| 511 | ParamsWithLogging foreman_cif; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 512 | foreman_cif.call.send_side_bwe = false; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 513 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 514 | 500000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 515 | 0, 0, false, false, false, "foreman_cif"}; |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 516 | foreman_cif.analyzer = {"foreman_cif_500kbps_100ms_32pkts_queue_recv_bwe", |
| 517 | 0.0, 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 518 | foreman_cif.config->queue_length_packets = 32; |
| 519 | foreman_cif.config->queue_delay_ms = 100; |
| 520 | foreman_cif.config->link_capacity_kbps = 500; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 521 | fixture->RunWithAnalyzer(foreman_cif); |
stefan@webrtc.org | b8e9e44 | 2014-07-09 11:29:06 +0000 | [diff] [blame] | 522 | } |
| 523 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 524 | TEST(FullStackTest, ForemanCif1000kbps100msLimitedQueue) { |
| 525 | auto fixture = CreateVideoQualityTestFixture(); |
| 526 | ParamsWithLogging foreman_cif; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 527 | foreman_cif.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 528 | foreman_cif.video[0] = {true, 352, 288, 30, 30000, |
| 529 | 2000000, 2000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 530 | 0, 0, false, false, false, "foreman_cif"}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 531 | foreman_cif.analyzer = {"foreman_cif_1000kbps_100ms_32pkts_queue", 0.0, 0.0, |
| 532 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 533 | foreman_cif.config->queue_length_packets = 32; |
| 534 | foreman_cif.config->queue_delay_ms = 100; |
| 535 | foreman_cif.config->link_capacity_kbps = 1000; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 536 | fixture->RunWithAnalyzer(foreman_cif); |
stefan@webrtc.org | b8e9e44 | 2014-07-09 11:29:06 +0000 | [diff] [blame] | 537 | } |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 538 | |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 539 | // TODO(sprang): Remove this if we have the similar ModerateLimits below? |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 540 | TEST(FullStackTest, ConferenceMotionHd2000kbps100msLimitedQueue) { |
| 541 | auto fixture = CreateVideoQualityTestFixture(); |
| 542 | ParamsWithLogging conf_motion_hd; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 543 | conf_motion_hd.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 544 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 545 | true, 1280, 720, 50, 30000, |
| 546 | 3000000, 3000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 547 | 0, 0, false, false, false, "ConferenceMotion_1280_720_50"}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 548 | conf_motion_hd.analyzer = {"conference_motion_hd_2000kbps_100ms_32pkts_queue", |
| 549 | 0.0, 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 550 | conf_motion_hd.config->queue_length_packets = 32; |
| 551 | conf_motion_hd.config->queue_delay_ms = 100; |
| 552 | conf_motion_hd.config->link_capacity_kbps = 2000; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 553 | fixture->RunWithAnalyzer(conf_motion_hd); |
stefan | b179767 | 2016-08-11 07:00:57 -0700 | [diff] [blame] | 554 | } |
| 555 | |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 556 | // TODO(webrtc:9722): Remove when experiment is cleaned up. |
| 557 | TEST(FullStackTest, ConferenceMotionHd1TLModerateLimitsWhitelistVp8) { |
| 558 | test::ScopedFieldTrials override_field_trials( |
| 559 | AppendFieldTrials(kVp8TrustedRateControllerFieldTrial)); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 560 | auto fixture = CreateVideoQualityTestFixture(); |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 561 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 562 | ParamsWithLogging conf_motion_hd; |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 563 | conf_motion_hd.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 564 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 565 | true, 1280, 720, 50, 30000, |
| 566 | 3000000, 3000000, false, "VP8", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 567 | -1, 0, false, false, false, "ConferenceMotion_1280_720_50"}; |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 568 | conf_motion_hd.analyzer = { |
| 569 | "conference_motion_hd_1tl_moderate_limits_trusted_rate_ctrl", 0.0, 0.0, |
| 570 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 571 | conf_motion_hd.config->queue_length_packets = 50; |
| 572 | conf_motion_hd.config->loss_percent = 3; |
| 573 | conf_motion_hd.config->queue_delay_ms = 100; |
| 574 | conf_motion_hd.config->link_capacity_kbps = 2000; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 575 | fixture->RunWithAnalyzer(conf_motion_hd); |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 576 | } |
| 577 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 578 | TEST_P(GenericDescriptorTest, ConferenceMotionHd2TLModerateLimits) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 579 | auto fixture = CreateVideoQualityTestFixture(); |
| 580 | ParamsWithLogging conf_motion_hd; |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 581 | conf_motion_hd.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 582 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 583 | true, 1280, 720, 50, 30000, |
| 584 | 3000000, 3000000, false, "VP8", 2, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 585 | -1, 0, false, false, false, "ConferenceMotion_1280_720_50"}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 586 | conf_motion_hd.analyzer = { |
| 587 | GetTestName("conference_motion_hd_2tl_moderate_limits"), 0.0, 0.0, |
| 588 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 589 | conf_motion_hd.config->queue_length_packets = 50; |
| 590 | conf_motion_hd.config->loss_percent = 3; |
| 591 | conf_motion_hd.config->queue_delay_ms = 100; |
| 592 | conf_motion_hd.config->link_capacity_kbps = 2000; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 593 | conf_motion_hd.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 594 | fixture->RunWithAnalyzer(conf_motion_hd); |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 595 | } |
| 596 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 597 | TEST(FullStackTest, ConferenceMotionHd3TLModerateLimits) { |
| 598 | auto fixture = CreateVideoQualityTestFixture(); |
| 599 | ParamsWithLogging conf_motion_hd; |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 600 | conf_motion_hd.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 601 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 602 | true, 1280, 720, 50, 30000, |
| 603 | 3000000, 3000000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 604 | -1, 0, false, false, false, "ConferenceMotion_1280_720_50"}; |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 605 | conf_motion_hd.analyzer = {"conference_motion_hd_3tl_moderate_limits", 0.0, |
| 606 | 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 607 | conf_motion_hd.config->queue_length_packets = 50; |
| 608 | conf_motion_hd.config->loss_percent = 3; |
| 609 | conf_motion_hd.config->queue_delay_ms = 100; |
| 610 | conf_motion_hd.config->link_capacity_kbps = 2000; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 611 | fixture->RunWithAnalyzer(conf_motion_hd); |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 612 | } |
| 613 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 614 | TEST(FullStackTest, ConferenceMotionHd4TLModerateLimits) { |
| 615 | auto fixture = CreateVideoQualityTestFixture(); |
| 616 | ParamsWithLogging conf_motion_hd; |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 617 | conf_motion_hd.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 618 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 619 | true, 1280, 720, 50, 30000, |
| 620 | 3000000, 3000000, false, "VP8", 4, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 621 | -1, 0, false, false, false, "ConferenceMotion_1280_720_50"}; |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 622 | conf_motion_hd.analyzer = {"conference_motion_hd_4tl_moderate_limits", 0.0, |
| 623 | 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 624 | conf_motion_hd.config->queue_length_packets = 50; |
| 625 | conf_motion_hd.config->loss_percent = 3; |
| 626 | conf_motion_hd.config->queue_delay_ms = 100; |
| 627 | conf_motion_hd.config->link_capacity_kbps = 2000; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 628 | fixture->RunWithAnalyzer(conf_motion_hd); |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 629 | } |
| 630 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 631 | TEST(FullStackTest, ConferenceMotionHd3TLModerateLimitsAltTLPattern) { |
Erik Språng | b6b1cac | 2018-08-09 16:12:54 +0200 | [diff] [blame] | 632 | test::ScopedFieldTrials field_trial( |
| 633 | AppendFieldTrials("WebRTC-UseShortVP8TL3Pattern/Enabled/")); |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 634 | auto fixture = CreateVideoQualityTestFixture(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 635 | ParamsWithLogging conf_motion_hd; |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 636 | conf_motion_hd.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 637 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3583693 | 2018-10-23 09:17:24 +0200 | [diff] [blame] | 638 | true, 1280, 720, 50, |
| 639 | 30000, 3000000, 3000000, false, |
| 640 | "VP8", 3, -1, 0, |
| 641 | false, false, false, "ConferenceMotion_1280_720_50"}; |
| 642 | conf_motion_hd.analyzer = {"conference_motion_hd_3tl_alt_moderate_limits", |
| 643 | 0.0, 0.0, kFullStackTestDurationSecs}; |
| 644 | conf_motion_hd.config->queue_length_packets = 50; |
| 645 | conf_motion_hd.config->loss_percent = 3; |
| 646 | conf_motion_hd.config->queue_delay_ms = 100; |
| 647 | conf_motion_hd.config->link_capacity_kbps = 2000; |
| 648 | fixture->RunWithAnalyzer(conf_motion_hd); |
| 649 | } |
| 650 | |
| 651 | TEST(FullStackTest, |
| 652 | ConferenceMotionHd3TLModerateLimitsAltTLPatternAndBaseHeavyTLAllocation) { |
| 653 | auto fixture = CreateVideoQualityTestFixture(); |
| 654 | test::ScopedFieldTrials field_trial( |
| 655 | AppendFieldTrials("WebRTC-UseShortVP8TL3Pattern/Enabled/" |
| 656 | "WebRTC-UseBaseHeavyVP8TL3RateAllocation/Enabled/")); |
| 657 | ParamsWithLogging conf_motion_hd; |
| 658 | conf_motion_hd.call.send_side_bwe = true; |
| 659 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 660 | true, 1280, 720, 50, 30000, |
| 661 | 3000000, 3000000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 662 | -1, 0, false, false, false, "ConferenceMotion_1280_720_50"}; |
Rasmus Brandt | 3583693 | 2018-10-23 09:17:24 +0200 | [diff] [blame] | 663 | conf_motion_hd.analyzer = { |
| 664 | "conference_motion_hd_3tl_alt_heavy_moderate_limits", 0.0, 0.0, |
| 665 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 666 | conf_motion_hd.config->queue_length_packets = 50; |
| 667 | conf_motion_hd.config->loss_percent = 3; |
| 668 | conf_motion_hd.config->queue_delay_ms = 100; |
| 669 | conf_motion_hd.config->link_capacity_kbps = 2000; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 670 | fixture->RunWithAnalyzer(conf_motion_hd); |
sprang | ff19d35 | 2017-09-06 07:14:02 -0700 | [diff] [blame] | 671 | } |
| 672 | |
Mirko Bonadei | 8ef5793 | 2018-11-16 14:38:03 +0100 | [diff] [blame] | 673 | #if defined(RTC_ENABLE_VP9) |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 674 | TEST(FullStackTest, ConferenceMotionHd2000kbps100msLimitedQueueVP9) { |
| 675 | auto fixture = CreateVideoQualityTestFixture(); |
| 676 | ParamsWithLogging conf_motion_hd; |
jianj | 390e64d | 2017-02-03 09:51:23 -0800 | [diff] [blame] | 677 | conf_motion_hd.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 678 | conf_motion_hd.video[0] = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 679 | true, 1280, 720, 50, 30000, |
| 680 | 3000000, 3000000, false, "VP9", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 681 | 0, 0, false, false, false, "ConferenceMotion_1280_720_50"}; |
jianj | 390e64d | 2017-02-03 09:51:23 -0800 | [diff] [blame] | 682 | conf_motion_hd.analyzer = { |
| 683 | "conference_motion_hd_2000kbps_100ms_32pkts_queue_vp9", 0.0, 0.0, |
| 684 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 685 | conf_motion_hd.config->queue_length_packets = 32; |
| 686 | conf_motion_hd.config->queue_delay_ms = 100; |
| 687 | conf_motion_hd.config->link_capacity_kbps = 2000; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 688 | fixture->RunWithAnalyzer(conf_motion_hd); |
jianj | 390e64d | 2017-02-03 09:51:23 -0800 | [diff] [blame] | 689 | } |
| 690 | #endif |
| 691 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 692 | TEST(FullStackTest, ScreenshareSlidesVP8_2TL) { |
| 693 | auto fixture = CreateVideoQualityTestFixture(); |
| 694 | ParamsWithLogging screenshare; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 695 | screenshare.call.send_side_bwe = true; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 696 | screenshare.video[0] = {true, 1850, 1110, 5, 50000, 200000, |
| 697 | 1000000, false, "VP8", 2, 1, 400000, |
| 698 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 699 | screenshare.screenshare[0] = {true, false, 10}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 700 | screenshare.analyzer = {"screenshare_slides", 0.0, 0.0, |
| 701 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 702 | fixture->RunWithAnalyzer(screenshare); |
Erik Språng | 6ee69aa | 2015-09-03 15:58:05 +0200 | [diff] [blame] | 703 | } |
| 704 | |
Ilya Nikolaevskiy | f08dd9d | 2018-10-09 17:22:15 +0200 | [diff] [blame] | 705 | #if !defined(WEBRTC_MAC) |
Oskar Sundbom | 8bacf25 | 2019-01-08 16:40:08 +0100 | [diff] [blame^] | 706 | // All the tests using this constant are disabled on Mac. |
Ilya Nikolaevskiy | f08dd9d | 2018-10-09 17:22:15 +0200 | [diff] [blame] | 707 | const char kScreenshareSimulcastExperiment[] = |
| 708 | "WebRTC-SimulcastScreenshare/Enabled/"; |
| 709 | |
Oskar Sundbom | 8bacf25 | 2019-01-08 16:40:08 +0100 | [diff] [blame^] | 710 | // TODO(bugs.webrtc.org/9840): Investigate why is this test flaky on Win/Mac. |
| 711 | #if !defined(WEBRTC_WIN) |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 712 | TEST(FullStackTest, ScreenshareSlidesVP8_3TL_Simulcast) { |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 713 | test::ScopedFieldTrials field_trial( |
| 714 | AppendFieldTrials(kScreenshareSimulcastExperiment)); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 715 | auto fixture = CreateVideoQualityTestFixture(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 716 | ParamsWithLogging screenshare; |
ilnik | cb8c146 | 2017-03-09 09:23:30 -0800 | [diff] [blame] | 717 | screenshare.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 718 | screenshare.screenshare[0] = {true, false, 10}; |
| 719 | screenshare.video[0] = {true, 1850, 1110, 5, 800000, |
| 720 | 2500000, 2500000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 721 | 2, 400000, false, false, false, ""}; |
ilnik | cb8c146 | 2017-03-09 09:23:30 -0800 | [diff] [blame] | 722 | screenshare.analyzer = {"screenshare_slides_simulcast", 0.0, 0.0, |
| 723 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 724 | ParamsWithLogging screenshare_params_high; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 725 | screenshare_params_high.video[0] = {true, 1850, 1110, 5, 400000, 1000000, |
| 726 | 1000000, false, "VP8", 3, 0, 400000, |
| 727 | false, false, false, ""}; |
ilnik | cb8c146 | 2017-03-09 09:23:30 -0800 | [diff] [blame] | 728 | VideoQualityTest::Params screenshare_params_low; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 729 | screenshare_params_low.video[0] = {true, 1850, 1110, 5, 50000, 200000, |
| 730 | 1000000, false, "VP8", 2, 0, 400000, |
| 731 | false, false, false, ""}; |
ilnik | cb8c146 | 2017-03-09 09:23:30 -0800 | [diff] [blame] | 732 | |
| 733 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 734 | VideoQualityTest::DefaultVideoStream(screenshare_params_low, 0), |
| 735 | VideoQualityTest::DefaultVideoStream(screenshare_params_high, 0)}; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 736 | screenshare.ss[0] = { |
| 737 | streams, 1, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 738 | false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 739 | fixture->RunWithAnalyzer(screenshare); |
ilnik | cb8c146 | 2017-03-09 09:23:30 -0800 | [diff] [blame] | 740 | } |
Oskar Sundbom | 8bacf25 | 2019-01-08 16:40:08 +0100 | [diff] [blame^] | 741 | #endif // !defined(WEBRTC_WIN) |
Ilya Nikolaevskiy | f08dd9d | 2018-10-09 17:22:15 +0200 | [diff] [blame] | 742 | #endif // !defined(WEBRTC_MAC) |
ilnik | cb8c146 | 2017-03-09 09:23:30 -0800 | [diff] [blame] | 743 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 744 | TEST(FullStackTest, ScreenshareSlidesVP8_2TL_Scroll) { |
| 745 | auto fixture = CreateVideoQualityTestFixture(); |
| 746 | ParamsWithLogging config; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 747 | config.call.send_side_bwe = true; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 748 | config.video[0] = {true, 1850, 1110 / 2, 5, 50000, 200000, |
| 749 | 1000000, false, "VP8", 2, 1, 400000, |
| 750 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 751 | config.screenshare[0] = {true, false, 10, 2}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 752 | config.analyzer = {"screenshare_slides_scrolling", 0.0, 0.0, |
| 753 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 754 | fixture->RunWithAnalyzer(config); |
ivica | 028cf48 | 2015-07-30 02:15:56 -0700 | [diff] [blame] | 755 | } |
| 756 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 757 | TEST_P(GenericDescriptorTest, ScreenshareSlidesVP8_2TL_LossyNet) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 758 | auto fixture = CreateVideoQualityTestFixture(); |
| 759 | ParamsWithLogging screenshare; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 760 | screenshare.call.send_side_bwe = true; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 761 | screenshare.video[0] = {true, 1850, 1110, 5, 50000, 200000, |
| 762 | 1000000, false, "VP8", 2, 1, 400000, |
| 763 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 764 | screenshare.screenshare[0] = {true, false, 10}; |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 765 | screenshare.analyzer = {GetTestName("screenshare_slides_lossy_net"), 0.0, 0.0, |
Lu Liu | 6f68324 | 2018-09-25 18:48:48 +0000 | [diff] [blame] | 766 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 767 | screenshare.config->loss_percent = 5; |
| 768 | screenshare.config->queue_delay_ms = 200; |
| 769 | screenshare.config->link_capacity_kbps = 500; |
philipel | f638bbc | 2018-10-04 16:57:12 +0200 | [diff] [blame] | 770 | screenshare.call.generic_descriptor = GenericDescriptorEnabled(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 771 | fixture->RunWithAnalyzer(screenshare); |
sprang | ee37de3 | 2015-11-23 06:10:23 -0800 | [diff] [blame] | 772 | } |
| 773 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 774 | TEST(FullStackTest, ScreenshareSlidesVP8_2TL_VeryLossyNet) { |
| 775 | auto fixture = CreateVideoQualityTestFixture(); |
| 776 | ParamsWithLogging screenshare; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 777 | screenshare.call.send_side_bwe = true; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 778 | screenshare.video[0] = {true, 1850, 1110, 5, 50000, 200000, |
| 779 | 1000000, false, "VP8", 2, 1, 400000, |
| 780 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 781 | screenshare.screenshare[0] = {true, false, 10}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 782 | screenshare.analyzer = {"screenshare_slides_very_lossy", 0.0, 0.0, |
| 783 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 784 | screenshare.config->loss_percent = 10; |
| 785 | screenshare.config->queue_delay_ms = 200; |
| 786 | screenshare.config->link_capacity_kbps = 500; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 787 | fixture->RunWithAnalyzer(screenshare); |
sprang | ee37de3 | 2015-11-23 06:10:23 -0800 | [diff] [blame] | 788 | } |
| 789 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 790 | TEST(FullStackTest, ScreenshareSlidesVP8_2TL_LossyNetRestrictedQueue) { |
| 791 | auto fixture = CreateVideoQualityTestFixture(); |
| 792 | ParamsWithLogging screenshare; |
sprang | e566e17 | 2017-06-08 01:29:15 -0700 | [diff] [blame] | 793 | screenshare.call.send_side_bwe = true; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 794 | screenshare.video[0] = {true, 1850, 1110, 5, 50000, 200000, |
| 795 | 1000000, false, "VP8", 2, 1, 400000, |
| 796 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 797 | screenshare.screenshare[0] = {true, false, 10}; |
sprang | e566e17 | 2017-06-08 01:29:15 -0700 | [diff] [blame] | 798 | screenshare.analyzer = {"screenshare_slides_lossy_limited", 0.0, 0.0, |
| 799 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 800 | screenshare.config->loss_percent = 5; |
| 801 | screenshare.config->link_capacity_kbps = 200; |
| 802 | screenshare.config->queue_length_packets = 30; |
sprang | e566e17 | 2017-06-08 01:29:15 -0700 | [diff] [blame] | 803 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 804 | fixture->RunWithAnalyzer(screenshare); |
sprang | e566e17 | 2017-06-08 01:29:15 -0700 | [diff] [blame] | 805 | } |
| 806 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 807 | TEST(FullStackTest, ScreenshareSlidesVP8_2TL_ModeratelyRestricted) { |
| 808 | auto fixture = CreateVideoQualityTestFixture(); |
| 809 | ParamsWithLogging screenshare; |
sprang | 89c4a7e | 2017-06-30 13:27:40 -0700 | [diff] [blame] | 810 | screenshare.call.send_side_bwe = true; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 811 | screenshare.video[0] = {true, 1850, 1110, 5, 50000, 200000, |
| 812 | 1000000, false, "VP8", 2, 1, 400000, |
| 813 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 814 | screenshare.screenshare[0] = {true, false, 10}; |
sprang | 89c4a7e | 2017-06-30 13:27:40 -0700 | [diff] [blame] | 815 | screenshare.analyzer = {"screenshare_slides_moderately_restricted", 0.0, 0.0, |
| 816 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 817 | screenshare.config->loss_percent = 1; |
| 818 | screenshare.config->link_capacity_kbps = 1200; |
| 819 | screenshare.config->queue_length_packets = 30; |
sprang | 89c4a7e | 2017-06-30 13:27:40 -0700 | [diff] [blame] | 820 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 821 | fixture->RunWithAnalyzer(screenshare); |
sprang | 89c4a7e | 2017-06-30 13:27:40 -0700 | [diff] [blame] | 822 | } |
| 823 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 824 | const ParamsWithLogging::Video kSvcVp9Video = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 825 | true, 1280, 720, 30, 800000, |
| 826 | 2500000, 2500000, false, "VP9", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 827 | 2, 400000, false, false, false, "ConferenceMotion_1280_720_50"}; |
ilnik | 566c43b | 2017-03-07 04:42:54 -0800 | [diff] [blame] | 828 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 829 | const ParamsWithLogging::Video kSimulcastVp8VideoHigh = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 830 | true, 1280, 720, 30, 800000, |
| 831 | 2500000, 2500000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 832 | 2, 400000, false, false, false, "ConferenceMotion_1280_720_50"}; |
ilnik | 566c43b | 2017-03-07 04:42:54 -0800 | [diff] [blame] | 833 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 834 | const ParamsWithLogging::Video kSimulcastVp8VideoMedium = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 835 | true, 640, 360, 30, 150000, |
| 836 | 500000, 700000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 837 | 2, 400000, false, false, false, "ConferenceMotion_1280_720_50"}; |
ilnik | 566c43b | 2017-03-07 04:42:54 -0800 | [diff] [blame] | 838 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 839 | const ParamsWithLogging::Video kSimulcastVp8VideoLow = { |
Rasmus Brandt | 3102734 | 2017-09-29 13:48:12 +0000 | [diff] [blame] | 840 | true, 320, 180, 30, 30000, |
| 841 | 150000, 200000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 842 | 2, 400000, false, false, false, "ConferenceMotion_1280_720_50"}; |
ilnik | 566c43b | 2017-03-07 04:42:54 -0800 | [diff] [blame] | 843 | |
Mirko Bonadei | 8ef5793 | 2018-11-16 14:38:03 +0100 | [diff] [blame] | 844 | #if defined(RTC_ENABLE_VP9) |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 845 | TEST(FullStackTest, ScreenshareSlidesVP9_2SL) { |
| 846 | auto fixture = CreateVideoQualityTestFixture(); |
| 847 | ParamsWithLogging screenshare; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 848 | screenshare.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 849 | screenshare.video[0] = {true, 1850, 1110, 5, 50000, |
| 850 | 200000, 2000000, false, "VP9", 1, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 851 | 0, 400000, false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 852 | screenshare.screenshare[0] = {true, false, 10}; |
minyue | 626bc95 | 2016-10-31 05:47:02 -0700 | [diff] [blame] | 853 | screenshare.analyzer = {"screenshare_slides_vp9_2sl", 0.0, 0.0, |
| 854 | kFullStackTestDurationSecs}; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 855 | screenshare.ss[0] = { |
| 856 | std::vector<VideoStream>(), 0, 2, 1, InterLayerPredMode::kOn, |
| 857 | std::vector<SpatialLayer>(), false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 858 | fixture->RunWithAnalyzer(screenshare); |
sprang@webrtc.org | 131bea8 | 2015-02-18 12:46:06 +0000 | [diff] [blame] | 859 | } |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 860 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 861 | TEST(FullStackTest, VP9SVC_3SL_High) { |
| 862 | auto fixture = CreateVideoQualityTestFixture(); |
| 863 | ParamsWithLogging simulcast; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 864 | simulcast.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 865 | simulcast.video[0] = kSvcVp9Video; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 866 | simulcast.analyzer = {"vp9svc_3sl_high", 0.0, 0.0, |
| 867 | kFullStackTestDurationSecs}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 868 | |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 869 | simulcast.ss[0] = { |
| 870 | std::vector<VideoStream>(), 0, 3, 2, InterLayerPredMode::kOn, |
| 871 | std::vector<SpatialLayer>(), false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 872 | fixture->RunWithAnalyzer(simulcast); |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 873 | } |
| 874 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 875 | TEST(FullStackTest, VP9SVC_3SL_Medium) { |
| 876 | auto fixture = CreateVideoQualityTestFixture(); |
| 877 | ParamsWithLogging simulcast; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 878 | simulcast.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 879 | simulcast.video[0] = kSvcVp9Video; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 880 | simulcast.analyzer = {"vp9svc_3sl_medium", 0.0, 0.0, |
| 881 | kFullStackTestDurationSecs}; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 882 | simulcast.ss[0] = { |
| 883 | std::vector<VideoStream>(), 0, 3, 1, InterLayerPredMode::kOn, |
| 884 | std::vector<SpatialLayer>(), false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 885 | fixture->RunWithAnalyzer(simulcast); |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 886 | } |
| 887 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 888 | TEST(FullStackTest, VP9SVC_3SL_Low) { |
| 889 | auto fixture = CreateVideoQualityTestFixture(); |
| 890 | ParamsWithLogging simulcast; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 891 | simulcast.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 892 | simulcast.video[0] = kSvcVp9Video; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 893 | simulcast.analyzer = {"vp9svc_3sl_low", 0.0, 0.0, kFullStackTestDurationSecs}; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 894 | simulcast.ss[0] = { |
| 895 | std::vector<VideoStream>(), 0, 3, 0, InterLayerPredMode::kOn, |
| 896 | std::vector<SpatialLayer>(), false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 897 | fixture->RunWithAnalyzer(simulcast); |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 898 | } |
Sergey Silkin | 0643fd6 | 2018-05-17 12:50:53 +0200 | [diff] [blame] | 899 | |
Sergey Silkin | 7f978f1 | 2018-09-10 12:01:49 +0000 | [diff] [blame] | 900 | // bugs.webrtc.org/9506 |
| 901 | #if !defined(WEBRTC_MAC) |
| 902 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 903 | TEST(FullStackTest, VP9KSVC_3SL_High) { |
Sergey Silkin | e7ce888 | 2018-10-03 18:04:57 +0200 | [diff] [blame] | 904 | webrtc::test::ScopedFieldTrials override_trials( |
| 905 | AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/")); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 906 | auto fixture = CreateVideoQualityTestFixture(); |
| 907 | ParamsWithLogging simulcast; |
Sergey Silkin | 0643fd6 | 2018-05-17 12:50:53 +0200 | [diff] [blame] | 908 | simulcast.call.send_side_bwe = true; |
| 909 | simulcast.video[0] = kSvcVp9Video; |
| 910 | simulcast.analyzer = {"vp9ksvc_3sl_high", 0.0, 0.0, |
| 911 | kFullStackTestDurationSecs}; |
| 912 | simulcast.ss[0] = { |
| 913 | std::vector<VideoStream>(), 0, 3, 2, InterLayerPredMode::kOnKeyPic, |
| 914 | std::vector<SpatialLayer>(), false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 915 | fixture->RunWithAnalyzer(simulcast); |
Sergey Silkin | 0643fd6 | 2018-05-17 12:50:53 +0200 | [diff] [blame] | 916 | } |
| 917 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 918 | TEST(FullStackTest, VP9KSVC_3SL_Medium) { |
Sergey Silkin | e7ce888 | 2018-10-03 18:04:57 +0200 | [diff] [blame] | 919 | webrtc::test::ScopedFieldTrials override_trials( |
| 920 | AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/")); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 921 | auto fixture = CreateVideoQualityTestFixture(); |
| 922 | ParamsWithLogging simulcast; |
Sergey Silkin | 0643fd6 | 2018-05-17 12:50:53 +0200 | [diff] [blame] | 923 | simulcast.call.send_side_bwe = true; |
| 924 | simulcast.video[0] = kSvcVp9Video; |
| 925 | simulcast.analyzer = {"vp9ksvc_3sl_medium", 0.0, 0.0, |
| 926 | kFullStackTestDurationSecs}; |
| 927 | simulcast.ss[0] = { |
| 928 | std::vector<VideoStream>(), 0, 3, 1, InterLayerPredMode::kOnKeyPic, |
| 929 | std::vector<SpatialLayer>(), false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 930 | fixture->RunWithAnalyzer(simulcast); |
Sergey Silkin | 0643fd6 | 2018-05-17 12:50:53 +0200 | [diff] [blame] | 931 | } |
| 932 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 933 | TEST(FullStackTest, VP9KSVC_3SL_Low) { |
Sergey Silkin | e7ce888 | 2018-10-03 18:04:57 +0200 | [diff] [blame] | 934 | webrtc::test::ScopedFieldTrials override_trials( |
| 935 | AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/")); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 936 | auto fixture = CreateVideoQualityTestFixture(); |
| 937 | ParamsWithLogging simulcast; |
Sergey Silkin | 0643fd6 | 2018-05-17 12:50:53 +0200 | [diff] [blame] | 938 | simulcast.call.send_side_bwe = true; |
| 939 | simulcast.video[0] = kSvcVp9Video; |
| 940 | simulcast.analyzer = {"vp9ksvc_3sl_low", 0.0, 0.0, |
| 941 | kFullStackTestDurationSecs}; |
| 942 | simulcast.ss[0] = { |
| 943 | std::vector<VideoStream>(), 0, 3, 0, InterLayerPredMode::kOnKeyPic, |
| 944 | std::vector<SpatialLayer>(), false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 945 | fixture->RunWithAnalyzer(simulcast); |
Sergey Silkin | 0643fd6 | 2018-05-17 12:50:53 +0200 | [diff] [blame] | 946 | } |
“Michael | 277a656 | 2018-06-01 14:09:19 -0500 | [diff] [blame] | 947 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 948 | TEST(FullStackTest, VP9KSVC_3SL_Medium_Network_Restricted) { |
Sergey Silkin | e7ce888 | 2018-10-03 18:04:57 +0200 | [diff] [blame] | 949 | webrtc::test::ScopedFieldTrials override_trials( |
| 950 | AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/")); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 951 | auto fixture = CreateVideoQualityTestFixture(); |
Niels Möller | 0e90982 | 2018-08-21 17:34:35 +0200 | [diff] [blame] | 952 | ParamsWithLogging simulcast; |
“Michael | 277a656 | 2018-06-01 14:09:19 -0500 | [diff] [blame] | 953 | simulcast.call.send_side_bwe = true; |
| 954 | simulcast.video[0] = kSvcVp9Video; |
| 955 | simulcast.analyzer = {"vp9ksvc_3sl_medium_network_restricted", 0.0, 0.0, |
| 956 | kFullStackTestDurationSecs}; |
| 957 | simulcast.ss[0] = { |
Sergey Silkin | e7ce888 | 2018-10-03 18:04:57 +0200 | [diff] [blame] | 958 | std::vector<VideoStream>(), 0, 3, -1, InterLayerPredMode::kOnKeyPic, |
“Michael | 277a656 | 2018-06-01 14:09:19 -0500 | [diff] [blame] | 959 | std::vector<SpatialLayer>(), false}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 960 | simulcast.config->link_capacity_kbps = 1000; |
Sergey Silkin | e7ce888 | 2018-10-03 18:04:57 +0200 | [diff] [blame] | 961 | simulcast.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 962 | fixture->RunWithAnalyzer(simulcast); |
“Michael | 277a656 | 2018-06-01 14:09:19 -0500 | [diff] [blame] | 963 | } |
Erik Språng | d3438aa | 2018-11-08 16:56:43 +0100 | [diff] [blame] | 964 | |
| 965 | // TODO(webrtc:9722): Remove when experiment is cleaned up. |
| 966 | TEST(FullStackTest, VP9KSVC_3SL_Medium_Network_Restricted_Trusted_Rate) { |
| 967 | webrtc::test::ScopedFieldTrials override_trials( |
| 968 | AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/" |
| 969 | "WebRTC-LibvpxVp9TrustedRateController/Enabled/")); |
| 970 | auto fixture = CreateVideoQualityTestFixture(); |
| 971 | ParamsWithLogging simulcast; |
| 972 | simulcast.call.send_side_bwe = true; |
| 973 | simulcast.video[0] = kSvcVp9Video; |
| 974 | simulcast.analyzer = {"vp9ksvc_3sl_medium_network_restricted_trusted_rate", |
| 975 | 0.0, 0.0, kFullStackTestDurationSecs}; |
| 976 | simulcast.ss[0] = { |
| 977 | std::vector<VideoStream>(), 0, 3, -1, InterLayerPredMode::kOnKeyPic, |
| 978 | std::vector<SpatialLayer>(), false}; |
| 979 | simulcast.config->link_capacity_kbps = 1000; |
| 980 | simulcast.config->queue_delay_ms = 100; |
| 981 | fixture->RunWithAnalyzer(simulcast); |
| 982 | } |
Sergey Silkin | 7f978f1 | 2018-09-10 12:01:49 +0000 | [diff] [blame] | 983 | #endif // !defined(WEBRTC_MAC) |
| 984 | |
Mirko Bonadei | 8ef5793 | 2018-11-16 14:38:03 +0100 | [diff] [blame] | 985 | #endif // defined(RTC_ENABLE_VP9) |
brandtr | 93c5d03 | 2016-11-30 07:50:07 -0800 | [diff] [blame] | 986 | |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 987 | // Android bots can't handle FullHD, so disable the test. |
Ilya Nikolaevskiy | 7e5203f | 2018-09-10 12:04:50 +0000 | [diff] [blame] | 988 | // TODO(bugs.webrtc.org/9220): Investigate source of flakiness on Mac. |
| 989 | #if defined(WEBRTC_ANDROID) || defined(WEBRTC_MAC) |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 990 | #define MAYBE_SimulcastFullHdOveruse DISABLED_SimulcastFullHdOveruse |
| 991 | #else |
| 992 | #define MAYBE_SimulcastFullHdOveruse SimulcastFullHdOveruse |
| 993 | #endif |
| 994 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 995 | TEST(FullStackTest, MAYBE_SimulcastFullHdOveruse) { |
| 996 | auto fixture = CreateVideoQualityTestFixture(); |
| 997 | ParamsWithLogging simulcast; |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 998 | simulcast.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 999 | simulcast.video[0] = {true, 1920, 1080, 30, 800000, |
| 1000 | 2500000, 2500000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 1001 | 2, 400000, false, false, false, "Generator"}; |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 1002 | simulcast.analyzer = {"simulcast_HD_high", 0.0, 0.0, |
| 1003 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1004 | simulcast.config->loss_percent = 0; |
| 1005 | simulcast.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1006 | std::vector<VideoStream> streams = { |
| 1007 | VideoQualityTest::DefaultVideoStream(simulcast, 0), |
| 1008 | VideoQualityTest::DefaultVideoStream(simulcast, 0), |
| 1009 | VideoQualityTest::DefaultVideoStream(simulcast, 0) |
| 1010 | }; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1011 | simulcast.ss[0] = { |
| 1012 | streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1013 | true}; |
Erik Språng | b6b1cac | 2018-08-09 16:12:54 +0200 | [diff] [blame] | 1014 | webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials( |
| 1015 | "WebRTC-ForceSimulatedOveruseIntervalMs/1000-50000-300/")); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1016 | fixture->RunWithAnalyzer(simulcast); |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 1017 | } |
| 1018 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1019 | TEST(FullStackTest, SimulcastVP8_3SL_High) { |
| 1020 | auto fixture = CreateVideoQualityTestFixture(); |
| 1021 | ParamsWithLogging simulcast; |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1022 | simulcast.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1023 | simulcast.video[0] = kSimulcastVp8VideoHigh; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 1024 | simulcast.analyzer = {"simulcast_vp8_3sl_high", 0.0, 0.0, |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1025 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1026 | simulcast.config->loss_percent = 0; |
| 1027 | simulcast.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1028 | ParamsWithLogging video_params_high; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1029 | video_params_high.video[0] = kSimulcastVp8VideoHigh; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1030 | ParamsWithLogging video_params_medium; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1031 | video_params_medium.video[0] = kSimulcastVp8VideoMedium; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1032 | ParamsWithLogging video_params_low; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1033 | video_params_low.video[0] = kSimulcastVp8VideoLow; |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1034 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1035 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1036 | VideoQualityTest::DefaultVideoStream(video_params_low, 0), |
| 1037 | VideoQualityTest::DefaultVideoStream(video_params_medium, 0), |
| 1038 | VideoQualityTest::DefaultVideoStream(video_params_high, 0)}; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1039 | simulcast.ss[0] = { |
| 1040 | streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1041 | false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1042 | fixture->RunWithAnalyzer(simulcast); |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1043 | } |
| 1044 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1045 | TEST(FullStackTest, SimulcastVP8_3SL_Medium) { |
| 1046 | auto fixture = CreateVideoQualityTestFixture(); |
| 1047 | ParamsWithLogging simulcast; |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1048 | simulcast.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1049 | simulcast.video[0] = kSimulcastVp8VideoHigh; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 1050 | simulcast.analyzer = {"simulcast_vp8_3sl_medium", 0.0, 0.0, |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1051 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1052 | simulcast.config->loss_percent = 0; |
| 1053 | simulcast.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1054 | ParamsWithLogging video_params_high; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1055 | video_params_high.video[0] = kSimulcastVp8VideoHigh; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1056 | ParamsWithLogging video_params_medium; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1057 | video_params_medium.video[0] = kSimulcastVp8VideoMedium; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1058 | ParamsWithLogging video_params_low; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1059 | video_params_low.video[0] = kSimulcastVp8VideoLow; |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1060 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1061 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1062 | VideoQualityTest::DefaultVideoStream(video_params_low, 0), |
| 1063 | VideoQualityTest::DefaultVideoStream(video_params_medium, 0), |
| 1064 | VideoQualityTest::DefaultVideoStream(video_params_high, 0)}; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1065 | simulcast.ss[0] = { |
| 1066 | streams, 1, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1067 | false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1068 | fixture->RunWithAnalyzer(simulcast); |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1069 | } |
| 1070 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1071 | TEST(FullStackTest, SimulcastVP8_3SL_Low) { |
| 1072 | auto fixture = CreateVideoQualityTestFixture(); |
| 1073 | ParamsWithLogging simulcast; |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1074 | simulcast.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1075 | simulcast.video[0] = kSimulcastVp8VideoHigh; |
ilnik | 2a8c2f5 | 2017-02-15 02:23:28 -0800 | [diff] [blame] | 1076 | simulcast.analyzer = {"simulcast_vp8_3sl_low", 0.0, 0.0, |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1077 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1078 | simulcast.config->loss_percent = 0; |
| 1079 | simulcast.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1080 | ParamsWithLogging video_params_high; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1081 | video_params_high.video[0] = kSimulcastVp8VideoHigh; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1082 | ParamsWithLogging video_params_medium; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1083 | video_params_medium.video[0] = kSimulcastVp8VideoMedium; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1084 | ParamsWithLogging video_params_low; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1085 | video_params_low.video[0] = kSimulcastVp8VideoLow; |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1086 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1087 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1088 | VideoQualityTest::DefaultVideoStream(video_params_low, 0), |
| 1089 | VideoQualityTest::DefaultVideoStream(video_params_medium, 0), |
| 1090 | VideoQualityTest::DefaultVideoStream(video_params_high, 0)}; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1091 | simulcast.ss[0] = { |
| 1092 | streams, 0, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1093 | false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1094 | fixture->RunWithAnalyzer(simulcast); |
ilnik | 3dd5ad9 | 2017-02-09 04:58:53 -0800 | [diff] [blame] | 1095 | } |
| 1096 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1097 | TEST(FullStackTest, LargeRoomVP8_5thumb) { |
| 1098 | auto fixture = CreateVideoQualityTestFixture(); |
| 1099 | ParamsWithLogging large_room; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1100 | large_room.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1101 | large_room.video[0] = kSimulcastVp8VideoHigh; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1102 | large_room.analyzer = {"largeroom_5thumb", 0.0, 0.0, |
| 1103 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1104 | large_room.config->loss_percent = 0; |
| 1105 | large_room.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1106 | ParamsWithLogging video_params_high; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1107 | video_params_high.video[0] = kSimulcastVp8VideoHigh; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1108 | ParamsWithLogging video_params_medium; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1109 | video_params_medium.video[0] = kSimulcastVp8VideoMedium; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1110 | ParamsWithLogging video_params_low; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1111 | video_params_low.video[0] = kSimulcastVp8VideoLow; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1112 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1113 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1114 | VideoQualityTest::DefaultVideoStream(video_params_low, 0), |
| 1115 | VideoQualityTest::DefaultVideoStream(video_params_medium, 0), |
| 1116 | VideoQualityTest::DefaultVideoStream(video_params_high, 0)}; |
ilnik | 9843695 | 2017-07-13 00:47:03 -0700 | [diff] [blame] | 1117 | large_room.call.num_thumbnails = 5; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1118 | large_room.ss[0] = { |
| 1119 | streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1120 | false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1121 | fixture->RunWithAnalyzer(large_room); |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1122 | } |
| 1123 | |
oprypin | 743117f | 2017-09-15 05:24:24 -0700 | [diff] [blame] | 1124 | #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS) |
| 1125 | // Fails on mobile devices: |
ilnik | f89a738 | 2017-03-07 06:15:27 -0800 | [diff] [blame] | 1126 | // https://bugs.chromium.org/p/webrtc/issues/detail?id=7301 |
| 1127 | #define MAYBE_LargeRoomVP8_50thumb DISABLED_LargeRoomVP8_50thumb |
ilnik | 3ae7c25 | 2017-03-08 01:17:35 -0800 | [diff] [blame] | 1128 | #define MAYBE_LargeRoomVP8_15thumb DISABLED_LargeRoomVP8_15thumb |
ilnik | f89a738 | 2017-03-07 06:15:27 -0800 | [diff] [blame] | 1129 | #else |
| 1130 | #define MAYBE_LargeRoomVP8_50thumb LargeRoomVP8_50thumb |
ilnik | 3ae7c25 | 2017-03-08 01:17:35 -0800 | [diff] [blame] | 1131 | #define MAYBE_LargeRoomVP8_15thumb LargeRoomVP8_15thumb |
ilnik | f89a738 | 2017-03-07 06:15:27 -0800 | [diff] [blame] | 1132 | #endif |
| 1133 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1134 | TEST(FullStackTest, MAYBE_LargeRoomVP8_15thumb) { |
| 1135 | auto fixture = CreateVideoQualityTestFixture(); |
| 1136 | ParamsWithLogging large_room; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1137 | large_room.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1138 | large_room.video[0] = kSimulcastVp8VideoHigh; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1139 | large_room.analyzer = {"largeroom_15thumb", 0.0, 0.0, |
| 1140 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1141 | large_room.config->loss_percent = 0; |
| 1142 | large_room.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1143 | ParamsWithLogging video_params_high; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1144 | video_params_high.video[0] = kSimulcastVp8VideoHigh; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1145 | ParamsWithLogging video_params_medium; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1146 | video_params_medium.video[0] = kSimulcastVp8VideoMedium; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1147 | ParamsWithLogging video_params_low; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1148 | video_params_low.video[0] = kSimulcastVp8VideoLow; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1149 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1150 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1151 | VideoQualityTest::DefaultVideoStream(video_params_low, 0), |
| 1152 | VideoQualityTest::DefaultVideoStream(video_params_medium, 0), |
| 1153 | VideoQualityTest::DefaultVideoStream(video_params_high, 0)}; |
ilnik | 9843695 | 2017-07-13 00:47:03 -0700 | [diff] [blame] | 1154 | large_room.call.num_thumbnails = 15; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1155 | large_room.ss[0] = { |
| 1156 | streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1157 | false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1158 | fixture->RunWithAnalyzer(large_room); |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1159 | } |
| 1160 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1161 | TEST(FullStackTest, MAYBE_LargeRoomVP8_50thumb) { |
| 1162 | auto fixture = CreateVideoQualityTestFixture(); |
| 1163 | ParamsWithLogging large_room; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1164 | large_room.call.send_side_bwe = true; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1165 | large_room.video[0] = kSimulcastVp8VideoHigh; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1166 | large_room.analyzer = {"largeroom_50thumb", 0.0, 0.0, |
| 1167 | kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1168 | large_room.config->loss_percent = 0; |
| 1169 | large_room.config->queue_delay_ms = 100; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1170 | ParamsWithLogging video_params_high; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1171 | video_params_high.video[0] = kSimulcastVp8VideoHigh; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1172 | ParamsWithLogging video_params_medium; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1173 | video_params_medium.video[0] = kSimulcastVp8VideoMedium; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1174 | ParamsWithLogging video_params_low; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1175 | video_params_low.video[0] = kSimulcastVp8VideoLow; |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1176 | |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1177 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1178 | VideoQualityTest::DefaultVideoStream(video_params_low, 0), |
| 1179 | VideoQualityTest::DefaultVideoStream(video_params_medium, 0), |
| 1180 | VideoQualityTest::DefaultVideoStream(video_params_high, 0)}; |
ilnik | 9843695 | 2017-07-13 00:47:03 -0700 | [diff] [blame] | 1181 | large_room.call.num_thumbnails = 50; |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1182 | large_room.ss[0] = { |
| 1183 | streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1184 | false}; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1185 | fixture->RunWithAnalyzer(large_room); |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1186 | } |
| 1187 | |
philipel | dd8b0d8 | 2018-09-27 11:18:10 +0200 | [diff] [blame] | 1188 | INSTANTIATE_TEST_CASE_P(FullStackTest, |
| 1189 | GenericDescriptorTest, |
| 1190 | ::testing::Values("WebRTC-GenericDescriptor/Disabled/", |
| 1191 | "WebRTC-GenericDescriptor/Enabled/")); |
| 1192 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1193 | class DualStreamsTest : public ::testing::TestWithParam<int> {}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1194 | |
| 1195 | // Disable dual video test on mobile device becuase it's too heavy. |
Ilya Nikolaevskiy | f08dd9d | 2018-10-09 17:22:15 +0200 | [diff] [blame] | 1196 | // TODO(bugs.webrtc.org/9840): Investigate why is this test flaky on MAC. |
| 1197 | #if !defined(WEBRTC_ANDROID) && !defined(WEBRTC_IOS) && !defined(WEBRTC_MAC) |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1198 | TEST_P(DualStreamsTest, |
| 1199 | ModeratelyRestricted_SlidesVp8_3TL_Simulcast_Video_Simulcast_High) { |
| 1200 | test::ScopedFieldTrials field_trial( |
Erik Språng | b65aa01 | 2018-09-24 11:35:19 +0200 | [diff] [blame] | 1201 | AppendFieldTrials(std::string(kPacerPushBackExperiment) + |
| 1202 | std::string(kScreenshareSimulcastExperiment))); |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1203 | const int first_stream = GetParam(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1204 | ParamsWithLogging dual_streams; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1205 | |
| 1206 | // Screenshare Settings. |
| 1207 | dual_streams.screenshare[first_stream] = {true, false, 10}; |
| 1208 | dual_streams.video[first_stream] = {true, 1850, 1110, 5, 800000, |
| 1209 | 2500000, 2500000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 1210 | 2, 400000, false, false, false, |
| 1211 | ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1212 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1213 | ParamsWithLogging screenshare_params_high; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 1214 | screenshare_params_high.video[0] = {true, 1850, 1110, 5, 400000, 1000000, |
| 1215 | 1000000, false, "VP8", 3, 0, 400000, |
| 1216 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1217 | VideoQualityTest::Params screenshare_params_low; |
Erik Språng | 28bb391 | 2018-07-11 16:06:55 +0200 | [diff] [blame] | 1218 | screenshare_params_low.video[0] = {true, 1850, 1110, 5, 50000, 200000, |
| 1219 | 1000000, false, "VP8", 2, 0, 400000, |
| 1220 | false, false, false, ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1221 | std::vector<VideoStream> screenhsare_streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1222 | VideoQualityTest::DefaultVideoStream(screenshare_params_low, 0), |
| 1223 | VideoQualityTest::DefaultVideoStream(screenshare_params_high, 0)}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1224 | |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1225 | dual_streams.ss[first_stream] = { |
| 1226 | screenhsare_streams, 1, 1, 0, InterLayerPredMode::kOn, |
| 1227 | std::vector<SpatialLayer>(), false}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1228 | |
| 1229 | // Video settings. |
| 1230 | dual_streams.video[1 - first_stream] = kSimulcastVp8VideoHigh; |
| 1231 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1232 | ParamsWithLogging video_params_high; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1233 | video_params_high.video[0] = kSimulcastVp8VideoHigh; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1234 | ParamsWithLogging video_params_medium; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1235 | video_params_medium.video[0] = kSimulcastVp8VideoMedium; |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1236 | ParamsWithLogging video_params_low; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1237 | video_params_low.video[0] = kSimulcastVp8VideoLow; |
| 1238 | std::vector<VideoStream> streams = { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1239 | VideoQualityTest::DefaultVideoStream(video_params_low, 0), |
| 1240 | VideoQualityTest::DefaultVideoStream(video_params_medium, 0), |
| 1241 | VideoQualityTest::DefaultVideoStream(video_params_high, 0)}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1242 | |
| 1243 | dual_streams.ss[1 - first_stream] = { |
Sergey Silkin | 5702736 | 2018-05-15 09:12:05 +0200 | [diff] [blame] | 1244 | streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(), |
| 1245 | false}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1246 | |
| 1247 | // Call settings. |
| 1248 | dual_streams.call.send_side_bwe = true; |
| 1249 | dual_streams.call.dual_video = true; |
Edward Lemur | 35d2b7e | 2017-12-27 18:54:47 +0100 | [diff] [blame] | 1250 | std::string test_label = "dualstreams_moderately_restricted_screenshare_" + |
| 1251 | std::to_string(first_stream); |
| 1252 | dual_streams.analyzer = {test_label, 0.0, 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1253 | dual_streams.config->loss_percent = 1; |
| 1254 | dual_streams.config->link_capacity_kbps = 7500; |
| 1255 | dual_streams.config->queue_length_packets = 30; |
| 1256 | dual_streams.config->queue_delay_ms = 100; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1257 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1258 | auto fixture = CreateVideoQualityTestFixture(); |
| 1259 | fixture->RunWithAnalyzer(dual_streams); |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1260 | } |
Ilya Nikolaevskiy | f08dd9d | 2018-10-09 17:22:15 +0200 | [diff] [blame] | 1261 | #endif // !defined(WEBRTC_ANDROID) && !defined(WEBRTC_IOS) && |
| 1262 | // !defined(WEBRTC_MAC) |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1263 | |
| 1264 | TEST_P(DualStreamsTest, Conference_Restricted) { |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1265 | test::ScopedFieldTrials field_trial( |
Ilya Nikolaevskiy | cb96062 | 2018-09-04 09:07:31 +0000 | [diff] [blame] | 1266 | AppendFieldTrials(std::string(kPacerPushBackExperiment))); |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1267 | const int first_stream = GetParam(); |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1268 | ParamsWithLogging dual_streams; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1269 | |
| 1270 | // Screenshare Settings. |
| 1271 | dual_streams.screenshare[first_stream] = {true, false, 10}; |
| 1272 | dual_streams.video[first_stream] = {true, 1850, 1110, 5, 800000, |
| 1273 | 2500000, 2500000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 1274 | 2, 400000, false, false, false, |
| 1275 | ""}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1276 | // Video settings. |
| 1277 | dual_streams.video[1 - first_stream] = { |
| 1278 | true, 1280, 720, 30, 150000, |
| 1279 | 500000, 700000, false, "VP8", 3, |
Niels Möller | 6aa415e | 2018-06-07 11:14:13 +0200 | [diff] [blame] | 1280 | 2, 400000, false, false, false, "ConferenceMotion_1280_720_50"}; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1281 | |
| 1282 | // Call settings. |
| 1283 | dual_streams.call.send_side_bwe = true; |
| 1284 | dual_streams.call.dual_video = true; |
Edward Lemur | 35d2b7e | 2017-12-27 18:54:47 +0100 | [diff] [blame] | 1285 | std::string test_label = "dualstreams_conference_restricted_screenshare_" + |
| 1286 | std::to_string(first_stream); |
| 1287 | dual_streams.analyzer = {test_label, 0.0, 0.0, kFullStackTestDurationSecs}; |
Artem Titov | f18b352 | 2018-08-28 16:54:24 +0200 | [diff] [blame] | 1288 | dual_streams.config->loss_percent = 1; |
| 1289 | dual_streams.config->link_capacity_kbps = 5000; |
| 1290 | dual_streams.config->queue_length_packets = 30; |
| 1291 | dual_streams.config->queue_delay_ms = 100; |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1292 | |
Patrik Höglund | b6b29e0 | 2018-06-21 16:58:01 +0200 | [diff] [blame] | 1293 | auto fixture = CreateVideoQualityTestFixture(); |
| 1294 | fixture->RunWithAnalyzer(dual_streams); |
Ilya Nikolaevskiy | 255d1cd | 2017-12-21 18:02:59 +0100 | [diff] [blame] | 1295 | } |
| 1296 | |
| 1297 | INSTANTIATE_TEST_CASE_P(FullStackTest, |
| 1298 | DualStreamsTest, |
| 1299 | ::testing::Values(0, 1)); |
ilnik | a014cc5 | 2017-03-07 04:21:04 -0800 | [diff] [blame] | 1300 | |
pbos@webrtc.org | af8d5af | 2013-07-09 08:02:33 +0000 | [diff] [blame] | 1301 | } // namespace webrtc |