Merge "Add sysprop for refresh rate threshold." into sc-dev (c14d1a9f) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/Scheduler/RefreshRateConfigs.cpp

+36 −6

Original line number	Original line	Diff line number	Diff line
	@@ -107,9 +107,39 @@ std::pair<nsecs_t, nsecs_t> RefreshRateConfigs::getDisplayFrames(nsecs_t layerPe
	return {quotient, remainder};		return {quotient, remainder};
	}		}

			bool RefreshRateConfigs::isVoteAllowed(const LayerRequirement& layer,
			const RefreshRate& refreshRate) const {
			switch (layer.vote) {
			case LayerVoteType::ExplicitExactOrMultiple:
			case LayerVoteType::Heuristic:
			if (mConfig.frameRateMultipleThreshold != 0 &&
			refreshRate.fps.greaterThanOrEqualWithMargin(
			Fps(mConfig.frameRateMultipleThreshold)) &&
			layer.desiredRefreshRate.lessThanWithMargin(
			Fps(mConfig.frameRateMultipleThreshold / 2))) {
			// Don't vote high refresh rates past the threshold for layers with a low desired
			// refresh rate. For example, desired 24 fps with 120 Hz threshold means no vote for
			// 120 Hz, but desired 60 fps should have a vote.
			return false;
			}
			break;
			case LayerVoteType::ExplicitDefault:
			case LayerVoteType::ExplicitExact:
			case LayerVoteType::Max:
			case LayerVoteType::Min:
			case LayerVoteType::NoVote:
			break;
			}
			return true;
			}

	float RefreshRateConfigs::calculateLayerScoreLocked(const LayerRequirement& layer,		float RefreshRateConfigs::calculateLayerScoreLocked(const LayerRequirement& layer,
	const RefreshRate& refreshRate,		const RefreshRate& refreshRate,
	bool isSeamlessSwitch) const {		bool isSeamlessSwitch) const {
			if (!isVoteAllowed(layer, refreshRate)) {
			return 0;
			}

	// Slightly prefer seamless switches.		// Slightly prefer seamless switches.
	constexpr float kSeamedSwitchPenalty = 0.95f;		constexpr float kSeamedSwitchPenalty = 0.95f;
	const float seamlessness = isSeamlessSwitch ? 1.0f : kSeamedSwitchPenalty;		const float seamlessness = isSeamlessSwitch ? 1.0f : kSeamedSwitchPenalty;
	@@ -331,8 +361,9 @@ RefreshRate RefreshRateConfigs::getBestRefreshRateLocked(
	const auto& defaultMode = mRefreshRates.at(policy->defaultMode);		const auto& defaultMode = mRefreshRates.at(policy->defaultMode);

	for (const auto& layer : layers) {		for (const auto& layer : layers) {
	ALOGV("Calculating score for %s (%s, weight %.2f)", layer.name.c_str(),		ALOGV("Calculating score for %s (%s, weight %.2f, desired %.2f) ", layer.name.c_str(),
	layerVoteTypeString(layer.vote).c_str(), layer.weight);		layerVoteTypeString(layer.vote).c_str(), layer.weight,
			layer.desiredRefreshRate.getValue());
	if (layer.vote == LayerVoteType::NoVote \|\| layer.vote == LayerVoteType::Min) {		if (layer.vote == LayerVoteType::NoVote \|\| layer.vote == LayerVoteType::Min) {
	continue;		continue;
	}		}
	@@ -646,9 +677,8 @@ void RefreshRateConfigs::setCurrentModeId(DisplayModeId modeId) {
	}		}

	RefreshRateConfigs::RefreshRateConfigs(const DisplayModes& modes, DisplayModeId currentModeId,		RefreshRateConfigs::RefreshRateConfigs(const DisplayModes& modes, DisplayModeId currentModeId,
	bool enableFrameRateOverride)		Config config)
	: mKnownFrameRates(constructKnownFrameRates(modes)),		: mKnownFrameRates(constructKnownFrameRates(modes)), mConfig(config) {
	mEnableFrameRateOverride(enableFrameRateOverride) {
	updateDisplayModes(modes, currentModeId);		updateDisplayModes(modes, currentModeId);
	}		}

	@@ -685,7 +715,7 @@ void RefreshRateConfigs::updateDisplayModes(const DisplayModes& modes,
	mMaxSupportedRefreshRate = sortedModes.back();		mMaxSupportedRefreshRate = sortedModes.back();

	mSupportsFrameRateOverride = false;		mSupportsFrameRateOverride = false;
	if (mEnableFrameRateOverride) {		if (mConfig.enableFrameRateOverride) {
	for (const auto& mode1 : sortedModes) {		for (const auto& mode1 : sortedModes) {
	for (const auto& mode2 : sortedModes) {		for (const auto& mode2 : sortedModes) {
	if (getFrameRateDivider(mode1->getFps(), mode2->getFps()) >= 2) {		if (getFrameRateDivider(mode1->getFps(), mode2->getFps()) >= 2) {

services/surfaceflinger/Scheduler/RefreshRateConfigs.h

+17 −3

Original line number	Original line	Diff line number	Diff line
	@@ -302,8 +302,19 @@ public:
	// Returns a known frame rate that is the closest to frameRate		// Returns a known frame rate that is the closest to frameRate
	Fps findClosestKnownFrameRate(Fps frameRate) const;		Fps findClosestKnownFrameRate(Fps frameRate) const;

			// Configuration flags.
			struct Config {
			bool enableFrameRateOverride = false;

			// Specifies the upper refresh rate threshold (inclusive) for layer vote types of multiple
			// or heuristic, such that refresh rates higher than this value will not be voted for. 0 if
			// no threshold is set.
			int frameRateMultipleThreshold = 0;
			};

	RefreshRateConfigs(const DisplayModes& modes, DisplayModeId currentModeId,		RefreshRateConfigs(const DisplayModes& modes, DisplayModeId currentModeId,
	bool enableFrameRateOverride = false);		Config config = {.enableFrameRateOverride = false,
			.frameRateMultipleThreshold = 0});

	void updateDisplayModes(const DisplayModes& mode, DisplayModeId currentModeId) EXCLUDES(mLock);		void updateDisplayModes(const DisplayModes& mode, DisplayModeId currentModeId) EXCLUDES(mLock);

	@@ -387,6 +398,9 @@ private:
	const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);		const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
	bool isPolicyValidLocked(const Policy& policy) const REQUIRES(mLock);		bool isPolicyValidLocked(const Policy& policy) const REQUIRES(mLock);

			// Returns whether the layer is allowed to vote for the given refresh rate.
			bool isVoteAllowed(const LayerRequirement&, const RefreshRate&) const;

	// calculates a score for a layer. Used to determine the display refresh rate		// calculates a score for a layer. Used to determine the display refresh rate
	// and the frame rate override for certains applications.		// and the frame rate override for certains applications.
	float calculateLayerScoreLocked(const LayerRequirement&, const RefreshRate&,		float calculateLayerScoreLocked(const LayerRequirement&, const RefreshRate&,
	@@ -424,7 +438,7 @@ private:
	// from based on the closest value.		// from based on the closest value.
	const std::vector<Fps> mKnownFrameRates;		const std::vector<Fps> mKnownFrameRates;

	const bool mEnableFrameRateOverride;		const Config mConfig;
	bool mSupportsFrameRateOverride;		bool mSupportsFrameRateOverride;

	struct GetBestRefreshRateInvocation {		struct GetBestRefreshRateInvocation {

services/surfaceflinger/SurfaceFlinger.cpp

+9 −4

Original line number	Original line	Diff line number	Diff line
	@@ -3118,10 +3118,15 @@ void SurfaceFlinger::initScheduler(const DisplayDeviceState& displayState) {
	return;		return;
	}		}
	const auto displayId = displayState.physical->id;		const auto displayId = displayState.physical->id;
	mRefreshRateConfigs = std::make_unique<		scheduler::RefreshRateConfigs::Config config =
	scheduler::RefreshRateConfigs>(displayState.physical->supportedModes,		{.enableFrameRateOverride = android::sysprop::enable_frame_rate_override(false),
	displayState.physical->activeMode->getId(),		.frameRateMultipleThreshold =
	android::sysprop::enable_frame_rate_override(false));		base::GetIntProperty("debug.sf.frame_rate_multiple_threshold", 0)};
			mRefreshRateConfigs =
			std::make_unique<scheduler::RefreshRateConfigs>(displayState.physical->supportedModes,
			displayState.physical->activeMode
			->getId(),
			config);
	const auto currRefreshRate = displayState.physical->activeMode->getFps();		const auto currRefreshRate = displayState.physical->activeMode->getFps();
	mRefreshRateStats = std::make_unique<scheduler::RefreshRateStats>(*mTimeStats, currRefreshRate,		mRefreshRateStats = std::make_unique<scheduler::RefreshRateStats>(*mTimeStats, currRefreshRate,
	hal::PowerMode::OFF);		hal::PowerMode::OFF);

services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp

+168 −10

Original line number	Original line	Diff line number	Diff line
	@@ -165,6 +165,7 @@ protected:
	RefreshRate::ConstructorTag(0)};		RefreshRate::ConstructorTag(0)};
	RefreshRate mExpected120Config = {HWC_CONFIG_ID_120, mConfig120, Fps(120),		RefreshRate mExpected120Config = {HWC_CONFIG_ID_120, mConfig120, Fps(120),
	RefreshRate::ConstructorTag(0)};		RefreshRate::ConstructorTag(0)};

	private:		private:
	DisplayModePtr createDisplayMode(DisplayModeId modeId, int32_t group, int64_t vsyncPeriod,		DisplayModePtr createDisplayMode(DisplayModeId modeId, int32_t group, int64_t vsyncPeriod,
	ui::Size resolution = ui::Size());		ui::Size resolution = ui::Size());
	@@ -487,6 +488,52 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_90) {
	refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));		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];

			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.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";
			EXPECT_EQ(mExpected60Config,
			refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));

			lr.desiredRefreshRate = Fps(45.0f);
			lr.name = "45Hz Heuristic";
			EXPECT_EQ(mExpected90Config,
			refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));

			lr.desiredRefreshRate = Fps(30.0f);
			lr.name = "30Hz Heuristic";
			EXPECT_EQ(mExpected60Config,
			refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));

			lr.desiredRefreshRate = Fps(24.0f);
			lr.name = "24Hz Heuristic";
			EXPECT_EQ(mExpected60Config,
			refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
			}

	TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) {		TEST_F(RefreshRateConfigsTest, getBestRefreshRate_60_72_90) {
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m60_72_90Device,		std::make_unique<RefreshRateConfigs>(m60_72_90Device,
	@@ -649,6 +696,99 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60_90_120_DifferentTypes) {
	refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));		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.vote = LayerVoteType::ExplicitExactOrMultiple;
			lr2.name = "90Hz ExplicitExactOrMultiple";
			EXPECT_EQ(mExpected90Config,
			refreshRateConfigs->getBestRefreshRate(layers, {.touch = false, .idle = false}));
			}

	TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) {		TEST_F(RefreshRateConfigsTest, getBestRefreshRate_30_60) {
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m30_60Device,		std::make_unique<RefreshRateConfigs>(m30_60Device,
	@@ -819,6 +959,24 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo) {
	}		}
	}		}

			TEST_F(RefreshRateConfigsTest, getBestRefreshRate_24FpsVideo_multipleThreshold_60_120) {
			RefreshRateConfigs::Config config = {.frameRateMultipleThreshold = 120};
			auto refreshRateConfigs =
			std::make_unique<RefreshRateConfigs>(m60_120Device,
			/currentConfigId=/HWC_CONFIG_ID_60, config);

			auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
			auto& lr = layers[0];

			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();
			}
			}

	TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getBestRefreshRate_Explicit) {		TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_getBestRefreshRate_Explicit) {
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m60_90Device,		std::make_unique<RefreshRateConfigs>(m60_90Device,
	@@ -1732,10 +1890,10 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExact) {
	}		}

	TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) {		TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactEnableFrameRateOverride) {
			RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,		std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device,
	/currentConfigId=/HWC_CONFIG_ID_60,		/currentConfigId=/HWC_CONFIG_ID_60, config);
	/enableFrameRateOverride=/true);

	auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},		auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
	LayerRequirement{.weight = 0.5f}};		LayerRequirement{.weight = 0.5f}};
	@@ -1846,10 +2004,10 @@ TEST_F(RefreshRateConfigsTest, getBestRefreshRate_WritesCache) {
	}		}

	TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactTouchBoost) {		TEST_F(RefreshRateConfigsTest, getBestRefreshRate_ExplicitExactTouchBoost) {
			RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m60_120Device,		std::make_unique<RefreshRateConfigs>(m60_120Device,
	/currentConfigId=/HWC_CONFIG_ID_60,		/currentConfigId=/HWC_CONFIG_ID_60, config);
	/enableFrameRateOverride=/true);

	auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},		auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f},
	LayerRequirement{.weight = 0.5f}};		LayerRequirement{.weight = 0.5f}};
	@@ -1950,10 +2108,10 @@ TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_noLayers) {
	}		}

	TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_60on120) {		TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_60on120) {
			RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /currentConfigId=/		std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /currentConfigId=/
	HWC_CONFIG_ID_120,		HWC_CONFIG_ID_120, config);
	/enableFrameRateOverride=/true);

	auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};		auto layers = std::vector<LayerRequirement>{LayerRequirement{.weight = 1.0f}};
	layers[0].name = "Test layer";		layers[0].name = "Test layer";
	@@ -1995,10 +2153,10 @@ TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_60on120) {
	}		}

	TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_twoUids) {		TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_twoUids) {
			RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /currentConfigId=/		std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /currentConfigId=/
	HWC_CONFIG_ID_120,		HWC_CONFIG_ID_120, config);
	/enableFrameRateOverride=/true);

	auto layers = std::vector<LayerRequirement>{		auto layers = std::vector<LayerRequirement>{
	LayerRequirement{.ownerUid = 1234, .weight = 1.0f},		LayerRequirement{.ownerUid = 1234, .weight = 1.0f},
	@@ -2035,10 +2193,10 @@ TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_twoUids) {
	}		}

	TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_touch) {		TEST_F(RefreshRateConfigsTest, getFrameRateOverrides_touch) {
			RefreshRateConfigs::Config config = {.enableFrameRateOverride = true};
	auto refreshRateConfigs =		auto refreshRateConfigs =
	std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /currentConfigId=/		std::make_unique<RefreshRateConfigs>(m30_60_72_90_120Device, /currentConfigId=/
	HWC_CONFIG_ID_120,		HWC_CONFIG_ID_120, config);
	/enableFrameRateOverride=/true);

	auto layers = std::vector<LayerRequirement>{		auto layers = std::vector<LayerRequirement>{
	LayerRequirement{.ownerUid = 1234, .weight = 1.0f},		LayerRequirement{.ownerUid = 1234, .weight = 1.0f},