#4064 move shadow server configuration to its own gui

Author: totaam

fs/share/xpra/icons/shadow.png

@@ -3,17 +3,16 @@
 # Xpra is released under the terms of the GNU GPL v2, or, at your option, any
 # later version. See the file COPYING for details.
 
-import os
 from time import sleep
 from textwrap import wrap
 
-from xpra.os_util import gi_import, POSIX, OSX, WIN32
+from xpra.os_util import gi_import, OSX, WIN32
 from xpra.util.env import envint
 from xpra.util.str_fn import csv
 from xpra.util.thread import start_thread
-from xpra.gtk.configure.common import DISCLAIMER, run_gui, get_config_env, update_config_env
+from xpra.gtk.configure.common import DISCLAIMER, run_gui
 from xpra.gtk.dialogs.base_gui_window import BaseGUIWindow
-from xpra.gtk.widget import label, setfont
+from xpra.gtk.widget import label
 from xpra.platform.paths import get_image
 from xpra.log import Logger
 
@@ -192,99 +191,7 @@ def configure_decoding(self, *_args) -> None:
         pass
 
     def configure_shadow(self, *_args) -> None:
-        self.clear_vbox()
-        self.set_box_margin()
-        self.layout = None
-        messages = (
-            "Configuring shadow mode",
-        )
-
-        def has(*els):
-            return all(el in self.elements for el in els)
-
-        backends = []
-        if POSIX and not OSX:
-            from xpra.platform.posix.shadow_server import SHADOW_OPTIONS
-            backends = SHADOW_OPTIONS
-            options = (
-                (
-                    True, "auto", "Automatic runtime detection",
-                    "this is the default behaviour,",
-                    "this option should always find a suitable capture strategy",
-                    "and it may not choose to use a video stream",
-                ),
-                (
-                    has("ximagesrc"), "X11", "X11 image capture",
-                    "GStreamer will capture the session's contents using 'ximagesrc'",
-                    "the pixel data will be compressed using a stream encoder",
-                    "eg: h264, hevc, av1, etc",
-                    "this option is only available for shadowing existing X11 sessions",
-                ),
-                (
-                    has("pipewiresrc"), "pipewire", "pipewire capture",
-                    "GStreamer pipewire source from the RemoteDesktop interface",
-                    "the pixel data will be compressed using a stream encoder",
-                    "eg: h264, hevc, av1, etc",
-                    "your desktop sessions must support the 'RemoteDesktop' dbus interface",
-                ),
-            )
-        else:
-            raise RuntimeError(f"unsupported platform {os.name}")
-        for i, message in enumerate(messages):
-            lbl = label(message, font="Sans 22")
-            self.vbox.add(lbl)
-        current_setting = get_config_env("XPRA_SHADOW_BACKEND")
-        self.buttons = []
-        for available, backend, description, *details in options:
-            btn = Gtk.CheckButton(label=description)
-            btn.set_sensitive(available)
-            btn.set_active(backend == current_setting)
-            btn._backend = backend
-            setfont(btn, font="sans 14")
-            self.vbox.add(btn)
-            for detail in details:
-                lbl = label(detail)
-                lbl.set_halign(Gtk.Align.START)
-                lbl.set_margin_start(32)
-                self.vbox.add(lbl)
-            self.buttons.append(btn)
-        btn_box = Gtk.HBox(homogeneous=True, spacing=40)
-        btn_box.set_vexpand(True)
-        btn_box.set_valign(Gtk.Align.END)
-        self.vbox.add(btn_box)
-        cancel_btn = Gtk.Button.new_with_label("Cancel")
-        cancel_btn.connect("clicked", self.dismiss)
-        btn_box.add(cancel_btn)
-        confirm_btn = Gtk.Button.new_with_label("Confirm")
-
-        def save_shadow(*_args):
-            active = [button for button in self.buttons if button.get_active()]
-            assert len(active) == 1
-            setting = active[0]._backend.lower()
-            if setting not in backends:
-                raise RuntimeError(f"invalid backend selected: {setting}")
-            log.info(f"saving XPRA_SHADOW_BACKEND={setting}")
-            update_config_env("XPRA_SHADOW_BACKEND", setting)
-            self.dismiss()
-
-        confirm_btn.connect("clicked", save_shadow)
-        confirm_btn.set_sensitive(False)
-        btn_box.add(confirm_btn)
-
-        # only enable the confirm button once an option has been chosen:
-        def option_toggled(toggled_btn, *_args):
-            if toggled_btn.get_active():
-                for button in self.buttons:
-                    if button != toggled_btn:
-                        button.set_active(False)
-            else:
-                if not any(button.get_active() for button in self.buttons):
-                    self.buttons[0].set_active(True)
-            confirm_btn.set_sensitive(any(button.get_active() for button in self.buttons))
-
-        for btn in self.buttons:
-            btn.connect("toggled", option_toggled)
-        self.vbox.show_all()
+        pass
 
 
 def main(_args) -> int:

xpra/gtk/configure/gstreamer.py

@@ -31,6 +31,7 @@ def populate(self):
         self.sub("Features", "features.png", "Enable or disable feature groups", "features")
         self.sub("Picture compression", "encoding.png", "Encodings, speed and quality", "encodings")
         self.sub("GStreamer", "gstreamer.png", "Configure the GStreamer codecs", "gstreamer")
+        self.sub("Shadow Server", "shadow.png", "Configure the Shadow Server", "shadow")
         self.sub("OpenGL acceleration", "opengl.png", "Test and validate OpenGL renderer", "opengl")
 
     def sub(self, title="", icon_name="browse.png", tooltip="", configure: str = "") -> None:

xpra/gtk/configure/home.py

@@ -22,6 +22,21 @@
 log = Logger("shadow", "osx")
 
 USE_TIMER = envbool("XPRA_OSX_SHADOW_USE_TIMER", False)
+GSTREAMER = envbool("XPRA_SHADOW_GSTREAMER", True)
+
+
+def check_gstreamer() -> bool:
+    if not GSTREAMER:
+        return False
+    from xpra.gstreamer.common import has_plugins, import_gst
+    import_gst()
+    return has_plugins("avfvideosrc")
+
+
+SHADOW_OPTIONS = {
+    "auto": lambda: True,
+    "gstreamer": check_gstreamer,
+}
 
 ALPHA: dict[int, str] = {
     CG.kCGImageAlphaNone: "AlphaNone",

xpra/platform/darwin/shadow_server.py

@@ -60,7 +60,7 @@ def __init__(self, multi_window=True):
         self.capture: Capture | None = None
         self.portal_interface = get_portal_interface()
         self.input_devices = 0
-        log(f"setup_capture() self.portal_interface={self.portal_interface}")
+        log(f"PortalShadow({multi_window}) portal_interface={self.portal_interface}")
 
     def get_server_mode(self) -> str:
         return "portal shadow"

xpra/platform/posix/fd_portal_shadow.py

@@ -6,8 +6,13 @@
 import os
 
 from xpra.log import Logger
+from xpra.util.env import envbool
 
-SHADOW_OPTIONS = ("auto", "x11", "pipewire", "screencast", "remotedesktop", "wayland")
+
+XSHM: bool = envbool("XPRA_SHADOW_XSHM", True)
+NVFBC: bool = envbool("XPRA_SHADOW_NVFBC", True)
+GSTREAMER: bool = envbool("XPRA_SHADOW_GSTREAMER", True)
+PIPEWIRE: bool = envbool("XPRA_SHADOW_PIPEWIRE", True)
 
 
 def warn(*messages) -> None:
@@ -50,7 +55,7 @@ def load_wayland(display: str = "") -> type | None:
     return c
 
 
-def load_x11(display: str = "") -> type | None:
+def load_xshm(display: str = "") -> type | None:
     gdkb = os.environ.get("GDK_BACKEND")
     try:
         os.environ["GDK_BACKEND"] = "x11"
@@ -68,8 +73,8 @@ def load_auto(display: str = "") -> type | None:
     if display.startswith("wayland-") or os.path.isabs(display):
         c = load_wayland(display)
     elif display.startswith(":"):
-        c = load_x11(display)
-    return c or load_remotedesktop(display) or load_screencast(display) or load_x11(display)
+        c = load_xshm(display)
+    return c or load_remotedesktop(display) or load_screencast(display) or load_xshm(display)
 
 
 def ShadowServer(display: str = "", multi_window: bool = True):
@@ -83,3 +88,43 @@ def ShadowServer(display: str = "", multi_window: bool = True):
     log = Logger("server", "shadow")
     log(f"ShadowServer({display}, {multi_window}) {env_setting}={shadow_server}")
     return shadow_server(multi_window)
+
+
+def check_nvfbc() -> bool:
+    return NVFBC
+
+
+def check_gstreamer() -> bool:
+    if not GSTREAMER:
+        return False
+    from xpra.gstreamer.common import has_plugins, import_gst
+    import_gst()
+    return has_plugins("ximagesrc")
+
+
+def check_pipewire() -> bool:
+    if not PIPEWIRE:
+        return False
+    from xpra.gstreamer.common import has_plugins, import_gst
+    import_gst()
+    return has_plugins("pipewiresrc")
+
+
+def check_xshm() -> bool:
+    from xpra.x11.bindings.ximage import XImageBindings  # pylint: disable=import-outside-toplevel
+    assert XImageBindings
+    return True
+
+
+def nocheck() -> bool:
+    return True
+
+
+SHADOW_OPTIONS = {
+    "auto": nocheck,
+    "nvfbc": check_nvfbc,
+    "gstreamer": check_gstreamer,
+    "pipewire": check_pipewire,
+    "xshm": check_xshm,
+    "gtk": nocheck,
+}

xpra/platform/posix/shadow_server.py

@@ -1,13 +1,19 @@
 # This file is part of Xpra.
-# Copyright (C) 2011-2020 Antoine Martin <antoine@xpra.org>
+# Copyright (C) 2011-2024 Antoine Martin <antoine@xpra.org>
 # Xpra is released under the terms of the GNU GPL v2, or, at your option, any
 # later version. See the file COPYING for details.
 
+from collections.abc import Callable
+
 from xpra.platform import platform_import
 
+SHADOW_OPTIONS: dict[str, Callable[[], bool]] = {}
+
 
 def ShadowServer(*_args):  # pragma: no cover
     raise NotImplementedError()
 
 
-platform_import(globals(), "shadow_server", True, "ShadowServer")
+platform_import(globals(), "shadow_server", True,
+                "ShadowServer",
+                "SHADOW_OPTIONS")

xpra/platform/shadow_server.py

@@ -46,6 +46,48 @@
 keylog = Logger("keyboard")
 screenlog = Logger("screen")
 
+
+SEAMLESS = envbool("XPRA_WIN32_SEAMLESS", False)
+NVFBC = envbool("XPRA_SHADOW_NVFBC", True)
+GDI = envbool("XPRA_SHADOW_GDI", True)
+GSTREAMER = envbool("XPRA_SHADOW_GSTREAMER", True)
+
+
+def check_gstreamer() -> bool:
+    if not GSTREAMER:
+        return False
+    from xpra.gstreamer.common import has_plugins, import_gst
+    import_gst()
+    return has_plugins("d3d11screencapturesrc") or has_plugins("dx9screencapsrc") or has_plugins("gdiscreencapsrc")
+
+
+def check_nvfbc() -> bool:
+    if not NVFBC:
+        return False
+    from xpra.codecs.nvidia.nvfbc.capture import get_capture_instance
+    assert get_capture_instance
+    return NVFBC
+
+
+def check_gdi() -> bool:
+    return GDI
+
+
+def check_gtk() -> bool:
+    from xpra.gtk import signals
+    assert signals
+    return True
+
+
+SHADOW_OPTIONS = {
+    "auto": lambda: True,
+    "nvfbc": check_nvfbc,
+    "gstreamer": check_gstreamer,
+    "gdi": check_gdi,
+    "gtk": check_gtk,
+}
+
+
 NOEVENT = object()
 BUTTON_EVENTS = {
     # (button,up-or-down)  : win-event-name
@@ -69,11 +111,6 @@
     (9, False): (win32con.MOUSEEVENTF_XUP, win32con.XBUTTON2),
 }
 
-SEAMLESS = envbool("XPRA_WIN32_SEAMLESS", False)
-NVFBC = envbool("XPRA_SHADOW_NVFBC", True)
-GDI = envbool("XPRA_SHADOW_GDI", True)
-GSTREAMER = envbool("XPRA_SHADOW_GSTREAMER", True)
-
 
 def get_root_window_size() -> tuple[int, int]:
     w = GetSystemMetrics(win32con.SM_CXVIRTUALSCREEN)