Sunshine + KDE Wayland 虚拟显示器配置教程

krfb-virtualmonitor 请求 KWin 创建虚拟输出
                  ↓
Virtual-sunshine-virtual：独立桌面源、主输出
        ├── Sunshine 通过 KWin / PipeWire 捕获 → NVENC → Moonlight
        └── 内置屏幕 eDP-2 复制它，按自身物理模式显示

sudo pacman -S krfb kscreen python dbus qt6-tools

command -v krfb-virtualmonitor
command -v kscreen-doctor
command -v python3
command -v qdbus6
command -v dbus-monitor

printf '%s\n' "$XDG_SESSION_TYPE" "$WAYLAND_DISPLAY"
kscreen-doctor -o
kscreen-doctor --help
krfb-virtualmonitor --help
systemctl --user list-unit-files '*Sunshine*' '*sunshine*'

sunshine_backup_dir="$HOME/sunshine-display-backup-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$sunshine_backup_dir"
chmod 700 "$sunshine_backup_dir"
for sunshine_config_file in "$HOME/.config/kwinoutputconfig.json" "$HOME/.config/powerdevilrc" "$HOME/.config/sunshine/sunshine.conf" "$HOME/.config/sunshine/apps.json"; do
    if [ -f "$sunshine_config_file" ]; then
        cp -p "$sunshine_config_file" "$sunshine_backup_dir/"
    fi
done
printf '备份目录：%s\n' "$sunshine_backup_dir"

mkdir -p "$HOME/.local/bin" "$HOME/.config/systemd/user"

#!/usr/bin/env python3
"""Populate KWin virtual modes and select them only after they exist."""
import argparse
import json
import os
import re
import subprocess
import sys
import time

OUTPUT = 'Virtual-sunshine-virtual'
RESOLUTIONS = [
    (1280, 720), (1280, 800), (1600, 900), (1600, 1000),
    (1920, 1080), (1920, 1200), (2560, 1440), (2560, 1600),
    (3840, 2160), (2360, 1640), (2384, 1080),
]
REFRESH_RATES = [24, 30, 60, 90, 120, 144, 165, 240]
PRESETS = [(width, height, fps) for width, height in RESOLUTIONS
           for fps in REFRESH_RATES]


def doctor(*args):
    result = subprocess.run(['kscreen-doctor', *args], capture_output=True,
                            text=True, timeout=15)
    # Some libkscreen versions print an apply failure but still exit zero.
    if result.returncode or 'applying config failed' in result.stdout.lower():
        raise RuntimeError((result.stdout + result.stderr).strip()
                           or 'kscreen-doctor failed')
    return result.stdout


def output(wait=0):
    deadline = time.monotonic() + wait
    while True:
        data = json.loads(doctor('-j'))
        found = next((o for o in data['outputs'] if o['name'] == OUTPUT), None)
        if found:
            return found
        if time.monotonic() >= deadline:
            raise RuntimeError(f'{OUTPUT} is not available')
        time.sleep(0.2)


def matching_mode(out, width, height, fps):
    matches = [m for m in out['modes']
               if m['size'] == {'width': width, 'height': height}
               and abs(m['refreshRate'] - fps) < 0.5]
    return min(matches, key=lambda m: abs(m['refreshRate'] - fps)) if matches else None


def custom_modes():
    # JSON omits customModes; the text output exposes the removal indices.
    text = re.sub(r'\x1b\[[0-9;]*m', '', doctor('-o'))
    section = next(s for s in text.split('Output: ')[1:] if s.splitlines()[0].split()[1] == OUTPUT)
    block = section.split('Custom modes:', 1)[1].split('Geometry:', 1)[0]
    return [(int(i), int(w), int(h), float(fps))
            for i, w, h, fps in re.findall(r'(\d+): (\d+)x(\d+)@([\d.]+)', block)]


def nominal_rate(w, h, fps):
    known = [f for pw, ph, f in PRESETS if (pw, ph) == (w, h)]
    return min(known, key=lambda f: abs(f - fps)) if known and min(abs(f-fps) for f in known) < 2 else round(fps)


def add_modes(out, modes, replace=False):
    # libkscreen sends CVT-rounded rates back on every configuration change.
    # Rebuild using nominal integer rates so retries cannot accumulate drift.
    existing = custom_modes()
    desired = set(modes)
    if not replace:
        desired.update((w, h, nominal_rate(w, h, fps)) for _, w, h, fps in existing)
    elif current := next((m for m in out['modes'] if m['id'] == out['currentModeId']), None):
        # Prune old presets without removing the mode currently in use.
        desired.add((current['size']['width'], current['size']['height'],
                     nominal_rate(current['size']['width'], current['size']['height'],
                                  current['refreshRate'])))
    native = [m for m in out['modes'] if m['id'] in out['preferredModes']]
    desired = {mode for mode in desired if not any(
        n['size'] == {'width': mode[0], 'height': mode[1]} and
        abs(n['refreshRate'] - mode[2]) < 0.5 for n in native)}
    args = [f'output.{OUTPUT}.removeCustomMode.{i}' for i, *_ in sorted(existing, reverse=True)]
    args += [f'output.{OUTPUT}.addCustomMode.{w}.{h}.{fps * 1000}.reduced'
             for w, h, fps in sorted(desired)]
    if args:
        doctor(*args)
    out = output()
    for w, h, fps in modes:
        if not matching_mode(out, w, h, fps):
            raise RuntimeError(f'KWin did not add {w}x{h}@{fps}')
    return out


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--defaults', action='store_true', help='Replace presets without switching the current mode')
    parser.add_argument('--wait', type=float, default=0)
    parser.add_argument('--set', nargs=3, type=int, metavar=('WIDTH', 'HEIGHT', 'FPS'))
    args = parser.parse_args()
    if not args.defaults and args.set is None:
        parser.error('use --defaults and/or --set WIDTH HEIGHT FPS')
    if args.set:
        w, h, fps = args.set
        if not (320 <= w <= 16384 and 320 <= h <= 16384 and w * h <= 50000000 and 1 <= fps <= 240):
            parser.error('invalid resolution or frame rate')
    os.environ.setdefault('XDG_RUNTIME_DIR', f'/run/user/{os.getuid()}')
    os.environ.setdefault('WAYLAND_DISPLAY', 'wayland-0')
    os.environ.setdefault('DBUS_SESSION_BUS_ADDRESS', 'unix:path=' + os.environ['XDG_RUNTIME_DIR'] + '/bus')
    out = output(args.wait)
    modes = PRESETS.copy() if args.defaults else []
    if args.set and tuple(args.set) not in modes:
        modes.append(tuple(args.set))
    out = add_modes(out, modes, replace=args.defaults)
    if args.set:
        mode = matching_mode(out, *args.set)
        doctor(f'output.{OUTPUT}.mode.{mode["id"]}')
        actual = output()
        current = next(m for m in actual['modes'] if m['id'] == actual['currentModeId'])
        if current['size'] != mode['size'] or abs(current['refreshRate'] - mode['refreshRate']) > 0.1:
            raise RuntimeError('KWin did not switch to the requested mode')
        print(f'{OUTPUT}: {current["size"]["width"]}x{current["size"]["height"]}@{current["refreshRate"]:.2f}')
    else:
        print(f'{OUTPUT}: {len(out["modes"])} modes available')


if __name__ == '__main__':
    try:
        main()
    except (RuntimeError, ValueError, subprocess.SubprocessError, OSError) as exc:
        print(str(exc), file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env python3
"""Make the virtual output the capture source; the panel mirrors it."""
import datetime
import json
import os
from pathlib import Path
import subprocess
import sys

VIRTUAL = 'Virtual-sunshine-virtual'
PANEL = 'eDP-2'
UNIT = 'sunshine-virtual-monitor.service'
BIN = Path.home() / '.local/bin'
STATE = Path(os.environ.get('XDG_STATE_HOME', str(Path.home() / '.local/state'))) / 'sunshine-virtual-display'


def run(*cmd):
    r = subprocess.run(cmd, capture_output=True, text=True, timeout=25)
    if r.returncode or 'applying config failed' in r.stdout.lower():
        raise RuntimeError((r.stdout + r.stderr).strip() or f'{cmd[0]} failed')
    return r.stdout


def snapshot():
    return json.loads(run('kscreen-doctor', '-j'))['outputs']


def current_mode(out):
    return next(m for m in out['modes'] if m['id'] == out['currentModeId'])


def record(message):
    STATE.mkdir(parents=True, exist_ok=True)
    with (STATE / 'hook.log').open('a') as log:
        log.write(f'[{datetime.datetime.now():%Y-%m-%d %H:%M:%S}] {message}\n')


def configure(requested=None):
    outputs = snapshot()
    virtual = next((o for o in outputs if o['name'] == VIRTUAL), None)
    if not virtual:
        run('systemctl', '--user', 'start', UNIT)
        outputs = snapshot()
        virtual = next((o for o in outputs if o['name'] == VIRTUAL), None)
    if not virtual:
        raise RuntimeError('persistent virtual output is unavailable')
    panel = next((o for o in outputs if o['name'] == PANEL and o['connected']), None)
    closed = run('qdbus6', 'org.kde.Solid.PowerManagement',
                 '/org/kde/Solid/PowerManagement', 'isLidClosed').strip() == 'true'
    args = [f'output.{VIRTUAL}.enable', f'output.{VIRTUAL}.mirror.none', f'output.{VIRTUAL}.primary']
    ready = virtual['enabled'] and virtual['replicationSource'] == 0 and virtual['priority'] == 1
    if panel:
        # Do not disable an open panel; let KWin manage its power on lid close.
        if not closed:
            args.append(f'output.{PANEL}.enable')
        args.append(f'output.{PANEL}.mirror.{VIRTUAL}')
        ready = ready and panel['replicationSource'] == virtual['id'] and (closed or panel['enabled'])
    if not ready:
        run('kscreen-doctor', *args)
    if requested:
        width, height, fps = requested
        actual = current_mode(next(o for o in snapshot() if o['name'] == VIRTUAL))
        if actual['size'] != {'width': width, 'height': height} or abs(actual['refreshRate'] - fps) >= 0.5:
            run(str(BIN / 'sunshine-display-modes'), '--set', str(width), str(height), str(fps))
    final = snapshot()
    v = next(o for o in final if o['name'] == VIRTUAL)
    if not v['enabled'] or v['replicationSource'] != 0 or v['priority'] != 1:
        raise RuntimeError('virtual output did not become the independent capture source')
    if panel:
        p = next(o for o in final if o['name'] == PANEL)
        if p['replicationSource'] != v['id'] or (not closed and not p['enabled']):
            raise RuntimeError('panel mirror was not preserved')
    mode = current_mode(v)
    if requested and (mode['size'] != {'width': requested[0], 'height': requested[1]} or abs(mode['refreshRate']-requested[2]) >= 0.5):
        raise RuntimeError('actual virtual resolution does not match the client request')
    message = f'virtual capture source {mode["size"]["width"]}x{mode["size"]["height"]}@{mode["refreshRate"]:.2f}; panel mirrors virtual; lid closed={closed}'
    record(message)
    print(message)


def client_mode():
    w, h = os.environ.get('SUNSHINE_CLIENT_WIDTH'), os.environ.get('SUNSHINE_CLIENT_HEIGHT')
    if w is None and h is None:
        return None  # Manual invocation preserves the user's chosen mode.
    try:
        width, height = int(w), int(h)
        fps = int(os.environ.get('SUNSHINE_CLIENT_FPS', '60'))
    except (TypeError, ValueError):
        raise RuntimeError('invalid client mode')
    if not (320 <= width <= 16384 and 320 <= height <= 16384 and width*height <= 50000000 and 1 <= fps <= 240):
        raise RuntimeError('invalid client mode')
    return width, height, fps


if __name__ == '__main__':
    os.environ.setdefault('XDG_RUNTIME_DIR', f'/run/user/{os.getuid()}')
    os.environ.setdefault('WAYLAND_DISPLAY', 'wayland-0')
    os.environ.setdefault('DBUS_SESSION_BUS_ADDRESS', 'unix:path=' + os.environ['XDG_RUNTIME_DIR'] + '/bus')
    action = sys.argv[1] if len(sys.argv) == 2 else ''
    if action not in ('start','stop','mirror'):
        print(f'Usage: {sys.argv[0]} {{start|stop|mirror}}', file=sys.stderr)
        sys.exit(2)
    try:
        if action == 'stop':
            record('client disconnected; retaining virtual capture source and selected resolution')
        else:
            configure(client_mode() if action == 'start' else None)
    except (RuntimeError, ValueError, subprocess.SubprocessError, OSError) as exc:
        record(f'ERROR: {exc}')
        print(str(exc), file=sys.stderr)
        sys.exit(1)

#!/usr/bin/env python3
"""Repair the capture source after KWin loads a saved lid layout."""
from pathlib import Path
import subprocess
import time

hook = str(Path.home() / '.local/bin/sunshine-virtual-display')
subprocess.run([hook, 'mirror'], check=True)
monitor = subprocess.Popen([
    '/usr/bin/dbus-monitor', '--session',
    "type='signal',interface='org.kde.Solid.PowerManagement',member='lidClosedChanged'"
], stdout=subprocess.PIPE, text=True, bufsize=1)
try:
    for line in monitor.stdout:
        if 'member=lidClosedChanged' in line:
            # Both PowerDevil and KWin react to the hardware lid event.
            # Reapply after their saved layout has been loaded.
            time.sleep(0.5)
            subprocess.run([hook, 'mirror'], check=True)
            time.sleep(0.5)
            subprocess.run([hook, 'mirror'], check=True)
finally:
    monitor.terminate()
raise SystemExit('lid signal monitor exited')

chmod 755 "$HOME/.local/bin/sunshine-display-modes" "$HOME/.local/bin/sunshine-virtual-display" "$HOME/.local/bin/sunshine-mirror-lid-watch"
python3 -m py_compile "$HOME/.local/bin/sunshine-display-modes" "$HOME/.local/bin/sunshine-virtual-display" "$HOME/.local/bin/sunshine-mirror-lid-watch"

[Unit]
Description=Persistent KWin virtual display for Sunshine
After=graphical-session.target
PartOf=graphical-session.target
Before=app-dev.lizardbyte.app.Sunshine.service

[Service]
Type=simple
Environment=QT_QPA_PLATFORM=wayland
Environment=WAYLAND_DISPLAY=wayland-0
Environment=XDG_RUNTIME_DIR=%t
Environment=DBUS_SESSION_BUS_ADDRESS=unix:path=%t/bus
ExecStart=/usr/bin/krfb-virtualmonitor --resolution 2560x1600 --name sunshine-virtual --password CHANGE_ME_RANDOM_VNC_PASSWORD --desktopfile org.kde.krfb.virtualmonitor --scale 1 --port 5915
ExecStartPost=-%h/.local/bin/sunshine-display-modes --defaults --wait 10
Restart=on-failure
RestartSec=3

[Install]
WantedBy=graphical-session.target

[Unit]
Description=Keep Sunshine virtual capture source across lid changes
After=graphical-session.target sunshine-virtual-monitor.service
PartOf=graphical-session.target

[Service]
Type=simple
Environment=QT_QPA_PLATFORM=wayland
Environment=WAYLAND_DISPLAY=wayland-0
Environment=XDG_RUNTIME_DIR=%t
Environment=DBUS_SESSION_BUS_ADDRESS=unix:path=%t/bus
ExecStart=%h/.local/bin/sunshine-mirror-lid-watch
Restart=on-failure
RestartSec=3

[Install]
WantedBy=graphical-session.target

systemctl --user daemon-reload
systemctl --user enable --now sunshine-virtual-monitor.service
kscreen-doctor -o
systemctl --user enable --now sunshine-mirror-lid.service

systemctl --user is-enabled sunshine-virtual-monitor.service sunshine-mirror-lid.service
systemctl --user is-active sunshine-virtual-monitor.service sunshine-mirror-lid.service

"$HOME/.local/bin/sunshine-virtual-display" mirror

[AC][SuspendAndShutdown]
LidAction=0

[Battery][SuspendAndShutdown]
LidAction=0

[LowBattery][SuspendAndShutdown]
LidAction=0

capture = kwin
encoder = nvenc
output_name = Virtual-sunshine-virtual

python3 - <<'PY_CONFIG'
import json
from pathlib import Path
script = str(Path.home() / '.local/bin/sunshine-virtual-display')
commands = [{'do': script + ' start', 'undo': script + ' stop'}]
print('global_prep_cmd = ' + json.dumps(commands, ensure_ascii=False))
PY_CONFIG

systemctl --user restart app-dev.lizardbyte.app.Sunshine.service

"$HOME/.local/bin/sunshine-display-modes" --defaults

"$HOME/.local/bin/sunshine-display-modes" --set 1920 1080 60
"$HOME/.local/bin/sunshine-display-modes" --set 2560 1600 165
"$HOME/.local/bin/sunshine-display-modes" --set 2384 1080 120
"$HOME/.local/bin/sunshine-display-modes" --set 2360 1640 90

kscreen-doctor -j | python3 -c 'import json,sys; d=json.load(sys.stdin); print([(o["name"],o["enabled"],o.get("replicationSource"),next((m for m in o["modes"] if m["id"]==o["currentModeId"]),None)) for o in d["outputs"]])'

journalctl --user -u app-dev.lizardbyte.app.Sunshine.service -b --no-pager | rg 'kwingrab|Screencasting output|resolution|frame pacing|CLIENT'

Screencasting output name Virtual-sunshine-virtual ... resolution 1600x900
Screencasting output name Virtual-sunshine-virtual ... resolution 1920x1080

journalctl --user -u sunshine-virtual-monitor.service -b -n 80 --no-pager
journalctl --user -u sunshine-mirror-lid.service -b -n 80 --no-pager
tail -n 50 "$HOME/.local/state/sunshine-virtual-display/hook.log"

systemctl --user disable --now sunshine-mirror-lid.service
systemctl --user disable --now sunshine-virtual-monitor.service

kscreen-doctor output.eDP-2.enable output.eDP-2.mirror.none output.eDP-2.primary