#!/usr/bin/env python3 """ Wayland screen capture: XDG portal + GStreamer → raw JPEG stream on stdout. Used when Node cannot receive D-Bus Unix FDs (no `usocket` native module). Requires: python-dbus, PyGObject, GStreamer (same as screencast). """ from __future__ import annotations import argparse import logging import shutil import signal import subprocess import sys import threading import dbus from dbus.mainloop.glib import DBusGMainLoop import gi gi.require_version("GLib", "2.0") from gi.repository import GLib log = logging.getLogger("nebucast-bridge") SCREEN_CAST_IFACE = "org.freedesktop.portal.ScreenCast" REQUEST_IFACE = "org.freedesktop.portal.Request" PORTAL_BUS = "org.freedesktop.portal.Desktop" PORTAL_PATH = "/org/freedesktop/portal/desktop" SOURCE_TYPE_MONITOR = 1 CURSOR_MODE_EMBEDDED = 2 class PortalSession: def __init__(self): DBusGMainLoop(set_as_default=True) self._bus = dbus.SessionBus() self._portal = self._bus.get_object(PORTAL_BUS, PORTAL_PATH) self._sc = dbus.Interface(self._portal, SCREEN_CAST_IFACE) self._loop = GLib.MainLoop() self._session = None self._node_id = None self._pw_fd = None self._n = 0 self._sender = self._bus.get_unique_name().replace(".", "_").lstrip(":") def _token(self): self._n += 1 return f"nb{self._n}" def _on_response(self, token, callback): path = f"/org/freedesktop/portal/desktop/request/{self._sender}/{token}" self._bus.add_signal_receiver( callback, signal_name="Response", dbus_interface=REQUEST_IFACE, path=path, ) def _fail(self, stage, code): log.error("%s failed with response %d", stage, code) self._loop.quit() def run(self) -> tuple[int, int]: t = self._token() self._on_response(t, self._created) self._sc.CreateSession( { "handle_token": t, "session_handle_token": "nebucast_py_bridge", } ) self._loop.run() if self._pw_fd is None or self._node_id is None: raise RuntimeError( "Portal session failed. Use GNOME on Wayland with xdg-desktop-portal-gnome." ) return self._pw_fd, self._node_id def _created(self, code, results): if code != 0: return self._fail("CreateSession", code) self._session = str(results["session_handle"]) log.info("Session: %s", self._session) t = self._token() self._on_response(t, self._sources_selected) self._sc.SelectSources( self._session, { "handle_token": t, "types": dbus.UInt32(SOURCE_TYPE_MONITOR), "cursor_mode": dbus.UInt32(CURSOR_MODE_EMBEDDED), }, ) def _sources_selected(self, code, results): if code != 0: return self._fail("SelectSources", code) log.info("Source selected, starting…") t = self._token() self._on_response(t, self._started) self._sc.Start(self._session, "", {"handle_token": t}) def _started(self, code, results): if code != 0: return self._fail("Start", code) streams = results.get("streams", []) if not streams: return self._fail("Start (no streams)", -1) self._node_id = int(streams[0][0]) fd_obj = self._sc.OpenPipeWireRemote(self._session, {}) self._pw_fd = fd_obj.take() log.info("PipeWire fd=%d node=%d", self._pw_fd, self._node_id) self._loop.quit() def build_pipeline(pw_fd: int, node_id: int, fps: int, quality: int) -> list[str]: src = ( f"pipewiresrc fd={pw_fd} path={node_id} do-timestamp=true keepalive-time=1000" ) rest = ( f"! videoconvert ! videoscale ! video/x-raw,width=1280,height=720 ! " f"videorate ! video/x-raw,framerate={fps}/1 ! " f"jpegenc quality={quality} ! fdsink fd=1 sync=false" ) return ["gst-launch-1.0", "-q", *src.split(), *rest.split()] def main() -> None: logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s", ) ap = argparse.ArgumentParser() ap.add_argument("--fps", type=int, default=30) ap.add_argument("--quality", type=int, default=80) args = ap.parse_args() session = PortalSession() pw_fd, node_id = session.run() argv = build_pipeline(pw_fd, node_id, args.fps, args.quality) log.info("Starting gstreamer (fd=%d node=%d)", pw_fd, node_id) proc = subprocess.Popen( argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE, pass_fds=(pw_fd,), ) def cleanup(*_args): if proc.poll() is None: proc.terminate() signal.signal(signal.SIGTERM, cleanup) signal.signal(signal.SIGINT, cleanup) def drain_stderr(): if proc.stderr: for line in iter(proc.stderr.readline, b""): sys.stderr.buffer.write(line) sys.stderr.buffer.flush() threading.Thread(target=drain_stderr, daemon=True).start() try: assert proc.stdout is not None shutil.copyfileobj(proc.stdout, sys.stdout.buffer) finally: cleanup() proc.wait() rc = proc.returncode if rc not in (0, -signal.SIGTERM, -signal.SIGINT): log.error("gst-launch exited %s", rc) sys.exit(1) if __name__ == "__main__": main()