624 lines
22 KiB
Python
624 lines
22 KiB
Python
"""Launch Gamescope with low-overhead host-window resize behavior."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import hashlib
|
|
import os
|
|
from pathlib import Path
|
|
import platform
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
from collections.abc import Mapping, Sequence
|
|
|
|
from .gamebox_runtime import (
|
|
GAMESCOPE_HOST_FOCUS_STATE_ENV,
|
|
GameboxRuntimeError,
|
|
_X11,
|
|
_X_WM_STATE_ICONIC,
|
|
_X_WM_STATE_NORMAL,
|
|
)
|
|
|
|
WINDOW_DISCOVERY_TIMEOUT_SECONDS = 10.0
|
|
WINDOW_DISCOVERY_POLL_SECONDS = 0.05
|
|
RESIZE_STEPS_PER_GAME_CANVAS = 20
|
|
MIN_RESIZE_INCREMENT = 8
|
|
MAX_RESIZE_INCREMENT = 96
|
|
CHILD_STATUS_POLL_SECONDS = 0.05
|
|
HOST_FOCUS_HEARTBEAT_SECONDS = 0.2
|
|
HOST_REICONIFY_INTERVAL_SECONDS = 0.2
|
|
GAMESCOPE_VERSION_TIMEOUT_SECONDS = 1.0
|
|
WAYLAND_BACKING_FIX_VERSION = (3, 16, 28)
|
|
BUNDLED_GAMESCOPE_VERSION = (3, 16, 20)
|
|
BUNDLED_GAMESCOPE_FILENAME = "gamescope-3.16.20-ubuntu26.04-amd64"
|
|
BUNDLED_GAMESCOPE_SHA256 = (
|
|
"3fc81536c22dcce2c593c11507a612c13221f5b2ce2e5326f7c63706ca965639"
|
|
)
|
|
BUNDLED_GAMESCOPE_OS_ID = "ubuntu"
|
|
BUNDLED_GAMESCOPE_OS_VERSION = "26.04"
|
|
KEEP_NESTED_WINDOWS_VISIBLE_ENV = "PTLINUX_GAMESCOPE_KEEP_WINDOWS_VISIBLE"
|
|
HASH_READ_SIZE = 256 * 1024
|
|
_GAMESCOPE_VERSION_PATTERN = re.compile(
|
|
r"\bgamescope\s+version\s+(\d+)\.(\d+)\.(\d+)",
|
|
re.IGNORECASE,
|
|
)
|
|
|
|
|
|
class GamescopeRuntimeError(RuntimeError):
|
|
"""Raised when the Gamescope process cannot be started."""
|
|
|
|
|
|
class _HostFocusPublisher:
|
|
"""Publish the host WM's focus decision to the nested game supervisor."""
|
|
|
|
def __init__(self, file_descriptor: int, path: Path) -> None:
|
|
self.file_descriptor = file_descriptor
|
|
self.path = path
|
|
self._last_active: bool | None = None
|
|
self._last_published_at = 0.0
|
|
self._last_reiconify_at = 0.0
|
|
self._seen_normal_state = False
|
|
self._minimized_latched = False
|
|
self._publish(False, force=True)
|
|
|
|
@classmethod
|
|
def create(cls) -> _HostFocusPublisher:
|
|
runtime_directory = os.environ.get("XDG_RUNTIME_DIR")
|
|
try:
|
|
file_descriptor, path = tempfile.mkstemp(
|
|
prefix="ptlinux-gamescope-focus-",
|
|
dir=runtime_directory,
|
|
)
|
|
except OSError:
|
|
file_descriptor, path = tempfile.mkstemp(
|
|
prefix="ptlinux-gamescope-focus-",
|
|
)
|
|
try:
|
|
return cls(file_descriptor, Path(path))
|
|
except BaseException:
|
|
os.close(file_descriptor)
|
|
Path(path).unlink(missing_ok=True)
|
|
raise
|
|
|
|
def update(self, mapper: _X11, window: int) -> None:
|
|
now = time.monotonic()
|
|
try:
|
|
state = mapper.window_state(window)
|
|
active = state == _X_WM_STATE_NORMAL and mapper.window_is_active(window)
|
|
except Exception:
|
|
state = None
|
|
active = False
|
|
if state == _X_WM_STATE_ICONIC and self._seen_normal_state:
|
|
self._minimized_latched = True
|
|
elif state == _X_WM_STATE_NORMAL:
|
|
self._seen_normal_state = True
|
|
if self._minimized_latched:
|
|
if active:
|
|
# A normal, active window was explicitly restored by the
|
|
# desktop. Resume nested focus repair for it.
|
|
self._minimized_latched = False
|
|
elif now - self._last_reiconify_at >= HOST_REICONIFY_INTERVAL_SECONDS:
|
|
# Gamescope's SDL visibility handoff uses XMapRaised. If it
|
|
# remaps an inactive window after a user minimize, preserve
|
|
# the user's state instead of letting it cover other apps.
|
|
try:
|
|
mapper.minimize_window(window)
|
|
except Exception:
|
|
pass
|
|
self._last_reiconify_at = now
|
|
active = False
|
|
self._publish(active, now=now)
|
|
|
|
def _publish(
|
|
self,
|
|
active: bool,
|
|
*,
|
|
force: bool = False,
|
|
now: float | None = None,
|
|
) -> None:
|
|
published_at = time.monotonic() if now is None else now
|
|
if (
|
|
not force
|
|
and active == self._last_active
|
|
and published_at - self._last_published_at < HOST_FOCUS_HEARTBEAT_SECONDS
|
|
):
|
|
return
|
|
payload = f"{int(active)} {published_at:.9f}\n".encode("ascii")
|
|
try:
|
|
os.lseek(self.file_descriptor, 0, os.SEEK_SET)
|
|
# Truncating first makes an interrupted update fail closed in the
|
|
# nested reader instead of leaving a stale active value behind.
|
|
os.ftruncate(self.file_descriptor, 0)
|
|
os.write(self.file_descriptor, payload)
|
|
except OSError:
|
|
self._last_active = None
|
|
return
|
|
self._last_active = active
|
|
self._last_published_at = published_at
|
|
|
|
def close(self) -> None:
|
|
try:
|
|
os.close(self.file_descriptor)
|
|
finally:
|
|
self.path.unlink(missing_ok=True)
|
|
|
|
|
|
def resize_increments(width: int, height: int) -> tuple[int, int]:
|
|
"""Return coarse-enough size steps to avoid a swapchain rebuild storm."""
|
|
|
|
if width <= 0 or height <= 0:
|
|
raise ValueError("game canvas dimensions must be positive")
|
|
return (
|
|
min(
|
|
MAX_RESIZE_INCREMENT,
|
|
max(MIN_RESIZE_INCREMENT, width // RESIZE_STEPS_PER_GAME_CANVAS),
|
|
),
|
|
min(
|
|
MAX_RESIZE_INCREMENT,
|
|
max(MIN_RESIZE_INCREMENT, height // RESIZE_STEPS_PER_GAME_CANVAS),
|
|
),
|
|
)
|
|
|
|
|
|
def _supervised_command(
|
|
command: Sequence[str],
|
|
status_file: Path,
|
|
backend: str,
|
|
*,
|
|
force_composition: bool = False,
|
|
) -> list[str]:
|
|
"""Select a presentation backend and wrap the primary child."""
|
|
|
|
if not command:
|
|
raise ValueError("Gamescope command cannot be empty")
|
|
if backend not in {"sdl", "wayland"}:
|
|
raise ValueError(f"unsupported Gamescope backend: {backend}")
|
|
result = [
|
|
str(command[0]),
|
|
"--backend",
|
|
backend,
|
|
"--keep-alive",
|
|
]
|
|
if backend == "sdl" or force_composition:
|
|
result.append("--force-composition")
|
|
result.extend(map(str, command[1:]))
|
|
try:
|
|
separator = result.index("--")
|
|
except ValueError as exc:
|
|
raise ValueError("Gamescope command has no nested command separator") from exc
|
|
if separator == len(result) - 1:
|
|
raise ValueError("Gamescope command has no nested command")
|
|
result[separator + 1:separator + 1] = [
|
|
sys.executable,
|
|
"-m",
|
|
"ptlinux.gamescope_child_runtime",
|
|
"--status-file",
|
|
str(status_file),
|
|
"--",
|
|
]
|
|
return result
|
|
|
|
|
|
def _read_gamescope_version(executable: str) -> tuple[int, int, int] | None:
|
|
"""Read Gamescope's release tuple without delaying a normal launch."""
|
|
|
|
try:
|
|
completed = subprocess.run(
|
|
[executable, "--version"],
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
text=True,
|
|
encoding="utf-8",
|
|
errors="replace",
|
|
timeout=GAMESCOPE_VERSION_TIMEOUT_SECONDS,
|
|
check=False,
|
|
)
|
|
except (OSError, subprocess.TimeoutExpired):
|
|
return None
|
|
if completed.returncode != 0:
|
|
return None
|
|
match = _GAMESCOPE_VERSION_PATTERN.search(completed.stdout)
|
|
if match is None:
|
|
return None
|
|
major, minor, patch = match.groups()
|
|
return int(major), int(minor), int(patch)
|
|
|
|
|
|
def _bundled_gamescope_path() -> Path:
|
|
return Path(__file__).resolve().parent / "native" / BUNDLED_GAMESCOPE_FILENAME
|
|
|
|
|
|
def _bundled_gamescope_host_supported() -> bool:
|
|
"""Limit the distribution-specific executable to its build target."""
|
|
|
|
if sys.platform != "linux" or platform.machine().casefold() not in {
|
|
"amd64",
|
|
"x86_64",
|
|
}:
|
|
return False
|
|
try:
|
|
release = platform.freedesktop_os_release()
|
|
except OSError:
|
|
return False
|
|
return (
|
|
release.get("ID", "").casefold() == BUNDLED_GAMESCOPE_OS_ID
|
|
and release.get("VERSION_ID") == BUNDLED_GAMESCOPE_OS_VERSION
|
|
)
|
|
|
|
|
|
def _bundled_gamescope_is_usable() -> bool:
|
|
"""Verify the launcher-local executable and restore its safe archive mode."""
|
|
|
|
if not _bundled_gamescope_host_supported():
|
|
return False
|
|
path = _bundled_gamescope_path()
|
|
try:
|
|
if path.is_symlink() or not path.is_file():
|
|
return False
|
|
digest = hashlib.sha256()
|
|
with path.open("rb") as handle:
|
|
for chunk in iter(lambda: handle.read(HASH_READ_SIZE), b""):
|
|
digest.update(chunk)
|
|
except OSError:
|
|
return False
|
|
if digest.hexdigest() != BUNDLED_GAMESCOPE_SHA256:
|
|
return False
|
|
if not os.access(path, os.X_OK):
|
|
try:
|
|
path.chmod(0o755)
|
|
except OSError:
|
|
return False
|
|
return os.access(path, os.X_OK)
|
|
|
|
|
|
def _select_wayland_gamescope(executable: str) -> tuple[str, bool, bool]:
|
|
"""Choose a direct-safe Gamescope or request the stable composed path."""
|
|
|
|
version = _read_gamescope_version(executable)
|
|
if version is not None and version >= WAYLAND_BACKING_FIX_VERSION:
|
|
return executable, False, False
|
|
if version == BUNDLED_GAMESCOPE_VERSION and _bundled_gamescope_is_usable():
|
|
return str(_bundled_gamescope_path()), False, True
|
|
return executable, True, False
|
|
|
|
|
|
def _wayland_socket_available(environment: Mapping[str, str]) -> bool:
|
|
"""Return whether the launch environment names an accessible Wayland socket."""
|
|
|
|
display = environment.get("WAYLAND_DISPLAY", "").strip()
|
|
if not display:
|
|
return False
|
|
display_path = Path(display)
|
|
if not display_path.is_absolute():
|
|
runtime_directory = environment.get("XDG_RUNTIME_DIR", "").strip()
|
|
if not runtime_directory:
|
|
return False
|
|
display_path = Path(runtime_directory) / display_path
|
|
try:
|
|
return display_path.is_socket()
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def _select_host_backend(environment: Mapping[str, str]) -> str:
|
|
"""Prefer Wayland's retained-buffer resize path when it is usable."""
|
|
|
|
if _wayland_socket_available(environment):
|
|
return "wayland"
|
|
return "sdl"
|
|
|
|
|
|
def _create_child_status_file() -> Path:
|
|
"""Create a private rendezvous file inherited by the nested child command."""
|
|
|
|
runtime_directory = os.environ.get("XDG_RUNTIME_DIR")
|
|
try:
|
|
file_descriptor, path = tempfile.mkstemp(
|
|
prefix="ptlinux-gamescope-status-",
|
|
dir=runtime_directory,
|
|
)
|
|
except OSError:
|
|
file_descriptor, path = tempfile.mkstemp(prefix="ptlinux-gamescope-status-")
|
|
os.close(file_descriptor)
|
|
return Path(path)
|
|
|
|
|
|
def _read_child_status(status_file: Path) -> int | None:
|
|
try:
|
|
value = status_file.read_text(encoding="ascii").strip()
|
|
except (FileNotFoundError, OSError, UnicodeError):
|
|
return None
|
|
if not value:
|
|
return None
|
|
try:
|
|
returncode = int(value, 10)
|
|
except ValueError:
|
|
return None
|
|
if returncode < -255 or returncode > 255:
|
|
return None
|
|
return returncode
|
|
|
|
|
|
def _process_exit_status(returncode: int) -> int:
|
|
if returncode < 0:
|
|
return 128 + min(-returncode, 127)
|
|
return min(returncode, 255)
|
|
|
|
|
|
def _wait_for_optimized_gamescope(
|
|
process: subprocess.Popen[bytes],
|
|
status_file: Path | None,
|
|
*,
|
|
host_focus_publisher: _HostFocusPublisher | None = None,
|
|
host_mapper: _X11 | None = None,
|
|
host_window: int | None = None,
|
|
) -> int:
|
|
"""Monitor host focus and preserve the nested child's real exit status."""
|
|
|
|
while True:
|
|
if host_focus_publisher is not None and host_mapper is not None:
|
|
if host_window is None:
|
|
try:
|
|
host_window = host_mapper.find_window_by_pid(process.pid)
|
|
except Exception:
|
|
host_window = None
|
|
if host_window is not None:
|
|
host_focus_publisher.update(host_mapper, host_window)
|
|
child_status = (
|
|
_read_child_status(status_file) if status_file is not None else None
|
|
)
|
|
if child_status is not None:
|
|
if process.poll() is None:
|
|
process.kill()
|
|
process.wait()
|
|
return _process_exit_status(child_status)
|
|
gamescope_status = process.poll()
|
|
if gamescope_status is not None:
|
|
child_status = (
|
|
_read_child_status(status_file) if status_file is not None else None
|
|
)
|
|
return _process_exit_status(
|
|
gamescope_status if child_status is None else child_status
|
|
)
|
|
time.sleep(CHILD_STATUS_POLL_SECONDS)
|
|
|
|
|
|
def _open_host_x11() -> _X11 | None:
|
|
"""Open the host X11 connection used by Gamescope's SDL window."""
|
|
|
|
if not os.environ.get("DISPLAY"):
|
|
return None
|
|
try:
|
|
return _X11()
|
|
except GameboxRuntimeError:
|
|
return None
|
|
|
|
|
|
def _tune_process_window(
|
|
mapper: _X11,
|
|
process: subprocess.Popen[bytes],
|
|
width: int,
|
|
height: int,
|
|
*,
|
|
host_focus_publisher: _HostFocusPublisher | None = None,
|
|
) -> tuple[int, int] | None:
|
|
"""Stabilize resizing once the SDL host window becomes available."""
|
|
|
|
deadline = time.monotonic() + WINDOW_DISCOVERY_TIMEOUT_SECONDS
|
|
while process.poll() is None and time.monotonic() < deadline:
|
|
window = mapper.find_window_by_pid(process.pid)
|
|
if window is not None:
|
|
if host_focus_publisher is not None:
|
|
host_focus_publisher.update(mapper, window)
|
|
increments = resize_increments(width, height)
|
|
increments_applied = mapper.set_resize_increments(
|
|
window,
|
|
(width, height),
|
|
increments,
|
|
)
|
|
# Apply every client-owned hint first, then wait for the window
|
|
# manager to publish resize and maximize actions from those hints.
|
|
scaling_enabled = mapper.enable_window_scaling(window)
|
|
if host_focus_publisher is not None:
|
|
host_focus_publisher.update(mapper, window)
|
|
compositing_preferred = mapper.prefer_composited_presentation(window)
|
|
if scaling_enabled and increments_applied and compositing_preferred:
|
|
return increments
|
|
time.sleep(WINDOW_DISCOVERY_POLL_SECONDS)
|
|
return None
|
|
|
|
|
|
def run_gamescope(command: Sequence[str], width: int, height: int) -> int:
|
|
"""Run Gamescope with stable host presentation for the current session."""
|
|
|
|
if not command:
|
|
raise GamescopeRuntimeError("Gamescope command cannot be empty")
|
|
resize_increments(width, height)
|
|
environment = os.environ.copy()
|
|
backend = _select_host_backend(environment)
|
|
selected_command = list(map(str, command))
|
|
force_composition = backend == "sdl"
|
|
using_bundled_gamescope = False
|
|
if backend == "wayland":
|
|
(
|
|
selected_command[0],
|
|
force_composition,
|
|
using_bundled_gamescope,
|
|
) = _select_wayland_gamescope(selected_command[0])
|
|
mapper = _open_host_x11() if backend == "sdl" else None
|
|
status_file: Path | None = None
|
|
host_focus_publisher: _HostFocusPublisher | None = None
|
|
try:
|
|
candidate_status_file = _create_child_status_file()
|
|
try:
|
|
launch_command = _supervised_command(
|
|
selected_command,
|
|
candidate_status_file,
|
|
backend,
|
|
force_composition=force_composition,
|
|
)
|
|
except ValueError:
|
|
candidate_status_file.unlink(missing_ok=True)
|
|
if mapper is not None:
|
|
mapper.close()
|
|
raise
|
|
status_file = candidate_status_file
|
|
except OSError as exc:
|
|
launch_command = [
|
|
selected_command[0],
|
|
"--backend",
|
|
backend,
|
|
]
|
|
if force_composition:
|
|
launch_command.append("--force-composition")
|
|
launch_command.extend(selected_command[1:])
|
|
print(
|
|
f"Warning: Gamescope child-status supervision is unavailable: {exc}; "
|
|
"continuing with stable presentation.",
|
|
file=sys.stderr,
|
|
flush=True,
|
|
)
|
|
if backend == "sdl" and environment.get("DISPLAY"):
|
|
environment["SDL_VIDEODRIVER"] = "x11"
|
|
# Keep Mutter on one composited presentation path at every window size.
|
|
# SDL otherwise requests compositor bypass, which can switch near
|
|
# screen-filling sizes and visibly flicker while Gamescope is scaling.
|
|
environment["SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR"] = "0"
|
|
# If host X11 monitoring cannot start, make the nested focus repair
|
|
# fail closed. An absent bridge retains legacy behavior for direct
|
|
# gamebox invocations and native Wayland Gamescope only.
|
|
environment[GAMESCOPE_HOST_FOCUS_STATE_ENV] = "unavailable"
|
|
if mapper is not None:
|
|
try:
|
|
publisher = _HostFocusPublisher.create()
|
|
except OSError as exc:
|
|
print(
|
|
f"Warning: Gamescope host-focus monitoring is unavailable: "
|
|
f"{exc}; nested focus repair will remain disabled.",
|
|
file=sys.stderr,
|
|
flush=True,
|
|
)
|
|
else:
|
|
host_focus_publisher = publisher
|
|
environment[GAMESCOPE_HOST_FOCUS_STATE_ENV] = str(publisher.path)
|
|
if using_bundled_gamescope:
|
|
# The game asks its X11 WM to iconify the first client while entering
|
|
# the login screen. Our scoped Gamescope patch keeps that nested surface
|
|
# visible without activating or raising the host window.
|
|
environment[KEEP_NESTED_WINDOWS_VISIBLE_ENV] = "1"
|
|
try:
|
|
process = subprocess.Popen(launch_command, env=environment)
|
|
except OSError as exc:
|
|
if mapper is not None:
|
|
mapper.close()
|
|
if host_focus_publisher is not None:
|
|
host_focus_publisher.close()
|
|
if status_file is not None:
|
|
status_file.unlink(missing_ok=True)
|
|
raise GamescopeRuntimeError(f"could not start Gamescope: {exc}") from exc
|
|
|
|
if backend == "wayland" and not force_composition:
|
|
message = (
|
|
"Gamescope resize optimization active: native Wayland direct "
|
|
"presentation keeps live host-window changes off the game surface."
|
|
)
|
|
if using_bundled_gamescope:
|
|
message += (
|
|
" Launcher-local lazy-output, live-resize, letterbox backing, "
|
|
"decoration-input, and login-window visibility fixes are active."
|
|
)
|
|
print(message, file=sys.stderr, flush=True)
|
|
elif backend == "wayland":
|
|
print(
|
|
"Warning: this Gamescope build lacks safe direct Wayland letterbox "
|
|
"backing. Forced composition prevents flicker, but live resizing may "
|
|
"pause; install Gamescope 3.16.28 or newer for direct presentation.",
|
|
file=sys.stderr,
|
|
flush=True,
|
|
)
|
|
elif mapper is not None:
|
|
try:
|
|
increments = _tune_process_window(
|
|
mapper,
|
|
process,
|
|
width,
|
|
height,
|
|
host_focus_publisher=host_focus_publisher,
|
|
)
|
|
except Exception as exc:
|
|
increments = None
|
|
print(
|
|
f"Warning: Gamescope resize tuning failed: {exc}; "
|
|
"continuing normally.",
|
|
file=sys.stderr,
|
|
flush=True,
|
|
)
|
|
if increments is not None:
|
|
print(
|
|
"Gamescope resize optimization active: the host window remains "
|
|
"composited and size changes use "
|
|
f"{increments[0]}x{increments[1]} pixel steps.",
|
|
file=sys.stderr,
|
|
flush=True,
|
|
)
|
|
elif process.poll() is None:
|
|
print(
|
|
"Warning: Gamescope's host window could not be resize-tuned; "
|
|
"continuing normally.",
|
|
file=sys.stderr,
|
|
flush=True,
|
|
)
|
|
else:
|
|
print(
|
|
"Gamescope is using its SDL presentation fallback; host X11 resize "
|
|
"tuning is unavailable.",
|
|
file=sys.stderr,
|
|
flush=True,
|
|
)
|
|
try:
|
|
return _wait_for_optimized_gamescope(
|
|
process,
|
|
status_file,
|
|
host_focus_publisher=host_focus_publisher,
|
|
host_mapper=mapper,
|
|
)
|
|
except BaseException:
|
|
if process.poll() is None:
|
|
process.terminate()
|
|
try:
|
|
process.wait(timeout=2.0)
|
|
except subprocess.TimeoutExpired:
|
|
process.kill()
|
|
process.wait()
|
|
raise
|
|
finally:
|
|
if mapper is not None:
|
|
mapper.close()
|
|
if host_focus_publisher is not None:
|
|
host_focus_publisher.close()
|
|
if status_file is not None:
|
|
status_file.unlink(missing_ok=True)
|
|
|
|
|
|
def main(argv: Sequence[str] | None = None) -> int:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("--width", required=True, type=int)
|
|
parser.add_argument("--height", required=True, type=int)
|
|
parser.add_argument("command", nargs=argparse.REMAINDER)
|
|
arguments = parser.parse_args(argv)
|
|
command = arguments.command
|
|
if command and command[0] == "--":
|
|
command = command[1:]
|
|
try:
|
|
return run_gamescope(command, arguments.width, arguments.height)
|
|
except (GamescopeRuntimeError, ValueError) as exc:
|
|
print(f"Gamescope launch failed: {exc}", file=sys.stderr)
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|