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 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wextra"
20
21 #undef LOG_TAG
22 #define LOG_TAG "SchedulerUnittests"
23
24 #include <gmock/gmock.h>
25 #include <log/log.h>
26 #include <thread>
27
28 #include <ui/Size.h>
29
30 #include "../../Scheduler/RefreshRateConfigs.h"
31 #include "DisplayHardware/HWC2.h"
32 #include "Scheduler/RefreshRateConfigs.h"
33
34 using namespace std::chrono_literals;
35
36 namespace android {
37
38 namespace scheduler {
39
40 namespace hal = android::hardware::graphics::composer::hal;
41
42 using RefreshRate = RefreshRateConfigs::RefreshRate;
43 using LayerVoteType = RefreshRateConfigs::LayerVoteType;
44 using LayerRequirement = RefreshRateConfigs::LayerRequirement;
45
46 class RefreshRateConfigsTest : public testing::Test {
47 protected:
48 using GetBestRefreshRateInvocation = RefreshRateConfigs::GetBestRefreshRateInvocation;
49
50 RefreshRateConfigsTest();
51 ~RefreshRateConfigsTest();
52
createRefreshRate(DisplayModePtr displayMode)53 RefreshRate createRefreshRate(DisplayModePtr displayMode) {
54 return {displayMode, RefreshRate::ConstructorTag(0)};
55 }
56
findClosestKnownFrameRate(const RefreshRateConfigs & refreshRateConfigs,Fps frameRate)57 Fps findClosestKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs, Fps frameRate) {
58 return refreshRateConfigs.findClosestKnownFrameRate(frameRate);
59 }
60
getKnownFrameRate(const RefreshRateConfigs & refreshRateConfigs)61 std::vector<Fps> getKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs) {
62 return refreshRateConfigs.mKnownFrameRates;
63 }
64
getMinRefreshRateByPolicy(const RefreshRateConfigs & refreshRateConfigs)65 RefreshRate getMinRefreshRateByPolicy(const RefreshRateConfigs& refreshRateConfigs) {
66 std::lock_guard lock(refreshRateConfigs.mLock);
67 return refreshRateConfigs.getMinRefreshRateByPolicyLocked();
68 }
69
getMinSupportedRefreshRate(const RefreshRateConfigs & refreshRateConfigs)70 RefreshRate getMinSupportedRefreshRate(const RefreshRateConfigs& refreshRateConfigs) {
71 std::lock_guard lock(refreshRateConfigs.mLock);
72 return *refreshRateConfigs.mMinSupportedRefreshRate;
73 }
74
getMaxSupportedRefreshRate(const RefreshRateConfigs & refreshRateConfigs)75 RefreshRate getMaxSupportedRefreshRate(const RefreshRateConfigs& refreshRateConfigs) {
76 std::lock_guard lock(refreshRateConfigs.mLock);
77 return *refreshRateConfigs.mMaxSupportedRefreshRate;
78 }
79
setLastBestRefreshRateInvocation(RefreshRateConfigs & refreshRateConfigs,const GetBestRefreshRateInvocation & invocation)80 void setLastBestRefreshRateInvocation(RefreshRateConfigs& refreshRateConfigs,
81 const GetBestRefreshRateInvocation& invocation) {
82 std::lock_guard lock(refreshRateConfigs.mLock);
83 refreshRateConfigs.lastBestRefreshRateInvocation.emplace(
84 GetBestRefreshRateInvocation(invocation));
85 }
86
getLastBestRefreshRateInvocation(const RefreshRateConfigs & refreshRateConfigs)87 std::optional<GetBestRefreshRateInvocation> getLastBestRefreshRateInvocation(
88 const RefreshRateConfigs& refreshRateConfigs) {
89 std::lock_guard lock(refreshRateConfigs.mLock);
90 return refreshRateConfigs.lastBestRefreshRateInvocation;
91 }
92
93 // Test config IDs
94 static inline const DisplayModeId HWC_CONFIG_ID_60 = DisplayModeId(0);
95 static inline const DisplayModeId HWC_CONFIG_ID_90 = DisplayModeId(1);
96 static inline const DisplayModeId HWC_CONFIG_ID_72 = DisplayModeId(2);
97 static inline const DisplayModeId HWC_CONFIG_ID_120 = DisplayModeId(3);
98 static inline const DisplayModeId HWC_CONFIG_ID_30 = DisplayModeId(4);
99 static inline const DisplayModeId HWC_CONFIG_ID_25 = DisplayModeId(5);
100 static inline const DisplayModeId HWC_CONFIG_ID_50 = DisplayModeId(6);
101
102 // Test configs
103 DisplayModePtr mConfig60 = createDisplayMode(HWC_CONFIG_ID_60, 0, Fps(60.0f).getPeriodNsecs());
104 DisplayModePtr mConfig90 = createDisplayMode(HWC_CONFIG_ID_90, 0, Fps(90.0f).getPeriodNsecs());
105 DisplayModePtr mConfig90DifferentGroup =
106 createDisplayMode(HWC_CONFIG_ID_90, 1, Fps(90.0f).getPeriodNsecs());
107 DisplayModePtr mConfig90DifferentResolution =
108 createDisplayMode(HWC_CONFIG_ID_90, 0, Fps(90.0f).getPeriodNsecs(), ui::Size(111, 222));
109 DisplayModePtr mConfig72 = createDisplayMode(HWC_CONFIG_ID_72, 0, Fps(72.0f).getPeriodNsecs());
110 DisplayModePtr mConfig72DifferentGroup =
111 createDisplayMode(HWC_CONFIG_ID_72, 1, Fps(72.0f).getPeriodNsecs());
112 DisplayModePtr mConfig120 =
113 createDisplayMode(HWC_CONFIG_ID_120, 0, Fps(120.0f).getPeriodNsecs());
114 DisplayModePtr mConfig120DifferentGroup =
115 createDisplayMode(HWC_CONFIG_ID_120, 1, Fps(120.0f).getPeriodNsecs());
116 DisplayModePtr mConfig30 = createDisplayMode(HWC_CONFIG_ID_30, 0, Fps(30.0f).getPeriodNsecs());
117 DisplayModePtr mConfig30DifferentGroup =
118 createDisplayMode(HWC_CONFIG_ID_30, 1, Fps(30.0f).getPeriodNsecs());
119 DisplayModePtr mConfig25DifferentGroup =
120 createDisplayMode(HWC_CONFIG_ID_25, 1, Fps(25.0f).getPeriodNsecs());
121 DisplayModePtr mConfig50 = createDisplayMode(HWC_CONFIG_ID_50, 0, Fps(50.0f).getPeriodNsecs());
122
123 // Test device configurations
124 // The positions of the configs in the arrays below MUST match their IDs. For example,
125 // the first config should always be 60Hz, the second 90Hz etc.
126 DisplayModes m60OnlyConfigDevice = {mConfig60};
127 DisplayModes m60_90Device = {mConfig60, mConfig90};
128 DisplayModes m60_90DeviceWithDifferentGroups = {mConfig60, mConfig90DifferentGroup};
129 DisplayModes m60_90DeviceWithDifferentResolutions = {mConfig60, mConfig90DifferentResolution};
130 DisplayModes m60_72_90Device = {mConfig60, mConfig90, mConfig72};
131 DisplayModes m60_90_72_120Device = {mConfig60, mConfig90, mConfig72, mConfig120};
132 DisplayModes m30_60_72_90_120Device = {mConfig60, mConfig90, mConfig72, mConfig120, mConfig30};
133 DisplayModes m30_60Device = {mConfig60, mConfig90DifferentGroup, mConfig72DifferentGroup,
134 mConfig120DifferentGroup, mConfig30};
135 DisplayModes m30_60_72_90Device = {mConfig60, mConfig90, mConfig72, mConfig120DifferentGroup,
136 mConfig30};
137 DisplayModes m30_60_90Device = {mConfig60, mConfig90, mConfig72DifferentGroup,
138 mConfig120DifferentGroup, mConfig30};
139 DisplayModes m25_30_50_60Device = {mConfig60,
140 mConfig90,
141 mConfig72DifferentGroup,
142 mConfig120DifferentGroup,
143 mConfig30DifferentGroup,
144 mConfig25DifferentGroup,
145 mConfig50};
146 DisplayModes m60_120Device = {mConfig60, mConfig120};
147
148 // Expected RefreshRate objects
149 RefreshRate mExpected60Config = {mConfig60, RefreshRate::ConstructorTag(0)};
150 RefreshRate mExpectedAlmost60Config = {createDisplayMode(HWC_CONFIG_ID_60, 0, 16666665),
151 RefreshRate::ConstructorTag(0)};
152 RefreshRate mExpected90Config = {mConfig90, RefreshRate::ConstructorTag(0)};
153 RefreshRate mExpected90DifferentGroupConfig = {mConfig90DifferentGroup,
154 RefreshRate::ConstructorTag(0)};
155 RefreshRate mExpected90DifferentResolutionConfig = {mConfig90DifferentResolution,
156 RefreshRate::ConstructorTag(0)};
157 RefreshRate mExpected72Config = {mConfig72, RefreshRate::ConstructorTag(0)};
158 RefreshRate mExpected30Config = {mConfig30, RefreshRate::ConstructorTag(0)};
159 RefreshRate mExpected120Config = {mConfig120, RefreshRate::ConstructorTag(0)};
160
161 private:
162 DisplayModePtr createDisplayMode(DisplayModeId modeId, int32_t group, int64_t vsyncPeriod,
163 ui::Size resolution = ui::Size());
164 };
165
166 using Builder = DisplayMode::Builder;
167
RefreshRateConfigsTest()168 RefreshRateConfigsTest::RefreshRateConfigsTest() {
169 const ::testing::TestInfo* const test_info =
170 ::testing::UnitTest::GetInstance()->current_test_info();
171 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
172 }
173
~RefreshRateConfigsTest()174 RefreshRateConfigsTest::~RefreshRateConfigsTest() {
175 const ::testing::TestInfo* const test_info =
176 ::testing::UnitTest::GetInstance()->current_test_info();
177 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
178 }
179
createDisplayMode(DisplayModeId modeId,int32_t group,int64_t vsyncPeriod,ui::Size resolution)180 DisplayModePtr RefreshRateConfigsTest::createDisplayMode(DisplayModeId modeId, int32_t group,
181 int64_t vsyncPeriod, ui::Size resolution) {
182 return DisplayMode::Builder(hal::HWConfigId(modeId.value()))
183 .setId(modeId)
184 .setPhysicalDisplayId(PhysicalDisplayId(0))
185 .setVsyncPeriod(int32_t(vsyncPeriod))
186 .setGroup(group)
187 .setHeight(resolution.height)
188 .setWidth(resolution.width)
189 .build();
190 }
191
192 namespace {
193 /* ------------------------------------------------------------------------
194 * Test cases
195 */
TEST_F(RefreshRateConfigsTest,oneDeviceConfig_SwitchingSupported)196 TEST_F(RefreshRateConfigsTest, oneDeviceConfig_SwitchingSupported) {
197 auto refreshRateConfigs =
198 std::make_unique<RefreshRateConfigs>(m60OnlyConfigDevice,
199 /*currentConfigId=*/HWC_CONFIG_ID_60);
200 }
201
TEST_F(RefreshRateConfigsTest,invalidPolicy)202 TEST_F(RefreshRateConfigsTest, invalidPolicy) {
203 auto refreshRateConfigs =
204 std::make_unique<RefreshRateConfigs>(m60OnlyConfigDevice,
205 /*currentConfigId=*/HWC_CONFIG_ID_60);
206 ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({DisplayModeId(10), {Fps(60), Fps(60)}}),
207 0);
208 ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(20), Fps(40)}}),
209 0);
210 }
211
TEST_F(RefreshRateConfigsTest,twoDeviceConfigs_storesFullRefreshRateMap)212 TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap) {
213 auto refreshRateConfigs =
214 std::make_unique<RefreshRateConfigs>(m60_90Device,
215 /*currentConfigId=*/HWC_CONFIG_ID_60);
216
217 const auto& minRate = getMinSupportedRefreshRate(*refreshRateConfigs);
218 const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs);
219
220 ASSERT_EQ(mExpected60Config, minRate);
221 ASSERT_EQ(mExpected90Config, performanceRate);
222
223 const auto& minRateByPolicy = getMinRefreshRateByPolicy(*refreshRateConfigs);
224 const auto& performanceRateByPolicy = refreshRateConfigs->getMaxRefreshRateByPolicy();
225 ASSERT_EQ(minRateByPolicy, minRate);
226 ASSERT_EQ(performanceRateByPolicy, performanceRate);
227 }
228
TEST_F(RefreshRateConfigsTest,twoDeviceConfigs_storesFullRefreshRateMap_differentGroups)229 TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap_differentGroups) {
230 auto refreshRateConfigs =
231 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
232 /*currentConfigId=*/HWC_CONFIG_ID_60);
233
234 const auto& minRate = getMinRefreshRateByPolicy(*refreshRateConfigs);
235 const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs);
236 const auto& minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs);
237 const auto& performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy();
238
239 ASSERT_EQ(mExpected60Config, minRate);
240 ASSERT_EQ(mExpected60Config, minRate60);
241 ASSERT_EQ(mExpected60Config, performanceRate60);
242
243 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(60), Fps(90)}}),
244 0);
245 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
246
247 const auto& minRate90 = getMinRefreshRateByPolicy(*refreshRateConfigs);
248 const auto& performanceRate90 = refreshRateConfigs->getMaxRefreshRateByPolicy();
249
250 ASSERT_EQ(mExpected90DifferentGroupConfig, performanceRate);
251 ASSERT_EQ(mExpected90DifferentGroupConfig, minRate90);
252 ASSERT_EQ(mExpected90DifferentGroupConfig, performanceRate90);
253 }
254
TEST_F(RefreshRateConfigsTest,twoDeviceConfigs_storesFullRefreshRateMap_differentResolutions)255 TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap_differentResolutions) {
256 auto refreshRateConfigs =
257 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentResolutions,
258 /*currentConfigId=*/HWC_CONFIG_ID_60);
259
260 const auto& minRate = getMinRefreshRateByPolicy(*refreshRateConfigs);
261 const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs);
262 const auto& minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs);
263 const auto& performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy();
264
265 ASSERT_EQ(mExpected60Config, minRate);
266 ASSERT_EQ(mExpected60Config, minRate60);
267 ASSERT_EQ(mExpected60Config, performanceRate60);
268
269 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(60), Fps(90)}}),
270 0);
271 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
272
273 const auto& minRate90 = getMinRefreshRateByPolicy(*refreshRateConfigs);
274 const auto& performanceRate90 = refreshRateConfigs->getMaxRefreshRateByPolicy();
275
276 ASSERT_EQ(mExpected90DifferentResolutionConfig, performanceRate);
277 ASSERT_EQ(mExpected90DifferentResolutionConfig, minRate90);
278 ASSERT_EQ(mExpected90DifferentResolutionConfig, performanceRate90);
279 }
280
TEST_F(RefreshRateConfigsTest,twoDeviceConfigs_policyChange)281 TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_policyChange) {
282 auto refreshRateConfigs =
283 std::make_unique<RefreshRateConfigs>(m60_90Device,
284 /*currentConfigId=*/HWC_CONFIG_ID_60);
285
286 auto minRate = getMinRefreshRateByPolicy(*refreshRateConfigs);
287 auto performanceRate = refreshRateConfigs->getMaxRefreshRateByPolicy();
288
289 ASSERT_EQ(mExpected60Config, minRate);
290 ASSERT_EQ(mExpected90Config, performanceRate);
291
292 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}),
293 0);
294
295 auto minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs);
296 auto performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy();
297 ASSERT_EQ(mExpected60Config, minRate60);
298 ASSERT_EQ(mExpected60Config, performanceRate60);
299 }
300
TEST_F(RefreshRateConfigsTest,twoDeviceConfigs_getCurrentRefreshRate)301 TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getCurrentRefreshRate) {
302 auto refreshRateConfigs =
303 std::make_unique<RefreshRateConfigs>(m60_90Device,
304 /*currentConfigId=*/HWC_CONFIG_ID_60);
305 {
306 auto current = refreshRateConfigs->getCurrentRefreshRate();
307 EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_60);
308 }
309
310 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
311 {
312 auto current = refreshRateConfigs->getCurrentRefreshRate();
313 EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_90);
314 }
315
316 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(90), Fps(90)}}),
317 0);
318 {
319 auto current = refreshRateConfigs->getCurrentRefreshRate();
320 EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_90);
321 }
322 }
323
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_noLayers)324 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_noLayers) {
325 auto refreshRateConfigs =
326 std::make_unique<RefreshRateConfigs>(m60_72_90Device, /*currentConfigId=*/
327 HWC_CONFIG_ID_72);
328
329 // If there are no layers we select the default frame rate, which is the max of the primary
330 // range.
331 auto layers = std::vector<LayerRequirement>{};
332 EXPECT_EQ(mExpected90Config,
333 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
334
335 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}),
336 0);
337 EXPECT_EQ(mExpected60Config,
338 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
339 }
340
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_60_90)341 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) {
342 auto refreshRateConfigs =
343 std::make_unique<RefreshRateConfigs>(m60_90Device,
344 /*currentConfigId=*/HWC_CONFIG_ID_60);
345
346 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
347 auto& lr = layers[0];
348
349 lr.vote = LayerVoteType::Min;
350 lr.name = "Min";
351 EXPECT_EQ(mExpected60Config,
352 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
353
354 lr.vote = LayerVoteType::Max;
355 lr.name = "Max";
356 EXPECT_EQ(mExpected90Config,
357 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
358
359 lr.desiredRefreshRate = Fps(90.0f);
360 lr.vote = LayerVoteType::Heuristic;
361 lr.name = "90Hz Heuristic";
362 EXPECT_EQ(mExpected90Config,
363 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
364
365 lr.desiredRefreshRate = Fps(60.0f);
366 lr.name = "60Hz Heuristic";
367 EXPECT_EQ(mExpected60Config,
368 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
369
370 lr.desiredRefreshRate = Fps(45.0f);
371 lr.name = "45Hz Heuristic";
372 EXPECT_EQ(mExpected90Config,
373 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
374
375 lr.desiredRefreshRate = Fps(30.0f);
376 lr.name = "30Hz Heuristic";
377 EXPECT_EQ(mExpected60Config,
378 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
379
380 lr.desiredRefreshRate = Fps(24.0f);
381 lr.name = "24Hz Heuristic";
382 EXPECT_EQ(mExpected60Config,
383 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
384
385 lr.name = "";
386 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}),
387 0);
388
389 lr.vote = LayerVoteType::Min;
390 EXPECT_EQ(mExpected60Config,
391 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
392
393 lr.vote = LayerVoteType::Max;
394 EXPECT_EQ(mExpected60Config,
395 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
396
397 lr.desiredRefreshRate = Fps(90.0f);
398 lr.vote = LayerVoteType::Heuristic;
399 EXPECT_EQ(mExpected60Config,
400 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
401
402 lr.desiredRefreshRate = Fps(60.0f);
403 EXPECT_EQ(mExpected60Config,
404 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
405
406 lr.desiredRefreshRate = Fps(45.0f);
407 EXPECT_EQ(mExpected60Config,
408 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
409
410 lr.desiredRefreshRate = Fps(30.0f);
411 EXPECT_EQ(mExpected60Config,
412 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
413
414 lr.desiredRefreshRate = Fps(24.0f);
415 EXPECT_EQ(mExpected60Config,
416 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
417
418 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
419 {HWC_CONFIG_ID_90, {Fps(90.0f), Fps(90.0f)}}),
420 0);
421
422 lr.vote = LayerVoteType::Min;
423 EXPECT_EQ(mExpected90Config,
424 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
425
426 lr.vote = LayerVoteType::Max;
427 EXPECT_EQ(mExpected90Config,
428 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
429
430 lr.desiredRefreshRate = Fps(90.0f);
431 lr.vote = LayerVoteType::Heuristic;
432 EXPECT_EQ(mExpected90Config,
433 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
434
435 lr.desiredRefreshRate = Fps(60.0f);
436 EXPECT_EQ(mExpected90Config,
437 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
438
439 lr.desiredRefreshRate = Fps(45.0f);
440 EXPECT_EQ(mExpected90Config,
441 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
442
443 lr.desiredRefreshRate = Fps(30.0f);
444 EXPECT_EQ(mExpected90Config,
445 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
446
447 lr.desiredRefreshRate = Fps(24.0f);
448 EXPECT_EQ(mExpected90Config,
449 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
450
451 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
452 {HWC_CONFIG_ID_60, {Fps(0.0f), Fps(120.0f)}}),
453 0);
454 lr.vote = LayerVoteType::Min;
455 EXPECT_EQ(mExpected60Config,
456 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
457
458 lr.vote = LayerVoteType::Max;
459 EXPECT_EQ(mExpected90Config,
460 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
461
462 lr.desiredRefreshRate = Fps(90.0f);
463 lr.vote = LayerVoteType::Heuristic;
464 EXPECT_EQ(mExpected90Config,
465 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
466
467 lr.desiredRefreshRate = Fps(60.0f);
468 EXPECT_EQ(mExpected60Config,
469 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
470
471 lr.desiredRefreshRate = Fps(45.0f);
472 EXPECT_EQ(mExpected90Config,
473 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
474
475 lr.desiredRefreshRate = Fps(30.0f);
476 EXPECT_EQ(mExpected60Config,
477 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
478
479 lr.desiredRefreshRate = Fps(24.0f);
480 EXPECT_EQ(mExpected60Config,
481 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
482 }
483
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_multipleThreshold_60_90)484 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_multipleThreshold_60_90) {
485 RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 90};
486 auto refreshRateConfigs =
487 std::make_unique<RefreshRateConfigs>(m60_90Device,
488 /*currentConfigId=*/HWC_CONFIG_ID_60, config);
489
490 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
491 auto& lr = layers[0];
492
493 lr.vote = LayerVoteType::Min;
494 lr.name = "Min";
495 EXPECT_EQ(mExpected60Config,
496 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
497
498 lr.vote = LayerVoteType::Max;
499 lr.name = "Max";
500 EXPECT_EQ(mExpected90Config,
501 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
502
503 lr.desiredRefreshRate = Fps(90.0f);
504 lr.vote = LayerVoteType::Heuristic;
505 lr.name = "90Hz Heuristic";
506 EXPECT_EQ(mExpected90Config,
507 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
508
509 lr.desiredRefreshRate = Fps(60.0f);
510 lr.name = "60Hz Heuristic";
511 EXPECT_EQ(mExpected60Config,
512 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
513
514 lr.desiredRefreshRate = Fps(45.0f);
515 lr.name = "45Hz Heuristic";
516 EXPECT_EQ(mExpected90Config,
517 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
518
519 lr.desiredRefreshRate = Fps(30.0f);
520 lr.name = "30Hz Heuristic";
521 EXPECT_EQ(mExpected60Config,
522 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
523
524 lr.desiredRefreshRate = Fps(24.0f);
525 lr.name = "24Hz Heuristic";
526 EXPECT_EQ(mExpected60Config,
527 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
528 }
529
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_60_72_90)530 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) {
531 auto refreshRateConfigs =
532 std::make_unique<RefreshRateConfigs>(m60_72_90Device,
533 /*currentConfigId=*/HWC_CONFIG_ID_60);
534
535 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
536 auto& lr = layers[0];
537
538 lr.vote = LayerVoteType::Min;
539 EXPECT_EQ(mExpected60Config,
540 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
541
542 lr.vote = LayerVoteType::Max;
543 EXPECT_EQ(mExpected90Config,
544 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
545
546 lr.desiredRefreshRate = Fps(90.0f);
547 lr.vote = LayerVoteType::Heuristic;
548 EXPECT_EQ(mExpected90Config,
549 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
550
551 lr.desiredRefreshRate = Fps(60.0f);
552 EXPECT_EQ(mExpected60Config,
553 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
554
555 lr.desiredRefreshRate = Fps(45.0f);
556 EXPECT_EQ(mExpected90Config,
557 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
558
559 lr.desiredRefreshRate = Fps(30.0f);
560 EXPECT_EQ(mExpected60Config,
561 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
562
563 lr.desiredRefreshRate = Fps(24.0f);
564 EXPECT_EQ(mExpected72Config,
565 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
566 }
567
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_30_60_72_90_120)568 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90_120) {
569 auto refreshRateConfigs =
570 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
571 /*currentConfigId=*/HWC_CONFIG_ID_60);
572
573 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
574 LayerRequirement{.weight = 1.0f}};
575 auto& lr1 = layers[0];
576 auto& lr2 = layers[1];
577
578 lr1.desiredRefreshRate = Fps(24.0f);
579 lr1.vote = LayerVoteType::Heuristic;
580 lr2.desiredRefreshRate = Fps(60.0f);
581 lr2.vote = LayerVoteType::Heuristic;
582 EXPECT_EQ(mExpected120Config,
583 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
584
585 lr1.desiredRefreshRate = Fps(24.0f);
586 lr1.vote = LayerVoteType::Heuristic;
587 lr2.desiredRefreshRate = Fps(48.0f);
588 lr2.vote = LayerVoteType::Heuristic;
589 EXPECT_EQ(mExpected72Config,
590 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
591
592 lr1.desiredRefreshRate = Fps(24.0f);
593 lr1.vote = LayerVoteType::Heuristic;
594 lr2.desiredRefreshRate = Fps(48.0f);
595 lr2.vote = LayerVoteType::Heuristic;
596 EXPECT_EQ(mExpected72Config,
597 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
598 }
599
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_30_60_90_120_DifferentTypes)600 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes) {
601 auto refreshRateConfigs =
602 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
603 /*currentConfigId=*/HWC_CONFIG_ID_60);
604
605 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
606 LayerRequirement{.weight = 1.0f}};
607 auto& lr1 = layers[0];
608 auto& lr2 = layers[1];
609
610 lr1.desiredRefreshRate = Fps(24.0f);
611 lr1.vote = LayerVoteType::ExplicitDefault;
612 lr1.name = "24Hz ExplicitDefault";
613 lr2.desiredRefreshRate = Fps(60.0f);
614 lr2.vote = LayerVoteType::Heuristic;
615 lr2.name = "60Hz Heuristic";
616 EXPECT_EQ(mExpected120Config,
617 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
618
619 lr1.desiredRefreshRate = Fps(24.0f);
620 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
621 lr1.name = "24Hz ExplicitExactOrMultiple";
622 lr2.desiredRefreshRate = Fps(60.0f);
623 lr2.vote = LayerVoteType::Heuristic;
624 lr2.name = "60Hz Heuristic";
625 EXPECT_EQ(mExpected120Config,
626 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
627
628 lr1.desiredRefreshRate = Fps(24.0f);
629 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
630 lr1.name = "24Hz ExplicitExactOrMultiple";
631 lr2.desiredRefreshRate = Fps(60.0f);
632 lr2.vote = LayerVoteType::ExplicitDefault;
633 lr2.name = "60Hz ExplicitDefault";
634 EXPECT_EQ(mExpected120Config,
635 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
636
637 lr1.desiredRefreshRate = Fps(24.0f);
638 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
639 lr1.name = "24Hz ExplicitExactOrMultiple";
640 lr2.desiredRefreshRate = Fps(90.0f);
641 lr2.vote = LayerVoteType::Heuristic;
642 lr2.name = "90Hz Heuristic";
643 EXPECT_EQ(mExpected90Config,
644 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
645
646 lr1.desiredRefreshRate = Fps(24.0f);
647 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
648 lr1.name = "24Hz ExplicitExactOrMultiple";
649 lr2.desiredRefreshRate = Fps(90.0f);
650 lr2.vote = LayerVoteType::ExplicitDefault;
651 lr2.name = "90Hz Heuristic";
652 EXPECT_EQ(mExpected72Config,
653 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
654
655 lr1.desiredRefreshRate = Fps(24.0f);
656 lr1.vote = LayerVoteType::ExplicitDefault;
657 lr1.name = "24Hz ExplicitDefault";
658 lr2.desiredRefreshRate = Fps(90.0f);
659 lr2.vote = LayerVoteType::Heuristic;
660 lr2.name = "90Hz Heuristic";
661 EXPECT_EQ(mExpected90Config,
662 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
663
664 lr1.desiredRefreshRate = Fps(24.0f);
665 lr1.vote = LayerVoteType::Heuristic;
666 lr1.name = "24Hz Heuristic";
667 lr2.desiredRefreshRate = Fps(90.0f);
668 lr2.vote = LayerVoteType::ExplicitDefault;
669 lr2.name = "90Hz ExplicitDefault";
670 EXPECT_EQ(mExpected72Config,
671 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
672
673 lr1.desiredRefreshRate = Fps(24.0f);
674 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
675 lr1.name = "24Hz ExplicitExactOrMultiple";
676 lr2.desiredRefreshRate = Fps(90.0f);
677 lr2.vote = LayerVoteType::ExplicitDefault;
678 lr2.name = "90Hz ExplicitDefault";
679 EXPECT_EQ(mExpected72Config,
680 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
681
682 lr1.desiredRefreshRate = Fps(24.0f);
683 lr1.vote = LayerVoteType::ExplicitDefault;
684 lr1.name = "24Hz ExplicitDefault";
685 lr2.desiredRefreshRate = Fps(90.0f);
686 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
687 lr2.name = "90Hz ExplicitExactOrMultiple";
688 EXPECT_EQ(mExpected90Config,
689 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
690 }
691
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_30_60_90_120_DifferentTypes_multipleThreshold)692 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes_multipleThreshold) {
693 RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 120};
694 auto refreshRateConfigs =
695 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
696 /*currentConfigId=*/HWC_CONFIG_ID_60, config);
697
698 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
699 LayerRequirement{.weight = 1.0f}};
700 auto& lr1 = layers[0];
701 auto& lr2 = layers[1];
702
703 lr1.desiredRefreshRate = Fps(24.0f);
704 lr1.vote = LayerVoteType::ExplicitDefault;
705 lr1.name = "24Hz ExplicitDefault";
706 lr2.desiredRefreshRate = Fps(60.0f);
707 lr2.vote = LayerVoteType::Heuristic;
708 lr2.name = "60Hz Heuristic";
709 EXPECT_EQ(mExpected120Config,
710 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
711
712 lr1.desiredRefreshRate = Fps(24.0f);
713 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
714 lr1.name = "24Hz ExplicitExactOrMultiple";
715 lr2.desiredRefreshRate = Fps(60.0f);
716 lr2.vote = LayerVoteType::Heuristic;
717 lr2.name = "60Hz Heuristic";
718 EXPECT_EQ(mExpected60Config,
719 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
720
721 lr1.desiredRefreshRate = Fps(24.0f);
722 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
723 lr1.name = "24Hz ExplicitExactOrMultiple";
724 lr2.desiredRefreshRate = Fps(60.0f);
725 lr2.vote = LayerVoteType::ExplicitDefault;
726 lr2.name = "60Hz ExplicitDefault";
727 EXPECT_EQ(mExpected72Config,
728 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
729
730 lr1.desiredRefreshRate = Fps(24.0f);
731 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
732 lr1.name = "24Hz ExplicitExactOrMultiple";
733 lr2.desiredRefreshRate = Fps(90.0f);
734 lr2.vote = LayerVoteType::Heuristic;
735 lr2.name = "90Hz Heuristic";
736 EXPECT_EQ(mExpected90Config,
737 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
738
739 lr1.desiredRefreshRate = Fps(24.0f);
740 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
741 lr1.name = "24Hz ExplicitExactOrMultiple";
742 lr2.desiredRefreshRate = Fps(90.0f);
743 lr2.vote = LayerVoteType::ExplicitDefault;
744 lr2.name = "90Hz Heuristic";
745 EXPECT_EQ(mExpected72Config,
746 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
747
748 lr1.desiredRefreshRate = Fps(24.0f);
749 lr1.vote = LayerVoteType::ExplicitDefault;
750 lr1.name = "24Hz ExplicitDefault";
751 lr2.desiredRefreshRate = Fps(90.0f);
752 lr2.vote = LayerVoteType::Heuristic;
753 lr2.name = "90Hz Heuristic";
754 EXPECT_EQ(mExpected90Config,
755 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
756
757 lr1.desiredRefreshRate = Fps(24.0f);
758 lr1.vote = LayerVoteType::Heuristic;
759 lr1.name = "24Hz Heuristic";
760 lr2.desiredRefreshRate = Fps(90.0f);
761 lr2.vote = LayerVoteType::ExplicitDefault;
762 lr2.name = "90Hz ExplicitDefault";
763 EXPECT_EQ(mExpected72Config,
764 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
765
766 lr1.desiredRefreshRate = Fps(24.0f);
767 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
768 lr1.name = "24Hz ExplicitExactOrMultiple";
769 lr2.desiredRefreshRate = Fps(90.0f);
770 lr2.vote = LayerVoteType::ExplicitDefault;
771 lr2.name = "90Hz ExplicitDefault";
772 EXPECT_EQ(mExpected72Config,
773 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
774
775 lr1.desiredRefreshRate = Fps(24.0f);
776 lr1.vote = LayerVoteType::ExplicitDefault;
777 lr1.name = "24Hz ExplicitDefault";
778 lr2.desiredRefreshRate = Fps(90.0f);
779 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
780 lr2.name = "90Hz ExplicitExactOrMultiple";
781 EXPECT_EQ(mExpected90Config,
782 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
783 }
784
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_30_60)785 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) {
786 auto refreshRateConfigs =
787 std::make_unique<RefreshRateConfigs>(m30_60Device,
788 /*currentConfigId=*/HWC_CONFIG_ID_60);
789
790 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
791 auto& lr = layers[0];
792
793 lr.vote = LayerVoteType::Min;
794 EXPECT_EQ(mExpected30Config,
795 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
796
797 lr.vote = LayerVoteType::Max;
798 EXPECT_EQ(mExpected60Config,
799 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
800
801 lr.desiredRefreshRate = Fps(90.0f);
802 lr.vote = LayerVoteType::Heuristic;
803 EXPECT_EQ(mExpected60Config,
804 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
805
806 lr.desiredRefreshRate = Fps(60.0f);
807 EXPECT_EQ(mExpected60Config,
808 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
809
810 lr.desiredRefreshRate = Fps(45.0f);
811 EXPECT_EQ(mExpected60Config,
812 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
813
814 lr.desiredRefreshRate = Fps(30.0f);
815 EXPECT_EQ(mExpected30Config,
816 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
817
818 lr.desiredRefreshRate = Fps(24.0f);
819 EXPECT_EQ(mExpected60Config,
820 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
821 }
822
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_30_60_72_90)823 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90) {
824 auto refreshRateConfigs =
825 std::make_unique<RefreshRateConfigs>(m30_60_72_90Device,
826 /*currentConfigId=*/HWC_CONFIG_ID_60);
827
828 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
829 auto& lr = layers[0];
830
831 lr.vote = LayerVoteType::Min;
832 lr.name = "Min";
833 EXPECT_EQ(mExpected30Config,
834 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
835
836 lr.vote = LayerVoteType::Max;
837 lr.name = "Max";
838 EXPECT_EQ(mExpected90Config,
839 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
840
841 lr.desiredRefreshRate = Fps(90.0f);
842 lr.vote = LayerVoteType::Heuristic;
843 lr.name = "90Hz Heuristic";
844 EXPECT_EQ(mExpected90Config,
845 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
846
847 lr.desiredRefreshRate = Fps(60.0f);
848 lr.name = "60Hz Heuristic";
849 EXPECT_EQ(mExpected60Config,
850 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
851 EXPECT_EQ(mExpected90Config,
852 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
853
854 lr.desiredRefreshRate = Fps(45.0f);
855 lr.name = "45Hz Heuristic";
856 EXPECT_EQ(mExpected90Config,
857 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
858 EXPECT_EQ(mExpected90Config,
859 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
860
861 lr.desiredRefreshRate = Fps(30.0f);
862 lr.name = "30Hz Heuristic";
863 EXPECT_EQ(mExpected30Config,
864 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
865 EXPECT_EQ(mExpected90Config,
866 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
867
868 lr.desiredRefreshRate = Fps(24.0f);
869 lr.name = "24Hz Heuristic";
870 EXPECT_EQ(mExpected72Config,
871 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
872 EXPECT_EQ(mExpected90Config,
873 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
874
875 lr.desiredRefreshRate = Fps(24.0f);
876 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
877 lr.name = "24Hz ExplicitExactOrMultiple";
878 EXPECT_EQ(mExpected72Config,
879 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
880 EXPECT_EQ(mExpected90Config,
881 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
882 }
883
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_PriorityTest)884 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_PriorityTest) {
885 auto refreshRateConfigs =
886 std::make_unique<RefreshRateConfigs>(m30_60_90Device,
887 /*currentConfigId=*/HWC_CONFIG_ID_60);
888
889 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
890 LayerRequirement{.weight = 1.0f}};
891 auto& lr1 = layers[0];
892 auto& lr2 = layers[1];
893
894 lr1.vote = LayerVoteType::Min;
895 lr2.vote = LayerVoteType::Max;
896 EXPECT_EQ(mExpected90Config,
897 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
898
899 lr1.vote = LayerVoteType::Min;
900 lr2.vote = LayerVoteType::Heuristic;
901 lr2.desiredRefreshRate = Fps(24.0f);
902 EXPECT_EQ(mExpected60Config,
903 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
904
905 lr1.vote = LayerVoteType::Min;
906 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
907 lr2.desiredRefreshRate = Fps(24.0f);
908 EXPECT_EQ(mExpected60Config,
909 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
910
911 lr1.vote = LayerVoteType::Max;
912 lr2.vote = LayerVoteType::Heuristic;
913 lr2.desiredRefreshRate = Fps(60.0f);
914 EXPECT_EQ(mExpected90Config,
915 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
916
917 lr1.vote = LayerVoteType::Max;
918 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
919 lr2.desiredRefreshRate = Fps(60.0f);
920 EXPECT_EQ(mExpected90Config,
921 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
922
923 lr1.vote = LayerVoteType::Heuristic;
924 lr1.desiredRefreshRate = Fps(15.0f);
925 lr2.vote = LayerVoteType::Heuristic;
926 lr2.desiredRefreshRate = Fps(45.0f);
927 EXPECT_EQ(mExpected90Config,
928 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
929
930 lr1.vote = LayerVoteType::Heuristic;
931 lr1.desiredRefreshRate = Fps(30.0f);
932 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
933 lr2.desiredRefreshRate = Fps(45.0f);
934 EXPECT_EQ(mExpected90Config,
935 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
936 }
937
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_24FpsVideo)938 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo) {
939 auto refreshRateConfigs =
940 std::make_unique<RefreshRateConfigs>(m60_90Device,
941 /*currentConfigId=*/HWC_CONFIG_ID_60);
942
943 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
944 auto& lr = layers[0];
945
946 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
947 for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
948 lr.desiredRefreshRate = Fps(fps);
949 const auto& refreshRate =
950 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false});
951 EXPECT_EQ(mExpected60Config, refreshRate) << fps << "Hz chooses " << refreshRate.getName();
952 }
953 }
954
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_24FpsVideo_multipleThreshold_60_120)955 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo_multipleThreshold_60_120) {
956 RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 120};
957 auto refreshRateConfigs =
958 std::make_unique<RefreshRateConfigs>(m60_120Device,
959 /*currentConfigId=*/HWC_CONFIG_ID_60, config);
960
961 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
962 auto& lr = layers[0];
963
964 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
965 for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) {
966 lr.desiredRefreshRate = Fps(fps);
967 const auto& refreshRate =
968 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false});
969 EXPECT_EQ(mExpected60Config, refreshRate) << fps << "Hz chooses " << refreshRate.getName();
970 }
971 }
972
TEST_F(RefreshRateConfigsTest,twoDeviceConfigs_getBestRefreshRate_Explicit)973 TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getBestRefreshRate_Explicit) {
974 auto refreshRateConfigs =
975 std::make_unique<RefreshRateConfigs>(m60_90Device,
976 /*currentConfigId=*/HWC_CONFIG_ID_60);
977
978 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
979 LayerRequirement{.weight = 1.0f}};
980 auto& lr1 = layers[0];
981 auto& lr2 = layers[1];
982
983 lr1.vote = LayerVoteType::Heuristic;
984 lr1.desiredRefreshRate = Fps(60.0f);
985 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
986 lr2.desiredRefreshRate = Fps(90.0f);
987 EXPECT_EQ(mExpected90Config,
988 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
989
990 lr1.vote = LayerVoteType::ExplicitDefault;
991 lr1.desiredRefreshRate = Fps(90.0f);
992 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
993 lr2.desiredRefreshRate = Fps(60.0f);
994 EXPECT_EQ(mExpected60Config,
995 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
996
997 lr1.vote = LayerVoteType::Heuristic;
998 lr1.desiredRefreshRate = Fps(90.0f);
999 lr2.vote = LayerVoteType::ExplicitExactOrMultiple;
1000 lr2.desiredRefreshRate = Fps(60.0f);
1001 EXPECT_EQ(mExpected90Config,
1002 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1003 }
1004
TEST_F(RefreshRateConfigsTest,testInPolicy)1005 TEST_F(RefreshRateConfigsTest, testInPolicy) {
1006 ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(Fps(60.000004f), Fps(60.000004f)));
1007 ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(Fps(59.0f), Fps(60.1f)));
1008 ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(Fps(75.0f), Fps(90.0f)));
1009 ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(Fps(60.0011f), Fps(90.0f)));
1010 ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(Fps(50.0f), Fps(59.998f)));
1011 }
1012
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_75HzContent)1013 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_75HzContent) {
1014 auto refreshRateConfigs =
1015 std::make_unique<RefreshRateConfigs>(m60_90Device,
1016 /*currentConfigId=*/HWC_CONFIG_ID_60);
1017
1018 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1019 auto& lr = layers[0];
1020
1021 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
1022 for (float fps = 75.0f; fps < 100.0f; fps += 0.1f) {
1023 lr.desiredRefreshRate = Fps(fps);
1024 const auto& refreshRate =
1025 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false});
1026 EXPECT_EQ(mExpected90Config, refreshRate) << fps << "Hz chooses " << refreshRate.getName();
1027 }
1028 }
1029
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_Multiples)1030 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_Multiples) {
1031 auto refreshRateConfigs =
1032 std::make_unique<RefreshRateConfigs>(m60_90Device,
1033 /*currentConfigId=*/HWC_CONFIG_ID_60);
1034
1035 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
1036 LayerRequirement{.weight = 1.0f}};
1037 auto& lr1 = layers[0];
1038 auto& lr2 = layers[1];
1039
1040 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1041 lr1.desiredRefreshRate = Fps(60.0f);
1042 lr1.name = "60Hz ExplicitExactOrMultiple";
1043 lr2.vote = LayerVoteType::Heuristic;
1044 lr2.desiredRefreshRate = Fps(90.0f);
1045 lr2.name = "90Hz Heuristic";
1046 EXPECT_EQ(mExpected90Config,
1047 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1048
1049 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1050 lr1.desiredRefreshRate = Fps(60.0f);
1051 lr1.name = "60Hz ExplicitExactOrMultiple";
1052 lr2.vote = LayerVoteType::ExplicitDefault;
1053 lr2.desiredRefreshRate = Fps(90.0f);
1054 lr2.name = "90Hz ExplicitDefault";
1055 EXPECT_EQ(mExpected60Config,
1056 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1057
1058 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1059 lr1.desiredRefreshRate = Fps(60.0f);
1060 lr1.name = "60Hz ExplicitExactOrMultiple";
1061 lr2.vote = LayerVoteType::Max;
1062 lr2.name = "Max";
1063 EXPECT_EQ(mExpected90Config,
1064 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1065
1066 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1067 lr1.desiredRefreshRate = Fps(30.0f);
1068 lr1.name = "30Hz ExplicitExactOrMultiple";
1069 lr2.vote = LayerVoteType::Heuristic;
1070 lr2.desiredRefreshRate = Fps(90.0f);
1071 lr2.name = "90Hz Heuristic";
1072 EXPECT_EQ(mExpected90Config,
1073 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1074
1075 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1076 lr1.desiredRefreshRate = Fps(30.0f);
1077 lr1.name = "30Hz ExplicitExactOrMultiple";
1078 lr2.vote = LayerVoteType::Max;
1079 lr2.name = "Max";
1080 EXPECT_EQ(mExpected90Config,
1081 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1082 }
1083
TEST_F(RefreshRateConfigsTest,scrollWhileWatching60fps_60_90)1084 TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) {
1085 auto refreshRateConfigs =
1086 std::make_unique<RefreshRateConfigs>(m60_90Device,
1087 /*currentConfigId=*/HWC_CONFIG_ID_60);
1088
1089 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
1090 LayerRequirement{.weight = 1.0f}};
1091 auto& lr1 = layers[0];
1092 auto& lr2 = layers[1];
1093
1094 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1095 lr1.desiredRefreshRate = Fps(60.0f);
1096 lr1.name = "60Hz ExplicitExactOrMultiple";
1097 lr2.vote = LayerVoteType::NoVote;
1098 lr2.name = "NoVote";
1099 EXPECT_EQ(mExpected60Config,
1100 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1101
1102 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1103 lr1.desiredRefreshRate = Fps(60.0f);
1104 lr1.name = "60Hz ExplicitExactOrMultiple";
1105 lr2.vote = LayerVoteType::NoVote;
1106 lr2.name = "NoVote";
1107 EXPECT_EQ(mExpected90Config,
1108 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
1109
1110 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1111 lr1.desiredRefreshRate = Fps(60.0f);
1112 lr1.name = "60Hz ExplicitExactOrMultiple";
1113 lr2.vote = LayerVoteType::Max;
1114 lr2.name = "Max";
1115 EXPECT_EQ(mExpected90Config,
1116 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
1117
1118 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1119 lr1.desiredRefreshRate = Fps(60.0f);
1120 lr1.name = "60Hz ExplicitExactOrMultiple";
1121 lr2.vote = LayerVoteType::Max;
1122 lr2.name = "Max";
1123 EXPECT_EQ(mExpected90Config,
1124 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1125
1126 // The other layer starts to provide buffers
1127 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1128 lr1.desiredRefreshRate = Fps(60.0f);
1129 lr1.name = "60Hz ExplicitExactOrMultiple";
1130 lr2.vote = LayerVoteType::Heuristic;
1131 lr2.desiredRefreshRate = Fps(90.0f);
1132 lr2.name = "90Hz Heuristic";
1133 EXPECT_EQ(mExpected90Config,
1134 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1135 }
1136
TEST_F(RefreshRateConfigsTest,touchConsidered)1137 TEST_F(RefreshRateConfigsTest, touchConsidered) {
1138 RefreshRateConfigs::GlobalSignals consideredSignals;
1139 auto refreshRateConfigs =
1140 std::make_unique<RefreshRateConfigs>(m60_90Device,
1141 /*currentConfigId=*/HWC_CONFIG_ID_60);
1142
1143 refreshRateConfigs->getBestRefreshRate({}, {.touch = false, .idle = false}, &consideredSignals);
1144 EXPECT_EQ(false, consideredSignals.touch);
1145
1146 refreshRateConfigs->getBestRefreshRate({}, {.touch = true, .idle = false}, &consideredSignals);
1147 EXPECT_EQ(true, consideredSignals.touch);
1148
1149 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
1150 LayerRequirement{.weight = 1.0f}};
1151 auto& lr1 = layers[0];
1152 auto& lr2 = layers[1];
1153
1154 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1155 lr1.desiredRefreshRate = Fps(60.0f);
1156 lr1.name = "60Hz ExplicitExactOrMultiple";
1157 lr2.vote = LayerVoteType::Heuristic;
1158 lr2.desiredRefreshRate = Fps(60.0f);
1159 lr2.name = "60Hz Heuristic";
1160 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false},
1161 &consideredSignals);
1162 EXPECT_EQ(true, consideredSignals.touch);
1163
1164 lr1.vote = LayerVoteType::ExplicitDefault;
1165 lr1.desiredRefreshRate = Fps(60.0f);
1166 lr1.name = "60Hz ExplicitExactOrMultiple";
1167 lr2.vote = LayerVoteType::Heuristic;
1168 lr2.desiredRefreshRate = Fps(60.0f);
1169 lr2.name = "60Hz Heuristic";
1170 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false},
1171 &consideredSignals);
1172 EXPECT_EQ(false, consideredSignals.touch);
1173
1174 lr1.vote = LayerVoteType::ExplicitExactOrMultiple;
1175 lr1.desiredRefreshRate = Fps(60.0f);
1176 lr1.name = "60Hz ExplicitExactOrMultiple";
1177 lr2.vote = LayerVoteType::Heuristic;
1178 lr2.desiredRefreshRate = Fps(60.0f);
1179 lr2.name = "60Hz Heuristic";
1180 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false},
1181 &consideredSignals);
1182 EXPECT_EQ(true, consideredSignals.touch);
1183
1184 lr1.vote = LayerVoteType::ExplicitDefault;
1185 lr1.desiredRefreshRate = Fps(60.0f);
1186 lr1.name = "60Hz ExplicitExactOrMultiple";
1187 lr2.vote = LayerVoteType::Heuristic;
1188 lr2.desiredRefreshRate = Fps(60.0f);
1189 lr2.name = "60Hz Heuristic";
1190 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false},
1191 &consideredSignals);
1192 EXPECT_EQ(false, consideredSignals.touch);
1193 }
1194
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_ExplicitDefault)1195 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitDefault) {
1196 auto refreshRateConfigs =
1197 std::make_unique<RefreshRateConfigs>(m60_90_72_120Device, /*currentConfigId=*/
1198 HWC_CONFIG_ID_60);
1199
1200 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1201 auto& lr = layers[0];
1202
1203 // Prepare a table with the vote and the expected refresh rate
1204 const std::vector<std::pair<float, float>> testCases = {
1205 {130, 120}, {120, 120}, {119, 120}, {110, 120},
1206
1207 {100, 90}, {90, 90}, {89, 90},
1208
1209 {80, 72}, {73, 72}, {72, 72}, {71, 72}, {70, 72},
1210
1211 {65, 60}, {60, 60}, {59, 60}, {58, 60},
1212
1213 {55, 90}, {50, 90}, {45, 90},
1214
1215 {42, 120}, {40, 120}, {39, 120},
1216
1217 {37, 72}, {36, 72}, {35, 72},
1218
1219 {30, 60},
1220 };
1221
1222 for (const auto& test : testCases) {
1223 lr.vote = LayerVoteType::ExplicitDefault;
1224 lr.desiredRefreshRate = Fps(test.first);
1225
1226 std::stringstream ss;
1227 ss << "ExplicitDefault " << test.first << " fps";
1228 lr.name = ss.str();
1229
1230 const auto& refreshRate =
1231 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false});
1232 EXPECT_TRUE(refreshRate.getFps().equalsWithMargin(Fps(test.second)))
1233 << "Expecting " << test.first << "fps => " << test.second << "Hz";
1234 }
1235 }
1236
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresTouchFlag)1237 TEST_F(RefreshRateConfigsTest,
1238 getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresTouchFlag) {
1239 auto refreshRateConfigs =
1240 std::make_unique<RefreshRateConfigs>(m60_90Device,
1241 /*currentConfigId=*/HWC_CONFIG_ID_90);
1242
1243 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
1244 {HWC_CONFIG_ID_90, {Fps(90.f), Fps(90.f)}, {Fps(60.f), Fps(90.f)}}),
1245 0);
1246
1247 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1248 auto& lr = layers[0];
1249
1250 RefreshRateConfigs::GlobalSignals consideredSignals;
1251 lr.vote = LayerVoteType::ExplicitDefault;
1252 lr.desiredRefreshRate = Fps(60.0f);
1253 lr.name = "60Hz ExplicitDefault";
1254 lr.focused = true;
1255 EXPECT_EQ(mExpected60Config,
1256 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = true},
1257 &consideredSignals));
1258 EXPECT_EQ(false, consideredSignals.touch);
1259 }
1260
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresIdleFlag)1261 TEST_F(RefreshRateConfigsTest,
1262 getBestRefreshRate_withDisplayManagerRequestingSingleRate_ignoresIdleFlag) {
1263 auto refreshRateConfigs =
1264 std::make_unique<RefreshRateConfigs>(m60_90Device,
1265 /*currentConfigId=*/HWC_CONFIG_ID_60);
1266
1267 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
1268 {HWC_CONFIG_ID_60, {Fps(60.f), Fps(60.f)}, {Fps(60.f), Fps(90.f)}}),
1269 0);
1270
1271 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1272 auto& lr = layers[0];
1273
1274 lr.vote = LayerVoteType::ExplicitDefault;
1275 lr.desiredRefreshRate = Fps(90.0f);
1276 lr.name = "90Hz ExplicitDefault";
1277 lr.focused = true;
1278 EXPECT_EQ(mExpected90Config,
1279 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = true}));
1280 }
1281
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_withDisplayManagerRequestingSingleRate_onlySwitchesRatesForExplicitFocusedLayers)1282 TEST_F(RefreshRateConfigsTest,
1283 getBestRefreshRate_withDisplayManagerRequestingSingleRate_onlySwitchesRatesForExplicitFocusedLayers) {
1284 auto refreshRateConfigs =
1285 std::make_unique<RefreshRateConfigs>(m60_90Device,
1286 /*currentConfigId=*/HWC_CONFIG_ID_90);
1287
1288 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
1289 {HWC_CONFIG_ID_90, {Fps(90.f), Fps(90.f)}, {Fps(60.f), Fps(90.f)}}),
1290 0);
1291
1292 RefreshRateConfigs::GlobalSignals consideredSignals;
1293 EXPECT_EQ(mExpected90Config,
1294 refreshRateConfigs->getBestRefreshRate({}, {.touch = false, .idle = false},
1295 &consideredSignals));
1296 EXPECT_EQ(false, consideredSignals.touch);
1297
1298 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1299 auto& lr = layers[0];
1300
1301 lr.vote = LayerVoteType::ExplicitExactOrMultiple;
1302 lr.desiredRefreshRate = Fps(60.0f);
1303 lr.name = "60Hz ExplicitExactOrMultiple";
1304 lr.focused = false;
1305 EXPECT_EQ(mExpected90Config,
1306 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1307
1308 lr.focused = true;
1309 EXPECT_EQ(mExpected90Config,
1310 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1311
1312 lr.vote = LayerVoteType::ExplicitDefault;
1313 lr.desiredRefreshRate = Fps(60.0f);
1314 lr.name = "60Hz ExplicitDefault";
1315 lr.focused = false;
1316 EXPECT_EQ(mExpected90Config,
1317 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1318
1319 lr.focused = true;
1320 EXPECT_EQ(mExpected60Config,
1321 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1322
1323 lr.vote = LayerVoteType::Heuristic;
1324 lr.desiredRefreshRate = Fps(60.0f);
1325 lr.name = "60Hz Heuristic";
1326 lr.focused = false;
1327 EXPECT_EQ(mExpected90Config,
1328 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1329
1330 lr.focused = true;
1331 EXPECT_EQ(mExpected90Config,
1332 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1333
1334 lr.vote = LayerVoteType::Max;
1335 lr.desiredRefreshRate = Fps(60.0f);
1336 lr.name = "60Hz Max";
1337 lr.focused = false;
1338 EXPECT_EQ(mExpected90Config,
1339 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1340
1341 lr.focused = true;
1342 EXPECT_EQ(mExpected90Config,
1343 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1344
1345 lr.vote = LayerVoteType::Min;
1346 lr.desiredRefreshRate = Fps(60.0f);
1347 lr.name = "60Hz Min";
1348 lr.focused = false;
1349 EXPECT_EQ(mExpected90Config,
1350 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1351
1352 lr.focused = true;
1353 EXPECT_EQ(mExpected90Config,
1354 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1355 }
1356
TEST_F(RefreshRateConfigsTest,groupSwitchingNotAllowed)1357 TEST_F(RefreshRateConfigsTest, groupSwitchingNotAllowed) {
1358 auto refreshRateConfigs =
1359 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1360 /*currentConfigId=*/HWC_CONFIG_ID_60);
1361
1362 // The default policy doesn't allow group switching. Verify that no
1363 // group switches are performed.
1364 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1365 auto& layer = layers[0];
1366 layer.vote = LayerVoteType::ExplicitDefault;
1367 layer.desiredRefreshRate = Fps(90.0f);
1368 layer.seamlessness = Seamlessness::SeamedAndSeamless;
1369 layer.name = "90Hz ExplicitDefault";
1370 layer.focused = true;
1371
1372 ASSERT_EQ(HWC_CONFIG_ID_60,
1373 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1374 .getModeId());
1375 }
1376
TEST_F(RefreshRateConfigsTest,groupSwitchingWithOneLayer)1377 TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayer) {
1378 auto refreshRateConfigs =
1379 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1380 /*currentConfigId=*/HWC_CONFIG_ID_60);
1381 RefreshRateConfigs::Policy policy;
1382 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1383 policy.allowGroupSwitching = true;
1384 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1385
1386 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1387 auto& layer = layers[0];
1388 layer.vote = LayerVoteType::ExplicitDefault;
1389 layer.desiredRefreshRate = Fps(90.0f);
1390 layer.seamlessness = Seamlessness::SeamedAndSeamless;
1391 layer.name = "90Hz ExplicitDefault";
1392 layer.focused = true;
1393 ASSERT_EQ(HWC_CONFIG_ID_90,
1394 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1395 .getModeId());
1396 }
1397
TEST_F(RefreshRateConfigsTest,groupSwitchingWithOneLayerOnlySeamless)1398 TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamless) {
1399 auto refreshRateConfigs =
1400 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1401 /*currentConfigId=*/HWC_CONFIG_ID_60);
1402 RefreshRateConfigs::Policy policy;
1403 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1404 policy.allowGroupSwitching = true;
1405 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1406
1407 // Verify that we won't change the group if seamless switch is required.
1408 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1409 auto& layer = layers[0];
1410 layer.vote = LayerVoteType::ExplicitDefault;
1411 layer.desiredRefreshRate = Fps(90.0f);
1412 layer.seamlessness = Seamlessness::OnlySeamless;
1413 layer.name = "90Hz ExplicitDefault";
1414 layer.focused = true;
1415 ASSERT_EQ(HWC_CONFIG_ID_60,
1416 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1417 .getModeId());
1418 }
1419
TEST_F(RefreshRateConfigsTest,groupSwitchingWithOneLayerOnlySeamlessDefaultFps)1420 TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamlessDefaultFps) {
1421 auto refreshRateConfigs =
1422 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1423 /*currentConfigId=*/HWC_CONFIG_ID_60);
1424 RefreshRateConfigs::Policy policy;
1425 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1426 policy.allowGroupSwitching = true;
1427 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1428
1429 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
1430
1431 // Verify that we won't do a seamless switch if we request the same mode as the default
1432 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1433 auto& layer = layers[0];
1434 layer.vote = LayerVoteType::ExplicitDefault;
1435 layer.desiredRefreshRate = Fps(60.0f);
1436 layer.seamlessness = Seamlessness::OnlySeamless;
1437 layer.name = "60Hz ExplicitDefault";
1438 layer.focused = true;
1439 ASSERT_EQ(HWC_CONFIG_ID_90,
1440 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1441 .getModeId());
1442 }
1443
TEST_F(RefreshRateConfigsTest,groupSwitchingWithOneLayerDefaultSeamlessness)1444 TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerDefaultSeamlessness) {
1445 auto refreshRateConfigs =
1446 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1447 /*currentConfigId=*/HWC_CONFIG_ID_60);
1448 RefreshRateConfigs::Policy policy;
1449 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1450 policy.allowGroupSwitching = true;
1451 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1452
1453 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
1454
1455 // Verify that if the current config is in another group and there are no layers with
1456 // seamlessness=SeamedAndSeamless we'll go back to the default group.
1457
1458 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1459 auto& layer = layers[0];
1460 layer.vote = LayerVoteType::ExplicitDefault;
1461 layer.desiredRefreshRate = Fps(60.0f);
1462 layer.seamlessness = Seamlessness::Default;
1463 layer.name = "60Hz ExplicitDefault";
1464 layer.focused = true;
1465
1466 ASSERT_EQ(HWC_CONFIG_ID_60,
1467 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1468 .getModeId());
1469 }
1470
TEST_F(RefreshRateConfigsTest,groupSwitchingWithTwoLayersOnlySeamlessAndSeamed)1471 TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersOnlySeamlessAndSeamed) {
1472 auto refreshRateConfigs =
1473 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1474 /*currentConfigId=*/HWC_CONFIG_ID_60);
1475 RefreshRateConfigs::Policy policy;
1476 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1477 policy.allowGroupSwitching = true;
1478 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1479
1480 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
1481
1482 // If there's a layer with seamlessness=SeamedAndSeamless, another layer with
1483 // seamlessness=OnlySeamless can't change the mode group.
1484 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1485 layers[0].vote = LayerVoteType::ExplicitDefault;
1486 layers[0].desiredRefreshRate = Fps(60.0f);
1487 layers[0].seamlessness = Seamlessness::OnlySeamless;
1488 layers[0].name = "60Hz ExplicitDefault";
1489 layers[0].focused = true;
1490
1491 layers.push_back(LayerRequirement{.weight = 0.5f});
1492 layers[1].vote = LayerVoteType::ExplicitDefault;
1493 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
1494 layers[1].desiredRefreshRate = Fps(90.0f);
1495 layers[1].name = "90Hz ExplicitDefault";
1496 layers[1].focused = false;
1497
1498 ASSERT_EQ(HWC_CONFIG_ID_90,
1499 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1500 .getModeId());
1501 }
1502
TEST_F(RefreshRateConfigsTest,groupSwitchingWithTwoLayersDefaultFocusedAndSeamed)1503 TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultFocusedAndSeamed) {
1504 auto refreshRateConfigs =
1505 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1506 /*currentConfigId=*/HWC_CONFIG_ID_60);
1507 RefreshRateConfigs::Policy policy;
1508 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1509 policy.allowGroupSwitching = true;
1510 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1511
1512 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
1513
1514 // If there's a focused layer with seamlessness=SeamedAndSeamless, another layer with
1515 // seamlessness=Default can't change the mode group back to the group of the default
1516 // mode.
1517 // For example, this may happen when a video playback requests and gets a seamed switch,
1518 // but another layer (with default seamlessness) starts animating. The animating layer
1519 // should not cause a seamed switch.
1520 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1521 layers[0].seamlessness = Seamlessness::Default;
1522 layers[0].desiredRefreshRate = Fps(60.0f);
1523 layers[0].focused = true;
1524 layers[0].vote = LayerVoteType::ExplicitDefault;
1525 layers[0].name = "60Hz ExplicitDefault";
1526
1527 layers.push_back(LayerRequirement{.weight = 0.1f});
1528 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
1529 layers[1].desiredRefreshRate = Fps(90.0f);
1530 layers[1].focused = true;
1531 layers[1].vote = LayerVoteType::ExplicitDefault;
1532 layers[1].name = "90Hz ExplicitDefault";
1533
1534 ASSERT_EQ(HWC_CONFIG_ID_90,
1535 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1536 .getModeId());
1537 }
1538
TEST_F(RefreshRateConfigsTest,groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed)1539 TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed) {
1540 auto refreshRateConfigs =
1541 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1542 /*currentConfigId=*/HWC_CONFIG_ID_60);
1543 RefreshRateConfigs::Policy policy;
1544 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1545 policy.allowGroupSwitching = true;
1546 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1547
1548 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
1549
1550 // Layer with seamlessness=Default can change the mode group if there's a not
1551 // focused layer with seamlessness=SeamedAndSeamless. This happens for example,
1552 // when in split screen mode the user switches between the two visible applications.
1553 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1554 layers[0].seamlessness = Seamlessness::Default;
1555 layers[0].desiredRefreshRate = Fps(60.0f);
1556 layers[0].focused = true;
1557 layers[0].vote = LayerVoteType::ExplicitDefault;
1558 layers[0].name = "60Hz ExplicitDefault";
1559
1560 layers.push_back(LayerRequirement{.weight = 0.7f});
1561 layers[1].seamlessness = Seamlessness::SeamedAndSeamless;
1562 layers[1].desiredRefreshRate = Fps(90.0f);
1563 layers[1].focused = false;
1564 layers[1].vote = LayerVoteType::ExplicitDefault;
1565 layers[1].name = "90Hz ExplicitDefault";
1566
1567 ASSERT_EQ(HWC_CONFIG_ID_60,
1568 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1569 .getModeId());
1570 }
1571
TEST_F(RefreshRateConfigsTest,nonSeamlessVotePrefersSeamlessSwitches)1572 TEST_F(RefreshRateConfigsTest, nonSeamlessVotePrefersSeamlessSwitches) {
1573 auto refreshRateConfigs =
1574 std::make_unique<RefreshRateConfigs>(m30_60Device,
1575 /*currentConfigId=*/HWC_CONFIG_ID_60);
1576
1577 // Allow group switching.
1578 RefreshRateConfigs::Policy policy;
1579 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1580 policy.allowGroupSwitching = true;
1581 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1582
1583 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1584 auto& layer = layers[0];
1585 layer.vote = LayerVoteType::ExplicitExactOrMultiple;
1586 layer.desiredRefreshRate = Fps(60.0f);
1587 layer.seamlessness = Seamlessness::SeamedAndSeamless;
1588 layer.name = "60Hz ExplicitExactOrMultiple";
1589 layer.focused = true;
1590
1591 ASSERT_EQ(HWC_CONFIG_ID_60,
1592 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1593 .getModeId());
1594
1595 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_120);
1596 ASSERT_EQ(HWC_CONFIG_ID_120,
1597 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1598 .getModeId());
1599 }
1600
TEST_F(RefreshRateConfigsTest,nonSeamlessExactAndSeamlessMultipleLayers)1601 TEST_F(RefreshRateConfigsTest, nonSeamlessExactAndSeamlessMultipleLayers) {
1602 auto refreshRateConfigs =
1603 std::make_unique<RefreshRateConfigs>(m25_30_50_60Device,
1604 /*currentConfigId=*/HWC_CONFIG_ID_60);
1605
1606 // Allow group switching.
1607 RefreshRateConfigs::Policy policy;
1608 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1609 policy.allowGroupSwitching = true;
1610 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1611
1612 auto layers = std::vector<
1613 LayerRequirement>{LayerRequirement{.name = "60Hz ExplicitDefault",
1614 .vote = LayerVoteType::ExplicitDefault,
1615 .desiredRefreshRate = Fps(60.0f),
1616 .seamlessness = Seamlessness::SeamedAndSeamless,
1617 .weight = 0.5f,
1618 .focused = false},
1619 LayerRequirement{.name = "25Hz ExplicitExactOrMultiple",
1620 .vote = LayerVoteType::ExplicitExactOrMultiple,
1621 .desiredRefreshRate = Fps(25.0f),
1622 .seamlessness = Seamlessness::OnlySeamless,
1623 .weight = 1.0f,
1624 .focused = true}};
1625
1626 ASSERT_EQ(HWC_CONFIG_ID_50,
1627 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1628 .getModeId());
1629
1630 auto& seamedLayer = layers[0];
1631 seamedLayer.name = "30Hz ExplicitDefault", seamedLayer.desiredRefreshRate = Fps(30.0f);
1632 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_30);
1633
1634 ASSERT_EQ(HWC_CONFIG_ID_25,
1635 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1636 .getModeId());
1637 }
1638
TEST_F(RefreshRateConfigsTest,minLayersDontTrigerSeamedSwitch)1639 TEST_F(RefreshRateConfigsTest, minLayersDontTrigerSeamedSwitch) {
1640 auto refreshRateConfigs =
1641 std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups,
1642 /*currentConfigId=*/HWC_CONFIG_ID_90);
1643
1644 // Allow group switching.
1645 RefreshRateConfigs::Policy policy;
1646 policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode;
1647 policy.allowGroupSwitching = true;
1648 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0);
1649
1650 auto layers = std::vector<LayerRequirement>{LayerRequirement{.name = "Min",
1651 .vote = LayerVoteType::Min,
1652 .weight = 1.f,
1653 .focused = true}};
1654
1655 ASSERT_EQ(HWC_CONFIG_ID_90,
1656 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})
1657 .getModeId());
1658 }
1659
TEST_F(RefreshRateConfigsTest,primaryVsAppRequestPolicy)1660 TEST_F(RefreshRateConfigsTest, primaryVsAppRequestPolicy) {
1661 auto refreshRateConfigs =
1662 std::make_unique<RefreshRateConfigs>(m30_60_90Device,
1663 /*currentConfigId=*/HWC_CONFIG_ID_60);
1664
1665 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1666 layers[0].name = "Test layer";
1667
1668 // Return the config ID from calling getBestRefreshRate() for a single layer with the
1669 // given voteType and fps.
1670 auto getFrameRate = [&](LayerVoteType voteType, Fps fps, bool touchActive = false,
1671 bool focused = true) -> DisplayModeId {
1672 layers[0].vote = voteType;
1673 layers[0].desiredRefreshRate = fps;
1674 layers[0].focused = focused;
1675 return refreshRateConfigs->getBestRefreshRate(layers, {.touch = touchActive, .idle = false})
1676 .getModeId();
1677 };
1678
1679 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
1680 {HWC_CONFIG_ID_60, {Fps(30.f), Fps(60.f)}, {Fps(30.f), Fps(90.f)}}),
1681 0);
1682 EXPECT_EQ(HWC_CONFIG_ID_60,
1683 refreshRateConfigs->getBestRefreshRate({}, {.touch = false, .idle = false})
1684 .getModeId());
1685 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, Fps(90.f)));
1686 EXPECT_EQ(HWC_CONFIG_ID_30, getFrameRate(LayerVoteType::Min, Fps(90.f)));
1687 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, Fps(90.f)));
1688 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, Fps(90.f)));
1689 EXPECT_EQ(HWC_CONFIG_ID_90, getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f)));
1690 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f)));
1691
1692 // Layers not focused are not allowed to override primary config
1693 EXPECT_EQ(HWC_CONFIG_ID_60,
1694 getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f), /*touch=*/false,
1695 /*focused=*/false));
1696 EXPECT_EQ(HWC_CONFIG_ID_60,
1697 getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f), /*touch=*/false,
1698 /*focused=*/false));
1699
1700 // Touch boost should be restricted to the primary range.
1701 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, Fps(90.f), /*touch=*/true));
1702 // When we're higher than the primary range max due to a layer frame rate setting, touch boost
1703 // shouldn't drag us back down to the primary range max.
1704 EXPECT_EQ(HWC_CONFIG_ID_90,
1705 getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f), /*touch=*/true));
1706 EXPECT_EQ(HWC_CONFIG_ID_60,
1707 getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f), /*touch=*/true));
1708
1709 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
1710 {HWC_CONFIG_ID_60, {Fps(60.f), Fps(60.f)}, {Fps(60.f), Fps(60.f)}}),
1711 0);
1712 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, Fps(90.f)));
1713 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Min, Fps(90.f)));
1714 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, Fps(90.f)));
1715 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, Fps(90.f)));
1716 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f)));
1717 EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f)));
1718 }
1719
TEST_F(RefreshRateConfigsTest,idle)1720 TEST_F(RefreshRateConfigsTest, idle) {
1721 auto refreshRateConfigs =
1722 std::make_unique<RefreshRateConfigs>(m60_90Device,
1723 /*currentConfigId=*/HWC_CONFIG_ID_60);
1724
1725 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1726 layers[0].name = "Test layer";
1727
1728 const auto getIdleFrameRate = [&](LayerVoteType voteType, bool touchActive) -> DisplayModeId {
1729 layers[0].vote = voteType;
1730 layers[0].desiredRefreshRate = Fps(90.f);
1731 RefreshRateConfigs::GlobalSignals consideredSignals;
1732 const auto configId =
1733 refreshRateConfigs
1734 ->getBestRefreshRate(layers, {.touch = touchActive, .idle = true},
1735 &consideredSignals)
1736 .getModeId();
1737 // Refresh rate will be chosen by either touch state or idle state
1738 EXPECT_EQ(!touchActive, consideredSignals.idle);
1739 return configId;
1740 };
1741
1742 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
1743 {HWC_CONFIG_ID_60, {Fps(60.f), Fps(90.f)}, {Fps(60.f), Fps(90.f)}}),
1744 0);
1745
1746 // Idle should be lower priority than touch boost.
1747 EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::NoVote, /*touchActive=*/true));
1748 EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::Min, /*touchActive=*/true));
1749 EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::Max, /*touchActive=*/true));
1750 EXPECT_EQ(HWC_CONFIG_ID_90, getIdleFrameRate(LayerVoteType::Heuristic, /*touchActive=*/true));
1751 EXPECT_EQ(HWC_CONFIG_ID_90,
1752 getIdleFrameRate(LayerVoteType::ExplicitDefault, /*touchActive=*/true));
1753 EXPECT_EQ(HWC_CONFIG_ID_90,
1754 getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, /*touchActive=*/true));
1755
1756 // With no layers, idle should still be lower priority than touch boost.
1757 EXPECT_EQ(HWC_CONFIG_ID_90,
1758 refreshRateConfigs->getBestRefreshRate({}, {.touch = true, .idle = true})
1759 .getModeId());
1760
1761 // Idle should be higher precedence than other layer frame rate considerations.
1762 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
1763 EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::NoVote, /*touchActive=*/false));
1764 EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Min, /*touchActive=*/false));
1765 EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Max, /*touchActive=*/false));
1766 EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Heuristic, /*touchActive=*/false));
1767 EXPECT_EQ(HWC_CONFIG_ID_60,
1768 getIdleFrameRate(LayerVoteType::ExplicitDefault, /*touchActive=*/false));
1769 EXPECT_EQ(HWC_CONFIG_ID_60,
1770 getIdleFrameRate(LayerVoteType::ExplicitExactOrMultiple, /*touchActive=*/false));
1771
1772 // Idle should be applied rather than the current config when there are no layers.
1773 EXPECT_EQ(HWC_CONFIG_ID_60,
1774 refreshRateConfigs->getBestRefreshRate({}, {.touch = false, .idle = true})
1775 .getModeId());
1776 }
1777
TEST_F(RefreshRateConfigsTest,findClosestKnownFrameRate)1778 TEST_F(RefreshRateConfigsTest, findClosestKnownFrameRate) {
1779 auto refreshRateConfigs =
1780 std::make_unique<RefreshRateConfigs>(m60_90Device,
1781 /*currentConfigId=*/HWC_CONFIG_ID_60);
1782
1783 for (float fps = 1.0f; fps <= 120.0f; fps += 0.1f) {
1784 const auto knownFrameRate = findClosestKnownFrameRate(*refreshRateConfigs, Fps(fps));
1785 Fps expectedFrameRate;
1786 if (fps < 26.91f) {
1787 expectedFrameRate = Fps(24.0f);
1788 } else if (fps < 37.51f) {
1789 expectedFrameRate = Fps(30.0f);
1790 } else if (fps < 52.51f) {
1791 expectedFrameRate = Fps(45.0f);
1792 } else if (fps < 66.01f) {
1793 expectedFrameRate = Fps(60.0f);
1794 } else if (fps < 81.01f) {
1795 expectedFrameRate = Fps(72.0f);
1796 } else {
1797 expectedFrameRate = Fps(90.0f);
1798 }
1799 EXPECT_TRUE(expectedFrameRate.equalsWithMargin(knownFrameRate))
1800 << "findClosestKnownFrameRate(" << fps << ") = " << knownFrameRate;
1801 }
1802 }
1803
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_KnownFrameRate)1804 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_KnownFrameRate) {
1805 auto refreshRateConfigs =
1806 std::make_unique<RefreshRateConfigs>(m60_90Device,
1807 /*currentConfigId=*/HWC_CONFIG_ID_60);
1808
1809 struct ExpectedRate {
1810 Fps rate;
1811 const RefreshRate& expected;
1812 };
1813
1814 /* clang-format off */
1815 std::vector<ExpectedRate> knownFrameRatesExpectations = {
1816 {Fps(24.0f), mExpected60Config},
1817 {Fps(30.0f), mExpected60Config},
1818 {Fps(45.0f), mExpected90Config},
1819 {Fps(60.0f), mExpected60Config},
1820 {Fps(72.0f), mExpected90Config},
1821 {Fps(90.0f), mExpected90Config},
1822 };
1823 /* clang-format on */
1824
1825 // Make sure the test tests all the known frame rate
1826 const auto knownFrameRateList = getKnownFrameRate(*refreshRateConfigs);
1827 const auto equal =
1828 std::equal(knownFrameRateList.begin(), knownFrameRateList.end(),
1829 knownFrameRatesExpectations.begin(),
1830 [](Fps a, const ExpectedRate& b) { return a.equalsWithMargin(b.rate); });
1831 EXPECT_TRUE(equal);
1832
1833 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
1834 auto& layer = layers[0];
1835 layer.vote = LayerVoteType::Heuristic;
1836 for (const auto& expectedRate : knownFrameRatesExpectations) {
1837 layer.desiredRefreshRate = expectedRate.rate;
1838 const auto& refreshRate =
1839 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false});
1840 EXPECT_EQ(expectedRate.expected, refreshRate);
1841 }
1842 }
1843
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_ExplicitExact)1844 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExact) {
1845 auto refreshRateConfigs =
1846 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
1847 /*currentConfigId=*/HWC_CONFIG_ID_60);
1848
1849 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
1850 LayerRequirement{.weight = 0.5f}};
1851 auto& explicitExactLayer = layers[0];
1852 auto& explicitExactOrMultipleLayer = layers[1];
1853
1854 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
1855 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
1856 explicitExactOrMultipleLayer.desiredRefreshRate = Fps(60);
1857
1858 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
1859 explicitExactLayer.name = "ExplicitExact";
1860 explicitExactLayer.desiredRefreshRate = Fps(30);
1861
1862 EXPECT_EQ(mExpected30Config,
1863 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1864 EXPECT_EQ(mExpected30Config,
1865 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
1866
1867 explicitExactOrMultipleLayer.desiredRefreshRate = Fps(120);
1868 explicitExactLayer.desiredRefreshRate = Fps(60);
1869 EXPECT_EQ(mExpected60Config,
1870 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1871
1872 explicitExactLayer.desiredRefreshRate = Fps(72);
1873 EXPECT_EQ(mExpected72Config,
1874 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1875
1876 explicitExactLayer.desiredRefreshRate = Fps(90);
1877 EXPECT_EQ(mExpected90Config,
1878 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1879
1880 explicitExactLayer.desiredRefreshRate = Fps(120);
1881 EXPECT_EQ(mExpected120Config,
1882 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1883 }
1884
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_ExplicitExactEnableFrameRateOverride)1885 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) {
1886 RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
1887 auto refreshRateConfigs =
1888 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
1889 /*currentConfigId=*/HWC_CONFIG_ID_60, config);
1890
1891 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
1892 LayerRequirement{.weight = 0.5f}};
1893 auto& explicitExactLayer = layers[0];
1894 auto& explicitExactOrMultipleLayer = layers[1];
1895
1896 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
1897 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
1898 explicitExactOrMultipleLayer.desiredRefreshRate = Fps(60);
1899
1900 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
1901 explicitExactLayer.name = "ExplicitExact";
1902 explicitExactLayer.desiredRefreshRate = Fps(30);
1903
1904 EXPECT_EQ(mExpected60Config,
1905 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1906 EXPECT_EQ(mExpected120Config,
1907 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
1908
1909 explicitExactOrMultipleLayer.desiredRefreshRate = Fps(120);
1910 explicitExactLayer.desiredRefreshRate = Fps(60);
1911 EXPECT_EQ(mExpected120Config,
1912 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1913
1914 explicitExactLayer.desiredRefreshRate = Fps(72);
1915 EXPECT_EQ(mExpected72Config,
1916 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1917
1918 explicitExactLayer.desiredRefreshRate = Fps(90);
1919 EXPECT_EQ(mExpected90Config,
1920 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1921
1922 explicitExactLayer.desiredRefreshRate = Fps(120);
1923 EXPECT_EQ(mExpected120Config,
1924 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
1925 }
1926
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_ReadsCached)1927 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ReadsCached) {
1928 using GlobalSignals = RefreshRateConfigs::GlobalSignals;
1929
1930 auto refreshRateConfigs =
1931 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
1932 /*currentConfigId=*/HWC_CONFIG_ID_60);
1933
1934 setLastBestRefreshRateInvocation(*refreshRateConfigs,
1935 GetBestRefreshRateInvocation{.layerRequirements = std::vector<
1936 LayerRequirement>(),
1937 .globalSignals = {.touch = true,
1938 .idle = true},
1939 .outSignalsConsidered =
1940 {.touch = true,
1941 .idle = false},
1942 .resultingBestRefreshRate =
1943 createRefreshRate(
1944 mConfig90)});
1945
1946 EXPECT_EQ(createRefreshRate(mConfig90),
1947 refreshRateConfigs->getBestRefreshRate(std::vector<LayerRequirement>(),
1948 {.touch = true, .idle = true}));
1949
1950 const GlobalSignals cachedSignalsConsidered{.touch = true, .idle = false};
1951 setLastBestRefreshRateInvocation(*refreshRateConfigs,
1952 GetBestRefreshRateInvocation{.layerRequirements = std::vector<
1953 LayerRequirement>(),
1954 .globalSignals = {.touch = true,
1955 .idle = true},
1956 .outSignalsConsidered =
1957 cachedSignalsConsidered,
1958 .resultingBestRefreshRate =
1959 createRefreshRate(
1960 mConfig30)});
1961
1962 GlobalSignals signalsConsidered;
1963 EXPECT_EQ(createRefreshRate(mConfig30),
1964 refreshRateConfigs->getBestRefreshRate(std::vector<LayerRequirement>(),
1965 {.touch = true, .idle = true},
1966 &signalsConsidered));
1967
1968 EXPECT_EQ(cachedSignalsConsidered, signalsConsidered);
1969 }
1970
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_WritesCache)1971 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_WritesCache) {
1972 using GlobalSignals = RefreshRateConfigs::GlobalSignals;
1973
1974 auto refreshRateConfigs =
1975 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
1976 /*currentConfigId=*/HWC_CONFIG_ID_60);
1977 ASSERT_FALSE(getLastBestRefreshRateInvocation(*refreshRateConfigs).has_value());
1978
1979 GlobalSignals globalSignals{.touch = true, .idle = true};
1980 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
1981 LayerRequirement{.weight = 0.5f}};
1982 const auto lastResult =
1983 refreshRateConfigs->getBestRefreshRate(layers, globalSignals,
1984 /* outSignalsConsidered */ nullptr);
1985
1986 const auto lastInvocation = getLastBestRefreshRateInvocation(*refreshRateConfigs);
1987
1988 ASSERT_TRUE(lastInvocation.has_value());
1989 ASSERT_EQ(layers, lastInvocation->layerRequirements);
1990 ASSERT_EQ(globalSignals, lastInvocation->globalSignals);
1991 ASSERT_EQ(lastResult, lastInvocation->resultingBestRefreshRate);
1992
1993 // outSignalsConsidered needs to be populated even tho earlier we gave nullptr
1994 // to getBestRefreshRate()
1995 GlobalSignals detaultSignals;
1996 ASSERT_FALSE(detaultSignals == lastInvocation->outSignalsConsidered);
1997 }
1998
TEST_F(RefreshRateConfigsTest,getBestRefreshRate_ExplicitExactTouchBoost)1999 TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactTouchBoost) {
2000 RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
2001 auto refreshRateConfigs =
2002 std::make_unique<RefreshRateConfigs>(m60_120Device,
2003 /*currentConfigId=*/HWC_CONFIG_ID_60, config);
2004
2005 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
2006 LayerRequirement{.weight = 0.5f}};
2007 auto& explicitExactLayer = layers[0];
2008 auto& explicitExactOrMultipleLayer = layers[1];
2009
2010 explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple;
2011 explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple";
2012 explicitExactOrMultipleLayer.desiredRefreshRate = Fps(60);
2013
2014 explicitExactLayer.vote = LayerVoteType::ExplicitExact;
2015 explicitExactLayer.name = "ExplicitExact";
2016 explicitExactLayer.desiredRefreshRate = Fps(30);
2017
2018 EXPECT_EQ(mExpected60Config,
2019 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
2020 EXPECT_EQ(mExpected120Config,
2021 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
2022
2023 explicitExactOrMultipleLayer.vote = LayerVoteType::NoVote;
2024
2025 EXPECT_EQ(mExpected60Config,
2026 refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
2027 EXPECT_EQ(mExpected60Config,
2028 refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}));
2029 }
2030
TEST_F(RefreshRateConfigsTest,testComparisonOperator)2031 TEST_F(RefreshRateConfigsTest, testComparisonOperator) {
2032 EXPECT_TRUE(mExpected60Config < mExpected90Config);
2033 EXPECT_FALSE(mExpected60Config < mExpected60Config);
2034 EXPECT_FALSE(mExpected90Config < mExpected90Config);
2035 }
2036
TEST_F(RefreshRateConfigsTest,testKernelIdleTimerAction)2037 TEST_F(RefreshRateConfigsTest, testKernelIdleTimerAction) {
2038 using KernelIdleTimerAction = scheduler::RefreshRateConfigs::KernelIdleTimerAction;
2039
2040 auto refreshRateConfigs =
2041 std::make_unique<RefreshRateConfigs>(m60_90Device,
2042 /*currentConfigId=*/HWC_CONFIG_ID_90);
2043 // SetPolicy(60, 90), current 90Hz => TurnOn.
2044 EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
2045
2046 // SetPolicy(60, 90), current 60Hz => TurnOn.
2047 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(90)}}),
2048 0);
2049 EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
2050
2051 // SetPolicy(60, 60), current 60Hz => TurnOff
2052 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}),
2053 0);
2054 EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
2055
2056 // SetPolicy(90, 90), current 90Hz => TurnOff.
2057 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(90), Fps(90)}}),
2058 0);
2059 EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
2060 }
2061
TEST_F(RefreshRateConfigsTest,testKernelIdleTimerActionFor120Hz)2062 TEST_F(RefreshRateConfigsTest, testKernelIdleTimerActionFor120Hz) {
2063 using KernelIdleTimerAction = scheduler::RefreshRateConfigs::KernelIdleTimerAction;
2064
2065 // Tests with 120Hz
2066 auto refreshRateConfigs =
2067 std::make_unique<RefreshRateConfigs>(m60_120Device,
2068 /*currentConfigId=*/HWC_CONFIG_ID_120);
2069 // SetPolicy(0, 60), current 60Hz => TurnOn.
2070 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(0), Fps(60)}}),
2071 0);
2072 EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
2073
2074 // SetPolicy(60, 60), current 60Hz => TurnOff.
2075 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}),
2076 0);
2077 EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
2078
2079 // SetPolicy(60, 120), current 60Hz => TurnOn.
2080 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(120)}}),
2081 0);
2082 EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction());
2083
2084 // SetPolicy(120, 120), current 120Hz => TurnOff.
2085 ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(
2086 {HWC_CONFIG_ID_120, {Fps(120), Fps(120)}}),
2087 0);
2088 EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction());
2089 }
2090
TEST_F(RefreshRateConfigsTest,getFrameRateDivider)2091 TEST_F(RefreshRateConfigsTest, getFrameRateDivider) {
2092 auto refreshRateConfigs =
2093 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
2094 /*currentConfigId=*/HWC_CONFIG_ID_30);
2095
2096 const auto frameRate = Fps(30.f);
2097 Fps displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
2098 EXPECT_EQ(1, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
2099
2100 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_60);
2101 displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
2102 EXPECT_EQ(2, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
2103
2104 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_72);
2105 displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
2106 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
2107
2108 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
2109 displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
2110 EXPECT_EQ(3, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
2111
2112 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_120);
2113 displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
2114 EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate));
2115
2116 refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90);
2117 displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps();
2118 EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, Fps(22.5f)));
2119
2120 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(Fps(24.f), Fps(25.f)));
2121 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(Fps(24.f), Fps(23.976f)));
2122 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(Fps(30.f), Fps(29.97f)));
2123 EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(Fps(60.f), Fps(59.94f)));
2124 }
2125
TEST_F(RefreshRateConfigsTest,getFrameRateOverrides_noLayers)2126 TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_noLayers) {
2127 auto refreshRateConfigs =
2128 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
2129 HWC_CONFIG_ID_120);
2130
2131 auto layers = std::vector<LayerRequirement>{};
2132 ASSERT_TRUE(refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false)
2133 .empty());
2134 }
2135
TEST_F(RefreshRateConfigsTest,getFrameRateOverrides_60on120)2136 TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_60on120) {
2137 RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
2138 auto refreshRateConfigs =
2139 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
2140 HWC_CONFIG_ID_120, config);
2141
2142 auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
2143 layers[0].name = "Test layer";
2144 layers[0].ownerUid = 1234;
2145 layers[0].desiredRefreshRate = Fps(60.0f);
2146 layers[0].vote = LayerVoteType::ExplicitDefault;
2147 auto frameRateOverrides =
2148 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2149 ASSERT_EQ(1, frameRateOverrides.size());
2150 ASSERT_EQ(1, frameRateOverrides.count(1234));
2151 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2152
2153 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
2154 frameRateOverrides =
2155 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2156 ASSERT_EQ(1, frameRateOverrides.size());
2157 ASSERT_EQ(1, frameRateOverrides.count(1234));
2158 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2159
2160 layers[0].vote = LayerVoteType::NoVote;
2161 frameRateOverrides =
2162 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2163 ASSERT_TRUE(frameRateOverrides.empty());
2164
2165 layers[0].vote = LayerVoteType::Min;
2166 frameRateOverrides =
2167 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2168 ASSERT_TRUE(frameRateOverrides.empty());
2169
2170 layers[0].vote = LayerVoteType::Max;
2171 frameRateOverrides =
2172 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2173 ASSERT_TRUE(frameRateOverrides.empty());
2174
2175 layers[0].vote = LayerVoteType::Heuristic;
2176 frameRateOverrides =
2177 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2178 ASSERT_TRUE(frameRateOverrides.empty());
2179 }
2180
TEST_F(RefreshRateConfigsTest,getFrameRateOverrides_twoUids)2181 TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_twoUids) {
2182 RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
2183 auto refreshRateConfigs =
2184 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
2185 HWC_CONFIG_ID_120, config);
2186
2187 auto layers = std::vector<LayerRequirement>{
2188 LayerRequirement{.ownerUid = 1234, .weight = 1.0f},
2189 LayerRequirement{.ownerUid = 5678, .weight = 1.0f},
2190 };
2191
2192 layers[0].name = "Test layer 1234";
2193 layers[0].desiredRefreshRate = Fps(60.0f);
2194 layers[0].vote = LayerVoteType::ExplicitDefault;
2195
2196 layers[1].name = "Test layer 5678";
2197 layers[1].desiredRefreshRate = Fps(30.0f);
2198 layers[1].vote = LayerVoteType::ExplicitDefault;
2199 auto frameRateOverrides =
2200 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2201
2202 ASSERT_EQ(2, frameRateOverrides.size());
2203 ASSERT_EQ(1, frameRateOverrides.count(1234));
2204 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2205 ASSERT_EQ(1, frameRateOverrides.count(5678));
2206 ASSERT_EQ(30.0f, frameRateOverrides.at(5678).getValue());
2207
2208 layers[1].vote = LayerVoteType::Heuristic;
2209 frameRateOverrides =
2210 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2211 ASSERT_EQ(1, frameRateOverrides.size());
2212 ASSERT_EQ(1, frameRateOverrides.count(1234));
2213 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2214
2215 layers[1].ownerUid = 1234;
2216 frameRateOverrides =
2217 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2218 ASSERT_TRUE(frameRateOverrides.empty());
2219 }
2220
TEST_F(RefreshRateConfigsTest,getFrameRateOverrides_touch)2221 TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_touch) {
2222 RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
2223 auto refreshRateConfigs =
2224 std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/
2225 HWC_CONFIG_ID_120, config);
2226
2227 auto layers = std::vector<LayerRequirement>{
2228 LayerRequirement{.ownerUid = 1234, .weight = 1.0f},
2229 };
2230
2231 layers[0].name = "Test layer";
2232 layers[0].desiredRefreshRate = Fps(60.0f);
2233 layers[0].vote = LayerVoteType::ExplicitDefault;
2234
2235 auto frameRateOverrides =
2236 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2237 ASSERT_EQ(1, frameRateOverrides.size());
2238 ASSERT_EQ(1, frameRateOverrides.count(1234));
2239 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2240
2241 frameRateOverrides =
2242 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/true);
2243 ASSERT_EQ(1, frameRateOverrides.size());
2244 ASSERT_EQ(1, frameRateOverrides.count(1234));
2245 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2246
2247 layers[0].vote = LayerVoteType::ExplicitExact;
2248 frameRateOverrides =
2249 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2250 ASSERT_EQ(1, frameRateOverrides.size());
2251 ASSERT_EQ(1, frameRateOverrides.count(1234));
2252 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2253
2254 frameRateOverrides =
2255 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/true);
2256 ASSERT_EQ(1, frameRateOverrides.size());
2257 ASSERT_EQ(1, frameRateOverrides.count(1234));
2258 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2259
2260 layers[0].vote = LayerVoteType::ExplicitExactOrMultiple;
2261 frameRateOverrides =
2262 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false);
2263 ASSERT_EQ(1, frameRateOverrides.size());
2264 ASSERT_EQ(1, frameRateOverrides.count(1234));
2265 ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue());
2266
2267 frameRateOverrides =
2268 refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/true);
2269 ASSERT_TRUE(frameRateOverrides.empty());
2270 }
2271
2272 } // namespace
2273 } // namespace scheduler
2274 } // namespace android
2275
2276 // TODO(b/129481165): remove the #pragma below and fix conversion issues
2277 #pragma clang diagnostic pop // ignored "-Wextra"
2278