feat: reduce build size — replace Pillow with cv2, refactor build scripts

- Create utils/image_codec.py with cv2-based image helpers
- Replace PIL usage across all routes, filters, and engines with cv2
- Move Pillow from core deps to [tray] optional in pyproject.toml
- Extract shared build logic into build-common.sh (detect_version, cleanup, etc.)
- Strip unused NumPy/PIL/zeroconf/debug files in build scripts

server/src/wled_controller/api/routes/picture_sources.py

@@ -1,13 +1,10 @@
 """Picture source routes."""
 
 import asyncio
-import base64
-import io
 import time
 
 import httpx
 import numpy as np
-from PIL import Image
 from fastapi import APIRouter, HTTPException, Depends, Query, WebSocket, WebSocketDisconnect
 from fastapi.responses import Response
 
@@ -115,16 +112,20 @@ async def validate_image(
             img_bytes = path
 
         def _process_image(src):
-            pil_image = Image.open(io.BytesIO(src) if isinstance(src, bytes) else src)
-            pil_image = pil_image.convert("RGB")
-            width, height = pil_image.size
-            thumb = pil_image.copy()
-            thumb.thumbnail((320, 320), Image.Resampling.LANCZOS)
-            buf = io.BytesIO()
-            thumb.save(buf, format="JPEG", quality=80)
-            buf.seek(0)
-            preview = f"data:image/jpeg;base64,{base64.b64encode(buf.getvalue()).decode()}"
-            return width, height, preview
+            from wled_controller.utils.image_codec import (
+                encode_jpeg_data_uri,
+                load_image_bytes,
+                load_image_file,
+                thumbnail as make_thumbnail,
+            )
+            if isinstance(src, bytes):
+                image = load_image_bytes(src)
+            else:
+                image = load_image_file(src)
+            h, w = image.shape[:2]
+            thumb = make_thumbnail(image, 320)
+            preview = encode_jpeg_data_uri(thumb, quality=80)
+            return w, h, preview
 
         width, height, preview = await asyncio.to_thread(_process_image, img_bytes)
 
@@ -161,11 +162,12 @@ async def get_full_image(
             img_bytes = path
 
         def _encode_full(src):
-            pil_image = Image.open(io.BytesIO(src) if isinstance(src, bytes) else src)
-            pil_image = pil_image.convert("RGB")
-            buf = io.BytesIO()
-            pil_image.save(buf, format="JPEG", quality=90)
-            return buf.getvalue()
+            from wled_controller.utils.image_codec import encode_jpeg, load_image_bytes, load_image_file
+            if isinstance(src, bytes):
+                image = load_image_bytes(src)
+            else:
+                image = load_image_file(src)
+            return encode_jpeg(image, quality=90)
 
         jpeg_bytes = await asyncio.to_thread(_encode_full, img_bytes)
         return Response(content=jpeg_bytes, media_type="image/jpeg")
@@ -333,13 +335,9 @@ async def get_video_thumbnail(
     store: PictureSourceStore = Depends(get_picture_source_store),
 ):
     """Get a thumbnail for a video picture source (first frame)."""
-    import base64
-    from io import BytesIO
-
-    from PIL import Image
-
     from wled_controller.core.processing.video_stream import extract_thumbnail
     from wled_controller.storage.picture_source import VideoCaptureSource
+    from wled_controller.utils.image_codec import encode_jpeg_data_uri, resize_down
 
     try:
         source = store.get_stream(stream_id)
@@ -352,18 +350,12 @@ async def get_video_thumbnail(
         if frame is None:
             raise HTTPException(status_code=404, detail="Could not extract thumbnail")
 
-        # Encode as JPEG
-        pil_img = Image.fromarray(frame)
         # Resize to max 320px wide for thumbnail
-        if pil_img.width > 320:
-            ratio = 320 / pil_img.width
-            pil_img = pil_img.resize((320, int(pil_img.height * ratio)), Image.LANCZOS)
+        frame = resize_down(frame, 320)
+        h, w = frame.shape[:2]
+        data_uri = encode_jpeg_data_uri(frame, quality=80)
 
-        buf = BytesIO()
-        pil_img.save(buf, format="JPEG", quality=80)
-        b64 = base64.b64encode(buf.getvalue()).decode()
-
-        return {"thumbnail": f"data:image/jpeg;base64,{b64}", "width": pil_img.width, "height": pil_img.height}
+        return {"thumbnail": data_uri, "width": w, "height": h}
 
     except HTTPException:
         raise
@@ -408,16 +400,18 @@ async def test_picture_source(
             source = raw_stream.image_source
             start_time = time.perf_counter()
 
+            from wled_controller.utils.image_codec import load_image_bytes, load_image_file
+
             if source.startswith(("http://", "https://")):
                 async with httpx.AsyncClient(timeout=15, follow_redirects=True) as client:
                     resp = await client.get(source)
                     resp.raise_for_status()
-                    pil_image = Image.open(io.BytesIO(resp.content)).convert("RGB")
+                    image = load_image_bytes(resp.content)
             else:
                 path = Path(source)
                 if not path.exists():
                     raise HTTPException(status_code=400, detail=f"Image file not found: {source}")
-                pil_image = await asyncio.to_thread(lambda: Image.open(path).convert("RGB"))
+                image = await asyncio.to_thread(load_image_file, path)
 
             actual_duration = time.perf_counter() - start_time
             frame_count = 1
@@ -479,12 +473,13 @@ async def test_picture_source(
             if last_frame is None:
                 raise RuntimeError("No frames captured during test")
 
-            if isinstance(last_frame.image, np.ndarray):
-                pil_image = Image.fromarray(last_frame.image)
-            else:
+            if not isinstance(last_frame.image, np.ndarray):
                 raise ValueError("Unexpected image format from engine")
+            image = last_frame.image
 
         # Create thumbnail + encode (CPU-bound — run in thread)
+        from wled_controller.utils.image_codec import encode_jpeg_data_uri, thumbnail as make_thumbnail
+
         pp_template_ids = chain["postprocessing_template_ids"]
         flat_filters = None
         if pp_template_ids:
@@ -494,45 +489,33 @@ async def test_picture_source(
             except ValueError:
                 logger.warning(f"PP template {pp_template_ids[0]} not found, skipping postprocessing preview")
 
-        def _create_thumbnails_and_encode(pil_img, filters):
-            thumbnail_w = 640
-            aspect_ratio = pil_img.height / pil_img.width
-            thumbnail_h = int(thumbnail_w * aspect_ratio)
-            thumb = pil_img.copy()
-            thumb.thumbnail((thumbnail_w, thumbnail_h), Image.Resampling.LANCZOS)
+        def _create_thumbnails_and_encode(img, filters):
+            thumb = make_thumbnail(img, 640)
 
             if filters:
                 pool = ImagePool()
-                def apply_filters(img):
-                    arr = np.array(img)
+                def apply_filters(arr):
                     for fi in filters:
                         f = FilterRegistry.create_instance(fi.filter_id, fi.options)
                         result = f.process_image(arr, pool)
                         if result is not None:
                             arr = result
-                    return Image.fromarray(arr)
+                    return arr
                 thumb = apply_filters(thumb)
-                pil_img = apply_filters(pil_img)
+                img = apply_filters(img)
 
-            img_buffer = io.BytesIO()
-            thumb.save(img_buffer, format='JPEG', quality=85)
-            thumb_b64 = base64.b64encode(img_buffer.getvalue()).decode('utf-8')
+            thumb_uri = encode_jpeg_data_uri(thumb, quality=85)
+            full_uri = encode_jpeg_data_uri(img, quality=90)
+            th, tw = thumb.shape[:2]
+            return tw, th, thumb_uri, full_uri
 
-            full_buffer = io.BytesIO()
-            pil_img.save(full_buffer, format='JPEG', quality=90)
-            full_b64 = base64.b64encode(full_buffer.getvalue()).decode('utf-8')
-
-            return thumbnail_w, thumbnail_h, thumb_b64, full_b64
-
-        thumbnail_width, thumbnail_height, thumbnail_b64, full_b64 = await asyncio.to_thread(
-            _create_thumbnails_and_encode, pil_image, flat_filters
+        thumbnail_width, thumbnail_height, thumbnail_data_uri, full_data_uri = await asyncio.to_thread(
+            _create_thumbnails_and_encode, image, flat_filters
         )
-        thumbnail_data_uri = f"data:image/jpeg;base64,{thumbnail_b64}"
-        full_data_uri = f"data:image/jpeg;base64,{full_b64}"
 
         actual_fps = frame_count / actual_duration if actual_duration > 0 else 0
         avg_capture_time_ms = (total_capture_time / frame_count * 1000) if frame_count > 0 else 0
-        width, height = pil_image.size
+        height, width = image.shape[:2]
 
         return TemplateTestResponse(
             full_capture=CaptureImage(
@@ -635,15 +618,11 @@ async def test_picture_source_ws(
 
         def _encode_video_frame(image, pw):
             """Encode numpy RGB image as JPEG base64 data URI."""
-            from PIL import Image as PILImage
-            pil = PILImage.fromarray(image)
-            if pw and pil.width > pw:
-                ratio = pw / pil.width
-                pil = pil.resize((pw, int(pil.height * ratio)), PILImage.LANCZOS)
-            buf = io.BytesIO()
-            pil.save(buf, format="JPEG", quality=80)
-            b64 = base64.b64encode(buf.getvalue()).decode()
-            return f"data:image/jpeg;base64,{b64}", pil.width, pil.height
+            from wled_controller.utils.image_codec import encode_jpeg_data_uri, resize_down
+            if pw:
+                image = resize_down(image, pw)
+            h, w = image.shape[:2]
+            return encode_jpeg_data_uri(image, quality=80), w, h
 
         try:
             await asyncio.get_event_loop().run_in_executor(None, video_stream.start)