1 /*
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
20 #include <algorithm>
21 #include <array>
22
23 #include <ftl/enum.h>
24 #include <ftl/fake_guard.h>
25 #include <gmock/gmock.h>
26 #include <log/log.h>
27 #include <ui/Size.h>
28
29 #include <common/test/FlagUtils.h>
30 #include <scheduler/Fps.h>
31 #include <scheduler/FrameRateMode.h>
32 #include "DisplayHardware/HWC2.h"
33 #include "FpsOps.h"
34 #include "Scheduler/RefreshRateSelector.h"
35 #include "mock/DisplayHardware/MockDisplayMode.h"
36 #include "mock/MockFrameRateMode.h"
37
38 #include "libsurfaceflinger_unittest_main.h"
39
40 #include <com_android_graphics_surfaceflinger_flags.h>
41
42 using namespace com::android::graphics::surfaceflinger;
43 using namespace std::chrono_literals;
44
45 namespace android::scheduler {
46
47 namespace hal = android::hardware::graphics::composer::hal;
48
49 using Config = RefreshRateSelector::Config;
50 using LayerRequirement = RefreshRateSelector::LayerRequirement;
51 using LayerVoteType = RefreshRateSelector::LayerVoteType;
52 using SetPolicyResult = RefreshRateSelector::SetPolicyResult;
53
54 using mock::createDisplayMode;
55 using mock::createVrrDisplayMode;
56
57 struct TestableRefreshRateSelector : RefreshRateSelector {
58 using RefreshRateSelector::FrameRateRanking;
59 using RefreshRateSelector::RefreshRateOrder;
60
61 using RefreshRateSelector::RefreshRateSelector;
62
setActiveModeandroid::scheduler::TestableRefreshRateSelector63 void setActiveMode(DisplayModeId modeId, Fps renderFrameRate) {
64 ftl::FakeGuard guard(kMainThreadContext);
65 return RefreshRateSelector::setActiveMode(modeId, renderFrameRate);
66 }
67
getActiveModeandroid::scheduler::TestableRefreshRateSelector68 const DisplayMode& getActiveMode() const {
69 std::lock_guard lock(mLock);
70 return *RefreshRateSelector::getActiveModeLocked().modePtr;
71 }
72
getMinSupportedRefreshRateandroid::scheduler::TestableRefreshRateSelector73 ftl::NonNull<DisplayModePtr> getMinSupportedRefreshRate() const {
74 std::lock_guard lock(mLock);
75 return ftl::as_non_null(mMinRefreshRateModeIt->second);
76 }
77
getMaxSupportedRefreshRateandroid::scheduler::TestableRefreshRateSelector78 ftl::NonNull<DisplayModePtr> getMaxSupportedRefreshRate() const {
79 std::lock_guard lock(mLock);
80 return ftl::as_non_null(mMaxRefreshRateModeIt->second);
81 }
82
getMinRefreshRateByPolicyandroid::scheduler::TestableRefreshRateSelector83 ftl::NonNull<DisplayModePtr> getMinRefreshRateByPolicy() const {
84 std::lock_guard lock(mLock);
85 return ftl::as_non_null(getMinRefreshRateByPolicyLocked());
86 }
87
getMaxRefreshRateByPolicyandroid::scheduler::TestableRefreshRateSelector88 ftl::NonNull<DisplayModePtr> getMaxRefreshRateByPolicy() const {
89 std::lock_guard lock(mLock);
90 return ftl::as_non_null(
91 getMaxRefreshRateByPolicyLocked(getActiveModeLocked().modePtr->getGroup()));
92 }
93
rankRefreshRatesandroid::scheduler::TestableRefreshRateSelector94 FrameRateRanking rankRefreshRates(std::optional<int> anchorGroupOpt,
95 RefreshRateOrder refreshRateOrder) const {
96 std::lock_guard lock(mLock);
97 return RefreshRateSelector::rankFrameRates(anchorGroupOpt, refreshRateOrder);
98 }
99
knownFrameRatesandroid::scheduler::TestableRefreshRateSelector100 const std::vector<Fps>& knownFrameRates() const { return mKnownFrameRates; }
101
102 using RefreshRateSelector::GetRankedFrameRatesCache;
mutableGetRankedRefreshRatesCacheandroid::scheduler::TestableRefreshRateSelector103 auto& mutableGetRankedRefreshRatesCache() NO_THREAD_SAFETY_ANALYSIS {
104 return mGetRankedFrameRatesCache;
105 }
106
getRankedFrameRatesandroid::scheduler::TestableRefreshRateSelector107 auto getRankedFrameRates(const std::vector<LayerRequirement>& layers,
108 GlobalSignals signals = {}, Fps pacesetterFps = {}) const {
109 const auto result =
110 RefreshRateSelector::getRankedFrameRates(layers, signals, pacesetterFps);
111
112 EXPECT_TRUE(std::is_sorted(result.ranking.begin(), result.ranking.end(),
113 ScoredFrameRate::DescendingScore{}));
114
115 return result;
116 }
117
getRankedRefreshRatesAsPairandroid::scheduler::TestableRefreshRateSelector118 auto getRankedRefreshRatesAsPair(const std::vector<LayerRequirement>& layers,
119 GlobalSignals signals) const {
120 const auto result = getRankedFrameRates(layers, signals);
121 return std::make_pair(result.ranking, result.consideredSignals);
122 }
123
getBestFrameRateModeandroid::scheduler::TestableRefreshRateSelector124 FrameRateMode getBestFrameRateMode(const std::vector<LayerRequirement>& layers = {},
125 GlobalSignals signals = {}) const {
126 return getRankedFrameRates(layers, signals).ranking.front().frameRateMode;
127 }
128
getBestScoredFrameRateandroid::scheduler::TestableRefreshRateSelector129 ScoredFrameRate getBestScoredFrameRate(const std::vector<LayerRequirement>& layers = {},
130 GlobalSignals signals = {}) const {
131 return getRankedFrameRates(layers, signals).ranking.front();
132 }
133
setPolicyandroid::scheduler::TestableRefreshRateSelector134 SetPolicyResult setPolicy(const PolicyVariant& policy) {
135 ftl::FakeGuard guard(kMainThreadContext);
136 return RefreshRateSelector::setPolicy(policy);
137 }
138
setDisplayManagerPolicyandroid::scheduler::TestableRefreshRateSelector139 SetPolicyResult setDisplayManagerPolicy(const DisplayManagerPolicy& policy) {
140 return setPolicy(policy);
141 }
142
getPrimaryFrameRatesandroid::scheduler::TestableRefreshRateSelector143 const auto& getPrimaryFrameRates() const NO_THREAD_SAFETY_ANALYSIS {
144 return mPrimaryFrameRates;
145 }
146 };
147
148 class RefreshRateSelectorTest : public testing::TestWithParam<Config::FrameRateOverride> {
149 protected:
150 using RefreshRateOrder = TestableRefreshRateSelector::RefreshRateOrder;
151
152 RefreshRateSelectorTest();
153 ~RefreshRateSelectorTest();
154
155 static constexpr DisplayModeId kModeId60{0};
156 static constexpr DisplayModeId kModeId90{1};
157 static constexpr DisplayModeId kModeId72{2};
158 static constexpr DisplayModeId kModeId120{3};
159 static constexpr DisplayModeId kModeId30{4};
160 static constexpr DisplayModeId kModeId25{5};
161 static constexpr DisplayModeId kModeId50{6};
162 static constexpr DisplayModeId kModeId24{7};
163 static constexpr DisplayModeId kModeId24Frac{8};
164 static constexpr DisplayModeId kModeId30Frac{9};
165 static constexpr DisplayModeId kModeId60Frac{10};
166 static constexpr DisplayModeId kModeId35{11};
167 static constexpr DisplayModeId kModeId1{12};
168 static constexpr DisplayModeId kModeId5{13};
169 static constexpr DisplayModeId kModeId10{14};
170
171 static inline const ftl::NonNull<DisplayModePtr> kMode60 =
172 ftl::as_non_null(createDisplayMode(kModeId60, 60_Hz));
173 static inline const ftl::NonNull<DisplayModePtr> kMode60Frac =
174 ftl::as_non_null(createDisplayMode(kModeId60Frac, 59.94_Hz));
175 static inline const ftl::NonNull<DisplayModePtr> kMode90 =
176 ftl::as_non_null(createDisplayMode(kModeId90, 90_Hz));
177 static inline const ftl::NonNull<DisplayModePtr> kMode90_G1 =
178 ftl::as_non_null(createDisplayMode(kModeId90, 90_Hz, 1));
179 static inline const ftl::NonNull<DisplayModePtr> kMode90_4K =
180 ftl::as_non_null(createDisplayMode(kModeId90, 90_Hz, 0, {3840, 2160}));
181 static inline const ftl::NonNull<DisplayModePtr> kMode72 =
182 ftl::as_non_null(createDisplayMode(kModeId72, 72_Hz));
183 static inline const ftl::NonNull<DisplayModePtr> kMode72_G1 =
184 ftl::as_non_null(createDisplayMode(kModeId72, 72_Hz, 1));
185 static inline const ftl::NonNull<DisplayModePtr> kMode120 =
186 ftl::as_non_null(createDisplayMode(kModeId120, 120_Hz));
187 static inline const ftl::NonNull<DisplayModePtr> kMode120_G1 =
188 ftl::as_non_null(createDisplayMode(kModeId120, 120_Hz, 1));
189 static inline const ftl::NonNull<DisplayModePtr> kMode30 =
190 ftl::as_non_null(createDisplayMode(kModeId30, 30_Hz));
191 static inline const ftl::NonNull<DisplayModePtr> kMode30_G1 =
192 ftl::as_non_null(createDisplayMode(kModeId30, 30_Hz, 1));
193 static inline const ftl::NonNull<DisplayModePtr> kMode30Frac =
194 ftl::as_non_null(createDisplayMode(kModeId30Frac, 29.97_Hz));
195 static inline const ftl::NonNull<DisplayModePtr> kMode25 =
196 ftl::as_non_null(createDisplayMode(kModeId25, 25_Hz));
197 static inline const ftl::NonNull<DisplayModePtr> kMode25_G1 =
198 ftl::as_non_null(createDisplayMode(kModeId25, 25_Hz, 1));
199 static inline const ftl::NonNull<DisplayModePtr> kMode35 =
200 ftl::as_non_null(createDisplayMode(kModeId35, 35_Hz));
201 static inline const ftl::NonNull<DisplayModePtr> kMode50 =
202 ftl::as_non_null(createDisplayMode(kModeId50, 50_Hz));
203 static inline const ftl::NonNull<DisplayModePtr> kMode24 =
204 ftl::as_non_null(createDisplayMode(kModeId24, 24_Hz));
205 static inline const ftl::NonNull<DisplayModePtr> kMode24Frac =
206 ftl::as_non_null(createDisplayMode(kModeId24Frac, 23.976_Hz));
207 static inline const ftl::NonNull<DisplayModePtr> kMode1 =
208 ftl::as_non_null(createDisplayMode(kModeId1, 1_Hz));
209 static inline const ftl::NonNull<DisplayModePtr> kMode5 =
210 ftl::as_non_null(createDisplayMode(kModeId5, 5_Hz));
211 static inline const ftl::NonNull<DisplayModePtr> kMode10 =
212 ftl::as_non_null(createDisplayMode(kModeId10, 10_Hz));
213
214 // VRR modes
215 static inline const ftl::NonNull<DisplayModePtr> kVrrMode120TE240 = ftl::as_non_null(
216 createVrrDisplayMode(kModeId120, 240_Hz,
217 hal::VrrConfig{
218 .minFrameIntervalNs =
219 static_cast<Fps>(120_Hz).getPeriodNsecs()}));
220
221 static inline const ftl::NonNull<DisplayModePtr> kVrrMode60TE120 = ftl::as_non_null(
222 createVrrDisplayMode(kModeId60, 120_Hz,
223 hal::VrrConfig{.minFrameIntervalNs =
224 static_cast<Fps>(60_Hz).getPeriodNsecs()},
225 /*group=*/1));
226
227 // Test configurations.
228 static inline const DisplayModes kModes_60 = makeModes(kMode60);
229 static inline const DisplayModes kModes_35_60_90 = makeModes(kMode35, kMode60, kMode90);
230 static inline const DisplayModes kModes_60_90 = makeModes(kMode60, kMode90);
231 static inline const DisplayModes kModes_60_90_G1 = makeModes(kMode60, kMode90_G1);
232 static inline const DisplayModes kModes_60_90_4K = makeModes(kMode60, kMode90_4K);
233 static inline const DisplayModes kModes_60_72_90 = makeModes(kMode60, kMode90, kMode72);
234 static inline const DisplayModes kModes_60_90_72_120 =
235 makeModes(kMode60, kMode90, kMode72, kMode120);
236 static inline const DisplayModes kModes_30_60_72_90_120 =
237 makeModes(kMode60, kMode90, kMode72, kMode120, kMode30);
238
239 static inline const DisplayModes kModes_30_60 =
240 makeModes(kMode60, kMode90_G1, kMode72_G1, kMode120_G1, kMode30);
241 static inline const DisplayModes kModes_30_60_72_90 =
242 makeModes(kMode60, kMode90, kMode72, kMode120_G1, kMode30);
243 static inline const DisplayModes kModes_30_60_90 =
244 makeModes(kMode60, kMode90, kMode72_G1, kMode120_G1, kMode30);
245 static inline const DisplayModes kModes_25_30_50_60 =
246 makeModes(kMode60, kMode90, kMode72_G1, kMode120_G1, kMode30_G1, kMode25_G1, kMode50);
247 static inline const DisplayModes kModes_60_120 = makeModes(kMode60, kMode120);
248 static inline const DisplayModes kModes_1_5_10 = makeModes(kMode1, kMode5, kMode10);
249 static inline const DisplayModes kModes_60_90_120 = makeModes(kMode60, kMode90, kMode120);
250
251 // VRR display modes
252 static inline const DisplayModes kVrrMode_120 = makeModes(kVrrMode120TE240);
253 static inline const DisplayModes kVrrModes_60_120 =
254 makeModes(kVrrMode60TE120, kVrrMode120TE240);
255
256 // This is a typical TV configuration.
257 static inline const DisplayModes kModes_24_25_30_50_60_Frac =
258 makeModes(kMode24, kMode24Frac, kMode25, kMode30, kMode30Frac, kMode50, kMode60,
259 kMode60Frac);
260
createSelector(DisplayModes modes,DisplayModeId activeModeId,Config config={})261 static TestableRefreshRateSelector createSelector(DisplayModes modes,
262 DisplayModeId activeModeId,
263 Config config = {}) {
264 config.enableFrameRateOverride = GetParam();
265 return TestableRefreshRateSelector(modes, activeModeId, config);
266 }
267
268 template <class T>
testFrameRateCategoryWithMultipleLayers(const std::initializer_list<T> & testCases,const TestableRefreshRateSelector & selector)269 void testFrameRateCategoryWithMultipleLayers(const std::initializer_list<T>& testCases,
270 const TestableRefreshRateSelector& selector) {
271 std::vector<LayerRequirement> layers;
272 for (auto testCase : testCases) {
273 ALOGI("**** %s: Testing desiredFrameRate=%s, frameRateCategory=%s", __func__,
274 to_string(testCase.desiredFrameRate).c_str(),
275 ftl::enum_string(testCase.frameRateCategory).c_str());
276
277 if (testCase.desiredFrameRate.isValid()) {
278 std::stringstream ss;
279 ss << to_string(testCase.desiredFrameRate)
280 << ftl::enum_string(testCase.frameRateCategory) << "ExplicitDefault";
281 LayerRequirement layer = {.name = ss.str(),
282 .vote = LayerVoteType::ExplicitDefault,
283 .desiredRefreshRate = testCase.desiredFrameRate,
284 .weight = 1.f};
285 layers.push_back(layer);
286 }
287
288 if (testCase.frameRateCategory != FrameRateCategory::Default) {
289 std::stringstream ss;
290 ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory) << ")";
291 LayerRequirement layer = {.name = ss.str(),
292 .vote = LayerVoteType::ExplicitCategory,
293 .frameRateCategory = testCase.frameRateCategory,
294 .weight = 1.f};
295 layers.push_back(layer);
296 }
297
298 EXPECT_EQ(testCase.expectedFrameRate,
299 selector.getBestFrameRateMode(layers).modePtr->getPeakFps())
300 << "Did not get expected frame rate for frameRate="
301 << to_string(testCase.desiredFrameRate)
302 << " category=" << ftl::enum_string(testCase.frameRateCategory);
303 EXPECT_EQ(testCase.expectedModeId,
304 selector.getBestFrameRateMode(layers).modePtr->getId())
305 << "Did not get expected DisplayModeId for modeId="
306 << ftl::to_underlying(testCase.expectedModeId)
307 << " frameRate=" << to_string(testCase.desiredFrameRate)
308 << " category=" << ftl::enum_string(testCase.frameRateCategory);
309 }
310 }
311 };
312
RefreshRateSelectorTest()313 RefreshRateSelectorTest::RefreshRateSelectorTest() {
314 const ::testing::TestInfo* const test_info =
315 ::testing::UnitTest::GetInstance()->current_test_info();
316 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
317 }
318
~RefreshRateSelectorTest()319 RefreshRateSelectorTest::~RefreshRateSelectorTest() {
320 const ::testing::TestInfo* const test_info =
321 ::testing::UnitTest::GetInstance()->current_test_info();
322 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
323 }
324
325 namespace {
326
327 INSTANTIATE_TEST_SUITE_P(PerOverrideConfig, RefreshRateSelectorTest,
328 testing::Values(Config::FrameRateOverride::Disabled,
329 Config::FrameRateOverride::AppOverrideNativeRefreshRates,
330 Config::FrameRateOverride::AppOverride,
331 Config::FrameRateOverride::Enabled));
332
TEST_P(RefreshRateSelectorTest,oneMode_canSwitch)333 TEST_P(RefreshRateSelectorTest, oneMode_canSwitch) {
334 auto selector = createSelector(kModes_60, kModeId60);
335 if (GetParam() == Config::FrameRateOverride::Enabled) {
336 EXPECT_TRUE(selector.canSwitch());
337 } else {
338 EXPECT_FALSE(selector.canSwitch());
339 }
340 }
341
TEST_P(RefreshRateSelectorTest,invalidPolicy)342 TEST_P(RefreshRateSelectorTest, invalidPolicy) {
343 auto selector = createSelector(kModes_60, kModeId60);
344
345 EXPECT_EQ(SetPolicyResult::Invalid,
346 selector.setDisplayManagerPolicy({DisplayModeId(10), {60_Hz, 60_Hz}}));
347 EXPECT_EQ(SetPolicyResult::Invalid,
348 selector.setDisplayManagerPolicy({kModeId60, {20_Hz, 40_Hz}}));
349 }
350
TEST_P(RefreshRateSelectorTest,unchangedPolicy)351 TEST_P(RefreshRateSelectorTest, unchangedPolicy) {
352 auto selector = createSelector(kModes_60_90, kModeId60);
353
354 EXPECT_EQ(SetPolicyResult::Changed,
355 selector.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}));
356
357 EXPECT_EQ(SetPolicyResult::Unchanged,
358 selector.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}));
359
360 // Override to the same policy.
361 EXPECT_EQ(SetPolicyResult::Unchanged,
362 selector.setPolicy(RefreshRateSelector::OverridePolicy{kModeId90, {60_Hz, 90_Hz}}));
363
364 // Clear override to restore DisplayManagerPolicy.
365 EXPECT_EQ(SetPolicyResult::Unchanged,
366 selector.setPolicy(RefreshRateSelector::NoOverridePolicy{}));
367
368 EXPECT_EQ(SetPolicyResult::Changed,
369 selector.setDisplayManagerPolicy({kModeId90, {30_Hz, 90_Hz}}));
370 }
371
TEST_P(RefreshRateSelectorTest,twoModes_storesFullRefreshRateMap)372 TEST_P(RefreshRateSelectorTest, twoModes_storesFullRefreshRateMap) {
373 auto selector = createSelector(kModes_60_90, kModeId60);
374
375 const auto minRate = selector.getMinSupportedRefreshRate();
376 const auto performanceRate = selector.getMaxSupportedRefreshRate();
377
378 EXPECT_EQ(kMode60, minRate);
379 EXPECT_EQ(kMode90, performanceRate);
380
381 const auto minRateByPolicy = selector.getMinRefreshRateByPolicy();
382 const auto performanceRateByPolicy = selector.getMaxRefreshRateByPolicy();
383
384 EXPECT_EQ(minRateByPolicy, minRate);
385 EXPECT_EQ(performanceRateByPolicy, performanceRate);
386 }
387
TEST_P(RefreshRateSelectorTest,twoModes_storesFullRefreshRateMap_differentGroups)388 TEST_P(RefreshRateSelectorTest, twoModes_storesFullRefreshRateMap_differentGroups) {
389 auto selector = createSelector(kModes_60_90_G1, kModeId60);
390
391 const auto minRate = selector.getMinRefreshRateByPolicy();
392 const auto performanceRate = selector.getMaxSupportedRefreshRate();
393 const auto minRate60 = selector.getMinRefreshRateByPolicy();
394 const auto performanceRate60 = selector.getMaxRefreshRateByPolicy();
395
396 EXPECT_EQ(kMode60, minRate);
397 EXPECT_EQ(kMode60, minRate60);
398 EXPECT_EQ(kMode60, performanceRate60);
399
400 EXPECT_EQ(SetPolicyResult::Changed,
401 selector.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}));
402 selector.setActiveMode(kModeId90, 90_Hz);
403
404 const auto minRate90 = selector.getMinRefreshRateByPolicy();
405 const auto performanceRate90 = selector.getMaxRefreshRateByPolicy();
406
407 EXPECT_EQ(kMode90_G1, performanceRate);
408 EXPECT_EQ(kMode90_G1, minRate90);
409 EXPECT_EQ(kMode90_G1, performanceRate90);
410 }
411
TEST_P(RefreshRateSelectorTest,twoModes_storesFullRefreshRateMap_differentResolutions)412 TEST_P(RefreshRateSelectorTest, twoModes_storesFullRefreshRateMap_differentResolutions) {
413 auto selector = createSelector(kModes_60_90_4K, kModeId60);
414
415 const auto minRate = selector.getMinRefreshRateByPolicy();
416 const auto performanceRate = selector.getMaxSupportedRefreshRate();
417 const auto minRate60 = selector.getMinRefreshRateByPolicy();
418 const auto performanceRate60 = selector.getMaxRefreshRateByPolicy();
419
420 EXPECT_EQ(kMode60, minRate);
421 EXPECT_EQ(kMode60, minRate60);
422 EXPECT_EQ(kMode60, performanceRate60);
423
424 EXPECT_EQ(SetPolicyResult::Changed,
425 selector.setDisplayManagerPolicy({kModeId90, {60_Hz, 90_Hz}}));
426 selector.setActiveMode(kModeId90, 90_Hz);
427
428 const auto minRate90 = selector.getMinRefreshRateByPolicy();
429 const auto performanceRate90 = selector.getMaxRefreshRateByPolicy();
430
431 EXPECT_EQ(kMode90_4K, performanceRate);
432 EXPECT_EQ(kMode90_4K, minRate90);
433 EXPECT_EQ(kMode90_4K, performanceRate90);
434 }
435
TEST_P(RefreshRateSelectorTest,twoModes_policyChange)436 TEST_P(RefreshRateSelectorTest, twoModes_policyChange) {
437 auto selector = createSelector(kModes_60_90, kModeId60);
438
439 const auto minRate = selector.getMinRefreshRateByPolicy();
440 const auto performanceRate = selector.getMaxRefreshRateByPolicy();
441
442 EXPECT_EQ(kMode60, minRate);
443 EXPECT_EQ(kMode90, performanceRate);
444
445 EXPECT_EQ(SetPolicyResult::Changed,
446 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}));
447
448 const auto minRate60 = selector.getMinRefreshRateByPolicy();
449 const auto performanceRate60 = selector.getMaxRefreshRateByPolicy();
450
451 EXPECT_EQ(kMode60, minRate60);
452 EXPECT_EQ(kMode60, performanceRate60);
453 }
454
TEST_P(RefreshRateSelectorTest,twoModes_getActiveMode)455 TEST_P(RefreshRateSelectorTest, twoModes_getActiveMode) {
456 auto selector = createSelector(kModes_60_90, kModeId60);
457 {
458 const auto& mode = selector.getActiveMode();
459 EXPECT_EQ(mode.getId(), kModeId60);
460 }
461
462 selector.setActiveMode(kModeId90, 90_Hz);
463 {
464 const auto& mode = selector.getActiveMode();
465 EXPECT_EQ(mode.getId(), kModeId90);
466 }
467
468 EXPECT_EQ(SetPolicyResult::Changed,
469 selector.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}));
470 {
471 const auto& mode = selector.getActiveMode();
472 EXPECT_EQ(mode.getId(), kModeId90);
473 }
474 }
475
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_noLayers)476 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_noLayers) {
477 {
478 auto selector = createSelector(kModes_60_72_90, kModeId72);
479
480 // If there are no layers we select the default frame rate, which is the max of the primary
481 // range.
482 EXPECT_EQ(kMode90, selector.getBestFrameRateMode().modePtr);
483
484 EXPECT_EQ(SetPolicyResult::Changed,
485 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}));
486 EXPECT_EQ(kMode60, selector.getBestFrameRateMode().modePtr);
487 }
488 {
489 // We select max even when this will cause a non-seamless switch.
490 auto selector = createSelector(kModes_60_90_G1, kModeId60);
491 constexpr bool kAllowGroupSwitching = true;
492 EXPECT_EQ(SetPolicyResult::Changed,
493 selector.setDisplayManagerPolicy(
494 {kModeId90, {0_Hz, 90_Hz}, kAllowGroupSwitching}));
495 EXPECT_EQ(kMode90_G1, selector.getBestFrameRateMode().modePtr);
496 }
497 }
498
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_exactDontChangeRefreshRateWhenNotInPolicy)499 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_exactDontChangeRefreshRateWhenNotInPolicy) {
500 auto selector = createSelector(kModes_30_60_72_90_120, kModeId72);
501
502 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
503 layers[0].vote = LayerVoteType::ExplicitExact;
504 layers[0].desiredRefreshRate = 120_Hz;
505
506 EXPECT_EQ(SetPolicyResult::Changed,
507 selector.setDisplayManagerPolicy({kModeId72, {0_Hz, 90_Hz}}));
508 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
509 }
510
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_60_90)511 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_60_90) {
512 auto selector = createSelector(kModes_60_90, kModeId60);
513
514 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
515 auto& lr = layers[0];
516
517 lr.vote = LayerVoteType::Min;
518 lr.name = "Min";
519 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
520
521 lr.vote = LayerVoteType::Max;
522 lr.name = "Max";
523 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
524
525 lr.desiredRefreshRate = 90_Hz;
526 lr.vote = LayerVoteType::Heuristic;
527 lr.name = "90Hz Heuristic";
528 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
529
530 lr.desiredRefreshRate = 60_Hz;
531 lr.name = "60Hz Heuristic";
532 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
533
534 lr.desiredRefreshRate = 45_Hz;
535 lr.name = "45Hz Heuristic";
536 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
537
538 lr.desiredRefreshRate = 30_Hz;
539 lr.name = "30Hz Heuristic";
540 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
541
542 lr.desiredRefreshRate = 24_Hz;
543 lr.name = "24Hz Heuristic";
544 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
545
546 lr.name = "";
547 EXPECT_EQ(SetPolicyResult::Changed,
548 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}));
549
550 lr.vote = LayerVoteType::Min;
551 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
552
553 lr.vote = LayerVoteType::Max;
554 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
555
556 lr.desiredRefreshRate = 90_Hz;
557 lr.vote = LayerVoteType::Heuristic;
558 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
559
560 lr.desiredRefreshRate = 60_Hz;
561 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
562
563 lr.desiredRefreshRate = 45_Hz;
564 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
565
566 lr.desiredRefreshRate = 30_Hz;
567 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
568
569 lr.desiredRefreshRate = 24_Hz;
570 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
571
572 EXPECT_EQ(SetPolicyResult::Changed,
573 selector.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}));
574
575 lr.vote = LayerVoteType::Min;
576 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
577
578 lr.vote = LayerVoteType::Max;
579 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
580
581 lr.desiredRefreshRate = 90_Hz;
582 lr.vote = LayerVoteType::Heuristic;
583 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
584
585 lr.desiredRefreshRate = 60_Hz;
586 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
587
588 lr.desiredRefreshRate = 45_Hz;
589 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
590
591 lr.desiredRefreshRate = 30_Hz;
592 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
593
594 lr.desiredRefreshRate = 24_Hz;
595 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
596
597 EXPECT_EQ(SetPolicyResult::Changed,
598 selector.setDisplayManagerPolicy({kModeId60, {0_Hz, 120_Hz}}));
599 lr.vote = LayerVoteType::Min;
600 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
601
602 lr.vote = LayerVoteType::Max;
603 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
604
605 lr.desiredRefreshRate = 90_Hz;
606 lr.vote = LayerVoteType::Heuristic;
607 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
608
609 lr.desiredRefreshRate = 60_Hz;
610 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
611
612 lr.desiredRefreshRate = 45_Hz;
613 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
614
615 lr.desiredRefreshRate = 30_Hz;
616 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
617
618 lr.desiredRefreshRate = 24_Hz;
619 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
620 }
621
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_multipleThreshold_60_90)622 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_multipleThreshold_60_90) {
623 auto selector = createSelector(kModes_60_90, kModeId60, {.frameRateMultipleThreshold = 90});
624
625 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
626 auto& lr = layers[0];
627
628 lr.vote = LayerVoteType::Min;
629 lr.name = "Min";
630 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
631
632 lr.vote = LayerVoteType::Max;
633 lr.name = "Max";
634 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
635
636 lr.desiredRefreshRate = 90_Hz;
637 lr.vote = LayerVoteType::Heuristic;
638 lr.name = "90Hz Heuristic";
639 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
640
641 lr.desiredRefreshRate = 60_Hz;
642 lr.name = "60Hz Heuristic";
643 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
644
645 lr.desiredRefreshRate = 45_Hz;
646 lr.name = "45Hz Heuristic";
647 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
648
649 lr.desiredRefreshRate = 30_Hz;
650 lr.name = "30Hz Heuristic";
651 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
652
653 lr.desiredRefreshRate = 24_Hz;
654 lr.name = "24Hz Heuristic";
655 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
656 }
657
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_60_72_90)658 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_60_72_90) {
659 auto selector = createSelector(kModes_60_72_90, kModeId60);
660
661 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
662 auto& lr = layers[0];
663
664 lr.vote = LayerVoteType::Min;
665 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
666
667 lr.vote = LayerVoteType::Max;
668 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
669
670 lr.desiredRefreshRate = 90_Hz;
671 lr.vote = LayerVoteType::Heuristic;
672 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
673
674 lr.desiredRefreshRate = 60_Hz;
675 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
676
677 lr.desiredRefreshRate = 45_Hz;
678 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
679
680 lr.desiredRefreshRate = 30_Hz;
681 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
682
683 lr.desiredRefreshRate = 24_Hz;
684 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
685 }
686
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_30_60_72_90_120)687 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_30_60_72_90_120) {
688 auto selector = createSelector(kModes_30_60_72_90_120, kModeId60);
689
690 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
691 auto& lr1 = layers[0];
692 auto& lr2 = layers[1];
693
694 lr1.desiredRefreshRate = 24_Hz;
695 lr1.vote = LayerVoteType::Heuristic;
696 lr2.desiredRefreshRate = 60_Hz;
697 lr2.vote = LayerVoteType::Heuristic;
698 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
699
700 lr1.desiredRefreshRate = 24_Hz;
701 lr1.vote = LayerVoteType::Heuristic;
702 lr2.desiredRefreshRate = 48_Hz;
703 lr2.vote = LayerVoteType::Heuristic;
704 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
705
706 lr1.desiredRefreshRate = 24_Hz;
707 lr1.vote = LayerVoteType::Heuristic;
708 lr2.desiredRefreshRate = 48_Hz;
709 lr2.vote = LayerVoteType::Heuristic;
710 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
711 }
712
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_30_60_90_120_DifferentTypes)713 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_30_60_90_120_DifferentTypes) {
714 auto selector = createSelector(kModes_30_60_72_90_120, kModeId60);
715
716 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
717 auto& lr1 = layers[0];
718 auto& lr2 = layers[1];
719
720 lr1.desiredRefreshRate = 24_Hz;
721 lr1.vote = LayerVoteType::ExplicitDefault;
722 lr1.name = "24Hz ExplicitDefault";
723 lr2.desiredRefreshRate = 60_Hz;
724 lr2.vote = LayerVoteType::Heuristic;
725 lr2.name = "60Hz Heuristic";
726 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
727
728 lr1.desiredRefreshRate = 24_Hz;
729 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
730 lr1.name = "24Hz ExplicitExactOrMultiple";
731 lr2.desiredRefreshRate = 60_Hz;
732 lr2.vote = LayerVoteType::Heuristic;
733 lr2.name = "60Hz Heuristic";
734 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
735
736 lr1.desiredRefreshRate = 24_Hz;
737 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
738 lr1.name = "24Hz ExplicitExactOrMultiple";
739 lr2.desiredRefreshRate = 60_Hz;
740 lr2.vote = LayerVoteType::ExplicitDefault;
741 lr2.name = "60Hz ExplicitDefault";
742 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
743
744 lr1.desiredRefreshRate = 24_Hz;
745 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
746 lr1.name = "24Hz ExplicitExactOrMultiple";
747 lr2.desiredRefreshRate = 90_Hz;
748 lr2.vote = LayerVoteType::Heuristic;
749 lr2.name = "90Hz Heuristic";
750 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
751
752 lr1.desiredRefreshRate = 24_Hz;
753 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
754 lr1.name = "24Hz ExplicitExactOrMultiple";
755 lr2.desiredRefreshRate = 90_Hz;
756 lr2.vote = LayerVoteType::ExplicitDefault;
757 lr2.name = "90Hz Heuristic";
758 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
759
760 lr1.desiredRefreshRate = 24_Hz;
761 lr1.vote = LayerVoteType::ExplicitDefault;
762 lr1.name = "24Hz ExplicitDefault";
763 lr2.desiredRefreshRate = 90_Hz;
764 lr2.vote = LayerVoteType::Heuristic;
765 lr2.name = "90Hz Heuristic";
766 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
767
768 lr1.desiredRefreshRate = 24_Hz;
769 lr1.vote = LayerVoteType::Heuristic;
770 lr1.name = "24Hz Heuristic";
771 lr2.desiredRefreshRate = 90_Hz;
772 lr2.vote = LayerVoteType::ExplicitDefault;
773 lr2.name = "90Hz ExplicitDefault";
774 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
775
776 lr1.desiredRefreshRate = 24_Hz;
777 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
778 lr1.name = "24Hz ExplicitExactOrMultiple";
779 lr2.desiredRefreshRate = 90_Hz;
780 lr2.vote = LayerVoteType::ExplicitDefault;
781 lr2.name = "90Hz ExplicitDefault";
782 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
783
784 lr1.desiredRefreshRate = 24_Hz;
785 lr1.vote = LayerVoteType::ExplicitDefault;
786 lr1.name = "24Hz ExplicitDefault";
787 lr2.desiredRefreshRate = 90_Hz;
788 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
789 lr2.name = "90Hz ExplicitExactOrMultiple";
790 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
791 }
792
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_30_60_90_120_DifferentTypes_multipleThreshold)793 TEST_P(RefreshRateSelectorTest,
794 getBestFrameRateMode_30_60_90_120_DifferentTypes_multipleThreshold) {
795 auto selector =
796 createSelector(kModes_30_60_72_90_120, kModeId60, {.frameRateMultipleThreshold = 120});
797
798 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}, {.weight = 1.f}};
799 auto& lr1 = layers[0];
800 auto& lr2 = layers[1];
801 auto& lr3 = layers[2];
802
803 lr1.desiredRefreshRate = 24_Hz;
804 lr1.vote = LayerVoteType::ExplicitDefault;
805 lr1.name = "24Hz ExplicitDefault";
806 lr2.desiredRefreshRate = 60_Hz;
807 lr2.vote = LayerVoteType::Heuristic;
808 lr2.name = "60Hz Heuristic";
809 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
810
811 lr1.desiredRefreshRate = 24_Hz;
812 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
813 lr1.name = "24Hz ExplicitExactOrMultiple";
814 lr2.desiredRefreshRate = 60_Hz;
815 lr2.vote = LayerVoteType::Heuristic;
816 lr2.name = "60Hz Heuristic";
817 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
818
819 lr1.desiredRefreshRate = 24_Hz;
820 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
821 lr1.name = "24Hz ExplicitExactOrMultiple";
822 lr2.desiredRefreshRate = 60_Hz;
823 lr2.vote = LayerVoteType::ExplicitDefault;
824 lr2.name = "60Hz ExplicitDefault";
825 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
826
827 lr1.desiredRefreshRate = 24_Hz;
828 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
829 lr1.name = "24Hz ExplicitExactOrMultiple";
830 lr2.desiredRefreshRate = 90_Hz;
831 lr2.vote = LayerVoteType::Heuristic;
832 lr2.name = "90Hz Heuristic";
833 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
834
835 lr1.desiredRefreshRate = 24_Hz;
836 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
837 lr1.name = "24Hz ExplicitExactOrMultiple";
838 lr2.desiredRefreshRate = 90_Hz;
839 lr2.vote = LayerVoteType::ExplicitDefault;
840 lr2.name = "90Hz Heuristic";
841 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
842
843 lr1.desiredRefreshRate = 24_Hz;
844 lr1.vote = LayerVoteType::ExplicitDefault;
845 lr1.name = "24Hz ExplicitDefault";
846 lr2.desiredRefreshRate = 90_Hz;
847 lr2.vote = LayerVoteType::Heuristic;
848 lr2.name = "90Hz Heuristic";
849 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
850
851 lr1.desiredRefreshRate = 24_Hz;
852 lr1.vote = LayerVoteType::Heuristic;
853 lr1.name = "24Hz Heuristic";
854 lr2.desiredRefreshRate = 90_Hz;
855 lr2.vote = LayerVoteType::ExplicitDefault;
856 lr2.name = "90Hz ExplicitDefault";
857 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
858
859 lr1.desiredRefreshRate = 24_Hz;
860 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
861 lr1.name = "24Hz ExplicitExactOrMultiple";
862 lr2.desiredRefreshRate = 90_Hz;
863 lr2.vote = LayerVoteType::ExplicitDefault;
864 lr2.name = "90Hz ExplicitDefault";
865 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
866
867 lr1.desiredRefreshRate = 24_Hz;
868 lr1.vote = LayerVoteType::ExplicitDefault;
869 lr1.name = "24Hz ExplicitDefault";
870 lr2.desiredRefreshRate = 90_Hz;
871 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
872 lr2.name = "90Hz ExplicitExactOrMultiple";
873 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
874
875 lr1.desiredRefreshRate = 24_Hz;
876 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
877 lr1.name = "24Hz ExplicitExactOrMultiple";
878 lr2.vote = LayerVoteType::Max;
879 lr2.name = "Max";
880 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
881
882 lr1.desiredRefreshRate = 24_Hz;
883 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
884 lr1.name = "24Hz ExplicitExactOrMultiple";
885 lr2.desiredRefreshRate = 120_Hz;
886 lr2.vote = LayerVoteType::ExplicitDefault;
887 lr2.name = "120Hz ExplicitDefault";
888 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
889
890 lr1.desiredRefreshRate = 24_Hz;
891 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
892 lr1.name = "24Hz ExplicitExactOrMultiple";
893 lr2.desiredRefreshRate = 120_Hz;
894 lr2.vote = LayerVoteType::ExplicitExact;
895 lr2.name = "120Hz ExplicitExact";
896 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
897
898 lr1.desiredRefreshRate = 10_Hz;
899 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
900 lr1.name = "30Hz ExplicitExactOrMultiple";
901 lr2.desiredRefreshRate = 120_Hz;
902 lr2.vote = LayerVoteType::Heuristic;
903 lr2.name = "120Hz ExplicitExact";
904 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
905
906 lr1.desiredRefreshRate = 30_Hz;
907 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
908 lr1.name = "30Hz ExplicitExactOrMultiple";
909 lr2.desiredRefreshRate = 30_Hz;
910 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
911 lr2.name = "30Hz ExplicitExactOrMultiple";
912 lr3.vote = LayerVoteType::Heuristic;
913 lr3.desiredRefreshRate = 120_Hz;
914 lr3.name = "120Hz Heuristic";
915 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
916 }
917
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_30_60)918 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_30_60) {
919 auto selector = createSelector(kModes_30_60, kModeId60);
920
921 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
922 auto& lr = layers[0];
923
924 lr.vote = LayerVoteType::Min;
925 EXPECT_EQ(kMode30, selector.getBestFrameRateMode(layers).modePtr);
926
927 lr.vote = LayerVoteType::Max;
928 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
929
930 lr.desiredRefreshRate = 90_Hz;
931 lr.vote = LayerVoteType::Heuristic;
932 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
933
934 lr.desiredRefreshRate = 60_Hz;
935 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
936
937 lr.desiredRefreshRate = 45_Hz;
938 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
939
940 lr.desiredRefreshRate = 30_Hz;
941 EXPECT_EQ(kMode30, selector.getBestFrameRateMode(layers).modePtr);
942
943 lr.desiredRefreshRate = 24_Hz;
944 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
945 }
946
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_30_60_72_90)947 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_30_60_72_90) {
948 auto selector = createSelector(kModes_30_60_72_90, kModeId60);
949
950 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
951 auto& lr = layers[0];
952
953 lr.vote = LayerVoteType::Min;
954 lr.name = "Min";
955 EXPECT_EQ(kMode30, selector.getBestFrameRateMode(layers).modePtr);
956
957 lr.vote = LayerVoteType::Max;
958 lr.name = "Max";
959 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
960
961 lr.desiredRefreshRate = 90_Hz;
962 lr.vote = LayerVoteType::Heuristic;
963 lr.name = "90Hz Heuristic";
964 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
965
966 lr.desiredRefreshRate = 60_Hz;
967 lr.name = "60Hz Heuristic";
968 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
969 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
970
971 lr.desiredRefreshRate = 45_Hz;
972 lr.name = "45Hz Heuristic";
973 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
974 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
975
976 lr.desiredRefreshRate = 30_Hz;
977 lr.name = "30Hz Heuristic";
978 EXPECT_EQ(kMode30, selector.getBestFrameRateMode(layers).modePtr);
979 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
980
981 lr.desiredRefreshRate = 24_Hz;
982 lr.name = "24Hz Heuristic";
983 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
984 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
985
986 lr.desiredRefreshRate = 24_Hz;
987 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
988 lr.name = "24Hz ExplicitExactOrMultiple";
989 EXPECT_EQ(kMode72, selector.getBestFrameRateMode(layers).modePtr);
990 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
991 }
992
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_PriorityTest)993 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_PriorityTest) {
994 auto selector = createSelector(kModes_30_60_90, kModeId60);
995
996 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
997 auto& lr1 = layers[0];
998 auto& lr2 = layers[1];
999
1000 lr1.vote = LayerVoteType::Min;
1001 lr2.vote = LayerVoteType::Max;
1002 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1003
1004 lr1.vote = LayerVoteType::Min;
1005 lr2.vote = LayerVoteType::Heuristic;
1006 lr2.desiredRefreshRate = 24_Hz;
1007 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1008
1009 lr1.vote = LayerVoteType::Min;
1010 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1011 lr2.desiredRefreshRate = 24_Hz;
1012 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1013
1014 lr1.vote = LayerVoteType::Max;
1015 lr2.vote = LayerVoteType::Heuristic;
1016 lr2.desiredRefreshRate = 60_Hz;
1017 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1018
1019 lr1.vote = LayerVoteType::Max;
1020 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1021 lr2.desiredRefreshRate = 60_Hz;
1022 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1023
1024 lr1.vote = LayerVoteType::Heuristic;
1025 lr1.desiredRefreshRate = 15_Hz;
1026 lr2.vote = LayerVoteType::Heuristic;
1027 lr2.desiredRefreshRate = 45_Hz;
1028 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1029
1030 lr1.vote = LayerVoteType::Heuristic;
1031 lr1.desiredRefreshRate = 30_Hz;
1032 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1033 lr2.desiredRefreshRate = 45_Hz;
1034 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1035 }
1036
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_24FpsVideo)1037 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_24FpsVideo) {
1038 auto selector = createSelector(kModes_60_90, kModeId60);
1039
1040 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
1041 auto& lr = layers[0];
1042
1043 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
1044 for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
1045 lr.desiredRefreshRate = Fps::fromValue(fps);
1046 const auto mode = selector.getBestFrameRateMode(layers).modePtr;
1047 EXPECT_EQ(kMode60, mode) << lr.desiredRefreshRate << " chooses "
1048 << to_string(mode->getPeakFps()) << "("
1049 << to_string(mode->getVsyncRate()) << ")";
1050 }
1051 }
1052
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_24FpsVideo_multipleThreshold_60_120)1053 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_24FpsVideo_multipleThreshold_60_120) {
1054 auto selector = createSelector(kModes_60_120, kModeId60, {.frameRateMultipleThreshold = 120});
1055
1056 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
1057 auto& lr = layers[0];
1058
1059 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
1060 for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
1061 lr.desiredRefreshRate = Fps::fromValue(fps);
1062 const auto mode = selector.getBestFrameRateMode(layers).modePtr;
1063 EXPECT_EQ(kMode60, mode) << lr.desiredRefreshRate << " chooses "
1064 << to_string(mode->getPeakFps()) << "("
1065 << to_string(mode->getVsyncRate()) << ")";
1066 }
1067 }
1068
TEST_P(RefreshRateSelectorTest,twoModes_getBestFrameRateMode_Explicit)1069 TEST_P(RefreshRateSelectorTest, twoModes_getBestFrameRateMode_Explicit) {
1070 auto selector = createSelector(kModes_60_90, kModeId60);
1071
1072 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
1073 auto& lr1 = layers[0];
1074 auto& lr2 = layers[1];
1075
1076 lr1.vote = LayerVoteType::Heuristic;
1077 lr1.desiredRefreshRate = 60_Hz;
1078 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1079 lr2.desiredRefreshRate = 90_Hz;
1080 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1081
1082 lr1.vote = LayerVoteType::ExplicitDefault;
1083 lr1.desiredRefreshRate = 90_Hz;
1084 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1085 lr2.desiredRefreshRate = 60_Hz;
1086 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1087
1088 lr1.vote = LayerVoteType::Heuristic;
1089 lr1.desiredRefreshRate = 90_Hz;
1090 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1091 lr2.desiredRefreshRate = 60_Hz;
1092 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1093 }
1094
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_75HzContent)1095 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_75HzContent) {
1096 auto selector = createSelector(kModes_60_90, kModeId60);
1097
1098 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
1099 auto& lr = layers[0];
1100
1101 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
1102 for (float fps = 75.0f; fps < 100.0f; fps += 0.1f) {
1103 lr.desiredRefreshRate = Fps::fromValue(fps);
1104 const auto mode = selector.getBestFrameRateMode(layers, {}).modePtr;
1105 EXPECT_EQ(kMode90, mode) << lr.desiredRefreshRate << " chooses "
1106 << to_string(mode->getPeakFps()) << "("
1107 << to_string(mode->getVsyncRate()) << ")";
1108 }
1109 }
1110
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_Multiples)1111 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_Multiples) {
1112 auto selector = createSelector(kModes_60_90, kModeId60);
1113
1114 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
1115 auto& lr1 = layers[0];
1116 auto& lr2 = layers[1];
1117
1118 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1119 lr1.desiredRefreshRate = 60_Hz;
1120 lr1.name = "60Hz ExplicitExactOrMultiple";
1121 lr2.vote = LayerVoteType::Heuristic;
1122 lr2.desiredRefreshRate = 90_Hz;
1123 lr2.name = "90Hz Heuristic";
1124 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1125
1126 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1127 lr1.desiredRefreshRate = 60_Hz;
1128 lr1.name = "60Hz ExplicitExactOrMultiple";
1129 lr2.vote = LayerVoteType::ExplicitDefault;
1130 lr2.desiredRefreshRate = 90_Hz;
1131 lr2.name = "90Hz ExplicitDefault";
1132 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1133
1134 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1135 lr1.desiredRefreshRate = 60_Hz;
1136 lr1.name = "60Hz ExplicitExactOrMultiple";
1137 lr2.vote = LayerVoteType::Max;
1138 lr2.name = "Max";
1139 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1140
1141 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1142 lr1.desiredRefreshRate = 30_Hz;
1143 lr1.name = "30Hz ExplicitExactOrMultiple";
1144 lr2.vote = LayerVoteType::Heuristic;
1145 lr2.desiredRefreshRate = 90_Hz;
1146 lr2.name = "90Hz Heuristic";
1147 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1148
1149 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1150 lr1.desiredRefreshRate = 30_Hz;
1151 lr1.name = "30Hz ExplicitExactOrMultiple";
1152 lr2.vote = LayerVoteType::Max;
1153 lr2.name = "Max";
1154 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1155 }
1156
TEST_P(RefreshRateSelectorTest,scrollWhileWatching60fps_60_90)1157 TEST_P(RefreshRateSelectorTest, scrollWhileWatching60fps_60_90) {
1158 auto selector = createSelector(kModes_60_90, kModeId60);
1159
1160 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
1161 auto& lr1 = layers[0];
1162 auto& lr2 = layers[1];
1163
1164 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1165 lr1.desiredRefreshRate = 60_Hz;
1166 lr1.name = "60Hz ExplicitExactOrMultiple";
1167 lr2.vote = LayerVoteType::NoVote;
1168 lr2.name = "NoVote";
1169 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1170
1171 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1172 lr1.desiredRefreshRate = 60_Hz;
1173 lr1.name = "60Hz ExplicitExactOrMultiple";
1174 lr2.vote = LayerVoteType::NoVote;
1175 lr2.name = "NoVote";
1176 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
1177
1178 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1179 lr1.desiredRefreshRate = 60_Hz;
1180 lr1.name = "60Hz ExplicitExactOrMultiple";
1181 lr2.vote = LayerVoteType::Max;
1182 lr2.name = "Max";
1183 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
1184
1185 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1186 lr1.desiredRefreshRate = 60_Hz;
1187 lr1.name = "60Hz ExplicitExactOrMultiple";
1188 lr2.vote = LayerVoteType::Max;
1189 lr2.name = "Max";
1190 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1191
1192 // The other layer starts to provide buffers
1193 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1194 lr1.desiredRefreshRate = 60_Hz;
1195 lr1.name = "60Hz ExplicitExactOrMultiple";
1196 lr2.vote = LayerVoteType::Heuristic;
1197 lr2.desiredRefreshRate = 90_Hz;
1198 lr2.name = "90Hz Heuristic";
1199 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1200 }
1201
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_ExplicitGte)1202 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_ExplicitGte) {
1203 auto selector = createSelector(makeModes(kMode30, kMode60, kMode90, kMode120), kModeId120);
1204
1205 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
1206 auto& lr1 = layers[0];
1207 auto& lr2 = layers[1];
1208
1209 lr1.vote = LayerVoteType::ExplicitGte;
1210 lr1.desiredRefreshRate = 60_Hz;
1211 lr1.name = "60Hz ExplicitGte";
1212 lr2.vote = LayerVoteType::NoVote;
1213 lr2.name = "NoVote";
1214 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1215
1216 lr1.vote = LayerVoteType::ExplicitGte;
1217 lr1.desiredRefreshRate = 25_Hz;
1218 lr1.name = "25Hz ExplicitGte";
1219 lr2.vote = LayerVoteType::NoVote;
1220 lr2.name = "NoVote";
1221 EXPECT_EQ(kMode30, selector.getBestFrameRateMode(layers).modePtr);
1222
1223 lr1.vote = LayerVoteType::ExplicitGte;
1224 lr1.desiredRefreshRate = 91_Hz;
1225 lr1.name = "91Hz ExplicitGte";
1226 lr2.vote = LayerVoteType::NoVote;
1227 lr2.name = "NoVote";
1228 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
1229
1230 lr1.vote = LayerVoteType::ExplicitGte;
1231 lr1.desiredRefreshRate = 60_Hz;
1232 lr1.name = "60Hz ExplicitGte";
1233 lr2.vote = LayerVoteType::ExplicitDefault;
1234 lr2.desiredRefreshRate = 30_Hz;
1235 lr2.name = "30Hz ExplicitDefault";
1236 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1237
1238 lr1.vote = LayerVoteType::ExplicitGte;
1239 lr1.desiredRefreshRate = 60_Hz;
1240 lr1.name = "60Hz ExplicitGte";
1241 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1242 lr2.desiredRefreshRate = 30_Hz;
1243 lr2.name = "30Hz ExplicitExactOrMultiple";
1244 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1245
1246 lr1.vote = LayerVoteType::ExplicitGte;
1247 lr1.desiredRefreshRate = 60_Hz;
1248 lr1.name = "60Hz ExplicitGte";
1249 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1250 lr2.desiredRefreshRate = 60_Hz;
1251 lr2.name = "60Hz ExplicitExactOrMultiple";
1252 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
1253
1254 lr1.vote = LayerVoteType::ExplicitGte;
1255 lr1.desiredRefreshRate = 60_Hz;
1256 lr1.name = "60Hz ExplicitGte";
1257 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1258 lr2.desiredRefreshRate = 90_Hz;
1259 lr2.name = "90Hz ExplicitExactOrMultiple";
1260 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
1261
1262 lr1.vote = LayerVoteType::ExplicitGte;
1263 lr1.desiredRefreshRate = 60_Hz;
1264 lr1.name = "60Hz ExplicitGte";
1265 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1266 lr2.desiredRefreshRate = 120_Hz;
1267 lr2.name = "120Hz ExplicitExactOrMultiple";
1268 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers).modePtr);
1269 }
1270
TEST_P(RefreshRateSelectorTest,getMaxRefreshRatesByPolicy)1271 TEST_P(RefreshRateSelectorTest, getMaxRefreshRatesByPolicy) {
1272 // The kModes_30_60_90 contains two kMode72_G1, kMode120_G1 which are from the
1273 // different group.
1274 auto selector = createSelector(kModes_30_60_90, kModeId60);
1275 const auto refreshRates = selector.rankRefreshRates(selector.getActiveMode().getGroup(),
1276 RefreshRateOrder::Descending);
1277
1278 const auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
1279 switch (GetParam()) {
1280 case Config::FrameRateOverride::Disabled:
1281 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
1282 case Config::FrameRateOverride::AppOverride:
1283 return {{90_Hz, kMode90}, {60_Hz, kMode60}, {30_Hz, kMode30}};
1284 case Config::FrameRateOverride::Enabled:
1285 return {{90_Hz, kMode90}, {60_Hz, kMode60}, {45_Hz, kMode90}, {30_Hz, kMode30}};
1286 }
1287 }();
1288 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1289
1290 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1291 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1292 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1293 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1294 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1295 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1296 }
1297 }
1298
TEST_P(RefreshRateSelectorTest,getMinRefreshRatesByPolicy)1299 TEST_P(RefreshRateSelectorTest, getMinRefreshRatesByPolicy) {
1300 // The kModes_30_60_90 contains two kMode72_G1, kMode120_G1 which are from the
1301 // different group.
1302 auto selector = createSelector(kModes_30_60_90, kModeId60);
1303
1304 const auto refreshRates = selector.rankRefreshRates(selector.getActiveMode().getGroup(),
1305 RefreshRateOrder::Ascending);
1306
1307 const auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
1308 switch (GetParam()) {
1309 case Config::FrameRateOverride::Disabled:
1310 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
1311 case Config::FrameRateOverride::AppOverride:
1312 return {{30_Hz, kMode30}, {60_Hz, kMode60}, {90_Hz, kMode90}};
1313 case Config::FrameRateOverride::Enabled:
1314 return {{30_Hz, kMode30}, {60_Hz, kMode60}, {90_Hz, kMode90}};
1315 }
1316 }();
1317 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1318
1319 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1320 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1321 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1322 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1323 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1324 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1325 }
1326 }
1327
TEST_P(RefreshRateSelectorTest,getMinRefreshRatesByPolicyOutsideTheGroup)1328 TEST_P(RefreshRateSelectorTest, getMinRefreshRatesByPolicyOutsideTheGroup) {
1329 // The kModes_30_60_90 contains two kMode72_G1, kMode120_G1 which are from the
1330 // different group.
1331 auto selector = createSelector(kModes_30_60_90, kModeId72);
1332
1333 EXPECT_EQ(SetPolicyResult::Changed,
1334 selector.setDisplayManagerPolicy({kModeId60, {30_Hz, 90_Hz}}));
1335
1336 const auto refreshRates =
1337 selector.rankRefreshRates(/*anchorGroupOpt*/ std::nullopt, RefreshRateOrder::Ascending);
1338
1339 const auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
1340 switch (GetParam()) {
1341 case Config::FrameRateOverride::Disabled:
1342 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
1343 case Config::FrameRateOverride::AppOverride:
1344 return {{30_Hz, kMode30}, {60_Hz, kMode60}, {90_Hz, kMode90}};
1345 case Config::FrameRateOverride::Enabled:
1346 return {{30_Hz, kMode30}, {60_Hz, kMode60}, {90_Hz, kMode90}};
1347 }
1348 }();
1349 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1350
1351 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1352 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1353 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1354 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1355 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1356 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1357 }
1358 }
1359
TEST_P(RefreshRateSelectorTest,getMaxRefreshRatesByPolicyOutsideTheGroup)1360 TEST_P(RefreshRateSelectorTest, getMaxRefreshRatesByPolicyOutsideTheGroup) {
1361 // The kModes_30_60_90 contains two kMode72_G1, kMode120_G1 which are from the
1362 // different group.
1363 auto selector = createSelector(kModes_30_60_90, kModeId72);
1364
1365 EXPECT_EQ(SetPolicyResult::Changed,
1366 selector.setDisplayManagerPolicy({kModeId60, {30_Hz, 90_Hz}}));
1367
1368 const auto refreshRates = selector.rankRefreshRates(/*anchorGroupOpt*/ std::nullopt,
1369 RefreshRateOrder::Descending);
1370
1371 const auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
1372 switch (GetParam()) {
1373 case Config::FrameRateOverride::Disabled:
1374 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
1375 case Config::FrameRateOverride::AppOverride:
1376 return {{90_Hz, kMode90}, {60_Hz, kMode60}, {30_Hz, kMode30}};
1377 case Config::FrameRateOverride::Enabled:
1378 return {{90_Hz, kMode90}, {60_Hz, kMode60}, {45_Hz, kMode90}, {30_Hz, kMode30}};
1379 }
1380 }();
1381 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1382
1383 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1384 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1385 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1386 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1387 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1388 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1389 }
1390 }
1391
TEST_P(RefreshRateSelectorTest,powerOnImminentConsidered)1392 TEST_P(RefreshRateSelectorTest, powerOnImminentConsidered) {
1393 auto selector = createSelector(kModes_60_90, kModeId60);
1394
1395 auto [refreshRates, signals, _] = selector.getRankedFrameRates({}, {});
1396 EXPECT_FALSE(signals.powerOnImminent);
1397
1398 auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
1399 switch (GetParam()) {
1400 case Config::FrameRateOverride::Disabled:
1401 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
1402 case Config::FrameRateOverride::AppOverride:
1403 return {{90_Hz, kMode90}, {60_Hz, kMode60}};
1404 case Config::FrameRateOverride::Enabled:
1405 return {{90_Hz, kMode90}, {60_Hz, kMode60}, {45_Hz, kMode90},
1406 {30_Hz, kMode60}, {22.5_Hz, kMode90}, {20_Hz, kMode60}};
1407 }
1408 }();
1409 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1410
1411 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1412 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1413 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1414 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1415 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1416 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1417 }
1418
1419 std::tie(refreshRates, signals) =
1420 selector.getRankedRefreshRatesAsPair({}, {.powerOnImminent = true});
1421 EXPECT_TRUE(signals.powerOnImminent);
1422
1423 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1424
1425 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1426 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1427 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1428 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1429 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1430 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1431 }
1432
1433 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
1434 auto& lr1 = layers[0];
1435 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1436 lr1.desiredRefreshRate = 60_Hz;
1437 lr1.name = "60Hz ExplicitExactOrMultiple";
1438
1439 std::tie(refreshRates, signals) =
1440 selector.getRankedRefreshRatesAsPair(layers, {.powerOnImminent = true});
1441 EXPECT_TRUE(signals.powerOnImminent);
1442
1443 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1444
1445 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1446 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1447 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1448 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1449 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1450 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1451 }
1452
1453 std::tie(refreshRates, signals) =
1454 selector.getRankedRefreshRatesAsPair(layers, {.powerOnImminent = false});
1455 EXPECT_FALSE(signals.powerOnImminent);
1456
1457 expectedRefreshRates = []() -> std::vector<FrameRateMode> {
1458 switch (GetParam()) {
1459 case Config::FrameRateOverride::Disabled:
1460 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
1461 case Config::FrameRateOverride::AppOverride:
1462 return {{60_Hz, kMode60}, {90_Hz, kMode90}};
1463 case Config::FrameRateOverride::Enabled:
1464 return {{60_Hz, kMode60}, {90_Hz, kMode90}, {45_Hz, kMode90},
1465 {30_Hz, kMode60}, {22.5_Hz, kMode90}, {20_Hz, kMode60}};
1466 }
1467 }();
1468 ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
1469
1470 for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
1471 EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
1472 << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
1473 << expectedRefreshRates[i].modePtr->getVsyncRate().getIntValue() << ")"
1474 << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
1475 << refreshRates[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
1476 }
1477 }
1478
TEST_P(RefreshRateSelectorTest,pacesetterConsidered)1479 TEST_P(RefreshRateSelectorTest, pacesetterConsidered) {
1480 auto selector = createSelector(kModes_60_90, kModeId60);
1481 constexpr RefreshRateSelector::GlobalSignals kNoSignals;
1482
1483 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
1484 layers[0].vote = LayerVoteType::Min;
1485
1486 // The pacesetterFps takes precedence over the LayerRequirement.
1487 {
1488 const auto result = selector.getRankedFrameRates(layers, {}, 90_Hz);
1489 EXPECT_EQ(kMode90, result.ranking.front().frameRateMode.modePtr);
1490 EXPECT_EQ(kNoSignals, result.consideredSignals);
1491 }
1492
1493 // The pacesetterFps takes precedence over GlobalSignals.
1494 {
1495 const auto result = selector.getRankedFrameRates(layers, {.touch = true}, 60_Hz);
1496 EXPECT_EQ(kMode60, result.ranking.front().frameRateMode.modePtr);
1497 EXPECT_EQ(kNoSignals, result.consideredSignals);
1498 }
1499 }
1500
TEST_P(RefreshRateSelectorTest,touchConsidered)1501 TEST_P(RefreshRateSelectorTest, touchConsidered) {
1502 auto selector = createSelector(kModes_60_90, kModeId60);
1503
1504 auto signals = selector.getRankedFrameRates({}, {}).consideredSignals;
1505 EXPECT_FALSE(signals.touch);
1506
1507 std::tie(std::ignore, signals) = selector.getRankedRefreshRatesAsPair({}, {.touch = true});
1508 EXPECT_TRUE(signals.touch);
1509
1510 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
1511 auto& lr1 = layers[0];
1512 auto& lr2 = layers[1];
1513
1514 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1515 lr1.desiredRefreshRate = 60_Hz;
1516 lr1.name = "60Hz ExplicitExactOrMultiple";
1517 lr2.vote = LayerVoteType::Heuristic;
1518 lr2.desiredRefreshRate = 60_Hz;
1519 lr2.name = "60Hz Heuristic";
1520 std::tie(std::ignore, signals) = selector.getRankedRefreshRatesAsPair(layers, {.touch = true});
1521 EXPECT_TRUE(signals.touch);
1522
1523 lr1.vote = LayerVoteType::ExplicitDefault;
1524 lr1.desiredRefreshRate = 60_Hz;
1525 lr1.name = "60Hz ExplicitDefault";
1526 lr2.vote = LayerVoteType::Heuristic;
1527 lr2.desiredRefreshRate = 60_Hz;
1528 lr2.name = "60Hz Heuristic";
1529 std::tie(std::ignore, signals) = selector.getRankedRefreshRatesAsPair(layers, {.touch = true});
1530 EXPECT_FALSE(signals.touch);
1531
1532 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1533 lr1.desiredRefreshRate = 60_Hz;
1534 lr1.name = "60Hz ExplicitExactOrMultiple";
1535 lr2.vote = LayerVoteType::Heuristic;
1536 lr2.desiredRefreshRate = 60_Hz;
1537 lr2.name = "60Hz Heuristic";
1538 std::tie(std::ignore, signals) = selector.getRankedRefreshRatesAsPair(layers, {.touch = true});
1539 EXPECT_TRUE(signals.touch);
1540
1541 lr1.vote = LayerVoteType::ExplicitDefault;
1542 lr1.desiredRefreshRate = 60_Hz;
1543 lr1.name = "60Hz ExplicitDefault";
1544 lr2.vote = LayerVoteType::Heuristic;
1545 lr2.desiredRefreshRate = 60_Hz;
1546 lr2.name = "60Hz Heuristic";
1547 std::tie(std::ignore, signals) = selector.getRankedRefreshRatesAsPair(layers, {.touch = true});
1548 EXPECT_FALSE(signals.touch);
1549 }
1550
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_30_60_90_120)1551 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_30_60_90_120) {
1552 auto selector = createSelector(makeModes(kMode30, kMode60, kMode90, kMode120), kModeId60);
1553
1554 struct Case {
1555 // Params
1556 Fps desiredFrameRate = 0_Hz;
1557 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
1558
1559 // Expected result
1560 Fps expectedFrameRate = 0_Hz;
1561 };
1562
1563 // Prepare a table with the vote and the expected refresh rate
1564 const std::initializer_list<Case> testCases = {
1565 // Cases that only have frame rate category requirements, but no desired frame rate.
1566 // When frame rates get an equal score, the lower is chosen, unless there are Max votes.
1567 {0_Hz, FrameRateCategory::High, 90_Hz},
1568 {0_Hz, FrameRateCategory::Normal, 60_Hz},
1569 {0_Hz, FrameRateCategory::Low, 60_Hz},
1570 {0_Hz, FrameRateCategory::NoPreference, 60_Hz},
1571
1572 // Cases that have both desired frame rate and frame rate category requirements.
1573 {24_Hz, FrameRateCategory::High, 120_Hz},
1574 {30_Hz, FrameRateCategory::High, 90_Hz},
1575 {12_Hz, FrameRateCategory::Normal, 60_Hz},
1576 {30_Hz, FrameRateCategory::NoPreference, 30_Hz},
1577
1578 // Cases that only have desired frame rate.
1579 {30_Hz, FrameRateCategory::Default, 30_Hz},
1580 };
1581
1582 for (auto testCase : testCases) {
1583 std::vector<LayerRequirement> layers;
1584 ALOGI("**** %s: Testing desiredFrameRate=%s, frameRateCategory=%s", __func__,
1585 to_string(testCase.desiredFrameRate).c_str(),
1586 ftl::enum_string(testCase.frameRateCategory).c_str());
1587
1588 if (testCase.desiredFrameRate.isValid()) {
1589 std::stringstream ss;
1590 ss << to_string(testCase.desiredFrameRate) << "ExplicitDefault";
1591 LayerRequirement layer = {.name = ss.str(),
1592 .vote = LayerVoteType::ExplicitDefault,
1593 .desiredRefreshRate = testCase.desiredFrameRate,
1594 .weight = 1.f};
1595 layers.push_back(layer);
1596 }
1597
1598 if (testCase.frameRateCategory != FrameRateCategory::Default) {
1599 std::stringstream ss;
1600 ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory) << ")";
1601 LayerRequirement layer = {.name = ss.str(),
1602 .vote = LayerVoteType::ExplicitCategory,
1603 .frameRateCategory = testCase.frameRateCategory,
1604 .weight = 1.f};
1605 layers.push_back(layer);
1606 }
1607
1608 EXPECT_EQ(testCase.expectedFrameRate,
1609 selector.getBestFrameRateMode(layers).modePtr->getPeakFps())
1610 << "Did not get expected frame rate for frameRate="
1611 << to_string(testCase.desiredFrameRate)
1612 << " category=" << ftl::enum_string(testCase.frameRateCategory);
1613 }
1614 }
1615
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_120_vrr)1616 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_120_vrr) {
1617 if (GetParam() != Config::FrameRateOverride::Enabled) {
1618 return;
1619 }
1620
1621 SET_FLAG_FOR_TEST(flags::vrr_config, true);
1622 // Device with VRR config mode
1623 auto selector = createSelector(kVrrMode_120, kModeId120);
1624
1625 struct Case {
1626 // Params
1627 Fps desiredFrameRate = 0_Hz;
1628 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
1629
1630 // Expected result
1631 Fps expectedFrameRate = 0_Hz;
1632 };
1633
1634 // Prepare a table with the vote and the expected refresh rate
1635 const std::initializer_list<Case> testCases = {
1636 // Cases that only have frame rate category requirements, but no desired frame rate.
1637 // When frame rates get an equal score, the lower is chosen, unless there are Max votes.
1638 {0_Hz, FrameRateCategory::High, 120_Hz},
1639 {0_Hz, FrameRateCategory::Normal, 60_Hz},
1640 {0_Hz, FrameRateCategory::Low, 48_Hz},
1641 {0_Hz, FrameRateCategory::NoPreference, 120_Hz},
1642
1643 // Cases that have both desired frame rate and frame rate category requirements.
1644 {24_Hz, FrameRateCategory::High, 120_Hz},
1645 {30_Hz, FrameRateCategory::High, 120_Hz},
1646 {12_Hz, FrameRateCategory::Normal, 60_Hz},
1647 {24_Hz, FrameRateCategory::Low, 48_Hz},
1648 {30_Hz, FrameRateCategory::NoPreference, 30_Hz},
1649
1650 // Cases that only have desired frame rate.
1651 {30_Hz, FrameRateCategory::Default, 30_Hz},
1652 };
1653
1654 for (auto testCase : testCases) {
1655 std::vector<LayerRequirement> layers;
1656 ALOGI("**** %s: Testing desiredFrameRate=%s, frameRateCategory=%s", __func__,
1657 to_string(testCase.desiredFrameRate).c_str(),
1658 ftl::enum_string(testCase.frameRateCategory).c_str());
1659
1660 if (testCase.desiredFrameRate.isValid()) {
1661 std::stringstream ss;
1662 ss << to_string(testCase.desiredFrameRate) << "ExplicitDefault";
1663 LayerRequirement layer = {.name = ss.str(),
1664 .vote = LayerVoteType::ExplicitDefault,
1665 .desiredRefreshRate = testCase.desiredFrameRate,
1666 .weight = 1.f};
1667 layers.push_back(layer);
1668 }
1669
1670 if (testCase.frameRateCategory != FrameRateCategory::Default) {
1671 std::stringstream ss;
1672 ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory) << ")";
1673 LayerRequirement layer = {.name = ss.str(),
1674 .vote = LayerVoteType::ExplicitCategory,
1675 .frameRateCategory = testCase.frameRateCategory,
1676 .weight = 1.f};
1677 layers.push_back(layer);
1678 }
1679
1680 EXPECT_EQ(testCase.expectedFrameRate, selector.getBestFrameRateMode(layers).fps)
1681 << "Did not get expected frame rate for frameRate="
1682 << to_string(testCase.desiredFrameRate)
1683 << " category=" << ftl::enum_string(testCase.frameRateCategory);
1684 }
1685 }
1686
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategoryMultiLayers_30_60_90_120)1687 TEST_P(RefreshRateSelectorTest,
1688 getBestFrameRateMode_withFrameRateCategoryMultiLayers_30_60_90_120) {
1689 auto selector = createSelector(makeModes(kMode30, kMode60, kMode90, kMode120), kModeId60);
1690
1691 struct Case {
1692 // Params
1693 Fps desiredFrameRate = 0_Hz;
1694 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
1695
1696 // Expected result
1697 Fps expectedFrameRate = 0_Hz;
1698 DisplayModeId expectedModeId = kModeId90;
1699 };
1700
1701 testFrameRateCategoryWithMultipleLayers(
1702 std::initializer_list<Case>{
1703 {0_Hz, FrameRateCategory::High, 90_Hz},
1704 {0_Hz, FrameRateCategory::NoPreference, 90_Hz},
1705 {0_Hz, FrameRateCategory::Normal, 90_Hz},
1706 {0_Hz, FrameRateCategory::Normal, 90_Hz},
1707 {0_Hz, FrameRateCategory::NoPreference, 90_Hz},
1708 },
1709 selector);
1710
1711 testFrameRateCategoryWithMultipleLayers(
1712 std::initializer_list<Case>{
1713 {0_Hz, FrameRateCategory::Normal, 60_Hz, kModeId60},
1714 {0_Hz, FrameRateCategory::High, 90_Hz},
1715 {0_Hz, FrameRateCategory::NoPreference, 90_Hz},
1716 },
1717 selector);
1718
1719 testFrameRateCategoryWithMultipleLayers(
1720 std::initializer_list<Case>{
1721 {30_Hz, FrameRateCategory::High, 90_Hz},
1722 {24_Hz, FrameRateCategory::High, 120_Hz, kModeId120},
1723 {12_Hz, FrameRateCategory::Normal, 120_Hz, kModeId120},
1724 {30_Hz, FrameRateCategory::NoPreference, 120_Hz, kModeId120},
1725
1726 },
1727 selector);
1728
1729 testFrameRateCategoryWithMultipleLayers(
1730 std::initializer_list<Case>{
1731 {24_Hz, FrameRateCategory::Default, 120_Hz, kModeId120},
1732 {30_Hz, FrameRateCategory::Default, 120_Hz, kModeId120},
1733 {120_Hz, FrameRateCategory::Default, 120_Hz, kModeId120},
1734 },
1735 selector);
1736 }
1737
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategoryMultiLayers_60_120)1738 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategoryMultiLayers_60_120) {
1739 auto selector = createSelector(makeModes(kMode60, kMode120), kModeId60);
1740
1741 struct Case {
1742 // Params
1743 Fps desiredFrameRate = 0_Hz;
1744 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
1745
1746 // Expected result
1747 Fps expectedFrameRate = 0_Hz;
1748 DisplayModeId expectedModeId = kModeId120;
1749 };
1750
1751 testFrameRateCategoryWithMultipleLayers(std::initializer_list<
1752 Case>{{0_Hz, FrameRateCategory::High, 120_Hz},
1753 {0_Hz, FrameRateCategory::NoPreference,
1754 120_Hz},
1755 {0_Hz, FrameRateCategory::Normal, 120_Hz},
1756 {0_Hz, FrameRateCategory::Normal, 120_Hz},
1757 {0_Hz, FrameRateCategory::NoPreference,
1758 120_Hz}},
1759 selector);
1760
1761 testFrameRateCategoryWithMultipleLayers(std::initializer_list<
1762 Case>{{24_Hz, FrameRateCategory::High, 120_Hz},
1763 {30_Hz, FrameRateCategory::High, 120_Hz},
1764 {12_Hz, FrameRateCategory::Normal,
1765 120_Hz},
1766 {30_Hz, FrameRateCategory::NoPreference,
1767 120_Hz}},
1768 selector);
1769
1770 testFrameRateCategoryWithMultipleLayers(
1771 std::initializer_list<Case>{
1772 {24_Hz, FrameRateCategory::Default, 120_Hz},
1773 {30_Hz, FrameRateCategory::Default, 120_Hz},
1774 {120_Hz, FrameRateCategory::Default, 120_Hz},
1775 },
1776 selector);
1777 }
1778
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_60_120)1779 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_60_120) {
1780 auto selector = createSelector(makeModes(kMode60, kMode120), kModeId60);
1781
1782 struct Case {
1783 // Params
1784 Fps desiredFrameRate = 0_Hz;
1785 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
1786
1787 // Expected result
1788 Fps expectedFrameRate = 0_Hz;
1789 };
1790
1791 // Prepare a table with the vote and the expected refresh rate
1792 const std::initializer_list<Case> testCases = {
1793 // Cases that only have frame rate category requirements, but no desired frame rate.
1794 // When frame rates get an equal score, the lower is chosen, unless there are Max votes.
1795 {0_Hz, FrameRateCategory::High, 120_Hz},
1796 {0_Hz, FrameRateCategory::Normal, 60_Hz},
1797 {0_Hz, FrameRateCategory::Low, 60_Hz},
1798 {0_Hz, FrameRateCategory::NoPreference, 60_Hz},
1799
1800 // Cases that have both desired frame rate and frame rate category requirements.
1801 {24_Hz, FrameRateCategory::High, 120_Hz},
1802 {30_Hz, FrameRateCategory::High, 120_Hz},
1803 {12_Hz, FrameRateCategory::Normal, 60_Hz},
1804 {30_Hz, FrameRateCategory::NoPreference, 60_Hz},
1805
1806 // Cases that only have desired frame rate.
1807 {30_Hz, FrameRateCategory::Default, 60_Hz},
1808 };
1809
1810 for (auto testCase : testCases) {
1811 std::vector<LayerRequirement> layers;
1812 ALOGI("**** %s: Testing desiredFrameRate=%s, frameRateCategory=%s", __func__,
1813 to_string(testCase.desiredFrameRate).c_str(),
1814 ftl::enum_string(testCase.frameRateCategory).c_str());
1815
1816 if (testCase.desiredFrameRate.isValid()) {
1817 std::stringstream ss;
1818 ss << to_string(testCase.desiredFrameRate) << "ExplicitDefault";
1819 LayerRequirement layer = {.name = ss.str(),
1820 .vote = LayerVoteType::ExplicitDefault,
1821 .desiredRefreshRate = testCase.desiredFrameRate,
1822 .weight = 1.f};
1823 layers.push_back(layer);
1824 }
1825
1826 if (testCase.frameRateCategory != FrameRateCategory::Default) {
1827 std::stringstream ss;
1828 ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory) << ")";
1829 LayerRequirement layer = {.name = ss.str(),
1830 .vote = LayerVoteType::ExplicitCategory,
1831 .frameRateCategory = testCase.frameRateCategory,
1832 .weight = 1.f};
1833 layers.push_back(layer);
1834 }
1835
1836 EXPECT_EQ(testCase.expectedFrameRate,
1837 selector.getBestFrameRateMode(layers).modePtr->getPeakFps())
1838 << "Did not get expected frame rate for frameRate="
1839 << to_string(testCase.desiredFrameRate)
1840 << " category=" << ftl::enum_string(testCase.frameRateCategory);
1841 }
1842 }
1843
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_vrrHighHintTouch_primaryRangeIsSingleRate)1844 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_vrrHighHintTouch_primaryRangeIsSingleRate) {
1845 if (GetParam() != Config::FrameRateOverride::Enabled) {
1846 return;
1847 }
1848
1849 SET_FLAG_FOR_TEST(flags::vrr_config, true);
1850
1851 auto selector = createSelector(kVrrMode_120, kModeId120);
1852 selector.setActiveMode(kModeId120, 60_Hz);
1853
1854 // Change primary physical range to be single rate, which on VRR device should not affect
1855 // fps scoring.
1856 EXPECT_EQ(SetPolicyResult::Changed,
1857 selector.setDisplayManagerPolicy({kModeId120, {120_Hz, 120_Hz}}));
1858
1859 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
1860 layers[0].vote = LayerVoteType::ExplicitCategory;
1861 layers[0].frameRateCategory = FrameRateCategory::HighHint;
1862 layers[0].name = "ExplicitCategory HighHint";
1863
1864 auto actualRankedFrameRates = selector.getRankedFrameRates(layers);
1865 // Expect late touch boost from HighHint.
1866 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1867 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1868 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1869
1870 layers[1].vote = LayerVoteType::ExplicitExactOrMultiple;
1871 layers[1].desiredRefreshRate = 30_Hz;
1872 layers[1].name = "ExplicitExactOrMultiple 30Hz";
1873
1874 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1875 // Expect late touch boost from HighHint.
1876 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1877 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1878 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1879 }
1880
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_HighHint)1881 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_HighHint) {
1882 auto selector = createSelector(makeModes(kMode24, kMode30, kMode60, kMode120), kModeId60);
1883
1884 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
1885 auto& lr1 = layers[0];
1886 auto& lr2 = layers[1];
1887
1888 lr1.vote = LayerVoteType::ExplicitCategory;
1889 lr1.frameRateCategory = FrameRateCategory::HighHint;
1890 lr1.name = "ExplicitCategory HighHint";
1891 lr2.vote = LayerVoteType::NoVote;
1892 lr2.name = "NoVote";
1893 auto actualRankedFrameRates = selector.getRankedFrameRates(layers);
1894 // Gets touch boost
1895 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1896 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1897 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1898
1899 // No touch boost, for example a game that uses setFrameRate(30, default compatibility).
1900 lr1.vote = LayerVoteType::ExplicitCategory;
1901 lr1.frameRateCategory = FrameRateCategory::HighHint;
1902 lr1.name = "ExplicitCategory HighHint";
1903 lr2.vote = LayerVoteType::ExplicitDefault;
1904 lr2.desiredRefreshRate = 30_Hz;
1905 lr2.name = "30Hz ExplicitDefault";
1906 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1907 EXPECT_EQ(30_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1908 EXPECT_EQ(kModeId30, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1909 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
1910
1911 lr1.vote = LayerVoteType::ExplicitCategory;
1912 lr1.frameRateCategory = FrameRateCategory::HighHint;
1913 lr1.name = "ExplicitCategory HighHint";
1914 lr2.vote = LayerVoteType::ExplicitCategory;
1915 lr2.frameRateCategory = FrameRateCategory::HighHint;
1916 lr2.name = "ExplicitCategory HighHint#2";
1917 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1918 // Gets touch boost
1919 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1920 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1921 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1922
1923 lr1.vote = LayerVoteType::ExplicitCategory;
1924 lr1.frameRateCategory = FrameRateCategory::HighHint;
1925 lr1.name = "ExplicitCategory HighHint";
1926 lr2.vote = LayerVoteType::ExplicitCategory;
1927 lr2.frameRateCategory = FrameRateCategory::Low;
1928 lr2.name = "ExplicitCategory Low";
1929 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1930 // Gets touch boost
1931 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1932 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1933 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1934
1935 lr1.vote = LayerVoteType::ExplicitCategory;
1936 lr1.frameRateCategory = FrameRateCategory::HighHint;
1937 lr1.name = "ExplicitCategory HighHint";
1938 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1939 lr2.frameRateCategory = FrameRateCategory::Default;
1940 lr2.desiredRefreshRate = 30_Hz;
1941 lr2.name = "30Hz ExplicitExactOrMultiple";
1942 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1943 // Gets touch boost
1944 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1945 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1946 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1947
1948 lr1.vote = LayerVoteType::ExplicitCategory;
1949 lr1.frameRateCategory = FrameRateCategory::HighHint;
1950 lr1.name = "ExplicitCategory HighHint";
1951 lr2.vote = LayerVoteType::ExplicitExact;
1952 lr2.desiredRefreshRate = 30_Hz;
1953 lr2.name = "30Hz ExplicitExact";
1954 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1955 if (selector.supportsAppFrameRateOverrideByContent()) {
1956 // Gets touch boost
1957 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1958 EXPECT_EQ(kModeId120,
1959 actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1960 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1961 } else {
1962 EXPECT_EQ(30_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1963 EXPECT_EQ(kModeId30, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1964 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
1965 }
1966
1967 lr1.vote = LayerVoteType::ExplicitCategory;
1968 lr1.frameRateCategory = FrameRateCategory::HighHint;
1969 lr1.name = "ExplicitCategory HighHint";
1970 lr2.vote = LayerVoteType::Heuristic;
1971 lr2.desiredRefreshRate = 30_Hz;
1972 lr2.name = "30Hz Heuristic";
1973 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1974 // Gets touch boost
1975 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1976 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1977 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1978
1979 lr1.vote = LayerVoteType::ExplicitCategory;
1980 lr1.frameRateCategory = FrameRateCategory::HighHint;
1981 lr1.name = "ExplicitCategory HighHint";
1982 lr2.vote = LayerVoteType::Min;
1983 lr2.name = "Min";
1984 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1985 // Gets touch boost
1986 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1987 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1988 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
1989
1990 lr1.vote = LayerVoteType::ExplicitCategory;
1991 lr1.frameRateCategory = FrameRateCategory::HighHint;
1992 lr1.name = "ExplicitCategory HighHint";
1993 lr2.vote = LayerVoteType::Max;
1994 lr2.name = "Max";
1995 actualRankedFrameRates = selector.getRankedFrameRates(layers);
1996 // Gets touch boost
1997 EXPECT_EQ(120_Hz, actualRankedFrameRates.ranking.front().frameRateMode.fps);
1998 EXPECT_EQ(kModeId120, actualRankedFrameRates.ranking.front().frameRateMode.modePtr->getId());
1999 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2000 }
2001
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_TouchBoost)2002 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_TouchBoost) {
2003 auto selector = createSelector(makeModes(kMode24, kMode30, kMode60, kMode120), kModeId60);
2004
2005 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 1.f}};
2006 auto& lr1 = layers[0];
2007 auto& lr2 = layers[1];
2008
2009 lr1.vote = LayerVoteType::ExplicitCategory;
2010 lr1.frameRateCategory = FrameRateCategory::Normal;
2011 lr1.name = "ExplicitCategory Normal";
2012 lr2.vote = LayerVoteType::NoVote;
2013 lr2.name = "NoVote";
2014 auto actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2015 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2016 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
2017
2018 // No touch boost, for example a game that uses setFrameRate(30, default compatibility).
2019 lr1.vote = LayerVoteType::ExplicitCategory;
2020 lr1.frameRateCategory = FrameRateCategory::Normal;
2021 lr1.name = "ExplicitCategory Normal";
2022 lr2.vote = LayerVoteType::ExplicitDefault;
2023 lr2.desiredRefreshRate = 30_Hz;
2024 lr2.name = "30Hz ExplicitDefault";
2025 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2026 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2027 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
2028
2029 lr1.vote = LayerVoteType::ExplicitCategory;
2030 lr1.frameRateCategory = FrameRateCategory::Normal;
2031 lr1.name = "ExplicitCategory Normal";
2032 lr2.vote = LayerVoteType::ExplicitCategory;
2033 lr2.frameRateCategory = FrameRateCategory::HighHint;
2034 lr2.name = "ExplicitCategory HighHint";
2035 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2036 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2037 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2038
2039 lr1.vote = LayerVoteType::ExplicitCategory;
2040 lr1.frameRateCategory = FrameRateCategory::Normal;
2041 lr1.name = "ExplicitCategory Normal";
2042 lr2.vote = LayerVoteType::ExplicitCategory;
2043 lr2.frameRateCategory = FrameRateCategory::Low;
2044 lr2.name = "ExplicitCategory Low";
2045 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2046 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2047 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
2048
2049 lr1.vote = LayerVoteType::ExplicitCategory;
2050 lr1.frameRateCategory = FrameRateCategory::Normal;
2051 lr1.name = "ExplicitCategory Normal";
2052 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
2053 lr2.frameRateCategory = FrameRateCategory::Default;
2054 lr2.desiredRefreshRate = 30_Hz;
2055 lr2.name = "30Hz ExplicitExactOrMultiple";
2056 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2057 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2058 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2059
2060 lr1.vote = LayerVoteType::ExplicitCategory;
2061 lr1.frameRateCategory = FrameRateCategory::Normal;
2062 lr1.name = "ExplicitCategory Normal";
2063 lr2.vote = LayerVoteType::ExplicitExact;
2064 lr2.desiredRefreshRate = 30_Hz;
2065 lr2.name = "30Hz ExplicitExact";
2066 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2067 if (selector.supportsAppFrameRateOverrideByContent()) {
2068 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz,
2069 actualRankedFrameRates.ranking.front().frameRateMode);
2070 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2071 } else {
2072 EXPECT_FRAME_RATE_MODE(kMode30, 30_Hz,
2073 actualRankedFrameRates.ranking.front().frameRateMode);
2074 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
2075 }
2076
2077 lr1.vote = LayerVoteType::ExplicitCategory;
2078 lr1.frameRateCategory = FrameRateCategory::Normal;
2079 lr1.name = "ExplicitCategory Normal";
2080 lr2.vote = LayerVoteType::Min;
2081 lr2.name = "Min";
2082 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2083 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2084 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2085
2086 lr1.vote = LayerVoteType::ExplicitCategory;
2087 lr1.frameRateCategory = FrameRateCategory::Normal;
2088 lr1.name = "ExplicitCategory Normal";
2089 lr2.vote = LayerVoteType::Max;
2090 lr2.name = "Max";
2091 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2092 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2093 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2094
2095 lr1.vote = LayerVoteType::ExplicitCategory;
2096 lr1.frameRateCategory = FrameRateCategory::Normal;
2097 lr1.name = "ExplicitCategory Normal";
2098 lr2.vote = LayerVoteType::Heuristic;
2099 lr2.name = "30Hz Heuristic";
2100 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2101 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2102 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2103
2104 lr1.vote = LayerVoteType::ExplicitCategory;
2105 lr1.frameRateCategory = FrameRateCategory::Normal;
2106 lr1.name = "ExplicitCategory Normal";
2107 lr2.vote = LayerVoteType::ExplicitGte;
2108 lr2.desiredRefreshRate = 30_Hz;
2109 lr2.name = "30Hz ExplicitGte";
2110 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2111 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, actualRankedFrameRates.ranking.front().frameRateMode);
2112 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
2113 }
2114
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_touchBoost_twoUids_arr)2115 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withFrameRateCategory_touchBoost_twoUids_arr) {
2116 if (GetParam() != Config::FrameRateOverride::Enabled) {
2117 return;
2118 }
2119
2120 SET_FLAG_FOR_TEST(flags::vrr_config, true);
2121 // Device with VRR config mode
2122 auto selector = createSelector(kVrrMode_120, kModeId120);
2123
2124 std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f},
2125 {.ownerUid = 5678, .weight = 1.f}};
2126 auto& lr1 = layers[0];
2127 auto& lr2 = layers[1];
2128
2129 lr1.vote = LayerVoteType::ExplicitCategory;
2130 lr1.frameRateCategory = FrameRateCategory::Normal;
2131 lr1.name = "ExplicitCategory Normal";
2132 lr2.vote = LayerVoteType::ExplicitDefault;
2133 lr2.desiredRefreshRate = 30_Hz;
2134 lr2.name = "30Hz ExplicitDefault";
2135 auto actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2136 // No global touch boost, for example a game that uses setFrameRate(30, default compatibility).
2137 // However see 60 due to Normal vote.
2138 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 60_Hz,
2139 actualRankedFrameRates.ranking.front().frameRateMode);
2140 EXPECT_FALSE(actualRankedFrameRates.consideredSignals.touch);
2141
2142 lr1.vote = LayerVoteType::ExplicitCategory;
2143 lr1.frameRateCategory = FrameRateCategory::HighHint;
2144 lr1.name = "ExplicitCategory HighHint";
2145 lr2.vote = LayerVoteType::ExplicitDefault;
2146 lr2.desiredRefreshRate = 30_Hz;
2147 lr2.name = "30Hz ExplicitDefault";
2148 // Gets touch boost because the touched (HighHint) app is different from the 30 Default app.
2149 actualRankedFrameRates = selector.getRankedFrameRates(layers, {.touch = true});
2150 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 120_Hz,
2151 actualRankedFrameRates.ranking.front().frameRateMode);
2152 EXPECT_TRUE(actualRankedFrameRates.consideredSignals.touch);
2153 }
2154
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_idleTimer_60_120_nonVrr)2155 TEST_P(RefreshRateSelectorTest,
2156 getBestFrameRateMode_withFrameRateCategory_idleTimer_60_120_nonVrr) {
2157 SET_FLAG_FOR_TEST(flags::vrr_config, false);
2158 using KernelIdleTimerAction = RefreshRateSelector::KernelIdleTimerAction;
2159 struct LayerArg {
2160 // Params
2161 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
2162 LayerVoteType voteType = LayerVoteType::ExplicitDefault;
2163
2164 // Expected result
2165 Fps expectedFrameRate = 0_Hz;
2166 DisplayModeId expectedModeId = kModeId60;
2167 };
2168
2169 const auto runTest = [&](const TestableRefreshRateSelector& selector,
2170 const std::initializer_list<LayerArg>& layerArgs,
2171 const RefreshRateSelector::GlobalSignals& signals) {
2172 std::vector<LayerRequirement> layers;
2173 for (auto testCase : layerArgs) {
2174 ALOGI("**** %s: Testing frameRateCategory=%s", __func__,
2175 ftl::enum_string(testCase.frameRateCategory).c_str());
2176
2177 if (testCase.frameRateCategory != FrameRateCategory::Default) {
2178 std::stringstream ss;
2179 ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory) << ")";
2180 LayerRequirement layer = {.name = ss.str(),
2181 .vote = LayerVoteType::ExplicitCategory,
2182 .frameRateCategory = testCase.frameRateCategory,
2183 .weight = 1.f};
2184 layers.push_back(layer);
2185 }
2186
2187 if (testCase.voteType != LayerVoteType::ExplicitDefault) {
2188 std::stringstream ss;
2189 ss << ftl::enum_string(testCase.voteType);
2190 LayerRequirement layer = {.name = ss.str(),
2191 .vote = testCase.voteType,
2192 .weight = 1.f};
2193 layers.push_back(layer);
2194 }
2195
2196 EXPECT_EQ(testCase.expectedFrameRate,
2197 selector.getBestFrameRateMode(layers, signals).modePtr->getPeakFps())
2198 << "Did not get expected frame rate for"
2199 << " category=" << ftl::enum_string(testCase.frameRateCategory);
2200 EXPECT_EQ(testCase.expectedModeId,
2201 selector.getBestFrameRateMode(layers, signals).modePtr->getId())
2202 << "Did not get expected DisplayModeId for modeId="
2203 << ftl::to_underlying(testCase.expectedModeId)
2204 << " category=" << ftl::enum_string(testCase.frameRateCategory);
2205 }
2206 };
2207
2208 {
2209 // IdleTimer not configured
2210 auto selector = createSelector(makeModes(kMode60, kMode120), kModeId120);
2211 ASSERT_EQ(0ms, selector.getIdleTimerTimeout());
2212
2213 runTest(selector,
2214 std::initializer_list<LayerArg>{
2215 // Rate does not change due to NoPreference.
2216 {.frameRateCategory = FrameRateCategory::NoPreference,
2217 .expectedFrameRate = 120_Hz,
2218 .expectedModeId = kModeId120},
2219 {.voteType = LayerVoteType::NoVote,
2220 .expectedFrameRate = 120_Hz,
2221 .expectedModeId = kModeId120},
2222 {.frameRateCategory = FrameRateCategory::NoPreference,
2223 .expectedFrameRate = 120_Hz,
2224 .expectedModeId = kModeId120},
2225 },
2226 {.idle = false});
2227 }
2228
2229 // IdleTimer configured
2230 constexpr std::chrono::milliseconds kIdleTimerTimeoutMs = 10ms;
2231 auto selector = createSelector(makeModes(kMode60, kMode120), kModeId120,
2232 Config{
2233 .legacyIdleTimerTimeout = kIdleTimerTimeoutMs,
2234 });
2235 ASSERT_EQ(KernelIdleTimerAction::TurnOn, selector.getIdleTimerAction());
2236 ASSERT_EQ(kIdleTimerTimeoutMs, selector.getIdleTimerTimeout());
2237 runTest(selector,
2238 std::initializer_list<LayerArg>{
2239 // Rate won't change immediately and will stay 120 due to NoPreference, as
2240 // idle timer did not timeout yet.
2241 {.frameRateCategory = FrameRateCategory::NoPreference,
2242 .expectedFrameRate = 120_Hz,
2243 .expectedModeId = kModeId120},
2244 {.voteType = LayerVoteType::NoVote,
2245 .expectedFrameRate = 120_Hz,
2246 .expectedModeId = kModeId120},
2247 {.frameRateCategory = FrameRateCategory::NoPreference,
2248 .expectedFrameRate = 120_Hz,
2249 .expectedModeId = kModeId120},
2250 },
2251 {.idle = false});
2252
2253 // Idle timer is triggered using GlobalSignals.
2254 ASSERT_EQ(KernelIdleTimerAction::TurnOn, selector.getIdleTimerAction());
2255 ASSERT_EQ(kIdleTimerTimeoutMs, selector.getIdleTimerTimeout());
2256 runTest(selector,
2257 std::initializer_list<LayerArg>{
2258 {.frameRateCategory = FrameRateCategory::NoPreference,
2259 .expectedFrameRate = 60_Hz,
2260 .expectedModeId = kModeId60},
2261 {.voteType = LayerVoteType::NoVote,
2262 .expectedFrameRate = 60_Hz,
2263 .expectedModeId = kModeId60},
2264 {.frameRateCategory = FrameRateCategory::NoPreference,
2265 .expectedFrameRate = 60_Hz,
2266 .expectedModeId = kModeId60},
2267 },
2268 {.idle = true});
2269 }
2270
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_smoothSwitchOnly_60_120_nonVrr)2271 TEST_P(RefreshRateSelectorTest,
2272 getBestFrameRateMode_withFrameRateCategory_smoothSwitchOnly_60_120_nonVrr) {
2273 if (GetParam() != Config::FrameRateOverride::Enabled) {
2274 return;
2275 }
2276
2277 SET_FLAG_FOR_TEST(flags::vrr_config, false);
2278 // VRR compatibility is determined by the presence of a vrr config in the DisplayMode.
2279 auto selector = createSelector(makeModes(kMode60, kMode120), kModeId120);
2280
2281 struct Case {
2282 // Params
2283 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
2284 bool smoothSwitchOnly = false;
2285
2286 // Expected result
2287 Fps expectedFrameRate = 0_Hz;
2288 DisplayModeId expectedModeId = kModeId60;
2289 };
2290
2291 const std::initializer_list<Case> testCases = {
2292 // These layers may switch modes because smoothSwitchOnly=false.
2293 {FrameRateCategory::Default, false, 120_Hz, kModeId120},
2294 {FrameRateCategory::NoPreference, false, 120_Hz, kModeId120},
2295 {FrameRateCategory::Low, false, 60_Hz, kModeId60},
2296 {FrameRateCategory::Normal, false, 60_Hz, kModeId60},
2297 {FrameRateCategory::High, false, 120_Hz, kModeId120},
2298
2299 // These layers cannot change mode due to smoothSwitchOnly, and will definitely use
2300 // active mode (120Hz).
2301 {FrameRateCategory::NoPreference, true, 120_Hz, kModeId120},
2302 {FrameRateCategory::Low, true, 120_Hz, kModeId120},
2303 {FrameRateCategory::Normal, true, 120_Hz, kModeId120},
2304 {FrameRateCategory::High, true, 120_Hz, kModeId120},
2305 };
2306
2307 for (auto testCase : testCases) {
2308 std::vector<LayerRequirement> layers;
2309 ALOGI("**** %s: Testing frameRateCategory=%s (smooth=%d)", __func__,
2310 ftl::enum_string(testCase.frameRateCategory).c_str(), testCase.smoothSwitchOnly);
2311
2312 if (testCase.frameRateCategory != FrameRateCategory::Default) {
2313 std::stringstream ss;
2314 ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory)
2315 << " smooth:" << testCase.smoothSwitchOnly << ")";
2316 LayerRequirement layer = {.name = ss.str(),
2317 .vote = LayerVoteType::ExplicitCategory,
2318 .frameRateCategory = testCase.frameRateCategory,
2319 .frameRateCategorySmoothSwitchOnly =
2320 testCase.smoothSwitchOnly,
2321 .weight = 1.f};
2322 layers.push_back(layer);
2323 }
2324
2325 auto actualFrameRateMode = selector.getBestFrameRateMode(layers);
2326 EXPECT_EQ(testCase.expectedFrameRate, actualFrameRateMode.fps)
2327 << "Did not get expected frame rate for category="
2328 << ftl::enum_string(testCase.frameRateCategory)
2329 << " (smooth=" << testCase.smoothSwitchOnly << ")";
2330
2331 EXPECT_EQ(testCase.expectedModeId, actualFrameRateMode.modePtr->getId())
2332 << "Did not get expected mode for category="
2333 << ftl::enum_string(testCase.frameRateCategory)
2334 << " (smooth=" << testCase.smoothSwitchOnly << ")";
2335 }
2336 }
2337
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withFrameRateCategory_smoothSwitchOnly_60_120_vrr)2338 TEST_P(RefreshRateSelectorTest,
2339 getBestFrameRateMode_withFrameRateCategory_smoothSwitchOnly_60_120_vrr) {
2340 if (GetParam() != Config::FrameRateOverride::Enabled) {
2341 return;
2342 }
2343
2344 SET_FLAG_FOR_TEST(flags::vrr_config, true);
2345 // VRR compatibility is determined by the presence of a vrr config in the DisplayMode.
2346 auto selector = createSelector(kVrrModes_60_120, kModeId120);
2347
2348 struct Case {
2349 // Params
2350 FrameRateCategory frameRateCategory = FrameRateCategory::Default;
2351 bool smoothSwitchOnly = false;
2352
2353 // Expected result
2354 Fps expectedFrameRate = 0_Hz;
2355 };
2356
2357 // Note that `smoothSwitchOnly` should not have an effect.
2358 const std::initializer_list<Case> testCases = {
2359 {FrameRateCategory::Default, false, 120_Hz},
2360 // TODO(b/266481656): Once this bug is fixed, NoPreference should be a lower frame rate.
2361 {FrameRateCategory::NoPreference, false, 120_Hz},
2362 {FrameRateCategory::Low, false, 48_Hz},
2363 {FrameRateCategory::Normal, false, 60_Hz},
2364 {FrameRateCategory::High, false, 120_Hz},
2365 {FrameRateCategory::Default, true, 120_Hz},
2366 // TODO(b/266481656): Once this bug is fixed, NoPreference should be a lower frame rate.
2367 {FrameRateCategory::NoPreference, true, 120_Hz},
2368 {FrameRateCategory::Low, true, 48_Hz},
2369 {FrameRateCategory::Normal, true, 60_Hz},
2370 {FrameRateCategory::High, true, 120_Hz},
2371 };
2372
2373 for (auto testCase : testCases) {
2374 std::vector<LayerRequirement> layers;
2375 ALOGI("**** %s: Testing frameRateCategory=%s (smooth=%d)", __func__,
2376 ftl::enum_string(testCase.frameRateCategory).c_str(), testCase.smoothSwitchOnly);
2377
2378 if (testCase.frameRateCategory != FrameRateCategory::Default) {
2379 std::stringstream ss;
2380 ss << "ExplicitCategory (" << ftl::enum_string(testCase.frameRateCategory)
2381 << " smooth:" << testCase.smoothSwitchOnly << ")";
2382 LayerRequirement layer = {.name = ss.str(),
2383 .vote = LayerVoteType::ExplicitCategory,
2384 .frameRateCategory = testCase.frameRateCategory,
2385 .frameRateCategorySmoothSwitchOnly =
2386 testCase.smoothSwitchOnly,
2387 .weight = 1.f};
2388 layers.push_back(layer);
2389 }
2390
2391 auto actualFrameRateMode = selector.getBestFrameRateMode(layers);
2392 EXPECT_EQ(testCase.expectedFrameRate, actualFrameRateMode.fps)
2393 << "Did not get expected frame rate for category="
2394 << ftl::enum_string(testCase.frameRateCategory)
2395 << " (smooth=" << testCase.smoothSwitchOnly << ")";
2396
2397 // Expect all cases to be able to stay at the mode with TE 240 due to VRR compatibility.
2398 EXPECT_EQ(kVrrMode120TE240->getId(), actualFrameRateMode.modePtr->getId())
2399 << "Did not get expected mode for category="
2400 << ftl::enum_string(testCase.frameRateCategory)
2401 << " (smooth=" << testCase.smoothSwitchOnly << ")";
2402 }
2403 }
2404
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_ExplicitDefault)2405 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_ExplicitDefault) {
2406 auto selector = createSelector(kModes_60_90_72_120, kModeId60);
2407
2408 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2409 auto& lr = layers[0];
2410
2411 // Prepare a table with the vote and the expected refresh rate
2412 const std::initializer_list<std::pair<Fps, Fps>> testCases = {
2413 {130_Hz, 120_Hz}, {120_Hz, 120_Hz}, {119_Hz, 120_Hz}, {110_Hz, 120_Hz},
2414
2415 {100_Hz, 90_Hz}, {90_Hz, 90_Hz}, {89_Hz, 90_Hz},
2416
2417 {80_Hz, 72_Hz}, {73_Hz, 72_Hz}, {72_Hz, 72_Hz}, {71_Hz, 72_Hz}, {70_Hz, 72_Hz},
2418
2419 {65_Hz, 60_Hz}, {60_Hz, 60_Hz}, {59_Hz, 60_Hz}, {58_Hz, 60_Hz},
2420
2421 {55_Hz, 90_Hz}, {50_Hz, 90_Hz}, {45_Hz, 90_Hz},
2422
2423 {42_Hz, 120_Hz}, {40_Hz, 120_Hz}, {39_Hz, 120_Hz},
2424
2425 {37_Hz, 72_Hz}, {36_Hz, 72_Hz}, {35_Hz, 72_Hz},
2426
2427 {30_Hz, 60_Hz},
2428 };
2429
2430 for (auto [desired, expected] : testCases) {
2431 lr.vote = LayerVoteType::ExplicitDefault;
2432 lr.desiredRefreshRate = desired;
2433
2434 std::stringstream ss;
2435 ss << "ExplicitDefault " << desired;
2436 lr.name = ss.str();
2437
2438 const auto bestMode = selector.getBestFrameRateMode(layers).modePtr;
2439 EXPECT_EQ(expected, bestMode->getPeakFps())
2440 << "expected " << expected << " for " << desired << " but got "
2441 << bestMode->getPeakFps() << "(" << bestMode->getVsyncRate() << ")";
2442 }
2443 }
2444
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_ExplicitExactOrMultiple_WithFractionalRefreshRates)2445 TEST_P(RefreshRateSelectorTest,
2446 getBestFrameRateMode_ExplicitExactOrMultiple_WithFractionalRefreshRates) {
2447 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2448 auto& lr = layers[0];
2449
2450 // Test that 23.976 will prefer 60 over 59.94 and 30
2451 {
2452 auto selector = createSelector(makeModes(kMode24, kMode25, kMode30, kMode30Frac, kMode60,
2453 kMode60Frac),
2454 kModeId60);
2455
2456 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
2457 lr.desiredRefreshRate = 23.976_Hz;
2458 lr.name = "ExplicitExactOrMultiple 23.976 Hz";
2459 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
2460 }
2461
2462 // Test that 24 will choose 23.976 if 24 is not supported
2463 {
2464 auto selector = createSelector(makeModes(kMode24Frac, kMode25, kMode30, kMode30Frac,
2465 kMode60, kMode60Frac),
2466 kModeId60);
2467
2468 lr.desiredRefreshRate = 24_Hz;
2469 lr.name = "ExplicitExactOrMultiple 24 Hz";
2470 EXPECT_EQ(kModeId24Frac, selector.getBestFrameRateMode(layers).modePtr->getId());
2471 }
2472
2473 // Test that 29.97 will prefer 59.94 over 60 and 30
2474 {
2475 auto selector = createSelector(makeModes(kMode24, kMode24Frac, kMode25, kMode30, kMode60,
2476 kMode60Frac),
2477 kModeId60);
2478
2479 lr.desiredRefreshRate = 29.97_Hz;
2480 lr.name = "ExplicitExactOrMultiple 29.97 Hz";
2481 EXPECT_EQ(kModeId60Frac, selector.getBestFrameRateMode(layers).modePtr->getId());
2482 }
2483
2484 // Test that 29.97 will choose 60 if 59.94 is not supported
2485 {
2486 auto selector = createSelector(makeModes(kMode30, kMode60), kModeId60);
2487
2488 lr.desiredRefreshRate = 29.97_Hz;
2489 lr.name = "ExplicitExactOrMultiple 29.97 Hz";
2490 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
2491 }
2492
2493 // Test that 59.94 will choose 60 if 59.94 is not supported
2494 {
2495 auto selector = createSelector(makeModes(kMode60, kMode30Frac, kMode30), kModeId60);
2496
2497 lr.desiredRefreshRate = 59.94_Hz;
2498 lr.name = "ExplicitExactOrMultiple 59.94 Hz";
2499 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
2500 }
2501 }
2502
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_ExplicitExact_WithFractionalRefreshRates)2503 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_ExplicitExact_WithFractionalRefreshRates) {
2504 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2505 auto& lr = layers[0];
2506
2507 // Test that voting for supported refresh rate will select this refresh rate
2508 {
2509 auto selector = createSelector(kModes_24_25_30_50_60_Frac, kModeId60);
2510
2511 for (auto desired : {23.976_Hz, 24_Hz, 25_Hz, 29.97_Hz, 30_Hz, 50_Hz, 59.94_Hz, 60_Hz}) {
2512 lr.vote = LayerVoteType::ExplicitExact;
2513 lr.desiredRefreshRate = desired;
2514 std::stringstream ss;
2515 ss << "ExplicitExact " << desired;
2516 lr.name = ss.str();
2517
2518 EXPECT_EQ(lr.desiredRefreshRate,
2519 selector.getBestFrameRateMode(layers).modePtr->getPeakFps());
2520 }
2521 }
2522 }
2523
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withDisplayManagerRequestingSingleRate_ignoresTouchFlag)2524 TEST_P(RefreshRateSelectorTest,
2525 getBestFrameRateMode_withDisplayManagerRequestingSingleRate_ignoresTouchFlag) {
2526 auto selector = createSelector(kModes_60_90, kModeId90);
2527
2528 constexpr FpsRange k90 = {90_Hz, 90_Hz};
2529 constexpr FpsRange k60_90 = {60_Hz, 90_Hz};
2530 EXPECT_EQ(SetPolicyResult::Changed,
2531 selector.setDisplayManagerPolicy({kModeId90, {k90, k90}, {k60_90, k60_90}}));
2532
2533 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2534 auto& lr = layers[0];
2535
2536 lr.vote = LayerVoteType::ExplicitDefault;
2537 lr.desiredRefreshRate = 60_Hz;
2538 lr.name = "60Hz ExplicitDefault";
2539 lr.focused = true;
2540
2541 const auto [rankedFrameRate, signals, _] =
2542 selector.getRankedFrameRates(layers, {.touch = true, .idle = true});
2543
2544 EXPECT_EQ(rankedFrameRate.begin()->frameRateMode.modePtr, kMode60);
2545 EXPECT_FALSE(signals.touch);
2546 }
2547
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withDisplayManagerRequestingSingleRate_ignoresIdleFlag)2548 TEST_P(RefreshRateSelectorTest,
2549 getBestFrameRateMode_withDisplayManagerRequestingSingleRate_ignoresIdleFlag) {
2550 auto selector = createSelector(kModes_60_90, kModeId60);
2551
2552 constexpr FpsRange k60 = {60_Hz, 60_Hz};
2553 constexpr FpsRange k60_90 = {60_Hz, 90_Hz};
2554
2555 EXPECT_EQ(SetPolicyResult::Changed,
2556 selector.setDisplayManagerPolicy({kModeId60, {k60, k60}, {k60_90, k60_90}}));
2557
2558 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2559 auto& lr = layers[0];
2560
2561 lr.vote = LayerVoteType::ExplicitDefault;
2562 lr.desiredRefreshRate = 90_Hz;
2563 lr.name = "90Hz ExplicitDefault";
2564 lr.focused = true;
2565 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers, {.idle = true}).modePtr);
2566 }
2567
TEST_P(RefreshRateSelectorTest,testDisplayModeOrdering)2568 TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
2569 auto selector = createSelector(kModes_30_60_72_90_120, kModeId60);
2570
2571 std::vector<LayerRequirement> layers = {{.weight = 1.f},
2572 {.weight = 1.f},
2573 {.weight = 1.f},
2574 {.weight = 1.f},
2575 {.weight = 1.f}};
2576 auto& lr1 = layers[0];
2577 auto& lr2 = layers[1];
2578 auto& lr3 = layers[2];
2579 auto& lr4 = layers[3];
2580 auto& lr5 = layers[4];
2581
2582 lr1.desiredRefreshRate = 90_Hz;
2583 lr1.name = "90Hz";
2584 lr1.focused = true;
2585
2586 lr2.desiredRefreshRate = 60_Hz;
2587 lr2.name = "60Hz";
2588 lr2.focused = true;
2589
2590 lr3.desiredRefreshRate = 72_Hz;
2591 lr3.name = "72Hz";
2592 lr3.focused = true;
2593
2594 lr4.desiredRefreshRate = 120_Hz;
2595 lr4.name = "120Hz";
2596 lr4.focused = true;
2597
2598 lr5.desiredRefreshRate = 30_Hz;
2599 lr5.name = "30Hz";
2600 lr5.focused = true;
2601
2602 auto expectedRanking = []() -> std::vector<FrameRateMode> {
2603 switch (GetParam()) {
2604 case Config::FrameRateOverride::Disabled:
2605 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
2606 case Config::FrameRateOverride::AppOverride:
2607 return {{120_Hz, kMode120},
2608 {90_Hz, kMode90},
2609 {72_Hz, kMode72},
2610 {60_Hz, kMode60},
2611 {30_Hz, kMode30}};
2612 case Config::FrameRateOverride::Enabled:
2613 return {{120_Hz, kMode120}, {90_Hz, kMode90}, {72_Hz, kMode72}, {60_Hz, kMode60},
2614 {45_Hz, kMode90}, {40_Hz, kMode120}, {36_Hz, kMode72}, {30_Hz, kMode30}};
2615 }
2616 }();
2617
2618 auto actualRanking = selector.getRankedFrameRates(layers, {}).ranking;
2619 ASSERT_EQ(expectedRanking.size(), actualRanking.size());
2620
2621 for (size_t i = 0; i < expectedRanking.size(); ++i) {
2622 EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
2623 << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
2624 << expectedRanking[i].modePtr->getVsyncRate().getIntValue() << ")"
2625 << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
2626 << actualRanking[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
2627 }
2628
2629 lr1.vote = LayerVoteType::Max;
2630 lr1.name = "Max";
2631
2632 lr2.desiredRefreshRate = 60_Hz;
2633 lr2.name = "60Hz";
2634
2635 lr3.desiredRefreshRate = 72_Hz;
2636 lr3.name = "72Hz";
2637
2638 lr4.desiredRefreshRate = 90_Hz;
2639 lr4.name = "90Hz";
2640
2641 lr5.desiredRefreshRate = 120_Hz;
2642 lr5.name = "120Hz";
2643
2644 expectedRanking = []() -> std::vector<FrameRateMode> {
2645 switch (GetParam()) {
2646 case Config::FrameRateOverride::Disabled:
2647 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
2648 case Config::FrameRateOverride::AppOverride:
2649 return {{120_Hz, kMode120},
2650 {90_Hz, kMode90},
2651 {72_Hz, kMode72},
2652 {60_Hz, kMode60},
2653 {30_Hz, kMode30}};
2654 case Config::FrameRateOverride::Enabled:
2655 return {{120_Hz, kMode120}, {90_Hz, kMode90}, {72_Hz, kMode72}, {60_Hz, kMode60},
2656 {45_Hz, kMode90}, {40_Hz, kMode120}, {36_Hz, kMode72}, {30_Hz, kMode30}};
2657 }
2658 }();
2659 actualRanking = selector.getRankedFrameRates(layers, {}).ranking;
2660
2661 ASSERT_EQ(expectedRanking.size(), actualRanking.size());
2662
2663 for (size_t i = 0; i < expectedRanking.size(); ++i) {
2664 EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
2665 << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
2666 << expectedRanking[i].modePtr->getVsyncRate().getIntValue() << ")"
2667 << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
2668 << actualRanking[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
2669 }
2670
2671 lr1.vote = LayerVoteType::Heuristic;
2672 lr1.desiredRefreshRate = 30_Hz;
2673 lr1.name = "30Hz";
2674
2675 lr2.desiredRefreshRate = 120_Hz;
2676 lr2.name = "120Hz";
2677
2678 lr3.desiredRefreshRate = 60_Hz;
2679 lr3.name = "60Hz";
2680
2681 lr5.desiredRefreshRate = 72_Hz;
2682 lr5.name = "72Hz";
2683
2684 expectedRanking = []() -> std::vector<FrameRateMode> {
2685 switch (GetParam()) {
2686 case Config::FrameRateOverride::Disabled:
2687 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
2688 case Config::FrameRateOverride::AppOverride:
2689 return {{30_Hz, kMode30},
2690 {60_Hz, kMode60},
2691 {90_Hz, kMode90},
2692 {120_Hz, kMode120},
2693 {72_Hz, kMode72}};
2694 case Config::FrameRateOverride::Enabled:
2695 return {{30_Hz, kMode30}, {60_Hz, kMode60}, {90_Hz, kMode90}, {120_Hz, kMode120},
2696 {45_Hz, kMode90}, {40_Hz, kMode120}, {72_Hz, kMode72}, {36_Hz, kMode72}};
2697 }
2698 }();
2699 actualRanking = selector.getRankedFrameRates(layers, {}).ranking;
2700
2701 ASSERT_EQ(expectedRanking.size(), actualRanking.size());
2702
2703 for (size_t i = 0; i < expectedRanking.size(); ++i) {
2704 EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
2705 << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
2706 << expectedRanking[i].modePtr->getVsyncRate().getIntValue() << ")"
2707 << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
2708 << actualRanking[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
2709 }
2710
2711 lr1.desiredRefreshRate = 120_Hz;
2712 lr1.name = "120Hz";
2713 lr1.weight = 0.0f;
2714
2715 lr2.desiredRefreshRate = 60_Hz;
2716 lr2.name = "60Hz";
2717 lr2.vote = LayerVoteType::NoVote;
2718
2719 lr3.name = "60Hz-2";
2720 lr3.vote = LayerVoteType::Heuristic;
2721
2722 lr4.vote = LayerVoteType::ExplicitExact;
2723
2724 lr5.desiredRefreshRate = 120_Hz;
2725 lr5.name = "120Hz-2";
2726
2727 expectedRanking = []() -> std::vector<FrameRateMode> {
2728 switch (GetParam()) {
2729 case Config::FrameRateOverride::Disabled:
2730 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
2731 case Config::FrameRateOverride::AppOverride:
2732 return {{90_Hz, kMode90},
2733 {60_Hz, kMode60},
2734 {120_Hz, kMode120},
2735 {72_Hz, kMode72},
2736 {30_Hz, kMode30}};
2737 case Config::FrameRateOverride::Enabled:
2738 return {{90_Hz, kMode90}, {60_Hz, kMode60}, {120_Hz, kMode120}, {72_Hz, kMode72},
2739 {45_Hz, kMode90}, {40_Hz, kMode120}, {36_Hz, kMode72}, {30_Hz, kMode30}};
2740 }
2741 }();
2742 actualRanking = selector.getRankedFrameRates(layers, {}).ranking;
2743
2744 ASSERT_EQ(expectedRanking.size(), actualRanking.size());
2745
2746 for (size_t i = 0; i < expectedRanking.size(); ++i) {
2747 EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
2748 << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
2749 << expectedRanking[i].modePtr->getVsyncRate().getIntValue() << ")"
2750 << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
2751 << actualRanking[i].frameRateMode.modePtr->getVsyncRate().getIntValue() << ")";
2752 }
2753 }
2754
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withDisplayManagerRequestingSingleRate_onlySwitchesRatesForExplicitFocusedLayers)2755 TEST_P(RefreshRateSelectorTest,
2756 getBestFrameRateMode_withDisplayManagerRequestingSingleRate_onlySwitchesRatesForExplicitFocusedLayers) {
2757 auto selector = createSelector(kModes_60_90, kModeId90);
2758
2759 constexpr FpsRange k90 = {90_Hz, 90_Hz};
2760 constexpr FpsRange k60_90 = {60_Hz, 90_Hz};
2761
2762 EXPECT_EQ(SetPolicyResult::Changed,
2763 selector.setDisplayManagerPolicy({kModeId90, {k90, k90}, {k60_90, k60_90}}));
2764
2765 const auto [ranking, signals, _] = selector.getRankedFrameRates({}, {});
2766 EXPECT_EQ(ranking.front().frameRateMode.modePtr, kMode90);
2767 EXPECT_FALSE(signals.touch);
2768
2769 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2770 auto& lr = layers[0];
2771
2772 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
2773 lr.desiredRefreshRate = 60_Hz;
2774 lr.name = "60Hz ExplicitExactOrMultiple";
2775 lr.focused = false;
2776 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2777
2778 lr.focused = true;
2779 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2780
2781 lr.vote = LayerVoteType::ExplicitDefault;
2782 lr.desiredRefreshRate = 60_Hz;
2783 lr.name = "60Hz ExplicitDefault";
2784 lr.focused = false;
2785 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2786
2787 lr.focused = true;
2788 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
2789
2790 lr.vote = LayerVoteType::Heuristic;
2791 lr.desiredRefreshRate = 60_Hz;
2792 lr.name = "60Hz Heuristic";
2793 lr.focused = false;
2794 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2795
2796 lr.focused = true;
2797 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2798
2799 lr.vote = LayerVoteType::Max;
2800 lr.desiredRefreshRate = 60_Hz;
2801 lr.name = "60Hz Max";
2802 lr.focused = false;
2803 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2804
2805 lr.focused = true;
2806 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2807
2808 lr.vote = LayerVoteType::Min;
2809 lr.desiredRefreshRate = 60_Hz;
2810 lr.name = "60Hz Min";
2811 lr.focused = false;
2812 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2813
2814 lr.focused = true;
2815 EXPECT_EQ(kMode90, selector.getBestFrameRateMode(layers).modePtr);
2816 }
2817
TEST_P(RefreshRateSelectorTest,groupSwitchingNotAllowed)2818 TEST_P(RefreshRateSelectorTest, groupSwitchingNotAllowed) {
2819 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2820
2821 // The default policy doesn't allow group switching. Verify that no
2822 // group switches are performed.
2823 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2824 auto& layer = layers[0];
2825 layer.vote = LayerVoteType::ExplicitDefault;
2826 layer.desiredRefreshRate = 90_Hz;
2827 layer.seamlessness = Seamlessness::SeamedAndSeamless;
2828 layer.name = "90Hz ExplicitDefault";
2829 layer.focused = true;
2830
2831 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
2832 }
2833
TEST_P(RefreshRateSelectorTest,groupSwitchingWithOneLayer)2834 TEST_P(RefreshRateSelectorTest, groupSwitchingWithOneLayer) {
2835 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2836
2837 RefreshRateSelector::DisplayManagerPolicy policy;
2838 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
2839 policy.allowGroupSwitching = true;
2840 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
2841
2842 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2843 auto& layer = layers[0];
2844 layer.vote = LayerVoteType::ExplicitDefault;
2845 layer.desiredRefreshRate = 90_Hz;
2846 layer.seamlessness = Seamlessness::SeamedAndSeamless;
2847 layer.name = "90Hz ExplicitDefault";
2848 layer.focused = true;
2849 EXPECT_EQ(kModeId90, selector.getBestFrameRateMode(layers).modePtr->getId());
2850 }
2851
TEST_P(RefreshRateSelectorTest,groupSwitchingWithOneLayerOnlySeamless)2852 TEST_P(RefreshRateSelectorTest, groupSwitchingWithOneLayerOnlySeamless) {
2853 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2854
2855 RefreshRateSelector::DisplayManagerPolicy policy;
2856 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
2857 policy.allowGroupSwitching = true;
2858 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
2859
2860 // Verify that we won't change the group if seamless switch is required.
2861 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2862 auto& layer = layers[0];
2863 layer.vote = LayerVoteType::ExplicitDefault;
2864 layer.desiredRefreshRate = 90_Hz;
2865 layer.seamlessness = Seamlessness::OnlySeamless;
2866 layer.name = "90Hz ExplicitDefault";
2867 layer.focused = true;
2868 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
2869 }
2870
TEST_P(RefreshRateSelectorTest,groupSwitchingWithOneLayerOnlySeamlessDefaultFps)2871 TEST_P(RefreshRateSelectorTest, groupSwitchingWithOneLayerOnlySeamlessDefaultFps) {
2872 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2873
2874 RefreshRateSelector::DisplayManagerPolicy policy;
2875 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
2876 policy.allowGroupSwitching = true;
2877 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
2878
2879 selector.setActiveMode(kModeId90, 90_Hz);
2880
2881 // Verify that we won't do a seamless switch if we request the same mode as the default
2882 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2883 auto& layer = layers[0];
2884 layer.vote = LayerVoteType::ExplicitDefault;
2885 layer.desiredRefreshRate = 60_Hz;
2886 layer.seamlessness = Seamlessness::OnlySeamless;
2887 layer.name = "60Hz ExplicitDefault";
2888 layer.focused = true;
2889 EXPECT_EQ(kModeId90, selector.getBestFrameRateMode(layers).modePtr->getId());
2890 }
2891
TEST_P(RefreshRateSelectorTest,groupSwitchingWithOneLayerDefaultSeamlessness)2892 TEST_P(RefreshRateSelectorTest, groupSwitchingWithOneLayerDefaultSeamlessness) {
2893 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2894
2895 RefreshRateSelector::DisplayManagerPolicy policy;
2896 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
2897 policy.allowGroupSwitching = true;
2898 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
2899
2900 selector.setActiveMode(kModeId90, 90_Hz);
2901
2902 // Verify that if the active mode is in another group and there are no layers with
2903 // Seamlessness::SeamedAndSeamless, we should switch back to the default group.
2904
2905 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2906 auto& layer = layers[0];
2907 layer.vote = LayerVoteType::ExplicitDefault;
2908 layer.desiredRefreshRate = 60_Hz;
2909 layer.seamlessness = Seamlessness::Default;
2910 layer.name = "60Hz ExplicitDefault";
2911 layer.focused = true;
2912
2913 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
2914 }
2915
TEST_P(RefreshRateSelectorTest,groupSwitchingWithTwoLayersOnlySeamlessAndSeamed)2916 TEST_P(RefreshRateSelectorTest, groupSwitchingWithTwoLayersOnlySeamlessAndSeamed) {
2917 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2918
2919 RefreshRateSelector::DisplayManagerPolicy policy;
2920 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
2921 policy.allowGroupSwitching = true;
2922 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
2923
2924 selector.setActiveMode(kModeId90, 90_Hz);
2925
2926 // If there's a layer with Seamlessness::SeamedAndSeamless, another layer with
2927 // Seamlessness::OnlySeamless can't change the mode group.
2928 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2929 layers[0].vote = LayerVoteType::ExplicitDefault;
2930 layers[0].desiredRefreshRate = 60_Hz;
2931 layers[0].seamlessness = Seamlessness::OnlySeamless;
2932 layers[0].name = "60Hz ExplicitDefault";
2933 layers[0].focused = true;
2934
2935 layers.push_back(LayerRequirement{.weight = 0.5f});
2936 layers[1].vote = LayerVoteType::ExplicitDefault;
2937 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
2938 layers[1].desiredRefreshRate = 90_Hz;
2939 layers[1].name = "90Hz ExplicitDefault";
2940 layers[1].focused = false;
2941
2942 EXPECT_EQ(kModeId90, selector.getBestFrameRateMode(layers).modePtr->getId());
2943 }
2944
TEST_P(RefreshRateSelectorTest,groupSwitchingWithTwoLayersDefaultFocusedAndSeamed)2945 TEST_P(RefreshRateSelectorTest, groupSwitchingWithTwoLayersDefaultFocusedAndSeamed) {
2946 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2947
2948 RefreshRateSelector::DisplayManagerPolicy policy;
2949 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
2950 policy.allowGroupSwitching = true;
2951 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
2952
2953 selector.setActiveMode(kModeId90, 90_Hz);
2954
2955 // If there's a focused layer with Seamlessness::SeamedAndSeamless, another layer with
2956 // Seamlessness::Default can't change the mode group back to the group of the default
2957 // mode.
2958 // For example, this may happen when a video playback requests and gets a seamed switch,
2959 // but another layer (with default seamlessness) starts animating. The animating layer
2960 // should not cause a seamed switch.
2961 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2962 layers[0].seamlessness = Seamlessness::Default;
2963 layers[0].desiredRefreshRate = 60_Hz;
2964 layers[0].focused = true;
2965 layers[0].vote = LayerVoteType::ExplicitDefault;
2966 layers[0].name = "60Hz ExplicitDefault";
2967
2968 layers.push_back(LayerRequirement{.weight = 0.1f});
2969 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
2970 layers[1].desiredRefreshRate = 90_Hz;
2971 layers[1].focused = true;
2972 layers[1].vote = LayerVoteType::ExplicitDefault;
2973 layers[1].name = "90Hz ExplicitDefault";
2974
2975 EXPECT_EQ(kModeId90, selector.getBestFrameRateMode(layers).modePtr->getId());
2976 }
2977
TEST_P(RefreshRateSelectorTest,groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed)2978 TEST_P(RefreshRateSelectorTest, groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed) {
2979 auto selector = createSelector(kModes_60_90_G1, kModeId60);
2980
2981 RefreshRateSelector::DisplayManagerPolicy policy;
2982 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
2983 policy.allowGroupSwitching = true;
2984 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
2985
2986 selector.setActiveMode(kModeId90, 90_Hz);
2987
2988 // Layer with Seamlessness::Default can change the mode group if there's an
2989 // unfocused layer with Seamlessness::SeamedAndSeamless. For example, this happens
2990 // when in split screen mode the user switches between the two visible applications.
2991 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
2992 layers[0].seamlessness = Seamlessness::Default;
2993 layers[0].desiredRefreshRate = 60_Hz;
2994 layers[0].focused = true;
2995 layers[0].vote = LayerVoteType::ExplicitDefault;
2996 layers[0].name = "60Hz ExplicitDefault";
2997
2998 layers.push_back(LayerRequirement{.weight = 0.7f});
2999 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
3000 layers[1].desiredRefreshRate = 90_Hz;
3001 layers[1].focused = false;
3002 layers[1].vote = LayerVoteType::ExplicitDefault;
3003 layers[1].name = "90Hz ExplicitDefault";
3004
3005 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
3006 }
3007
TEST_P(RefreshRateSelectorTest,nonSeamlessVotePrefersSeamlessSwitches)3008 TEST_P(RefreshRateSelectorTest, nonSeamlessVotePrefersSeamlessSwitches) {
3009 auto selector = createSelector(kModes_30_60, kModeId60);
3010
3011 // Allow group switching.
3012 RefreshRateSelector::DisplayManagerPolicy policy;
3013 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
3014 policy.allowGroupSwitching = true;
3015 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
3016
3017 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3018 auto& layer = layers[0];
3019 layer.vote = LayerVoteType::ExplicitExactOrMultiple;
3020 layer.desiredRefreshRate = 60_Hz;
3021 layer.seamlessness = Seamlessness::SeamedAndSeamless;
3022 layer.name = "60Hz ExplicitExactOrMultiple";
3023 layer.focused = true;
3024
3025 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode(layers).modePtr->getId());
3026
3027 selector.setActiveMode(kModeId120, 120_Hz);
3028 EXPECT_EQ(kModeId120, selector.getBestFrameRateMode(layers).modePtr->getId());
3029 }
3030
TEST_P(RefreshRateSelectorTest,nonSeamlessExactAndSeamlessMultipleLayers)3031 TEST_P(RefreshRateSelectorTest, nonSeamlessExactAndSeamlessMultipleLayers) {
3032 auto selector = createSelector(kModes_25_30_50_60, kModeId60);
3033
3034 // Allow group switching.
3035 RefreshRateSelector::DisplayManagerPolicy policy;
3036 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
3037 policy.allowGroupSwitching = true;
3038 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
3039
3040 std::vector<LayerRequirement> layers = {{.name = "60Hz ExplicitDefault",
3041 .vote = LayerVoteType::ExplicitDefault,
3042 .desiredRefreshRate = 60_Hz,
3043 .seamlessness = Seamlessness::SeamedAndSeamless,
3044 .weight = 0.5f,
3045 .focused = false},
3046 {.name = "25Hz ExplicitExactOrMultiple",
3047 .vote = LayerVoteType::ExplicitExactOrMultiple,
3048 .desiredRefreshRate = 25_Hz,
3049 .seamlessness = Seamlessness::OnlySeamless,
3050 .weight = 1.f,
3051 .focused = true}};
3052
3053 EXPECT_EQ(kModeId50, selector.getBestFrameRateMode(layers).modePtr->getId());
3054
3055 auto& seamedLayer = layers[0];
3056 seamedLayer.desiredRefreshRate = 30_Hz;
3057 seamedLayer.name = "30Hz ExplicitDefault";
3058 selector.setActiveMode(kModeId30, 30_Hz);
3059
3060 EXPECT_EQ(kModeId25, selector.getBestFrameRateMode(layers).modePtr->getId());
3061 }
3062
TEST_P(RefreshRateSelectorTest,minLayersDontTrigerSeamedSwitch)3063 TEST_P(RefreshRateSelectorTest, minLayersDontTrigerSeamedSwitch) {
3064 auto selector = createSelector(kModes_60_90_G1, kModeId90);
3065
3066 // Allow group switching.
3067 RefreshRateSelector::DisplayManagerPolicy policy;
3068 policy.defaultMode = selector.getCurrentPolicy().defaultMode;
3069 policy.allowGroupSwitching = true;
3070 EXPECT_EQ(SetPolicyResult::Changed, selector.setPolicy(policy));
3071
3072 std::vector<LayerRequirement> layers = {
3073 {.name = "Min", .vote = LayerVoteType::Min, .weight = 1.f, .focused = true}};
3074
3075 EXPECT_EQ(kModeId90, selector.getBestFrameRateMode(layers).modePtr->getId());
3076 }
3077
TEST_P(RefreshRateSelectorTest,primaryVsAppRequestPolicy)3078 TEST_P(RefreshRateSelectorTest, primaryVsAppRequestPolicy) {
3079 auto selector = createSelector(kModes_30_60_90, kModeId60);
3080
3081 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3082 layers[0].name = "Test layer";
3083
3084 struct Args {
3085 bool touch = false;
3086 bool focused = true;
3087 };
3088
3089 // Returns the mode selected by getBestFrameRateMode for a single layer with the given
3090 // arguments.
3091 const auto getFrameRate = [&](LayerVoteType voteType, Fps fps,
3092 Args args = {}) -> DisplayModeId {
3093 layers[0].vote = voteType;
3094 layers[0].desiredRefreshRate = fps;
3095 layers[0].focused = args.focused;
3096 return selector.getBestFrameRateMode(layers, {.touch = args.touch}).modePtr->getId();
3097 };
3098
3099 constexpr FpsRange k30_60 = {30_Hz, 60_Hz};
3100 constexpr FpsRange k30_90 = {30_Hz, 90_Hz};
3101
3102 EXPECT_EQ(SetPolicyResult::Changed,
3103 selector.setDisplayManagerPolicy({kModeId60, {k30_60, k30_60}, {k30_90, k30_90}}));
3104
3105 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode().modePtr->getId());
3106 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
3107 EXPECT_EQ(kModeId30, getFrameRate(LayerVoteType::Min, 90_Hz));
3108 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
3109 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
3110 EXPECT_EQ(kModeId90, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
3111 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
3112
3113 // Unfocused layers are not allowed to override primary range.
3114 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.focused = false}));
3115 EXPECT_EQ(kModeId60,
3116 getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz, {.focused = false}));
3117
3118 // Touch boost should be restricted to the primary range.
3119 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz, {.touch = true}));
3120
3121 // When we're higher than the primary range max due to a layer frame rate setting, touch boost
3122 // shouldn't drag us back down to the primary range max.
3123 EXPECT_EQ(kModeId90, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz, {.touch = true}));
3124 EXPECT_EQ(kModeId60,
3125 getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz, {.touch = true}));
3126
3127 EXPECT_EQ(SetPolicyResult::Changed,
3128 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}));
3129
3130 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::NoVote, 90_Hz));
3131 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Min, 90_Hz));
3132 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Max, 90_Hz));
3133 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::Heuristic, 90_Hz));
3134 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitDefault, 90_Hz));
3135 EXPECT_EQ(kModeId60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90_Hz));
3136 }
3137
TEST_P(RefreshRateSelectorTest,idle)3138 TEST_P(RefreshRateSelectorTest, idle) {
3139 auto selector = createSelector(kModes_60_90, kModeId60);
3140
3141 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3142 layers[0].name = "Test layer";
3143
3144 const auto getIdleDisplayModeId = [&](LayerVoteType voteType,
3145 bool touchActive) -> DisplayModeId {
3146 layers[0].vote = voteType;
3147 layers[0].desiredRefreshRate = 90_Hz;
3148
3149 const auto [ranking, signals, _] =
3150 selector.getRankedFrameRates(layers, {.touch = touchActive, .idle = true});
3151
3152 // Refresh rate will be chosen by either touch state or idle state.
3153 EXPECT_EQ(!touchActive, signals.idle);
3154 return ranking.front().frameRateMode.modePtr->getId();
3155 };
3156
3157 EXPECT_EQ(SetPolicyResult::Changed,
3158 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}}));
3159
3160 // Idle should be lower priority than touch boost.
3161 {
3162 constexpr bool kTouchActive = true;
3163 EXPECT_EQ(kModeId90, getIdleDisplayModeId(LayerVoteType::NoVote, kTouchActive));
3164 EXPECT_EQ(kModeId90, getIdleDisplayModeId(LayerVoteType::Min, kTouchActive));
3165 EXPECT_EQ(kModeId90, getIdleDisplayModeId(LayerVoteType::Max, kTouchActive));
3166 EXPECT_EQ(kModeId90, getIdleDisplayModeId(LayerVoteType::Heuristic, kTouchActive));
3167 EXPECT_EQ(kModeId90, getIdleDisplayModeId(LayerVoteType::ExplicitDefault, kTouchActive));
3168 EXPECT_EQ(kModeId90,
3169 getIdleDisplayModeId(LayerVoteType::ExplicitExactOrMultiple, kTouchActive));
3170 }
3171
3172 // With no layers, idle should still be lower priority than touch boost.
3173 EXPECT_EQ(kModeId90,
3174 selector.getBestFrameRateMode({}, {.touch = true, .idle = true}).modePtr->getId());
3175
3176 // Idle should be higher precedence than other layer frame rate considerations.
3177 selector.setActiveMode(kModeId90, 90_Hz);
3178
3179 {
3180 constexpr bool kTouchActive = false;
3181 EXPECT_EQ(kModeId60, getIdleDisplayModeId(LayerVoteType::NoVote, kTouchActive));
3182 EXPECT_EQ(kModeId60, getIdleDisplayModeId(LayerVoteType::Min, kTouchActive));
3183 EXPECT_EQ(kModeId60, getIdleDisplayModeId(LayerVoteType::Max, kTouchActive));
3184 EXPECT_EQ(kModeId60, getIdleDisplayModeId(LayerVoteType::Heuristic, kTouchActive));
3185 EXPECT_EQ(kModeId60, getIdleDisplayModeId(LayerVoteType::ExplicitDefault, kTouchActive));
3186 EXPECT_EQ(kModeId60,
3187 getIdleDisplayModeId(LayerVoteType::ExplicitExactOrMultiple, kTouchActive));
3188 }
3189
3190 // Idle should be applied rather than the active mode when there are no layers.
3191 EXPECT_EQ(kModeId60, selector.getBestFrameRateMode({}, {.idle = true}).modePtr->getId());
3192 }
3193
TEST_P(RefreshRateSelectorTest,findClosestKnownFrameRate)3194 TEST_P(RefreshRateSelectorTest, findClosestKnownFrameRate) {
3195 auto selector = createSelector(kModes_60_90, kModeId60);
3196
3197 for (float fps = 1.0f; fps <= 120.0f; fps += 0.1f) {
3198 const auto knownFrameRate = selector.findClosestKnownFrameRate(Fps::fromValue(fps));
3199 const Fps expectedFrameRate = [fps] {
3200 if (fps < 26.91f) return 24_Hz;
3201 if (fps < 37.51f) return 30_Hz;
3202 if (fps < 52.51f) return 45_Hz;
3203 if (fps < 66.01f) return 60_Hz;
3204 if (fps < 81.01f) return 72_Hz;
3205 return 90_Hz;
3206 }();
3207
3208 EXPECT_EQ(expectedFrameRate, knownFrameRate);
3209 }
3210 }
3211
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_KnownFrameRate)3212 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_KnownFrameRate) {
3213 auto selector = createSelector(kModes_60_90, kModeId60);
3214
3215 struct Expectation {
3216 Fps fps;
3217 ftl::NonNull<DisplayModePtr> mode;
3218 };
3219
3220 const std::initializer_list<Expectation> knownFrameRatesExpectations = {
3221 {24_Hz, kMode60}, {30_Hz, kMode60}, {45_Hz, kMode90},
3222 {60_Hz, kMode60}, {72_Hz, kMode90}, {90_Hz, kMode90},
3223 };
3224
3225 // Make sure the test tests all the known frame rate
3226 const auto& knownFrameRates = selector.knownFrameRates();
3227 const bool equal = std::equal(knownFrameRates.begin(), knownFrameRates.end(),
3228 knownFrameRatesExpectations.begin(),
3229 [](Fps fps, const Expectation& expected) {
3230 return isApproxEqual(fps, expected.fps);
3231 });
3232 EXPECT_TRUE(equal);
3233
3234 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3235 auto& layer = layers[0];
3236 layer.vote = LayerVoteType::Heuristic;
3237
3238 for (const auto& [fps, mode] : knownFrameRatesExpectations) {
3239 layer.desiredRefreshRate = fps;
3240 EXPECT_EQ(mode, selector.getBestFrameRateMode(layers).modePtr);
3241 }
3242 }
3243
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_ExplicitExact)3244 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_ExplicitExact) {
3245 auto selector = createSelector(kModes_30_60_72_90_120, kModeId60);
3246
3247 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
3248 auto& explicitExactLayer = layers[0];
3249 auto& explicitExactOrMultipleLayer = layers[1];
3250
3251 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
3252 explicitExactLayer.name = "ExplicitExact";
3253 explicitExactLayer.desiredRefreshRate = 30_Hz;
3254
3255 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
3256 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
3257 explicitExactOrMultipleLayer.desiredRefreshRate = 60_Hz;
3258
3259 if (GetParam() == Config::FrameRateOverride::Disabled) {
3260 EXPECT_FRAME_RATE_MODE(kMode30, 30_Hz,
3261 selector.getBestScoredFrameRate(layers).frameRateMode);
3262 EXPECT_FRAME_RATE_MODE(kMode30, 30_Hz,
3263 selector.getBestScoredFrameRate(layers, {.touch = true})
3264 .frameRateMode);
3265
3266 } else {
3267 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz,
3268 selector.getBestScoredFrameRate(layers).frameRateMode);
3269 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz,
3270 selector.getBestScoredFrameRate(layers, {.touch = true})
3271 .frameRateMode);
3272 }
3273
3274 explicitExactOrMultipleLayer.desiredRefreshRate = 120_Hz;
3275 explicitExactLayer.desiredRefreshRate = 60_Hz;
3276
3277 if (GetParam() == Config::FrameRateOverride::Disabled) {
3278 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz,
3279 selector.getBestScoredFrameRate(layers).frameRateMode);
3280 } else {
3281 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz,
3282 selector.getBestScoredFrameRate(layers).frameRateMode);
3283 }
3284
3285 explicitExactLayer.desiredRefreshRate = 72_Hz;
3286 EXPECT_FRAME_RATE_MODE(kMode72, 72_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3287
3288 explicitExactLayer.desiredRefreshRate = 90_Hz;
3289 EXPECT_FRAME_RATE_MODE(kMode90, 90_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3290
3291 explicitExactLayer.desiredRefreshRate = 120_Hz;
3292 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3293 }
3294
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_ReadsCache)3295 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_ReadsCache) {
3296 auto selector = createSelector(kModes_30_60_72_90_120, kModeId60);
3297
3298 using GlobalSignals = RefreshRateSelector::GlobalSignals;
3299 const RefreshRateSelector::RankedFrameRates result = {{RefreshRateSelector::ScoredFrameRate{
3300 {90_Hz, kMode90}}},
3301 GlobalSignals{.touch = true}};
3302
3303 selector.mutableGetRankedRefreshRatesCache() = {.layers = std::vector<LayerRequirement>{},
3304 .signals = GlobalSignals{.touch = true,
3305 .idle = true},
3306 .result = result};
3307
3308 const auto& cache = *selector.mutableGetRankedRefreshRatesCache();
3309 EXPECT_EQ(result, selector.getRankedFrameRates(cache.layers, cache.signals));
3310 }
3311
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_WritesCache)3312 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_WritesCache) {
3313 auto selector = createSelector(kModes_30_60_72_90_120, kModeId60);
3314
3315 EXPECT_FALSE(selector.mutableGetRankedRefreshRatesCache());
3316
3317 const std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
3318 const RefreshRateSelector::GlobalSignals globalSignals{.touch = true, .idle = true};
3319 const Fps pacesetterFps = 60_Hz;
3320
3321 const auto result = selector.getRankedFrameRates(layers, globalSignals, pacesetterFps);
3322
3323 const auto& cache = selector.mutableGetRankedRefreshRatesCache();
3324 ASSERT_TRUE(cache);
3325
3326 EXPECT_EQ(cache->layers, layers);
3327 EXPECT_EQ(cache->signals, globalSignals);
3328 EXPECT_EQ(cache->pacesetterFps, pacesetterFps);
3329 EXPECT_EQ(cache->result, result);
3330 }
3331
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_ExplicitExactTouchBoost)3332 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_ExplicitExactTouchBoost) {
3333 auto selector = createSelector(kModes_60_120, kModeId60);
3334
3335 std::vector<LayerRequirement> layers = {{.weight = 1.f}, {.weight = 0.5f}};
3336 auto& explicitExactLayer = layers[0];
3337 auto& explicitExactOrMultipleLayer = layers[1];
3338
3339 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
3340 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
3341 explicitExactOrMultipleLayer.desiredRefreshRate = 60_Hz;
3342
3343 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
3344 explicitExactLayer.name = "ExplicitExact";
3345 explicitExactLayer.desiredRefreshRate = 30_Hz;
3346
3347 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
3348 if (GetParam() == Config::FrameRateOverride::Disabled) {
3349 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
3350 } else {
3351 EXPECT_EQ(kMode120, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
3352 }
3353
3354 explicitExactOrMultipleLayer.vote = LayerVoteType::NoVote;
3355
3356 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
3357 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers, {.touch = true}).modePtr);
3358 }
3359
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_FractionalRefreshRates_ExactAndDefault)3360 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_FractionalRefreshRates_ExactAndDefault) {
3361 auto selector = createSelector(kModes_24_25_30_50_60_Frac, kModeId60);
3362
3363 std::vector<LayerRequirement> layers = {{.weight = 0.5f}, {.weight = 0.5f}};
3364 auto& explicitDefaultLayer = layers[0];
3365 auto& explicitExactOrMultipleLayer = layers[1];
3366
3367 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
3368 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
3369 explicitExactOrMultipleLayer.desiredRefreshRate = 60_Hz;
3370
3371 explicitDefaultLayer.vote = LayerVoteType::ExplicitDefault;
3372 explicitDefaultLayer.name = "ExplicitDefault";
3373 explicitDefaultLayer.desiredRefreshRate = 59.94_Hz;
3374
3375 EXPECT_EQ(kMode60, selector.getBestFrameRateMode(layers).modePtr);
3376 }
3377
3378 // b/190578904
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_withCloseRefreshRates)3379 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_withCloseRefreshRates) {
3380 if (g_noSlowTests) {
3381 GTEST_SKIP();
3382 }
3383
3384 const int kMinRefreshRate = RefreshRateSelector::kMinSupportedFrameRate.getIntValue();
3385 constexpr int kMaxRefreshRate = 240;
3386
3387 DisplayModes displayModes;
3388 for (int fps = kMinRefreshRate; fps < kMaxRefreshRate; fps++) {
3389 const DisplayModeId modeId(fps);
3390 displayModes.try_emplace(modeId,
3391 createDisplayMode(modeId,
3392 Fps::fromValue(static_cast<float>(fps))));
3393 }
3394
3395 const auto selector = createSelector(std::move(displayModes), DisplayModeId(kMinRefreshRate));
3396
3397 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3398 const auto testRefreshRate = [&](Fps fps, LayerVoteType vote) {
3399 layers[0].desiredRefreshRate = fps;
3400 layers[0].vote = vote;
3401 EXPECT_EQ(fps.getIntValue(),
3402 selector.getBestFrameRateMode(layers).modePtr->getPeakFps().getIntValue())
3403 << "Failed for " << ftl::enum_string(vote);
3404 };
3405
3406 for (int fps = kMinRefreshRate; fps < kMaxRefreshRate; fps++) {
3407 const auto refreshRate = Fps::fromValue(static_cast<float>(fps));
3408 testRefreshRate(refreshRate, LayerVoteType::Heuristic);
3409 testRefreshRate(refreshRate, LayerVoteType::ExplicitDefault);
3410 testRefreshRate(refreshRate, LayerVoteType::ExplicitExactOrMultiple);
3411 testRefreshRate(refreshRate, LayerVoteType::ExplicitExact);
3412 }
3413 }
3414
3415 // b/190578904
TEST_P(RefreshRateSelectorTest,getBestFrameRateMode_conflictingVotes)3416 TEST_P(RefreshRateSelectorTest, getBestFrameRateMode_conflictingVotes) {
3417 constexpr DisplayModeId kActiveModeId{0};
3418 DisplayModes displayModes = makeModes(createDisplayMode(kActiveModeId, 43_Hz),
3419 createDisplayMode(DisplayModeId(1), 53_Hz),
3420 createDisplayMode(DisplayModeId(2), 55_Hz),
3421 createDisplayMode(DisplayModeId(3), 60_Hz));
3422
3423 const RefreshRateSelector::GlobalSignals globalSignals = {.touch = false, .idle = false};
3424 const auto selector = createSelector(std::move(displayModes), kActiveModeId);
3425
3426 const std::vector<LayerRequirement> layers = {
3427 {
3428 .vote = LayerVoteType::ExplicitDefault,
3429 .desiredRefreshRate = 43_Hz,
3430 .seamlessness = Seamlessness::SeamedAndSeamless,
3431 .weight = 0.41f,
3432 },
3433 {
3434 .vote = LayerVoteType::ExplicitExactOrMultiple,
3435 .desiredRefreshRate = 53_Hz,
3436 .seamlessness = Seamlessness::SeamedAndSeamless,
3437 .weight = 0.41f,
3438 },
3439 };
3440
3441 EXPECT_EQ(53_Hz, selector.getBestFrameRateMode(layers, globalSignals).modePtr->getPeakFps());
3442 }
3443
TEST_P(RefreshRateSelectorTest,modeComparison)3444 TEST_P(RefreshRateSelectorTest, modeComparison) {
3445 EXPECT_LT(kMode60->getPeakFps(), kMode90->getPeakFps());
3446 EXPECT_GE(kMode60->getPeakFps(), kMode60->getPeakFps());
3447 EXPECT_GE(kMode90->getPeakFps(), kMode90->getPeakFps());
3448 }
3449
TEST_P(RefreshRateSelectorTest,testKernelIdleTimerAction)3450 TEST_P(RefreshRateSelectorTest, testKernelIdleTimerAction) {
3451 using KernelIdleTimerAction = RefreshRateSelector::KernelIdleTimerAction;
3452
3453 auto selector = createSelector(kModes_60_90, kModeId90);
3454
3455 EXPECT_EQ(KernelIdleTimerAction::TurnOn, selector.getIdleTimerAction());
3456
3457 EXPECT_EQ(SetPolicyResult::Changed,
3458 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 90_Hz}}));
3459 EXPECT_EQ(KernelIdleTimerAction::TurnOn, selector.getIdleTimerAction());
3460
3461 EXPECT_EQ(SetPolicyResult::Changed,
3462 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}));
3463 EXPECT_EQ(KernelIdleTimerAction::TurnOff, selector.getIdleTimerAction());
3464
3465 EXPECT_EQ(SetPolicyResult::Changed,
3466 selector.setDisplayManagerPolicy({kModeId90, {90_Hz, 90_Hz}}));
3467 EXPECT_EQ(KernelIdleTimerAction::TurnOff, selector.getIdleTimerAction());
3468 }
3469
TEST_P(RefreshRateSelectorTest,testKernelIdleTimerActionFor120Hz)3470 TEST_P(RefreshRateSelectorTest, testKernelIdleTimerActionFor120Hz) {
3471 using KernelIdleTimerAction = RefreshRateSelector::KernelIdleTimerAction;
3472
3473 auto selector = createSelector(kModes_60_120, kModeId120);
3474
3475 EXPECT_EQ(SetPolicyResult::Changed,
3476 selector.setDisplayManagerPolicy({kModeId60, {0_Hz, 60_Hz}}));
3477 EXPECT_EQ(KernelIdleTimerAction::TurnOn, selector.getIdleTimerAction());
3478
3479 EXPECT_EQ(SetPolicyResult::Changed,
3480 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 60_Hz}}));
3481 EXPECT_EQ(KernelIdleTimerAction::TurnOff, selector.getIdleTimerAction());
3482
3483 EXPECT_EQ(SetPolicyResult::Changed,
3484 selector.setDisplayManagerPolicy({kModeId60, {60_Hz, 120_Hz}}));
3485 EXPECT_EQ(KernelIdleTimerAction::TurnOn, selector.getIdleTimerAction());
3486
3487 EXPECT_EQ(SetPolicyResult::Changed,
3488 selector.setDisplayManagerPolicy({kModeId120, {120_Hz, 120_Hz}}));
3489 EXPECT_EQ(KernelIdleTimerAction::TurnOff, selector.getIdleTimerAction());
3490 }
3491
TEST_P(RefreshRateSelectorTest,getFrameRateDivisor)3492 TEST_P(RefreshRateSelectorTest, getFrameRateDivisor) {
3493 auto selector = createSelector(kModes_30_60_72_90_120, kModeId30);
3494
3495 const auto frameRate = 30_Hz;
3496 Fps displayRefreshRate = selector.getActiveMode().getPeakFps();
3497 EXPECT_EQ(1, RefreshRateSelector::getFrameRateDivisor(displayRefreshRate, frameRate));
3498
3499 selector.setActiveMode(kModeId60, 60_Hz);
3500 displayRefreshRate = selector.getActiveMode().getPeakFps();
3501 EXPECT_EQ(2, RefreshRateSelector::getFrameRateDivisor(displayRefreshRate, frameRate));
3502
3503 selector.setActiveMode(kModeId72, 72_Hz);
3504 displayRefreshRate = selector.getActiveMode().getPeakFps();
3505 EXPECT_EQ(0, RefreshRateSelector::getFrameRateDivisor(displayRefreshRate, frameRate));
3506
3507 selector.setActiveMode(kModeId90, 90_Hz);
3508 displayRefreshRate = selector.getActiveMode().getPeakFps();
3509 EXPECT_EQ(3, RefreshRateSelector::getFrameRateDivisor(displayRefreshRate, frameRate));
3510
3511 selector.setActiveMode(kModeId120, 120_Hz);
3512 displayRefreshRate = selector.getActiveMode().getPeakFps();
3513 EXPECT_EQ(4, RefreshRateSelector::getFrameRateDivisor(displayRefreshRate, frameRate));
3514
3515 selector.setActiveMode(kModeId90, 90_Hz);
3516 displayRefreshRate = selector.getActiveMode().getPeakFps();
3517 EXPECT_EQ(4, RefreshRateSelector::getFrameRateDivisor(displayRefreshRate, 22.5_Hz));
3518
3519 EXPECT_EQ(0, RefreshRateSelector::getFrameRateDivisor(24_Hz, 25_Hz));
3520 EXPECT_EQ(0, RefreshRateSelector::getFrameRateDivisor(24_Hz, 23.976_Hz));
3521 EXPECT_EQ(0, RefreshRateSelector::getFrameRateDivisor(30_Hz, 29.97_Hz));
3522 EXPECT_EQ(0, RefreshRateSelector::getFrameRateDivisor(60_Hz, 59.94_Hz));
3523 }
3524
TEST_P(RefreshRateSelectorTest,isFractionalPairOrMultiple)3525 TEST_P(RefreshRateSelectorTest, isFractionalPairOrMultiple) {
3526 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(23.976_Hz, 24_Hz));
3527 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(24_Hz, 23.976_Hz));
3528
3529 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(29.97_Hz, 30_Hz));
3530 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(30_Hz, 29.97_Hz));
3531
3532 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(59.94_Hz, 60_Hz));
3533 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(60_Hz, 59.94_Hz));
3534
3535 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(29.97_Hz, 60_Hz));
3536 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(60_Hz, 29.97_Hz));
3537
3538 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(59.94_Hz, 30_Hz));
3539 EXPECT_TRUE(RefreshRateSelector::isFractionalPairOrMultiple(30_Hz, 59.94_Hz));
3540
3541 const auto refreshRates = {23.976_Hz, 24_Hz, 25_Hz, 29.97_Hz, 30_Hz, 50_Hz, 59.94_Hz, 60_Hz};
3542 for (auto refreshRate : refreshRates) {
3543 EXPECT_FALSE(RefreshRateSelector::isFractionalPairOrMultiple(refreshRate, refreshRate));
3544 }
3545
3546 EXPECT_FALSE(RefreshRateSelector::isFractionalPairOrMultiple(24_Hz, 25_Hz));
3547 EXPECT_FALSE(RefreshRateSelector::isFractionalPairOrMultiple(23.978_Hz, 25_Hz));
3548 EXPECT_FALSE(RefreshRateSelector::isFractionalPairOrMultiple(29.97_Hz, 59.94_Hz));
3549 }
3550
TEST_P(RefreshRateSelectorTest,test23976Chooses120)3551 TEST_P(RefreshRateSelectorTest, test23976Chooses120) {
3552 auto selector = createSelector(kModes_60_90_120, kModeId120);
3553 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3554 layers[0].name = "23.976 ExplicitExactOrMultiple";
3555 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3556 layers[0].desiredRefreshRate = 23.976_Hz;
3557 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3558 }
3559
TEST_P(RefreshRateSelectorTest,test23976Chooses60IfThresholdIs120)3560 TEST_P(RefreshRateSelectorTest, test23976Chooses60IfThresholdIs120) {
3561 auto selector =
3562 createSelector(kModes_60_90_120, kModeId120, {.frameRateMultipleThreshold = 120});
3563 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3564 layers[0].name = "23.976 ExplicitExactOrMultiple";
3565 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3566 layers[0].desiredRefreshRate = 23.976_Hz;
3567 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3568 }
3569
TEST_P(RefreshRateSelectorTest,test25Chooses60)3570 TEST_P(RefreshRateSelectorTest, test25Chooses60) {
3571 auto selector = createSelector(kModes_60_90_120, kModeId120);
3572 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3573 layers[0].name = "25 ExplicitExactOrMultiple";
3574 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3575 layers[0].desiredRefreshRate = 25.00_Hz;
3576 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3577 }
3578
TEST_P(RefreshRateSelectorTest,test2997Chooses60)3579 TEST_P(RefreshRateSelectorTest, test2997Chooses60) {
3580 auto selector = createSelector(kModes_60_90_120, kModeId120);
3581 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3582 layers[0].name = "29.97 ExplicitExactOrMultiple";
3583 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3584 layers[0].desiredRefreshRate = 29.97_Hz;
3585 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3586 }
3587
TEST_P(RefreshRateSelectorTest,test50Chooses120)3588 TEST_P(RefreshRateSelectorTest, test50Chooses120) {
3589 auto selector = createSelector(kModes_60_90_120, kModeId120);
3590 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3591 layers[0].name = "50 ExplicitExactOrMultiple";
3592 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3593 layers[0].desiredRefreshRate = 50.00_Hz;
3594 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3595 }
3596
TEST_P(RefreshRateSelectorTest,test50Chooses60IfThresholdIs120)3597 TEST_P(RefreshRateSelectorTest, test50Chooses60IfThresholdIs120) {
3598 auto selector =
3599 createSelector(kModes_60_90_120, kModeId120, {.frameRateMultipleThreshold = 120});
3600 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3601 layers[0].name = "50 ExplicitExactOrMultiple";
3602 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3603 layers[0].desiredRefreshRate = 50.00_Hz;
3604 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3605 }
3606
TEST_P(RefreshRateSelectorTest,test5994Chooses60)3607 TEST_P(RefreshRateSelectorTest, test5994Chooses60) {
3608 auto selector = createSelector(kModes_60_90_120, kModeId120);
3609 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3610 layers[0].name = "59.94 ExplicitExactOrMultiple";
3611 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3612 layers[0].desiredRefreshRate = 59.94_Hz;
3613 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
3614 }
3615
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_noLayers)3616 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_noLayers) {
3617 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
3618
3619 EXPECT_TRUE(selector.getFrameRateOverrides({}, 120_Hz, {}).empty());
3620 }
3621
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_NonExplicit)3622 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_NonExplicit) {
3623 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
3624
3625 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3626 layers[0].name = "Test layer";
3627 layers[0].ownerUid = 1234;
3628 layers[0].desiredRefreshRate = 60_Hz;
3629
3630 layers[0].vote = LayerVoteType::NoVote;
3631 EXPECT_TRUE(selector.getFrameRateOverrides(layers, 120_Hz, {}).empty());
3632
3633 layers[0].vote = LayerVoteType::Min;
3634 EXPECT_TRUE(selector.getFrameRateOverrides(layers, 120_Hz, {}).empty());
3635
3636 layers[0].vote = LayerVoteType::Max;
3637 EXPECT_TRUE(selector.getFrameRateOverrides(layers, 120_Hz, {}).empty());
3638
3639 layers[0].vote = LayerVoteType::Heuristic;
3640 EXPECT_TRUE(selector.getFrameRateOverrides(layers, 120_Hz, {}).empty());
3641 }
3642
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_Disabled)3643 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_Disabled) {
3644 if (GetParam() != Config::FrameRateOverride::Disabled) {
3645 return;
3646 }
3647
3648 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
3649
3650 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3651 layers[0].name = "Test layer";
3652 layers[0].ownerUid = 1234;
3653 layers[0].desiredRefreshRate = 60_Hz;
3654
3655 layers[0].vote = LayerVoteType::ExplicitDefault;
3656 EXPECT_TRUE(selector.getFrameRateOverrides(layers, 120_Hz, {}).empty());
3657
3658 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3659 EXPECT_TRUE(selector.getFrameRateOverrides(layers, 120_Hz, {}).empty());
3660
3661 layers[0].vote = LayerVoteType::ExplicitExact;
3662 EXPECT_TRUE(selector.getFrameRateOverrides(layers, 120_Hz, {}).empty());
3663 }
3664
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_60on120)3665 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_60on120) {
3666 if (GetParam() == Config::FrameRateOverride::Disabled) {
3667 return;
3668 }
3669
3670 ASSERT_TRUE(GetParam() == Config::FrameRateOverride::AppOverrideNativeRefreshRates ||
3671 GetParam() == Config::FrameRateOverride::AppOverride ||
3672 GetParam() == Config::FrameRateOverride::Enabled);
3673
3674 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
3675
3676 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
3677 layers[0].name = "Test layer";
3678 layers[0].ownerUid = 1234;
3679 layers[0].desiredRefreshRate = 60_Hz;
3680
3681 layers[0].vote = LayerVoteType::ExplicitDefault;
3682 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3683 EXPECT_EQ(1u, frameRateOverrides.size());
3684 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3685 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3686
3687 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
3688 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3689 EXPECT_EQ(1u, frameRateOverrides.size());
3690 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3691 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3692
3693 layers[0].vote = LayerVoteType::ExplicitExact;
3694 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3695 EXPECT_EQ(1u, frameRateOverrides.size());
3696 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3697 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3698 }
3699
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_twoUids)3700 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_twoUids) {
3701 if (GetParam() == Config::FrameRateOverride::Disabled) {
3702 return;
3703 }
3704
3705 ASSERT_TRUE(GetParam() == Config::FrameRateOverride::AppOverrideNativeRefreshRates ||
3706 GetParam() == Config::FrameRateOverride::AppOverride ||
3707 GetParam() == Config::FrameRateOverride::Enabled);
3708
3709 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
3710
3711 std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f},
3712 {.ownerUid = 5678, .weight = 1.f}};
3713
3714 layers[0].name = "Test layer 1234";
3715 layers[0].desiredRefreshRate = 60_Hz;
3716 layers[0].vote = LayerVoteType::ExplicitDefault;
3717
3718 layers[1].name = "Test layer 5678";
3719 layers[1].desiredRefreshRate = 30_Hz;
3720 layers[1].vote = LayerVoteType::ExplicitDefault;
3721 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3722
3723 EXPECT_EQ(2u, frameRateOverrides.size());
3724 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3725 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3726 ASSERT_EQ(1u, frameRateOverrides.count(5678));
3727 EXPECT_EQ(30_Hz, frameRateOverrides.at(5678));
3728
3729 layers[1].vote = LayerVoteType::Heuristic;
3730 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3731 EXPECT_EQ(1u, frameRateOverrides.size());
3732 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3733 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3734
3735 layers[1].ownerUid = 1234;
3736 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3737 EXPECT_TRUE(frameRateOverrides.empty());
3738 }
3739
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_twoUids_arr)3740 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_twoUids_arr) {
3741 if (GetParam() != Config::FrameRateOverride::Enabled) {
3742 return;
3743 }
3744
3745 SET_FLAG_FOR_TEST(flags::vrr_config, true);
3746 // Device with VRR config mode
3747 auto selector = createSelector(kVrrMode_120, kModeId120);
3748
3749 std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f},
3750 {.ownerUid = 5678, .weight = 1.f}};
3751 auto& lr1 = layers[0];
3752 auto& lr2 = layers[1];
3753
3754 lr1.vote = LayerVoteType::ExplicitCategory;
3755 lr1.frameRateCategory = FrameRateCategory::Normal;
3756 lr1.name = "ExplicitCategory Normal";
3757 lr2.vote = LayerVoteType::ExplicitDefault;
3758 lr2.desiredRefreshRate = 30_Hz;
3759 lr2.name = "30Hz ExplicitDefault";
3760 // No global touch boost, for example a game that uses setFrameRate(30, default compatibility).
3761 // The `displayFrameRate` is 60.
3762 // However 30 Default app still gets frame rate override.
3763 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 60_Hz, {});
3764 EXPECT_EQ(2u, frameRateOverrides.size());
3765 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3766 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3767 ASSERT_EQ(1u, frameRateOverrides.count(5678));
3768 EXPECT_EQ(30_Hz, frameRateOverrides.at(5678));
3769
3770 lr1.vote = LayerVoteType::ExplicitCategory;
3771 lr1.frameRateCategory = FrameRateCategory::HighHint;
3772 lr1.name = "ExplicitCategory HighHint";
3773 lr2.vote = LayerVoteType::ExplicitDefault;
3774 lr2.desiredRefreshRate = 30_Hz;
3775 lr2.name = "30Hz ExplicitDefault";
3776 // Gets touch boost because the touched (HighHint) app is different from the 30 Default app.
3777 // The `displayFrameRate` is 120 (late touch boost).
3778 // However 30 Default app still gets frame rate override.
3779 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3780 EXPECT_EQ(1u, frameRateOverrides.size());
3781 ASSERT_EQ(1u, frameRateOverrides.count(5678));
3782 EXPECT_EQ(30_Hz, frameRateOverrides.at(5678));
3783 }
3784
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_withFrameRateCategory)3785 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_withFrameRateCategory) {
3786 if (GetParam() == Config::FrameRateOverride::Disabled) {
3787 return;
3788 }
3789
3790 ASSERT_TRUE(GetParam() == Config::FrameRateOverride::AppOverrideNativeRefreshRates ||
3791 GetParam() == Config::FrameRateOverride::AppOverride ||
3792 GetParam() == Config::FrameRateOverride::Enabled);
3793
3794 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
3795
3796 std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f},
3797 {.ownerUid = 1234, .weight = 1.f}};
3798
3799 // HighHint case with touch boost and thus should skip frame rate override.
3800 layers[0].name = "ExplicitCategory HighHint";
3801 layers[0].vote = LayerVoteType::ExplicitCategory;
3802 layers[0].desiredRefreshRate = 0_Hz;
3803 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3804 layers[1].name = "ExplicitCategory High";
3805 layers[1].vote = LayerVoteType::ExplicitCategory;
3806 layers[1].desiredRefreshRate = 0_Hz;
3807 layers[1].frameRateCategory = FrameRateCategory::High;
3808 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3809 EXPECT_TRUE(frameRateOverrides.empty());
3810 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3811 EXPECT_TRUE(frameRateOverrides.empty());
3812
3813 // HighHint case with touch boost and thus should skip frame rate override.
3814 layers[0].name = "ExplicitCategory HighHint";
3815 layers[0].vote = LayerVoteType::ExplicitCategory;
3816 layers[0].desiredRefreshRate = 0_Hz;
3817 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3818 layers[1].name = "ExplicitCategory Normal";
3819 layers[1].vote = LayerVoteType::ExplicitCategory;
3820 layers[1].desiredRefreshRate = 0_Hz;
3821 layers[1].frameRateCategory = FrameRateCategory::Normal;
3822 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3823 EXPECT_TRUE(frameRateOverrides.empty());
3824 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3825 EXPECT_TRUE(frameRateOverrides.empty());
3826
3827 // HighHint case with touch boost and thus should skip frame rate override.
3828 layers[0].name = "ExplicitCategory HighHint";
3829 layers[0].vote = LayerVoteType::ExplicitCategory;
3830 layers[0].desiredRefreshRate = 0_Hz;
3831 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3832 layers[1].name = "ExplicitCategory Low";
3833 layers[1].vote = LayerVoteType::ExplicitCategory;
3834 layers[1].desiredRefreshRate = 0_Hz;
3835 layers[1].frameRateCategory = FrameRateCategory::Low;
3836 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3837 EXPECT_TRUE(frameRateOverrides.empty());
3838 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3839 EXPECT_TRUE(frameRateOverrides.empty());
3840
3841 // HighHint case with touch boost and thus should skip frame rate override.
3842 layers[0].name = "ExplicitCategory HighHint";
3843 layers[0].vote = LayerVoteType::ExplicitCategory;
3844 layers[0].desiredRefreshRate = 0_Hz;
3845 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3846 layers[1].name = "ExplicitCategory NoPreference";
3847 layers[1].vote = LayerVoteType::ExplicitCategory;
3848 layers[1].desiredRefreshRate = 0_Hz;
3849 layers[1].frameRateCategory = FrameRateCategory::NoPreference;
3850 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3851 EXPECT_TRUE(frameRateOverrides.empty());
3852 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3853 EXPECT_TRUE(frameRateOverrides.empty());
3854
3855 // HighHint case *without* touch boost has frame rate override.
3856 // For example, game and touch interaction.
3857 layers[0].name = "ExplicitCategory HighHint";
3858 layers[0].vote = LayerVoteType::ExplicitCategory;
3859 layers[0].desiredRefreshRate = 0_Hz;
3860 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3861 layers[1].name = "ExplicitDefault 60";
3862 layers[1].vote = LayerVoteType::ExplicitDefault;
3863 layers[1].desiredRefreshRate = 60_Hz;
3864 layers[1].frameRateCategory = FrameRateCategory::Default;
3865 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3866 EXPECT_EQ(1u, frameRateOverrides.size());
3867 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3868 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3869 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3870 EXPECT_EQ(1u, frameRateOverrides.size());
3871 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3872 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3873
3874 // HighHint case with touch boost and thus should skip frame rate override.
3875 layers[0].name = "ExplicitCategory HighHint";
3876 layers[0].vote = LayerVoteType::ExplicitCategory;
3877 layers[0].desiredRefreshRate = 0_Hz;
3878 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3879 layers[1].name = "ExplicitExactOrMultiple 30";
3880 layers[1].vote = LayerVoteType::ExplicitExactOrMultiple;
3881 layers[1].desiredRefreshRate = 30_Hz;
3882 layers[1].frameRateCategory = FrameRateCategory::Default;
3883 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3884 EXPECT_TRUE(frameRateOverrides.empty());
3885 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3886 EXPECT_TRUE(frameRateOverrides.empty());
3887
3888 // HighHint case with touch boost and thus should skip frame rate override.
3889 layers[0].name = "ExplicitCategory HighHint";
3890 layers[0].vote = LayerVoteType::ExplicitCategory;
3891 layers[0].desiredRefreshRate = 0_Hz;
3892 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3893 layers[1].name = "ExplicitExact 60";
3894 layers[1].vote = LayerVoteType::ExplicitExact;
3895 layers[1].desiredRefreshRate = 60_Hz;
3896 layers[1].frameRateCategory = FrameRateCategory::Default;
3897 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3898 EXPECT_TRUE(frameRateOverrides.empty());
3899 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3900 EXPECT_TRUE(frameRateOverrides.empty());
3901
3902 // HighHint case with touch boost and thus should skip frame rate override.
3903 layers[0].name = "ExplicitCategory HighHint";
3904 layers[0].vote = LayerVoteType::ExplicitCategory;
3905 layers[0].desiredRefreshRate = 0_Hz;
3906 layers[0].frameRateCategory = FrameRateCategory::HighHint;
3907 layers[1].name = "ExplicitGte 60";
3908 layers[1].vote = LayerVoteType::ExplicitGte;
3909 layers[1].desiredRefreshRate = 60_Hz;
3910 layers[1].frameRateCategory = FrameRateCategory::Default;
3911 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3912 EXPECT_TRUE(frameRateOverrides.empty());
3913 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3914 EXPECT_TRUE(frameRateOverrides.empty());
3915
3916 // ExplicitCategory case that expects no global touch boost and thus has frame rate override.
3917 layers[0].name = "ExplicitDefault 60";
3918 layers[0].vote = LayerVoteType::ExplicitDefault;
3919 layers[0].desiredRefreshRate = 60_Hz;
3920 layers[0].frameRateCategory = FrameRateCategory::Default;
3921 layers[1].name = "ExplicitCategory High";
3922 layers[1].vote = LayerVoteType::ExplicitCategory;
3923 layers[1].desiredRefreshRate = 0_Hz;
3924 layers[1].frameRateCategory = FrameRateCategory::High;
3925 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3926 EXPECT_EQ(1u, frameRateOverrides.size());
3927 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3928 EXPECT_EQ(120_Hz, frameRateOverrides.at(1234));
3929 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3930 EXPECT_EQ(1u, frameRateOverrides.size());
3931 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3932 EXPECT_EQ(120_Hz, frameRateOverrides.at(1234));
3933
3934 // ExplicitCategory case that expects no global touch boost and thus has frame rate override.
3935 layers[0].name = "ExplicitDefault 60";
3936 layers[0].vote = LayerVoteType::ExplicitDefault;
3937 layers[0].desiredRefreshRate = 60_Hz;
3938 layers[0].frameRateCategory = FrameRateCategory::Default;
3939 layers[1].name = "ExplicitCategory Normal";
3940 layers[1].vote = LayerVoteType::ExplicitCategory;
3941 layers[1].desiredRefreshRate = 0_Hz;
3942 layers[1].frameRateCategory = FrameRateCategory::Normal;
3943 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3944 EXPECT_EQ(1u, frameRateOverrides.size());
3945 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3946 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3947 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3948 EXPECT_EQ(1u, frameRateOverrides.size());
3949 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3950 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3951
3952 // ExplicitCategory case that expects no global touch boost and thus has frame rate override.
3953 layers[0].name = "ExplicitDefault 60";
3954 layers[0].vote = LayerVoteType::ExplicitDefault;
3955 layers[0].desiredRefreshRate = 60_Hz;
3956 layers[0].frameRateCategory = FrameRateCategory::Default;
3957 layers[1].name = "ExplicitCategory Low";
3958 layers[1].vote = LayerVoteType::ExplicitCategory;
3959 layers[1].desiredRefreshRate = 0_Hz;
3960 layers[1].frameRateCategory = FrameRateCategory::Low;
3961 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3962 EXPECT_EQ(1u, frameRateOverrides.size());
3963 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3964 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3965 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3966 EXPECT_EQ(1u, frameRateOverrides.size());
3967 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3968 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3969
3970 // ExplicitCategory case that expects no global touch boost and thus has frame rate override.
3971 layers[0].name = "ExplicitDefault 60";
3972 layers[0].vote = LayerVoteType::ExplicitDefault;
3973 layers[0].desiredRefreshRate = 60_Hz;
3974 layers[0].frameRateCategory = FrameRateCategory::Default;
3975 layers[1].name = "ExplicitCategory NoPreference";
3976 layers[1].vote = LayerVoteType::ExplicitCategory;
3977 layers[1].desiredRefreshRate = 0_Hz;
3978 layers[1].frameRateCategory = FrameRateCategory::NoPreference;
3979 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
3980 EXPECT_EQ(1u, frameRateOverrides.size());
3981 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3982 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3983 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
3984 EXPECT_EQ(1u, frameRateOverrides.size());
3985 ASSERT_EQ(1u, frameRateOverrides.count(1234));
3986 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
3987 }
3988
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_touch)3989 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_touch) {
3990 if (GetParam() == Config::FrameRateOverride::Disabled) {
3991 return;
3992 }
3993
3994 ASSERT_TRUE(GetParam() == Config::FrameRateOverride::AppOverrideNativeRefreshRates ||
3995 GetParam() == Config::FrameRateOverride::AppOverride ||
3996 GetParam() == Config::FrameRateOverride::Enabled);
3997
3998 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
3999
4000 std::vector<LayerRequirement> layers = {{.ownerUid = 1234, .weight = 1.f}};
4001 layers[0].name = "Test layer";
4002 layers[0].desiredRefreshRate = 60_Hz;
4003 layers[0].vote = LayerVoteType::ExplicitDefault;
4004
4005 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4006 EXPECT_EQ(1u, frameRateOverrides.size());
4007 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4008 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4009
4010 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
4011 EXPECT_EQ(1u, frameRateOverrides.size());
4012 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4013 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4014
4015 layers[0].vote = LayerVoteType::ExplicitExact;
4016 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4017 EXPECT_EQ(1u, frameRateOverrides.size());
4018 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4019 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4020
4021 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
4022 EXPECT_EQ(1u, frameRateOverrides.size());
4023 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4024 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4025
4026 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
4027 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4028 EXPECT_EQ(1u, frameRateOverrides.size());
4029 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4030 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4031
4032 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
4033 EXPECT_TRUE(frameRateOverrides.empty());
4034
4035 layers[0].vote = LayerVoteType::ExplicitGte;
4036 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4037 EXPECT_EQ(1u, frameRateOverrides.size());
4038 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4039 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4040
4041 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {.touch = true});
4042 EXPECT_EQ(1u, frameRateOverrides.size());
4043 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4044 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4045 }
4046
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_DivisorIsNotDisplayRefreshRate)4047 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_DivisorIsNotDisplayRefreshRate) {
4048 if (GetParam() == Config::FrameRateOverride::Disabled) {
4049 return;
4050 }
4051
4052 ASSERT_TRUE(GetParam() == Config::FrameRateOverride::AppOverrideNativeRefreshRates ||
4053 GetParam() == Config::FrameRateOverride::AppOverride ||
4054 GetParam() == Config::FrameRateOverride::Enabled);
4055
4056 auto selector = createSelector(kModes_60_120, kModeId120);
4057
4058 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4059 layers[0].name = "Test layer";
4060 layers[0].ownerUid = 1234;
4061 layers[0].desiredRefreshRate = 30_Hz;
4062
4063 const auto expetedFps =
4064 GetParam() == Config::FrameRateOverride::AppOverrideNativeRefreshRates ? 60_Hz : 30_Hz;
4065 layers[0].vote = LayerVoteType::ExplicitDefault;
4066 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4067 EXPECT_EQ(1u, frameRateOverrides.size());
4068 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4069 EXPECT_EQ(expetedFps, frameRateOverrides.at(1234));
4070
4071 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
4072 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4073 EXPECT_EQ(1u, frameRateOverrides.size());
4074 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4075 EXPECT_EQ(expetedFps, frameRateOverrides.at(1234));
4076
4077 layers[0].vote = LayerVoteType::ExplicitExact;
4078 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4079 EXPECT_EQ(1u, frameRateOverrides.size());
4080 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4081 EXPECT_EQ(expetedFps, frameRateOverrides.at(1234));
4082 }
4083
TEST_P(RefreshRateSelectorTest,renderFrameRateInvalidPolicy)4084 TEST_P(RefreshRateSelectorTest, renderFrameRateInvalidPolicy) {
4085 auto selector = createSelector(kModes_60_120, kModeId120);
4086
4087 // The render frame rate cannot be greater than the physical refresh rate
4088 {
4089 const FpsRange physical = {60_Hz, 60_Hz};
4090 const FpsRange render = {60_Hz, 120_Hz};
4091 EXPECT_EQ(SetPolicyResult::Invalid,
4092 selector.setDisplayManagerPolicy(
4093 {kModeId60, {physical, render}, {physical, render}}));
4094 }
4095 }
4096
TEST_P(RefreshRateSelectorTest,renderFrameRateRestrictsPhysicalRefreshRate)4097 TEST_P(RefreshRateSelectorTest, renderFrameRateRestrictsPhysicalRefreshRate) {
4098 auto selector = createSelector(kModes_60_120, kModeId120);
4099
4100 {
4101 const FpsRange physical = {0_Hz, 120_Hz};
4102 const FpsRange render = {0_Hz, 60_Hz};
4103 EXPECT_EQ(SetPolicyResult::Changed,
4104 selector.setDisplayManagerPolicy(
4105 {kModeId60, {physical, render}, {physical, render}}));
4106 const auto expectedMaxMode =
4107 GetParam() == Config::FrameRateOverride::Enabled ? kMode120 : kMode60;
4108 EXPECT_EQ(expectedMaxMode, selector.getMaxRefreshRateByPolicy());
4109 EXPECT_EQ(kMode60, selector.getMinRefreshRateByPolicy());
4110 }
4111
4112 {
4113 const FpsRange physical = {0_Hz, 120_Hz};
4114 const FpsRange render = {120_Hz, 120_Hz};
4115 EXPECT_EQ(SetPolicyResult::Changed,
4116 selector.setDisplayManagerPolicy(
4117 {kModeId60, {physical, render}, {physical, render}}));
4118 EXPECT_EQ(kMode120, selector.getMaxRefreshRateByPolicy());
4119 EXPECT_EQ(kMode120, selector.getMinRefreshRateByPolicy());
4120 }
4121 }
4122
TEST_P(RefreshRateSelectorTest,getFrameRateOverrides_InPolicy)4123 TEST_P(RefreshRateSelectorTest, getFrameRateOverrides_InPolicy) {
4124 if (GetParam() != Config::FrameRateOverride::Enabled) {
4125 return;
4126 }
4127 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
4128
4129 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4130 {
4131 const FpsRange physical = {120_Hz, 120_Hz};
4132 const FpsRange render = {60_Hz, 90_Hz};
4133 EXPECT_EQ(SetPolicyResult::Changed,
4134 selector.setDisplayManagerPolicy(
4135 {kModeId120, {physical, render}, {physical, render}}));
4136 }
4137
4138 layers[0].name = "30Hz";
4139 layers[0].ownerUid = 1234;
4140 layers[0].desiredRefreshRate = 30_Hz;
4141 layers[0].vote = LayerVoteType::ExplicitDefault;
4142
4143 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4144 EXPECT_EQ(1u, frameRateOverrides.size());
4145 EXPECT_EQ(1u, frameRateOverrides.count(1234));
4146 EXPECT_EQ(60_Hz, frameRateOverrides.at(1234));
4147
4148 {
4149 const FpsRange physical = {120_Hz, 120_Hz};
4150 const FpsRange render = {30_Hz, 90_Hz};
4151 EXPECT_EQ(SetPolicyResult::Changed,
4152 selector.setDisplayManagerPolicy(
4153 {kModeId120, {physical, render}, {physical, render}}));
4154 }
4155
4156 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4157 EXPECT_EQ(1u, frameRateOverrides.size());
4158 EXPECT_EQ(1u, frameRateOverrides.count(1234));
4159 EXPECT_EQ(30_Hz, frameRateOverrides.at(1234));
4160
4161 {
4162 const FpsRange physical = {120_Hz, 120_Hz};
4163 const FpsRange render = {30_Hz, 30_Hz};
4164 EXPECT_EQ(SetPolicyResult::Changed,
4165 selector.setDisplayManagerPolicy(
4166 {kModeId120, {physical, render}, {physical, render}}));
4167 }
4168
4169 layers[0].name = "60Hz";
4170 layers[0].ownerUid = 1234;
4171 layers[0].desiredRefreshRate = 60_Hz;
4172 layers[0].vote = LayerVoteType::ExplicitDefault;
4173
4174 frameRateOverrides = selector.getFrameRateOverrides(layers, 120_Hz, {});
4175 EXPECT_EQ(1u, frameRateOverrides.size());
4176 EXPECT_EQ(1u, frameRateOverrides.count(1234));
4177 EXPECT_EQ(30_Hz, frameRateOverrides.at(1234));
4178 }
4179
TEST_P(RefreshRateSelectorTest,renderFrameRates)4180 TEST_P(RefreshRateSelectorTest, renderFrameRates) {
4181 auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
4182
4183 // [renderRate, refreshRate]
4184 const auto expected = []() -> std::vector<std::pair<Fps, Fps>> {
4185 switch (GetParam()) {
4186 case Config::FrameRateOverride::Disabled:
4187 case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
4188 case Config::FrameRateOverride::AppOverride:
4189 return {{30_Hz, 30_Hz},
4190 {60_Hz, 60_Hz},
4191 {72_Hz, 72_Hz},
4192 {90_Hz, 90_Hz},
4193 {120_Hz, 120_Hz}};
4194 case Config::FrameRateOverride::Enabled:
4195 return {{30_Hz, 30_Hz}, {36_Hz, 72_Hz}, {40_Hz, 120_Hz}, {45_Hz, 90_Hz},
4196 {60_Hz, 60_Hz}, {72_Hz, 72_Hz}, {90_Hz, 90_Hz}, {120_Hz, 120_Hz}};
4197 }
4198 }();
4199
4200 const auto& primaryRefreshRates = selector.getPrimaryFrameRates();
4201 ASSERT_EQ(expected.size(), primaryRefreshRates.size());
4202
4203 for (size_t i = 0; i < expected.size(); i++) {
4204 const auto [expectedRenderRate, expectedRefreshRate] = expected[i];
4205 EXPECT_EQ(expectedRenderRate, primaryRefreshRates[i].fps);
4206 EXPECT_EQ(expectedRefreshRate, primaryRefreshRates[i].modePtr->getPeakFps());
4207 }
4208 }
4209
TEST_P(RefreshRateSelectorTest,refreshRateIsCappedWithRenderFrameRate)4210 TEST_P(RefreshRateSelectorTest, refreshRateIsCappedWithRenderFrameRate) {
4211 if (GetParam() != Config::FrameRateOverride::Enabled) {
4212 return;
4213 }
4214
4215 auto selector = createSelector(kModes_60_120, kModeId60);
4216
4217 constexpr FpsRange k0_120Hz = {0_Hz, 120_Hz};
4218 constexpr FpsRange k0_60Hz = {0_Hz, 60_Hz};
4219
4220 constexpr FpsRanges kAppRequest = {/*physical*/ k0_120Hz,
4221 /*render*/ k0_120Hz};
4222
4223 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, selector.getBestScoredFrameRate().frameRateMode);
4224 {
4225 constexpr FpsRanges kPrimary = {/*physical*/ k0_120Hz,
4226 /*render*/ k0_120Hz};
4227 EXPECT_EQ(SetPolicyResult::Changed,
4228 selector.setDisplayManagerPolicy({/*defaultMode*/ kModeId60,
4229 /*primaryRanges*/
4230 kPrimary,
4231 /*appRequestRanges*/
4232 kAppRequest}));
4233 }
4234 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz, selector.getBestScoredFrameRate().frameRateMode);
4235
4236 {
4237 constexpr FpsRanges kPrimary = {/*physical*/ k0_60Hz,
4238 /*render*/ k0_60Hz};
4239 EXPECT_EQ(SetPolicyResult::Changed,
4240 selector.setDisplayManagerPolicy({/*defaultMode*/ kModeId60,
4241 /*primaryRanges*/
4242 kPrimary,
4243 /*appRequestRanges*/
4244 kAppRequest}));
4245 }
4246 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate().frameRateMode);
4247
4248 {
4249 constexpr FpsRanges kPrimary = {/*physical*/ k0_120Hz,
4250 /*render*/ k0_60Hz};
4251 EXPECT_EQ(SetPolicyResult::Changed,
4252 selector.setDisplayManagerPolicy({/*defaultMode*/ kModeId60,
4253 /*primaryRanges*/
4254 kPrimary,
4255 /*appRequestRanges*/
4256 kAppRequest}));
4257 }
4258 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate().frameRateMode);
4259 }
4260
TEST_P(RefreshRateSelectorTest,renderFrameRates_60_120)4261 TEST_P(RefreshRateSelectorTest, renderFrameRates_60_120) {
4262 auto selector = createSelector(kModes_60_120, kModeId120);
4263
4264 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4265 auto& layer = layers[0];
4266
4267 const auto expectedRenderRate =
4268 GetParam() == Config::FrameRateOverride::Enabled ? 30_Hz : 60_Hz;
4269
4270 layer.name = "30Hz ExplicitDefault";
4271 layer.desiredRefreshRate = 30_Hz;
4272 layer.vote = LayerVoteType::ExplicitDefault;
4273 EXPECT_FRAME_RATE_MODE(kMode60, expectedRenderRate,
4274 selector.getBestScoredFrameRate(layers).frameRateMode);
4275
4276 layer.name = "30Hz Heuristic";
4277 layer.desiredRefreshRate = 30_Hz;
4278 layer.vote = LayerVoteType::Heuristic;
4279 EXPECT_FRAME_RATE_MODE(kMode60, expectedRenderRate,
4280 selector.getBestScoredFrameRate(layers).frameRateMode);
4281
4282 layer.name = "30Hz ExplicitExactOrMultiple";
4283 layer.desiredRefreshRate = 30_Hz;
4284 layer.vote = LayerVoteType::ExplicitExactOrMultiple;
4285 EXPECT_FRAME_RATE_MODE(kMode60, expectedRenderRate,
4286 selector.getBestScoredFrameRate(layers).frameRateMode);
4287 }
4288
TEST_P(RefreshRateSelectorTest,idleWhenLowestRefreshRateIsNotDivisor)4289 TEST_P(RefreshRateSelectorTest, idleWhenLowestRefreshRateIsNotDivisor) {
4290 auto selector = createSelector(kModes_35_60_90, kModeId60);
4291
4292 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4293 layers[0].name = "Test layer";
4294
4295 const auto getIdleDisplayModeId = [&](LayerVoteType voteType,
4296 bool touchActive) -> DisplayModeId {
4297 layers[0].vote = voteType;
4298 layers[0].desiredRefreshRate = 90_Hz;
4299
4300 const auto [ranking, signals, _] =
4301 selector.getRankedFrameRates(layers, {.touch = touchActive, .idle = true});
4302
4303 // Refresh rate will be chosen by either touch state or idle state.
4304 EXPECT_EQ(!touchActive, signals.idle);
4305 return ranking.front().frameRateMode.modePtr->getId();
4306 };
4307
4308 EXPECT_EQ(SetPolicyResult::Changed,
4309 selector.setDisplayManagerPolicy({kModeId60, {0_Hz, 90_Hz}}));
4310
4311 // With no layers, idle should still be lower priority than touch boost.
4312 EXPECT_EQ(kModeId90,
4313 selector.getBestFrameRateMode({}, {.touch = true, .idle = true}).modePtr->getId());
4314
4315 // Idle should be higher precedence than other layer frame rate considerations.
4316 selector.setActiveMode(kModeId90, 90_Hz);
4317 {
4318 constexpr bool kTouchActive = false;
4319 EXPECT_EQ(kModeId35, getIdleDisplayModeId(LayerVoteType::NoVote, kTouchActive));
4320 EXPECT_EQ(kModeId35, getIdleDisplayModeId(LayerVoteType::Min, kTouchActive));
4321 EXPECT_EQ(kModeId35, getIdleDisplayModeId(LayerVoteType::Max, kTouchActive));
4322 EXPECT_EQ(kModeId35, getIdleDisplayModeId(LayerVoteType::Heuristic, kTouchActive));
4323 EXPECT_EQ(kModeId35, getIdleDisplayModeId(LayerVoteType::ExplicitDefault, kTouchActive));
4324 EXPECT_EQ(kModeId35,
4325 getIdleDisplayModeId(LayerVoteType::ExplicitExactOrMultiple, kTouchActive));
4326 }
4327
4328 // Idle should be applied rather than the active mode when there are no layers.
4329 EXPECT_EQ(kModeId35, selector.getBestFrameRateMode({}, {.idle = true}).modePtr->getId());
4330 }
4331
TEST_P(RefreshRateSelectorTest,policyCanBeInfinity)4332 TEST_P(RefreshRateSelectorTest, policyCanBeInfinity) {
4333 auto selector = createSelector(kModes_60_120, kModeId120);
4334
4335 constexpr Fps inf = Fps::fromValue(std::numeric_limits<float>::infinity());
4336
4337 using namespace fps_approx_ops;
4338 selector.setDisplayManagerPolicy({kModeId60, {0_Hz, inf}});
4339
4340 // With no layers, idle should still be lower priority than touch boost.
4341 EXPECT_EQ(kMode120, selector.getMaxRefreshRateByPolicy());
4342 EXPECT_EQ(kMode60, selector.getMinRefreshRateByPolicy());
4343 }
4344
TEST_P(RefreshRateSelectorTest,SupportsLowPhysicalRefreshRates)4345 TEST_P(RefreshRateSelectorTest, SupportsLowPhysicalRefreshRates) {
4346 auto selector = createSelector(kModes_1_5_10, kModeId10);
4347
4348 EXPECT_EQ(kMode10, selector.getMaxRefreshRateByPolicy());
4349 EXPECT_EQ(kMode1, selector.getMinRefreshRateByPolicy());
4350 }
4351
4352 // TODO(b/266481656): Once this bug is fixed, we can remove this test
4353 // And test for VRR when we remove this work around for VRR.
TEST_P(RefreshRateSelectorTest,noLowerFrameRateOnMinVote)4354 TEST_P(RefreshRateSelectorTest, noLowerFrameRateOnMinVote) {
4355 auto selector = createSelector(kModes_60_90, kModeId60);
4356
4357 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4358 layers[0].name = "Test layer";
4359 layers[0].vote = LayerVoteType::Min;
4360 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
4361
4362 constexpr FpsRanges kCappedAt60 = {{30_Hz, 90_Hz}, {30_Hz, 60_Hz}};
4363 EXPECT_EQ(SetPolicyResult::Changed,
4364 selector.setDisplayManagerPolicy(
4365 {DisplayModeId(kModeId60), kCappedAt60, kCappedAt60}));
4366 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
4367 }
4368
TEST_P(RefreshRateSelectorTest,frameRateIsCappedByPolicy)4369 TEST_P(RefreshRateSelectorTest, frameRateIsCappedByPolicy) {
4370 if (GetParam() != Config::FrameRateOverride::Enabled) {
4371 return;
4372 }
4373
4374 auto selector = createSelector(kModes_60_90, kModeId60);
4375
4376 constexpr FpsRanges kCappedAt30 = {{60_Hz, 90_Hz}, {30_Hz, 30_Hz}};
4377
4378 EXPECT_EQ(SetPolicyResult::Changed,
4379 selector.setDisplayManagerPolicy(
4380 {DisplayModeId(kModeId60), kCappedAt30, kCappedAt30}));
4381
4382 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4383 layers[0].name = "Test layer";
4384 layers[0].vote = LayerVoteType::Min;
4385 EXPECT_FRAME_RATE_MODE(kMode60, 30_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
4386 }
4387
TEST_P(RefreshRateSelectorTest,frameRateNotInRange)4388 TEST_P(RefreshRateSelectorTest, frameRateNotInRange) {
4389 auto selector = createSelector(kModes_60_90, kModeId60);
4390
4391 constexpr FpsRanges k60Only = {{60_Hz, 90_Hz}, {60_Hz, 60_Hz}};
4392 constexpr FpsRanges kAll = {{0_Hz, 90_Hz}, {0_Hz, 90_Hz}};
4393
4394 EXPECT_EQ(SetPolicyResult::Changed,
4395 selector.setDisplayManagerPolicy({DisplayModeId(kModeId60), k60Only, kAll}));
4396
4397 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4398 layers[0].name = "Test layer";
4399 layers[0].vote = LayerVoteType::Heuristic;
4400 layers[0].desiredRefreshRate = 45_Hz;
4401 EXPECT_FRAME_RATE_MODE(kMode60, 60_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
4402 }
4403
TEST_P(RefreshRateSelectorTest,frameRateIsLowerThanMinSupported)4404 TEST_P(RefreshRateSelectorTest, frameRateIsLowerThanMinSupported) {
4405 if (GetParam() != Config::FrameRateOverride::Enabled) {
4406 return;
4407 }
4408
4409 auto selector = createSelector(kModes_60_90, kModeId60);
4410
4411 constexpr Fps kMin = RefreshRateSelector::kMinSupportedFrameRate;
4412 constexpr FpsRanges kLowerThanMin = {{60_Hz, 90_Hz}, {kMin / 2, kMin / 2}};
4413
4414 EXPECT_EQ(SetPolicyResult::Changed,
4415 selector.setDisplayManagerPolicy(
4416 {DisplayModeId(kModeId60), kLowerThanMin, kLowerThanMin}));
4417 }
4418
4419 // b/296079213
TEST_P(RefreshRateSelectorTest,frameRateOverrideInBlockingZone60_120)4420 TEST_P(RefreshRateSelectorTest, frameRateOverrideInBlockingZone60_120) {
4421 auto selector = createSelector(kModes_60_120, kModeId120);
4422
4423 const FpsRange only120 = {120_Hz, 120_Hz};
4424 const FpsRange allRange = {0_Hz, 120_Hz};
4425 EXPECT_EQ(SetPolicyResult::Changed,
4426 selector.setDisplayManagerPolicy(
4427 {kModeId120, {only120, allRange}, {allRange, allRange}}));
4428
4429 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4430 layers[0].name = "30Hz ExplicitExactOrMultiple";
4431 layers[0].desiredRefreshRate = 30_Hz;
4432 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
4433
4434 if (GetParam() != Config::FrameRateOverride::Enabled) {
4435 EXPECT_FRAME_RATE_MODE(kMode120, 120_Hz,
4436 selector.getBestScoredFrameRate(layers).frameRateMode);
4437 } else {
4438 EXPECT_FRAME_RATE_MODE(kMode120, 30_Hz,
4439 selector.getBestScoredFrameRate(layers).frameRateMode);
4440 }
4441 }
4442
TEST_P(RefreshRateSelectorTest,frameRateOverrideInBlockingZone60_90)4443 TEST_P(RefreshRateSelectorTest, frameRateOverrideInBlockingZone60_90) {
4444 auto selector = createSelector(kModes_60_90, kModeId90);
4445
4446 const FpsRange only90 = {90_Hz, 90_Hz};
4447 const FpsRange allRange = {0_Hz, 90_Hz};
4448 EXPECT_EQ(SetPolicyResult::Changed,
4449 selector.setDisplayManagerPolicy(
4450 {kModeId90, {only90, allRange}, {allRange, allRange}}));
4451
4452 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4453 layers[0].name = "30Hz ExplicitExactOrMultiple";
4454 layers[0].desiredRefreshRate = 30_Hz;
4455 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
4456
4457 if (GetParam() != Config::FrameRateOverride::Enabled) {
4458 EXPECT_FRAME_RATE_MODE(kMode90, 90_Hz,
4459 selector.getBestScoredFrameRate(layers).frameRateMode);
4460 } else {
4461 EXPECT_FRAME_RATE_MODE(kMode90, 30_Hz,
4462 selector.getBestScoredFrameRate(layers).frameRateMode);
4463 }
4464 }
4465
TEST_P(RefreshRateSelectorTest,frameRateOverrideInBlockingZone60_90_NonDivisor)4466 TEST_P(RefreshRateSelectorTest, frameRateOverrideInBlockingZone60_90_NonDivisor) {
4467 auto selector = createSelector(kModes_60_90, kModeId90);
4468
4469 const FpsRange only90 = {90_Hz, 90_Hz};
4470 const FpsRange allRange = {0_Hz, 90_Hz};
4471 EXPECT_EQ(SetPolicyResult::Changed,
4472 selector.setDisplayManagerPolicy(
4473 {kModeId90, {only90, allRange}, {allRange, allRange}}));
4474
4475 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4476 layers[0].name = "60Hz ExplicitExactOrMultiple";
4477 layers[0].desiredRefreshRate = 60_Hz;
4478 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
4479
4480 EXPECT_FRAME_RATE_MODE(kMode90, 90_Hz, selector.getBestScoredFrameRate(layers).frameRateMode);
4481 }
4482
4483 // VRR tests
TEST_P(RefreshRateSelectorTest,singleMinMaxRateForVrr)4484 TEST_P(RefreshRateSelectorTest, singleMinMaxRateForVrr) {
4485 if (GetParam() != Config::FrameRateOverride::Enabled) {
4486 return;
4487 }
4488
4489 SET_FLAG_FOR_TEST(flags::vrr_config, true);
4490 auto selector = createSelector(kVrrMode_120, kModeId120);
4491 EXPECT_TRUE(selector.supportsFrameRateOverride());
4492
4493 const auto minRate = selector.getMinSupportedRefreshRate();
4494 const auto performanceRate = selector.getMaxSupportedRefreshRate();
4495 const auto minRateByPolicy = selector.getMinRefreshRateByPolicy();
4496 const auto performanceRateByPolicy = selector.getMaxRefreshRateByPolicy();
4497
4498 EXPECT_EQ(kVrrMode120TE240, minRate);
4499 EXPECT_EQ(kVrrMode120TE240, performanceRate);
4500 EXPECT_EQ(kVrrMode120TE240, minRateByPolicy);
4501 EXPECT_EQ(kVrrMode120TE240, performanceRateByPolicy);
4502 }
4503
TEST_P(RefreshRateSelectorTest,renderRateChangesWithPolicyChangeForVrr)4504 TEST_P(RefreshRateSelectorTest, renderRateChangesWithPolicyChangeForVrr) {
4505 if (GetParam() != Config::FrameRateOverride::Enabled) {
4506 return;
4507 }
4508
4509 SET_FLAG_FOR_TEST(flags::vrr_config, true);
4510 auto selector = createSelector(kVrrModes_60_120, kModeId120);
4511
4512 const FpsRange only120 = {120_Hz, 120_Hz};
4513 EXPECT_EQ(SetPolicyResult::Changed,
4514 selector.setDisplayManagerPolicy(
4515 {kModeId120, {only120, only120}, {only120, only120}}));
4516 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 120_Hz,
4517 selector.getBestScoredFrameRate({}).frameRateMode);
4518
4519 const FpsRange range120 = {0_Hz, 120_Hz};
4520 EXPECT_EQ(SetPolicyResult::Changed,
4521 selector.setDisplayManagerPolicy(
4522 {kModeId120, {only120, range120}, {only120, range120}}));
4523 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 120_Hz,
4524 selector.getBestScoredFrameRate({}).frameRateMode);
4525
4526 const FpsRange range90 = {0_Hz, 90_Hz};
4527 EXPECT_EQ(SetPolicyResult::Changed,
4528 selector.setDisplayManagerPolicy(
4529 {kModeId120, {only120, range90}, {only120, range90}}));
4530 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 80_Hz,
4531 selector.getBestScoredFrameRate({}).frameRateMode);
4532
4533 const FpsRange range80 = {0_Hz, 80_Hz};
4534 EXPECT_EQ(SetPolicyResult::Changed,
4535 selector.setDisplayManagerPolicy(
4536 {kModeId120, {only120, range80}, {only120, range80}}));
4537 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 80_Hz,
4538 selector.getBestScoredFrameRate({}).frameRateMode);
4539
4540 const FpsRange range60 = {0_Hz, 60_Hz};
4541 EXPECT_EQ(SetPolicyResult::Changed,
4542 selector.setDisplayManagerPolicy(
4543 {kModeId120, {only120, range60}, {only120, range60}}));
4544 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 60_Hz,
4545 selector.getBestScoredFrameRate({}).frameRateMode);
4546
4547 const FpsRange range48 = {0_Hz, 48_Hz};
4548 EXPECT_EQ(SetPolicyResult::Changed,
4549 selector.setDisplayManagerPolicy(
4550 {kModeId120, {only120, range48}, {only120, range48}}));
4551 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 48_Hz,
4552 selector.getBestScoredFrameRate({}).frameRateMode);
4553
4554 const FpsRange range30 = {0_Hz, 30_Hz};
4555 EXPECT_EQ(SetPolicyResult::Changed,
4556 selector.setDisplayManagerPolicy(
4557 {kModeId120, {only120, range30}, {only120, range30}}));
4558 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 30_Hz,
4559 selector.getBestScoredFrameRate({}).frameRateMode);
4560 }
4561
TEST_P(RefreshRateSelectorTest,modeChangesWithPolicyChangeForVrr)4562 TEST_P(RefreshRateSelectorTest, modeChangesWithPolicyChangeForVrr) {
4563 if (GetParam() != Config::FrameRateOverride::Enabled) {
4564 return;
4565 }
4566
4567 SET_FLAG_FOR_TEST(flags::vrr_config, true);
4568 auto selector = createSelector(kVrrModes_60_120, kModeId120);
4569
4570 const FpsRange range120 = {0_Hz, 120_Hz};
4571 const FpsRange range60 = {0_Hz, 60_Hz};
4572
4573 EXPECT_EQ(SetPolicyResult::Changed,
4574 selector.setDisplayManagerPolicy(
4575 {kModeId120, {range120, range60}, {range120, range60}}));
4576 EXPECT_FRAME_RATE_MODE(kVrrMode120TE240, 60_Hz,
4577 selector.getBestScoredFrameRate({}).frameRateMode);
4578
4579 EXPECT_EQ(SetPolicyResult::Changed,
4580 selector.setDisplayManagerPolicy(
4581 {kModeId60, {range60, range60}, {range60, range60}}));
4582 EXPECT_FRAME_RATE_MODE(kVrrMode60TE120, 60_Hz,
4583 selector.getBestScoredFrameRate({}).frameRateMode);
4584 }
4585
TEST_P(RefreshRateSelectorTest,getFrameRateOverridesForVrr)4586 TEST_P(RefreshRateSelectorTest, getFrameRateOverridesForVrr) {
4587 if (GetParam() != Config::FrameRateOverride::Enabled) {
4588 return;
4589 }
4590
4591 SET_FLAG_FOR_TEST(flags::vrr_config, true);
4592 auto selector = createSelector(kVrrMode_120, kModeId120);
4593 // TODO(b/297600226) Run at lower than 30 Fps for dVRR
4594 const std::vector<Fps> desiredRefreshRates = {30_Hz, 34.285_Hz, 40_Hz, 48_Hz,
4595 60_Hz, 80_Hz, 120_Hz};
4596 const std::vector<LayerVoteType> layerVotes = {LayerVoteType::ExplicitDefault,
4597 LayerVoteType::ExplicitExactOrMultiple,
4598 LayerVoteType::ExplicitExact};
4599
4600 std::vector<LayerRequirement> layers = {{.weight = 1.f}};
4601 layers[0].name = "Test layer";
4602 layers[0].ownerUid = 1234;
4603
4604 for (auto desiredRefreshRate : desiredRefreshRates) {
4605 layers[0].desiredRefreshRate = desiredRefreshRate;
4606 for (auto vote : layerVotes) {
4607 layers[0].vote = vote;
4608 auto frameRateOverrides = selector.getFrameRateOverrides(layers, 240_Hz, {});
4609 EXPECT_EQ(1u, frameRateOverrides.size());
4610 ASSERT_EQ(1u, frameRateOverrides.count(1234));
4611 EXPECT_EQ(desiredRefreshRate, frameRateOverrides.at(1234));
4612 }
4613 }
4614 }
4615
TEST_P(RefreshRateSelectorTest,renderFrameRatesForVrr)4616 TEST_P(RefreshRateSelectorTest, renderFrameRatesForVrr) {
4617 if (GetParam() != Config::FrameRateOverride::Enabled) {
4618 return;
4619 }
4620
4621 SET_FLAG_FOR_TEST(flags::vrr_config, true);
4622 auto selector = createSelector(kVrrMode_120, kModeId120);
4623 const FpsRange only120 = {120_Hz, 120_Hz};
4624 const FpsRange range120 = {0_Hz, 120_Hz};
4625
4626 EXPECT_EQ(SetPolicyResult::Changed,
4627 selector.setDisplayManagerPolicy(
4628 {kModeId120, {only120, range120}, {only120, range120}}));
4629
4630 std::vector<Fps> expected = {20_Hz, 21.818_Hz, 24_Hz, 26.666_Hz, 30_Hz, 34.285_Hz,
4631 40_Hz, 48_Hz, 60_Hz, 80_Hz, 120_Hz};
4632
4633 auto primaryRefreshRates = selector.getPrimaryFrameRates();
4634 ASSERT_EQ(expected.size(), primaryRefreshRates.size());
4635
4636 for (size_t i = 0; i < expected.size(); i++) {
4637 EXPECT_EQ(expected[i], primaryRefreshRates[i].fps);
4638 EXPECT_EQ(120_Hz, primaryRefreshRates[i].modePtr->getPeakFps());
4639 }
4640
4641 // Render range (0,90)
4642 const FpsRange range90 = {0_Hz, 90_Hz};
4643 EXPECT_EQ(SetPolicyResult::Changed,
4644 selector.setDisplayManagerPolicy(
4645 {kModeId120, {range120, range90}, {range120, range90}}));
4646
4647 expected = {20_Hz, 21.818_Hz, 24_Hz, 26.666_Hz, 30_Hz, 34.285_Hz, 40_Hz, 48_Hz, 60_Hz, 80_Hz};
4648
4649 primaryRefreshRates = selector.getPrimaryFrameRates();
4650 ASSERT_EQ(expected.size(), primaryRefreshRates.size());
4651 for (size_t i = 0; i < expected.size(); i++) {
4652 EXPECT_EQ(expected[i], primaryRefreshRates[i].fps);
4653 EXPECT_EQ(120_Hz, primaryRefreshRates[i].modePtr->getPeakFps());
4654 }
4655
4656 // Render range (0,60)
4657 const FpsRange range60 = {0_Hz, 60_Hz};
4658 EXPECT_EQ(SetPolicyResult::Changed,
4659 selector.setDisplayManagerPolicy(
4660 {kModeId120, {range120, range60}, {range120, range60}}));
4661 expected = {20_Hz, 21.818_Hz, 24_Hz, 26.666_Hz, 30_Hz, 34.285_Hz, 40_Hz, 48_Hz, 60_Hz};
4662
4663 primaryRefreshRates = selector.getPrimaryFrameRates();
4664 ASSERT_EQ(expected.size(), primaryRefreshRates.size());
4665 for (size_t i = 0; i < expected.size(); i++) {
4666 EXPECT_EQ(expected[i], primaryRefreshRates[i].fps);
4667 EXPECT_EQ(120_Hz, primaryRefreshRates[i].modePtr->getPeakFps());
4668 }
4669 }
4670
TEST_P(RefreshRateSelectorTest,getSupportedFrameRates)4671 TEST_P(RefreshRateSelectorTest, getSupportedFrameRates) {
4672 if (GetParam() != Config::FrameRateOverride::Enabled) {
4673 return;
4674 }
4675
4676 auto selector = createSelector(kModes_60_90, kModeId90);
4677 const FpsRange range60 = {0_Hz, 60_Hz};
4678 EXPECT_EQ(SetPolicyResult::Changed,
4679 selector.setDisplayManagerPolicy(
4680 {kModeId60, {range60, range60}, {range60, range60}}));
4681
4682 // Irrespective of the policy we get the full range of possible frame rates
4683 const std::vector<float> expected = {90.0f, 60.0f, 45.0f, 30.0f, 22.5f, 20.0f};
4684
4685 const auto allSupportedFrameRates = selector.getSupportedFrameRates();
4686 ASSERT_EQ(expected.size(), allSupportedFrameRates.size());
4687 for (size_t i = 0; i < expected.size(); i++) {
4688 EXPECT_EQ(expected[i], allSupportedFrameRates[i])
4689 << "expected " << expected[i] << " received " << allSupportedFrameRates[i];
4690 }
4691 }
4692
TEST_P(RefreshRateSelectorTest,getSupportedFrameRatesArr)4693 TEST_P(RefreshRateSelectorTest, getSupportedFrameRatesArr) {
4694 if (GetParam() != Config::FrameRateOverride::Enabled) {
4695 return;
4696 }
4697
4698 SET_FLAG_FOR_TEST(flags::vrr_config, true);
4699 const auto selector = createSelector(kVrrMode_120, kModeId120);
4700
4701 const std::vector<float> expected = {120.0f, 80.0f, 60.0f, 48.0f, 40.0f, 34.285f,
4702 30.0f, 26.666f, 24.0f, 21.818f, 20.0f};
4703
4704 const auto allSupportedFrameRates = selector.getSupportedFrameRates();
4705 ASSERT_EQ(expected.size(), allSupportedFrameRates.size());
4706 constexpr float kEpsilon = 0.001f;
4707 for (size_t i = 0; i < expected.size(); i++) {
4708 EXPECT_TRUE(std::abs(expected[i] - allSupportedFrameRates[i]) <= kEpsilon)
4709 << "expected " << expected[i] << " received " << allSupportedFrameRates[i];
4710 }
4711 }
4712 } // namespace
4713 } // namespace android::scheduler
4714