diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index 762d732a40..d523bd15e5 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -1489,13 +1489,16 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { * The rate of the mode PerfMode asked for, not the one the panel is still in: the switch lands * some frames after onCreate, and read too early it gave gamescope `-r 60` on a 120 Hz panel - * the client and every game then paced themselves to 60. (WinNative's requestedPanelRefreshRate.) + * Never above the user's peak refresh rate, which Android holds the panel to whatever mode is + * active; it is the rate gamescope gives Steam, and the QAM's Frame Limit divides it. */ private fun refreshHz(): Float { val display = if (Build.VERSION.SDK_INT >= 30) display else windowManager.defaultDisplay val wanted = window.attributes.preferredDisplayModeId val hz = display?.supportedModes?.firstOrNull { wanted != 0 && it.modeId == wanted }?.refreshRate ?: display?.refreshRate ?: 60f - return if (hz > 1f) hz else 60f + val capped = minOf(hz, PerfMode.peakRefreshCap(this)) + return if (capped > 1f) capped else 60f } /** diff --git a/app/src/main/java/com/droiddeck/launcher/session/PerfMode.kt b/app/src/main/java/com/droiddeck/launcher/session/PerfMode.kt index 7a44423a00..4a77141c38 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/PerfMode.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/PerfMode.kt @@ -3,7 +3,9 @@ package com.droiddeck.launcher.session import android.app.Activity import android.app.GameManager import android.app.GameState +import android.content.Context import android.os.Build +import android.provider.Settings import android.util.Log /** @@ -16,8 +18,9 @@ import android.util.Log * a level the device can hold indefinitely rather than holding a floor, which cost games and * Big Picture their peak clocks. WinNative never asks for it; the thermal budget is left to * the game; - * - the panel's fastest mode at its current size (Android 6+): a 120 Hz phone is switched to - * 120 Hz for the menu, not only when a game votes for it. With a frame cap, the fastest mode + * - the panel's fastest mode at its current size (Android 6+), up to the user's peak refresh rate + * ([peakRefreshCap]): a 120 Hz phone is switched to 120 Hz for the menu, not only when a game + * votes for it. With a frame cap, the fastest mode * the cap divides evenly, so every capped frame is shown for the same number of refreshes; * - GameManager's game state (Android 13+): "in gameplay", so an OEM framework that releases * its boost on loading screens or menus keeps it up. @@ -36,8 +39,11 @@ object PerfMode { val display = if (Build.VERSION.SDK_INT >= 30) a.display else @Suppress("DEPRECATION") a.windowManager.defaultDisplay if (display == null || Build.VERSION.SDK_INT < 23) "display mode unchanged" else { val cur = display.mode + val cap = peakRefreshCap(a) val sameSize = display.supportedModes .filter { it.physicalWidth == cur.physicalWidth && it.physicalHeight == cur.physicalHeight } + .filter { it.refreshRate <= cap + 0.5f } + .ifEmpty { display.supportedModes.filter { it.modeId == cur.modeId } } val best = sameSize.filter { cadenceFits(it.refreshRate, fpsLimit) }.maxByOrNull { it.refreshRate } ?: sameSize.maxByOrNull { it.refreshRate } if (best != null && best.modeId != cur.modeId && @@ -68,6 +74,20 @@ object PerfMode { return parts.joinToString(" ยท ") } + /** + * The highest rate Android will run the panel at: the user's "peak refresh rate" (Smooth display, + * or the AYN/Odin quick-settings tile). Above it a mode can be requested and is even reported back + * as active, while SurfaceFlinger keeps composing at the cap. The Thor set to 60 Hz ran 120 Hz + * sessions at 60: gamescope and Steam were told 120, every game topped out at 60, and the QAM's + * Frame Limit read "60 FPS (120 Hz)" and changed nothing. Unset (most phones) is no cap. + */ + fun peakRefreshCap(context: Context): Float { + val peak = try { + Settings.System.getFloat(context.contentResolver, "peak_refresh_rate") + } catch (_: Throwable) { 0f } + return if (peak >= 1f) peak else Float.POSITIVE_INFINITY + } + /** A panel rate that shows every capped frame for a whole number of refreshes (no cap: any). */ fun cadenceFits(hz: Float, fpsLimit: Int): Boolean { if (fpsLimit <= 0) return true