| /* |
| * Copyright 2019 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "rtc_base/experiments/balanced_degradation_settings.h" |
| |
| #include <limits> |
| |
| #include "rtc_base/gunit.h" |
| #include "test/field_trial.h" |
| #include "test/gmock.h" |
| |
| namespace webrtc { |
| namespace { |
| |
| void VerifyIsDefault( |
| const std::vector<BalancedDegradationSettings::Config>& config) { |
| EXPECT_THAT(config, ::testing::ElementsAre( |
| BalancedDegradationSettings::Config{ |
| 320 * 240, |
| 7, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 480 * 360, |
| 10, |
| 0, |
| 0, |
| 1, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 640 * 480, |
| 15, |
| 0, |
| 0, |
| 1, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}})); |
| } |
| } // namespace |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfNoList) { |
| webrtc::test::ScopedFieldTrials field_trials(""); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| EXPECT_TRUE(settings.CanAdaptUp(kVideoCodecVP8, 1, /*bitrate_bps*/ 1)); |
| EXPECT_TRUE( |
| settings.CanAdaptUpResolution(kVideoCodecVP8, 1, /*bitrate_bps*/ 1)); |
| EXPECT_FALSE(settings.MinFpsDiff(1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecVP8, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecVP9, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecH264, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecAV1, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecGeneric, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecMultiplex, 1)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsConfig) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:11|22|33,fps:5|15|25,other:4|5|6/"); |
| BalancedDegradationSettings settings; |
| EXPECT_THAT(settings.GetConfigs(), |
| ::testing::ElementsAre( |
| BalancedDegradationSettings::Config{ |
| 11, |
| 5, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 22, |
| 15, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 33, |
| 25, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}, |
| {0, 0, 0, 0, 0}})); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigForZeroFpsValue) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:0|15|25/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfPixelsDecreases) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|999|3000,fps:5|15|25/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfFramerateDecreases) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|4|25/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsConfigWithSpecificFps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,vp8_fps:7|8|9,vp9_fps:9|10|11," |
| "h264_fps:11|12|13,av1_fps:1|2|3,generic_fps:13|14|15/"); |
| BalancedDegradationSettings settings; |
| EXPECT_THAT(settings.GetConfigs(), |
| ::testing::ElementsAre( |
| BalancedDegradationSettings::Config{ |
| 1000, |
| 5, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 7, 0, 0}, |
| {0, 0, 9, 0, 0}, |
| {0, 0, 11, 0, 0}, |
| {0, 0, 1, 0, 0}, |
| {0, 0, 13, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 2000, |
| 15, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 8, 0, 0}, |
| {0, 0, 10, 0, 0}, |
| {0, 0, 12, 0, 0}, |
| {0, 0, 2, 0, 0}, |
| {0, 0, 14, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 3000, |
| 25, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 9, 0, 0}, |
| {0, 0, 11, 0, 0}, |
| {0, 0, 13, 0, 0}, |
| {0, 0, 3, 0, 0}, |
| {0, 0, 15, 0, 0}})); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigForZeroVp8FpsValue) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:7|15|25,vp8_fps:0|15|25/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigForInvalidFpsValue) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:7|15|25,vp8_fps:10|15|2000/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfVp8FramerateDecreases) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:4|5|25,vp8_fps:5|4|25/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsMinFps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(5, settings.MinFps(kVideoCodecVP8, 1)); |
| EXPECT_EQ(5, settings.MinFps(kVideoCodecVP8, 1000)); |
| EXPECT_EQ(15, settings.MinFps(kVideoCodecVP8, 1001)); |
| EXPECT_EQ(15, settings.MinFps(kVideoCodecVP8, 2000)); |
| EXPECT_EQ(25, settings.MinFps(kVideoCodecVP8, 2001)); |
| EXPECT_EQ(25, settings.MinFps(kVideoCodecVP8, 3000)); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| settings.MinFps(kVideoCodecVP8, 3001)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsVp8MinFps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,vp8_fps:7|10|12/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(7, settings.MinFps(kVideoCodecVP8, 1)); |
| EXPECT_EQ(7, settings.MinFps(kVideoCodecVP8, 1000)); |
| EXPECT_EQ(10, settings.MinFps(kVideoCodecVP8, 1001)); |
| EXPECT_EQ(10, settings.MinFps(kVideoCodecVP8, 2000)); |
| EXPECT_EQ(12, settings.MinFps(kVideoCodecVP8, 2001)); |
| EXPECT_EQ(12, settings.MinFps(kVideoCodecVP8, 3000)); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| settings.MinFps(kVideoCodecVP8, 3001)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsMaxFps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(15, settings.MaxFps(kVideoCodecVP8, 1)); |
| EXPECT_EQ(15, settings.MaxFps(kVideoCodecVP8, 1000)); |
| EXPECT_EQ(25, settings.MaxFps(kVideoCodecVP8, 1001)); |
| EXPECT_EQ(25, settings.MaxFps(kVideoCodecVP8, 2000)); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| settings.MaxFps(kVideoCodecVP8, 2001)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsVp8MaxFps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,vp8_fps:7|10|12/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(10, settings.MaxFps(kVideoCodecVP8, 1)); |
| EXPECT_EQ(10, settings.MaxFps(kVideoCodecVP8, 1000)); |
| EXPECT_EQ(12, settings.MaxFps(kVideoCodecVP8, 1001)); |
| EXPECT_EQ(12, settings.MaxFps(kVideoCodecVP8, 2000)); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| settings.MaxFps(kVideoCodecVP8, 2001)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsVp9Fps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,vp9_fps:7|10|12/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(7, settings.MinFps(kVideoCodecVP9, 1000)); |
| EXPECT_EQ(10, settings.MaxFps(kVideoCodecVP9, 1000)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsH264Fps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,h264_fps:8|11|13/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(11, settings.MinFps(kVideoCodecH264, 2000)); |
| EXPECT_EQ(13, settings.MaxFps(kVideoCodecH264, 2000)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsGenericFps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,generic_fps:9|12|14/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(14, settings.MinFps(kVideoCodecGeneric, 3000)); |
| EXPECT_EQ(std::numeric_limits<int>::max(), |
| settings.MaxFps(kVideoCodecGeneric, 3000)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsUnlimitedForMaxValidFps) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|100,vp8_fps:30|100|100/"); |
| const int kUnlimitedFps = std::numeric_limits<int>::max(); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(15, settings.MinFps(kVideoCodecH264, 2000)); |
| EXPECT_EQ(kUnlimitedFps, settings.MinFps(kVideoCodecH264, 2001)); |
| EXPECT_EQ(30, settings.MinFps(kVideoCodecVP8, 1000)); |
| EXPECT_EQ(kUnlimitedFps, settings.MinFps(kVideoCodecVP8, 1001)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsConfigWithBitrate) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:11|22|33,fps:5|15|25,kbps:44|88|99,kbps_res:55|111|222," |
| "vp8_kbps:11|12|13,vp8_kbps_res:14|15|16," |
| "vp9_kbps:21|22|23,vp9_kbps_res:24|25|26," |
| "h264_kbps:31|32|33,h264_kbps_res:34|35|36," |
| "av1_kbps:41|42|43,av1_kbps_res:44|45|46," |
| "generic_kbps:51|52|53,generic_kbps_res:54|55|56/"); |
| BalancedDegradationSettings settings; |
| EXPECT_THAT(settings.GetConfigs(), |
| ::testing::ElementsAre( |
| BalancedDegradationSettings::Config{ |
| 11, |
| 5, |
| 44, |
| 55, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 0, 11, 14}, |
| {0, 0, 0, 21, 24}, |
| {0, 0, 0, 31, 34}, |
| {0, 0, 0, 41, 44}, |
| {0, 0, 0, 51, 54}}, |
| BalancedDegradationSettings::Config{ |
| 22, |
| 15, |
| 88, |
| 111, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 0, 12, 15}, |
| {0, 0, 0, 22, 25}, |
| {0, 0, 0, 32, 35}, |
| {0, 0, 0, 42, 45}, |
| {0, 0, 0, 52, 55}}, |
| BalancedDegradationSettings::Config{ |
| 33, |
| 25, |
| 99, |
| 222, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {0, 0, 0, 13, 16}, |
| {0, 0, 0, 23, 26}, |
| {0, 0, 0, 33, 36}, |
| {0, 0, 0, 43, 46}, |
| {0, 0, 0, 53, 56}})); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfBitrateDecreases) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:11|22|33,fps:5|15|25,kbps:44|43|99/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, |
| GetsDefaultConfigIfBitrateDecreasesWithUnsetValue) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:11|22|33,fps:5|15|25,kbps:44|0|43/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, CanAdaptUp) { |
| VideoCodecType vp8 = kVideoCodecVP8; |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000|4000,fps:5|15|25|30,kbps:0|80|0|90," |
| "vp9_kbps:40|50|60|70/"); |
| BalancedDegradationSettings s; |
| EXPECT_TRUE(s.CanAdaptUp(vp8, 1000, 0)); // No bitrate provided. |
| EXPECT_FALSE(s.CanAdaptUp(vp8, 1000, 79000)); |
| EXPECT_TRUE(s.CanAdaptUp(vp8, 1000, 80000)); |
| EXPECT_TRUE(s.CanAdaptUp(vp8, 1001, 1)); // No limit configured. |
| EXPECT_FALSE(s.CanAdaptUp(vp8, 3000, 89000)); |
| EXPECT_TRUE(s.CanAdaptUp(vp8, 3000, 90000)); |
| EXPECT_TRUE(s.CanAdaptUp(vp8, 3001, 1)); // No limit. |
| } |
| |
| TEST(BalancedDegradationSettings, CanAdaptUpWithCodecType) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000|4000,fps:5|15|25|30,vp8_kbps:0|30|40|50," |
| "vp9_kbps:0|60|70|80,h264_kbps:0|55|65|75,av1_kbps:0|77|88|99," |
| "generic_kbps:0|25|35|45/"); |
| BalancedDegradationSettings s; |
| EXPECT_FALSE(s.CanAdaptUp(kVideoCodecVP8, 1000, 29000)); |
| EXPECT_TRUE(s.CanAdaptUp(kVideoCodecVP8, 1000, 30000)); |
| EXPECT_FALSE(s.CanAdaptUp(kVideoCodecVP9, 1000, 59000)); |
| EXPECT_TRUE(s.CanAdaptUp(kVideoCodecVP9, 1000, 60000)); |
| EXPECT_FALSE(s.CanAdaptUp(kVideoCodecH264, 1000, 54000)); |
| EXPECT_TRUE(s.CanAdaptUp(kVideoCodecH264, 1000, 55000)); |
| EXPECT_FALSE(s.CanAdaptUp(kVideoCodecAV1, 1000, 76000)); |
| EXPECT_TRUE(s.CanAdaptUp(kVideoCodecAV1, 1000, 77000)); |
| EXPECT_FALSE(s.CanAdaptUp(kVideoCodecGeneric, 1000, 24000)); |
| EXPECT_TRUE(s.CanAdaptUp(kVideoCodecGeneric, 1000, 25000)); |
| EXPECT_TRUE(s.CanAdaptUp(kVideoCodecMultiplex, 1000, 1)); // Not configured. |
| } |
| |
| TEST(BalancedDegradationSettings, CanAdaptUpResolution) { |
| VideoCodecType vp8 = kVideoCodecVP8; |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000|4000,fps:5|15|25|30,kbps_res:0|80|0|90," |
| "vp9_kbps_res:40|50|60|70/"); |
| BalancedDegradationSettings s; |
| EXPECT_TRUE(s.CanAdaptUpResolution(vp8, 1000, 0)); // No bitrate provided. |
| EXPECT_FALSE(s.CanAdaptUpResolution(vp8, 1000, 79000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(vp8, 1000, 80000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(vp8, 1001, 1)); // No limit configured. |
| EXPECT_FALSE(s.CanAdaptUpResolution(vp8, 3000, 89000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(vp8, 3000, 90000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(vp8, 3001, 1)); // No limit. |
| } |
| |
| TEST(BalancedDegradationSettings, CanAdaptUpResolutionWithCodecType) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000|4000,fps:5|15|25|30,vp8_kbps_res:0|30|40|50," |
| "vp9_kbps_res:0|60|70|80,h264_kbps_res:0|55|65|75," |
| "av1_kbps_res:0|77|88|99,generic_kbps_res:0|25|35|45/"); |
| BalancedDegradationSettings s; |
| EXPECT_FALSE(s.CanAdaptUpResolution(kVideoCodecVP8, 1000, 29000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(kVideoCodecVP8, 1000, 30000)); |
| EXPECT_FALSE(s.CanAdaptUpResolution(kVideoCodecVP9, 1000, 59000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(kVideoCodecVP9, 1000, 60000)); |
| EXPECT_FALSE(s.CanAdaptUpResolution(kVideoCodecH264, 1000, 54000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(kVideoCodecH264, 1000, 55000)); |
| EXPECT_FALSE(s.CanAdaptUpResolution(kVideoCodecAV1, 1000, 76000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(kVideoCodecAV1, 1000, 77000)); |
| EXPECT_FALSE(s.CanAdaptUpResolution(kVideoCodecGeneric, 1000, 24000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(kVideoCodecGeneric, 1000, 25000)); |
| EXPECT_TRUE(s.CanAdaptUpResolution(kVideoCodecMultiplex, 1000, |
| 1)); // Not configured. |
| } |
| |
| TEST(BalancedDegradationSettings, GetsFpsDiff) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,fps_diff:0|-2|3/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(0, settings.MinFpsDiff(1)); |
| EXPECT_EQ(0, settings.MinFpsDiff(1000)); |
| EXPECT_EQ(-2, settings.MinFpsDiff(1001)); |
| EXPECT_EQ(-2, settings.MinFpsDiff(2000)); |
| EXPECT_EQ(3, settings.MinFpsDiff(2001)); |
| EXPECT_EQ(3, settings.MinFpsDiff(3000)); |
| EXPECT_FALSE(settings.MinFpsDiff(3001)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsNoFpsDiffIfValueBelowMinSetting) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,fps_diff:-100|-99|-101/"); |
| // Min valid fps_diff setting: -99. |
| BalancedDegradationSettings settings; |
| EXPECT_FALSE(settings.MinFpsDiff(1000)); |
| EXPECT_EQ(-99, settings.MinFpsDiff(2000)); |
| EXPECT_FALSE(settings.MinFpsDiff(3000)); |
| } |
| |
| TEST(BalancedDegradationSettings, QpThresholdsNotSetByDefault) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25/"); |
| BalancedDegradationSettings settings; |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecVP8, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecVP9, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecH264, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecAV1, 1)); |
| EXPECT_FALSE(settings.GetQpThresholds(kVideoCodecGeneric, 1)); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsConfigWithQpThresholds) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,vp8_qp_low:89|90|88," |
| "vp8_qp_high:90|91|92,vp9_qp_low:27|28|29,vp9_qp_high:120|130|140," |
| "h264_qp_low:12|13|14,h264_qp_high:20|30|40,av1_qp_low:2|3|4," |
| "av1_qp_high:11|33|44,generic_qp_low:7|6|5,generic_qp_high:22|23|24/"); |
| BalancedDegradationSettings settings; |
| EXPECT_THAT(settings.GetConfigs(), |
| ::testing::ElementsAre( |
| BalancedDegradationSettings::Config{ |
| 1000, |
| 5, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {89, 90, 0, 0, 0}, |
| {27, 120, 0, 0, 0}, |
| {12, 20, 0, 0, 0}, |
| {2, 11, 0, 0, 0}, |
| {7, 22, 0, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 2000, |
| 15, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {90, 91, 0, 0, 0}, |
| {28, 130, 0, 0, 0}, |
| {13, 30, 0, 0, 0}, |
| {3, 33, 0, 0, 0}, |
| {6, 23, 0, 0, 0}}, |
| BalancedDegradationSettings::Config{ |
| 3000, |
| 25, |
| 0, |
| 0, |
| BalancedDegradationSettings::kNoFpsDiff, |
| {88, 92, 0, 0, 0}, |
| {29, 140, 0, 0, 0}, |
| {14, 40, 0, 0, 0}, |
| {4, 44, 0, 0, 0}, |
| {5, 24, 0, 0, 0}})); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfOnlyHasLowThreshold) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,vp8_qp_low:89|90|88/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfOnlyHasHighThreshold) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25,vp8_qp_high:90|91|92/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfLowEqualsHigh) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25," |
| "vp8_qp_low:89|90|88,vp8_qp_high:90|91|88/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigIfLowGreaterThanHigh) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25," |
| "vp8_qp_low:89|90|88,vp8_qp_high:90|91|87/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsDefaultConfigForZeroQpValue) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25," |
| "vp8_qp_low:89|0|88,vp8_qp_high:90|91|92/"); |
| BalancedDegradationSettings settings; |
| VerifyIsDefault(settings.GetConfigs()); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsVp8QpThresholds) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25," |
| "vp8_qp_low:89|90|88,vp8_qp_high:90|91|92/"); |
| BalancedDegradationSettings settings; |
| EXPECT_EQ(89, settings.GetQpThresholds(kVideoCodecVP8, 1)->low); |
| EXPECT_EQ(90, settings.GetQpThresholds(kVideoCodecVP8, 1)->high); |
| EXPECT_EQ(90, settings.GetQpThresholds(kVideoCodecVP8, 1000)->high); |
| EXPECT_EQ(91, settings.GetQpThresholds(kVideoCodecVP8, 1001)->high); |
| EXPECT_EQ(91, settings.GetQpThresholds(kVideoCodecVP8, 2000)->high); |
| EXPECT_EQ(92, settings.GetQpThresholds(kVideoCodecVP8, 2001)->high); |
| EXPECT_EQ(92, settings.GetQpThresholds(kVideoCodecVP8, 3000)->high); |
| EXPECT_EQ(92, settings.GetQpThresholds(kVideoCodecVP8, 3001)->high); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsVp9QpThresholds) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25," |
| "vp9_qp_low:55|56|57,vp9_qp_high:155|156|157/"); |
| BalancedDegradationSettings settings; |
| const auto thresholds = settings.GetQpThresholds(kVideoCodecVP9, 1000); |
| EXPECT_TRUE(thresholds); |
| EXPECT_EQ(55, thresholds->low); |
| EXPECT_EQ(155, thresholds->high); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsH264QpThresholds) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25," |
| "h264_qp_low:21|22|23,h264_qp_high:41|43|42/"); |
| BalancedDegradationSettings settings; |
| const auto thresholds = settings.GetQpThresholds(kVideoCodecH264, 2000); |
| EXPECT_TRUE(thresholds); |
| EXPECT_EQ(22, thresholds->low); |
| EXPECT_EQ(43, thresholds->high); |
| } |
| |
| TEST(BalancedDegradationSettings, GetsGenericQpThresholds) { |
| webrtc::test::ScopedFieldTrials field_trials( |
| "WebRTC-Video-BalancedDegradationSettings/" |
| "pixels:1000|2000|3000,fps:5|15|25," |
| "generic_qp_low:2|3|4,generic_qp_high:22|23|24/"); |
| BalancedDegradationSettings settings; |
| const auto thresholds = settings.GetQpThresholds(kVideoCodecGeneric, 3000); |
| EXPECT_TRUE(thresholds); |
| EXPECT_EQ(4, thresholds->low); |
| EXPECT_EQ(24, thresholds->high); |
| } |
| |
| } // namespace webrtc |
