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