trcc-linux 5.1.2__tar.gz → 5.2.0__tar.gz

{trcc_linux-5.1.2 → trcc_linux-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 5.1.2
+Version: 5.2.0
 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-5.1.2 → trcc_linux-5.2.0}/pyproject.toml

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

{trcc_linux-5.1.2 → trcc_linux-5.2.0}/src/trcc/__version__.py

@@ -1,6 +1,6 @@
 """TRCC Linux version information."""
 
-__version__ = "5.1.2"
+__version__ = "5.2.0"
 __version_info__ = tuple(int(x) for x in __version__.split("."))
 
 # Version history:
@@ -271,3 +271,9 @@ __version_info__ = tuple(int(x) for x in __version__.split("."))
 #          buffers per chunk size. Cache shutil.which('sg_raw'). Cache
 #          psutil.cpu_freq (10s TTL). Slow sensor poll 2s→4s. CPU usage
 #          drops ~21%→15% (animated theme), ~7% (static). 2286 tests.
+# 5.2.0  - HID Type 2 JPEG encoding for large-resolution devices: 1280x480
+#          (Trofeo Vision), 1600x720, 1920x462, 854x480, 960x540, 800x480,
+#          360x360 (FanLCD). C# uses ImageToJpg() (mode 2) instead of
+#          ImageTo565() (mode 3) for these FBLs — header byte[6]=0x00 with
+#          actual width/height instead of hardcoded 240x320. Auto-detects
+#          JPEG by FF D8 magic bytes. Addresses #34/#35. 2286 tests.

{trcc_linux-5.1.2 → trcc_linux-5.2.0}/src/trcc/adapters/device/hid.py

@@ -349,36 +349,46 @@ class HidDeviceType2(HidDevice):
     # -- Frame send -------------------------------------------------------
 
     @staticmethod
-    def build_frame_packet(image_data: bytes) -> bytes:
+    def build_frame_packet(
+        image_data: bytes,
+        width: int = 240,
+        height: int = 320,
+    ) -> bytes:
         """Build a frame packet from raw image data.
 
-        C# FormCZTV.ImageTo565() mode 3 builds a 20-byte header::
+        C# FormCZTV has two encoding modes for HID Type 2:
+
+        **Mode 3** (RGB565, ``ImageTo565()``): hardcoded 240x320 header::
 
             DA DB DC DD 02 00 01 00 F0 00 40 01 02 00 00 00 [len_LE32]
 
-        - [0:4]   DA DB DC DD — protocol magic (same as handshake)
-        - [4]     02 — SSCRM_CMD_TYPE_PICTURE
-        - [6]     01 — mode flag
-        - [8:10]  F0 00 — 240 (LE16, hardcoded in C#)
-        - [10:12] 40 01 — 320 (LE16, hardcoded in C#)
-        - [12]    02 — sub-flag
-        - [16:20] image data length (LE uint32)
+        **Mode 2** (JPEG, ``ImageToJpg()``): actual resolution in header::
 
-        The total transfer length is rounded up to the next 512-byte
-        boundary (C#: ``num2 / 512 * 512 + (num2 % 512 != 0 ? 512 : 0)``).
+            DA DB DC DD 02 00 00 00 WW WW HH HH 02 00 00 00 [len_LE32]
 
-        Returns the padded packet ready for USB bulk write.
+        Differences: byte[6] = 0x01 (RGB565) vs 0x00 (JPEG),
+        bytes[8:12] = hardcoded 240x320 vs actual width/height.
+
+        JPEG is auto-detected by FF D8 magic bytes.
+        The total transfer length is 512-byte aligned.
         """
-        # Match C# FormCZTV.ImageTo565() mode 3 header exactly
+        is_jpeg = len(image_data) >= 2 and image_data[0] == 0xFF and image_data[1] == 0xD8
+
         header = bytearray([
             0xDA, 0xDB, 0xDC, 0xDD,  # magic
             0x02, 0x00,               # cmd_type = PICTURE
-            0x01, 0x00,               # mode flag
-            0xF0, 0x00,               # 240 (LE16, hardcoded)
-            0x40, 0x01,               # 320 (LE16, hardcoded)
-            0x02, 0x00, 0x00, 0x00,   # sub-flag
         ])
+        if is_jpeg:
+            # Mode 2: JPEG — byte[6]=0x00, actual resolution
+            header.extend(b'\x00\x00')
+            header.extend(struct.pack('<HH', width, height))
+        else:
+            # Mode 3: RGB565 — byte[6]=0x01, hardcoded 240x320
+            header.extend(b'\x01\x00')
+            header.extend(struct.pack('<HH', 240, 320))
+        header.extend([0x02, 0x00, 0x00, 0x00])  # sub-flag
         header.extend(struct.pack('<I', len(image_data)))
+
         raw = bytes(header) + image_data
         padded_len = _ceil_to_512(len(raw))
         return raw.ljust(padded_len, b'\x00')
@@ -390,9 +400,11 @@ class HidDeviceType2(HidDevice):
         buffer in a single Transfer() call.  pyusb splits into USB packets
         internally — the device sees one logical transfer.
 
+        For JPEG-mode devices (FBL in JPEG_MODE_FBLS), the header includes
+        actual width/height. For RGB565 devices, header uses hardcoded 240x320.
+
         Args:
-            image_data: Raw image bytes (JPEG or other format the
-                        device expects).
+            image_data: Raw image bytes (RGB565 or JPEG depending on device).
 
         Returns:
             True if the transfer succeeded.
@@ -403,7 +415,9 @@ class HidDeviceType2(HidDevice):
         if not self._initialized:
             raise RuntimeError("Type 2 device not initialized — call handshake() first")
 
-        packet = self.build_frame_packet(image_data)
+        di = self.device_info
+        w, h = di.resolution if di is not None and di.resolution is not None else (240, 320)
+        packet = self.build_frame_packet(image_data, w, h)
 
         # C# USBLCDNEW ThreadSendDeviceDataH: single Transfer() call
         total = self.transport.write(EP_WRITE_02, packet, DEFAULT_TIMEOUT_MS)

{trcc_linux-5.1.2 → trcc_linux-5.2.0}/src/trcc/core/models.py

@@ -1150,6 +1150,11 @@ FBL_TO_RESOLUTION: dict[int, tuple[int, int]] = {
     224: (854, 480),
 }
 
+# FBL values that trigger JPEG encoding for HID Type 2 (C# myDeviceMode == 2).
+# C# FormCZTV: these resolutions use ImageToJpg() instead of ImageTo565().
+# Header byte[6] = 0x00 (JPEG) vs 0x01 (RGB565), with actual width/height.
+JPEG_MODE_FBLS: frozenset[int] = frozenset({54, 114, 128, 192, 224})
+
 # Reverse lookup: resolution → PM/FBL (first match wins)
 RESOLUTION_TO_PM: dict[tuple[int, int], int] = {
     res: fbl for fbl, res in FBL_TO_RESOLUTION.items()

{trcc_linux-5.1.2 → trcc_linux-5.2.0}/src/trcc/services/device.py

@@ -9,7 +9,7 @@ import logging
 import threading
 from typing import Any, Optional
 
-from ..core.models import DeviceInfo, LCDDeviceConfig
+from ..core.models import JPEG_MODE_FBLS, DeviceInfo, LCDDeviceConfig
 
 log = logging.getLogger(__name__)
 
@@ -162,16 +162,17 @@ class DeviceService:
     def send_pil(self, image: Any, width: int, height: int) -> bool:
         """Encode PIL Image for device and send.
 
-        Bulk devices use JPEG (C# ImageToJpg — no rotation),
-        SCSI/HID use RGB565 (C# ImageTo565 — non-square pre-rotation).
+        Bulk and HID JPEG-mode devices use JPEG (C# ImageToJpg — no rotation).
+        SCSI/HID (standard) use RGB565 (C# ImageTo565 — non-square pre-rotation).
         """
         from .image import ImageService
 
         device = self._selected
         protocol = device.protocol if device else 'scsi'
         resolution = device.resolution if device else (320, 320)
+        fbl = device.fbl_code if device else None
 
-        if protocol == 'bulk':
+        if protocol == 'bulk' or (protocol == 'hid' and fbl in JPEG_MODE_FBLS):
             jpeg = ImageService.to_jpeg(image)
             return self.send_rgb565(jpeg, width, height)
 

{trcc_linux-5.1.2 → trcc_linux-5.2.0}/src/trcc/services/display.py

@@ -15,7 +15,7 @@ from typing import Any, Tuple
 
 from ..adapters.infra.data_repository import RESOURCES_DIR, DataManager, ThemeDir
 from ..conf import settings
-from ..core.models import SPLIT_MODE_RESOLUTIONS, SPLIT_OVERLAY_MAP
+from ..core.models import JPEG_MODE_FBLS, SPLIT_MODE_RESOLUTIONS, SPLIT_OVERLAY_MAP
 from .device import DeviceService
 from .image import ImageService
 from .media import MediaService
@@ -517,20 +517,24 @@ class DisplayService:
     def _encode_for_device(self, img: Any) -> bytes:
         """Encode image for LCD device.
 
-        C# protocol: bulk devices (USBLCDNew) use JPEG (ImageToJpg),
-        SCSI/HID use raw RGB565 (ImageTo565).
+        C# protocol encoding depends on device type:
+        - Bulk: JPEG (ImageToJpg), no rotation
+        - HID Type 2 with JPEG_MODE_FBLS: JPEG (ImageToJpg), no rotation
+        - SCSI / HID (standard): RGB565 (ImageTo565), non-square pre-rotation
 
         C# ImageTo565 rotates non-square displays +90° CW before encoding.
-        ImageToJpg does NOT rotate — bulk devices skip pre-rotation.
+        ImageToJpg does NOT rotate.
         """
         device = self.devices.selected
         protocol = device.protocol if device else 'scsi'
         resolution = device.resolution if device else (320, 320)
+        fbl = device.fbl_code if device else None
 
-        if protocol == 'bulk':
+        # Bulk and HID JPEG-mode devices use JPEG encoding (no rotation)
+        if protocol == 'bulk' or (protocol == 'hid' and fbl in JPEG_MODE_FBLS):
             data = ImageService.to_jpeg(img)
-            log.debug("_encode_for_device: %dx%d → JPEG %d bytes",
-                      img.width, img.height, len(data))
+            log.debug("_encode_for_device: %dx%d → JPEG %d bytes (protocol=%s, fbl=%s)",
+                      img.width, img.height, len(data), protocol, fbl)
             return data
 
         # C# ImageTo565: non-square displays rotate +90° CW before encoding.