Åsa Persson | cb7eddb | 2018-11-05 14:11:44 +0100 | [diff] [blame^] | 1 | /* |
| 2 | * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include "test/call_test.h" |
| 12 | #include "test/field_trial.h" |
| 13 | #include "test/frame_generator_capturer.h" |
| 14 | |
| 15 | namespace webrtc { |
| 16 | namespace { |
| 17 | constexpr int kWidth = 1280; |
| 18 | constexpr int kHeight = 720; |
| 19 | constexpr int kFps = 28; |
| 20 | } // namespace |
| 21 | |
| 22 | // Minimal normal usage at start, then 60s overuse. |
| 23 | class CpuOveruseTest : public test::CallTest { |
| 24 | protected: |
| 25 | CpuOveruseTest() |
| 26 | : field_trials_("WebRTC-ForceSimulatedOveruseIntervalMs/1-60000-60000/") { |
| 27 | } |
| 28 | |
| 29 | void RunTestAndCheckForAdaptation( |
| 30 | const DegradationPreference& degradation_preference, |
| 31 | bool expect_adaptation); |
| 32 | |
| 33 | test::ScopedFieldTrials field_trials_; |
| 34 | }; |
| 35 | |
| 36 | void CpuOveruseTest::RunTestAndCheckForAdaptation( |
| 37 | const DegradationPreference& degradation_preference, |
| 38 | bool expect_adaptation) { |
| 39 | class OveruseObserver |
| 40 | : public test::SendTest, |
| 41 | public test::FrameGeneratorCapturer::SinkWantsObserver { |
| 42 | public: |
| 43 | OveruseObserver(const DegradationPreference& degradation_preference, |
| 44 | bool expect_adaptation) |
| 45 | : SendTest(expect_adaptation ? kLongTimeoutMs : kDefaultTimeoutMs), |
| 46 | degradation_preference_(degradation_preference), |
| 47 | expect_adaptation_(expect_adaptation) {} |
| 48 | |
| 49 | private: |
| 50 | void OnFrameGeneratorCapturerCreated( |
| 51 | test::FrameGeneratorCapturer* frame_generator_capturer) override { |
| 52 | frame_generator_capturer->SetSinkWantsObserver(this); |
| 53 | // Set initial resolution. |
| 54 | frame_generator_capturer->ChangeResolution(kWidth, kHeight); |
| 55 | } |
| 56 | |
| 57 | // Called when FrameGeneratorCapturer::AddOrUpdateSink is called. |
| 58 | void OnSinkWantsChanged(rtc::VideoSinkInterface<VideoFrame>* sink, |
| 59 | const rtc::VideoSinkWants& wants) override { |
| 60 | if (wants.max_pixel_count == std::numeric_limits<int>::max() && |
| 61 | wants.max_framerate_fps == kFps) { |
| 62 | // Max configured framerate is initially set. |
| 63 | return; |
| 64 | } |
| 65 | switch (degradation_preference_) { |
| 66 | case DegradationPreference::MAINTAIN_FRAMERATE: |
| 67 | EXPECT_LT(wants.max_pixel_count, kWidth * kHeight); |
| 68 | observation_complete_.Set(); |
| 69 | break; |
| 70 | case DegradationPreference::MAINTAIN_RESOLUTION: |
| 71 | EXPECT_LT(wants.max_framerate_fps, kFps); |
| 72 | observation_complete_.Set(); |
| 73 | break; |
| 74 | case DegradationPreference::BALANCED: |
| 75 | if (wants.max_pixel_count == std::numeric_limits<int>::max() && |
| 76 | wants.max_framerate_fps == std::numeric_limits<int>::max()) { |
| 77 | // |adapt_counters_| map in VideoStreamEncoder is reset when |
| 78 | // balanced mode is set. |
| 79 | break; |
| 80 | } |
| 81 | EXPECT_TRUE(wants.max_pixel_count < kWidth * kHeight || |
| 82 | wants.max_framerate_fps < kFps); |
| 83 | observation_complete_.Set(); |
| 84 | break; |
| 85 | default: |
| 86 | RTC_NOTREACHED(); |
| 87 | } |
| 88 | } |
| 89 | |
| 90 | void ModifyVideoConfigs( |
| 91 | VideoSendStream::Config* send_config, |
| 92 | std::vector<VideoReceiveStream::Config>* receive_configs, |
| 93 | VideoEncoderConfig* encoder_config) override { |
| 94 | EXPECT_FALSE(encoder_config->simulcast_layers.empty()); |
| 95 | encoder_config->simulcast_layers[0].max_framerate = kFps; |
| 96 | } |
| 97 | |
| 98 | void ModifyVideoDegradationPreference( |
| 99 | DegradationPreference* degradation_preference) override { |
| 100 | *degradation_preference = degradation_preference_; |
| 101 | } |
| 102 | |
| 103 | void PerformTest() override { |
| 104 | EXPECT_EQ(expect_adaptation_, Wait()) |
| 105 | << "Timed out while waiting for a scale down."; |
| 106 | } |
| 107 | |
| 108 | const DegradationPreference degradation_preference_; |
| 109 | const bool expect_adaptation_; |
| 110 | } test(degradation_preference, expect_adaptation); |
| 111 | |
| 112 | RunBaseTest(&test); |
| 113 | } |
| 114 | |
| 115 | TEST_F(CpuOveruseTest, AdaptsDownInResolutionOnOveruse) { |
| 116 | RunTestAndCheckForAdaptation(DegradationPreference::MAINTAIN_FRAMERATE, true); |
| 117 | } |
| 118 | |
| 119 | TEST_F(CpuOveruseTest, AdaptsDownInFpsOnOveruse) { |
| 120 | RunTestAndCheckForAdaptation(DegradationPreference::MAINTAIN_RESOLUTION, |
| 121 | true); |
| 122 | } |
| 123 | |
| 124 | TEST_F(CpuOveruseTest, AdaptsDownInResolutionOrFpsOnOveruse) { |
| 125 | RunTestAndCheckForAdaptation(DegradationPreference::BALANCED, true); |
| 126 | } |
| 127 | |
| 128 | TEST_F(CpuOveruseTest, NoAdaptDownOnOveruse) { |
| 129 | RunTestAndCheckForAdaptation(DegradationPreference::DISABLED, false); |
| 130 | } |
| 131 | } // namespace webrtc |