diff --git a/app/src/test/java/com/droiddeck/launcher/session/PerformanceModeTest.kt b/app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt similarity index 100% rename from app/src/test/java/com/droiddeck/launcher/session/PerformanceModeTest.kt rename to app/src/test/java/com/droiddeck/launcher/session/OutputPacingTest.kt diff --git a/tools/gamescope/PATCHES.md b/tools/gamescope/PATCHES.md index 5ff8197a2d..28dc1641e1 100644 --- a/tools/gamescope/PATCHES.md +++ b/tools/gamescope/PATCHES.md @@ -96,8 +96,7 @@ running AIO Graphics Test uncapped, Xwayland used 24-32% of a core and the game' present thread sat about half idle. The patch can keep the result for `DROIDDECK_WSI_BYPASS_CHECK_MS` milliseconds. Unset -or 0 keeps the per-present check; the app sets 100 only in Performance mode and 0 -otherwise. With 100, a window resize or a flip/obscure change is seen up to 100 ms +or 0 keeps the per-present check; the app sets 100. With 100, a window resize or a flip/obscure change is seen up to 100 ms later than before; surface creation and capability queries still check every time. ## 0118 Wayland: preserve signed plane positions @@ -121,3 +120,34 @@ The old component lost the image in Fill and magnification. The tested executabl matches the pinned p14 archive and the locally assembled APK. Hardware checks used native Gamescope properties; the physical Back+LB shortcut was not independently confirmed. The original APK and runtime were restored after validation. + +## 0119 WSI: default image count while the frame limiter runs + +The app sets `GAMESCOPE_WSI_MIN_IMAGE_COUNT=8` so an uncapped game keeps drawing while +gamescope turns its buffers around. With Steam's Frame Limit on, gamescope forces FIFO, +and the layer always hands the driver MAILBOX, so a game with eight images could queue +up to seven frames inside gamescope before it blocked: each one adds a frame of input +latency at the limited rate. + +While the limiter forces FIFO, the layer now reports and enforces its default minimum +of 3 images instead of the raised count; with the limiter off it uses the raised count +as before. DXVK and VKD3D-Proton already recreate their swapchain when the limiter +changes (the layer returns `VK_ERROR_OUT_OF_DATE_KHR`), so their image count follows +the Quick Access menu. Other apps keep their swapchain on a limiter change; they now +get `VK_SUBOPTIMAL_KHR` while their image count no longer matches, unless the layer +marks them as not taking it (`NoSuboptimal`). + +## 0120 Wayland: nested refresh follows the host + +`-r` fixes the refresh gamescope paces at, and the frame limiter and Steam's Frame Limit +slider use the same value. The app passes the panel refresh at session start, so a +panel switched to another mode during the session (for example in the device's own +quick settings) left gamescope pacing at the old rate until the next session; only the +reported output refresh changed. + +With `GAMESCOPE_NESTED_REFRESH_FOLLOWS_HOST=1`, a refresh the host compositor reports +through presentation feedback replaces the `-r` value, so pacing and the limiter switch +with the panel. `-r` still sets the starting rate, which avoids gamescope assuming +60 Hz until the first frame is shown. When the refresh changes, gamescope also sends +its `gamescope_control` display information to Steam again; Steam otherwise reads it +only when it binds. diff --git a/tools/gamescope/patches/0119-wsi-default-images-under-limiter.patch b/tools/gamescope/patches/0119-wsi-default-images-under-limiter.patch new file mode 100644 index 0000000000..78f2837ca6 --- /dev/null +++ b/tools/gamescope/patches/0119-wsi-default-images-under-limiter.patch @@ -0,0 +1,59 @@ +diff --git a/layer/VkLayer_FROG_gamescope_wsi.cpp b/layer/VkLayer_FROG_gamescope_wsi.cpp +index ea4ba84..46d086c 100644 +--- a/layer/VkLayer_FROG_gamescope_wsi.cpp ++++ b/layer/VkLayer_FROG_gamescope_wsi.cpp +@@ -201,6 +201,13 @@ namespace GamescopeWSILayer { + return s_minImageCount; + } + ++ // The raised count keeps an uncapped game drawing while gamescope turns its buffers around. ++ // Under the frame limiter's FIFO the extra images only queue frames ahead of the screen, ++ // so a limited swapchain gets the default count. ++ static uint32_t getMinImageCount(bool forcingFifo) { ++ return forcingFifo ? std::min(getMinImageCount(), 3u) : getMinImageCount(); ++ } ++ + static bool getEnsureMinImageCount() { + static bool s_ensureMinImageCount = []() -> bool { + if (auto ensure = parseEnv("GAMESCOPE_WSI_ENSURE_MIN_IMAGE_COUNT")) { +@@ -984,7 +991,7 @@ namespace GamescopeWSILayer { + + pSurfaceCapabilities->currentExtent = rect->extent; + } +- pSurfaceCapabilities->minImageCount = getMinImageCount(); ++ pSurfaceCapabilities->minImageCount = getMinImageCount(gamescopeIsForcingFifo(gamescopeSurface->waylandObjects)); + + return VK_SUCCESS; + } +@@ -1027,7 +1034,7 @@ namespace GamescopeWSILayer { + + pSurfaceCapabilities->surfaceCapabilities.currentExtent = rect->extent; + } +- pSurfaceCapabilities->surfaceCapabilities.minImageCount = getMinImageCount(); ++ pSurfaceCapabilities->surfaceCapabilities.minImageCount = getMinImageCount(gamescopeIsForcingFifo(gamescopeSurface->waylandObjects)); + + return VK_SUCCESS; + } +@@ -1305,7 +1312,7 @@ namespace GamescopeWSILayer { + + uint32_t minImageCount = swapchainInfo.minImageCount; + if (getEnsureMinImageCount()) +- minImageCount = std::max(getMinImageCount(), minImageCount); ++ minImageCount = std::max(getMinImageCount(gamescopeIsForcingFifo(gamescopeSurface->waylandObjects)), minImageCount); + swapchainInfo.minImageCount = minImageCount; + + fprintf(stderr, "[Gamescope WSI] Creating swapchain for xid: 0x%0x - oldSwapchain: %p - provided minImageCount: %u - minImageCount: %u - format: %s - colorspace: %s - flip: %s\n", +@@ -1627,6 +1634,13 @@ namespace GamescopeWSILayer { + continue; + } + ++ // Other apps keep their swapchain when the limiter changes; ask them to recreate it so ++ // the image count follows the limiter as well. ++ if (!frameLimiterAware && gamescopeSwapchain->forceFifo != forceFifo && ++ getMinImageCount(true) != getMinImageCount(false) && ++ !(gamescopeSurface->flags & GamescopeLayerClient::Flag::NoSuboptimal)) ++ UpdateSwapchainResult(VK_SUBOPTIMAL_KHR); ++ + const bool canBypass = gamescopeSurface->canBypassXWaylandAtPresent(gamescopeSwapchain->isHdrColorspace); + if (canBypass != gamescopeSwapchain->isBypassingXWayland) { + if (canBypass) { diff --git a/tools/gamescope/patches/0120-nested-refresh-follows-host.patch b/tools/gamescope/patches/0120-nested-refresh-follows-host.patch new file mode 100644 index 0000000000..913dc2d730 --- /dev/null +++ b/tools/gamescope/patches/0120-nested-refresh-follows-host.patch @@ -0,0 +1,63 @@ +diff --git a/src/Backends/WaylandBackend.cpp b/src/Backends/WaylandBackend.cpp +index 40164ba..fa6060e 100644 +--- a/src/Backends/WaylandBackend.cpp ++++ b/src/Backends/WaylandBackend.cpp +@@ -1698,6 +1698,22 @@ namespace gamescope + } + } + ++ // -r sets the refresh gamescope starts with. With GAMESCOPE_NESTED_REFRESH_FOLLOWS_HOST=1 a refresh ++ // the host compositor reports later replaces it, so pacing and the frame limiter follow a panel ++ // switched to another mode during the session. ++ static void FollowHostRefresh( int32_t nRefreshmHz ) ++ { ++ static const bool s_bFollow = [] ++ { ++ const char *pszFollow = getenv( "GAMESCOPE_NESTED_REFRESH_FOLLOWS_HOST" ); ++ return pszFollow && atoi( pszFollow ) != 0; ++ }(); ++ if ( !s_bFollow || !g_nNestedRefresh || g_nNestedRefresh == nRefreshmHz ) ++ return; ++ xdg_log.infof( "Nested refresh follows the host: %.3fhz", ConvertmHzToHz( (float) nRefreshmHz ) ); ++ g_nNestedRefresh = nRefreshmHz; ++ } ++ + void CWaylandPlane::UpdateVRRRefreshRate() + { + if ( m_pParent ) +@@ -1724,6 +1740,7 @@ namespace gamescope + // TODO(strategy): We should pick the largest refresh rate. + xdg_log.infof( "Changed refresh to: %.3fhz", ConvertmHzToHz( (float) nLargestRefreshRateMhz ) ); + g_nOutputRefresh = nLargestRefreshRateMhz; ++ FollowHostRefresh( nLargestRefreshRateMhz ); + } + } + +@@ -1798,6 +1815,7 @@ namespace gamescope + { + xdg_log.infof( "Changed refresh to: %.3fhz", ConvertmHzToHz( (float) nRefresh ) ); + g_nOutputRefresh = nRefresh; ++ FollowHostRefresh( nRefresh ); + } + + m_pConnector->SetHostCompositorIsCurrentlyVRR( false ); +diff --git a/src/steamcompmgr.cpp b/src/steamcompmgr.cpp +index 6c9299d..5fb9086 100644 +--- a/src/steamcompmgr.cpp ++++ b/src/steamcompmgr.cpp +@@ -9254,6 +9254,15 @@ void update_vrr_atoms(xwayland_ctx_t *root_ctx, bool force, bool* needs_flush = + g_nCurrentRefreshRate_CachedValue = g_nOutputRefresh; + if (needs_flush) + *needs_flush = true; ++ ++ // Steam reads the display's refresh rates from gamescope_control when it binds; send them again. ++ if ( !force ) ++ { ++ wlserver_lock(); ++ for ( const auto &control : wlserver.gamescope_controls ) ++ wlserver_send_gamescope_control( control ); ++ wlserver_unlock(); ++ } + } + + // Don't update this in-sync with DRM vrr usage. diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index 0f99643ee3..ada9cba2ec 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -238,6 +238,8 @@ if [ -z "${BL_INSIDE:-}" ]; then fi if [ "${BL_REFRESH:-0}" -gt 0 ]; then args+=(-r "$BL_REFRESH") + # -r is the starting rate; gamescope follows the panel when it switches modes later. + export GAMESCOPE_NESTED_REFRESH_FOLLOWS_HOST=1 fi [ "$mode" = steam ] && [ "${BL_STEAM_UI:-}" != desktop ] && args+=(-e) if [ "$mode" = steam ] && [ "${BL_XWAYLAND_COUNT:-2}" -gt 1 ]; then diff --git a/tools/tests/test_session_pacing.py b/tools/tests/test_session_pacing.py index e7c0df938f..84962fe9e6 100644 --- a/tools/tests/test_session_pacing.py +++ b/tools/tests/test_session_pacing.py @@ -18,16 +18,19 @@ class SessionPacingTest(unittest.TestCase): with tempfile.TemporaryDirectory() as directory: env = dict(os.environ, XDG_RUNTIME_DIR=directory, BL_REFRESH=str(refresh), BL_MANGOAPP='0', BL_FPS='0', DROIDDECK_GAME_FRAME_LIMIT='0') + env.pop('GAMESCOPE_NESTED_REFRESH_FOLLOWS_HOST', None) env.update(overrides) script = ''' set -u mode=steam pipewire_stub() { return 1; } -run_gamescope() { printf 'ARG:%s\\n' "$@"; } +run_gamescope() { printf 'ARG:%s\\n' "$@"; printf 'FOLLOW:%s\\n' "${GAMESCOPE_NESTED_REFRESH_FOLLOWS_HOST:-}"; } ''' + block result = subprocess.run(['bash', '-c', script], env=env, capture_output=True, text=True, timeout=5) self.assertEqual(0, result.returncode, result.stderr) + self.follow = [line.removeprefix('FOLLOW:') for line in result.stdout.splitlines() + if line.startswith('FOLLOW:')] return [line.removeprefix('ARG:') for line in result.stdout.splitlines() if line.startswith('ARG:')] @@ -38,6 +41,12 @@ run_gamescope() { printf 'ARG:%s\\n' "$@"; } self.assertEqual(str(refresh), args[args.index('-r') + 1]) self.assertIn('-e', args) + def test_gamescope_follows_the_panel_after_the_starting_rate(self): + self.launch(144) + self.assertEqual(['1'], self.follow) + self.launch(0) + self.assertEqual([''], self.follow) + def test_retired_cap_variables_do_not_override_the_display_rate(self): for performance in ('0', '1'): with self.subTest(performance=performance):