Merge "Rename RefreshRateOverlay vsyncRate to RefreshRate" into main (67ea1030) · Commits · e / os / android_frameworks_native

services/surfaceflinger/DisplayDevice.cpp

+2 −2

Original line number	Diff line number	Diff line
		@@ -485,11 +485,11 @@ void DisplayDevice::enableRefreshRateOverlay(bool enable, bool setByHwc, bool sh
		}
		}

		void DisplayDevice::updateRefreshRateOverlayRate(Fps vsyncRate, Fps renderFps, bool setByHwc) {
		void DisplayDevice::updateRefreshRateOverlayRate(Fps refreshRate, Fps renderFps, bool setByHwc) {
		ATRACE_CALL();
		if (mRefreshRateOverlay) {
		if (!mRefreshRateOverlay->isSetByHwc() \|\| setByHwc) {
		mRefreshRateOverlay->changeRefreshRate(vsyncRate, renderFps);
		mRefreshRateOverlay->changeRefreshRate(refreshRate, renderFps);
		} else {
		mRefreshRateOverlay->changeRenderRate(renderFps);
		}

services/surfaceflinger/DisplayDevice.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -226,7 +226,7 @@ public:
		// Enables an overlay to be displayed with the current refresh rate
		void enableRefreshRateOverlay(bool enable, bool setByHwc, bool showSpinner, bool showRenderRate,
		bool showInMiddle) REQUIRES(kMainThreadContext);
		void updateRefreshRateOverlayRate(Fps vsyncRate, Fps renderFps, bool setByHwc = false);
		void updateRefreshRateOverlayRate(Fps refreshRate, Fps renderFps, bool setByHwc = false);
		bool isRefreshRateOverlayEnabled() const { return mRefreshRateOverlay != nullptr; }
		bool onKernelTimerChanged(std::optional<DisplayModeId>, bool timerExpired);

services/surfaceflinger/RefreshRateOverlay.cpp

+14 −13

Original line number	Diff line number	Diff line
		@@ -28,7 +28,7 @@

		namespace android {

		auto RefreshRateOverlay::draw(int vsyncRate, int renderFps, SkColor color,
		auto RefreshRateOverlay::draw(int refreshRate, int renderFps, SkColor color,
		ui::Transform::RotationFlags rotation, ftl::Flags<Features> features)
		-> Buffers {
		const size_t loopCount = features.test(Features::Spinner) ? 6 : 1;
		@@ -71,7 +71,7 @@ auto RefreshRateOverlay::draw(int vsyncRate, int renderFps, SkColor color,
		canvas->setMatrix(canvasTransform);

		int left = 0;
		drawNumber(vsyncRate, left, color, *canvas);
		drawNumber(refreshRate, left, color, *canvas);
		left += 3 * (kDigitWidth + kDigitSpace);
		if (features.test(Features::Spinner)) {
		switch (i) {
		@@ -171,7 +171,7 @@ bool RefreshRateOverlay::initCheck() const {
		return mSurfaceControl != nullptr;
		}

		auto RefreshRateOverlay::getOrCreateBuffers(Fps vsyncRate, Fps renderFps) -> const Buffers& {
		auto RefreshRateOverlay::getOrCreateBuffers(Fps refreshRate, Fps renderFps) -> const Buffers& {
		static const Buffers kNoBuffers;
		if (!mSurfaceControl) return kNoBuffers;

		@@ -198,16 +198,16 @@ auto RefreshRateOverlay::getOrCreateBuffers(Fps vsyncRate, Fps renderFps) -> con
		createTransaction().setTransform(mSurfaceControl->get(), transform).apply();

		BufferCache::const_iterator it =
		mBufferCache.find({vsyncRate.getIntValue(), renderFps.getIntValue(), transformHint});
		mBufferCache.find({refreshRate.getIntValue(), renderFps.getIntValue(), transformHint});
		if (it == mBufferCache.end()) {
		// HWC minFps is not known by the framework in order
		// to consider lower rates we set minFps to 0.
		const int minFps = isSetByHwc() ? 0 : mFpsRange.min.getIntValue();
		const int maxFps = mFpsRange.max.getIntValue();

		// Clamp to the range. The current vsyncRate may be outside of this range if the display
		// Clamp to the range. The current refreshRate may be outside of this range if the display
		// has changed its set of supported refresh rates.
		const int displayIntFps = std::clamp(vsyncRate.getIntValue(), minFps, maxFps);
		const int displayIntFps = std::clamp(refreshRate.getIntValue(), minFps, maxFps);
		const int renderIntFps = renderFps.getIntValue();

		// Ensure non-zero range to avoid division by zero.
		@@ -260,25 +260,26 @@ void RefreshRateOverlay::setLayerStack(ui::LayerStack stack) {
		createTransaction().setLayerStack(mSurfaceControl->get(), stack).apply();
		}

		void RefreshRateOverlay::changeRefreshRate(Fps vsyncRate, Fps renderFps) {
		mVsyncRate = vsyncRate;
		void RefreshRateOverlay::changeRefreshRate(Fps refreshRate, Fps renderFps) {
		mRefreshRate = refreshRate;
		mRenderFps = renderFps;
		const auto buffer = getOrCreateBuffers(vsyncRate, renderFps)[mFrame];
		const auto buffer = getOrCreateBuffers(refreshRate, renderFps)[mFrame];
		createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();
		}

		void RefreshRateOverlay::changeRenderRate(Fps renderFps) {
		if (mFeatures.test(Features::RenderRate) && mVsyncRate && FlagManager::getInstance().misc1()) {
		if (mFeatures.test(Features::RenderRate) && mRefreshRate &&
		FlagManager::getInstance().misc1()) {
		mRenderFps = renderFps;
		const auto buffer = getOrCreateBuffers(*mVsyncRate, renderFps)[mFrame];
		const auto buffer = getOrCreateBuffers(*mRefreshRate, renderFps)[mFrame];
		createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();
		}
		}

		void RefreshRateOverlay::animate() {
		if (!mFeatures.test(Features::Spinner) \|\| !mVsyncRate) return;
		if (!mFeatures.test(Features::Spinner) \|\| !mRefreshRate) return;

		const auto& buffers = getOrCreateBuffers(mVsyncRate, mRenderFps);
		const auto& buffers = getOrCreateBuffers(mRefreshRate, mRenderFps);
		mFrame = (mFrame + 1) % buffers.size();
		const auto buffer = buffers[mFrame];
		createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

services/surfaceflinger/RefreshRateOverlay.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -74,12 +74,12 @@ private:
		SurfaceComposerClient::Transaction createTransaction() const;

		struct Key {
		int vsyncRate;
		int refreshRate;
		int renderFps;
		ui::Transform::RotationFlags flags;

		bool operator==(Key other) const {
		return vsyncRate == other.vsyncRate && renderFps == other.renderFps &&
		return refreshRate == other.refreshRate && renderFps == other.renderFps &&
		flags == other.flags;
		}
		};
		@@ -87,7 +87,7 @@ private:
		using BufferCache = ftl::SmallMap<Key, Buffers, 9>;
		BufferCache mBufferCache;

		std::optional<Fps> mVsyncRate;
		std::optional<Fps> mRefreshRate;
		std::optional<Fps> mRenderFps;
		size_t mFrame = 0;

services/surfaceflinger/SurfaceFlinger.cpp

+8 −7

Original line number	Diff line number	Diff line
		@@ -2254,12 +2254,12 @@ void SurfaceFlinger::onRefreshRateChangedDebug(const RefreshRateChangedDebugData
		kMainThreadContext) {
		if (const auto displayIdOpt = getHwComposer().toPhysicalDisplayId(data.display)) {
		if (const auto display = getDisplayDeviceLocked(*displayIdOpt)) {
		const Fps fps = Fps::fromPeriodNsecs(getHwComposer().getComposer()->isVrrSupported()
		? data.refreshPeriodNanos
		const Fps refreshRate = Fps::fromPeriodNsecs(
		getHwComposer().getComposer()->isVrrSupported() ? data.refreshPeriodNanos
		: data.vsyncPeriodNanos);
		ATRACE_FORMAT("%s Fps %d", whence, fps.getIntValue());
		display->updateRefreshRateOverlayRate(fps, display->getActiveMode().fps,
		/* setByHwc */ true);
		ATRACE_FORMAT("%s refresh rate = %d", whence, refreshRate.getIntValue());
		display->updateRefreshRateOverlayRate(refreshRate, display->getActiveMode().fps,
		/* showRefreshRate */ true);
		}
		}
		}));
		@@ -8833,7 +8833,8 @@ void SurfaceFlinger::enableRefreshRateOverlay(bool enable) {
		const auto status =
		getHwComposer().setRefreshRateChangedCallbackDebugEnabled(id, enable);
		if (status != NO_ERROR) {
		ALOGE("Error updating the refresh rate changed callback debug enabled");
		ALOGE("Error %s refresh rate changed callback debug",
		enable ? "enabling" : "disabling");
		enableOverlay(/setByHwc/ false);
		}
		}