#!/usr/bin/python3 import json import os import re import runpy import shutil import sys TOOL = "droiddeck-proton-arm64" TOOL_11 = "droiddeck-proton-11-arm64" LEGACY_TOOL = "bannerlator-proton-arm64" LABEL_FILE = "/etc/steam-compatibility-label" PROTON_ARM64_APPID = "4427310" LAUNCHER = "droiddeck-proton" LEGACY_LAUNCHER = "bannerlator-proton" LIBRARY = "/mnt/droiddeck" SOURCES = ("Proton Experimental (ARM64)", "Proton 11.0 (ARM64)") OWN_TOOLS = ((TOOL, SOURCES), (TOOL_11, ("Proton 11.0 (ARM64)",))) VALVE_DEPOTS = {"proton_experimental": SOURCES[0], "proton-experimental-arm64": SOURCES[0], "proton_11": SOURCES[1], "proton_11-arm64": SOURCES[1]} FEX_TOOL = "droiddeck-fex" FEX_LAUNCHER = "droiddeck-fex-tool" FEX_FILES = ("toolmanifest.vdf", "compatibilitytool.vdf", FEX_LAUNCHER) FEX_APPID = "3127680" SNIPER_APPID = "1628350" SLR4_APPID = "4183110" FEX_DEPENDENCIES = (FEX_APPID, SNIPER_APPID, SLR4_APPID) REQUIRED_TOOLS = (PROTON_ARM64_APPID,) + FEX_DEPENDENCIES # Linux builds that bundle an arm64 binary their launcher starts; Steamworks offers no arm64 # launch-option architecture, so appinfo cannot say so (#1774). FEX_DEFAULT_APPS = frozenset({"4385780"}) FULLY_INSTALLED = 4 UPDATE_REQUIRED = 2 REQUEST_HANDOFF_SECONDS = 30 PLAYABLE_TYPES = frozenset(("game", "demo", "application", "beta")) COMPAT_DIR = os.path.join(os.environ.get("HOME", "/root"), ".local", "share", "droiddeck-compat") OWN_FILES = ("toolmanifest.vdf", "compatibilitytool.vdf", LAUNCHER) COMPAT_TOOL_VDF = """"compatibilitytools" { "compat_tools" { "%s" { "install_path" "." "display_name" "%s" "from_oslist" "windows" "to_oslist" "linux" } } } """ TOOL_MANIFEST_VDF = """"manifest" { "version" "2" "commandline" "/%s %%verb%%" "use_sessions" "1" "compatmanager_layer_name" "proton" } """ % LAUNCHER DD_STORE_SETUP = """ dd_store_launch() { [ "${verb:-}" = waitforexitandrun ] || return 0 if [ -x /usr/local/bin/droiddeck-open-url ]; then mkdir -p /tmp/droiddeck-browser ln -sfn /usr/local/bin/droiddeck-open-url /tmp/droiddeck-browser/xdg-open [ -n "${DD_LAUNCH_DIR:-}" ] && printf '%s ' "$DD_LAUNCH_DIR" > /tmp/droiddeck-browser/launch-dir PATH="/tmp/droiddeck-browser:$PATH"; export PATH fi if [ "${DD_DEBUG_BROWSER:-}" = 1 ]; then WINEDEBUG="${WINEDEBUG:+$WINEDEBUG,}+shell,+winebrowser"; export WINEDEBUG fi [ -x /usr/local/bin/droiddeck-store-launch ] || return 0 /usr/local/bin/droiddeck-store-launch "$@" rc=$? [ $rc -eq 10 ] && DD_STORE_EXIT=1 [ $rc -eq 11 ] && exit 0 [ $rc -eq 12 ] && exit 1 return 0 } dd_run() { if [ -x /usr/local/bin/droiddeck-steamvr-flat ] && /usr/local/bin/droiddeck-steamvr-flat "${verb:-}"; then set -- /usr/local/bin/droiddeck-steamvr-game "$@" fi if [ -n "${DD_STORE_EXIT:-}" ]; then trap : INT TERM HUP "$@" rc=$? /usr/local/bin/droiddeck-store-launch --exited --code "$rc" "${DD_STORE_ARGS[@]}" || true exit $rc fi exec "$@" } """ DD_DESKTOP_GPU_SETUP = """ dd_desktop_gpu() { local name saved gpu=/usr/local/bin/droiddeck-gpu local names=(LD_PRELOAD LD_LIBRARY_PATH ENABLE_VK_LAYER_VALVE_steam_overlay_1 ENABLE_VK_LAYER_VALVE_steam_fossilize_1) if [ -n "${DD_DESKTOP_GPU_CHILD:-}" ]; then for name in "${names[@]}"; do saved=DD_GPU_SAVED_$name [ -n "${!saved+x}" ] || continue export "$name=${!saved}" unset "$saved" done return 0 fi [ "${DD_DESKTOP:-}" = 1 ] && [ "${verb:-}" = waitforexitandrun ] && [ -x "$gpu" ] || return 0 local choice=${DD_DESKTOP_GPU:-on} case "${choice,,}" in off | 0 | no | false) return 0 ;; esac case " $* " in *iscriptevaluator*) return 0 ;; esac local clear=() for name in "${names[@]}"; do [ -n "${!name+x}" ] || continue export "DD_GPU_SAVED_$name=${!name}" clear+=(-u "$name") done echo "droiddeck-gpu: the desktop starts this game on the GPU" >&2 exec env "${clear[@]}" "$gpu" "$0" "$verb" "$@" } dd_desktop_gpu "$@" """ DD_COMPONENTS_SETUP = """ dd_components() { base=$1 cm_dir="${HOME:-/root}/.local/share/droiddeck-components" cm_list="$cm_dir/desired.tsv" [ "${verb:-}" = waitforexitandrun ] || return 0 case "${STEAM_COMPAT_DATA_PATH:-}" in ''|*/compatdata/0|*/compatdata/0/|*/compatdata/0-*) return 0 ;; esac [ -f "$cm_list" ] || return 0 cm_app=${STEAM_COMPAT_DATA_PATH} while [[ "$cm_app" == */ ]]; do cm_app=${cm_app%/}; done cm_app=${cm_app##*/} if [[ "$cm_app" =~ ^(-?)([0-9]+)$ ]]; then cm_sign=${BASH_REMATCH[1]} cm_digits=${BASH_REMATCH[2]} while [[ ${#cm_digits} -gt 1 && "$cm_digits" == 0* ]]; do cm_digits=${cm_digits#0}; done if [[ ${#cm_digits} -le 10 ]]; then cm_app=$((10#$cm_digits)) [ "$cm_sign" = "-" ] && cm_app=$((-cm_app)) if (( cm_app >= -2147483648 && cm_app <= 4294967295 && cm_app != 0 )); then (( cm_app < 0 )) && cm_app=$((cm_app + 4294967296)) else cm_app="" fi else cm_app="" fi else cm_app="" fi if [ "$cm_app" = 2929927072 ] && [[ "${SteamAppId:-}" =~ ^[0-9]{1,10}$ ]] && (( 10#$SteamAppId > 0 && 10#$SteamAppId <= 4294967295 )); then cm_app=$((10#$SteamAppId)) elif [ "$cm_app" = 2929927072 ] && [[ "${SteamGameId:-}" =~ ^[1-9][0-9]{9,19}$ ]] && { [ ${#SteamGameId} -lt 20 ] || [[ ! "$SteamGameId" > 18446744073709551615 ]]; } && (( (10#$SteamGameId & 0xFFFFFFFF) == 0x02000000 && ((10#$SteamGameId >> 32) & 0xFFFFFFFF) != 0 )); then cm_app=$(( (10#$SteamGameId >> 32) & 0xFFFFFFFF )) fi if [ -z "$cm_app" ]; then echo "droiddeck-proton: components: invalid game prefix, left as it is" >&2 return 0 fi cm_tool=${base##*/} cm_build=$(awk 'NR == 1 { print $2 }' "$base/version" 2>/dev/null) cm_fixed=0 cm_checked=0 cm_selected=$(awk -F '\\t' -v app="$cm_app" -v tool="$cm_tool" -v build="$cm_build" ' $2 == tool && $3 == build { rows[++count] = $0 scopes[count] = $1 comps[count] = $4 if ($1 == app) specific[$4] = 1 } END { for (i = 1; i <= count; i++) if (scopes[i] == app || (scopes[i] == "*" && !specific[comps[i]])) print rows[i] } ' "$cm_list") local cm_rows=() cm_files=() row h p local -A cm_sums=() while IFS=$'\\t' read -r scope t want comp rel sum src; do [ -n "$scope" ] || continue # The selected system PowerVR runtime supplies DXVK at launch. Keep saved selections # for a later manual-driver session without rewriting this Proton's bundled files now. [ "$comp" = dxvk ] && [ -n "${DROIDDECK_POWERVR_RUNTIME:-}" ] && continue cm_rows+=("$comp"$'\\t'"$rel"$'\\t'"$sum"$'\\t'"$src") [ "$src" != "-" ] && [ -f "$base/$rel" ] && cm_files+=("$base/$rel") done <<< "$cm_selected" if [ ${#cm_files[@]} -gt 0 ]; then while read -r h p; do cm_sums["$p"]=$h; done < <(sha256sum -- "${cm_files[@]}" 2>/dev/null) fi for row in "${cm_rows[@]}"; do IFS=$'\\t' read -r comp rel sum src <<< "$row" cm_checked=$((cm_checked + 1)) f="$base/$rel" if [ "$src" = "-" ]; then if [ -e "$f" ]; then rm -f "$f" && cm_fixed=$((cm_fixed + 1)); fi continue fi if [ -f "$f" ] && [ "${cm_sums[$f]:-}" = "$sum" ]; then continue; fi if [ ! -f "$src" ]; then echo "droiddeck-proton: components: $comp source missing ($src), left as it is" >&2 continue fi mkdir -p "$(dirname "$f")" cp -f "$src" "$f.dd-new" && mv -f "$f.dd-new" "$f" || continue case "$rel" in *.so) chmod 755 "$f" ;; *) chmod 644 "$f" ;; esac cm_fixed=$((cm_fixed + 1)) done [ "$cm_checked" -gt 0 ] && echo "droiddeck-proton: components: checked $cm_checked file(s) in $cm_tool for app $cm_app" >&2 if [ "$cm_fixed" -gt 0 ]; then echo "droiddeck-proton: components: re-applied $cm_fixed of $cm_checked file(s) in $cm_tool before this launch" >&2 printf '%s\\t%s\\t%s\\n' "$(date +%s)" "$cm_tool" "$cm_fixed" >> "$cm_dir/reapplied.log" fi } """ DD_GAME_CPUS_SETUP = """ dd_game_cpus() { [ -n "${DD_GAME_CPUS:-}" ] || return 0 command -v taskset >/dev/null 2>&1 || return 0 DD_TASKSET="taskset -c $DD_GAME_CPUS" echo "droiddeck-proton: game cores $DD_GAME_CPUS" >&2 } """ DD_LIBPATH_SETUP = """ dd_libpath() { export PROTON_USE_PIPEWIRE=${PROTON_USE_PIPEWIRE:-0} [ -n "${LD_LIBRARY_PATH:-}" ] || return 0 local kept= dir old_ifs=$IFS IFS=: for dir in $LD_LIBRARY_PATH; do case $dir in "" | */steamrtarm64 | */steamrtarm64/*) ;; *) kept=${kept:+$kept:}$dir ;; esac done IFS=$old_ifs if [ -n "$kept" ]; then export LD_LIBRARY_PATH="$kept"; else unset LD_LIBRARY_PATH; fi } """ DD_IDTECH3_SETUP = """ dd_idtech3() { DD_EXTRA_ARGS=() case "${SteamAppId:-${STEAM_COMPAT_APP_ID:-}}" in 2200|2350|9010|6020) ;; *) return 0 ;; esac case " $* " in *r_fullscreen*|*r_mode*|*r_customwidth*|*r_customheight*) echo "droiddeck-proton: Quake-engine title; its launch options set the video mode, left as they are" >&2 return 0 ;; esac w=${DD_WIDTH:-1280} h=${DD_HEIGHT:-720} DD_EXTRA_ARGS=(+set r_fullscreen 0 +set r_mode -1 +set r_customwidth "$w" +set r_customheight "$h") echo "droiddeck-proton: Quake-engine title: windowed at ${w}x${h}" >&2 } """ DD_VACDIAG_SETUP = """ dd_vacdiag() { [ -f /root/.droiddeck-vac-diagnostics ] || return 0 [ "${verb:-}" = waitforexitandrun ] || return 0 local exe= a dir added=no app=${SteamAppId:-${STEAM_COMPAT_APP_ID:-0}} for a in "$@"; do case $a in *.exe|*.EXE) exe=$a ;; esac; done [ -n "$exe" ] || return 0 dir=$(dirname "$exe") # Source: /gameinfo.txt beside the exe. Source 2: game/bin/win64/ with game//gameinfo.gi. if ls "$dir"/*/gameinfo.txt >/dev/null 2>&1 || ls "$dir"/../../*/gameinfo.gi >/dev/null 2>&1; then case " $* " in *" -condebug "*) echo "droiddeck-proton: vac-diag: app $app already has -condebug" >&2 ;; *) DD_EXTRA_ARGS+=(-condebug); added=yes echo "droiddeck-proton: vac-diag: app $app is a Source title; launched with -condebug" >&2 ;; esac else added=not-source echo "droiddeck-proton: vac-diag: app $app is not a Source title; it keeps no console log to read" >&2 fi case " $* " in *" -insecure "*) echo "droiddeck-proton: vac-diag: app $app has -insecure in its launch options - it can never be VAC-secure this way" >&2 ;; esac printf '%s\tapp %s\tcondebug %s\t%s\n' "$(date +%s)" "$app" "$added" "${exe##*/}" >> /root/.droiddeck-vac-launches } """ DD_DRIVER_QUERY_SKIP = """ case "$verb:${1##*/}:${STEAM_COMPAT_DATA_PATH%/}" in run:d3ddriverquery64.exe:*/compatdata/0 | run:d3ddriverquery.exe:*/compatdata/0) echo "droiddeck-proton: Steam's D3D driver query is not run (it fails here and would start Wine in compatdata/0)" >&2 exit 1 ;; esac """ DD_DIRECTAUDIO_SETUP = """ dd_is_steam_installscript_target() { local target=${1:-} local steam_root=${STEAM_COMPAT_CLIENT_INSTALL_PATH:-${XDG_DATA_HOME:-$HOME/.local/share}/Steam} local helper="$steam_root/legacycompat/iscriptevaluator.exe" [ -f "$helper" ] && [[ -n "$target" && "$target" -ef "$helper" ]] } dd_directaudio() { case "${verb:-}" in run|waitforexitandrun|runinprefix) ;; *) return 0 ;; esac base=$1 [ -n "${DD_DIRECTAUDIO:-}" ] || return 0 [ -d "$DD_DIRECTAUDIO" ] || return 0 if dd_is_steam_installscript_target "${2:-}"; then echo "droiddeck-proton: DirectAudio skipped for Steam's install-script evaluator" >&2 return 0 fi streamer=$(cat "${XDG_RUNTIME_DIR:-/tmp}/droiddeck-remote-play" 2>/dev/null) if [ -n "$streamer" ] && kill -0 "$streamer" 2>/dev/null; then WINE_AUDIO_DRIVER=pulse export WINE_AUDIO_DRIVER echo "droiddeck-proton: a Remote Play client is connected - game audio goes through PulseAudio so the stream carries it" >&2 return 0 fi version=$("$base/files/bin-arm64/wine" --version 2>/dev/null) major=${version#wine-} major=${major%%.*} if [ "$major" != "11" ]; then echo "droiddeck-proton: DirectAudio left off - it is built for Wine 11 and this Proton is '${version:-unknown}'. Pairing them would be silent rather than broken, so it is not worth guessing." >&2 return 0 fi winepulse="$base/files/lib/wine/aarch64-unix/winepulse.so" if [ ! -f "$winepulse" ]; then echo "droiddeck-proton: DirectAudio left off - no winepulse.so to read this Proton's audio interface from" >&2 return 0 fi if grep -aq PsCreateSystemThread "$winepulse"; then set=linux-wine11-systhread; else set=linux-wine11; fi da="$DD_DIRECTAUDIO/$set" if [ ! -d "$da/lib/wine" ]; then echo "droiddeck-proton: DirectAudio left off - no driver set for the $set interface is staged" >&2 return 0 fi WINEDLLPATH="$da/lib/wine${WINEDLLPATH:+:$WINEDLLPATH}" export WINEDLLPATH for name in $(compgen -e); do case $name in AUDIO_DIRECT_*) export "BANNER_$name=${!name}" ;; esac done WINE_AUDIO_DRIVER="directaudio,pulse" export WINE_AUDIO_DRIVER pfx="${STEAM_COMPAT_DATA_PATH:-}/pfx" reg="$pfx/user.reg" if [ -f "$reg" ]; then for pair in system32:aarch64-windows syswow64:i386-windows; do dir="$pfx/drive_c/windows/${pair%%:*}" src="$da/lib/wine/${pair#*:}/winedirectaudio.drv" if [ -d "$dir" ] && [ -f "$src" ] && [ "$(readlink "$dir/winedirectaudio.drv" 2>/dev/null)" != "$src" ]; then ln -sfn "$src" "$dir/winedirectaudio.drv.dd-new" && mv -f "$dir/winedirectaudio.drv.dd-new" "$dir/winedirectaudio.drv" fi done key='[Software\\\\Wine\\\\Drivers]' if [ "$(readlink "$pfx/drive_c/windows/system32/winedirectaudio.drv" 2>/dev/null)" != "$da/lib/wine/aarch64-windows/winedirectaudio.drv" ]; then echo "droiddeck-proton: DirectAudio could not be placed in the prefix; Proton's own audio stays" >&2 elif ! DD_KEY="$key" awk 'index($0, "[") == 1 { inside = index($0, ENVIRON["DD_KEY"] " ") == 1 } inside && index($0, "\\"Audio\\"=") == 1 { last = $0 } END { exit last != "\\"Audio\\"=\\"directaudio,pulse\\"" }' "$reg" 2>/dev/null; then printf '\\n%s %s\\n"Audio"="directaudio,pulse"\\n' "$key" "$(date +%s)" >> "$reg" echo "droiddeck-proton: DirectAudio selected in the prefix" >&2 srv="${DD_WINE_SERVER_BASE:-/tmp/.wine-$(id -u)}/server-$(printf '%x-%x' $(stat -c '%d %i' "$pfx" 2>/dev/null || echo 0 0))/socket" if [ -S "$srv" ]; then echo "droiddeck-proton: a wineserver is already running for this prefix; DirectAudio may only engage on the next launch" >&2 fi fi else echo "droiddeck-proton: no prefix yet - DirectAudio takes effect the next time this game starts" >&2 fi echo "droiddeck-proton: DirectAudio ready (Wine $major, $set)" >&2 } """ LAUNCHER_SH = """#!/bin/bash verb=$1; shift steam_root=${STEAM_COMPAT_CLIENT_INSTALL_PATH:-${XDG_DATA_HOME:-$HOME/.local/share}/Steam} for fake in /usr/local/lib/libfakeinput.so /usr/local/lib/libddsession.so; do if [ -f "$fake" ]; then case ":${LD_PRELOAD:-}:" in *":$fake:"*) ;; *) LD_PRELOAD="$fake${LD_PRELOAD:+:$LD_PRELOAD}"; export LD_PRELOAD ;; esac fi done audit=/usr/local/lib/libddaudit.so if [ -n "${PROOT_FP_KEY:-}" ] && [ -f "$audit" ]; then case ":${LD_AUDIT:-}:" in *":$audit:"*) ;; *) LD_AUDIT="$audit${LD_AUDIT:+:$LD_AUDIT}"; export LD_AUDIT ;; esac fi depot= libraries=$(printf '%%s\\n' "$steam_root" /mnt/droiddeck-sd; sed -n 's/^[[:space:]]*"path"[[:space:]]*"\\(.*\\)"[[:space:]]*$/\\1/p' "$steam_root/steamapps/libraryfolders.vdf" 2>/dev/null) for name in %s; do best=0 while IFS= read -r library; do candidate="$library/steamapps/common/$name" [ -d "$candidate/files/bin-arm64" ] && [ -x "$candidate/proton" ] || continue build=0 read -r build _ 2>/dev/null < "$candidate/version" case $build in "" | *[!0-9]*) build=0 ;; esac if [ -z "$depot" ] || [ "$build" -gt "$best" ]; then depot=$candidate best=$build fi done <<< "$libraries" [ -n "$depot" ] && break done if [ -n "$depot" ]; then dd_components "$depot" dd_directaudio "$depot" "$@" dd_game_cpus dd_idtech3 "$@" dd_vacdiag "$@" dd_libpath DD_STORE_PROTON="$depot/proton"; export DD_STORE_PROTON dd_store_launch "$@" DD_STORE_ARGS=("$@") dd_run ${DD_TASKSET:-} /usr/local/bin/droiddeck-game-env "$depot/proton" "$verb" "$@" "${DD_EXTRA_ARGS[@]}" fi echo "droiddeck-proton: no ARM64 Proton depot yet - the client downloads one as this tool's dependency; retry the launch once it has" >&2 exit 1 """ LAUNCHER_TEMPLATE = LAUNCHER_SH def launcher_sh(sources=SOURCES): return (LAUNCHER_TEMPLATE % " ".join('"%s"' % n for n in sources)).replace( "verb=$1; shift", "verb=$1; shift\n" + DD_DRIVER_QUERY_SKIP + DD_DESKTOP_GPU_SETUP + DD_DIRECTAUDIO_SETUP + DD_GAME_CPUS_SETUP + DD_IDTECH3_SETUP + DD_VACDIAG_SETUP + DD_COMPONENTS_SETUP + DD_LIBPATH_SETUP + DD_STORE_SETUP, 1) LAUNCHER_SH = launcher_sh() EXTRA_WRAPPER = "droiddeck-proton-wrap" LEGACY_EXTRA_WRAPPER = "bannerlator-proton-wrap" ORIGINAL_SUFFIX = ".droiddeck-orig" LEGACY_ORIGINAL_SUFFIX = ".bannerlator-orig" EXTRA_MANIFEST_VDF = """"manifest" { "version" "2" "commandline" "/%s %%verb%%" "use_sessions" "1" "compatmanager_layer_name" "proton" } """ % EXTRA_WRAPPER EXTRA_WRAPPER_SH = """#!/bin/bash verb=$1; shift here=$(dirname "$0") for fake in /usr/local/lib/libfakeinput.so /usr/local/lib/libddsession.so; do if [ -f "$fake" ]; then case ":${LD_PRELOAD:-}:" in *":$fake:"*) ;; *) LD_PRELOAD="$fake${LD_PRELOAD:+:$LD_PRELOAD}"; export LD_PRELOAD ;; esac fi done audit=/usr/local/lib/libddaudit.so if [ -n "${PROOT_FP_KEY:-}" ] && [ -f "$audit" ]; then case ":${LD_AUDIT:-}:" in *":$audit:"*) ;; *) LD_AUDIT="$audit${LD_AUDIT:+:$LD_AUDIT}"; export LD_AUDIT ;; esac fi dd_components "$here" dd_directaudio "$here" "$@" dd_game_cpus dd_idtech3 "$@" dd_vacdiag "$@" dd_libpath DD_STORE_PROTON="$here/%s"; export DD_STORE_PROTON dd_store_launch "$@" DD_STORE_ARGS=("$@") dd_run ${DD_TASKSET:-} /usr/local/bin/droiddeck-game-env "$DD_STORE_PROTON" "$verb" "$@" "${DD_EXTRA_ARGS[@]}" """ def extra_wrapper_sh(entry_point): return (EXTRA_WRAPPER_SH % entry_point).replace( 'here=$(dirname "$0")', 'here=$(dirname "$0")\n' + DD_DRIVER_QUERY_SKIP + DD_DESKTOP_GPU_SETUP + DD_DIRECTAUDIO_SETUP + DD_GAME_CPUS_SETUP + DD_IDTECH3_SETUP + DD_VACDIAG_SETUP + DD_COMPONENTS_SETUP + DD_LIBPATH_SETUP + DD_STORE_SETUP, 1) EXTRA_COMPAT_TOOL_VDF = """"compatibilitytools" { "compat_tools" { "%s" { "install_path" "." "display_name" "%s" "from_oslist" "windows" "to_oslist" "linux" } } } """ FEX_COMPAT_TOOL_VDF = """"compatibilitytools" { "compat_tools" { "%s" { "install_path" "." "display_name" "%s" "from_oslist" "linux" "to_oslist" "linux" } } } """ FEX_MANIFEST_VDF = """"manifest" { "version" "2" "commandline" "/%s %%verb%%" "use_tool_subprocess_reaper" "1" } """ % FEX_LAUNCHER FEX_LAUNCHER_SH = """#!/bin/bash verb=$1; shift case $verb in getcompatpath | getnativepath) printf '%s\\n' "$1"; exit 0 ;; esac """ + DD_DESKTOP_GPU_SETUP + DD_GAME_CPUS_SETUP + """ dd_game_cpus if [ -x /usr/local/bin/droiddeck-steamvr-flat ] && /usr/local/bin/droiddeck-steamvr-flat "$verb"; then exec /usr/local/bin/droiddeck-steamvr-game ${DD_TASKSET:-} /usr/local/bin/droiddeck-fex steam "$verb" "$@" fi exec ${DD_TASKSET:-} /usr/local/bin/droiddeck-fex steam "$verb" "$@" """ TOKEN = re.compile(r'\s*(?:"((?:[^"\\]|\\.)*)"|([{}])|//[^\n]*)') def tokenize(text): tokens = [] pos = 0 while pos < len(text): m = TOKEN.match(text, pos) if not m or m.end() == pos: break pos = m.end() if m.group(2): tokens.append(m.group(2)) elif m.group(1) is not None: tokens.append('"' + m.group(1) + '"') return tokens def find_block(tokens, path): depth, want, i = 0, 0, 0 while i < len(tokens): t = tokens[i] if t == "{": depth += 1 elif t == "}": depth -= 1 if depth < want: return None elif depth == want and i + 1 < len(tokens) and tokens[i + 1] == "{": if t.lower() == '"%s"' % path[want].lower(): if want == len(path) - 1: return i + 1 want += 1 i += 1 return None def block_end(tokens, start): depth = 0 for i in range(start, len(tokens)): if tokens[i] == "{": depth += 1 elif tokens[i] == "}": depth -= 1 if depth == 0: return i return len(tokens) def serialize(tokens): out, depth, i = [], 0, 0 while i < len(tokens): t = tokens[i] if t == "}": depth -= 1 out.append("\t" * depth + "}") i += 1 elif i + 1 < len(tokens) and tokens[i + 1] == "{": out.append("\t" * depth + t) out.append("\t" * depth + "{") depth += 1 i += 2 else: out.append("\t" * depth + t + "\t\t" + tokens[i + 1]) i += 2 return "\n".join(out) + "\n" def write_changed(path, text, mode=None): try: with open(path, encoding="utf-8", errors="replace") as f: same = f.read() == text except OSError: same = False if not same: tmp = path + ".droiddeck" with open(tmp, "w", encoding="utf-8") as f: f.write(text) if mode is not None: os.chmod(tmp, mode) os.replace(tmp, path) elif mode is not None and (os.stat(path).st_mode & 0o7777) != mode: os.chmod(path, mode) return not same def display_name(base): try: with open(LABEL_FILE, encoding="utf-8") as f: label = f.read().strip().replace('"', "'").replace("\\", "") except OSError: label = "" return "%s (%s)" % (base, label) if label else base def first_key(path, section): try: with open(path, encoding="utf-8", errors="replace") as f: tokens = tokenize(f.read()) except OSError: return None block = find_block(tokens, section) if block is None: return None for i in range(block + 1, block_end(tokens, block)): if tokens[i] == "}": break if i + 1 < len(tokens) and tokens[i + 1] == "{": return tokens[i].strip('"') return None def manifest_entry_point(path): try: with open(path, encoding="utf-8", errors="replace") as f: tokens = tokenize(f.read()) except OSError: return None for i in range(len(tokens) - 1): if tokens[i].lower() == '"commandline"': command = tokens[i + 1].strip('"').split() if command: return command[0].lstrip("/") return None def adopt_extras(tools): adopted = {} try: entries = sorted(os.listdir(tools)) except OSError: return adopted for entry in entries: if entry in dict(OWN_TOOLS) or entry == FEX_TOOL or entry.startswith("."): continue tool_dir = os.path.join(tools, entry) manifest = os.path.join(tool_dir, "toolmanifest.vdf") if not os.path.isdir(tool_dir) or not os.path.isfile(manifest): continue original = manifest + ORIGINAL_SUFFIX legacy = manifest + LEGACY_ORIGINAL_SUFFIX if not os.path.isfile(original) and os.path.isfile(legacy): try: os.replace(legacy, original) except OSError: continue if not os.path.isfile(original): try: shutil.copy2(manifest, original) except OSError: continue entry_point = manifest_entry_point(original) if not entry_point or entry_point in (EXTRA_WRAPPER, LEGACY_EXTRA_WRAPPER): entry_point = "proton" if not os.path.exists(os.path.join(tool_dir, entry_point)): print("steam-compatibility: %s has no %s; left alone" % (entry, entry_point)) continue compat_vdf = os.path.join(tool_dir, "compatibilitytool.vdf") name = first_key(compat_vdf, ["compatibilitytools", "compat_tools"]) or entry wrapper = os.path.join(tool_dir, EXTRA_WRAPPER) try: write_changed(wrapper, extra_wrapper_sh(entry_point), 0o755) write_changed(manifest, EXTRA_MANIFEST_VDF) write_changed(compat_vdf, EXTRA_COMPAT_TOOL_VDF % (name, display_name(entry))) legacy_wrapper = os.path.join(tool_dir, LEGACY_EXTRA_WRAPPER) if os.path.isfile(legacy_wrapper): os.unlink(legacy_wrapper) except OSError as e: print("steam-compatibility: could not adopt %s (%s)" % (entry, e)) continue adopted[name] = entry return adopted NOT_GAMES = frozenset(( "228980", "1070560", "1391110", "1628350", "1493710", "3127680", "4183110", "4185400", "4427310", "4628740", )) def libraries(steam_root): found = [steam_root] try: with open(os.path.join(steam_root, "steamapps", "libraryfolders.vdf"), encoding="utf-8", errors="replace") as f: found += [path.replace("\\\\", "\\") for path in re.findall(r'"path"\s+"((?:[^"\\]|\\.)*)"', f.read())] except OSError: pass found.append(LIBRARY + "-sd") return list(dict.fromkeys(found)) def installed_apps(steam_root): entries = appinfo_entries(os.path.join(steam_root, "appcache", "appinfo.vdf")) apps = set() for library in libraries(steam_root): steamapps = os.path.join(library, "steamapps") try: names = os.listdir(steamapps) except OSError: continue for name in names: m = re.fullmatch(r"appmanifest_(\d+)\.acf", name) if m and m.group(1) not in NOT_GAMES and entries.get(m.group(1), {}).get("type") != "tool": apps.add(m.group(1)) return sorted(apps, key=int) APPINFO_CACHE = {} STEAM_PLAY_MANIFESTS = 891390 def launch_programs(config): launch = config.get("launch") if isinstance(config, dict) else None found = [] for option in launch.values() if isinstance(launch, dict) else (): if not isinstance(option, dict) or not option.get("executable"): continue settings = option.get("config") if isinstance(option.get("config"), dict) else {} oslist = str(settings.get("oslist", "")).lower() if oslist and "windows" not in oslist and "linux" not in oslist: continue found.append(os.path.normpath(str(option["executable"]).replace("\\", "/")).lstrip("/").lower()) return found def launch_options(config): launch = config.get("launch") if isinstance(config, dict) else None found = [] for key, option in launch.items() if isinstance(launch, dict) else (): if not isinstance(option, dict) or not option.get("executable"): continue settings = option.get("config") if isinstance(option.get("config"), dict) else {} found.append({ "key": str(key), "executable": str(option["executable"]), "arguments": str(option.get("arguments", "")), "workingdir": str(option.get("workingdir", "")), "type": str(option.get("type", "")).lower(), "oslist": str(settings.get("oslist", "")).lower(), "betakey": str(settings.get("betakey", "")), }) return found def appinfo_entries(path, wanted=None): """Read metadata for all apps, or only the requested app-id strings.""" import struct if wanted is not None: wanted = set(wanted) if not wanted: return {} try: stamp = os.stat(path).st_mtime_ns except OSError: return {} cached = APPINFO_CACHE.get(path) if cached and cached[0] == stamp: covered = cached[2] if covered is None or (wanted is not None and wanted <= covered): return cached[1] if wanted is None else {app: cached[1][app] for app in wanted if app in cached[1]} data = cached[3] needed = None if wanted is None else wanted - covered else: cached = None needed = wanted try: with open(path, "rb") as f: data = f.read() except OSError: return {} if len(data) < 8: return {} magic = struct.unpack_from("= 0x07564428 else 0) def section(position): result = {} while True: kind = data[position] position += 1 if kind == 8: return result, position if strings is not None: key = strings[struct.unpack_from(" 0xFFFFFFFF: continue if request is None: resolved[app] = None continue if (not isinstance(request, dict) or not isinstance(request.get("dir"), str) or not request["dir"] or not isinstance(request.get("valve"), bool)): continue tool = requested_tool(request, catalog) if tool is None or runnable is not None and tool not in runnable: resolved[app] = DEFERRED_GAME_TOOL else: resolved[app] = tool return resolved OWN_PROTON = "DroidDeck-Proton" ARCH_WORDS = re.compile(r"(?i)aarch64|arm64|x86_64|x86-64|amd64") def own_builds(tools): return [t for t in tools if isinstance(t, dict) and not t.get("valve") and isinstance(t.get("dir"), str) and t["dir"].startswith(OWN_PROTON) and t.get("name")] def build_key(name): return [int(n) for n in re.findall(r"\d+", ARCH_WORDS.sub(" ", name))] def own_proton_moves(state, catalog): names = {t["name"] for t in catalog} before = state.get("tools") if isinstance(state.get("tools"), list) else () seen = state.get("own_builds") if isinstance(state.get("own_builds"), list) else [] known = {n for n in seen if isinstance(n, str)} | {t["name"] for t in own_builds(before)} | {t["name"] for t in own_builds(catalog)} state["own_builds"] = sorted(known) builds = own_builds(catalog) if not builds: return None, set() newest = max(builds, key=lambda t: (build_key(t["dir"]), t["dir"]))["name"] return newest, known - names def now_ms(): import time return int(time.time() * 1000) def choose_default(steam_default, state, request, catalog, adopt_steam=True, apply_request=True, now=None, listed=None): state = dict(state) names = [t["name"] for t in catalog] listed = names if listed is None else listed if "written" not in state and state.get("source") == "steam": state["source"] = "fallback" hidden = state.get("default") in names and state.get("default") not in listed seq = request.get("seq") seq = seq if isinstance(seq, int) else 0 if apply_request and seq > int(state.get("applied", 0) or 0): wanted = requested_tool(request, catalog) state["applied"] = seq if wanted: if wanted != state.get("default"): state.update(default=wanted, seq=now or now_ms(), source="app") else: print("steam-compatibility: the app asked for %s, which is not installed; kept %s" % ( request.get("name") or request.get("dir"), state.get("default") or TOOL)) elif adopt_steam and steam_default in names and not hidden and steam_default not in ( state.get("default"), state.get("written", state.get("default") or TOOL)): state.update(default=steam_default, seq=now or now_ms(), source="steam") if state.get("default") not in names and state.get("default") != TOOL: state.update(default=TOOL, source="fallback") return state["default"] if state["default"] in listed else TOOL, state def mapping_block(tokens): steam = find_block(tokens, ["InstallConfigStore", "Software", "Valve", "Steam"]) if steam is None: return None mapping = find_block(tokens[steam + 1:], ["CompatToolMapping"]) if mapping is None: end = block_end(tokens, steam) tokens[end:end] = ['"CompatToolMapping"', "{", "}"] return end + 1 return mapping + steam + 1 def read_mapping(tokens, mapping): current = {} end = block_end(tokens, mapping) i = mapping + 1 while i < end: if i + 1 < end and tokens[i + 1] == "{": close = block_end(tokens, i + 1) name = "" for j in range(i + 2, close - 1): if tokens[j] == '"name"': name = tokens[j + 1].strip('"') break current[tokens[i].strip('"')] = name i = close + 1 else: i += 2 return current def read_config_mapping(config_path): try: with open(config_path, encoding="utf-8", errors="replace") as f: tokens = tokenize(f.read()) except OSError: return None depth = 0 for token in tokens: if token == "{": depth += 1 elif token == "}": depth -= 1 if depth < 0: return None if depth != 0: return None steam = find_block(tokens, ["InstallConfigStore", "Software", "Valve", "Steam"]) if steam is None: return None mapping = find_block(tokens[steam + 1:], ["CompatToolMapping"]) return read_mapping(tokens, mapping + steam + 1) if mapping is not None else {} def mapping_entry(app, tool): return ['"%s"' % app, "{", '"name"', '"%s"' % tool, '"config"', '""', '"priority"', '"75"' if app == "0" else '"250"', "}"] def set_mapping_tool(tokens, block, tool): end = block_end(tokens, block) for i in range(block + 1, end): if tokens[i] == '"name"': tokens[i + 1] = '"%s"' % tool return tokens[block + 1:block + 1] = ['"name"', '"%s"' % tool] def set_mapping(tokens, mapping, app, tool): block = find_block(tokens[mapping + 1:], [app]) if tool is None: if block is not None: block += mapping + 1 del tokens[block - 1:block_end(tokens, block) + 1] return if block is None: tokens[mapping + 1:mapping + 1] = mapping_entry(app, tool) return set_mapping_tool(tokens, block + mapping + 1, tool) def set_mappings(tokens, mapping, changes): """Apply a batch with one traversal of the affected mapping entries.""" pending = {('"%s"' % app).lower(): (app, tool) for app, tool in changes.items()} # Non-string or aliased keys retain the single writer's sequential semantics. if len(changes) < 2 or len(pending) != len(changes) or any(not isinstance(app, str) for app in changes): for app, tool in changes.items(): set_mapping(tokens, mapping, app, tool) return updated = [] i = mapping + 1 while pending and i < len(tokens) and tokens[i] != "}": if i + 1 < len(tokens) and tokens[i + 1] == "{": end = block_end(tokens, i + 1) change = pending.pop(tokens[i].lower(), None) if change is None: updated.extend(tokens[i:end + 1]) elif change[1] is not None: entry = tokens[i:end + 1] set_mapping_tool(entry, 1, change[1]) updated.extend(entry) i = end + 1 else: updated.append(tokens[i]) i += 1 added = [] for app, tool in reversed(list(pending.values())): if tool is not None: added.extend(mapping_entry(app, tool)) tokens[mapping + 1:i] = added + updated def steam_running(): try: pids = [p for p in os.listdir("/proc") if p.isdigit()] except OSError: return False for pid in pids: try: with open("/proc/%s/cmdline" % pid, "rb") as f: argv0 = f.read().split(b"\0", 1)[0] except OSError: continue if argv0.endswith(b"steamrtarm64/steam"): return True return False def game_running(): try: pids = [p for p in os.listdir("/proc") if p.isdigit()] except OSError: return False for pid in pids: try: with open("/proc/%s/cmdline" % pid, "rb") as f: if b"\0SteamLaunch\0AppId=" in f.read(): return True except OSError: continue return False def live_helper_running(directory=None): try: with open(state_path("live.pid", directory)) as f: pid = int(f.read().split()[0]) os.kill(pid, 0) return True except (OSError, ValueError, IndexError): return False def register_default(config_path, apps=(), protect=(), default=None, catalog=None, directory=None, settle=False, picks=(), linux_tool=FEX_TOOL, owned=None): with locked(directory): state = read_json(state_path("state.json", directory)) with open(config_path, encoding="utf-8", errors="replace") as f: original = f.read() tokens = tokenize(original) mapping = mapping_block(tokens) if mapping is None: return state.get("default") or TOOL current = read_mapping(tokens, mapping) if catalog is None: catalog = tool_catalog(os.path.dirname(os.path.dirname(os.path.abspath(config_path))), dict(protect) if isinstance(protect, dict) else {name: name for name in protect}) names = [t["name"] for t in catalog] newest, gone = own_proton_moves(state, catalog) previous = state.get("default") if owned is not None: auto = followers(state, current) known = {app for app in state.get("owned", ()) if isinstance(app, str)} if isinstance(state.get("owned"), list) else set() pinned = {app: current[app] for app in set(owned) - known if app in current and current.get(app) in {TOOL, previous} | gone and app not in auto} if pinned and isinstance(auto, dict): state["auto"] = dict(auto, **pinned) state["owned"] = sorted(set(owned), key=app_order) if default is None: if settle: default, state = choose_default(built_from(current.get("0", ""), catalog) or current.get("0", ""), state, read_json(state_path("request.json", directory)), catalog) else: default = state.get("default") if state.get("default") in names else TOOL if settle and newest and default == TOOL and state.get("source") not in ("app", "steam"): default = newest state.update(default=newest, seq=now_ms(), source="update") state.pop("own_proton", None) if newest: replacements = {app: newest for app, name in current.items() if app != "0" and name in gone} set_mappings(tokens, mapping, replacements) current.update(replacements) if isinstance(state.get("auto"), dict): state["auto"] = {app: newest if name in gone else name for app, name in state["auto"].items()} following = followers(state, current) following = following if isinstance(following, dict) else {} moved = rebuilt_picks(current, catalog, set(following) | picked_apps(state)) if moved: state["auto"] = {app: name for app, name in following.items() if app not in moved} set_mappings(tokens, mapping, moved) current.update(moved) steam_root = os.path.dirname(os.path.dirname(os.path.abspath(config_path))) requests = settled_game_requests(state, current, catalog, not steam_running(), directory) overrides = requested_games(requests or {}, catalog) managed = state.get("auto", {}).keys() if isinstance(state.get("auto"), dict) else () native_choices = state.get("native_choices", ()) native = native_targets(steam_root, set(apps) | set(picks) | set(managed) | set(native_choices)) if linux_tool != FEX_TOOL: native = {app: linux_tool if tool == FEX_TOOL else tool for app, tool in native.items()} for app in picked_apps(state) & set(native): current.setdefault(app, "") changes, auto = plan_mapping( current, apps, names, default, followers(state, current), native, picks, overrides, managed, native_choices, tool_platforms(steam_root)) set_mappings(tokens, mapping, changes) text = serialize(tokens) if text != serialize(tokenize(original)): write_changed(config_path, text) state["auto"] = {app: tool for app, tool in auto.items() if tool is not NATIVE_CHOICE} state["native_choices"] = sorted(app for app, tool in auto.items() if tool is NATIVE_CHOICE) state["picked"] = picked_after(current, changes) state["games_applied"] = applied_game_requests(requests, overrides, state) state.pop("native", None) state["tools"] = catalog state.setdefault("default", default) if settle: state["written"] = default write_json(state_path("state.json", directory), state) return default def depot_build(depot): try: with open(os.path.join(depot, "version"), encoding="utf-8", errors="replace") as f: first = f.read().split(None, 1) except OSError: return 0 return int(first[0]) if first and first[0].isdigit() else 0 def find_source(steam_root, sources=SOURCES, runnable=False): for name in sources: found = [os.path.join(root, "steamapps", "common", name) for root in libraries(steam_root) if os.path.isdir(os.path.join(root, "steamapps", "common", name, "files", "bin-arm64")) and (not runnable or os.access(os.path.join(root, "steamapps", "common", name, "proton"), os.X_OK))] if found: return max(found, key=depot_build) return None def build_tool(tool_dir, depot, sources=SOURCES, name=TOOL): if os.path.islink(tool_dir): os.unlink(tool_dir) elif os.path.isdir(tool_dir) and set(os.listdir(tool_dir)) - set(OWN_FILES): shutil.rmtree(tool_dir) os.makedirs(tool_dir, exist_ok=True) write_changed(os.path.join(tool_dir, "toolmanifest.vdf"), TOOL_MANIFEST_VDF) write_changed(os.path.join(tool_dir, "compatibilitytool.vdf"), COMPAT_TOOL_VDF % (name, display_name( os.path.basename(depot).replace(" (ARM64)", " ARM64") if depot else "Proton ARM64"))) write_changed(os.path.join(tool_dir, LAUNCHER), launcher_sh(sources), 0o755) def build_fex_tool(tool_dir): if os.path.islink(tool_dir): os.unlink(tool_dir) elif os.path.isdir(tool_dir) and set(os.listdir(tool_dir)) - set(FEX_FILES): shutil.rmtree(tool_dir) os.makedirs(tool_dir, exist_ok=True) write_changed(os.path.join(tool_dir, "toolmanifest.vdf"), FEX_MANIFEST_VDF) write_changed(os.path.join(tool_dir, "compatibilitytool.vdf"), FEX_COMPAT_TOOL_VDF % (FEX_TOOL, display_name("Linux x86 (FEX)"))) write_changed(os.path.join(tool_dir, FEX_LAUNCHER), FEX_LAUNCHER_SH, 0o755) def remove_tool(tool_dir): if os.path.isdir(tool_dir) and not os.path.islink(tool_dir) and not set(os.listdir(tool_dir)) - set(OWN_FILES) - {LEGACY_LAUNCHER}: shutil.rmtree(tool_dir) def local_tools(steam_root): names = set() tools = os.path.join(steam_root, "compatibilitytools.d") try: entries = os.listdir(tools) except OSError: return names for entry in entries: try: with open(os.path.join(tools, entry, "compatibilitytool.vdf"), encoding="utf-8", errors="replace") as f: m = re.search(r'"compat_tools"\s*\{\s*"([^"]+)"', f.read()) except OSError: continue if m: names.add(m.group(1).lower()) return names def x64_repoint(steam_root, tool, live=False): config = os.path.join(steam_root, "config", "config.vdf") if not tool or not os.path.isfile(config): return [] with open(config, encoding="utf-8", errors="replace") as f: original = f.read() tokens = tokenize(original) mapping = mapping_block(tokens) if mapping is None: return [] keep = local_tools(steam_root) moved = [] current = read_mapping(tokens, mapping) changes = {} if "0" in current else {"0": tool} for app, name in current.items(): named = name.lower() legacy = named == "droiddeck-proton-arm64" if (named.startswith("proton") or legacy) and named != tool.lower() \ and (legacy or named not in keep): changes[app] = tool if app != "0": moved.append(app) set_mappings(tokens, mapping, changes) text = serialize(tokens) if text != serialize(tokenize(original)): write_changed(config, text) print("steam-compatibility: x86-64 client's Proton entries point at %s" % tool) if moved and live: with open(os.path.join(os.path.expanduser("~"), ".dd-compat-pending"), "a") as f: f.write("".join("%s\n" % a for a in moved)) print("steam-compatibility: repointed while the client runs: %s" % " ".join(moved)) return moved def main(): steam_root = sys.argv[1] if "--x64" in sys.argv[2:]: x64_repoint(steam_root, os.environ.get("DD_COMPAT_TOOL"), "--live" in sys.argv[2:]) return tools = os.path.join(steam_root, "compatibilitytools.d") os.makedirs(tools, exist_ok=True) legacy = os.path.join(tools, LEGACY_TOOL) if os.path.islink(legacy): os.unlink(legacy) elif os.path.isdir(legacy): shutil.rmtree(legacy) for name, sources in OWN_TOOLS: depot = find_source(steam_root, sources) if depot is None and name != TOOL: remove_tool(os.path.join(tools, name)) continue build_tool(os.path.join(tools, name), depot, sources, name) print("steam-compatibility: registered %s (%s)" % ( name, "depot %s present" % os.path.basename(depot) if depot else "no ARM64 Proton depot yet; the session asks the client to fetch it")) build_fex_tool(os.path.join(tools, FEX_TOOL)) print("steam-compatibility: registered %s" % FEX_TOOL) extras = adopt_extras(tools) for name, directory in sorted(extras.items()): print("steam-compatibility: adopted %s as %s" % (directory, name)) catalog = tool_catalog(steam_root, extras) config = os.path.join(steam_root, "config", "config.vdf") if live_helper_running(): with locked(): state = read_json(state_path("state.json")) state["tools"] = catalog write_json(state_path("state.json"), state) print("steam-compatibility: the live helper keeps the client's mapping; tools listed") elif os.path.isfile(config): apps = installed_apps(steam_root) picks = valve_picks(steam_root) default = register_default(config, apps, protect=extras, catalog=catalog, settle=not steam_running(), picks=picks) print("steam-compatibility: default, %d installed title(s) and %d title(s) with a Valve pick set to %s" % (len(apps), len(picks), default)) sync = os.path.join(os.path.dirname(os.path.realpath(__file__)), "droiddeck-esync") if os.path.isfile(sync): try: summary = runpy.run_path(sync)["reconcile"](steam_root, os.environ) except Exception as e: summary = "droiddeck-esync: reconcile failed (%s)" % e if summary: print("steam-compatibility: %s" % summary) if __name__ == "__main__": main()