diff options
Diffstat (limited to 'services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp')
| -rw-r--r-- | services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp | 1544 |
1 files changed, 360 insertions, 1184 deletions
diff --git a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp index 3423bd590b..1f6f166b45 100644 --- a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp +++ b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp @@ -14,10 +14,6 @@ * limitations under the License. */ -// TODO(b/129481165): remove the #pragma below and fix conversion issues -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wextra" - #undef LOG_TAG #define LOG_TAG "SchedulerUnittests" @@ -25,16 +21,15 @@ #include <log/log.h> #include <thread> -#include <ui/Size.h> - #include "../../Scheduler/RefreshRateConfigs.h" #include "DisplayHardware/HWC2.h" #include "Scheduler/RefreshRateConfigs.h" +#include "mock/DisplayHardware/MockDisplay.h" using namespace std::chrono_literals; +using testing::_; namespace android { - namespace scheduler { namespace hal = android::hardware::graphics::composer::hal; @@ -45,133 +40,102 @@ using LayerRequirement = RefreshRateConfigs::LayerRequirement; class RefreshRateConfigsTest : public testing::Test { protected: - using GetBestRefreshRateInvocation = RefreshRateConfigs::GetBestRefreshRateInvocation; - RefreshRateConfigsTest(); ~RefreshRateConfigsTest(); - RefreshRate createRefreshRate(DisplayModePtr displayMode) { - return {displayMode->getId(), displayMode, displayMode->getFps(), - RefreshRate::ConstructorTag(0)}; - } - - Fps findClosestKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs, Fps frameRate) { + float findClosestKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs, float frameRate) { return refreshRateConfigs.findClosestKnownFrameRate(frameRate); } - std::vector<Fps> getKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs) { + std::vector<float> getKnownFrameRate(const RefreshRateConfigs& refreshRateConfigs) { return refreshRateConfigs.mKnownFrameRates; } - RefreshRate getMinRefreshRateByPolicy(const RefreshRateConfigs& refreshRateConfigs) { - std::lock_guard lock(refreshRateConfigs.mLock); - return refreshRateConfigs.getMinRefreshRateByPolicyLocked(); - } - - RefreshRate getMinSupportedRefreshRate(const RefreshRateConfigs& refreshRateConfigs) { - std::lock_guard lock(refreshRateConfigs.mLock); - return *refreshRateConfigs.mMinSupportedRefreshRate; - } - - RefreshRate getMaxSupportedRefreshRate(const RefreshRateConfigs& refreshRateConfigs) { - std::lock_guard lock(refreshRateConfigs.mLock); - return *refreshRateConfigs.mMaxSupportedRefreshRate; - } - - void setLastBestRefreshRateInvocation(RefreshRateConfigs& refreshRateConfigs, - const GetBestRefreshRateInvocation& invocation) { - std::lock_guard lock(refreshRateConfigs.mLock); - refreshRateConfigs.lastBestRefreshRateInvocation.emplace( - GetBestRefreshRateInvocation(invocation)); - } - - std::optional<GetBestRefreshRateInvocation> getLastBestRefreshRateInvocation( - const RefreshRateConfigs& refreshRateConfigs) { - std::lock_guard lock(refreshRateConfigs.mLock); - return refreshRateConfigs.lastBestRefreshRateInvocation; - } - // Test config IDs - static inline const DisplayModeId HWC_CONFIG_ID_60 = DisplayModeId(0); - static inline const DisplayModeId HWC_CONFIG_ID_90 = DisplayModeId(1); - static inline const DisplayModeId HWC_CONFIG_ID_72 = DisplayModeId(2); - static inline const DisplayModeId HWC_CONFIG_ID_120 = DisplayModeId(3); - static inline const DisplayModeId HWC_CONFIG_ID_30 = DisplayModeId(4); - static inline const DisplayModeId HWC_CONFIG_ID_25 = DisplayModeId(5); - static inline const DisplayModeId HWC_CONFIG_ID_50 = DisplayModeId(6); + static inline const HwcConfigIndexType HWC_CONFIG_ID_60 = HwcConfigIndexType(0); + static inline const HwcConfigIndexType HWC_CONFIG_ID_90 = HwcConfigIndexType(1); + static inline const HwcConfigIndexType HWC_CONFIG_ID_72 = HwcConfigIndexType(2); + static inline const HwcConfigIndexType HWC_CONFIG_ID_120 = HwcConfigIndexType(3); + static inline const HwcConfigIndexType HWC_CONFIG_ID_30 = HwcConfigIndexType(4); // Test configs - DisplayModePtr mConfig60 = createDisplayMode(HWC_CONFIG_ID_60, 0, Fps(60.0f).getPeriodNsecs()); - DisplayModePtr mConfig90 = createDisplayMode(HWC_CONFIG_ID_90, 0, Fps(90.0f).getPeriodNsecs()); - DisplayModePtr mConfig90DifferentGroup = - createDisplayMode(HWC_CONFIG_ID_90, 1, Fps(90.0f).getPeriodNsecs()); - DisplayModePtr mConfig90DifferentResolution = - createDisplayMode(HWC_CONFIG_ID_90, 0, Fps(90.0f).getPeriodNsecs(), ui::Size(111, 222)); - DisplayModePtr mConfig72 = createDisplayMode(HWC_CONFIG_ID_72, 0, Fps(72.0f).getPeriodNsecs()); - DisplayModePtr mConfig72DifferentGroup = - createDisplayMode(HWC_CONFIG_ID_72, 1, Fps(72.0f).getPeriodNsecs()); - DisplayModePtr mConfig120 = - createDisplayMode(HWC_CONFIG_ID_120, 0, Fps(120.0f).getPeriodNsecs()); - DisplayModePtr mConfig120DifferentGroup = - createDisplayMode(HWC_CONFIG_ID_120, 1, Fps(120.0f).getPeriodNsecs()); - DisplayModePtr mConfig30 = createDisplayMode(HWC_CONFIG_ID_30, 0, Fps(30.0f).getPeriodNsecs()); - DisplayModePtr mConfig30DifferentGroup = - createDisplayMode(HWC_CONFIG_ID_30, 1, Fps(30.0f).getPeriodNsecs()); - DisplayModePtr mConfig25DifferentGroup = - createDisplayMode(HWC_CONFIG_ID_25, 1, Fps(25.0f).getPeriodNsecs()); - DisplayModePtr mConfig50 = createDisplayMode(HWC_CONFIG_ID_50, 0, Fps(50.0f).getPeriodNsecs()); + std::shared_ptr<const HWC2::Display::Config> mConfig60 = + createConfig(HWC_CONFIG_ID_60, 0, static_cast<int64_t>(1e9f / 60)); + std::shared_ptr<const HWC2::Display::Config> mConfig90 = + createConfig(HWC_CONFIG_ID_90, 0, static_cast<int64_t>(1e9f / 90)); + std::shared_ptr<const HWC2::Display::Config> mConfig90DifferentGroup = + createConfig(HWC_CONFIG_ID_90, 1, static_cast<int64_t>(1e9f / 90)); + std::shared_ptr<const HWC2::Display::Config> mConfig90DifferentResolution = + createConfig(HWC_CONFIG_ID_90, 0, static_cast<int64_t>(1e9f / 90), 111, 222); + std::shared_ptr<const HWC2::Display::Config> mConfig72 = + createConfig(HWC_CONFIG_ID_72, 0, static_cast<int64_t>(1e9f / 72)); + std::shared_ptr<const HWC2::Display::Config> mConfig72DifferentGroup = + createConfig(HWC_CONFIG_ID_72, 1, static_cast<int64_t>(1e9f / 72)); + std::shared_ptr<const HWC2::Display::Config> mConfig120 = + createConfig(HWC_CONFIG_ID_120, 0, static_cast<int64_t>(1e9f / 120)); + std::shared_ptr<const HWC2::Display::Config> mConfig120DifferentGroup = + createConfig(HWC_CONFIG_ID_120, 1, static_cast<int64_t>(1e9f / 120)); + std::shared_ptr<const HWC2::Display::Config> mConfig30 = + createConfig(HWC_CONFIG_ID_30, 0, static_cast<int64_t>(1e9f / 30)); // Test device configurations - // The positions of the configs in the arrays below MUST match their IDs. For example, - // the first config should always be 60Hz, the second 90Hz etc. - DisplayModes m60OnlyConfigDevice = {mConfig60}; - DisplayModes m60_90Device = {mConfig60, mConfig90}; - DisplayModes m60_90DeviceWithDifferentGroups = {mConfig60, mConfig90DifferentGroup}; - DisplayModes m60_90DeviceWithDifferentResolutions = {mConfig60, mConfig90DifferentResolution}; - DisplayModes m60_72_90Device = {mConfig60, mConfig90, mConfig72}; - DisplayModes m60_90_72_120Device = {mConfig60, mConfig90, mConfig72, mConfig120}; - DisplayModes m30_60_72_90_120Device = {mConfig60, mConfig90, mConfig72, mConfig120, mConfig30}; - DisplayModes m30_60Device = {mConfig60, mConfig90DifferentGroup, mConfig72DifferentGroup, - mConfig120DifferentGroup, mConfig30}; - DisplayModes m30_60_72_90Device = {mConfig60, mConfig90, mConfig72, mConfig120DifferentGroup, - mConfig30}; - DisplayModes m30_60_90Device = {mConfig60, mConfig90, mConfig72DifferentGroup, - mConfig120DifferentGroup, mConfig30}; - DisplayModes m25_30_50_60Device = {mConfig60, - mConfig90, - mConfig72DifferentGroup, - mConfig120DifferentGroup, - mConfig30DifferentGroup, - mConfig25DifferentGroup, - mConfig50}; - DisplayModes m60_120Device = {mConfig60, mConfig120}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m60OnlyConfigDevice = {mConfig60}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m60_90Device = {mConfig60, mConfig90}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m60_90DeviceWithDifferentGroups = + {mConfig60, mConfig90DifferentGroup}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m60_90DeviceWithDifferentResolutions = + {mConfig60, mConfig90DifferentResolution}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m60_72_90Device = {mConfig60, + mConfig90, + mConfig72}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m60_90_72_120Device = {mConfig60, + mConfig90, + mConfig72, + mConfig120}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m30_60_72_90_120Device = {mConfig60, + mConfig90, + mConfig72, + mConfig120, + mConfig30}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m30_60Device = + {mConfig60, mConfig90DifferentGroup, mConfig72DifferentGroup, mConfig120DifferentGroup, + mConfig30}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m30_60_72_90Device = + {mConfig60, mConfig90, mConfig72, mConfig120DifferentGroup, mConfig30}; + std::vector<std::shared_ptr<const HWC2::Display::Config>> m30_60_90Device = + {mConfig60, mConfig90, mConfig72DifferentGroup, mConfig120DifferentGroup, mConfig30}; // Expected RefreshRate objects - RefreshRate mExpected60Config = {HWC_CONFIG_ID_60, mConfig60, Fps(60), + RefreshRate mExpected60Config = {HWC_CONFIG_ID_60, mConfig60, "60fps", 60, RefreshRate::ConstructorTag(0)}; RefreshRate mExpectedAlmost60Config = {HWC_CONFIG_ID_60, - createDisplayMode(HWC_CONFIG_ID_60, 0, 16666665), - Fps(60), RefreshRate::ConstructorTag(0)}; - RefreshRate mExpected90Config = {HWC_CONFIG_ID_90, mConfig90, Fps(90), + createConfig(HWC_CONFIG_ID_60, 0, 16666665), "60fps", 60, + RefreshRate::ConstructorTag(0)}; + RefreshRate mExpected90Config = {HWC_CONFIG_ID_90, mConfig90, "90fps", 90, RefreshRate::ConstructorTag(0)}; RefreshRate mExpected90DifferentGroupConfig = {HWC_CONFIG_ID_90, mConfig90DifferentGroup, - Fps(90), RefreshRate::ConstructorTag(0)}; + "90fps", 90, RefreshRate::ConstructorTag(0)}; RefreshRate mExpected90DifferentResolutionConfig = {HWC_CONFIG_ID_90, - mConfig90DifferentResolution, Fps(90), + mConfig90DifferentResolution, "90fps", 90, RefreshRate::ConstructorTag(0)}; - RefreshRate mExpected72Config = {HWC_CONFIG_ID_72, mConfig72, Fps(72.0f), + RefreshRate mExpected72Config = {HWC_CONFIG_ID_72, mConfig72, "72fps", 72, RefreshRate::ConstructorTag(0)}; - RefreshRate mExpected30Config = {HWC_CONFIG_ID_30, mConfig30, Fps(30), + RefreshRate mExpected30Config = {HWC_CONFIG_ID_30, mConfig30, "30fps", 30, RefreshRate::ConstructorTag(0)}; - RefreshRate mExpected120Config = {HWC_CONFIG_ID_120, mConfig120, Fps(120), + RefreshRate mExpected120Config = {HWC_CONFIG_ID_120, mConfig120, "120fps", 120, RefreshRate::ConstructorTag(0)}; + Hwc2::mock::Display mDisplay; + private: - DisplayModePtr createDisplayMode(DisplayModeId modeId, int32_t group, int64_t vsyncPeriod, - ui::Size resolution = ui::Size()); + std::shared_ptr<const HWC2::Display::Config> createConfig(HwcConfigIndexType configId, + int32_t configGroup, + int64_t vsyncPeriod, + int32_t hight = -1, + int32_t width = -1); }; -using Builder = DisplayMode::Builder; +using Builder = HWC2::Display::Config::Builder; RefreshRateConfigsTest::RefreshRateConfigsTest() { const ::testing::TestInfo* const test_info = @@ -185,14 +149,14 @@ RefreshRateConfigsTest::~RefreshRateConfigsTest() { ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name()); } -DisplayModePtr RefreshRateConfigsTest::createDisplayMode(DisplayModeId modeId, int32_t group, - int64_t vsyncPeriod, ui::Size resolution) { - return DisplayMode::Builder(hal::HWConfigId(modeId.value())) - .setId(modeId) +std::shared_ptr<const HWC2::Display::Config> RefreshRateConfigsTest::createConfig( + HwcConfigIndexType configId, int32_t configGroup, int64_t vsyncPeriod, int32_t hight, + int32_t width) { + return HWC2::Display::Config::Builder(mDisplay, hal::HWConfigId(configId.value())) .setVsyncPeriod(int32_t(vsyncPeriod)) - .setGroup(group) - .setHeight(resolution.height) - .setWidth(resolution.width) + .setConfigGroup(configGroup) + .setHeight(hight) + .setWidth(width) .build(); } @@ -210,10 +174,8 @@ TEST_F(RefreshRateConfigsTest, invalidPolicy) { auto refreshRateConfigs = std::make_unique<RefreshRateConfigs>(m60OnlyConfigDevice, /*currentConfigId=*/HWC_CONFIG_ID_60); - ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({DisplayModeId(10), {Fps(60), Fps(60)}}), - 0); - ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(20), Fps(40)}}), - 0); + ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({HwcConfigIndexType(10), {60, 60}}), 0); + ASSERT_LT(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {20, 40}}), 0); } TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap) { @@ -221,13 +183,13 @@ TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap) { std::make_unique<RefreshRateConfigs>(m60_90Device, /*currentConfigId=*/HWC_CONFIG_ID_60); - const auto& minRate = getMinSupportedRefreshRate(*refreshRateConfigs); - const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs); + const auto& minRate = refreshRateConfigs->getMinRefreshRate(); + const auto& performanceRate = refreshRateConfigs->getMaxRefreshRate(); ASSERT_EQ(mExpected60Config, minRate); ASSERT_EQ(mExpected90Config, performanceRate); - const auto& minRateByPolicy = getMinRefreshRateByPolicy(*refreshRateConfigs); + const auto& minRateByPolicy = refreshRateConfigs->getMinRefreshRateByPolicy(); const auto& performanceRateByPolicy = refreshRateConfigs->getMaxRefreshRateByPolicy(); ASSERT_EQ(minRateByPolicy, minRate); ASSERT_EQ(performanceRateByPolicy, performanceRate); @@ -238,20 +200,19 @@ TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap_differe std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, /*currentConfigId=*/HWC_CONFIG_ID_60); - const auto& minRate = getMinRefreshRateByPolicy(*refreshRateConfigs); - const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs); - const auto& minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs); + const auto& minRate = refreshRateConfigs->getMinRefreshRateByPolicy(); + const auto& performanceRate = refreshRateConfigs->getMaxRefreshRate(); + const auto& minRate60 = refreshRateConfigs->getMinRefreshRateByPolicy(); const auto& performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy(); ASSERT_EQ(mExpected60Config, minRate); ASSERT_EQ(mExpected60Config, minRate60); ASSERT_EQ(mExpected60Config, performanceRate60); - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(60), Fps(90)}}), - 0); - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {60, 90}}), 0); + refreshRateConfigs->setCurrentConfigId(HWC_CONFIG_ID_90); - const auto& minRate90 = getMinRefreshRateByPolicy(*refreshRateConfigs); + const auto& minRate90 = refreshRateConfigs->getMinRefreshRateByPolicy(); const auto& performanceRate90 = refreshRateConfigs->getMaxRefreshRateByPolicy(); ASSERT_EQ(mExpected90DifferentGroupConfig, performanceRate); @@ -264,20 +225,19 @@ TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesFullRefreshRateMap_differe std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentResolutions, /*currentConfigId=*/HWC_CONFIG_ID_60); - const auto& minRate = getMinRefreshRateByPolicy(*refreshRateConfigs); - const auto& performanceRate = getMaxSupportedRefreshRate(*refreshRateConfigs); - const auto& minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs); + const auto& minRate = refreshRateConfigs->getMinRefreshRateByPolicy(); + const auto& performanceRate = refreshRateConfigs->getMaxRefreshRate(); + const auto& minRate60 = refreshRateConfigs->getMinRefreshRateByPolicy(); const auto& performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy(); ASSERT_EQ(mExpected60Config, minRate); ASSERT_EQ(mExpected60Config, minRate60); ASSERT_EQ(mExpected60Config, performanceRate60); - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(60), Fps(90)}}), - 0); - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {60, 90}}), 0); + refreshRateConfigs->setCurrentConfigId(HWC_CONFIG_ID_90); - const auto& minRate90 = getMinRefreshRateByPolicy(*refreshRateConfigs); + const auto& minRate90 = refreshRateConfigs->getMinRefreshRateByPolicy(); const auto& performanceRate90 = refreshRateConfigs->getMaxRefreshRateByPolicy(); ASSERT_EQ(mExpected90DifferentResolutionConfig, performanceRate); @@ -290,17 +250,16 @@ TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_policyChange) { std::make_unique<RefreshRateConfigs>(m60_90Device, /*currentConfigId=*/HWC_CONFIG_ID_60); - auto minRate = getMinRefreshRateByPolicy(*refreshRateConfigs); - auto performanceRate = refreshRateConfigs->getMaxRefreshRateByPolicy(); + auto& minRate = refreshRateConfigs->getMinRefreshRateByPolicy(); + auto& performanceRate = refreshRateConfigs->getMaxRefreshRateByPolicy(); ASSERT_EQ(mExpected60Config, minRate); ASSERT_EQ(mExpected90Config, performanceRate); - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}), - 0); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60, 60}}), 0); - auto minRate60 = getMinRefreshRateByPolicy(*refreshRateConfigs); - auto performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy(); + auto& minRate60 = refreshRateConfigs->getMinRefreshRateByPolicy(); + auto& performanceRate60 = refreshRateConfigs->getMaxRefreshRateByPolicy(); ASSERT_EQ(mExpected60Config, minRate60); ASSERT_EQ(mExpected60Config, performanceRate60); } @@ -310,24 +269,80 @@ TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getCurrentRefreshRate) { std::make_unique<RefreshRateConfigs>(m60_90Device, /*currentConfigId=*/HWC_CONFIG_ID_60); { - auto current = refreshRateConfigs->getCurrentRefreshRate(); - EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_60); + auto& current = refreshRateConfigs->getCurrentRefreshRate(); + EXPECT_EQ(current.getConfigId(), HWC_CONFIG_ID_60); } - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); + refreshRateConfigs->setCurrentConfigId(HWC_CONFIG_ID_90); { - auto current = refreshRateConfigs->getCurrentRefreshRate(); - EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_90); + auto& current = refreshRateConfigs->getCurrentRefreshRate(); + EXPECT_EQ(current.getConfigId(), HWC_CONFIG_ID_90); } - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(90), Fps(90)}}), - 0); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {90, 90}}), 0); { - auto current = refreshRateConfigs->getCurrentRefreshRate(); - EXPECT_EQ(current.getModeId(), HWC_CONFIG_ID_90); + auto& current = refreshRateConfigs->getCurrentRefreshRate(); + EXPECT_EQ(current.getConfigId(), HWC_CONFIG_ID_90); } } +TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getRefreshRateForContent) { + auto refreshRateConfigs = + std::make_unique<RefreshRateConfigs>(m60_90Device, + /*currentConfigId=*/HWC_CONFIG_ID_60); + + const auto makeLayerRequirements = [](float refreshRate) -> std::vector<LayerRequirement> { + return {{"testLayer", LayerVoteType::Heuristic, refreshRate, /*weight*/ 1.0f, + /*focused*/ false}}; + }; + + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(90.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(60.0f))); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(45.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(30.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(24.0f))); + + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60, 60}}), 0); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(90.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(60.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(45.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(30.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(24.0f))); + + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {90, 90}}), 0); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(90.0f))); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(60.0f))); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(45.0f))); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(30.0f))); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(24.0f))); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {0, 120}}), 0); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(90.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(60.0f))); + EXPECT_EQ(mExpected90Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(45.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(30.0f))); + EXPECT_EQ(mExpected60Config, + refreshRateConfigs->getRefreshRateForContent(makeLayerRequirements(24.0f))); +} + TEST_F(RefreshRateConfigsTest, getBestRefreshRate_noLayers) { auto refreshRateConfigs = std::make_unique<RefreshRateConfigs>(m60_72_90Device, /*currentConfigId=*/ @@ -339,8 +354,7 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_noLayers) { EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}), - 0); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60, 60}}), 0); EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); } @@ -363,35 +377,34 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) { EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.vote = LayerVoteType::Heuristic; lr.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz Heuristic"; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(45.0f); + lr.desiredRefreshRate = 45.0f; lr.name = "45Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); + lr.desiredRefreshRate = 30.0f; lr.name = "30Hz Heuristic"; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); + lr.desiredRefreshRate = 24.0f; lr.name = "24Hz Heuristic"; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr.name = ""; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}), - 0); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60, 60}}), 0); lr.vote = LayerVoteType::Min; EXPECT_EQ(mExpected60Config, @@ -401,30 +414,28 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) { EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.vote = LayerVoteType::Heuristic; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(45.0f); + lr.desiredRefreshRate = 45.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); + lr.desiredRefreshRate = 30.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); + lr.desiredRefreshRate = 24.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_90, {Fps(90.0f), Fps(90.0f)}}), - 0); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {90, 90}}), 0); lr.vote = LayerVoteType::Min; EXPECT_EQ(mExpected90Config, @@ -434,102 +445,54 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) { EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.vote = LayerVoteType::Heuristic; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(60.0f); - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr.desiredRefreshRate = Fps(45.0f); + lr.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); + lr.desiredRefreshRate = 45.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); + lr.desiredRefreshRate = 30.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_60, {Fps(0.0f), Fps(120.0f)}}), - 0); - lr.vote = LayerVoteType::Min; - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr.vote = LayerVoteType::Max; - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr.desiredRefreshRate = Fps(90.0f); - lr.vote = LayerVoteType::Heuristic; - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr.desiredRefreshRate = Fps(60.0f); - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr.desiredRefreshRate = Fps(45.0f); + lr.desiredRefreshRate = 24.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr.desiredRefreshRate = Fps(24.0f); - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); -} - -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_multipleThreshold_60_90) { - RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 90}; - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90Device, - /*currentConfigId=*/HWC_CONFIG_ID_60, config); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - auto& lr = layers[0]; - + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {0, 120}}), 0); lr.vote = LayerVoteType::Min; - lr.name = "Min"; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr.vote = LayerVoteType::Max; - lr.name = "Max"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.vote = LayerVoteType::Heuristic; - lr.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(60.0f); - lr.name = "60Hz Heuristic"; + lr.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(45.0f); - lr.name = "45Hz Heuristic"; + lr.desiredRefreshRate = 45.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); - lr.name = "30Hz Heuristic"; + lr.desiredRefreshRate = 30.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); - lr.name = "24Hz Heuristic"; + lr.desiredRefreshRate = 24.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); } @@ -550,24 +513,24 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) { EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.vote = LayerVoteType::Heuristic; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(45.0f); + lr.desiredRefreshRate = 45.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); + lr.desiredRefreshRate = 30.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); + lr.desiredRefreshRate = 24.0f; EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); } @@ -582,23 +545,23 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90_120) { auto& lr1 = layers[0]; auto& lr2 = layers[1]; - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.vote = LayerVoteType::Heuristic; EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(48.0f); + lr2.desiredRefreshRate = 48.0f; lr2.vote = LayerVoteType::Heuristic; EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(48.0f); + lr2.desiredRefreshRate = 48.0f; lr2.vote = LayerVoteType::Heuristic; EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); @@ -614,175 +577,82 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes) { auto& lr1 = layers[0]; auto& lr2 = layers[1]; - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitDefault; lr1.name = "24Hz ExplicitDefault"; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.vote = LayerVoteType::Heuristic; lr2.name = "60Hz Heuristic"; EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.vote = LayerVoteType::Heuristic; lr2.name = "60Hz Heuristic"; EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.vote = LayerVoteType::ExplicitDefault; lr2.name = "60Hz ExplicitDefault"; EXPECT_EQ(mExpected120Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::Heuristic; lr2.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::ExplicitDefault; lr2.name = "90Hz Heuristic"; EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitDefault; lr1.name = "24Hz ExplicitDefault"; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::Heuristic; lr2.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::Heuristic; lr1.name = "24Hz Heuristic"; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::ExplicitDefault; lr2.name = "90Hz ExplicitDefault"; EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::ExplicitDefault; lr2.name = "90Hz ExplicitDefault"; EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr1.desiredRefreshRate = Fps(24.0f); + lr1.desiredRefreshRate = 24.0f; lr1.vote = LayerVoteType::ExplicitDefault; lr1.name = "24Hz ExplicitDefault"; - lr2.desiredRefreshRate = Fps(90.0f); - lr2.vote = LayerVoteType::ExplicitExactOrMultiple; - lr2.name = "90Hz ExplicitExactOrMultiple"; - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); -} - -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes_multipleThreshold) { - RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 120}; - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_60, config); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}, - LayerRequirement{.weight = 1.0f}}; - auto& lr1 = layers[0]; - auto& lr2 = layers[1]; - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitDefault; - lr1.name = "24Hz ExplicitDefault"; - lr2.desiredRefreshRate = Fps(60.0f); - lr2.vote = LayerVoteType::Heuristic; - lr2.name = "60Hz Heuristic"; - EXPECT_EQ(mExpected120Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(60.0f); - lr2.vote = LayerVoteType::Heuristic; - lr2.name = "60Hz Heuristic"; - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(60.0f); - lr2.vote = LayerVoteType::ExplicitDefault; - lr2.name = "60Hz ExplicitDefault"; - EXPECT_EQ(mExpected72Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(90.0f); - lr2.vote = LayerVoteType::Heuristic; - lr2.name = "90Hz Heuristic"; - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(90.0f); - lr2.vote = LayerVoteType::ExplicitDefault; - lr2.name = "90Hz Heuristic"; - EXPECT_EQ(mExpected72Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitDefault; - lr1.name = "24Hz ExplicitDefault"; - lr2.desiredRefreshRate = Fps(90.0f); - lr2.vote = LayerVoteType::Heuristic; - lr2.name = "90Hz Heuristic"; - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::Heuristic; - lr1.name = "24Hz Heuristic"; - lr2.desiredRefreshRate = Fps(90.0f); - lr2.vote = LayerVoteType::ExplicitDefault; - lr2.name = "90Hz ExplicitDefault"; - EXPECT_EQ(mExpected72Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.name = "24Hz ExplicitExactOrMultiple"; - lr2.desiredRefreshRate = Fps(90.0f); - lr2.vote = LayerVoteType::ExplicitDefault; - lr2.name = "90Hz ExplicitDefault"; - EXPECT_EQ(mExpected72Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - lr1.desiredRefreshRate = Fps(24.0f); - lr1.vote = LayerVoteType::ExplicitDefault; - lr1.name = "24Hz ExplicitDefault"; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::ExplicitExactOrMultiple; lr2.name = "90Hz ExplicitExactOrMultiple"; EXPECT_EQ(mExpected90Config, @@ -805,24 +675,24 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) { EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.vote = LayerVoteType::Heuristic; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(45.0f); + lr.desiredRefreshRate = 45.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); + lr.desiredRefreshRate = 30.0f; EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); + lr.desiredRefreshRate = 24.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); } @@ -845,41 +715,41 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_72_90) { EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.vote = LayerVoteType::Heuristic; lr.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz Heuristic"; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); - lr.desiredRefreshRate = Fps(45.0f); + lr.desiredRefreshRate = 45.0f; lr.name = "45Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); - lr.desiredRefreshRate = Fps(30.0f); + lr.desiredRefreshRate = 30.0f; lr.name = "30Hz Heuristic"; EXPECT_EQ(mExpected30Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); + lr.desiredRefreshRate = 24.0f; lr.name = "24Hz Heuristic"; EXPECT_EQ(mExpected72Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); - lr.desiredRefreshRate = Fps(24.0f); + lr.desiredRefreshRate = 24.0f; lr.vote = LayerVoteType::ExplicitExactOrMultiple; lr.name = "24Hz ExplicitExactOrMultiple"; EXPECT_EQ(mExpected72Config, @@ -905,39 +775,39 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_PriorityTest) { lr1.vote = LayerVoteType::Min; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(24.0f); + lr2.desiredRefreshRate = 24.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::Min; lr2.vote = LayerVoteType::ExplicitExactOrMultiple; - lr2.desiredRefreshRate = Fps(24.0f); + lr2.desiredRefreshRate = 24.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::Max; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::Max; lr2.vote = LayerVoteType::ExplicitExactOrMultiple; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::Heuristic; - lr1.desiredRefreshRate = Fps(15.0f); + lr1.desiredRefreshRate = 15.0f; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(45.0f); + lr2.desiredRefreshRate = 45.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::Heuristic; - lr1.desiredRefreshRate = Fps(30.0f); + lr1.desiredRefreshRate = 30.0f; lr2.vote = LayerVoteType::ExplicitExactOrMultiple; - lr2.desiredRefreshRate = Fps(45.0f); + lr2.desiredRefreshRate = 45.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); } @@ -952,29 +822,34 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo) { lr.vote = LayerVoteType::ExplicitExactOrMultiple; for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) { - lr.desiredRefreshRate = Fps(fps); + lr.desiredRefreshRate = fps; const auto& refreshRate = refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}); EXPECT_EQ(mExpected60Config, refreshRate) << fps << "Hz chooses " << refreshRate.getName(); } } -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo_multipleThreshold_60_120) { - RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 120}; +TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getRefreshRateForContent_Explicit) { auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_60, config); + std::make_unique<RefreshRateConfigs>(m60_90Device, + /*currentConfigId=*/HWC_CONFIG_ID_60); - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - auto& lr = layers[0]; + auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}, + LayerRequirement{.weight = 1.0f}}; + auto& lr1 = layers[0]; + auto& lr2 = layers[1]; - lr.vote = LayerVoteType::ExplicitExactOrMultiple; - for (float fps = 23.0f; fps < 25.0f; fps += 0.1f) { - lr.desiredRefreshRate = Fps(fps); - const auto& refreshRate = - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}); - EXPECT_EQ(mExpected60Config, refreshRate) << fps << "Hz chooses " << refreshRate.getName(); - } + lr1.vote = LayerVoteType::Heuristic; + lr1.desiredRefreshRate = 60.0f; + lr2.vote = LayerVoteType::ExplicitExactOrMultiple; + lr2.desiredRefreshRate = 90.0f; + EXPECT_EQ(mExpected90Config, refreshRateConfigs->getRefreshRateForContent(layers)); + + lr1.vote = LayerVoteType::Heuristic; + lr1.desiredRefreshRate = 90.0f; + lr2.vote = LayerVoteType::ExplicitExactOrMultiple; + lr2.desiredRefreshRate = 60.0f; + EXPECT_EQ(mExpected60Config, refreshRateConfigs->getRefreshRateForContent(layers)); } TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getBestRefreshRate_Explicit) { @@ -988,33 +863,33 @@ TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getBestRefreshRate_Explicit) { auto& lr2 = layers[1]; lr1.vote = LayerVoteType::Heuristic; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr2.vote = LayerVoteType::ExplicitExactOrMultiple; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::ExplicitDefault; - lr1.desiredRefreshRate = Fps(90.0f); + lr1.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::ExplicitExactOrMultiple; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::Heuristic; - lr1.desiredRefreshRate = Fps(90.0f); + lr1.desiredRefreshRate = 90.0f; lr2.vote = LayerVoteType::ExplicitExactOrMultiple; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); } TEST_F(RefreshRateConfigsTest, testInPolicy) { - ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(Fps(60.000004f), Fps(60.000004f))); - ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(Fps(59.0f), Fps(60.1f))); - ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(Fps(75.0f), Fps(90.0f))); - ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(Fps(60.0011f), Fps(90.0f))); - ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(Fps(50.0f), Fps(59.998f))); + ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(60.000004f, 60.000004f)); + ASSERT_TRUE(mExpectedAlmost60Config.inPolicy(59.0f, 60.1f)); + ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(75.0f, 90.0f)); + ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(60.0011f, 90.0f)); + ASSERT_FALSE(mExpectedAlmost60Config.inPolicy(50.0f, 59.998f)); } TEST_F(RefreshRateConfigsTest, getBestRefreshRate_75HzContent) { @@ -1027,7 +902,7 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_75HzContent) { lr.vote = LayerVoteType::ExplicitExactOrMultiple; for (float fps = 75.0f; fps < 100.0f; fps += 0.1f) { - lr.desiredRefreshRate = Fps(fps); + lr.desiredRefreshRate = fps; const auto& refreshRate = refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}); EXPECT_EQ(mExpected90Config, refreshRate) << fps << "Hz chooses " << refreshRate.getName(); @@ -1045,25 +920,25 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_Multiples) { auto& lr2 = layers[1]; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::ExplicitDefault; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.name = "90Hz ExplicitDefault"; EXPECT_EQ(mExpected60Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Max; lr2.name = "Max"; @@ -1071,16 +946,16 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_Multiples) { refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(30.0f); + lr1.desiredRefreshRate = 30.0f; lr1.name = "30Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(30.0f); + lr1.desiredRefreshRate = 30.0f; lr1.name = "30Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Max; lr2.name = "Max"; @@ -1099,7 +974,7 @@ TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) { auto& lr2 = layers[1]; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::NoVote; lr2.name = "NoVote"; @@ -1107,7 +982,7 @@ TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) { refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::NoVote; lr2.name = "NoVote"; @@ -1115,7 +990,7 @@ TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) { refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Max; lr2.name = "Max"; @@ -1123,7 +998,7 @@ TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) { refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Max; lr2.name = "Max"; @@ -1132,10 +1007,10 @@ TEST_F(RefreshRateConfigsTest, scrollWhileWatching60fps_60_90) { // The other layer starts to provide buffers lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(90.0f); + lr2.desiredRefreshRate = 90.0f; lr2.name = "90Hz Heuristic"; EXPECT_EQ(mExpected90Config, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); @@ -1159,40 +1034,40 @@ TEST_F(RefreshRateConfigsTest, touchConsidered) { auto& lr2 = layers[1]; lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.name = "60Hz Heuristic"; refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}, &consideredSignals); EXPECT_EQ(true, consideredSignals.touch); lr1.vote = LayerVoteType::ExplicitDefault; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.name = "60Hz Heuristic"; refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}, &consideredSignals); EXPECT_EQ(false, consideredSignals.touch); lr1.vote = LayerVoteType::ExplicitExactOrMultiple; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.name = "60Hz Heuristic"; refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}, &consideredSignals); EXPECT_EQ(true, consideredSignals.touch); lr1.vote = LayerVoteType::ExplicitDefault; - lr1.desiredRefreshRate = Fps(60.0f); + lr1.desiredRefreshRate = 60.0f; lr1.name = "60Hz ExplicitExactOrMultiple"; lr2.vote = LayerVoteType::Heuristic; - lr2.desiredRefreshRate = Fps(60.0f); + lr2.desiredRefreshRate = 60.0f; lr2.name = "60Hz Heuristic"; refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false}, &consideredSignals); @@ -1228,7 +1103,7 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitDefault) { for (const auto& test : testCases) { lr.vote = LayerVoteType::ExplicitDefault; - lr.desiredRefreshRate = Fps(test.first); + lr.desiredRefreshRate = test.first; std::stringstream ss; ss << "ExplicitDefault " << test.first << " fps"; @@ -1236,7 +1111,7 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitDefault) { const auto& refreshRate = refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}); - EXPECT_TRUE(refreshRate.getFps().equalsWithMargin(Fps(test.second))) + EXPECT_FLOAT_EQ(refreshRate.getFps(), test.second) << "Expecting " << test.first << "fps => " << test.second << "Hz"; } } @@ -1248,7 +1123,7 @@ TEST_F(RefreshRateConfigsTest, /*currentConfigId=*/HWC_CONFIG_ID_90); ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_90, {Fps(90.f), Fps(90.f)}, {Fps(60.f), Fps(90.f)}}), + {HWC_CONFIG_ID_90, {90.f, 90.f}, {60.f, 90.f}}), 0); auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; @@ -1256,7 +1131,7 @@ TEST_F(RefreshRateConfigsTest, RefreshRateConfigs::GlobalSignals consideredSignals; lr.vote = LayerVoteType::ExplicitDefault; - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz ExplicitDefault"; lr.focused = true; EXPECT_EQ(mExpected60Config, @@ -1272,14 +1147,14 @@ TEST_F(RefreshRateConfigsTest, /*currentConfigId=*/HWC_CONFIG_ID_60); ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_60, {Fps(60.f), Fps(60.f)}, {Fps(60.f), Fps(90.f)}}), + {HWC_CONFIG_ID_60, {60.f, 60.f}, {60.f, 90.f}}), 0); auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; auto& lr = layers[0]; lr.vote = LayerVoteType::ExplicitDefault; - lr.desiredRefreshRate = Fps(90.0f); + lr.desiredRefreshRate = 90.0f; lr.name = "90Hz ExplicitDefault"; lr.focused = true; EXPECT_EQ(mExpected90Config, @@ -1293,7 +1168,7 @@ TEST_F(RefreshRateConfigsTest, /*currentConfigId=*/HWC_CONFIG_ID_90); ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_90, {Fps(90.f), Fps(90.f)}, {Fps(60.f), Fps(90.f)}}), + {HWC_CONFIG_ID_90, {90.f, 90.f}, {60.f, 90.f}}), 0); RefreshRateConfigs::GlobalSignals consideredSignals; @@ -1306,7 +1181,7 @@ TEST_F(RefreshRateConfigsTest, auto& lr = layers[0]; lr.vote = LayerVoteType::ExplicitExactOrMultiple; - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz ExplicitExactOrMultiple"; lr.focused = false; EXPECT_EQ(mExpected90Config, @@ -1317,7 +1192,7 @@ TEST_F(RefreshRateConfigsTest, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr.vote = LayerVoteType::ExplicitDefault; - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz ExplicitDefault"; lr.focused = false; EXPECT_EQ(mExpected90Config, @@ -1328,7 +1203,7 @@ TEST_F(RefreshRateConfigsTest, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr.vote = LayerVoteType::Heuristic; - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz Heuristic"; lr.focused = false; EXPECT_EQ(mExpected90Config, @@ -1339,7 +1214,7 @@ TEST_F(RefreshRateConfigsTest, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr.vote = LayerVoteType::Max; - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz Max"; lr.focused = false; EXPECT_EQ(mExpected90Config, @@ -1350,7 +1225,7 @@ TEST_F(RefreshRateConfigsTest, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); lr.vote = LayerVoteType::Min; - lr.desiredRefreshRate = Fps(60.0f); + lr.desiredRefreshRate = 60.0f; lr.name = "60Hz Min"; lr.focused = false; EXPECT_EQ(mExpected90Config, @@ -1361,307 +1236,28 @@ TEST_F(RefreshRateConfigsTest, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); } -TEST_F(RefreshRateConfigsTest, groupSwitchingNotAllowed) { +TEST_F(RefreshRateConfigsTest, groupSwitching) { auto refreshRateConfigs = std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, /*currentConfigId=*/HWC_CONFIG_ID_60); - // The default policy doesn't allow group switching. Verify that no - // group switches are performed. auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; auto& layer = layers[0]; layer.vote = LayerVoteType::ExplicitDefault; - layer.desiredRefreshRate = Fps(90.0f); - layer.seamlessness = Seamlessness::SeamedAndSeamless; + layer.desiredRefreshRate = 90.0f; layer.name = "90Hz ExplicitDefault"; - layer.focused = true; ASSERT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} + .getConfigId()); -TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayer) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_60); RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; + policy.defaultConfig = refreshRateConfigs->getCurrentPolicy().defaultConfig; policy.allowGroupSwitching = true; ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - auto& layer = layers[0]; - layer.vote = LayerVoteType::ExplicitDefault; - layer.desiredRefreshRate = Fps(90.0f); - layer.seamlessness = Seamlessness::SeamedAndSeamless; - layer.name = "90Hz ExplicitDefault"; - layer.focused = true; ASSERT_EQ(HWC_CONFIG_ID_90, refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamless) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_60); - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - // Verify that we won't change the group if seamless switch is required. - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - auto& layer = layers[0]; - layer.vote = LayerVoteType::ExplicitDefault; - layer.desiredRefreshRate = Fps(90.0f); - layer.seamlessness = Seamlessness::OnlySeamless; - layer.name = "90Hz ExplicitDefault"; - layer.focused = true; - ASSERT_EQ(HWC_CONFIG_ID_60, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerOnlySeamlessDefaultFps) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_60); - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); - - // Verify that we won't do a seamless switch if we request the same mode as the default - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - auto& layer = layers[0]; - layer.vote = LayerVoteType::ExplicitDefault; - layer.desiredRefreshRate = Fps(60.0f); - layer.seamlessness = Seamlessness::OnlySeamless; - layer.name = "60Hz ExplicitDefault"; - layer.focused = true; - ASSERT_EQ(HWC_CONFIG_ID_90, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, groupSwitchingWithOneLayerDefaultSeamlessness) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_60); - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); - - // Verify that if the current config is in another group and there are no layers with - // seamlessness=SeamedAndSeamless we'll go back to the default group. - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - auto& layer = layers[0]; - layer.vote = LayerVoteType::ExplicitDefault; - layer.desiredRefreshRate = Fps(60.0f); - layer.seamlessness = Seamlessness::Default; - layer.name = "60Hz ExplicitDefault"; - layer.focused = true; - - ASSERT_EQ(HWC_CONFIG_ID_60, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersOnlySeamlessAndSeamed) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_60); - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); - - // If there's a layer with seamlessness=SeamedAndSeamless, another layer with - // seamlessness=OnlySeamless can't change the mode group. - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - layers[0].vote = LayerVoteType::ExplicitDefault; - layers[0].desiredRefreshRate = Fps(60.0f); - layers[0].seamlessness = Seamlessness::OnlySeamless; - layers[0].name = "60Hz ExplicitDefault"; - layers[0].focused = true; - - layers.push_back(LayerRequirement{.weight = 0.5f}); - layers[1].vote = LayerVoteType::ExplicitDefault; - layers[1].seamlessness = Seamlessness::SeamedAndSeamless; - layers[1].desiredRefreshRate = Fps(90.0f); - layers[1].name = "90Hz ExplicitDefault"; - layers[1].focused = false; - - ASSERT_EQ(HWC_CONFIG_ID_90, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultFocusedAndSeamed) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_60); - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); - - // If there's a focused layer with seamlessness=SeamedAndSeamless, another layer with - // seamlessness=Default can't change the mode group back to the group of the default - // mode. - // For example, this may happen when a video playback requests and gets a seamed switch, - // but another layer (with default seamlessness) starts animating. The animating layer - // should not cause a seamed switch. - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - layers[0].seamlessness = Seamlessness::Default; - layers[0].desiredRefreshRate = Fps(60.0f); - layers[0].focused = true; - layers[0].vote = LayerVoteType::ExplicitDefault; - layers[0].name = "60Hz ExplicitDefault"; - - layers.push_back(LayerRequirement{.weight = 0.1f}); - layers[1].seamlessness = Seamlessness::SeamedAndSeamless; - layers[1].desiredRefreshRate = Fps(90.0f); - layers[1].focused = true; - layers[1].vote = LayerVoteType::ExplicitDefault; - layers[1].name = "90Hz ExplicitDefault"; - - ASSERT_EQ(HWC_CONFIG_ID_90, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, groupSwitchingWithTwoLayersDefaultNotFocusedAndSeamed) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_60); - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); - - // Layer with seamlessness=Default can change the mode group if there's a not - // focused layer with seamlessness=SeamedAndSeamless. This happens for example, - // when in split screen mode the user switches between the two visible applications. - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - layers[0].seamlessness = Seamlessness::Default; - layers[0].desiredRefreshRate = Fps(60.0f); - layers[0].focused = true; - layers[0].vote = LayerVoteType::ExplicitDefault; - layers[0].name = "60Hz ExplicitDefault"; - - layers.push_back(LayerRequirement{.weight = 0.7f}); - layers[1].seamlessness = Seamlessness::SeamedAndSeamless; - layers[1].desiredRefreshRate = Fps(90.0f); - layers[1].focused = false; - layers[1].vote = LayerVoteType::ExplicitDefault; - layers[1].name = "90Hz ExplicitDefault"; - - ASSERT_EQ(HWC_CONFIG_ID_60, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, nonSeamlessVotePrefersSeamlessSwitches) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60Device, - /*currentConfigId=*/HWC_CONFIG_ID_60); - - // Allow group switching. - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - auto& layer = layers[0]; - layer.vote = LayerVoteType::ExplicitExactOrMultiple; - layer.desiredRefreshRate = Fps(60.0f); - layer.seamlessness = Seamlessness::SeamedAndSeamless; - layer.name = "60Hz ExplicitExactOrMultiple"; - layer.focused = true; - - ASSERT_EQ(HWC_CONFIG_ID_60, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_120); - ASSERT_EQ(HWC_CONFIG_ID_120, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, nonSeamlessExactAndSeamlessMultipleLayers) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m25_30_50_60Device, - /*currentConfigId=*/HWC_CONFIG_ID_60); - - // Allow group switching. - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - auto layers = std::vector< - LayerRequirement>{LayerRequirement{.name = "60Hz ExplicitDefault", - .vote = LayerVoteType::ExplicitDefault, - .desiredRefreshRate = Fps(60.0f), - .seamlessness = Seamlessness::SeamedAndSeamless, - .weight = 0.5f, - .focused = false}, - LayerRequirement{.name = "25Hz ExplicitExactOrMultiple", - .vote = LayerVoteType::ExplicitExactOrMultiple, - .desiredRefreshRate = Fps(25.0f), - .seamlessness = Seamlessness::OnlySeamless, - .weight = 1.0f, - .focused = true}}; - - ASSERT_EQ(HWC_CONFIG_ID_50, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); - - auto& seamedLayer = layers[0]; - seamedLayer.name = "30Hz ExplicitDefault", seamedLayer.desiredRefreshRate = Fps(30.0f); - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_30); - - ASSERT_EQ(HWC_CONFIG_ID_25, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); -} - -TEST_F(RefreshRateConfigsTest, minLayersDontTrigerSeamedSwitch) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_90DeviceWithDifferentGroups, - /*currentConfigId=*/HWC_CONFIG_ID_90); - - // Allow group switching. - RefreshRateConfigs::Policy policy; - policy.defaultMode = refreshRateConfigs->getCurrentPolicy().defaultMode; - policy.allowGroupSwitching = true; - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy(policy), 0); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.name = "Min", - .vote = LayerVoteType::Min, - .weight = 1.f, - .focused = true}}; - - ASSERT_EQ(HWC_CONFIG_ID_90, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}) - .getModeId()); + .getConfigId()); } TEST_F(RefreshRateConfigsTest, primaryVsAppRequestPolicy) { @@ -1674,54 +1270,53 @@ TEST_F(RefreshRateConfigsTest, primaryVsAppRequestPolicy) { // Return the config ID from calling getBestRefreshRate() for a single layer with the // given voteType and fps. - auto getFrameRate = [&](LayerVoteType voteType, Fps fps, bool touchActive = false, - bool focused = true) -> DisplayModeId { + auto getFrameRate = [&](LayerVoteType voteType, float fps, bool touchActive = false, + bool focused = true) -> HwcConfigIndexType { layers[0].vote = voteType; layers[0].desiredRefreshRate = fps; layers[0].focused = focused; return refreshRateConfigs->getBestRefreshRate(layers, {.touch = touchActive, .idle = false}) - .getModeId(); + .getConfigId(); }; ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_60, {Fps(30.f), Fps(60.f)}, {Fps(30.f), Fps(90.f)}}), + {HWC_CONFIG_ID_60, {30.f, 60.f}, {30.f, 90.f}}), 0); EXPECT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate({}, {.touch = false, .idle = false}) - .getModeId()); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_30, getFrameRate(LayerVoteType::Min, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_90, getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f))); + .getConfigId()); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_30, getFrameRate(LayerVoteType::Min, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_90, getFrameRate(LayerVoteType::ExplicitDefault, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90.f)); // Layers not focused are not allowed to override primary config EXPECT_EQ(HWC_CONFIG_ID_60, - getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f), /*touch=*/false, + getFrameRate(LayerVoteType::ExplicitDefault, 90.f, /*touch=*/false, /*focused=*/false)); EXPECT_EQ(HWC_CONFIG_ID_60, - getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f), /*touch=*/false, + getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90.f, /*touch=*/false, /*focused=*/false)); // Touch boost should be restricted to the primary range. - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, Fps(90.f), /*touch=*/true)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, 90.f, /*touch=*/true)); // When we're higher than the primary range max due to a layer frame rate setting, touch boost // shouldn't drag us back down to the primary range max. - EXPECT_EQ(HWC_CONFIG_ID_90, - getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f), /*touch=*/true)); + EXPECT_EQ(HWC_CONFIG_ID_90, getFrameRate(LayerVoteType::ExplicitDefault, 90.f, /*touch=*/true)); EXPECT_EQ(HWC_CONFIG_ID_60, - getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f), /*touch=*/true)); + getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90.f, /*touch=*/true)); ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_60, {Fps(60.f), Fps(60.f)}, {Fps(60.f), Fps(60.f)}}), + {HWC_CONFIG_ID_60, {60.f, 60.f}, {60.f, 60.f}}), 0); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Min, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitDefault, Fps(90.f))); - EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, Fps(90.f))); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::NoVote, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Min, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Max, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::Heuristic, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitDefault, 90.f)); + EXPECT_EQ(HWC_CONFIG_ID_60, getFrameRate(LayerVoteType::ExplicitExactOrMultiple, 90.f)); } TEST_F(RefreshRateConfigsTest, idle) { @@ -1732,22 +1327,23 @@ TEST_F(RefreshRateConfigsTest, idle) { auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; layers[0].name = "Test layer"; - const auto getIdleFrameRate = [&](LayerVoteType voteType, bool touchActive) -> DisplayModeId { + const auto getIdleFrameRate = [&](LayerVoteType voteType, + bool touchActive) -> HwcConfigIndexType { layers[0].vote = voteType; - layers[0].desiredRefreshRate = Fps(90.f); + layers[0].desiredRefreshRate = 90.f; RefreshRateConfigs::GlobalSignals consideredSignals; const auto configId = refreshRateConfigs ->getBestRefreshRate(layers, {.touch = touchActive, .idle = true}, &consideredSignals) - .getModeId(); + .getConfigId(); // Refresh rate will be chosen by either touch state or idle state EXPECT_EQ(!touchActive, consideredSignals.idle); return configId; }; ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_60, {Fps(60.f), Fps(90.f)}, {Fps(60.f), Fps(90.f)}}), + {HWC_CONFIG_ID_60, {60.f, 90.f}, {60.f, 90.f}}), 0); // Idle should be lower priority than touch boost. @@ -1763,10 +1359,10 @@ TEST_F(RefreshRateConfigsTest, idle) { // With no layers, idle should still be lower priority than touch boost. EXPECT_EQ(HWC_CONFIG_ID_90, refreshRateConfigs->getBestRefreshRate({}, {.touch = true, .idle = true}) - .getModeId()); + .getConfigId()); // Idle should be higher precedence than other layer frame rate considerations. - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); + refreshRateConfigs->setCurrentConfigId(HWC_CONFIG_ID_90); EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::NoVote, /*touchActive=*/false)); EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Min, /*touchActive=*/false)); EXPECT_EQ(HWC_CONFIG_ID_60, getIdleFrameRate(LayerVoteType::Max, /*touchActive=*/false)); @@ -1779,7 +1375,7 @@ TEST_F(RefreshRateConfigsTest, idle) { // Idle should be applied rather than the current config when there are no layers. EXPECT_EQ(HWC_CONFIG_ID_60, refreshRateConfigs->getBestRefreshRate({}, {.touch = false, .idle = true}) - .getModeId()); + .getConfigId()); } TEST_F(RefreshRateConfigsTest, findClosestKnownFrameRate) { @@ -1788,22 +1384,22 @@ TEST_F(RefreshRateConfigsTest, findClosestKnownFrameRate) { /*currentConfigId=*/HWC_CONFIG_ID_60); for (float fps = 1.0f; fps <= 120.0f; fps += 0.1f) { - const auto knownFrameRate = findClosestKnownFrameRate(*refreshRateConfigs, Fps(fps)); - Fps expectedFrameRate; + const auto knownFrameRate = findClosestKnownFrameRate(*refreshRateConfigs, fps); + float expectedFrameRate; if (fps < 26.91f) { - expectedFrameRate = Fps(24.0f); + expectedFrameRate = 24.0f; } else if (fps < 37.51f) { - expectedFrameRate = Fps(30.0f); + expectedFrameRate = 30.0f; } else if (fps < 52.51f) { - expectedFrameRate = Fps(45.0f); + expectedFrameRate = 45.0f; } else if (fps < 66.01f) { - expectedFrameRate = Fps(60.0f); + expectedFrameRate = 60.0f; } else if (fps < 81.01f) { - expectedFrameRate = Fps(72.0f); + expectedFrameRate = 72.0f; } else { - expectedFrameRate = Fps(90.0f); + expectedFrameRate = 90.0f; } - EXPECT_TRUE(expectedFrameRate.equalsWithMargin(knownFrameRate)) + EXPECT_FLOAT_EQ(expectedFrameRate, knownFrameRate) << "findClosestKnownFrameRate(" << fps << ") = " << knownFrameRate; } } @@ -1814,27 +1410,26 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_KnownFrameRate) { /*currentConfigId=*/HWC_CONFIG_ID_60); struct ExpectedRate { - Fps rate; + float rate; const RefreshRate& expected; }; /* clang-format off */ std::vector<ExpectedRate> knownFrameRatesExpectations = { - {Fps(24.0f), mExpected60Config}, - {Fps(30.0f), mExpected60Config}, - {Fps(45.0f), mExpected90Config}, - {Fps(60.0f), mExpected60Config}, - {Fps(72.0f), mExpected90Config}, - {Fps(90.0f), mExpected90Config}, + {24.0f, mExpected60Config}, + {30.0f, mExpected60Config}, + {45.0f, mExpected90Config}, + {60.0f, mExpected60Config}, + {72.0f, mExpected90Config}, + {90.0f, mExpected90Config}, }; /* clang-format on */ // Make sure the test tests all the known frame rate const auto knownFrameRateList = getKnownFrameRate(*refreshRateConfigs); - const auto equal = - std::equal(knownFrameRateList.begin(), knownFrameRateList.end(), - knownFrameRatesExpectations.begin(), - [](Fps a, const ExpectedRate& b) { return a.equalsWithMargin(b.rate); }); + const auto equal = std::equal(knownFrameRateList.begin(), knownFrameRateList.end(), + knownFrameRatesExpectations.begin(), + [](float a, const ExpectedRate& b) { return a == b.rate; }); EXPECT_TRUE(equal); auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; @@ -1848,193 +1443,6 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_KnownFrameRate) { } } -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExact) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_60); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}, - LayerRequirement{.weight = 0.5f}}; - auto& explicitExactLayer = layers[0]; - auto& explicitExactOrMultipleLayer = layers[1]; - - explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple; - explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple"; - explicitExactOrMultipleLayer.desiredRefreshRate = Fps(60); - - explicitExactLayer.vote = LayerVoteType::ExplicitExact; - explicitExactLayer.name = "ExplicitExact"; - explicitExactLayer.desiredRefreshRate = Fps(30); - - EXPECT_EQ(mExpected30Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - EXPECT_EQ(mExpected30Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); - - explicitExactOrMultipleLayer.desiredRefreshRate = Fps(120); - explicitExactLayer.desiredRefreshRate = Fps(60); - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - explicitExactLayer.desiredRefreshRate = Fps(72); - EXPECT_EQ(mExpected72Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - explicitExactLayer.desiredRefreshRate = Fps(90); - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - explicitExactLayer.desiredRefreshRate = Fps(120); - EXPECT_EQ(mExpected120Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); -} - -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) { - RefreshRateConfigs::Config config = {.enableFrameRateOverride = true}; - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_60, config); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}, - LayerRequirement{.weight = 0.5f}}; - auto& explicitExactLayer = layers[0]; - auto& explicitExactOrMultipleLayer = layers[1]; - - explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple; - explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple"; - explicitExactOrMultipleLayer.desiredRefreshRate = Fps(60); - - explicitExactLayer.vote = LayerVoteType::ExplicitExact; - explicitExactLayer.name = "ExplicitExact"; - explicitExactLayer.desiredRefreshRate = Fps(30); - - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - EXPECT_EQ(mExpected120Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); - - explicitExactOrMultipleLayer.desiredRefreshRate = Fps(120); - explicitExactLayer.desiredRefreshRate = Fps(60); - EXPECT_EQ(mExpected120Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - explicitExactLayer.desiredRefreshRate = Fps(72); - EXPECT_EQ(mExpected72Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - explicitExactLayer.desiredRefreshRate = Fps(90); - EXPECT_EQ(mExpected90Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - - explicitExactLayer.desiredRefreshRate = Fps(120); - EXPECT_EQ(mExpected120Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); -} - -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ReadsCached) { - using GlobalSignals = RefreshRateConfigs::GlobalSignals; - - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_60); - - setLastBestRefreshRateInvocation(*refreshRateConfigs, - GetBestRefreshRateInvocation{.layerRequirements = std::vector< - LayerRequirement>(), - .globalSignals = {.touch = true, - .idle = true}, - .outSignalsConsidered = - {.touch = true, - .idle = false}, - .resultingBestRefreshRate = - createRefreshRate( - mConfig90)}); - - EXPECT_EQ(createRefreshRate(mConfig90), - refreshRateConfigs->getBestRefreshRate(std::vector<LayerRequirement>(), - {.touch = true, .idle = true})); - - const GlobalSignals cachedSignalsConsidered{.touch = true, .idle = false}; - setLastBestRefreshRateInvocation(*refreshRateConfigs, - GetBestRefreshRateInvocation{.layerRequirements = std::vector< - LayerRequirement>(), - .globalSignals = {.touch = true, - .idle = true}, - .outSignalsConsidered = - cachedSignalsConsidered, - .resultingBestRefreshRate = - createRefreshRate( - mConfig30)}); - - GlobalSignals signalsConsidered; - EXPECT_EQ(createRefreshRate(mConfig30), - refreshRateConfigs->getBestRefreshRate(std::vector<LayerRequirement>(), - {.touch = true, .idle = true}, - &signalsConsidered)); - - EXPECT_EQ(cachedSignalsConsidered, signalsConsidered); -} - -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_WritesCache) { - using GlobalSignals = RefreshRateConfigs::GlobalSignals; - - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_60); - ASSERT_FALSE(getLastBestRefreshRateInvocation(*refreshRateConfigs).has_value()); - - GlobalSignals globalSignals{.touch = true, .idle = true}; - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}, - LayerRequirement{.weight = 0.5f}}; - const auto lastResult = - refreshRateConfigs->getBestRefreshRate(layers, globalSignals, - /* outSignalsConsidered */ nullptr); - - const auto lastInvocation = getLastBestRefreshRateInvocation(*refreshRateConfigs); - - ASSERT_TRUE(lastInvocation.has_value()); - ASSERT_EQ(layers, lastInvocation->layerRequirements); - ASSERT_EQ(globalSignals, lastInvocation->globalSignals); - ASSERT_EQ(lastResult, lastInvocation->resultingBestRefreshRate); - - // outSignalsConsidered needs to be populated even tho earlier we gave nullptr - // to getBestRefreshRate() - GlobalSignals detaultSignals; - ASSERT_FALSE(detaultSignals == lastInvocation->outSignalsConsidered); -} - -TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactTouchBoost) { - RefreshRateConfigs::Config config = {.enableFrameRateOverride = true}; - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_60, config); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}, - LayerRequirement{.weight = 0.5f}}; - auto& explicitExactLayer = layers[0]; - auto& explicitExactOrMultipleLayer = layers[1]; - - explicitExactOrMultipleLayer.vote = LayerVoteType::ExplicitExactOrMultiple; - explicitExactOrMultipleLayer.name = "ExplicitExactOrMultiple"; - explicitExactOrMultipleLayer.desiredRefreshRate = Fps(60); - - explicitExactLayer.vote = LayerVoteType::ExplicitExact; - explicitExactLayer.name = "ExplicitExact"; - explicitExactLayer.desiredRefreshRate = Fps(30); - - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - EXPECT_EQ(mExpected120Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); - - explicitExactOrMultipleLayer.vote = LayerVoteType::NoVote; - - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false})); - EXPECT_EQ(mExpected60Config, - refreshRateConfigs->getBestRefreshRate(layers, {.touch = true, .idle = false})); -} - TEST_F(RefreshRateConfigsTest, testComparisonOperator) { EXPECT_TRUE(mExpected60Config < mExpected90Config); EXPECT_FALSE(mExpected60Config < mExpected60Config); @@ -2051,250 +1459,18 @@ TEST_F(RefreshRateConfigsTest, testKernelIdleTimerAction) { EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction()); // SetPolicy(60, 90), current 60Hz => TurnOn. - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(90)}}), - 0); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60, 90}}), 0); EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction()); - // SetPolicy(60, 60), current 60Hz => TurnOff - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}), - 0); - EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction()); + // SetPolicy(60, 60), current 60Hz => NoChange, avoid extra calls. + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {60, 60}}), 0); + EXPECT_EQ(KernelIdleTimerAction::NoChange, refreshRateConfigs->getIdleTimerAction()); // SetPolicy(90, 90), current 90Hz => TurnOff. - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {Fps(90), Fps(90)}}), - 0); + ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_90, {90, 90}}), 0); EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction()); } -TEST_F(RefreshRateConfigsTest, testKernelIdleTimerActionFor120Hz) { - using KernelIdleTimerAction = scheduler::RefreshRateConfigs::KernelIdleTimerAction; - - // Tests with 120Hz - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m60_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_120); - // SetPolicy(0, 60), current 60Hz => TurnOn. - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(0), Fps(60)}}), - 0); - EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction()); - - // SetPolicy(60, 60), current 60Hz => TurnOff. - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(60)}}), - 0); - EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction()); - - // SetPolicy(60, 120), current 60Hz => TurnOn. - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy({HWC_CONFIG_ID_60, {Fps(60), Fps(120)}}), - 0); - EXPECT_EQ(KernelIdleTimerAction::TurnOn, refreshRateConfigs->getIdleTimerAction()); - - // SetPolicy(120, 120), current 120Hz => TurnOff. - ASSERT_GE(refreshRateConfigs->setDisplayManagerPolicy( - {HWC_CONFIG_ID_120, {Fps(120), Fps(120)}}), - 0); - EXPECT_EQ(KernelIdleTimerAction::TurnOff, refreshRateConfigs->getIdleTimerAction()); -} - -TEST_F(RefreshRateConfigsTest, getFrameRateDivider) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_30); - - const auto frameRate = Fps(30.f); - Fps displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps(); - EXPECT_EQ(1, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate)); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_60); - displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps(); - EXPECT_EQ(2, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate)); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_72); - displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps(); - EXPECT_EQ(0, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate)); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); - displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps(); - EXPECT_EQ(3, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate)); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_120); - displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps(); - EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, frameRate)); - - refreshRateConfigs->setCurrentModeId(HWC_CONFIG_ID_90); - displayRefreshRate = refreshRateConfigs->getCurrentRefreshRate().getFps(); - EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, Fps(22.5f))); - EXPECT_EQ(4, RefreshRateConfigs::getFrameRateDivider(displayRefreshRate, Fps(22.6f))); -} - -TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_noLayers) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/ - HWC_CONFIG_ID_120); - - auto layers = std::vector<LayerRequirement>{}; - ASSERT_TRUE(refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false) - .empty()); -} - -TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_60on120) { - RefreshRateConfigs::Config config = {.enableFrameRateOverride = true}; - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/ - HWC_CONFIG_ID_120, config); - - auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}}; - layers[0].name = "Test layer"; - layers[0].ownerUid = 1234; - layers[0].desiredRefreshRate = Fps(60.0f); - layers[0].vote = LayerVoteType::ExplicitDefault; - auto frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - layers[0].vote = LayerVoteType::ExplicitExactOrMultiple; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - layers[0].vote = LayerVoteType::NoVote; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_TRUE(frameRateOverrides.empty()); - - layers[0].vote = LayerVoteType::Min; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_TRUE(frameRateOverrides.empty()); - - layers[0].vote = LayerVoteType::Max; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_TRUE(frameRateOverrides.empty()); - - layers[0].vote = LayerVoteType::Heuristic; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_TRUE(frameRateOverrides.empty()); -} - -TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_twoUids) { - RefreshRateConfigs::Config config = {.enableFrameRateOverride = true}; - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/ - HWC_CONFIG_ID_120, config); - - auto layers = std::vector<LayerRequirement>{ - LayerRequirement{.ownerUid = 1234, .weight = 1.0f}, - LayerRequirement{.ownerUid = 5678, .weight = 1.0f}, - }; - - layers[0].name = "Test layer 1234"; - layers[0].desiredRefreshRate = Fps(60.0f); - layers[0].vote = LayerVoteType::ExplicitDefault; - - layers[1].name = "Test layer 5678"; - layers[1].desiredRefreshRate = Fps(30.0f); - layers[1].vote = LayerVoteType::ExplicitDefault; - auto frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - - ASSERT_EQ(2, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - ASSERT_EQ(1, frameRateOverrides.count(5678)); - ASSERT_EQ(30.0f, frameRateOverrides.at(5678).getValue()); - - layers[1].vote = LayerVoteType::Heuristic; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - layers[1].ownerUid = 1234; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_TRUE(frameRateOverrides.empty()); -} - -TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_touch) { - RefreshRateConfigs::Config config = {.enableFrameRateOverride = true}; - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /*currentConfigId=*/ - HWC_CONFIG_ID_120, config); - - auto layers = std::vector<LayerRequirement>{ - LayerRequirement{.ownerUid = 1234, .weight = 1.0f}, - }; - - layers[0].name = "Test layer"; - layers[0].desiredRefreshRate = Fps(60.0f); - layers[0].vote = LayerVoteType::ExplicitDefault; - - auto frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/true); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - layers[0].vote = LayerVoteType::ExplicitExact; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/true); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - layers[0].vote = LayerVoteType::ExplicitExactOrMultiple; - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/false); - ASSERT_EQ(1, frameRateOverrides.size()); - ASSERT_EQ(1, frameRateOverrides.count(1234)); - ASSERT_EQ(60.0f, frameRateOverrides.at(1234).getValue()); - - frameRateOverrides = - refreshRateConfigs->getFrameRateOverrides(layers, Fps(120.0f), /*touch=*/true); - ASSERT_TRUE(frameRateOverrides.empty()); -} - -TEST_F(RefreshRateConfigsTest, updateDisplayModes) { - auto refreshRateConfigs = - std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, - /*currentConfigId=*/HWC_CONFIG_ID_30); - refreshRateConfigs->setDisplayManagerPolicy({DisplayModeId(HWC_CONFIG_ID_30), - /* allowGroupSwitching */ false, - /* range */ {Fps(30.0f), Fps(30.0f)}}); - - refreshRateConfigs->updateDisplayModes(m60_90Device, HWC_CONFIG_ID_60); - - const auto currentRefreshRate = refreshRateConfigs->getCurrentRefreshRate(); - EXPECT_TRUE(currentRefreshRate.getFps().equalsWithMargin(Fps(60.0))); - EXPECT_EQ(currentRefreshRate.getModeId(), HWC_CONFIG_ID_60); - - EXPECT_TRUE( - getMaxSupportedRefreshRate(*refreshRateConfigs).getFps().equalsWithMargin(Fps(90.0))); - EXPECT_TRUE( - getMinSupportedRefreshRate(*refreshRateConfigs).getFps().equalsWithMargin(Fps(60.0))); -} - } // namespace } // namespace scheduler } // namespace android - -// TODO(b/129481165): remove the #pragma below and fix conversion issues -#pragma clang diagnostic pop // ignored "-Wextra" |