blob: 5d9b2a837d8424ad0a24e13d55a398e6fccd2aa6 [file] [log] [blame]
Alec Mouri0a1cc962019-03-14 12:33:02 -07001/*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#undef LOG_TAG
18#define LOG_TAG "SchedulerUnittests"
19
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -070020#include <ftl/enum.h>
Dominik Laskowskif8734e02022-08-26 09:06:59 -070021#include <ftl/fake_guard.h>
Alec Mouri0a1cc962019-03-14 12:33:02 -070022#include <gmock/gmock.h>
23#include <log/log.h>
Marin Shalamanov3ea1d602020-12-16 19:59:39 +010024#include <ui/Size.h>
25
Alec Mouri0a1cc962019-03-14 12:33:02 -070026#include "DisplayHardware/HWC2.h"
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070027#include "FpsOps.h"
Alec Mouri0a1cc962019-03-14 12:33:02 -070028#include "Scheduler/RefreshRateConfigs.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080029#include "mock/DisplayHardware/MockDisplayMode.h"
Alec Mouri0a1cc962019-03-14 12:33:02 -070030
31using namespace std::chrono_literals;
Alec Mouri0a1cc962019-03-14 12:33:02 -070032
Dominik Laskowski6eab42d2021-09-13 14:34:13 -070033namespace android::scheduler {
Alec Mouri0a1cc962019-03-14 12:33:02 -070034
Peiyong Line9d809e2020-04-14 13:10:48 -070035namespace hal = android::hardware::graphics::composer::hal;
36
Ady Abraham8a82ba62020-01-17 12:43:17 -080037using LayerVoteType = RefreshRateConfigs::LayerVoteType;
38using LayerRequirement = RefreshRateConfigs::LayerRequirement;
Alec Mouri0a1cc962019-03-14 12:33:02 -070039
Dominik Laskowskib0054a22022-03-03 09:03:06 -080040using mock::createDisplayMode;
41
Dominik Laskowski0c252702021-12-20 20:32:09 -080042struct TestableRefreshRateConfigs : RefreshRateConfigs {
43 using RefreshRateConfigs::RefreshRateConfigs;
44
Dominik Laskowskif8734e02022-08-26 09:06:59 -070045 void setActiveModeId(DisplayModeId modeId) {
46 ftl::FakeGuard guard(kMainThreadContext);
47 return RefreshRateConfigs::setActiveModeId(modeId);
48 }
49
50 const DisplayMode& getActiveMode() const {
51 ftl::FakeGuard guard(kMainThreadContext);
52 return RefreshRateConfigs::getActiveMode();
53 }
54
Dominik Laskowskib0054a22022-03-03 09:03:06 -080055 DisplayModePtr getMinSupportedRefreshRate() const {
Dominik Laskowski0c252702021-12-20 20:32:09 -080056 std::lock_guard lock(mLock);
Dominik Laskowskib0054a22022-03-03 09:03:06 -080057 return mMinRefreshRateModeIt->second;
Dominik Laskowski0c252702021-12-20 20:32:09 -080058 }
59
Dominik Laskowskib0054a22022-03-03 09:03:06 -080060 DisplayModePtr getMaxSupportedRefreshRate() const {
Dominik Laskowski0c252702021-12-20 20:32:09 -080061 std::lock_guard lock(mLock);
Dominik Laskowskib0054a22022-03-03 09:03:06 -080062 return mMaxRefreshRateModeIt->second;
Dominik Laskowski0c252702021-12-20 20:32:09 -080063 }
64
Dominik Laskowskib0054a22022-03-03 09:03:06 -080065 DisplayModePtr getMinRefreshRateByPolicy() const {
Dominik Laskowski0c252702021-12-20 20:32:09 -080066 std::lock_guard lock(mLock);
67 return getMinRefreshRateByPolicyLocked();
68 }
69
70 const std::vector<Fps>& knownFrameRates() const { return mKnownFrameRates; }
71
Dominik Laskowskia8626ec2021-12-15 18:13:30 -080072 using RefreshRateConfigs::GetBestRefreshRateCache;
73 auto& mutableGetBestRefreshRateCache() { return mGetBestRefreshRateCache; }
Dominik Laskowski0c252702021-12-20 20:32:09 -080074
Dominik Laskowskia8626ec2021-12-15 18:13:30 -080075 auto getBestRefreshRateAndSignals(const std::vector<LayerRequirement>& layers,
76 GlobalSignals signals) const {
77 return RefreshRateConfigs::getBestRefreshRate(layers, signals);
78 }
79
Dominik Laskowskib0054a22022-03-03 09:03:06 -080080 DisplayModePtr getBestRefreshRate(const std::vector<LayerRequirement>& layers = {},
81 GlobalSignals signals = {}) const {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -080082 return getBestRefreshRateAndSignals(layers, signals).first;
Dominik Laskowski0c252702021-12-20 20:32:09 -080083 }
84};
85
Alec Mouri0a1cc962019-03-14 12:33:02 -070086class RefreshRateConfigsTest : public testing::Test {
87protected:
Alec Mouri0a1cc962019-03-14 12:33:02 -070088 RefreshRateConfigsTest();
89 ~RefreshRateConfigsTest();
Ady Abrahamabc27602020-04-08 17:20:29 -070090
Dominik Laskowski0c252702021-12-20 20:32:09 -080091 static constexpr DisplayModeId kModeId60{0};
92 static constexpr DisplayModeId kModeId90{1};
93 static constexpr DisplayModeId kModeId72{2};
94 static constexpr DisplayModeId kModeId120{3};
95 static constexpr DisplayModeId kModeId30{4};
96 static constexpr DisplayModeId kModeId25{5};
97 static constexpr DisplayModeId kModeId50{6};
98 static constexpr DisplayModeId kModeId24{7};
99 static constexpr DisplayModeId kModeId24Frac{8};
100 static constexpr DisplayModeId kModeId30Frac{9};
101 static constexpr DisplayModeId kModeId60Frac{10};
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700102
Dominik Laskowski0c252702021-12-20 20:32:09 -0800103 static inline const DisplayModePtr kMode60 = createDisplayMode(kModeId60, 60_Hz);
104 static inline const DisplayModePtr kMode60Frac = createDisplayMode(kModeId60Frac, 59.94_Hz);
105 static inline const DisplayModePtr kMode90 = createDisplayMode(kModeId90, 90_Hz);
106 static inline const DisplayModePtr kMode90_G1 = createDisplayMode(kModeId90, 90_Hz, 1);
107 static inline const DisplayModePtr kMode90_4K =
108 createDisplayMode(kModeId90, 90_Hz, 0, {3840, 2160});
109 static inline const DisplayModePtr kMode72 = createDisplayMode(kModeId72, 72_Hz);
110 static inline const DisplayModePtr kMode72_G1 = createDisplayMode(kModeId72, 72_Hz, 1);
111 static inline const DisplayModePtr kMode120 = createDisplayMode(kModeId120, 120_Hz);
112 static inline const DisplayModePtr kMode120_G1 = createDisplayMode(kModeId120, 120_Hz, 1);
113 static inline const DisplayModePtr kMode30 = createDisplayMode(kModeId30, 30_Hz);
114 static inline const DisplayModePtr kMode30_G1 = createDisplayMode(kModeId30, 30_Hz, 1);
115 static inline const DisplayModePtr kMode30Frac = createDisplayMode(kModeId30Frac, 29.97_Hz);
116 static inline const DisplayModePtr kMode25 = createDisplayMode(kModeId25, 25_Hz);
117 static inline const DisplayModePtr kMode25_G1 = createDisplayMode(kModeId25, 25_Hz, 1);
118 static inline const DisplayModePtr kMode50 = createDisplayMode(kModeId50, 50_Hz);
119 static inline const DisplayModePtr kMode24 = createDisplayMode(kModeId24, 24_Hz);
120 static inline const DisplayModePtr kMode24Frac = createDisplayMode(kModeId24Frac, 23.976_Hz);
Ady Abrahamb1b9d412020-06-01 19:53:52 -0700121
Dominik Laskowski0c252702021-12-20 20:32:09 -0800122 // Test configurations.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800123 static inline const DisplayModes kModes_60 = makeModes(kMode60);
124 static inline const DisplayModes kModes_60_90 = makeModes(kMode60, kMode90);
125 static inline const DisplayModes kModes_60_90_G1 = makeModes(kMode60, kMode90_G1);
126 static inline const DisplayModes kModes_60_90_4K = makeModes(kMode60, kMode90_4K);
127 static inline const DisplayModes kModes_60_72_90 = makeModes(kMode60, kMode90, kMode72);
128 static inline const DisplayModes kModes_60_90_72_120 =
129 makeModes(kMode60, kMode90, kMode72, kMode120);
130 static inline const DisplayModes kModes_30_60_72_90_120 =
131 makeModes(kMode60, kMode90, kMode72, kMode120, kMode30);
Marin Shalamanoveadf2e72020-12-10 15:35:28 +0100132
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800133 static inline const DisplayModes kModes_30_60 =
134 makeModes(kMode60, kMode90_G1, kMode72_G1, kMode120_G1, kMode30);
135 static inline const DisplayModes kModes_30_60_72_90 =
136 makeModes(kMode60, kMode90, kMode72, kMode120_G1, kMode30);
137 static inline const DisplayModes kModes_30_60_90 =
138 makeModes(kMode60, kMode90, kMode72_G1, kMode120_G1, kMode30);
139 static inline const DisplayModes kModes_25_30_50_60 =
140 makeModes(kMode60, kMode90, kMode72_G1, kMode120_G1, kMode30_G1, kMode25_G1, kMode50);
141 static inline const DisplayModes kModes_60_120 = makeModes(kMode60, kMode120);
Ady Abrahamabc27602020-04-08 17:20:29 -0700142
Marin Shalamanov15a0fc62021-08-16 18:20:21 +0200143 // This is a typical TV configuration.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800144 static inline const DisplayModes kModes_24_25_30_50_60_Frac =
145 makeModes(kMode24, kMode24Frac, kMode25, kMode30, kMode30Frac, kMode50, kMode60,
146 kMode60Frac);
Alec Mouri0a1cc962019-03-14 12:33:02 -0700147};
148
149RefreshRateConfigsTest::RefreshRateConfigsTest() {
150 const ::testing::TestInfo* const test_info =
151 ::testing::UnitTest::GetInstance()->current_test_info();
152 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
153}
154
155RefreshRateConfigsTest::~RefreshRateConfigsTest() {
156 const ::testing::TestInfo* const test_info =
157 ::testing::UnitTest::GetInstance()->current_test_info();
158 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
159}
160
161namespace {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700162
Dominik Laskowski0c252702021-12-20 20:32:09 -0800163TEST_F(RefreshRateConfigsTest, oneMode_canSwitch) {
164 RefreshRateConfigs configs(kModes_60, kModeId60);
165 EXPECT_FALSE(configs.canSwitch());
Alec Mouri0a1cc962019-03-14 12:33:02 -0700166}
167
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100168TEST_F(RefreshRateConfigsTest, invalidPolicy) {
Dominik Laskowski0c252702021-12-20 20:32:09 -0800169 RefreshRateConfigs configs(kModes_60, kModeId60);
170 EXPECT_LT(configs.setDisplayManagerPolicy({DisplayModeId(10), {60_Hz, 60_Hz}}), 0);
171 EXPECT_LT(configs.setDisplayManagerPolicy({kModeId60, {20_Hz, 40_Hz}}), 0);
Ana Kruleced3a8cc2019-11-14 00:55:07 +0100172}
173
Dominik Laskowski0c252702021-12-20 20:32:09 -0800174TEST_F(RefreshRateConfigsTest, twoModes_storesFullRefreshRateMap) {
175 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Alec Mouri0a1cc962019-03-14 12:33:02 -0700176
Dominik Laskowski0c252702021-12-20 20:32:09 -0800177 const auto minRate = configs.getMinSupportedRefreshRate();
178 const auto performanceRate = configs.getMaxSupportedRefreshRate();
Alec Mouri0a1cc962019-03-14 12:33:02 -0700179
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800180 EXPECT_EQ(kMode60, minRate);
181 EXPECT_EQ(kMode90, performanceRate);
Ady Abraham2139f732019-11-13 18:56:40 -0800182
Dominik Laskowski0c252702021-12-20 20:32:09 -0800183 const auto minRateByPolicy = configs.getMinRefreshRateByPolicy();
184 const auto performanceRateByPolicy = configs.getMaxRefreshRateByPolicy();
185
186 EXPECT_EQ(minRateByPolicy, minRate);
187 EXPECT_EQ(performanceRateByPolicy, performanceRate);
Alec Mouri0a1cc962019-03-14 12:33:02 -0700188}
Ady Abraham2139f732019-11-13 18:56:40 -0800189
Dominik Laskowski0c252702021-12-20 20:32:09 -0800190TEST_F(RefreshRateConfigsTest, twoModes_storesFullRefreshRateMap_differentGroups) {
191 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Ady Abraham2139f732019-11-13 18:56:40 -0800192
Dominik Laskowski0c252702021-12-20 20:32:09 -0800193 const auto minRate = configs.getMinRefreshRateByPolicy();
194 const auto performanceRate = configs.getMaxSupportedRefreshRate();
195 const auto minRate60 = configs.getMinRefreshRateByPolicy();
196 const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
Ady Abraham2139f732019-11-13 18:56:40 -0800197
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800198 EXPECT_EQ(kMode60, minRate);
199 EXPECT_EQ(kMode60, minRate60);
200 EXPECT_EQ(kMode60, performanceRate60);
Ady Abraham2139f732019-11-13 18:56:40 -0800201
Dominik Laskowski0c252702021-12-20 20:32:09 -0800202 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}), 0);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800203 configs.setActiveModeId(kModeId90);
Ady Abraham2139f732019-11-13 18:56:40 -0800204
Dominik Laskowski0c252702021-12-20 20:32:09 -0800205 const auto minRate90 = configs.getMinRefreshRateByPolicy();
206 const auto performanceRate90 = configs.getMaxRefreshRateByPolicy();
Ady Abraham2139f732019-11-13 18:56:40 -0800207
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800208 EXPECT_EQ(kMode90_G1, performanceRate);
209 EXPECT_EQ(kMode90_G1, minRate90);
210 EXPECT_EQ(kMode90_G1, performanceRate90);
Ady Abrahamabc27602020-04-08 17:20:29 -0700211}
212
Dominik Laskowski0c252702021-12-20 20:32:09 -0800213TEST_F(RefreshRateConfigsTest, twoModes_storesFullRefreshRateMap_differentResolutions) {
214 TestableRefreshRateConfigs configs(kModes_60_90_4K, kModeId60);
Ady Abrahamabc27602020-04-08 17:20:29 -0700215
Dominik Laskowski0c252702021-12-20 20:32:09 -0800216 const auto minRate = configs.getMinRefreshRateByPolicy();
217 const auto performanceRate = configs.getMaxSupportedRefreshRate();
218 const auto minRate60 = configs.getMinRefreshRateByPolicy();
219 const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
Ady Abrahamabc27602020-04-08 17:20:29 -0700220
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800221 EXPECT_EQ(kMode60, minRate);
222 EXPECT_EQ(kMode60, minRate60);
223 EXPECT_EQ(kMode60, performanceRate60);
Ady Abrahamabc27602020-04-08 17:20:29 -0700224
Dominik Laskowski0c252702021-12-20 20:32:09 -0800225 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}), 0);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800226 configs.setActiveModeId(kModeId90);
Ady Abrahamabc27602020-04-08 17:20:29 -0700227
Dominik Laskowski0c252702021-12-20 20:32:09 -0800228 const auto minRate90 = configs.getMinRefreshRateByPolicy();
229 const auto performanceRate90 = configs.getMaxRefreshRateByPolicy();
Ady Abrahamabc27602020-04-08 17:20:29 -0700230
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800231 EXPECT_EQ(kMode90_4K, performanceRate);
232 EXPECT_EQ(kMode90_4K, minRate90);
233 EXPECT_EQ(kMode90_4K, performanceRate90);
Ady Abraham2139f732019-11-13 18:56:40 -0800234}
235
Dominik Laskowski0c252702021-12-20 20:32:09 -0800236TEST_F(RefreshRateConfigsTest, twoModes_policyChange) {
237 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ana Krulec3f6a2062020-01-23 15:48:01 -0800238
Dominik Laskowski0c252702021-12-20 20:32:09 -0800239 const auto minRate = configs.getMinRefreshRateByPolicy();
240 const auto performanceRate = configs.getMaxRefreshRateByPolicy();
Ady Abraham2139f732019-11-13 18:56:40 -0800241
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800242 EXPECT_EQ(kMode60, minRate);
243 EXPECT_EQ(kMode90, performanceRate);
Ady Abraham2139f732019-11-13 18:56:40 -0800244
Dominik Laskowski0c252702021-12-20 20:32:09 -0800245 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
Ady Abraham2139f732019-11-13 18:56:40 -0800246
Dominik Laskowski0c252702021-12-20 20:32:09 -0800247 const auto minRate60 = configs.getMinRefreshRateByPolicy();
248 const auto performanceRate60 = configs.getMaxRefreshRateByPolicy();
249
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800250 EXPECT_EQ(kMode60, minRate60);
251 EXPECT_EQ(kMode60, performanceRate60);
Ady Abraham2139f732019-11-13 18:56:40 -0800252}
253
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800254TEST_F(RefreshRateConfigsTest, twoModes_getActiveMode) {
Dominik Laskowski0c252702021-12-20 20:32:09 -0800255 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abraham2139f732019-11-13 18:56:40 -0800256 {
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700257 const auto& mode = configs.getActiveMode();
258 EXPECT_EQ(mode.getId(), kModeId60);
Ady Abraham2139f732019-11-13 18:56:40 -0800259 }
260
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800261 configs.setActiveModeId(kModeId90);
Ady Abraham2139f732019-11-13 18:56:40 -0800262 {
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700263 const auto& mode = configs.getActiveMode();
264 EXPECT_EQ(mode.getId(), kModeId90);
Ady Abraham2139f732019-11-13 18:56:40 -0800265 }
266
Dominik Laskowski0c252702021-12-20 20:32:09 -0800267 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
Ady Abraham2139f732019-11-13 18:56:40 -0800268 {
Dominik Laskowskif8734e02022-08-26 09:06:59 -0700269 const auto& mode = configs.getActiveMode();
270 EXPECT_EQ(mode.getId(), kModeId90);
Ady Abraham2139f732019-11-13 18:56:40 -0800271 }
272}
273
Steven Thomasbb374322020-04-28 22:47:16 -0700274TEST_F(RefreshRateConfigsTest, getBestRefreshRate_noLayers) {
Dominik Laskowski0c252702021-12-20 20:32:09 -0800275 {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800276 TestableRefreshRateConfigs configs(kModes_60_72_90, kModeId72);
Ana Krulec3d367c82020-02-25 15:02:01 -0800277
Dominik Laskowski0c252702021-12-20 20:32:09 -0800278 // If there are no layers we select the default frame rate, which is the max of the primary
279 // range.
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800280 EXPECT_EQ(kMode90, configs.getBestRefreshRate());
Ana Krulec3d367c82020-02-25 15:02:01 -0800281
Dominik Laskowski0c252702021-12-20 20:32:09 -0800282 EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), NO_ERROR);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800283 EXPECT_EQ(kMode60, configs.getBestRefreshRate());
Dominik Laskowski0c252702021-12-20 20:32:09 -0800284 }
285 {
286 // We select max even when this will cause a non-seamless switch.
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800287 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Dominik Laskowski0c252702021-12-20 20:32:09 -0800288 constexpr bool kAllowGroupSwitching = true;
289 EXPECT_EQ(configs.setDisplayManagerPolicy({kModeId90, kAllowGroupSwitching, {0_Hz, 90_Hz}}),
290 NO_ERROR);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800291 EXPECT_EQ(kMode90_G1, configs.getBestRefreshRate());
Dominik Laskowski0c252702021-12-20 20:32:09 -0800292 }
Ana Krulec3d367c82020-02-25 15:02:01 -0800293}
294
Steven Thomasbb374322020-04-28 22:47:16 -0700295TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800296 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800297
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700298 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800299 auto& lr = layers[0];
300
301 lr.vote = LayerVoteType::Min;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800302 lr.name = "Min";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800303 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800304
305 lr.vote = LayerVoteType::Max;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800306 lr.name = "Max";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800307 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800308
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700309 lr.desiredRefreshRate = 90_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800310 lr.vote = LayerVoteType::Heuristic;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800311 lr.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800312 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800313
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700314 lr.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800315 lr.name = "60Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800316 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800317
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700318 lr.desiredRefreshRate = 45_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800319 lr.name = "45Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800320 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800321
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700322 lr.desiredRefreshRate = 30_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800323 lr.name = "30Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800324 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800325
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700326 lr.desiredRefreshRate = 24_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800327 lr.name = "24Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800328 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800329
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800330 lr.name = "";
Dominik Laskowski0c252702021-12-20 20:32:09 -0800331 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800332
333 lr.vote = LayerVoteType::Min;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800334 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800335
336 lr.vote = LayerVoteType::Max;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800337 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800338
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700339 lr.desiredRefreshRate = 90_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800340 lr.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800341 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800342
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700343 lr.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800344 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800345
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700346 lr.desiredRefreshRate = 45_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800347 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800348
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700349 lr.desiredRefreshRate = 30_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800350 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800351
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700352 lr.desiredRefreshRate = 24_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800353 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800354
Dominik Laskowski0c252702021-12-20 20:32:09 -0800355 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800356
357 lr.vote = LayerVoteType::Min;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800358 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800359
360 lr.vote = LayerVoteType::Max;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800361 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800362
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700363 lr.desiredRefreshRate = 90_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800364 lr.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800365 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800366
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700367 lr.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800368 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800369
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700370 lr.desiredRefreshRate = 45_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800371 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800372
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700373 lr.desiredRefreshRate = 30_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800374 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800375
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700376 lr.desiredRefreshRate = 24_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800377 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800378
Dominik Laskowski0c252702021-12-20 20:32:09 -0800379 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {0_Hz, 120_Hz}}), 0);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800380 lr.vote = LayerVoteType::Min;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800381 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800382
383 lr.vote = LayerVoteType::Max;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800384 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800385
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700386 lr.desiredRefreshRate = 90_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800387 lr.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800388 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800389
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700390 lr.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800391 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800392
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700393 lr.desiredRefreshRate = 45_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800394 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800395
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700396 lr.desiredRefreshRate = 30_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800397 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800398
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700399 lr.desiredRefreshRate = 24_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800400 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800401}
402
rnlee3bd610662021-06-23 16:27:57 -0700403TEST_F(RefreshRateConfigsTest, getBestRefreshRate_multipleThreshold_60_90) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800404 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60, {.frameRateMultipleThreshold = 90});
rnlee3bd610662021-06-23 16:27:57 -0700405
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700406 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
rnlee3bd610662021-06-23 16:27:57 -0700407 auto& lr = layers[0];
408
409 lr.vote = LayerVoteType::Min;
410 lr.name = "Min";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800411 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700412
413 lr.vote = LayerVoteType::Max;
414 lr.name = "Max";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800415 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700416
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700417 lr.desiredRefreshRate = 90_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700418 lr.vote = LayerVoteType::Heuristic;
419 lr.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800420 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700421
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700422 lr.desiredRefreshRate = 60_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700423 lr.name = "60Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800424 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700425
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700426 lr.desiredRefreshRate = 45_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700427 lr.name = "45Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800428 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700429
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700430 lr.desiredRefreshRate = 30_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700431 lr.name = "30Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800432 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700433
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700434 lr.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700435 lr.name = "24Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800436 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700437}
438
Steven Thomasbb374322020-04-28 22:47:16 -0700439TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800440 TestableRefreshRateConfigs configs(kModes_60_72_90, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800441
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700442 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800443 auto& lr = layers[0];
444
445 lr.vote = LayerVoteType::Min;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800446 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800447
448 lr.vote = LayerVoteType::Max;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800449 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800450
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700451 lr.desiredRefreshRate = 90_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800452 lr.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800453 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800454
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700455 lr.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800456 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800457
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700458 lr.desiredRefreshRate = 45_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800459 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800460
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700461 lr.desiredRefreshRate = 30_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800462 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800463
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700464 lr.desiredRefreshRate = 24_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800465 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800466}
467
Steven Thomasbb374322020-04-28 22:47:16 -0700468TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90_120) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800469 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800470
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700471 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800472 auto& lr1 = layers[0];
473 auto& lr2 = layers[1];
474
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700475 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800476 lr1.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700477 lr2.desiredRefreshRate = 60_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800478 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800479 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800480
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700481 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800482 lr1.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700483 lr2.desiredRefreshRate = 48_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800484 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800485 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800486
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700487 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800488 lr1.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700489 lr2.desiredRefreshRate = 48_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800490 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800491 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800492}
493
Steven Thomasbb374322020-04-28 22:47:16 -0700494TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800495 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
Ady Abraham71c437d2020-01-31 15:56:57 -0800496
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700497 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
Ady Abraham71c437d2020-01-31 15:56:57 -0800498 auto& lr1 = layers[0];
499 auto& lr2 = layers[1];
500
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700501 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800502 lr1.vote = LayerVoteType::ExplicitDefault;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800503 lr1.name = "24Hz ExplicitDefault";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700504 lr2.desiredRefreshRate = 60_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800505 lr2.vote = LayerVoteType::Heuristic;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800506 lr2.name = "60Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800507 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800508
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700509 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800510 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800511 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700512 lr2.desiredRefreshRate = 60_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800513 lr2.vote = LayerVoteType::Heuristic;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800514 lr2.name = "60Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800515 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800516
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700517 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800518 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800519 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700520 lr2.desiredRefreshRate = 60_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800521 lr2.vote = LayerVoteType::ExplicitDefault;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800522 lr2.name = "60Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800523 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800524
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700525 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800526 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800527 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700528 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800529 lr2.vote = LayerVoteType::Heuristic;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800530 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800531 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800532
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700533 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800534 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
535 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700536 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800537 lr2.vote = LayerVoteType::ExplicitDefault;
538 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800539 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800540
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700541 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800542 lr1.vote = LayerVoteType::ExplicitDefault;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800543 lr1.name = "24Hz ExplicitDefault";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700544 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800545 lr2.vote = LayerVoteType::Heuristic;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800546 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800547 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800548
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700549 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800550 lr1.vote = LayerVoteType::Heuristic;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800551 lr1.name = "24Hz Heuristic";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700552 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800553 lr2.vote = LayerVoteType::ExplicitDefault;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800554 lr2.name = "90Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800555 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800556
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700557 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800558 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800559 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700560 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800561 lr2.vote = LayerVoteType::ExplicitDefault;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800562 lr2.name = "90Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800563 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800564
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700565 lr1.desiredRefreshRate = 24_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800566 lr1.vote = LayerVoteType::ExplicitDefault;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800567 lr1.name = "24Hz ExplicitDefault";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700568 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800569 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800570 lr2.name = "90Hz ExplicitExactOrMultiple";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800571 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham71c437d2020-01-31 15:56:57 -0800572}
573
rnlee3bd610662021-06-23 16:27:57 -0700574TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes_multipleThreshold) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800575 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
576 {.frameRateMultipleThreshold = 120});
rnlee3bd610662021-06-23 16:27:57 -0700577
Ady Abraham62f51d92022-08-24 22:20:22 +0000578 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}, {.weight = 1.f}};
rnlee3bd610662021-06-23 16:27:57 -0700579 auto& lr1 = layers[0];
580 auto& lr2 = layers[1];
Ady Abraham62f51d92022-08-24 22:20:22 +0000581 auto& lr3 = layers[2];
rnlee3bd610662021-06-23 16:27:57 -0700582
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700583 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700584 lr1.vote = LayerVoteType::ExplicitDefault;
585 lr1.name = "24Hz ExplicitDefault";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700586 lr2.desiredRefreshRate = 60_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700587 lr2.vote = LayerVoteType::Heuristic;
588 lr2.name = "60Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800589 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700590
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700591 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700592 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
593 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700594 lr2.desiredRefreshRate = 60_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700595 lr2.vote = LayerVoteType::Heuristic;
596 lr2.name = "60Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800597 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700598
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700599 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700600 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
601 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700602 lr2.desiredRefreshRate = 60_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700603 lr2.vote = LayerVoteType::ExplicitDefault;
604 lr2.name = "60Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800605 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700606
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700607 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700608 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
609 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700610 lr2.desiredRefreshRate = 90_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700611 lr2.vote = LayerVoteType::Heuristic;
612 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800613 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700614
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700615 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700616 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
617 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700618 lr2.desiredRefreshRate = 90_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700619 lr2.vote = LayerVoteType::ExplicitDefault;
620 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800621 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700622
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700623 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700624 lr1.vote = LayerVoteType::ExplicitDefault;
625 lr1.name = "24Hz ExplicitDefault";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700626 lr2.desiredRefreshRate = 90_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700627 lr2.vote = LayerVoteType::Heuristic;
628 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800629 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700630
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700631 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700632 lr1.vote = LayerVoteType::Heuristic;
633 lr1.name = "24Hz Heuristic";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700634 lr2.desiredRefreshRate = 90_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700635 lr2.vote = LayerVoteType::ExplicitDefault;
636 lr2.name = "90Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800637 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700638
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700639 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700640 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
641 lr1.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700642 lr2.desiredRefreshRate = 90_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700643 lr2.vote = LayerVoteType::ExplicitDefault;
644 lr2.name = "90Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800645 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700646
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700647 lr1.desiredRefreshRate = 24_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700648 lr1.vote = LayerVoteType::ExplicitDefault;
649 lr1.name = "24Hz ExplicitDefault";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700650 lr2.desiredRefreshRate = 90_Hz;
rnlee3bd610662021-06-23 16:27:57 -0700651 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
652 lr2.name = "90Hz ExplicitExactOrMultiple";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800653 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamae2e3c72022-08-13 05:12:13 +0000654
655 lr1.desiredRefreshRate = 24_Hz;
656 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
657 lr1.name = "24Hz ExplicitExactOrMultiple";
658 lr2.vote = LayerVoteType::Max;
659 lr2.name = "Max";
660 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
661
662 lr1.desiredRefreshRate = 24_Hz;
663 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
664 lr1.name = "24Hz ExplicitExactOrMultiple";
665 lr2.desiredRefreshRate = 120_Hz;
666 lr2.vote = LayerVoteType::ExplicitDefault;
667 lr2.name = "120Hz ExplicitDefault";
668 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
669
670 lr1.desiredRefreshRate = 24_Hz;
671 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
672 lr1.name = "24Hz ExplicitExactOrMultiple";
673 lr2.desiredRefreshRate = 120_Hz;
674 lr2.vote = LayerVoteType::ExplicitExact;
675 lr2.name = "120Hz ExplicitExact";
676 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abraham62f51d92022-08-24 22:20:22 +0000677
678 lr1.desiredRefreshRate = 10_Hz;
679 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
680 lr1.name = "30Hz ExplicitExactOrMultiple";
681 lr2.desiredRefreshRate = 120_Hz;
682 lr2.vote = LayerVoteType::Heuristic;
683 lr2.name = "120Hz ExplicitExact";
684 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
685
686 lr1.desiredRefreshRate = 30_Hz;
687 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
688 lr1.name = "30Hz ExplicitExactOrMultiple";
689 lr2.desiredRefreshRate = 30_Hz;
690 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
691 lr2.name = "30Hz ExplicitExactOrMultiple";
692 lr3.vote = LayerVoteType::Heuristic;
693 lr3.desiredRefreshRate = 120_Hz;
694 lr3.name = "120Hz Heuristic";
695 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
rnlee3bd610662021-06-23 16:27:57 -0700696}
697
Steven Thomasbb374322020-04-28 22:47:16 -0700698TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800699 TestableRefreshRateConfigs configs(kModes_30_60, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800700
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700701 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800702 auto& lr = layers[0];
703
704 lr.vote = LayerVoteType::Min;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800705 EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800706
707 lr.vote = LayerVoteType::Max;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800708 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800709
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700710 lr.desiredRefreshRate = 90_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800711 lr.vote = LayerVoteType::Heuristic;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800712 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800713
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700714 lr.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800715 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800716
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700717 lr.desiredRefreshRate = 45_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800718 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800719
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700720 lr.desiredRefreshRate = 30_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800721 EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800722
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700723 lr.desiredRefreshRate = 24_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800724 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800725}
726
Steven Thomasbb374322020-04-28 22:47:16 -0700727TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800728 TestableRefreshRateConfigs configs(kModes_30_60_72_90, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800729
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700730 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800731 auto& lr = layers[0];
732
733 lr.vote = LayerVoteType::Min;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800734 lr.name = "Min";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800735 EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800736
737 lr.vote = LayerVoteType::Max;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800738 lr.name = "Max";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800739 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800740
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700741 lr.desiredRefreshRate = 90_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800742 lr.vote = LayerVoteType::Heuristic;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800743 lr.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800744 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800745
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700746 lr.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800747 lr.name = "60Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800748 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
749 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800750
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700751 lr.desiredRefreshRate = 45_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800752 lr.name = "45Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800753 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
754 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800755
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700756 lr.desiredRefreshRate = 30_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800757 lr.name = "30Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800758 EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
759 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800760
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700761 lr.desiredRefreshRate = 24_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800762 lr.name = "24Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800763 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
764 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800765
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700766 lr.desiredRefreshRate = 24_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800767 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
768 lr.name = "24Hz ExplicitExactOrMultiple";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800769 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
770 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800771}
772
Steven Thomasbb374322020-04-28 22:47:16 -0700773TEST_F(RefreshRateConfigsTest, getBestRefreshRate_PriorityTest) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800774 TestableRefreshRateConfigs configs(kModes_30_60_90, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800775
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700776 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800777 auto& lr1 = layers[0];
778 auto& lr2 = layers[1];
779
780 lr1.vote = LayerVoteType::Min;
781 lr2.vote = LayerVoteType::Max;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800782 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800783
784 lr1.vote = LayerVoteType::Min;
785 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700786 lr2.desiredRefreshRate = 24_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800787 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800788
789 lr1.vote = LayerVoteType::Min;
Ady Abraham71c437d2020-01-31 15:56:57 -0800790 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700791 lr2.desiredRefreshRate = 24_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800792 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800793
794 lr1.vote = LayerVoteType::Max;
795 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700796 lr2.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800797 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800798
799 lr1.vote = LayerVoteType::Max;
Ady Abraham71c437d2020-01-31 15:56:57 -0800800 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700801 lr2.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800802 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800803
804 lr1.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700805 lr1.desiredRefreshRate = 15_Hz;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800806 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700807 lr2.desiredRefreshRate = 45_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800808 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800809
810 lr1.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700811 lr1.desiredRefreshRate = 30_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800812 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700813 lr2.desiredRefreshRate = 45_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800814 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800815}
816
Steven Thomasbb374322020-04-28 22:47:16 -0700817TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800818 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800819
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700820 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800821 auto& lr = layers[0];
822
Ady Abraham71c437d2020-01-31 15:56:57 -0800823 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800824 for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700825 lr.desiredRefreshRate = Fps::fromValue(fps);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800826 const auto mode = configs.getBestRefreshRate(layers);
827 EXPECT_EQ(kMode60, mode) << lr.desiredRefreshRate << " chooses "
828 << to_string(mode->getFps());
Ady Abraham8a82ba62020-01-17 12:43:17 -0800829 }
830}
831
rnlee3bd610662021-06-23 16:27:57 -0700832TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo_multipleThreshold_60_120) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800833 TestableRefreshRateConfigs configs(kModes_60_120, kModeId60,
834 {.frameRateMultipleThreshold = 120});
rnlee3bd610662021-06-23 16:27:57 -0700835
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700836 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
rnlee3bd610662021-06-23 16:27:57 -0700837 auto& lr = layers[0];
838
839 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
840 for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700841 lr.desiredRefreshRate = Fps::fromValue(fps);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800842 const auto mode = configs.getBestRefreshRate(layers);
843 EXPECT_EQ(kMode60, mode) << lr.desiredRefreshRate << " chooses "
844 << to_string(mode->getFps());
rnlee3bd610662021-06-23 16:27:57 -0700845 }
846}
847
Dominik Laskowski0c252702021-12-20 20:32:09 -0800848TEST_F(RefreshRateConfigsTest, twoModes_getBestRefreshRate_Explicit) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800849 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abraham8a82ba62020-01-17 12:43:17 -0800850
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700851 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
Ady Abraham8a82ba62020-01-17 12:43:17 -0800852 auto& lr1 = layers[0];
853 auto& lr2 = layers[1];
854
855 lr1.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700856 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800857 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700858 lr2.desiredRefreshRate = 90_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800859 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800860
861 lr1.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700862 lr1.desiredRefreshRate = 90_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800863 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700864 lr2.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800865 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham8a82ba62020-01-17 12:43:17 -0800866
867 lr1.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700868 lr1.desiredRefreshRate = 90_Hz;
Ady Abraham71c437d2020-01-31 15:56:57 -0800869 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700870 lr2.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800871 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham2139f732019-11-13 18:56:40 -0800872}
873
Steven Thomasbb374322020-04-28 22:47:16 -0700874TEST_F(RefreshRateConfigsTest, getBestRefreshRate_75HzContent) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800875 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abrahamf6b77072020-01-30 14:22:54 -0800876
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700877 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abrahamf6b77072020-01-30 14:22:54 -0800878 auto& lr = layers[0];
879
Ady Abraham71c437d2020-01-31 15:56:57 -0800880 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
Ady Abrahamf6b77072020-01-30 14:22:54 -0800881 for (float fps = 75.0f; fps < 100.0f; fps += 0.1f) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700882 lr.desiredRefreshRate = Fps::fromValue(fps);
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800883 const auto mode = configs.getBestRefreshRate(layers, {});
884 EXPECT_EQ(kMode90, mode) << lr.desiredRefreshRate << " chooses "
885 << to_string(mode->getFps());
Ady Abrahamf6b77072020-01-30 14:22:54 -0800886 }
887}
888
Steven Thomasbb374322020-04-28 22:47:16 -0700889TEST_F(RefreshRateConfigsTest, getBestRefreshRate_Multiples) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800890 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abraham34702102020-02-10 14:12:05 -0800891
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700892 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
Ady Abraham34702102020-02-10 14:12:05 -0800893 auto& lr1 = layers[0];
894 auto& lr2 = layers[1];
895
896 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700897 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800898 lr1.name = "60Hz ExplicitExactOrMultiple";
Ady Abraham34702102020-02-10 14:12:05 -0800899 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700900 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800901 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800902 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham34702102020-02-10 14:12:05 -0800903
904 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700905 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800906 lr1.name = "60Hz ExplicitExactOrMultiple";
907 lr2.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700908 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800909 lr2.name = "90Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800910 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800911
912 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700913 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800914 lr1.name = "60Hz ExplicitExactOrMultiple";
Ady Abraham34702102020-02-10 14:12:05 -0800915 lr2.vote = LayerVoteType::Max;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800916 lr2.name = "Max";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800917 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham34702102020-02-10 14:12:05 -0800918
919 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700920 lr1.desiredRefreshRate = 30_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800921 lr1.name = "30Hz ExplicitExactOrMultiple";
Ady Abraham34702102020-02-10 14:12:05 -0800922 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700923 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800924 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800925 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham34702102020-02-10 14:12:05 -0800926
927 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700928 lr1.desiredRefreshRate = 30_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800929 lr1.name = "30Hz ExplicitExactOrMultiple";
Ady Abraham34702102020-02-10 14:12:05 -0800930 lr2.vote = LayerVoteType::Max;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800931 lr2.name = "Max";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800932 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800933}
934
935TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -0800936 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800937
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700938 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800939 auto& lr1 = layers[0];
940 auto& lr2 = layers[1];
941
942 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700943 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800944 lr1.name = "60Hz ExplicitExactOrMultiple";
945 lr2.vote = LayerVoteType::NoVote;
946 lr2.name = "NoVote";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800947 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800948
949 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700950 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800951 lr1.name = "60Hz ExplicitExactOrMultiple";
952 lr2.vote = LayerVoteType::NoVote;
953 lr2.name = "NoVote";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800954 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800955
956 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700957 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800958 lr1.name = "60Hz ExplicitExactOrMultiple";
959 lr2.vote = LayerVoteType::Max;
960 lr2.name = "Max";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800961 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800962
963 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700964 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800965 lr1.name = "60Hz ExplicitExactOrMultiple";
966 lr2.vote = LayerVoteType::Max;
967 lr2.name = "Max";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800968 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800969
970 // The other layer starts to provide buffers
971 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700972 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800973 lr1.name = "60Hz ExplicitExactOrMultiple";
974 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -0700975 lr2.desiredRefreshRate = 90_Hz;
Ady Abraham4ccdcb42020-02-11 17:34:34 -0800976 lr2.name = "90Hz Heuristic";
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800977 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abraham6fb599b2020-03-05 13:48:22 -0800978}
979
ramindani38c84982022-08-29 18:02:57 +0000980TEST_F(RefreshRateConfigsTest, powerOnImminentConsidered) {
981 RefreshRateConfigs configs(kModes_60_90, kModeId60);
982
983 auto [refreshRate, signals] = configs.getBestRefreshRate({}, {});
984 EXPECT_FALSE(signals.powerOnImminent);
985 EXPECT_EQ(kMode90, refreshRate);
986
987 std::tie(refreshRate, signals) = configs.getBestRefreshRate({}, {.powerOnImminent = true});
988 EXPECT_TRUE(signals.powerOnImminent);
989 EXPECT_EQ(kMode90, refreshRate);
990
991 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
992 auto& lr1 = layers[0];
993 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
994 lr1.desiredRefreshRate = 60_Hz;
995 lr1.name = "60Hz ExplicitExactOrMultiple";
996
997 std::tie(refreshRate, signals) = configs.getBestRefreshRate(layers, {.powerOnImminent = false});
998 EXPECT_FALSE(signals.powerOnImminent);
999 EXPECT_EQ(kMode60, refreshRate);
1000
1001 std::tie(refreshRate, signals) = configs.getBestRefreshRate(layers, {.powerOnImminent = true});
1002 EXPECT_TRUE(signals.powerOnImminent);
1003 EXPECT_EQ(kMode90, refreshRate);
1004}
1005
Ady Abraham6fb599b2020-03-05 13:48:22 -08001006TEST_F(RefreshRateConfigsTest, touchConsidered) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001007 RefreshRateConfigs configs(kModes_60_90, kModeId60);
1008
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001009 auto [_, signals] = configs.getBestRefreshRate({}, {});
1010 EXPECT_FALSE(signals.touch);
Ady Abraham6fb599b2020-03-05 13:48:22 -08001011
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001012 std::tie(std::ignore, signals) = configs.getBestRefreshRate({}, {.touch = true});
1013 EXPECT_TRUE(signals.touch);
Ady Abraham6fb599b2020-03-05 13:48:22 -08001014
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001015 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
Ady Abraham6fb599b2020-03-05 13:48:22 -08001016 auto& lr1 = layers[0];
1017 auto& lr2 = layers[1];
1018
1019 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001020 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham6fb599b2020-03-05 13:48:22 -08001021 lr1.name = "60Hz ExplicitExactOrMultiple";
1022 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001023 lr2.desiredRefreshRate = 60_Hz;
Steven Thomasf734df42020-04-13 21:09:28 -07001024 lr2.name = "60Hz Heuristic";
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001025 std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
1026 EXPECT_TRUE(signals.touch);
Ady Abraham6fb599b2020-03-05 13:48:22 -08001027
1028 lr1.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001029 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham6fb599b2020-03-05 13:48:22 -08001030 lr1.name = "60Hz ExplicitExactOrMultiple";
1031 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001032 lr2.desiredRefreshRate = 60_Hz;
Steven Thomasf734df42020-04-13 21:09:28 -07001033 lr2.name = "60Hz Heuristic";
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001034 std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
1035 EXPECT_FALSE(signals.touch);
Ady Abraham6fb599b2020-03-05 13:48:22 -08001036
1037 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001038 lr1.desiredRefreshRate = 60_Hz;
Ady Abraham6fb599b2020-03-05 13:48:22 -08001039 lr1.name = "60Hz ExplicitExactOrMultiple";
1040 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001041 lr2.desiredRefreshRate = 60_Hz;
Steven Thomasf734df42020-04-13 21:09:28 -07001042 lr2.name = "60Hz Heuristic";
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001043 std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
1044 EXPECT_TRUE(signals.touch);
Ady Abraham6fb599b2020-03-05 13:48:22 -08001045
1046 lr1.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001047 lr1.desiredRefreshRate = 60_Hz;
Steven Thomasf734df42020-04-13 21:09:28 -07001048 lr1.name = "60Hz ExplicitExactOrMultiple";
Ady Abraham6fb599b2020-03-05 13:48:22 -08001049 lr2.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001050 lr2.desiredRefreshRate = 60_Hz;
Steven Thomasf734df42020-04-13 21:09:28 -07001051 lr2.name = "60Hz Heuristic";
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001052 std::tie(std::ignore, signals) = configs.getBestRefreshRate(layers, {.touch = true});
1053 EXPECT_FALSE(signals.touch);
Ady Abraham34702102020-02-10 14:12:05 -08001054}
1055
Steven Thomasbb374322020-04-28 22:47:16 -07001056TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitDefault) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001057 TestableRefreshRateConfigs configs(kModes_60_90_72_120, kModeId60);
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001058
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001059 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001060 auto& lr = layers[0];
1061
1062 // Prepare a table with the vote and the expected refresh rate
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001063 const std::initializer_list<std::pair<Fps, Fps>> testCases = {
1064 {130_Hz, 120_Hz}, {120_Hz, 120_Hz}, {119_Hz, 120_Hz}, {110_Hz, 120_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001065
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001066 {100_Hz, 90_Hz}, {90_Hz, 90_Hz}, {89_Hz, 90_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001067
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001068 {80_Hz, 72_Hz}, {73_Hz, 72_Hz}, {72_Hz, 72_Hz}, {71_Hz, 72_Hz}, {70_Hz, 72_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001069
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001070 {65_Hz, 60_Hz}, {60_Hz, 60_Hz}, {59_Hz, 60_Hz}, {58_Hz, 60_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001071
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001072 {55_Hz, 90_Hz}, {50_Hz, 90_Hz}, {45_Hz, 90_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001073
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001074 {42_Hz, 120_Hz}, {40_Hz, 120_Hz}, {39_Hz, 120_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001075
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001076 {37_Hz, 72_Hz}, {36_Hz, 72_Hz}, {35_Hz, 72_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001077
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001078 {30_Hz, 60_Hz},
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001079 };
1080
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001081 for (auto [desired, expected] : testCases) {
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001082 lr.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001083 lr.desiredRefreshRate = desired;
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001084
1085 std::stringstream ss;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001086 ss << "ExplicitDefault " << desired;
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001087 lr.name = ss.str();
1088
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001089 EXPECT_EQ(expected, configs.getBestRefreshRate(layers)->getFps());
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001090 }
1091}
1092
1093TEST_F(RefreshRateConfigsTest,
1094 getBestRefreshRate_ExplicitExactOrMultiple_WithFractionalRefreshRates) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001095 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001096 auto& lr = layers[0];
1097
1098 // Test that 23.976 will choose 24 if 23.976 is not supported
1099 {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001100 TestableRefreshRateConfigs configs(makeModes(kMode24, kMode25, kMode30, kMode30Frac,
1101 kMode60, kMode60Frac),
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001102 kModeId60);
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001103
1104 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001105 lr.desiredRefreshRate = 23.976_Hz;
1106 lr.name = "ExplicitExactOrMultiple 23.976 Hz";
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001107 EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001108 }
1109
1110 // Test that 24 will choose 23.976 if 24 is not supported
1111 {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001112 TestableRefreshRateConfigs configs(makeModes(kMode24Frac, kMode25, kMode30, kMode30Frac,
1113 kMode60, kMode60Frac),
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001114 kModeId60);
Dominik Laskowski0c252702021-12-20 20:32:09 -08001115
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001116 lr.desiredRefreshRate = 24_Hz;
1117 lr.name = "ExplicitExactOrMultiple 24 Hz";
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001118 EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001119 }
1120
1121 // Test that 29.97 will prefer 59.94 over 60 and 30
1122 {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001123 TestableRefreshRateConfigs configs(makeModes(kMode24, kMode24Frac, kMode25, kMode30,
1124 kMode60, kMode60Frac),
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001125 kModeId60);
Dominik Laskowski0c252702021-12-20 20:32:09 -08001126
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001127 lr.desiredRefreshRate = 29.97_Hz;
1128 lr.name = "ExplicitExactOrMultiple 29.97 Hz";
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001129 EXPECT_EQ(kModeId60Frac, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001130 }
1131}
1132
1133TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExact_WithFractionalRefreshRates) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001134 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001135 auto& lr = layers[0];
1136
1137 // Test that voting for supported refresh rate will select this refresh rate
1138 {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001139 TestableRefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60);
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001140
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001141 for (auto desired : {23.976_Hz, 24_Hz, 25_Hz, 29.97_Hz, 30_Hz, 50_Hz, 59.94_Hz, 60_Hz}) {
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001142 lr.vote = LayerVoteType::ExplicitExact;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001143 lr.desiredRefreshRate = desired;
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001144 std::stringstream ss;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001145 ss << "ExplicitExact " << desired;
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001146 lr.name = ss.str();
1147
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001148 EXPECT_EQ(lr.desiredRefreshRate, configs.getBestRefreshRate(layers)->getFps());
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001149 }
1150 }
1151
1152 // Test that 23.976 will choose 24 if 23.976 is not supported
1153 {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001154 TestableRefreshRateConfigs configs(makeModes(kMode24, kMode25, kMode30, kMode30Frac,
1155 kMode60, kMode60Frac),
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001156 kModeId60);
Dominik Laskowski0c252702021-12-20 20:32:09 -08001157
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001158 lr.vote = LayerVoteType::ExplicitExact;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001159 lr.desiredRefreshRate = 23.976_Hz;
1160 lr.name = "ExplicitExact 23.976 Hz";
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001161 EXPECT_EQ(kModeId24, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001162 }
1163
1164 // Test that 24 will choose 23.976 if 24 is not supported
1165 {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001166 TestableRefreshRateConfigs configs(makeModes(kMode24Frac, kMode25, kMode30, kMode30Frac,
1167 kMode60, kMode60Frac),
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001168 kModeId60);
Dominik Laskowski0c252702021-12-20 20:32:09 -08001169
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001170 lr.desiredRefreshRate = 24_Hz;
1171 lr.name = "ExplicitExact 24 Hz";
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001172 EXPECT_EQ(kModeId24Frac, configs.getBestRefreshRate(layers)->getId());
Ady Abraham5b8afb5a2020-03-06 14:57:26 -08001173 }
Alec Mouri0a1cc962019-03-14 12:33:02 -07001174}
1175
Alec Mouri11232a22020-05-14 18:06:25 -07001176TEST_F(RefreshRateConfigsTest,
1177 getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresTouchFlag) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001178 RefreshRateConfigs configs(kModes_60_90, kModeId90);
Alec Mouri11232a22020-05-14 18:06:25 -07001179
Dominik Laskowski0c252702021-12-20 20:32:09 -08001180 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
Alec Mouri11232a22020-05-14 18:06:25 -07001181
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001182 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Alec Mouri11232a22020-05-14 18:06:25 -07001183 auto& lr = layers[0];
1184
Alec Mouri11232a22020-05-14 18:06:25 -07001185 lr.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001186 lr.desiredRefreshRate = 60_Hz;
Alec Mouri11232a22020-05-14 18:06:25 -07001187 lr.name = "60Hz ExplicitDefault";
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001188 lr.focused = true;
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001189
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001190 const auto [mode, signals] = configs.getBestRefreshRate(layers, {.touch = true, .idle = true});
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001191
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001192 EXPECT_EQ(mode, kMode60);
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001193 EXPECT_FALSE(signals.touch);
Alec Mouri11232a22020-05-14 18:06:25 -07001194}
1195
1196TEST_F(RefreshRateConfigsTest,
1197 getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresIdleFlag) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001198 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Alec Mouri11232a22020-05-14 18:06:25 -07001199
Dominik Laskowski0c252702021-12-20 20:32:09 -08001200 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}, {60_Hz, 90_Hz}}), 0);
Alec Mouri11232a22020-05-14 18:06:25 -07001201
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001202 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Alec Mouri11232a22020-05-14 18:06:25 -07001203 auto& lr = layers[0];
1204
Alec Mouri11232a22020-05-14 18:06:25 -07001205 lr.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001206 lr.desiredRefreshRate = 90_Hz;
Alec Mouri11232a22020-05-14 18:06:25 -07001207 lr.name = "90Hz ExplicitDefault";
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001208 lr.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001209 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers, {.idle = true}));
Alec Mouri11232a22020-05-14 18:06:25 -07001210}
1211
1212TEST_F(RefreshRateConfigsTest,
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001213 getBestRefreshRate_withDisplayManagerRequestingSingleRate_onlySwitchesRatesForExplicitFocusedLayers) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001214 TestableRefreshRateConfigs configs(kModes_60_90, kModeId90);
Alec Mouri11232a22020-05-14 18:06:25 -07001215
Dominik Laskowski0c252702021-12-20 20:32:09 -08001216 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
Alec Mouri11232a22020-05-14 18:06:25 -07001217
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001218 const auto [mode, signals] = configs.getBestRefreshRateAndSignals({}, {});
1219 EXPECT_EQ(mode, kMode90);
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001220 EXPECT_FALSE(signals.touch);
Alec Mouri11232a22020-05-14 18:06:25 -07001221
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001222 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Alec Mouri11232a22020-05-14 18:06:25 -07001223 auto& lr = layers[0];
1224
1225 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001226 lr.desiredRefreshRate = 60_Hz;
Alec Mouri11232a22020-05-14 18:06:25 -07001227 lr.name = "60Hz ExplicitExactOrMultiple";
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001228 lr.focused = false;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001229 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001230
1231 lr.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001232 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Alec Mouri11232a22020-05-14 18:06:25 -07001233
1234 lr.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001235 lr.desiredRefreshRate = 60_Hz;
Alec Mouri11232a22020-05-14 18:06:25 -07001236 lr.name = "60Hz ExplicitDefault";
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001237 lr.focused = false;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001238 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001239
1240 lr.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001241 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Alec Mouri11232a22020-05-14 18:06:25 -07001242
1243 lr.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001244 lr.desiredRefreshRate = 60_Hz;
Alec Mouri11232a22020-05-14 18:06:25 -07001245 lr.name = "60Hz Heuristic";
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001246 lr.focused = false;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001247 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001248
1249 lr.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001250 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Alec Mouri11232a22020-05-14 18:06:25 -07001251
1252 lr.vote = LayerVoteType::Max;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001253 lr.desiredRefreshRate = 60_Hz;
Alec Mouri11232a22020-05-14 18:06:25 -07001254 lr.name = "60Hz Max";
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001255 lr.focused = false;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001256 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001257
1258 lr.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001259 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Alec Mouri11232a22020-05-14 18:06:25 -07001260
1261 lr.vote = LayerVoteType::Min;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001262 lr.desiredRefreshRate = 60_Hz;
Alec Mouri11232a22020-05-14 18:06:25 -07001263 lr.name = "60Hz Min";
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001264 lr.focused = false;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001265 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001266
1267 lr.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001268 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Alec Mouri11232a22020-05-14 18:06:25 -07001269}
1270
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001271TEST_F(RefreshRateConfigsTest, groupSwitchingNotAllowed) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001272 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Steven Thomasd4071902020-03-24 16:02:53 -07001273
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001274 // The default policy doesn't allow group switching. Verify that no
1275 // group switches are performed.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001276 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Steven Thomasd4071902020-03-24 16:02:53 -07001277 auto& layer = layers[0];
1278 layer.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001279 layer.desiredRefreshRate = 90_Hz;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001280 layer.seamlessness = Seamlessness::SeamedAndSeamless;
Steven Thomasd4071902020-03-24 16:02:53 -07001281 layer.name = "90Hz ExplicitDefault";
Marin Shalamanov46084422020-10-13 12:33:42 +02001282 layer.focused = true;
Steven Thomasd4071902020-03-24 16:02:53 -07001283
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001284 EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001285}
Steven Thomasd4071902020-03-24 16:02:53 -07001286
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001287TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayer) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001288 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
1289
Steven Thomasd4071902020-03-24 16:02:53 -07001290 RefreshRateConfigs::Policy policy;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001291 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
Steven Thomasd4071902020-03-24 16:02:53 -07001292 policy.allowGroupSwitching = true;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001293 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001294
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001295 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001296 auto& layer = layers[0];
1297 layer.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001298 layer.desiredRefreshRate = 90_Hz;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001299 layer.seamlessness = Seamlessness::SeamedAndSeamless;
1300 layer.name = "90Hz ExplicitDefault";
1301 layer.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001302 EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001303}
1304
1305TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamless) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001306 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Dominik Laskowski0c252702021-12-20 20:32:09 -08001307
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001308 RefreshRateConfigs::Policy policy;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001309 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001310 policy.allowGroupSwitching = true;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001311 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
Marin Shalamanov46084422020-10-13 12:33:42 +02001312
1313 // Verify that we won't change the group if seamless switch is required.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001314 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001315 auto& layer = layers[0];
1316 layer.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001317 layer.desiredRefreshRate = 90_Hz;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001318 layer.seamlessness = Seamlessness::OnlySeamless;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001319 layer.name = "90Hz ExplicitDefault";
1320 layer.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001321 EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001322}
1323
1324TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamlessDefaultFps) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001325 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001326
Dominik Laskowski0c252702021-12-20 20:32:09 -08001327 RefreshRateConfigs::Policy policy;
1328 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
1329 policy.allowGroupSwitching = true;
1330 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
1331
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001332 configs.setActiveModeId(kModeId90);
Marin Shalamanov46084422020-10-13 12:33:42 +02001333
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001334 // Verify that we won't do a seamless switch if we request the same mode as the default
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001335 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001336 auto& layer = layers[0];
1337 layer.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001338 layer.desiredRefreshRate = 60_Hz;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001339 layer.seamlessness = Seamlessness::OnlySeamless;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001340 layer.name = "60Hz ExplicitDefault";
1341 layer.focused = true;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001342 EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001343}
1344
1345TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerDefaultSeamlessness) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001346 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001347
Dominik Laskowski0c252702021-12-20 20:32:09 -08001348 RefreshRateConfigs::Policy policy;
1349 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
1350 policy.allowGroupSwitching = true;
1351 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
1352
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001353 configs.setActiveModeId(kModeId90);
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001354
1355 // Verify that if the current config is in another group and there are no layers with
1356 // seamlessness=SeamedAndSeamless we'll go back to the default group.
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001357
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001358 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001359 auto& layer = layers[0];
1360 layer.vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001361 layer.desiredRefreshRate = 60_Hz;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001362 layer.seamlessness = Seamlessness::Default;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001363 layer.name = "60Hz ExplicitDefault";
1364 layer.focused = true;
1365
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001366 EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001367}
1368
1369TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersOnlySeamlessAndSeamed) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001370 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001371
Dominik Laskowski0c252702021-12-20 20:32:09 -08001372 RefreshRateConfigs::Policy policy;
1373 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
1374 policy.allowGroupSwitching = true;
1375 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
1376
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001377 configs.setActiveModeId(kModeId90);
Marin Shalamanov46084422020-10-13 12:33:42 +02001378
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001379 // If there's a layer with seamlessness=SeamedAndSeamless, another layer with
Marin Shalamanova7fe3042021-01-29 21:02:08 +01001380 // seamlessness=OnlySeamless can't change the mode group.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001381 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001382 layers[0].vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001383 layers[0].desiredRefreshRate = 60_Hz;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001384 layers[0].seamlessness = Seamlessness::OnlySeamless;
1385 layers[0].name = "60Hz ExplicitDefault";
1386 layers[0].focused = true;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001387
1388 layers.push_back(LayerRequirement{.weight = 0.5f});
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001389 layers[1].vote = LayerVoteType::ExplicitDefault;
1390 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001391 layers[1].desiredRefreshRate = 90_Hz;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001392 layers[1].name = "90Hz ExplicitDefault";
1393 layers[1].focused = false;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001394
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001395 EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001396}
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001397
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001398TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultFocusedAndSeamed) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001399 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001400
Dominik Laskowski0c252702021-12-20 20:32:09 -08001401 RefreshRateConfigs::Policy policy;
1402 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
1403 policy.allowGroupSwitching = true;
1404 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
1405
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001406 configs.setActiveModeId(kModeId90);
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001407
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001408 // If there's a focused layer with seamlessness=SeamedAndSeamless, another layer with
1409 // seamlessness=Default can't change the mode group back to the group of the default
1410 // mode.
1411 // For example, this may happen when a video playback requests and gets a seamed switch,
1412 // but another layer (with default seamlessness) starts animating. The animating layer
1413 // should not cause a seamed switch.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001414 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001415 layers[0].seamlessness = Seamlessness::Default;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001416 layers[0].desiredRefreshRate = 60_Hz;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001417 layers[0].focused = true;
1418 layers[0].vote = LayerVoteType::ExplicitDefault;
1419 layers[0].name = "60Hz ExplicitDefault";
1420
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001421 layers.push_back(LayerRequirement{.weight = 0.1f});
1422 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001423 layers[1].desiredRefreshRate = 90_Hz;
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001424 layers[1].focused = true;
1425 layers[1].vote = LayerVoteType::ExplicitDefault;
1426 layers[1].name = "90Hz ExplicitDefault";
1427
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001428 EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov46084422020-10-13 12:33:42 +02001429}
1430
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001431TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001432 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId60);
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001433
Dominik Laskowski0c252702021-12-20 20:32:09 -08001434 RefreshRateConfigs::Policy policy;
1435 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
1436 policy.allowGroupSwitching = true;
1437 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
1438
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001439 configs.setActiveModeId(kModeId90);
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001440
1441 // Layer with seamlessness=Default can change the mode group if there's a not
1442 // focused layer with seamlessness=SeamedAndSeamless. This happens for example,
1443 // when in split screen mode the user switches between the two visible applications.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001444 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001445 layers[0].seamlessness = Seamlessness::Default;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001446 layers[0].desiredRefreshRate = 60_Hz;
Marin Shalamanovae0b5352021-03-24 12:56:08 +01001447 layers[0].focused = true;
1448 layers[0].vote = LayerVoteType::ExplicitDefault;
1449 layers[0].name = "60Hz ExplicitDefault";
1450
1451 layers.push_back(LayerRequirement{.weight = 0.7f});
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001452 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001453 layers[1].desiredRefreshRate = 90_Hz;
Marin Shalamanovbb65d052021-03-23 19:21:52 +01001454 layers[1].focused = false;
1455 layers[1].vote = LayerVoteType::ExplicitDefault;
1456 layers[1].name = "90Hz ExplicitDefault";
1457
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001458 EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov46084422020-10-13 12:33:42 +02001459}
1460
1461TEST_F(RefreshRateConfigsTest, nonSeamlessVotePrefersSeamlessSwitches) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001462 TestableRefreshRateConfigs configs(kModes_30_60, kModeId60);
Marin Shalamanov46084422020-10-13 12:33:42 +02001463
1464 // Allow group switching.
1465 RefreshRateConfigs::Policy policy;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001466 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
Marin Shalamanov46084422020-10-13 12:33:42 +02001467 policy.allowGroupSwitching = true;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001468 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
Marin Shalamanov46084422020-10-13 12:33:42 +02001469
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001470 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Marin Shalamanov46084422020-10-13 12:33:42 +02001471 auto& layer = layers[0];
1472 layer.vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001473 layer.desiredRefreshRate = 60_Hz;
Marin Shalamanov53fc11d2020-11-20 14:00:13 +01001474 layer.seamlessness = Seamlessness::SeamedAndSeamless;
Marin Shalamanov46084422020-10-13 12:33:42 +02001475 layer.name = "60Hz ExplicitExactOrMultiple";
1476 layer.focused = true;
1477
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001478 EXPECT_EQ(kModeId60, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov46084422020-10-13 12:33:42 +02001479
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001480 configs.setActiveModeId(kModeId120);
1481 EXPECT_EQ(kModeId120, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov46084422020-10-13 12:33:42 +02001482}
1483
1484TEST_F(RefreshRateConfigsTest, nonSeamlessExactAndSeamlessMultipleLayers) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001485 TestableRefreshRateConfigs configs(kModes_25_30_50_60, kModeId60);
Marin Shalamanov46084422020-10-13 12:33:42 +02001486
1487 // Allow group switching.
1488 RefreshRateConfigs::Policy policy;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001489 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
Marin Shalamanov46084422020-10-13 12:33:42 +02001490 policy.allowGroupSwitching = true;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001491 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
Marin Shalamanov46084422020-10-13 12:33:42 +02001492
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001493 std::vector<LayerRequirement> layers = {{.name = "60Hz ExplicitDefault",
1494 .vote = LayerVoteType::ExplicitDefault,
1495 .desiredRefreshRate = 60_Hz,
1496 .seamlessness = Seamlessness::SeamedAndSeamless,
1497 .weight = 0.5f,
1498 .focused = false},
1499 {.name = "25Hz ExplicitExactOrMultiple",
1500 .vote = LayerVoteType::ExplicitExactOrMultiple,
1501 .desiredRefreshRate = 25_Hz,
1502 .seamlessness = Seamlessness::OnlySeamless,
1503 .weight = 1.f,
1504 .focused = true}};
Marin Shalamanov46084422020-10-13 12:33:42 +02001505
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001506 EXPECT_EQ(kModeId50, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanov46084422020-10-13 12:33:42 +02001507
Marin Shalamanove7aadcc2021-04-09 18:58:38 +02001508 auto& seamedLayer = layers[0];
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001509 seamedLayer.desiredRefreshRate = 30_Hz;
1510 seamedLayer.name = "30Hz ExplicitDefault";
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001511 configs.setActiveModeId(kModeId30);
Marin Shalamanov46084422020-10-13 12:33:42 +02001512
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001513 EXPECT_EQ(kModeId25, configs.getBestRefreshRate(layers)->getId());
Steven Thomasd4071902020-03-24 16:02:53 -07001514}
1515
Marin Shalamanove7aadcc2021-04-09 18:58:38 +02001516TEST_F(RefreshRateConfigsTest, minLayersDontTrigerSeamedSwitch) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001517 TestableRefreshRateConfigs configs(kModes_60_90_G1, kModeId90);
Marin Shalamanove7aadcc2021-04-09 18:58:38 +02001518
1519 // Allow group switching.
1520 RefreshRateConfigs::Policy policy;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001521 policy.defaultMode = configs.getCurrentPolicy().defaultMode;
Marin Shalamanove7aadcc2021-04-09 18:58:38 +02001522 policy.allowGroupSwitching = true;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001523 EXPECT_GE(configs.setDisplayManagerPolicy(policy), 0);
Marin Shalamanove7aadcc2021-04-09 18:58:38 +02001524
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001525 std::vector<LayerRequirement> layers = {
1526 {.name = "Min", .vote = LayerVoteType::Min, .weight = 1.f, .focused = true}};
Marin Shalamanove7aadcc2021-04-09 18:58:38 +02001527
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001528 EXPECT_EQ(kModeId90, configs.getBestRefreshRate(layers)->getId());
Marin Shalamanove7aadcc2021-04-09 18:58:38 +02001529}
1530
Steven Thomasf734df42020-04-13 21:09:28 -07001531TEST_F(RefreshRateConfigsTest, primaryVsAppRequestPolicy) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001532 TestableRefreshRateConfigs configs(kModes_30_60_90, kModeId60);
Steven Thomasf734df42020-04-13 21:09:28 -07001533
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001534 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Steven Thomasf734df42020-04-13 21:09:28 -07001535 layers[0].name = "Test layer";
1536
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001537 struct Args {
1538 bool touch = false;
1539 bool focused = true;
1540 };
1541
Steven Thomasbb374322020-04-28 22:47:16 -07001542 // Return the config ID from calling getBestRefreshRate() for a single layer with the
Steven Thomasf734df42020-04-13 21:09:28 -07001543 // given voteType and fps.
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001544 auto getFrameRate = [&](LayerVoteType voteType, Fps fps, Args args = {}) -> DisplayModeId {
Steven Thomasf734df42020-04-13 21:09:28 -07001545 layers[0].vote = voteType;
1546 layers[0].desiredRefreshRate = fps;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001547 layers[0].focused = args.focused;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001548 return configs.getBestRefreshRate(layers, {.touch = args.touch})->getId();
Steven Thomasf734df42020-04-13 21:09:28 -07001549 };
1550
Dominik Laskowski0c252702021-12-20 20:32:09 -08001551 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {30_Hz, 60_Hz}, {30_Hz, 90_Hz}}), 0);
1552
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001553 EXPECT_EQ(kModeId60, configs.getBestRefreshRate()->getId());
Dominik Laskowski0c252702021-12-20 20:32:09 -08001554 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
1555 EXPECT_EQ(kModeId30, getFrameRate(LayerVoteType::Min, 90_Hz));
1556 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
1557 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
1558 EXPECT_EQ(kModeId90, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
1559 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
Steven Thomasf734df42020-04-13 21:09:28 -07001560
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001561 // Unfocused layers are not allowed to override primary config.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001562 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.focused = false}));
1563 EXPECT_EQ(kModeId60,
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001564 getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz, {.focused = false}));
Ady Abrahamaae5ed52020-06-26 09:32:43 -07001565
Steven Thomasf734df42020-04-13 21:09:28 -07001566 // Touch boost should be restricted to the primary range.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001567 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz, {.touch = true}));
1568
Steven Thomasf734df42020-04-13 21:09:28 -07001569 // When we're higher than the primary range max due to a layer frame rate setting, touch boost
1570 // shouldn't drag us back down to the primary range max.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001571 EXPECT_EQ(kModeId90, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.touch = true}));
1572 EXPECT_EQ(kModeId60,
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001573 getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz, {.touch = true}));
Steven Thomasf734df42020-04-13 21:09:28 -07001574
Dominik Laskowski0c252702021-12-20 20:32:09 -08001575 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}, {60_Hz, 60_Hz}}), 0);
1576
1577 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
1578 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Min, 90_Hz));
1579 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
1580 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
1581 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
1582 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
Steven Thomasf734df42020-04-13 21:09:28 -07001583}
1584
Steven Thomasbb374322020-04-28 22:47:16 -07001585TEST_F(RefreshRateConfigsTest, idle) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001586 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Steven Thomasbb374322020-04-28 22:47:16 -07001587
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001588 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Steven Thomasbb374322020-04-28 22:47:16 -07001589 layers[0].name = "Test layer";
1590
Marin Shalamanov23c44202020-12-22 19:09:20 +01001591 const auto getIdleFrameRate = [&](LayerVoteType voteType, bool touchActive) -> DisplayModeId {
Steven Thomasbb374322020-04-28 22:47:16 -07001592 layers[0].vote = voteType;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001593 layers[0].desiredRefreshRate = 90_Hz;
Dominik Laskowski0c252702021-12-20 20:32:09 -08001594
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001595 const auto [refreshRate, signals] =
1596 configs.getBestRefreshRateAndSignals(layers, {.touch = touchActive, .idle = true});
1597
1598 // Refresh rate will be chosen by either touch state or idle state.
1599 EXPECT_EQ(!touchActive, signals.idle);
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001600 return refreshRate->getId();
Steven Thomasbb374322020-04-28 22:47:16 -07001601 };
1602
Dominik Laskowski0c252702021-12-20 20:32:09 -08001603 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}, {60_Hz, 90_Hz}}), 0);
Steven Thomasbb374322020-04-28 22:47:16 -07001604
1605 // Idle should be lower priority than touch boost.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001606 {
1607 constexpr bool kTouchActive = true;
1608 EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::NoVote, kTouchActive));
1609 EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::Min, kTouchActive));
1610 EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::Max, kTouchActive));
1611 EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::Heuristic, kTouchActive));
1612 EXPECT_EQ(kModeId90, getIdleFrameRate(LayerVoteType::ExplicitDefault, kTouchActive));
1613 EXPECT_EQ(kModeId90,
1614 getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, kTouchActive));
1615 }
Steven Thomasbb374322020-04-28 22:47:16 -07001616
1617 // With no layers, idle should still be lower priority than touch boost.
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001618 EXPECT_EQ(kModeId90, configs.getBestRefreshRate({}, {.touch = true, .idle = true})->getId());
Steven Thomasbb374322020-04-28 22:47:16 -07001619
1620 // Idle should be higher precedence than other layer frame rate considerations.
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001621 configs.setActiveModeId(kModeId90);
Dominik Laskowski0c252702021-12-20 20:32:09 -08001622
1623 {
1624 constexpr bool kTouchActive = false;
1625 EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::NoVote, kTouchActive));
1626 EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::Min, kTouchActive));
1627 EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::Max, kTouchActive));
1628 EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::Heuristic, kTouchActive));
1629 EXPECT_EQ(kModeId60, getIdleFrameRate(LayerVoteType::ExplicitDefault, kTouchActive));
1630 EXPECT_EQ(kModeId60,
1631 getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, kTouchActive));
1632 }
Steven Thomasbb374322020-04-28 22:47:16 -07001633
1634 // Idle should be applied rather than the current config when there are no layers.
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001635 EXPECT_EQ(kModeId60, configs.getBestRefreshRate({}, {.idle = true})->getId());
Steven Thomasbb374322020-04-28 22:47:16 -07001636}
1637
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001638TEST_F(RefreshRateConfigsTest, findClosestKnownFrameRate) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001639 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001640
1641 for (float fps = 1.0f; fps <= 120.0f; fps += 0.1f) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001642 const auto knownFrameRate = configs.findClosestKnownFrameRate(Fps::fromValue(fps));
1643 const Fps expectedFrameRate = [fps] {
1644 if (fps < 26.91f) return 24_Hz;
1645 if (fps < 37.51f) return 30_Hz;
1646 if (fps < 52.51f) return 45_Hz;
1647 if (fps < 66.01f) return 60_Hz;
1648 if (fps < 81.01f) return 72_Hz;
1649 return 90_Hz;
1650 }();
1651
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001652 EXPECT_EQ(expectedFrameRate, knownFrameRate);
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001653 }
1654}
1655
1656TEST_F(RefreshRateConfigsTest, getBestRefreshRate_KnownFrameRate) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001657 TestableRefreshRateConfigs configs(kModes_60_90, kModeId60);
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001658
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001659 struct Expectation {
1660 Fps fps;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001661 DisplayModePtr mode;
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001662 };
1663
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001664 const std::initializer_list<Expectation> knownFrameRatesExpectations = {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001665 {24_Hz, kMode60}, {30_Hz, kMode60}, {45_Hz, kMode90},
1666 {60_Hz, kMode60}, {72_Hz, kMode90}, {90_Hz, kMode90},
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001667 };
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001668
1669 // Make sure the test tests all the known frame rate
Dominik Laskowski0c252702021-12-20 20:32:09 -08001670 const auto& knownFrameRates = configs.knownFrameRates();
1671 const bool equal = std::equal(knownFrameRates.begin(), knownFrameRates.end(),
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001672 knownFrameRatesExpectations.begin(),
1673 [](Fps fps, const Expectation& expected) {
1674 return isApproxEqual(fps, expected.fps);
1675 });
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001676 EXPECT_TRUE(equal);
1677
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001678 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001679 auto& layer = layers[0];
1680 layer.vote = LayerVoteType::Heuristic;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001681
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001682 for (const auto& [fps, mode] : knownFrameRatesExpectations) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001683 layer.desiredRefreshRate = fps;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001684 EXPECT_EQ(mode, configs.getBestRefreshRate(layers));
Ady Abrahamb1b9d412020-06-01 19:53:52 -07001685 }
1686}
1687
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001688TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExact) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001689 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001690
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001691 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001692 auto& explicitExactLayer = layers[0];
1693 auto& explicitExactOrMultipleLayer = layers[1];
1694
1695 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
1696 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001697 explicitExactOrMultipleLayer.desiredRefreshRate = 60_Hz;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001698
1699 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
1700 explicitExactLayer.name = "ExplicitExact";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001701 explicitExactLayer.desiredRefreshRate = 30_Hz;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001702
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001703 EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers));
1704 EXPECT_EQ(kMode30, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001705
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001706 explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
1707 explicitExactLayer.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001708 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001709
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001710 explicitExactLayer.desiredRefreshRate = 72_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001711 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001712
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001713 explicitExactLayer.desiredRefreshRate = 90_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001714 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001715
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001716 explicitExactLayer.desiredRefreshRate = 120_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001717 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001718}
1719
1720TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001721 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60,
1722 {.enableFrameRateOverride = true});
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001723
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001724 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001725 auto& explicitExactLayer = layers[0];
1726 auto& explicitExactOrMultipleLayer = layers[1];
1727
1728 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
1729 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001730 explicitExactOrMultipleLayer.desiredRefreshRate = 60_Hz;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001731
1732 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
1733 explicitExactLayer.name = "ExplicitExact";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001734 explicitExactLayer.desiredRefreshRate = 30_Hz;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001735
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001736 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
1737 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001738
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001739 explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
1740 explicitExactLayer.desiredRefreshRate = 60_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001741 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001742
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001743 explicitExactLayer.desiredRefreshRate = 72_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001744 EXPECT_EQ(kMode72, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001745
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001746 explicitExactLayer.desiredRefreshRate = 90_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001747 EXPECT_EQ(kMode90, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001748
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001749 explicitExactLayer.desiredRefreshRate = 120_Hz;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001750 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001751}
1752
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001753TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ReadsCache) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001754 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001755
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001756 using GlobalSignals = RefreshRateConfigs::GlobalSignals;
1757 const auto args = std::make_pair(std::vector<LayerRequirement>{},
1758 GlobalSignals{.touch = true, .idle = true});
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001759 const auto result = std::make_pair(kMode90, GlobalSignals{.touch = true});
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001760
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001761 configs.mutableGetBestRefreshRateCache() = {args, result};
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001762
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001763 EXPECT_EQ(result, configs.getBestRefreshRateAndSignals(args.first, args.second));
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001764}
1765
1766TEST_F(RefreshRateConfigsTest, getBestRefreshRate_WritesCache) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001767 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId60);
1768
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001769 EXPECT_FALSE(configs.mutableGetBestRefreshRateCache());
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001770
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001771 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001772 RefreshRateConfigs::GlobalSignals globalSignals{.touch = true, .idle = true};
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001773
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001774 const auto result = configs.getBestRefreshRateAndSignals(layers, globalSignals);
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001775
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001776 const auto& cache = configs.mutableGetBestRefreshRateCache();
1777 ASSERT_TRUE(cache);
1778
1779 EXPECT_EQ(cache->arguments, std::make_pair(layers, globalSignals));
1780 EXPECT_EQ(cache->result, result);
Marin Shalamanov4c7831e2021-06-08 20:44:06 +02001781}
1782
Ady Abraham5e4e9832021-06-14 13:40:56 -07001783TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactTouchBoost) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001784 TestableRefreshRateConfigs configs(kModes_60_120, kModeId60, {.enableFrameRateOverride = true});
Ady Abraham5e4e9832021-06-14 13:40:56 -07001785
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001786 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
Ady Abraham5e4e9832021-06-14 13:40:56 -07001787 auto& explicitExactLayer = layers[0];
1788 auto& explicitExactOrMultipleLayer = layers[1];
1789
1790 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
1791 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001792 explicitExactOrMultipleLayer.desiredRefreshRate = 60_Hz;
Ady Abraham5e4e9832021-06-14 13:40:56 -07001793
1794 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
1795 explicitExactLayer.name = "ExplicitExact";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001796 explicitExactLayer.desiredRefreshRate = 30_Hz;
Ady Abraham5e4e9832021-06-14 13:40:56 -07001797
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001798 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
1799 EXPECT_EQ(kMode120, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham5e4e9832021-06-14 13:40:56 -07001800
1801 explicitExactOrMultipleLayer.vote = LayerVoteType::NoVote;
1802
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001803 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
1804 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers, {.touch = true}));
Ady Abraham5e4e9832021-06-14 13:40:56 -07001805}
1806
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001807TEST_F(RefreshRateConfigsTest, getBestRefreshRate_FractionalRefreshRates_ExactAndDefault) {
Dominik Laskowskia8626ec2021-12-15 18:13:30 -08001808 TestableRefreshRateConfigs configs(kModes_24_25_30_50_60_Frac, kModeId60,
1809 {.enableFrameRateOverride = true});
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001810
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001811 std::vector<LayerRequirement> layers = {{.weight = 0.5f}, {.weight = 0.5f}};
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001812 auto& explicitDefaultLayer = layers[0];
1813 auto& explicitExactOrMultipleLayer = layers[1];
1814
1815 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
1816 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001817 explicitExactOrMultipleLayer.desiredRefreshRate = 60_Hz;
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001818
1819 explicitDefaultLayer.vote = LayerVoteType::ExplicitDefault;
1820 explicitDefaultLayer.name = "ExplicitDefault";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001821 explicitDefaultLayer.desiredRefreshRate = 59.94_Hz;
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001822
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001823 EXPECT_EQ(kMode60, configs.getBestRefreshRate(layers));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001824}
1825
Ady Abraham05243be2021-09-16 15:58:52 -07001826// b/190578904
Dominik Laskowski0c252702021-12-20 20:32:09 -08001827TEST_F(RefreshRateConfigsTest, getBestRefreshRate_withCloseRefreshRates) {
Ady Abraham05243be2021-09-16 15:58:52 -07001828 constexpr int kMinRefreshRate = 10;
1829 constexpr int kMaxRefreshRate = 240;
1830
1831 DisplayModes displayModes;
1832 for (int fps = kMinRefreshRate; fps < kMaxRefreshRate; fps++) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001833 const DisplayModeId modeId(fps);
1834 displayModes.try_emplace(modeId,
1835 createDisplayMode(modeId,
1836 Fps::fromValue(static_cast<float>(fps))));
Ady Abraham05243be2021-09-16 15:58:52 -07001837 }
1838
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001839 const TestableRefreshRateConfigs configs(std::move(displayModes),
1840 DisplayModeId(kMinRefreshRate));
Ady Abraham05243be2021-09-16 15:58:52 -07001841
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001842 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham05243be2021-09-16 15:58:52 -07001843 const auto testRefreshRate = [&](Fps fps, LayerVoteType vote) {
1844 layers[0].desiredRefreshRate = fps;
1845 layers[0].vote = vote;
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001846 EXPECT_EQ(fps.getIntValue(), configs.getBestRefreshRate(layers)->getFps().getIntValue())
Dominik Laskowskif5d0ea52021-09-26 17:27:01 -07001847 << "Failed for " << ftl::enum_string(vote);
Ady Abraham05243be2021-09-16 15:58:52 -07001848 };
1849
1850 for (int fps = kMinRefreshRate; fps < kMaxRefreshRate; fps++) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001851 const auto refreshRate = Fps::fromValue(static_cast<float>(fps));
Ady Abraham05243be2021-09-16 15:58:52 -07001852 testRefreshRate(refreshRate, LayerVoteType::Heuristic);
1853 testRefreshRate(refreshRate, LayerVoteType::ExplicitDefault);
1854 testRefreshRate(refreshRate, LayerVoteType::ExplicitExactOrMultiple);
1855 testRefreshRate(refreshRate, LayerVoteType::ExplicitExact);
1856 }
1857}
1858
Ady Abraham1c595502022-01-13 21:58:32 -08001859// b/190578904
1860TEST_F(RefreshRateConfigsTest, getBestRefreshRate_conflictingVotes) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001861 constexpr DisplayModeId kActiveModeId{0};
1862 DisplayModes displayModes = makeModes(createDisplayMode(kActiveModeId, 43_Hz),
1863 createDisplayMode(DisplayModeId(1), 53_Hz),
1864 createDisplayMode(DisplayModeId(2), 55_Hz),
1865 createDisplayMode(DisplayModeId(3), 60_Hz));
Ady Abraham1c595502022-01-13 21:58:32 -08001866
1867 const RefreshRateConfigs::GlobalSignals globalSignals = {.touch = false, .idle = false};
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001868 const TestableRefreshRateConfigs configs(std::move(displayModes), kActiveModeId);
Ady Abraham1c595502022-01-13 21:58:32 -08001869
Dominik Laskowski0c252702021-12-20 20:32:09 -08001870 const std::vector<LayerRequirement> layers = {
1871 {
Ady Abraham1c595502022-01-13 21:58:32 -08001872 .vote = LayerVoteType::ExplicitDefault,
1873 .desiredRefreshRate = 43_Hz,
1874 .seamlessness = Seamlessness::SeamedAndSeamless,
1875 .weight = 0.41f,
1876 },
Dominik Laskowski0c252702021-12-20 20:32:09 -08001877 {
Ady Abraham1c595502022-01-13 21:58:32 -08001878 .vote = LayerVoteType::ExplicitExactOrMultiple,
1879 .desiredRefreshRate = 53_Hz,
1880 .seamlessness = Seamlessness::SeamedAndSeamless,
1881 .weight = 0.41f,
1882 },
1883 };
1884
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001885 EXPECT_EQ(53_Hz, configs.getBestRefreshRate(layers, globalSignals)->getFps());
Ady Abraham1c595502022-01-13 21:58:32 -08001886}
1887
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001888TEST_F(RefreshRateConfigsTest, modeComparison) {
1889 EXPECT_LT(kMode60->getFps(), kMode90->getFps());
1890 EXPECT_GE(kMode60->getFps(), kMode60->getFps());
1891 EXPECT_GE(kMode90->getFps(), kMode90->getFps());
Ana Krulecb9afd792020-06-11 13:16:15 -07001892}
1893
1894TEST_F(RefreshRateConfigsTest, testKernelIdleTimerAction) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001895 using KernelIdleTimerAction = RefreshRateConfigs::KernelIdleTimerAction;
Ana Krulecb9afd792020-06-11 13:16:15 -07001896
Dominik Laskowski0c252702021-12-20 20:32:09 -08001897 RefreshRateConfigs configs(kModes_60_90, kModeId90);
1898
Ana Krulecb9afd792020-06-11 13:16:15 -07001899 // SetPolicy(60, 90), current 90Hz => TurnOn.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001900 EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
Ana Krulecb9afd792020-06-11 13:16:15 -07001901
1902 // SetPolicy(60, 90), current 60Hz => TurnOn.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001903 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}}), 0);
1904 EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
Ana Krulecb9afd792020-06-11 13:16:15 -07001905
Ady Abrahama91605e2021-06-18 11:41:47 -07001906 // SetPolicy(60, 60), current 60Hz => TurnOff
Dominik Laskowski0c252702021-12-20 20:32:09 -08001907 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
1908 EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
Ana Krulecb9afd792020-06-11 13:16:15 -07001909
1910 // SetPolicy(90, 90), current 90Hz => TurnOff.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001911 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}), 0);
1912 EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
Ana Krulecb9afd792020-06-11 13:16:15 -07001913}
1914
TreeHugger Robot758ab612021-06-22 19:17:29 +00001915TEST_F(RefreshRateConfigsTest, testKernelIdleTimerActionFor120Hz) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001916 using KernelIdleTimerAction = RefreshRateConfigs::KernelIdleTimerAction;
TreeHugger Robot758ab612021-06-22 19:17:29 +00001917
Dominik Laskowski0c252702021-12-20 20:32:09 -08001918 RefreshRateConfigs configs(kModes_60_120, kModeId120);
1919
TreeHugger Robot758ab612021-06-22 19:17:29 +00001920 // SetPolicy(0, 60), current 60Hz => TurnOn.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001921 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {0_Hz, 60_Hz}}), 0);
1922 EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
TreeHugger Robot758ab612021-06-22 19:17:29 +00001923
1924 // SetPolicy(60, 60), current 60Hz => TurnOff.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001925 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}), 0);
1926 EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
TreeHugger Robot758ab612021-06-22 19:17:29 +00001927
1928 // SetPolicy(60, 120), current 60Hz => TurnOn.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001929 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId60, {60_Hz, 120_Hz}}), 0);
1930 EXPECT_EQ(KernelIdleTimerAction::TurnOn, configs.getIdleTimerAction());
TreeHugger Robot758ab612021-06-22 19:17:29 +00001931
1932 // SetPolicy(120, 120), current 120Hz => TurnOff.
Dominik Laskowski0c252702021-12-20 20:32:09 -08001933 EXPECT_GE(configs.setDisplayManagerPolicy({kModeId120, {120_Hz, 120_Hz}}), 0);
1934 EXPECT_EQ(KernelIdleTimerAction::TurnOff, configs.getIdleTimerAction());
TreeHugger Robot758ab612021-06-22 19:17:29 +00001935}
1936
Ady Abrahamcc315492022-02-17 17:06:39 -08001937TEST_F(RefreshRateConfigsTest, getFrameRateDivisor) {
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001938 TestableRefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId30);
Ady Abraham62a0be22020-12-08 16:54:10 -08001939
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001940 const auto frameRate = 30_Hz;
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001941 Fps displayRefreshRate = configs.getActiveMode().getFps();
Ady Abrahamcc315492022-02-17 17:06:39 -08001942 EXPECT_EQ(1, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
Ady Abraham0bb6a472020-10-12 10:22:13 -07001943
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001944 configs.setActiveModeId(kModeId60);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001945 displayRefreshRate = configs.getActiveMode().getFps();
Ady Abrahamcc315492022-02-17 17:06:39 -08001946 EXPECT_EQ(2, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
Ady Abraham0bb6a472020-10-12 10:22:13 -07001947
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001948 configs.setActiveModeId(kModeId72);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001949 displayRefreshRate = configs.getActiveMode().getFps();
Ady Abrahamcc315492022-02-17 17:06:39 -08001950 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
Ady Abraham0bb6a472020-10-12 10:22:13 -07001951
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001952 configs.setActiveModeId(kModeId90);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001953 displayRefreshRate = configs.getActiveMode().getFps();
Ady Abrahamcc315492022-02-17 17:06:39 -08001954 EXPECT_EQ(3, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
Ady Abraham0bb6a472020-10-12 10:22:13 -07001955
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001956 configs.setActiveModeId(kModeId120);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001957 displayRefreshRate = configs.getActiveMode().getFps();
Ady Abrahamcc315492022-02-17 17:06:39 -08001958 EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, frameRate));
Ady Abraham62f216c2020-10-13 19:07:23 -07001959
Dominik Laskowskib0054a22022-03-03 09:03:06 -08001960 configs.setActiveModeId(kModeId90);
Dominik Laskowskif8734e02022-08-26 09:06:59 -07001961 displayRefreshRate = configs.getActiveMode().getFps();
Ady Abrahamcc315492022-02-17 17:06:39 -08001962 EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivisor(displayRefreshRate, 22.5_Hz));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001963
Ady Abrahamcc315492022-02-17 17:06:39 -08001964 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivisor(24_Hz, 25_Hz));
1965 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivisor(24_Hz, 23.976_Hz));
1966 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivisor(30_Hz, 29.97_Hz));
1967 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivisor(60_Hz, 59.94_Hz));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001968}
1969
1970TEST_F(RefreshRateConfigsTest, isFractionalPairOrMultiple) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001971 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(23.976_Hz, 24_Hz));
1972 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(24_Hz, 23.976_Hz));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001973
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001974 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(29.97_Hz, 30_Hz));
1975 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(30_Hz, 29.97_Hz));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001976
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001977 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(59.94_Hz, 60_Hz));
1978 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(60_Hz, 59.94_Hz));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001979
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001980 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(29.97_Hz, 60_Hz));
1981 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(60_Hz, 29.97_Hz));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001982
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001983 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(59.94_Hz, 30_Hz));
1984 EXPECT_TRUE(RefreshRateConfigs::isFractionalPairOrMultiple(30_Hz, 59.94_Hz));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001985
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001986 const auto refreshRates = {23.976_Hz, 24_Hz, 25_Hz, 29.97_Hz, 30_Hz, 50_Hz, 59.94_Hz, 60_Hz};
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001987 for (auto refreshRate : refreshRates) {
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001988 EXPECT_FALSE(RefreshRateConfigs::isFractionalPairOrMultiple(refreshRate, refreshRate));
Marin Shalamanov15a0fc62021-08-16 18:20:21 +02001989 }
1990
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07001991 EXPECT_FALSE(RefreshRateConfigs::isFractionalPairOrMultiple(24_Hz, 25_Hz));
1992 EXPECT_FALSE(RefreshRateConfigs::isFractionalPairOrMultiple(23.978_Hz, 25_Hz));
1993 EXPECT_FALSE(RefreshRateConfigs::isFractionalPairOrMultiple(29.97_Hz, 59.94_Hz));
Ady Abraham62a0be22020-12-08 16:54:10 -08001994}
1995
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08001996TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_noLayers) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08001997 RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120);
Ady Abraham62a0be22020-12-08 16:54:10 -08001998
Dominik Laskowski0c252702021-12-20 20:32:09 -08001999 EXPECT_TRUE(configs.getFrameRateOverrides({}, 120_Hz, {}).empty());
Ady Abraham62a0be22020-12-08 16:54:10 -08002000}
2001
2002TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_60on120) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08002003 RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120,
2004 {.enableFrameRateOverride = true});
Ady Abraham62a0be22020-12-08 16:54:10 -08002005
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002006 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
Ady Abraham62a0be22020-12-08 16:54:10 -08002007 layers[0].name = "Test layer";
2008 layers[0].ownerUid = 1234;
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002009 layers[0].desiredRefreshRate = 60_Hz;
Ady Abraham62a0be22020-12-08 16:54:10 -08002010 layers[0].vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002011
2012 auto frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2013 EXPECT_EQ(1u, frameRateOverrides.size());
2014 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2015 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abraham62a0be22020-12-08 16:54:10 -08002016
2017 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002018 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2019 EXPECT_EQ(1u, frameRateOverrides.size());
2020 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2021 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abraham62a0be22020-12-08 16:54:10 -08002022
2023 layers[0].vote = LayerVoteType::NoVote;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002024 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2025 EXPECT_TRUE(frameRateOverrides.empty());
Ady Abraham62a0be22020-12-08 16:54:10 -08002026
2027 layers[0].vote = LayerVoteType::Min;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002028 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2029 EXPECT_TRUE(frameRateOverrides.empty());
Ady Abraham62a0be22020-12-08 16:54:10 -08002030
2031 layers[0].vote = LayerVoteType::Max;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002032 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2033 EXPECT_TRUE(frameRateOverrides.empty());
Ady Abraham62a0be22020-12-08 16:54:10 -08002034
2035 layers[0].vote = LayerVoteType::Heuristic;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002036 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2037 EXPECT_TRUE(frameRateOverrides.empty());
Ady Abraham62a0be22020-12-08 16:54:10 -08002038}
2039
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002040TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_twoUids) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08002041 RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120,
2042 {.enableFrameRateOverride = true});
Ady Abraham62a0be22020-12-08 16:54:10 -08002043
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002044 std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f},
2045 {.ownerUid = 5678, .weight = 1.f}};
Ady Abraham62a0be22020-12-08 16:54:10 -08002046
2047 layers[0].name = "Test layer 1234";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002048 layers[0].desiredRefreshRate = 60_Hz;
Ady Abraham62a0be22020-12-08 16:54:10 -08002049 layers[0].vote = LayerVoteType::ExplicitDefault;
2050
2051 layers[1].name = "Test layer 5678";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002052 layers[1].desiredRefreshRate = 30_Hz;
Ady Abraham62a0be22020-12-08 16:54:10 -08002053 layers[1].vote = LayerVoteType::ExplicitDefault;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002054 auto frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
Ady Abraham62a0be22020-12-08 16:54:10 -08002055
Dominik Laskowski0c252702021-12-20 20:32:09 -08002056 EXPECT_EQ(2u, frameRateOverrides.size());
2057 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2058 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
2059 ASSERT_EQ(1u, frameRateOverrides.count(5678));
2060 EXPECT_EQ(30_Hz, frameRateOverrides.at(5678));
Ady Abraham62a0be22020-12-08 16:54:10 -08002061
2062 layers[1].vote = LayerVoteType::Heuristic;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002063 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2064 EXPECT_EQ(1u, frameRateOverrides.size());
2065 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2066 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abraham62a0be22020-12-08 16:54:10 -08002067
2068 layers[1].ownerUid = 1234;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002069 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2070 EXPECT_TRUE(frameRateOverrides.empty());
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002071}
2072
2073TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_touch) {
Dominik Laskowski0c252702021-12-20 20:32:09 -08002074 RefreshRateConfigs configs(kModes_30_60_72_90_120, kModeId120,
2075 {.enableFrameRateOverride = true});
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002076
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002077 std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f}};
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002078 layers[0].name = "Test layer";
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002079 layers[0].desiredRefreshRate = 60_Hz;
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002080 layers[0].vote = LayerVoteType::ExplicitDefault;
2081
Dominik Laskowski0c252702021-12-20 20:32:09 -08002082 auto frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2083 EXPECT_EQ(1u, frameRateOverrides.size());
2084 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2085 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002086
Dominik Laskowski0c252702021-12-20 20:32:09 -08002087 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
2088 EXPECT_EQ(1u, frameRateOverrides.size());
2089 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2090 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002091
2092 layers[0].vote = LayerVoteType::ExplicitExact;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002093 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2094 EXPECT_EQ(1u, frameRateOverrides.size());
2095 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2096 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002097
Dominik Laskowski0c252702021-12-20 20:32:09 -08002098 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
2099 EXPECT_EQ(1u, frameRateOverrides.size());
2100 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2101 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002102
2103 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
Dominik Laskowski0c252702021-12-20 20:32:09 -08002104 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {});
2105 EXPECT_EQ(1u, frameRateOverrides.size());
2106 ASSERT_EQ(1u, frameRateOverrides.count(1234));
2107 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
Ady Abrahamdd5bfa92021-01-07 17:56:08 -08002108
Dominik Laskowski0c252702021-12-20 20:32:09 -08002109 frameRateOverrides = configs.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
2110 EXPECT_TRUE(frameRateOverrides.empty());
Ady Abraham0bb6a472020-10-12 10:22:13 -07002111}
2112
Alec Mouri0a1cc962019-03-14 12:33:02 -07002113} // namespace
Dominik Laskowski6eab42d2021-09-13 14:34:13 -07002114} // namespace android::scheduler