trcc-linux 9.3.3__tar.gz → 9.3.4__tar.gz

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.3.3
+Version: 9.3.4
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.3.3"
+version = "9.3.4"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.3.3"
+__version__ = "9.3.4"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/adapters/system/linux/setup.py

@@ -520,7 +520,9 @@ class LinuxSetup(PlatformSetup):
     def get_screencast_capture(
         self, x: int, y: int, w: int, h: int,
     ) -> tuple[str, str, list[str]] | None:
-        display = os.environ.get('DISPLAY', ':0.0')
+        display = os.environ.get('DISPLAY')
+        if not display:
+            return None  # No X11 display (pure Wayland or headless)
         inp = f'{display}+{x},{y}' if (w and h) else display
         region_args = ['-video_size', f'{w}x{h}'] if (w and h) else []
         return 'x11grab', inp, region_args

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/api/__init__.py

@@ -110,7 +110,8 @@ def start_video_playback(
     """
     global _media_service, _video_thread, _video_stop_event  # noqa: PLW0603
 
-    stop_video_playback()  # Stop any existing playback
+    stop_video_playback()
+    stop_screencast()
 
     from trcc.adapters.infra.media_player import ThemeZtDecoder, VideoDecoder
     media = MediaService(
@@ -128,14 +129,16 @@ def start_video_playback(
     _video_stop_event = threading.Event()
     stop_event = _video_stop_event  # Local ref for closure
 
+    lcd = _display_dispatcher  # capture for closure
+
     def _pump() -> None:
         interval = media.frame_interval_ms / 1000.0
         while not stop_event.is_set() and media.is_playing:
             frame, should_send, _ = media.tick()
             if frame is None:
                 break
-            if should_send:
-                _device_svc.send_frame(frame, width, height)
+            if should_send and lcd is not None:
+                lcd.send_frame(frame)
             stop_event.wait(interval)
 
     _video_thread = threading.Thread(target=_pump, daemon=True, name="api-video")
@@ -183,6 +186,7 @@ def start_overlay_loop(
     global _overlay_svc, _overlay_thread, _overlay_stop_event  # noqa: PLW0603
 
     stop_overlay_loop()
+    stop_screencast()
 
     from trcc.services.image import ImageService
     overlay = OverlayService(
@@ -197,6 +201,7 @@ def start_overlay_loop(
     _overlay_svc = overlay
     _overlay_stop_event = threading.Event()
     stop_event = _overlay_stop_event
+    lcd = _display_dispatcher  # capture for closure
 
     def _loop() -> None:
         while not stop_event.is_set():
@@ -207,8 +212,8 @@ def start_overlay_loop(
             if overlay.would_change(metrics):
                 overlay.update_metrics(metrics)
                 frame = overlay.render(metrics=metrics)
-                if frame is not None:
-                    _device_svc.send_frame(frame, width, height)
+                if frame is not None and lcd is not None:
+                    lcd.send_frame(frame)
             stop_event.wait(2.0)
 
     _overlay_thread = threading.Thread(target=_loop, daemon=True, name="api-overlay")
@@ -244,10 +249,12 @@ def start_keepalive_loop(image, width: int, height: int) -> bool:
 
     _keepalive_stop_event = threading.Event()
     stop_event = _keepalive_stop_event
+    lcd = _display_dispatcher  # capture for closure
 
     def _loop() -> None:
         while not stop_event.is_set():
-            _device_svc.send_frame(image, width, height)
+            if lcd is not None:
+                lcd.send_frame(image)
             stop_event.wait(0.150)
 
     _keepalive_thread = threading.Thread(target=_loop, daemon=True, name="api-keepalive")
@@ -268,6 +275,181 @@ def stop_keepalive_loop() -> None:
     _keepalive_stop_event = None
 
 
+# ── Screencast (background thread — X11 or PipeWire) ──────────────────
+
+_screencast_thread: threading.Thread | None = None
+_screencast_stop_event: threading.Event | None = None
+_screencast_proc: object | None = None  # subprocess.Popen (X11)
+_screencast_cast: object | None = None  # PipeWireScreenCast (Wayland)
+_screencast_frames: int = 0
+_screencast_params: dict | None = None
+
+
+def _is_wayland() -> bool:
+    return (os.environ.get('XDG_SESSION_TYPE', '').lower() == 'wayland'
+            or bool(os.environ.get('WAYLAND_DISPLAY')))
+
+
+def start_screencast(
+    x: int = 0, y: int = 0, w: int = 0, h: int = 0, fps: int = 10,
+) -> dict:
+    """Start background screen capture — pumps frames to LCD and preview.
+
+    Auto-detects backend: ffmpeg x11grab on X11, PipeWire on Wayland.
+    """
+    global _screencast_thread, _screencast_stop_event  # noqa: PLW0603
+    global _screencast_proc, _screencast_cast  # noqa: PLW0603
+    global _screencast_frames, _screencast_params  # noqa: PLW0603
+
+    stop_screencast()
+    stop_video_playback()
+    stop_overlay_loop()
+    stop_keepalive_loop()
+
+    if not _display_dispatcher or not _display_dispatcher.connected:
+        return {"success": False, "error": "No LCD device connected"}
+
+    lcd = _display_dispatcher  # capture for closures
+    lcd_w, lcd_h = lcd.resolution  # type: ignore[union-attr]
+    _screencast_stop_event = threading.Event()
+    stop_event = _screencast_stop_event
+    _screencast_frames = 0
+    _screencast_params = {"x": x, "y": y, "w": w, "h": h, "fps": fps}
+
+    # Try X11 (ffmpeg x11grab) — works on X11 and XWayland
+    display = os.environ.get('DISPLAY')
+    if display:
+        import shutil
+        if not shutil.which('ffmpeg'):
+            return {"success": False, "error": "ffmpeg not found"}
+
+        from trcc.core.app import TrccApp
+        capture = TrccApp.get().build_setup().get_screencast_capture(x, y, w, h)
+        if capture is None:
+            return {"success": False, "error": "Screencast not supported on this platform"}
+        fmt, inp, region_args = capture
+
+        import subprocess
+        cmd = [
+            'ffmpeg', '-hide_banner', '-loglevel', 'error',
+            '-f', fmt, '-framerate', str(fps),
+            *region_args,
+            '-i', inp,
+            '-vf', f'scale={lcd_w}:{lcd_h}',
+            '-f', 'rawvideo', '-pix_fmt', 'rgb24',
+            'pipe:1',
+        ]
+        try:
+            proc = subprocess.Popen(
+                cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+        except FileNotFoundError:
+            return {"success": False, "error": "ffmpeg not found"}
+
+        _screencast_proc = proc
+
+        def _x11_pump() -> None:
+            global _screencast_frames  # noqa: PLW0603
+            from PySide6.QtGui import QImage
+            frame_size = lcd_w * lcd_h * 3
+            assert proc.stdout is not None
+            while not stop_event.is_set():
+                raw = proc.stdout.read(frame_size)
+                if len(raw) < frame_size:
+                    break
+                qimg = QImage(
+                    raw, lcd_w, lcd_h, lcd_w * 3,
+                    QImage.Format.Format_RGB888).copy()
+                lcd.send_frame(qimg)
+                set_current_image(qimg)
+                _screencast_frames += 1
+
+        _screencast_thread = threading.Thread(
+            target=_x11_pump, daemon=True, name="api-screencast")
+        _screencast_thread.start()
+        _screencast_params["backend"] = "x11"
+        log.info("Screencast started (x11grab): %dx%d @ %dfps", lcd_w, lcd_h, fps)
+        return {"success": True, "backend": "x11"}
+
+    # Fallback: PipeWire (pure Wayland, no $DISPLAY)
+    if _is_wayland():
+        from trcc.gui.pipewire_capture import PIPEWIRE_AVAILABLE, PipeWireScreenCast
+        if not PIPEWIRE_AVAILABLE:
+            return {"success": False,
+                    "error": "Wayland detected but PipeWire deps missing (dbus, PyGObject, GStreamer)"}
+
+        cast = PipeWireScreenCast()
+        _screencast_cast = cast
+
+        def _pipewire_pump() -> None:
+            global _screencast_frames  # noqa: PLW0603
+            from PySide6.QtGui import QImage
+            if not cast.start(timeout=30):
+                log.error("PipeWire screencast failed to start")
+                return
+            interval = 1.0 / fps
+            while not stop_event.is_set():
+                frame = cast.grab_frame()
+                if frame is not None:
+                    fw, fh, rgb_bytes = frame
+                    qimg = QImage(
+                        rgb_bytes, fw, fh, fw * 3,
+                        QImage.Format.Format_RGB888).copy()
+                    if w and h:
+                        qimg = qimg.copy(x, y, min(w, fw - x), min(h, fh - y))
+                    qimg = qimg.scaled(lcd_w, lcd_h)
+                    lcd.send_frame(qimg)
+                    set_current_image(qimg)
+                    _screencast_frames += 1
+                stop_event.wait(interval)
+            cast.stop()
+
+        _screencast_thread = threading.Thread(
+            target=_pipewire_pump, daemon=True, name="api-screencast")
+        _screencast_thread.start()
+        _screencast_params["backend"] = "pipewire"
+        log.info("Screencast started (PipeWire): %dx%d @ %dfps", lcd_w, lcd_h, fps)
+        return {"success": True, "backend": "pipewire"}
+
+    return {"success": False,
+            "error": "No display server detected (no DISPLAY or WAYLAND_DISPLAY set)"}
+
+
+def stop_screencast() -> None:
+    """Stop background screencast if running."""
+    global _screencast_thread, _screencast_stop_event  # noqa: PLW0603
+    global _screencast_proc, _screencast_cast  # noqa: PLW0603
+    global _screencast_frames, _screencast_params  # noqa: PLW0603
+
+    if _screencast_stop_event:
+        _screencast_stop_event.set()
+
+    if _screencast_proc is not None:
+        import subprocess
+        proc = _screencast_proc
+        if isinstance(proc, subprocess.Popen):
+            proc.terminate()
+            try:
+                proc.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+
+    if _screencast_cast is not None:
+        try:
+            _screencast_cast.stop()  # type: ignore[union-attr]
+        except Exception:
+            pass
+
+    if _screencast_thread and _screencast_thread.is_alive():
+        _screencast_thread.join(timeout=2)
+
+    _screencast_thread = None
+    _screencast_stop_event = None
+    _screencast_proc = None
+    _screencast_cast = None
+    _screencast_frames = 0
+    _screencast_params = None
+
+
 # ── LED keepalive loop (background thread for animated modes) ─────────
 
 _led_thread: threading.Thread | None = None

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/api/devices.py

@@ -154,52 +154,45 @@ async def send_image(device_id: int, image: UploadFile, rotation: int = 0,
     """Send an image to the device LCD.
 
     Accepts image file upload. Validates size and format before processing.
+    Routes through LCDDevice for consistent encoding and send behavior.
     """
-    from trcc.api import _device_svc
+    import tempfile
+    from pathlib import Path
 
-    dev = _get_device_by_id(device_id)
-    _device_svc.select(dev)
+    from trcc.core.app import TrccApp
+
+    _get_device_by_id(device_id)  # validate device exists
+
+    app = TrccApp.get()
+    if not app.has_lcd:
+        raise HTTPException(status_code=409, detail="No LCD device connected")
+    lcd = app.lcd
 
     # Read and validate upload
     data = await image.read()
     if len(data) > MAX_UPLOAD_BYTES:
         raise HTTPException(status_code=413, detail="Image exceeds 10 MB limit")
 
-    from PySide6.QtGui import QImage
-    img = QImage.fromData(bytes(data))
-    if img.isNull():
-        raise HTTPException(status_code=400, detail="Invalid image format")
-
-    # Apply rotation and brightness
-    if rotation:
-        img = ImageService.apply_rotation(img, rotation)
-    if brightness != 100:
-        img = ImageService.apply_brightness(img, brightness)
-
-    # Discover resolution via handshake if not yet known
-    w, h = dev.resolution
-    if (w, h) == (0, 0):
-        from trcc.adapters.device.factory import DeviceProtocolFactory
-        protocol = DeviceProtocolFactory.get_protocol(dev)
-        result = protocol.handshake()
-        if result:
-            res = getattr(result, 'resolution', None)
-            if isinstance(res, tuple) and len(res) == 2 and res != (0, 0):
-                dev.resolution = res
-                w, h = res
-            # Propagate FBL code for JPEG mode detection
-            fbl = getattr(result, 'fbl', None) or getattr(result, 'model_id', None)
-            if fbl:
-                dev.fbl_code = fbl
-        if (w, h) == (0, 0):
-            raise HTTPException(status_code=503, detail="Cannot discover device resolution")
-    img = ImageService.resize(img, w, h)
-
-    # Encode and send via service (handles JPEG vs RGB565, rotation, byte order)
-    # Frame capture is automatic via on_frame_sent callback
-    ok = _device_svc.send_frame(img, w, h)
-
-    if not ok:
-        raise HTTPException(status_code=500, detail="Send failed (device busy or error)")
+    # Save upload to temp file, load via LCDDevice
+    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f:
+        f.write(data)
+        tmp_path = Path(f.name)
+
+    try:
+        result = lcd.load_image(tmp_path)
+        if not result.get("success"):
+            raise HTTPException(status_code=400, detail=result.get("error", "Invalid image"))
+
+        if rotation:
+            lcd.set_rotation(rotation)
+        if brightness != 100:
+            lcd.set_brightness(brightness)
+
+        send_result = lcd.send(result["image"])
+        if not send_result.get("success"):
+            raise HTTPException(status_code=500, detail="Send failed (device busy or error)")
+    finally:
+        tmp_path.unlink(missing_ok=True)
 
+    w, h = lcd.lcd_size
     return {"sent": True, "resolution": (w, h)}

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/api/display.py

@@ -22,6 +22,8 @@ from trcc.api.models import (
     BrightnessRequest,
     HexColorRequest,
     RotationRequest,
+    ScreencastRequest,
+    ScreencastStatusResponse,
     SplitRequest,
     VideoStatusResponse,
     dispatch_result,
@@ -397,31 +399,70 @@ async def create_theme(
             raise HTTPException(status_code=400, detail=mask_result.get("error", "Mask load failed"))
         img = mask_result.get("image", img)
 
+    from trcc.core.app import TrccApp
+    lcd_device = TrccApp.get().lcd
+
+    # Load background into DisplayService state
+    lcd_device.load_image(bg_path)
+
     if overlay_config:
-        from trcc.adapters.infra.dc_config import DcConfig
-        from trcc.adapters.infra.dc_parser import load_config_json
-        from trcc.services.image import ImageService
-        from trcc.services.overlay import OverlayService
-        overlay_svc = OverlayService(
-            w, h, renderer=ImageService._r(),
-            load_config_json_fn=load_config_json,
-            dc_config_cls=DcConfig,
-        )
-        overlay_svc.set_background(img)
-        overlay_svc.set_config(overlay_config)
-        overlay_svc.enabled = True
-        api._overlay_svc = overlay_svc
-        from trcc.services.system import get_all_metrics
-        frame = overlay_svc.render(get_all_metrics())
-        lcd.send(frame)
+        lcd_device.set_config(overlay_config)
+        lcd_device.enable_overlay(True)
+        result = lcd_device.render_and_send()
+        frame = result.get("image", img)
         api.set_current_image(frame)
     else:
-        lcd.send(img)
+        lcd_device.send(img)
         api.set_current_image(img)
 
     return {"success": True, "animated": False, "resolution": f"{w}x{h}"}
 
 
+# ── Screencast endpoints ──────────────────────────────────────────────
+
+
+@router.post("/screencast/start")
+def screencast_start(body: ScreencastRequest) -> dict:
+    """Start streaming screen capture to LCD device.
+
+    Auto-detects backend: ffmpeg x11grab on X11, PipeWire on Wayland.
+    Mutually exclusive with video playback and overlay loops.
+    """
+    import trcc.api as api
+
+    _get_display()
+    result = api.start_screencast(body.x, body.y, body.w, body.h, body.fps)
+    if not result.get("success"):
+        raise HTTPException(status_code=400, detail=result.get("error", "Screencast failed"))
+    return result
+
+
+@router.post("/screencast/stop")
+def screencast_stop() -> dict:
+    """Stop screen capture streaming."""
+    from trcc.api import stop_screencast
+
+    stop_screencast()
+    return {"success": True, "message": "Screencast stopped"}
+
+
+@router.get("/screencast/status")
+def screencast_status() -> ScreencastStatusResponse:
+    """Check current screencast state."""
+    from trcc.api import _screencast_frames, _screencast_params, _screencast_stop_event
+
+    running = (_screencast_stop_event is not None
+               and not _screencast_stop_event.is_set())
+    params = _screencast_params or {}
+    return ScreencastStatusResponse(
+        running=running,
+        backend=params.get("backend", ""),
+        fps=params.get("fps", 0),
+        region={k: params[k] for k in ("x", "y", "w", "h") if k in params},
+        frames=_screencast_frames,
+    )
+
+
 # ── Preview helpers ───────────────────────────────────────────────────
 
 

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/api/models.py

@@ -139,3 +139,19 @@ class ThemeLoadRequest(BaseModel):
 
 class ThemeSaveRequest(BaseModel):
     name: str
+
+
+class ScreencastRequest(BaseModel):
+    x: int = 0
+    y: int = 0
+    w: int = 0
+    h: int = 0
+    fps: int = 10
+
+
+class ScreencastStatusResponse(BaseModel):
+    running: bool = False
+    backend: str = ""
+    fps: int = 0
+    region: dict = {}  # noqa: RUF012
+    frames: int = 0

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/cli/__init__.py

@@ -444,24 +444,27 @@ def _cmd_overlay(
 
 
 @app.command("theme-list", rich_help_panel="Themes")
-def _cmd_theme_list(
-    cloud: Annotated[bool, typer.Option(
-        "--cloud", "-c", help="List cloud themes instead of local",
-    )] = False,
-    category: Annotated[Optional[str], typer.Option(
-        "--category", help="Filter by category (a=Gallery, b=Tech, c=HUD, etc.)",
-    )] = None,
-) -> int:
-    """List available themes."""
-    return _theme.list_themes(cloud=cloud, category=category)
+def _cmd_theme_list() -> int:
+    """List local themes."""
+    return _theme.list_themes()
 
 
 @app.command("mask-list", rich_help_panel="Themes")
 def _cmd_mask_list() -> int:
-    """List available mask overlays."""
+    """List cloud masks."""
     return _theme.list_masks()
 
 
+@app.command("background-list", rich_help_panel="Themes")
+def _cmd_background_list(
+    category: Annotated[Optional[str], typer.Option(
+        "--category", help="Filter by category (a=Gallery, b=Tech, c=HUD, etc.)",
+    )] = None,
+) -> int:
+    """List cloud backgrounds."""
+    return _theme.list_backgrounds(category=category)
+
+
 @app.command("theme-load", rich_help_panel="Themes")
 def _cmd_theme_load(
     name: Annotated[str, typer.Argument(help="Theme name (from theme-list)")],
@@ -1274,6 +1277,7 @@ render_overlay = _display.render_overlay
 # Theme commands
 list_themes = _theme.list_themes
 list_masks = _theme.list_masks
+list_backgrounds = _theme.list_backgrounds
 load_theme = _theme.load_theme
 save_theme = _theme.save_theme
 export_theme = _theme.export_theme

{trcc_linux-9.3.3 → trcc_linux-9.3.4}/src/trcc/cli/_theme.py

@@ -9,12 +9,12 @@ log = logging.getLogger(__name__)
 
 
 @_cli_handler
-def list_themes(cloud=False, category=None):
-    """List available themes for the current device resolution."""
+def list_themes():
+    """List local themes for the current device resolution."""
     from trcc.conf import settings
     from trcc.services import ThemeService
 
-    log.debug("list_themes cloud=%s category=%s", cloud, category)
+    log.debug("list_themes")
     w, h = settings.width, settings.height
     if not w or not h:
         print("No device resolution saved. Connect your device first.")
@@ -22,28 +22,44 @@ def list_themes(cloud=False, category=None):
 
     settings._resolve_paths()
 
-    if cloud:
-        web_dir = settings.web_dir
-        if not web_dir or not web_dir.exists():
-            print(f"No cloud themes for {w}x{h}.")
-            return 0
-        themes = ThemeService.discover_cloud(web_dir, category)
-        print(f"Cloud themes ({w}x{h}): {len(themes)}")
-        for t in themes:
-            cat = f" [{t.category}]" if t.category else ""
-            print(f"  {t.name}{cat}")
-    else:
-        td = settings.theme_dir
-        if not td or not td.exists():
-            print(f"No local themes for {w}x{h}.")
-            return 0
-        themes = ThemeService.discover_local_merged(
-            td.path, settings.user_content_dir, (w, h))
-        print(f"Local themes ({w}x{h}): {len(themes)}")
-        for t in themes:
-            kind = "video" if t.is_animated else "static"
-            user = " [user]" if t.name.startswith(('Custom_', 'User')) else ""
-            print(f"  {t.name} ({kind}){user}")
+    td = settings.theme_dir
+    if not td or not td.exists():
+        print(f"No local themes for {w}x{h}.")
+        return 0
+    themes = ThemeService.discover_local_merged(
+        td.path, settings.user_content_dir, (w, h))
+    print(f"Local themes ({w}x{h}): {len(themes)}")
+    for t in themes:
+        kind = "video" if t.is_animated else "static"
+        user = " [user]" if t.name.startswith(('Custom_', 'User')) else ""
+        print(f"  {t.name} ({kind}){user}")
+
+    return 0
+
+
+@_cli_handler
+def list_backgrounds(category=None):
+    """List cloud backgrounds for the current device resolution."""
+    from trcc.conf import settings
+    from trcc.services import ThemeService
+
+    log.debug("list_backgrounds category=%s", category)
+    w, h = settings.width, settings.height
+    if not w or not h:
+        print("No device resolution saved. Connect your device first.")
+        return 1
+
+    settings._resolve_paths()
+
+    web_dir = settings.web_dir
+    if not web_dir or not web_dir.exists():
+        print(f"No cloud backgrounds for {w}x{h}.")
+        return 0
+    themes = ThemeService.discover_cloud(web_dir, category)
+    print(f"Cloud backgrounds ({w}x{h}): {len(themes)}")
+    for t in themes:
+        cat = f" [{t.category}]" if t.category else ""
+        print(f"  {t.name}{cat}")
 
     return 0