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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.3.3
+Version: 9.3.5
 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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.3.3"
+version = "9.3.5"
 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.5}/src/trcc/__version__.py

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

{trcc_linux-9.3.3 → trcc_linux-9.3.5}/src/trcc/adapters/infra/data_repository.py

@@ -26,6 +26,7 @@ from ...core.paths import (
     ASSETS_DIR,  # noqa: F401 — re-export (package resource dir)
     RESOURCES_DIR,  # noqa: F401 — re-export (package resource dir)
     USER_CONFIG_DIR,  # noqa: F401 — re-export (universal config dir)
+    has_themes,
 )
 from ...core.platform import SUBPROCESS_NO_WINDOW as _NO_WINDOW
 
@@ -367,7 +368,7 @@ class DataManager:
             pkg_dir=os.path.join(DataManager._data_dir(), name),
             user_dir=os.path.join(DataManager._data_dir(), name),
             archive_name=f'{name}.7z',
-            check_fn=ThemeDir.has_themes,
+            check_fn=has_themes,
             fetch_fn=lambda a: DataManager._fetch_archive(a),
         )
 
@@ -393,7 +394,7 @@ class DataManager:
             pkg_dir=os.path.join(DataManager._data_dir(), 'web', res_key),
             user_dir=os.path.join(DataManager._data_dir(), 'web', res_key),
             archive_name=f'{res_key}.7z',
-            check_fn=ThemeDir.has_themes,
+            check_fn=has_themes,
             fetch_fn=lambda a: DataManager._fetch_archive(a, 'web'),
         )
 
@@ -452,10 +453,10 @@ class DataManager:
         name = f"theme{width}{height}"
         pkg = os.path.join(DataManager._data_dir(), name)
         user = os.path.join(DataManager._data_dir(), name)
-        if ThemeDir.has_themes(pkg):
+        if has_themes(pkg):
             log.debug("Resolution %s: verified at %s", key, pkg)
             return True
-        if ThemeDir.has_themes(user):
+        if has_themes(user):
             log.debug("Resolution %s: verified at %s", key, user)
             return True
         log.warning(

{trcc_linux-9.3.3 → trcc_linux-9.3.5}/src/trcc/adapters/infra/diagnostics.py

@@ -44,6 +44,40 @@ log = logging.getLogger(__name__)
 _DEFAULT_LOG_FILE = Path.home() / '.trcc' / 'trcc.log'
 
 
+class DeviceLogger(logging.Logger):
+    """Logger subclass that tags every record with a device identifier.
+
+    Device-owned services create child loggers with a device label
+    (e.g. ``logging.getLogger('trcc.services.display.lcd:0')``).
+    Setting ``logger.dev = 'lcd:0'`` flows into every log record
+    via ``makeRecord``. Format string uses ``%(dev)s``.
+    """
+
+    def __init__(self, name: str, level: int = logging.NOTSET) -> None:
+        super().__init__(name, level)
+        self.dev = '-'
+
+    def makeRecord(self, *args: Any, **kwargs: Any) -> logging.LogRecord:
+        record = super().makeRecord(*args, **kwargs)
+        record.dev = self.dev  # type: ignore[attr-defined]
+        return record
+
+
+# Register before any getLogger() calls in this module or importers.
+logging.setLoggerClass(DeviceLogger)
+
+
+class _DeviceDefaultFilter(logging.Filter):
+    """Ensure ``%(dev)s`` is always present — covers loggers created
+    before ``setLoggerClass`` (stdlib, third-party).
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if not hasattr(record, 'dev'):
+            record.dev = '-'  # type: ignore[attr-defined]
+        return True
+
+
 class TrccLoggingConfigurator(ABC):
     """Port: TRCC application logging configuration.
 
@@ -69,7 +103,7 @@ class StandardLoggingConfigurator(TrccLoggingConfigurator):
     updates log output.
     """
 
-    FORMAT = '%(asctime)s [%(levelname)s] %(name)s.%(funcName)s: %(message)s'
+    FORMAT = '%(asctime)s [%(levelname)s] [%(dev)s] %(name)s.%(funcName)s: %(message)s'
     DATE_FMT = '%Y-%m-%d %H:%M:%S'
     DATE_FMT_CONSOLE = '%H:%M:%S'
 
@@ -87,11 +121,12 @@ class StandardLoggingConfigurator(TrccLoggingConfigurator):
         root.setLevel(logging.DEBUG)
 
         self._log_file.parent.mkdir(parents=True, exist_ok=True)
-        fh = logging.handlers.RotatingFileHandler(
-            self._log_file, maxBytes=1_000_000, backupCount=3,
-        )
+        dev_filter = _DeviceDefaultFilter()
+
+        fh = logging.FileHandler(self._log_file, mode='w')
         fh.setLevel(logging.DEBUG)
         fh.setFormatter(logging.Formatter(self.FORMAT, datefmt=self.DATE_FMT))
+        fh.addFilter(dev_filter)
         root.addHandler(fh)
 
         console_level = (
@@ -102,6 +137,7 @@ class StandardLoggingConfigurator(TrccLoggingConfigurator):
         ch = logging.StreamHandler()
         ch.setLevel(console_level)
         ch.setFormatter(logging.Formatter(self.FORMAT, datefmt=self.DATE_FMT_CONSOLE))
+        ch.addFilter(dev_filter)
         root.addHandler(ch)
 
 
@@ -228,44 +264,58 @@ def _detect_pkg_manager() -> str | None:
     return None
 
 
+def _re_pkg_name(pattern: str, text: str) -> str | None:
+    """Extract package name from first regex group, or None."""
+    m = re.search(pattern, text)
+    return m.group(1) if m else None
+
+
+def _parse_dnf(output: str) -> str | None:
+    return _re_pkg_name(r'([\w][\w.+-]*)-\d', output.split('\n')[0])
+
+
+def _parse_pacman(output: str) -> str | None:
+    return output.split('\n')[0].split('/')[-1].strip() or None
+
+
+def _parse_zypper(output: str) -> str | None:
+    for line in output.strip().split('\n'):
+        parts = [p.strip() for p in line.split('|')]
+        if len(parts) >= 2 and parts[1] and parts[1] != 'Name':
+            return parts[1]
+    return None
+
+
+def _parse_xbps(output: str) -> str | None:
+    return _re_pkg_name(r'[\]\s]+([\w][\w.+-]*)-\d', output.split('\n')[0])
+
+
 def _provides_search(dep: str, pm: str) -> str | None:
     """Use PM's native 'provides' to find which package owns a file."""
-    if pm == 'dnf':
-        cmd = ['dnf', 'provides', '--quiet', f'*/{dep}*']
-    elif pm == 'pacman':
-        cmd = ['pacman', '-Fq', dep]
-    elif pm == 'zypper':
-        cmd = ['zypper', '--non-interactive', 'search', '--provides', dep]
-    elif pm == 'apk':
-        cmd = ['apk', 'search', dep]
-    elif pm == 'xbps':
-        cmd = ['xbps-query', '-Rs', dep]
-    else:
-        return None
+    match pm:
+        case 'dnf':
+            cmd = ['dnf', 'provides', '--quiet', f'*/{dep}*']
+            parse = _parse_dnf
+        case 'pacman':
+            cmd = ['pacman', '-Fq', dep]
+            parse = _parse_pacman
+        case 'zypper':
+            cmd = ['zypper', '--non-interactive', 'search', '--provides', dep]
+            parse = _parse_zypper
+        case 'apk':
+            cmd = ['apk', 'search', dep]
+            parse = _parse_dnf  # Same format as dnf
+        case 'xbps':
+            cmd = ['xbps-query', '-Rs', dep]
+            parse = _parse_xbps
+        case _:
+            return None
 
     try:
         r = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
         if r.returncode != 0 or not r.stdout.strip():
             return None
-        first = r.stdout.strip().split('\n')[0]
-        if pm == 'dnf':
-            m = re.match(r'([\w][\w.+-]*)-\d', first)
-            return m.group(1) if m else None
-        if pm == 'pacman':
-            return first.split('/')[-1].strip() or None
-        if pm == 'zypper':
-            for line in r.stdout.strip().split('\n'):
-                parts = [p.strip() for p in line.split('|')]
-                if len(parts) >= 2 and parts[1] and parts[1] != 'Name':
-                    return parts[1]
-            return None
-        if pm == 'apk':
-            m = re.match(r'([\w][\w.+-]*)-\d', first)
-            return m.group(1) if m else None
-        if pm == 'xbps':
-            m = re.search(r'[\]\\s]+([\w][\w.+-]*)-\d', first)
-            return m.group(1) if m else None
-        return None
+        return parse(r.stdout.strip())
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
         return None
 
@@ -1023,7 +1073,7 @@ def _debug_hid_led_interactive(dev: Any) -> None:
         print(f"  Segments   = {style.segment_count}")
         print(f"  Zones      = {style.zone_count}")
 
-    if info.pm in PmRegistry.PM_TO_STYLE:
+    if info.pm in PmRegistry:
         print(f"\n  Status: KNOWN device (PM {info.pm} in tables)")
     else:
         print(f"\n  Status: UNKNOWN PM byte ({info.pm})")
@@ -1199,7 +1249,7 @@ def led_debug_interactive(test_colors: bool = False) -> int:
         print(f"  Segments:   {style.segment_count}")
         print(f"  Zones:      {style.zone_count}")
 
-        if info.pm in PmRegistry.PM_TO_STYLE:
+        if info.pm in PmRegistry:
             print(f"\n  Status: KNOWN device (PM {info.pm} in tables)")
         else:
             print(f"\n  Status: UNKNOWN PM byte ({info.pm})")
@@ -1608,7 +1658,7 @@ class DebugReport:
                 return
 
             assert isinstance(info, LedHandshakeInfo)
-            known = "KNOWN" if info.pm in PmRegistry.PM_TO_STYLE else "UNKNOWN"
+            known = "KNOWN" if info.pm in PmRegistry else "UNKNOWN"
             style_info = ""
             if info.style:
                 style_info = (f", LEDs={info.style.led_count}, "

{trcc_linux-9.3.3 → trcc_linux-9.3.5}/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.5}/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
@@ -332,28 +514,31 @@ def mount_static_dirs(width: int, height: int) -> None:
 
     Called after device select when resolution is known. Remounts if resolution
     changes (e.g., user switches device).
+    Reads dirs from active device's Orientation (DI'd per device).
     """
-    from trcc.adapters.infra.data_repository import DataManager, ThemeDir
+    from trcc.adapters.infra.data_repository import DataManager
+    from trcc.core.paths import resolve_theme_dir
 
     # Remove previous mounts
     for path in _mounted_routes:
         app.routes[:] = [r for r in app.routes if getattr(r, 'path', '') != path]
     _mounted_routes.clear()
 
-    # Theme directory (local themes)
-    theme_dir = str(ThemeDir.for_resolution(width, height).path)
+    # Read from device's orientation when available, fallback to resolve
+    o = getattr(_display_dispatcher, 'orientation', None) if _display_dispatcher else None
+    if o is not None and not hasattr(o, 'theme_dir'):
+        o = None  # proxy/mock without real Orientation
+    td = o.theme_dir if o else None
+    theme_dir = str(td.path) if td else resolve_theme_dir(width, height)
+    web_dir = str(o.web_dir) if o and o.web_dir else DataManager.get_web_dir(width, height)
+    masks_dir = str(o.masks_dir) if o and o.masks_dir else DataManager.get_web_masks_dir(width, height)
+
     if os.path.isdir(theme_dir):
         app.mount("/static/themes", StaticFiles(directory=theme_dir), name="themes")
         _mounted_routes.append("/static/themes")
-
-    # Cloud theme previews
-    web_dir = DataManager.get_web_dir(width, height)
     if os.path.isdir(web_dir):
         app.mount("/static/web", StaticFiles(directory=web_dir), name="web")
         _mounted_routes.append("/static/web")
-
-    # Cloud masks
-    masks_dir = DataManager.get_web_masks_dir(width, height)
     if os.path.isdir(masks_dir):
         app.mount("/static/masks", StaticFiles(directory=masks_dir), name="masks")
         _mounted_routes.append("/static/masks")

{trcc_linux-9.3.3 → trcc_linux-9.3.5}/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)}