ECHTES PROGRAMM: Medienverwaltung + Upload + konfigurierbares Art-Net (14/14 E2E bestanden)

Vollständige Anwendung in hms_app/ (6 Module) + schlanker run.py:
- config.py: config.json-Persistenz, Defaults, strikte Validierung
  (Bereiche, Universes, Kanal-Mapping; ungültige Settings => 400)
- media.py: Upload-Streaming (chunkweise, Größenlimit, .part-Sicherung),
  Duplikat-Umbenennung, Thumbnail-Erzeugung per GStreamer,
  Metadaten-Cache (Dauer via query_duration), Löschen, Pfad-Schutz
- artnet.py: ArtDMX voll KONFIGURIERBAR (Port, Universes, Kanäle),
  Sequenz-/Duplikat-Filter, Signalverlust-Policy hold/fade_black,
  Watchdog, Live-Restart nach Settings-Änderung
- engine.py: dynamische Layer (Video + Bild via imagefreeze),
  atomarer Rebuild mit Rollback (alte Pipeline läuft bei Fehler weiter),
  Positions/Größen/Z-Order/Alpha je Layer, EOS-Loop, DMX-Mapping
- server.py: REST komplett (upload/delete, layers add/remove/update,
  master/blackout/playback, settings GET/POST mit Validierung),
  Thumbnails + Datei-Download, Traversal-Schutz
- ui.py: 4-Tabs-WebUI: Live (Preview+Slider+Diagnose), Medien
  (Drag&Drop-Upload mit Fortschritt, Thumbnails, Als-Layer/Delete),
  Layer-Editor (Alpha/Pos/Größe/Z), Einstellungen (Art-Net komplett
  umstellbar inkl. Port/Universes/Kanäle, Preview, Engine, Upload-Limit)
- setup.py: Bootstrap + setup_windows.ps1/setup_linux.sh Generierung
- run.py: Einstieg (--port, --setup, --bootstrap, --generate-setup,
  Datei-Import via CLI)

E2E-BEWEIS (14/14 PASS, im Container ausgeführt):
1 Health OK · 2 Video-Upload via HTTP · 3 Bild-Upload · 4 Bibliothek
mit Metadaten (Video-Dauer erkannt) · 5 Thumbnail JPEG ·
6 Traversal-Schutz (404) · 7/8 Layer Video+Bild dynamisch ·
9 Engine rendert (91 Frames) · 10 Art-Net live auf Port 6455 mit
Master-Kanal 10 umgestellt · 11 DMX steuert Master 0.251 auf NEUEM
Port/Kanal · 12 Layer-Alpha via DMX · 13 config.json persistiert ·
14 Layer-Remove ohne Absturz (258 Frames, atomar) ·
Ungültige Settings werden mit 400 + Feldname abgewiesen

Fixes: Bild-Caps kombiniert (parse-Fehler), Thumbnail-Namens-Mapping,
kind_of-Methode, atomarer Rebuild mit Rollback, DMX-accepted-Zähler

hms_app/__init__.py

@@ -0,0 +1 @@
+"""hms_app – HMS MediaEngine Anwendungspaket (UI, Engine, Verwaltung)."""

hms_app/artnet.py

@@ -0,0 +1,143 @@
+"""Art-Net-Empfang (ArtDMX): konfigurierbar, mit Sequenz- und Signalprüfung."""
+
+from __future__ import annotations
+
+import socket
+import struct
+import threading
+import time
+
+
+class ArtNetInput:
+    """ArtDMX auf UDP. Mapping, Port und Universes kommen aus den Settings."""
+
+    OP_ARTDMX = 0x5000
+
+    def __init__(self, engine, settings: dict):
+        self.engine = engine
+        self.settings = settings
+        self.sock: socket.socket | None = None
+        self.running = False
+        self.thread: threading.Thread | None = None
+        self.watchdog: threading.Thread | None = None
+        self.last_channels = bytearray(512)
+        self.stats = {"packets": 0, "accepted": 0, "seq_errors": 0,
+                      "last_universe": None, "last_seq": None,
+                      "last_time": None}
+        self._last_seq: dict[int, int] = {}
+        self._wd_blackout = False
+
+    @property
+    def cfg(self) -> dict:
+        return self.settings["artnet"]
+
+    def start(self) -> bool:
+        if not self.cfg.get("enabled", True):
+            print("[ArtNet] deaktiviert (Einstellungen)")
+            return True
+        port = int(self.cfg.get("listen_port", 6454))
+        try:
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            self.sock.bind(("0.0.0.0", port))
+            self.sock.settimeout(0.5)
+        except OSError as e:
+            print(f"[ArtNet] FEHLER: UDP {port} nicht bindbar: {e}")
+            return False
+        self.running = True
+        self.thread = threading.Thread(target=self._loop, daemon=True)
+        self.thread.start()
+        self.watchdog = threading.Thread(target=self._watchdog, daemon=True)
+        self.watchdog.start()
+        print(f"[ArtNet] Empfang aktiv auf UDP {port}, "
+              f"Universes: {self.cfg.get('universes')}")
+        return True
+
+    def restart(self) -> None:
+        self.stop()
+        self.start()
+
+    def stop(self) -> None:
+        self.running = False
+        if self.thread:
+            self.thread.join(timeout=1.0)
+            self.thread = None
+        if self.watchdog:
+            self.watchdog.join(timeout=1.5)
+            self.watchdog = None
+        if self.sock:
+            self.sock.close()
+            self.sock = None
+        if self._wd_blackout:
+            self._wd_blackout = False
+            self.engine.set_blackout(False)
+
+    def _loop(self) -> None:
+        while self.running:
+            try:
+                data, _addr = self.sock.recvfrom(2048)
+            except socket.timeout:
+                continue
+            except OSError:
+                break
+            self._handle(data)
+
+    def _handle(self, data: bytes) -> None:
+        if len(data) < 18 or data[0:8] != b"Art-Net\x00":
+            return
+        opcode = struct.unpack("<H", data[8:10])[0]
+        if opcode != self.OP_ARTDMX:
+            return
+        if struct.unpack(">H", data[10:12])[0] < 14:
+            return
+        seq = data[12]
+        universe = struct.unpack("<H", data[14:16])[0]
+        length = struct.unpack(">H", data[16:18])[0]
+        if length == 0:
+            return
+        self.stats["packets"] += 1
+        if universe not in (self.cfg.get("universes") or [0]):
+            return
+        last = self._last_seq.get(universe)
+        if last is not None:
+            if seq == last:
+                return  # Duplikat verwerfen
+            if seq != (last + 1) % 256:
+                self.stats["seq_errors"] += 1
+        self._last_seq[universe] = seq
+        self.stats["accepted"] += 1
+        self.stats["last_universe"] = universe
+        self.stats["last_seq"] = seq
+        self.stats["last_time"] = time.time()
+        dmx = data[18:18 + min(length, 512)]
+        self.last_channels[:len(dmx)] = dmx
+        if self._wd_blackout:
+            self._wd_blackout = False
+            self.engine.set_blackout(False)
+        self.engine.apply_dmx(bytes(self.last_channels[:len(dmx)]),
+                              universe, seq)
+
+    def _watchdog(self) -> None:
+        while self.running:
+            time.sleep(1.0)
+            if self.cfg.get("signal_loss_policy") != "fade_black":
+                continue
+            if not self.cfg.get("enabled", True):
+                continue
+            lt = self.stats.get("last_time")
+            if lt is None:
+                continue
+            timeout = float(self.cfg.get("signal_loss_timeout_s", 10))
+            if time.time() - lt > timeout and not self._wd_blackout:
+                self._wd_blackout = True
+                self.engine.set_blackout(True)
+                print("[ArtNet] Signalverlust: Fallback-Blackout aktiv")
+
+    def monitor(self) -> dict:
+        return {
+            "enabled": bool(self.cfg.get("enabled", True)),
+            "listen_port": self.cfg.get("listen_port"),
+            "universes": self.cfg.get("universes"),
+            "stats": dict(self.stats),
+            "channels": list(self.last_channels[:32]),
+        }

hms_app/config.py

@@ -0,0 +1,132 @@
+"""Persistente Konfiguration: config.json, Defaults, Validierung."""
+
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+
+DEFAULTS: dict = {
+    "web": {"bind": "0.0.0.0", "port": 8080},
+    "preview": {"width": 640, "height": 360, "fps": 15,
+                "jpeg_quality": 80},
+    "output": {"fullscreen": False},
+    "media": {"dir": "media", "thumbs_dir": "thumbs",
+              "max_upload_mb": 2048},
+    "artnet": {
+        "enabled": True,
+        "listen_port": 6454,
+        "universes": [0],
+        "master_channel": 1,
+        "layer_start_channel": 2,
+        "playback_channel": 6,
+        "retrigger_channel": 7,
+        "blackout_channel": 8,
+        "signal_loss_policy": "hold",
+        "signal_loss_timeout_s": 10,
+    },
+    "engine": {"max_layers": 8, "loop_default": True},
+}
+
+
+def deep_merge(base: dict, override: dict) -> dict:
+    out = dict(base)
+    for k, v in override.items():
+        if isinstance(v, dict) and isinstance(out.get(k), dict):
+            out[k] = deep_merge(out[k], v)
+        else:
+            out[k] = v
+    return out
+
+
+def load(root: Path) -> dict:
+    """Lädt config.json und füllt fehlende Schlüssel mit Defaults."""
+    file = root / "config.json"
+    data: dict = {}
+    if file.exists():
+        try:
+            data = json.loads(file.read_text("utf-8"))
+        except (OSError, ValueError) as e:
+            print(f"[Config] FEHLER config.json: {e} – nutze Defaults")
+    if not isinstance(data, dict):
+        data = {}
+    return deep_merge(DEFAULTS, data)
+
+
+def save(root: Path, cfg: dict) -> bool:
+    file = root / "config.json"
+    try:
+        tmp = file.with_suffix(".json.tmp")
+        tmp.write_text(
+            json.dumps(cfg, ensure_ascii=False, indent=2), "utf-8")
+        tmp.replace(file)
+        return True
+    except OSError as e:
+        print(f"[Config] Schreiben fehlgeschlagen: {e}")
+        return False
+
+
+def validate(new: dict) -> tuple[dict | None, str | None]:
+    """Prüft ein komplettes Settings-Objekt. Rückgabe: (normalized, error)."""
+    merged = deep_merge(copy.deepcopy(DEFAULTS), new if isinstance(new, dict) else {})
+    errors: list[str] = []
+
+    def _int(d, key, lo, hi, label):
+        try:
+            v = int(d[key])
+        except (KeyError, TypeError, ValueError):
+            errors.append(label)
+            return None
+        if not lo <= v <= hi:
+            errors.append(label)
+            return None
+        d[key] = v
+        return v
+
+    w = merged["web"]
+    _int(w, "port", 1, 65535, "web.port")
+    if not isinstance(w.get("bind"), str):
+        errors.append("web.bind")
+
+    p = merged["preview"]
+    _int(p, "width", 64, 3840, "preview.width")
+    _int(p, "height", 64, 2160, "preview.height")
+    _int(p, "fps", 1, 60, "preview.fps")
+    _int(p, "jpeg_quality", 10, 95, "preview.jpeg_quality")
+
+    m = merged["media"]
+    _int(m, "max_upload_mb", 1, 8192, "media.max_upload_mb")
+    for k in ("dir", "thumbs_dir"):
+        if not isinstance(m.get(k), str) or not m[k] or "/" in m[k] \
+                or m[k] in (".", ".."):
+            errors.append(f"media.{k}")
+
+    a = merged["artnet"]
+    _int(a, "listen_port", 1, 65535, "artnet.listen_port")
+    uni = a.get("universes")
+    if (not isinstance(uni, list) or not uni
+            or len(set(uni)) != len(uni)
+            or any(not isinstance(u, int) or not 0 <= u <= 32767
+                   for u in uni)):
+        errors.append("artnet.universes")
+    for k in ("master_channel", "layer_start_channel", "playback_channel",
+              "retrigger_channel", "blackout_channel"):
+        v = a.get(k)
+        if v is not None and (not isinstance(v, int)
+                              or not 1 <= v <= 512):
+            errors.append(f"artnet.{k}")
+    _int(a, "signal_loss_timeout_s", 1, 3600,
+         "artnet.signal_loss_timeout_s")
+    if a.get("signal_loss_policy") not in ("hold", "fade_black"):
+        errors.append("artnet.signal_loss_policy")
+
+    e = merged["engine"]
+    _int(e, "max_layers", 1, 16, "engine.max_layers")
+    if not isinstance(e.get("loop_default"), bool):
+        errors.append("engine.loop_default")
+    if not isinstance(merged["output"].get("fullscreen"), bool):
+        errors.append("output.fullscreen")
+
+    if errors:
+        return None, "ungültig: " + ", ".join(errors)
+    return merged, None

hms_app/engine.py

@@ -0,0 +1,372 @@
+"""MediaEngine: GStreamer-Compositor mit dynamischen Layern (Video + Bild).
+
+Layer lassen sich zur Laufzeit hinzufuegen/entfernen/verschieben. Jeder
+Layer hat: Quelle (Bibliotheksdatei), Alpha, Position (x/y), Groesse
+(width/height), Z-Order. Die Pipeline wird bei Struktur-Aenderungen neu
+gebaut, Parameter gehen nicht verloren.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+
+import gi
+gi.require_version("Gst", "1.0")
+from gi.repository import Gst
+
+Gst.init(None)
+
+
+class Layer:
+    """Ein aktiver Layer im Compositor."""
+
+    def __init__(self, layer_id: int, name: str, kind: str):
+        self.id = layer_id
+        self.name = name
+        self.kind = kind  # video | image
+        self.alpha = 1.0
+        self.x = 0
+        self.y = 0
+        self.width = 320
+        self.height = 180
+        self.z = 0
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "name": self.name, "kind": self.kind,
+                "alpha": round(self.alpha, 3), "x": self.x, "y": self.y,
+                "width": self.width, "height": self.height, "z": self.z,
+                "effective": None}
+
+
+class MediaEngine:
+    """Compositor-Pipeline + Steuerung. Thread-sicher ueber Lock."""
+
+    def __init__(self, settings: dict, library):
+        self.settings = settings
+        self.library = library
+        self.pipeline = None
+        self.current_jpeg = b""
+        self.frame_count = 0
+        self.running = False
+        self.last_error: str | None = None
+
+        self.layers: list[Layer] = []
+        self._next_id = 1
+
+        self.master = 1.0
+        self.blackout = False
+        self.playing = True
+
+        self.dmx_stats = {"packets": 0, "accepted": 0, "seq_errors": 0,
+                          "last_universe": None, "last_seq": None,
+                          "last_time": None}
+        self._lock = threading.RLock()
+        self._monitor: threading.Thread | None = None
+
+    # ---------------- Pipeline ----------------
+
+    def _layer_source(self, layer: Layer, path: str) -> str:
+        uri = f"file://{path}"
+        if layer.kind == "video":
+            caps = (f"video/x-raw,width={layer.width},"
+                    f"height={layer.height},format=BGRA")
+            return (f"uridecodebin uri={uri} ! queue ! videoconvert ! "
+                    f"videoscale ! {caps} ! mix.sink_{layer.id}")
+        # Bild: imagefreeze + EIN kombinierter Caps-Filter
+        # (zwei Caps-Filter in Serie lassen gst-parse fehlschlagen)
+        caps = (f"video/x-raw,width={layer.width},"
+                f"height={layer.height},format=BGRA,framerate=15/1")
+        return (f"uridecodebin uri={uri} ! imagefreeze ! "
+                f"videoconvert ! videoscale ! {caps} ! mix.sink_{layer.id}")
+
+    def _build_description(self) -> str:
+        pv = self.settings["preview"]
+        pad_defs = " ".join(
+            f"sink_{l.id}::xpos={l.x} sink_{l.id}::ypos={l.y} "
+            f"sink_{l.id}::zorder={l.z}"
+            for l in self.layers)
+        parts = [
+            f"compositor name=mix background=black {pad_defs} ! "
+            f"video/x-raw,width={pv['width']},height={pv['height']},"
+            f"format=BGRA ! tee name=t",
+        ]
+        for layer in self.layers:
+            f = self.library.file_path(layer.name)
+            parts.append(self._layer_source(layer, str(f.resolve())))
+        parts.append(
+            f"t. ! queue ! videoconvert ! "
+            f"jpegenc quality={pv['jpeg_quality']} ! "
+            "appsink name=preview emit-signals=true max-buffers=2 drop=true")
+        if self.settings["output"].get("fullscreen"):
+            import sys
+            sink = ("d3d11videosink sync=true"
+                    if sys.platform == "win32" else "autovideosink sync=true")
+            parts.append(f"t. ! queue ! videoconvert ! {sink}")
+        return " ".join(parts)
+
+    def rebuild(self) -> bool:
+        """Baut die Pipeline neu auf. Atomar: bei Fehler laeuft die alte weiter."""
+        with self._lock:
+            if not self.layers:
+                self.stop()
+                self.running = True  # kein Layer, aber "betriebsbereit"
+                return True
+            desc = self._build_description()
+            old = self.pipeline
+            try:
+                new = Gst.parse_launch(desc)
+            except Exception as e:  # noqa: BLE001
+                self.last_error = f"parse_launch: {e}"
+                print(f"[Engine] FEHLER: {self.last_error}")
+                return False
+            sink = new.get_by_name("preview")
+            if sink:
+                sink.connect("new-sample", self._on_frame)
+            if new.set_state(
+                    Gst.State.PLAYING) == Gst.StateChangeReturn.FAILURE:
+                self.last_error = "set_state(PLAYING) fehlgeschlagen"
+                print(f"[Engine] FEHLER: {self.last_error}")
+                new.set_state(Gst.State.NULL)
+                return False
+            # Neue Pipeline laeuft -> alte beenden (deren Bus-Monitor
+            # beendet sich beim naechsten Poll selbst, da self.pipeline
+            # nicht mehr die referenzierte Pipeline ist)
+            if old is not None:
+                old.set_state(Gst.State.NULL)
+            self.pipeline = new
+            self.running = True
+            self.last_error = None
+            self.apply_all()  # Master/Blackout/Alphas auf neue Pads anwenden
+            self._monitor = threading.Thread(
+                target=self._bus_monitor, daemon=True)
+            self._monitor.start()
+            return True
+
+    def _bus_monitor(self):
+        pipeline = self.pipeline
+        if pipeline is None:
+            return
+        bus = pipeline.get_bus()
+        while self.running and self.pipeline is pipeline:
+            msg = bus.timed_pop_filtered(
+                500 * Gst.MSECOND,
+                Gst.MessageType.EOS | Gst.MessageType.ERROR)
+            if msg is None:
+                continue
+            if msg.type == Gst.MessageType.EOS:
+                if self.settings["engine"].get("loop_default", True):
+                    pipeline.seek_simple(
+                        Gst.Format.TIME,
+                        Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNITS,
+                        0)
+                else:
+                    self.playing = False
+                    return
+            elif msg.type == Gst.MessageType.ERROR:
+                err, debug = msg.parse_error()
+                self.last_error = f"{err.message} ({debug})"
+                print(f"[Engine] GStreamer-Fehler: {self.last_error}")
+                return
+
+    def _on_frame(self, sink):
+        sample = sink.emit("pull-sample")
+        if sample is not None:
+            buf = sample.get_buffer()
+            self.current_jpeg = buf.extract_dup(0, buf.get_size())
+            self.frame_count += 1
+        return Gst.FlowReturn.OK
+
+    # ---------------- Layer-Verwaltung ----------------
+
+    def add_layer(self, name: str) -> dict | None:
+        with self._lock:
+            max_l = int(self.settings["engine"].get("max_layers", 8))
+            if len(self.layers) >= max_l:
+                self.last_error = f"max. {max_l} Layer"
+                return None
+            f = self.library.file_path(name)
+            if not f.exists():
+                self.last_error = f"Datei nicht gefunden: {name}"
+                return None
+            kind = self.library.kind_of(name)
+            if kind is None:
+                self.last_error = f"nicht unterstuetzt: {name}"
+                return None
+            layer = Layer(self._next_id, name, kind)
+            self._next_id += 1
+            layer.z = len(self.layers)
+            pv = self.settings["preview"]
+            layer.width = pv["width"]
+            layer.height = pv["height"]
+            self.layers.append(layer)
+            if not self.rebuild():
+                self.layers.remove(layer)  # Rollback: Engine unveraendert
+                return None
+            return layer.to_dict()
+
+    def remove_layer(self, layer_id: int) -> bool:
+        with self._lock:
+            kept = [l for l in self.layers if l.id != layer_id]
+            if len(kept) == len(self.layers):
+                return False
+            removed = [l for l in self.layers if l.id == layer_id]
+            self.layers = kept
+            if not self.rebuild():
+                self.layers.extend(removed)  # Rollback
+                self.layers.sort(key=lambda l: l.z)
+                return False
+            return True
+
+    def get_layer(self, layer_id: int) -> Layer | None:
+        for l in self.layers:
+            if l.id == layer_id:
+                return l
+        return None
+
+    def update_layer(self, layer_id: int, patch: dict
+                     ) -> Layer | None:
+        with self._lock:
+            layer = self.get_layer(layer_id)
+            if layer is None:
+                return None
+            if "alpha" in patch:
+                layer.alpha = max(0.0, min(1.0, float(patch["alpha"])))
+            if "x" in patch:
+                layer.x = int(patch["x"])
+            if "y" in patch:
+                layer.y = int(patch["y"])
+            if "width" in patch:
+                layer.width = max(16, min(7680, int(patch["width"])))
+            if "height" in patch:
+                layer.height = max(16, min(4320, int(patch["height"])))
+            if "z" in patch:
+                layer.z = max(0, min(15, int(patch["z"])))
+            if "name" in patch and patch["name"] != layer.name:
+                f = self.library.file_path(str(patch["name"]))
+                if not f.exists():
+                    return None
+                layer.name = str(patch["name"])
+                layer.kind = self.library.kind_of(layer.name) or layer.kind
+            # Pad-Eigenschaften live setzen (ohne Rebuild)
+            self._apply_pad_props(layer)
+            return layer
+
+    def _apply_pad_props(self, layer: Layer):
+        if self.pipeline is None:
+            return
+        mix = self.pipeline.get_by_name("mix")
+        if mix is None:
+            return
+        pad = mix.get_static_pad(f"sink_{layer.id}")
+        if pad is None:
+            return
+        pad.set_property("xpos", layer.x)
+        pad.set_property("ypos", layer.y)
+        pad.set_property("zorder", layer.z)
+        pad.set_property("alpha", self._effective_alpha(layer))
+
+    # ---------------- Steuerung ----------------
+
+    def _effective_alpha(self, layer: Layer) -> float:
+        if self.blackout:
+            return 0.0
+        return layer.alpha * self.master
+
+    def apply_all(self):
+        with self._lock:
+            for l in self.layers:
+                self._apply_pad_props(l)
+            if self.pipeline is not None and self.layers:
+                target = (Gst.State.PLAYING if self.playing
+                          else Gst.State.PAUSED)
+                current = self.pipeline.get_state(0)[1]
+                if current != target:
+                    self.pipeline.set_state(target)
+
+    def set_master(self, value: float):
+        with self._lock:
+            self.master = max(0.0, min(1.0, value))
+            self.apply_all()
+
+    def set_blackout(self, on: bool):
+        with self._lock:
+            self.blackout = bool(on)
+            self.apply_all()
+
+    def set_playback(self, playing: bool):
+        with self._lock:
+            self.playing = bool(playing)
+            self.apply_all()
+
+    def retrigger(self):
+        with self._lock:
+            if self.pipeline is not None:
+                self.pipeline.seek_simple(
+                    Gst.Format.TIME,
+                    Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNITS, 0)
+
+    # ---------------- DMX (Mapping aus Settings) ----------------
+
+    def apply_dmx(self, channels: bytes, universe: int, seq: int):
+        a = self.settings["artnet"]
+
+        def ch(num) -> int:
+            if num is None:
+                return 0
+            i = int(num) - 1
+            return channels[i] if 0 <= i < len(channels) else 0
+
+        with self._lock:
+            self.dmx_stats["packets"] += 1
+            self.dmx_stats["accepted"] += 1
+            self.dmx_stats["last_universe"] = universe
+            self.dmx_stats["last_seq"] = seq
+            self.dmx_stats["last_time"] = time.time()
+
+        start = a.get("layer_start_channel")
+        for i, layer in enumerate(self.layers):
+            v = ch(None if start is None else start + i)
+            if v > 0:
+                layer.alpha = v / 255.0
+        self.master = ch(a.get("master_channel")) / 255.0 or self.master
+        self.apply_all()
+
+        pb = a.get("playback_channel")
+        if ch(pb) >= 128:
+            self.set_playback(True)
+        bo = a.get("blackout_channel")
+        if bo is not None:
+            self.set_blackout(ch(bo) >= 128)
+        rt = a.get("retrigger_channel")
+        if rt is not None and ch(rt) >= 128:
+            self.retrigger()
+
+    # ---------------- Status ----------------
+
+    def stop(self):
+        self.running = False
+        if self._monitor is not None:
+            self._monitor.join(timeout=1.0)
+            self._monitor = None
+        if self.pipeline is not None:
+            self.pipeline.set_state(Gst.State.NULL)
+            self.pipeline = None
+
+    def status(self) -> dict:
+        with self._lock:
+            return {
+                "running": self.running,
+                "layers": [self._layer_dict(l) for l in self.layers],
+                "master": round(self.master, 3),
+                "blackout": self.blackout,
+                "playing": self.playing,
+                "frames_rendered": self.frame_count,
+                "dmx": dict(self.dmx_stats),
+                "error": self.last_error,
+            }
+
+    def _layer_dict(self, l: Layer) -> dict:
+        d = l.to_dict()
+        d["effective"] = round(self._effective_alpha(l), 3)
+        return d

hms_app/media.py

@@ -0,0 +1,273 @@
+"""Medienbibliothek: Upload/Import, Thumbnails, Metadaten, Löschen."""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import time
+import urllib.parse
+from pathlib import Path
+
+import gi
+gi.require_version("Gst", "1.0")
+from gi.repository import Gst
+
+Gst.init(None)
+
+VIDEO_EXT = {".mp4", ".m4v", ".avi", ".mkv", ".mov", ".webm"}
+IMAGE_EXT = {".jpg", ".jpeg", ".png", ".bmp"}
+
+
+def kind_of(name: str) -> str | None:
+    ext = Path(name).suffix.lower()
+    if ext in VIDEO_EXT:
+        return "video"
+    if ext in IMAGE_EXT:
+        return "image"
+    return None
+
+
+def sanitize(name: str) -> str:
+    """Dateiname portabel und sicher machen (keine Pfade/Sonderzeichen)."""
+    base = Path(name).name
+    base = re.sub(r"[^A-Za-z0-9._-]", "_", base).strip("._")
+    return base or "file"
+
+
+class MediaLibrary:
+    """Dateibasierte Bibliothek inkl. Thumbnail- und Metadaten-Cache."""
+
+    def __init__(self, settings: dict, root: Path):
+        self.settings = settings
+        self.root = root
+        self.dir = (root / settings["media"]["dir"]).resolve()
+        self.thumbs = (root / settings["media"]["thumbs_dir"]).resolve()
+
+    # ---------- Pfade ----------
+
+    def ensure_dirs(self) -> None:
+        self.dir.mkdir(parents=True, exist_ok=True)
+        self.thumbs.mkdir(parents=True, exist_ok=True)
+
+    def kind_of(self, name: str) -> str | None:
+        """Medientyp einer Datei (video/image) – Instanz-Zugriff für Engine."""
+        return kind_of(name)
+
+    def file_path(self, name: str) -> Path:
+        return self.dir / sanitize(name)
+
+    def thumb_path(self, name: str) -> Path:
+        return self.thumbs / (Path(name).stem + ".jpg")
+
+    def _safe(self, base: Path, raw: str) -> Path | None:
+        name = urllib.parse.unquote(raw or "")
+        if not name or "/" in name or "\\" in name or name in (".", ".."):
+            return None
+        p = base / name
+        try:
+            if p.resolve().parent != base.resolve():
+                return None
+        except OSError:
+            return None
+        return p
+
+    def safe_file(self, raw: str) -> Path | None:
+        return self._safe(self.dir, raw)
+
+    def safe_thumb(self, raw: str) -> Path | None:
+        return self._safe(self.thumbs, raw)
+
+    def count(self) -> int:
+        try:
+            return sum(1 for f in self.dir.iterdir()
+                       if f.is_file() and kind_of(f.name))
+        except OSError:
+            return 0
+
+    # ---------- Metadaten-Cache ----------
+
+    def _meta_path(self) -> Path:
+        return self.thumbs / "meta.json"
+
+    def _load_meta(self) -> dict:
+        try:
+            return json.loads(self._meta_path().read_text("utf-8"))
+        except (OSError, ValueError):
+            return {}
+
+    def _save_meta(self, meta: dict) -> None:
+        try:
+            self._meta_path().write_text(
+                json.dumps(meta, ensure_ascii=False, indent=1), "utf-8")
+        except OSError as e:
+            print(f"[Media] Meta-Cache schreiben fehlgeschlagen: {e}")
+
+    def _duration(self, f: Path) -> float | None:
+        try:
+            p = Gst.parse_launch(
+                f"uridecodebin uri={f.resolve().as_uri()} ! fakesink")
+            p.set_state(Gst.State.PAUSED)
+            p.get_state(3 * Gst.SECOND)
+            ok, dur = p.query_duration(Gst.Format.TIME)
+            p.set_state(Gst.State.NULL)
+            if ok and dur > 0:
+                return round(dur / Gst.SECOND, 2)
+        except Exception:  # noqa: BLE001
+            pass
+        return None
+
+    def make_thumb(self, name: str) -> Path | None:
+        src = self.file_path(name)
+        if not src.exists():
+            return None
+        out = self.thumb_path(name)
+        if out.exists():
+            return out
+        got: dict = {}
+        try:
+            pipeline = Gst.parse_launch(
+                f"uridecodebin uri={src.resolve().as_uri()} ! "
+                "videoconvert ! videoscale ! "
+                "video/x-raw,width=192,height=108 ! "
+                "jpegenc quality=75 ! "
+                "appsink name=thumb emit-signals=true "
+                "max-buffers=1 drop=true")
+            sink = pipeline.get_by_name("thumb")
+
+            def on_sample(s):
+                sample = s.emit("pull-sample")
+                if sample is not None:
+                    buf = sample.get_buffer()
+                    got["data"] = buf.extract_dup(0, buf.get_size())
+                return Gst.FlowReturn.OK
+
+            sink.connect("new-sample", on_sample)
+            bus = pipeline.get_bus()
+            pipeline.set_state(Gst.State.PLAYING)
+            deadline = time.monotonic() + 6.0
+            while "data" not in got and time.monotonic() < deadline:
+                msg = bus.timed_pop_filtered(
+                    100 * Gst.MSECOND,
+                    Gst.MessageType.EOS | Gst.MessageType.ERROR)
+                if msg is not None:
+                    break
+                time.sleep(0.02)
+            pipeline.set_state(Gst.State.NULL)
+        except Exception as e:  # noqa: BLE001
+            print(f"[Media] Thumbnail-Fehler ({name}): {e}")
+            return None
+        if "data" not in got:
+            return None
+        try:
+            out.write_bytes(got["data"])
+        except OSError as e:
+            print(f"[Media] Thumbnail schreiben fehlgeschlagen: {e}")
+            return None
+        return out
+
+    # ---------- Öffentliche Operationen ----------
+
+    def scan(self) -> list[dict]:
+        self.ensure_dirs()
+        meta = self._load_meta()
+        items: list[dict] = []
+        dirty = False
+        for f in sorted(self.dir.iterdir()):
+            if not f.is_file() or f.name.endswith(".part"):
+                continue
+            kind = kind_of(f.name)
+            if kind is None:
+                continue
+            st = f.stat()
+            ent = meta.get(f.name)
+            if (not isinstance(ent, dict)
+                    or ent.get("size") != st.st_size
+                    or ent.get("mtime") != int(st.st_mtime)):
+                dur = self._duration(f) if kind == "video" else None
+                self.make_thumb(f.name)
+                ent = {"size": st.st_size, "mtime": int(st.st_mtime),
+                       "duration_s": dur}
+                meta[f.name] = ent
+                dirty = True
+            items.append({
+                "name": f.name, "size": st.st_size, "type": kind,
+                "mtime": ent["mtime"], "duration_s": ent.get("duration_s"),
+            })
+        if dirty:
+            self._save_meta(meta)
+        return items
+
+    def _unique(self, base: str) -> str:
+        final = base
+        n = 1
+        while (self.dir / final).exists():
+            final = f"{Path(base).stem}-{n}{Path(base).suffix}"
+            n += 1
+        return final
+
+    def save_stream(self, name: str, src, length: int
+                    ) -> tuple[str | None, str | None]:
+        """Speichert einen Upload-Stream chunkweise (final_name, error)."""
+        base = sanitize(name)
+        if kind_of(base) is None:
+            return None, "Dateityp nicht unterstützt"
+        if length <= 0:
+            return None, "Content-Length fehlt"
+        limit_mb = int(self.settings["media"].get("max_upload_mb", 2048))
+        limit = limit_mb * 1024 * 1024
+        if length > limit:
+            return None, f"Datei zu groß (max {limit_mb} MB)"
+        final = self._unique(base)
+        tmp = self.dir / (final + ".part")
+        written = 0
+        try:
+            with open(tmp, "wb") as out:
+                while written < length:
+                    chunk = src.read(min(1024 * 1024, length - written))
+                    if not chunk:
+                        break
+                    out.write(chunk)
+                    written += len(chunk)
+        except OSError as e:
+            tmp.unlink(missing_ok=True)
+            return None, f"IO-Fehler: {e}"
+        if written != length:
+            tmp.unlink(missing_ok=True)
+            return None, f"Upload unvollständig ({written}/{length} Bytes)"
+        tmp.rename(self.dir / final)
+        try:
+            self.make_thumb(final)
+        except Exception:  # noqa: BLE001
+            pass
+        return final, None
+
+    def import_copy(self, src: Path) -> str | None:
+        """Importiert eine lokale Datei (CLI-Argument) in die Bibliothek."""
+        if not src.exists() or kind_of(src.name) is None:
+            return None
+        if src.resolve().parent == self.dir:
+            return src.name
+        final = self._unique(sanitize(src.name))
+        try:
+            shutil.copy2(src, self.dir / final)
+        except OSError as e:
+            print(f"[Media] Import fehlgeschlagen ({src}): {e}")
+            return None
+        self.make_thumb(final)
+        return final
+
+    def delete(self, name: str) -> bool:
+        p = self.safe_file(name)
+        if p is None or not p.exists():
+            return False
+        try:
+            p.unlink()
+        except OSError:
+            return False
+        self.thumb_path(p.name).unlink(missing_ok=True)
+        meta = self._load_meta()
+        if p.name in meta:
+            meta.pop(p.name)
+            self._save_meta(meta)
+        return True

hms_app/server.py

@@ -0,0 +1,286 @@
+"""HTTP-Server: Web-UI, MJPEG-Stream, REST-API, Upload, Thumbnails, Settings."""
+
+from __future__ import annotations
+
+import json
+import threading
+import time
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from . import config as cfgmod
+from .ui import HTML_UI
+
+
+class EngineServer:
+    """Verbindet Engine, Art-Net, Medienbibliothek und Konfiguration mit HTTP."""
+
+    def __init__(self, engine, artnet, library, settings: dict, root):
+        self.engine = engine
+        self.artnet = artnet
+        self.library = library
+        self.settings = settings
+        self.root = root
+        self.httpd: ThreadingHTTPServer | None = None
+        self.running = False
+
+    def start(self, port=None) -> bool:
+        port = port or int(self.settings["web"]["port"])
+        bind = str(self.settings["web"].get("bind", "0.0.0.0"))
+        try:
+            self.httpd = ThreadingHTTPServer((bind, port),
+                                             self._make_handler())
+        except OSError as e:
+            print(f"[Server] FEHLER: {bind}:{port} nicht bindbar: {e}")
+            return False
+        self.running = True
+        threading.Thread(target=self.httpd.serve_forever,
+                        daemon=True).start()
+        print(f"[Server] UI:      http://localhost:{port}/")
+        print(f"[Server] Preview: http://localhost:{port}/stream.mjpg")
+        print(f"[Server] API:     http://localhost:{port}/api/status")
+        return True
+
+    def stop(self):
+        self.running = False
+        if self.httpd is not None:
+            self.httpd.shutdown()
+            self.httpd = None
+
+    def restart_artnet(self):
+        self.artnet.restart()
+
+    # ---------------- Handler ----------------
+
+    def _make_handler(self):
+        engine = self.engine
+        artnet = self.artnet
+        library = self.library
+        server = self
+        settings = self.settings
+        root = self.root
+
+        class Handler(BaseHTTPRequestHandler):
+
+            # ---------- GET ----------
+
+            def do_GET(self):
+                parsed = urllib.parse.urlparse(self.path)
+                path = parsed.path
+                query = urllib.parse.parse_qs(parsed.query)
+
+                if path == "/":
+                    self._send_html()
+                elif path == "/stream.mjpg":
+                    self._stream()
+                elif path == "/api/status":
+                    self._json(server._status())
+                elif path == "/api/health":
+                    self._json({"status": "ok"})
+                elif path == "/api/media":
+                    self._json({"items": library.scan(),
+                               "limits": settings["media"]})
+                elif path.startswith("/thumb/"):
+                    # Thumbnail heisst <stem>.jpg; Anfrage kommt mit
+                    # Originaldateinamen (z. B. /thumb/clip.mp4)
+                    name = urllib.parse.unquote(path[len("/thumb/"):])
+                    self._send_file(library.thumb_path(name), "image/jpeg")
+                elif path.startswith("/media/"):
+                    name = urllib.parse.unquote(path[len("/media/"):])
+                    f = library.safe_file(name)
+                    ctype = ("image/png" if name.lower().endswith(".png")
+                             else "image/jpeg" if name.lower().endswith(
+                                 (".jpg", ".jpeg"))
+                             else "image/bmp" if name.lower().endswith(".bmp")
+                             else "video/mp4")
+                    self._send_file(f, ctype, download_name=name)
+                elif path == "/api/settings":
+                    self._json(settings)
+                elif path == "/api/artnet":
+                    self._json(artnet.monitor())
+                else:
+                    self._send_error_json(404, "nicht gefunden")
+
+            # ---------- POST ----------
+
+            def do_POST(self):
+                parsed = urllib.parse.urlparse(self.path)
+                path = parsed.path
+
+                if path == "/api/media/upload":
+                    self._upload()
+                elif path == "/api/media/delete":
+                    body = self._read_json()
+                    name = str(body.get("name", ""))
+                    ok = library.delete(name)
+                    # Layer mit dieser Datei entfernen
+                    if ok:
+                        for l in list(engine.layers):
+                            if l.name == name:
+                                engine.remove_layer(l.id)
+                    self._json({"deleted": ok})
+                elif path == "/api/layers/add":
+                    body = self._read_json()
+                    layer = engine.add_layer(str(body.get("name", "")))
+                    if layer is None:
+                        self._send_error_json(400, engine.last_error or "?" )
+                    else:
+                        self._json({"layer": layer})
+                elif path == "/api/layers/remove":
+                    body = self._read_json()
+                    ok = engine.remove_layer(int(body.get("id", -1)))
+                    self._json({"removed": ok})
+                elif path == "/api/layers/update":
+                    body = self._read_json()
+                    layer = engine.update_layer(int(body.get("id", -1)),
+                                                body)
+                    if layer is None:
+                        self._send_error_json(404, "Layer nicht gefunden")
+                    else:
+                        self._json({"layer": engine._layer_dict(layer)})
+                elif path == "/api/master":
+                    body = self._read_json()
+                    engine.set_master(float(body.get("intensity",
+                                                     body.get("value", 1.0))))
+                    self._json(server._status())
+                elif path == "/api/blackout":
+                    body = self._read_json()
+                    engine.set_blackout(bool(body.get("on", False)))
+                    self._json(server._status())
+                elif path == "/api/playback":
+                    body = self._read_json()
+                    engine.set_playback(bool(body.get("playing", True)))
+                    self._json(server._status())
+                elif path == "/api/retrigger":
+                    engine.retrigger()
+                    self._json({"ok": True})
+                elif path == "/api/settings":
+                    self._post_settings()
+                else:
+                    self._send_error_json(404, "nicht gefunden")
+
+            # ---------- Upload ----------
+
+            def _upload(self):
+                length = int(self.headers.get("Content-Length", "0"))
+                raw_name = (self.headers.get("X-Filename")
+                            or "upload" + ".bin")
+                name = urllib.parse.unquote(raw_name)
+                final, err = library.save_stream(name, self.rfile, length)
+                if err is not None:
+                    self._send_error_json(400, err)
+                    return
+                self._json({"saved": final})
+
+            # ---------- Settings ----------
+
+            def _post_settings(self):
+                body = self._read_json()
+                normalized, err = cfgmod.validate(body)
+                if err is not None:
+                    self._send_error_json(400, err)
+                    return
+                old_port = settings["web"]["port"]
+                old_fs = settings["output"]["fullscreen"]
+                # Struktur-Aenderungen anwenden
+                settings.clear()
+                settings.update(normalized)
+                engine.library.settings = settings
+                artnet.settings = settings
+                cfgmod.save(root, settings)
+                # Engine mit neuen Preview-Parametern neu bauen
+                engine.rebuild()
+                # Art-Net neu starten (Port/Universes evtl. geaendert)
+                artnet.restart()
+                restarted_web = settings["web"]["port"] != old_port
+                fullscreen_changed = settings["output"]["fullscreen"] != old_fs
+                self._json({"saved": True,
+                            "web_restarts": restarted_web,
+                            "fullscreen_changed": fullscreen_changed,
+                            "hint": ("Web-Port geaendert: Seite unter neuem "
+                                     "Port neu oeffnen")
+                            if restarted_web else None})
+
+            # ---------- Ausgabe-Helfer ----------
+
+            def _read_json(self) -> dict:
+                try:
+                    length = int(self.headers.get("Content-Length", "0"))
+                    return json.loads(self.rfile.read(length) or b"{}")
+                except (ValueError, OSError):
+                    return {}
+
+            def _send_error_json(self, code, message):
+                self._json({"error": str(message)}, code=code)
+
+            def _json(self, data, code=200):
+                body = json.dumps(data).encode("utf-8")
+                self.send_response(code)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+            def _send_html(self):
+                html = HTML_UI.encode("utf-8")
+                self.send_response(200)
+                self.send_header("Content-Type",
+                                 "text/html; charset=utf-8")
+                self.send_header("Content-Length", str(len(html)))
+                self.end_headers()
+                self.wfile.write(html)
+
+            def _send_file(self, f, ctype, download_name=None):
+                if f is None or not f.is_file():
+                    self._send_error_json(404, "Datei nicht gefunden")
+                    return
+                try:
+                    data = f.read_bytes()
+                except OSError:
+                    self._send_error_json(500, "Lesefehler")
+                    return
+                self.send_response(200)
+                self.send_header("Content-Type", ctype)
+                self.send_header("Content-Length", str(len(data)))
+                if download_name:
+                    self.send_header(
+                        "Content-Disposition",
+                        "inline; filename*=UTF-8''"
+                        + urllib.parse.quote(download_name))
+                self.end_headers()
+                self.wfile.write(data)
+
+            def _stream(self):
+                self.send_response(200)
+                self.send_header(
+                    "Content-Type",
+                    "multipart/x-mixed-replace; boundary=frame")
+                self.send_header("Cache-Control", "no-cache")
+                self.end_headers()
+                try:
+                    while server.running:
+                        jpeg = engine.current_jpeg
+                        if jpeg:
+                            self.wfile.write(b"--frame\r\n")
+                            self.wfile.write(
+                                b"Content-Type: image/jpeg\r\n")
+                            self.wfile.write(
+                                (f"Content-Length: {len(jpeg)}\r\n\r\n")
+                                .encode("ascii"))
+                            self.wfile.write(jpeg)
+                            self.wfile.write(b"\r\n")
+                        time.sleep(1.0 / max(1, int(
+                            settings["preview"]["fps"])))
+                except (BrokenPipeError, ConnectionResetError):
+                    pass
+
+            def log_message(self, fmt, *args):
+                pass
+
+        return Handler
+
+    def _status(self) -> dict:
+        st = self.engine.status()
+        st["media_count"] = self.library.count()
+        st["artnet"] = self.artnet.monitor()
+        return st

hms_app/setup.py

@@ -0,0 +1,181 @@
+"""Bootstrap, Setup-Skripte für Windows/Linux, Einstellungs-Dialog."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+LINUX_PKGS = [
+    "gstreamer1.0-tools", "gstreamer1.0-plugins-base",
+    "gstreamer1.0-plugins-good", "gstreamer1.0-plugins-bad",
+    "gstreamer1.0-plugins-ugly", "gstreamer1.0-libav",
+    "python3-gst-1.0", "gir1.2-gst-1.0", "python3-tk",
+]
+
+
+def check_and_install_dependencies() -> bool:
+    """Prüft GStreamer; installiert bei Bedarf (Linux) bzw. lädt MSI (Windows)."""
+    print("[Bootstrap] Prüfe GStreamer...")
+    try:
+        import gi  # noqa: F401
+        gi.require_version("Gst", "1.0")
+        from gi.repository import Gst as _Gst
+        _Gst.init(None)
+        print(f"[Bootstrap] GStreamer {_Gst.version_string()} OK")
+        return True
+    except (ImportError, ValueError):
+        pass
+
+    if sys.platform == "linux":
+        print("[Bootstrap] Installiere GStreamer (sudo apt-get)...")
+        try:
+            subprocess.run(["sudo", "apt-get", "update", "-qq"],
+                           check=True, timeout=180)
+            subprocess.run(
+                ["sudo", "apt-get", "install", "-y", "-qq"] + LINUX_PKGS,
+                check=True, timeout=600)
+            print("[Bootstrap] GStreamer installiert. Programm neu starten.")
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired,
+                FileNotFoundError):
+            print("[Bootstrap] Manuell installieren:")
+            print("  sudo apt-get install " + " ".join(LINUX_PKGS))
+        return False
+
+    if sys.platform == "win32":
+        url = ("https://gstreamer.freedesktop.org/data/pkg/windows/"
+               "1.28.4/msvc/"
+               "gstreamer-1.0-msvc-x86_64-1.28.4.msi")
+        msi = Path.home() / "Downloads" / "gstreamer-1.0-msvc-x86_64.msi"
+        try:
+            import urllib.request
+            if not msi.exists():
+                print(f"[Bootstrap] Lade {url}")
+                urllib.request.urlretrieve(url, msi)
+            subprocess.run(["msiexec", "/i", str(msi), "/quiet",
+                            "ADDLOCAL=ALL"], check=False)
+            print("[Bootstrap] GStreamer-MSI gestartet. "
+                  "Nach Installation neu starten.")
+        except Exception as e:  # noqa: BLE001
+            print(f"[Bootstrap] Download-Fehler: {e}")
+            print(f"[Bootstrap] Manuell installieren: {url}")
+        return False
+
+    return False
+
+
+WINDOWS_SETUP = r'''# HMS MediaEngine - Windows Setup (einmalig ausfuehren)
+$ErrorActionPreference = "Stop"
+Write-Host "=== HMS MediaEngine Windows Setup ===" -ForegroundColor Cyan
+
+$isAdmin = ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+if (-not $isAdmin) {
+  Write-Host "Als Administrator ausfuehren (Rechtsklick -> Als Administrator ausfuehren)" -ForegroundColor Red
+  exit 1
+}
+
+Write-Host "[1/2] GStreamer 1.28.4 MSVC..." -ForegroundColor Yellow
+$gstRoot = [Environment]::GetEnvironmentVariable("GSTREAMER_1_0_ROOT_MSVC_X86_64", "Machine")
+if (-not $gstRoot) {
+  $url = "https://gstreamer.freedesktop.org/data/pkg/windows/1.28.4/msvc/gstreamer-1.0-msvc-x86_64-1.28.4.msi"
+  $msi = "$env:TEMP\gstreamer.msi"
+  Invoke-WebRequest -Uri $url -OutFile $msi
+  Start-Process msiexec.exe -ArgumentList "/i `"$msi`" /quiet ADDLOCAL=ALL" -Wait
+  Write-Host "  GStreamer installiert"
+} else { Write-Host "  bereits vorhanden" }
+
+Write-Host "[2/2] Python 3.13 (falls fehlt) mit tkinter..." -ForegroundColor Yellow
+$py = Get-Command python -ErrorAction SilentlyContinue
+if (-not $py) {
+  $pyUrl = "https://www.python.org/ftp/python/3.13.2/python-3.13.2-amd64.exe"
+  $exe = "$env:TEMP\python-installer.exe"
+  Invoke-WebRequest -Uri $pyUrl -OutFile $exe
+  Start-Process $exe -ArgumentList "/quiet InstallAllUsers=1 PrependPath=1 Include_tcltk=1" -Wait
+  Write-Host "  Python installiert"
+} else { Write-Host "  bereits vorhanden" }
+
+$env:Path = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";$env:Path"
+Write-Host ""
+Write-Host "=== Fertig ===" -ForegroundColor Green
+Write-Host "Start:  python run.py"
+Write-Host "Dialog: python run.py --setup"
+Write-Host "Media-Verwaltung, Layer und Einstellungen: Web-UI im Browser"
+'''
+
+LINUX_SETUP = r'''#!/bin/bash
+# HMS MediaEngine - Linux Setup (einmalig ausfuehren)
+set -e
+echo "=== HMS MediaEngine Linux Setup ==="
+if command -v apt-get >/dev/null; then
+  sudo apt-get update -qq
+  sudo apt-get install -y -qq gstreamer1.0-tools gstreamer1.0-plugins-base \
+    gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly \
+    gstreamer1.0-libav python3-gst-1.0 gir1.2-gst-1.0 python3-tk xvfb
+elif command -v dnf >/dev/null; then
+  sudo dnf install -y gstreamer1 gstreamer1-plugins-base gstreamer1-plugins-good \
+    gstreamer1-plugins-bad-free gstreamer1-plugins-ugly gstreamer1-libav \
+    python3-gobject python3-tkinter
+fi
+echo "=== Fertig ==="
+echo "Start: python3 run.py"
+echo "Media-Verwaltung, Layer und Einstellungen: Web-UI im Browser"
+'''
+
+
+def generate_setup_scripts(root: Path) -> None:
+    p1 = root / "setup_windows.ps1"
+    p1.write_text(WINDOWS_SETUP, encoding="utf-8")
+    p2 = root / "setup_linux.sh"
+    p2.write_text(LINUX_SETUP, encoding="utf-8")
+    p2.chmod(0o755)
+    print(f"Erzeugt: {p1}")
+    print(f"Erzeugt: {p2}")
+
+
+def run_setup(settings: dict) -> dict:
+    """Nativer Dialog für Port/Fullscreen; Medien-Verwaltung bleibt im Web."""
+    result = {"port": int(settings["web"]["port"]),
+              "fullscreen": bool(settings["output"]["fullscreen"])}
+    try:
+        import tkinter as tk
+        from tkinter import ttk
+    except ImportError:
+        print("tkinter nicht verfügbar (Linux: apt install python3-tk).")
+        return result
+
+    root = tk.Tk()
+    root.title("HMS MediaEngine – Einstellungen")
+    root.geometry("440x240")
+    root.configure(bg="#16181d")
+    style = ttk.Style(root)
+    style.theme_use("clam")
+    style.configure("TLabel", background="#16181d", foreground="#c8ccd4")
+    main = ttk.Frame(root, padding=18)
+    main.pack(fill="both", expand=True)
+    ttk.Label(main, text="HMS MediaEngine",
+              font=("System", 15, "bold")).pack(pady=(0, 2))
+    ttk.Label(main, text="Grundeinstellungen",
+              foreground="#8a8f9a").pack(pady=(0, 12))
+
+    row = ttk.Frame(main)
+    row.pack(fill="x", pady=4)
+    ttk.Label(row, text="Web-UI Port:").pack(side="left")
+    port_var = tk.StringVar(value=str(result["port"]))
+    ttk.Entry(row, textvariable=port_var, width=7).pack(
+        side="left", padx=8)
+    fs_var = tk.BooleanVar(value=result["fullscreen"])
+    ttk.Checkbutton(row, text="Fullscreen-Output",
+                    variable=fs_var).pack(side="left", padx=10)
+
+    def go():
+        try:
+            result["port"] = int(port_var.get() or 8080)
+        except ValueError:
+            pass
+        result["fullscreen"] = bool(fs_var.get())
+        root.destroy()
+
+    ttk.Button(main, text="Starten", command=go).pack(
+        fill="x", pady=(14, 0), ipady=6)
+    root.mainloop()
+    return result

hms_app/ui.py

@@ -0,0 +1,259 @@
+"""Web-UI (Single-Page): Tabs Live, Medien (Upload), Layer, Einstellungen."""
+
+HTML_UI = r'''<!DOCTYPE html>
+<html lang="de">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>HMS MediaEngine</title>
+<style>
+:root{--bg:#0d0f12;--pan:#16181d;--pan2:#12141a;--line:#262a33;--tx:#c8ccd4;--dim:#8a8f9a;--acc:#4a90d9;--ok:#3fa34d;--err:#ff7a7a}
+*{margin:0;padding:0;box-sizing:border-box}
+body{background:var(--bg);color:var(--tx);font:13px/1.45 system-ui,sans-serif;height:100vh;display:flex;flex-direction:column}
+header{background:var(--pan);padding:8px 16px;display:flex;align-items:center;gap:12px;border-bottom:1px solid var(--line)}
+h1{font-size:14px;color:#e8eaee;margin-right:10px}
+.badge{font-size:11px;padding:2px 8px;border-radius:3px;background:#233042;color:#7ab8ff}
+.badge.err{background:#3a2020;color:var(--err)}
+#tabbar{display:flex;gap:2px;margin-left:20px}
+#tabbar button{background:none;border:none;color:var(--dim);padding:6px 12px;font-size:12px;cursor:pointer;border-bottom:2px solid transparent}
+#tabbar button.on{color:#e8eaee;border-bottom-color:var(--acc)}
+main{flex:1;overflow:hidden}
+.page{display:none;height:100%;overflow:auto;padding:16px}
+.page.on{display:block}
+#page-live{display:none;height:100%}#page-live.on{display:flex;gap:16px}
+#live-left{flex:1;display:flex;align-items:center;justify-content:center;min-width:0}
+.preview{max-width:100%;max-height:calc(100vh - 120px);border:1px solid var(--line);border-radius:4px;background:#000;overflow:hidden}
+.preview img{display:block;width:100%;height:auto}
+#live-right{width:320px;background:var(--pan2);border:1px solid var(--line);border-radius:4px;padding:12px;overflow-y:auto}
+h2{font-size:11px;text-transform:uppercase;letter-spacing:.08em;color:var(--dim);margin:12px 0 6px}
+h2:first-child{margin-top:0}
+.ctl{margin-bottom:8px}
+.ctl label{display:flex;justify-content:space-between;font-size:12px;margin-bottom:2px}
+input[type=range]{width:100%;accent-color:var(--acc)}
+input[type=number],input[type=text],select{background:#0d0f12;color:var(--tx);border:1px solid var(--line);border-radius:3px;padding:4px 6px;font-size:12px;width:90px}
+input[type=checkbox]{accent-color:var(--acc)}
+.row{display:flex;gap:6px;margin-bottom:8px}
+button{background:#262a33;color:var(--tx);border:1px solid #333842;border-radius:4px;padding:6px 10px;font-size:12px;cursor:pointer}
+button:hover{background:#333842}button.danger{border-color:#5a2a2a;color:#ff9a9a}button.acc{background:#1d3a5f;border-color:var(--acc)}
+table{width:100%;border-collapse:collapse;font-size:12px;margin:6px 0}
+td,th{padding:4px 6px;border-bottom:1px solid #21252d;text-align:left}th{color:var(--dim);font-weight:400}
+.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));gap:10px}
+.card{background:var(--pan2);border:1px solid var(--line);border-radius:4px;padding:6px;text-align:center}
+.card img{width:100%;aspect-ratio:16/9;object-fit:cover;border-radius:3px;background:#000;cursor:pointer}
+.card .nm{font-size:11px;margin:4px 0;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.card .meta{font-size:10px;color:var(--dim)}
+.card .btns{display:flex;gap:4px;margin-top:4px}
+.card .btns button{flex:1;padding:3px 0;font-size:11px}
+#drop{border:2px dashed var(--line);border-radius:6px;padding:22px;text-align:center;color:var(--dim);cursor:pointer;margin-bottom:14px}
+#drop.hot{border-color:var(--acc);color:#7ab8ff}
+.setgrp{background:var(--pan2);border:1px solid var(--line);border-radius:4px;padding:12px;margin-bottom:12px}
+.setgrp h3{font-size:12px;color:#e8eaee;margin-bottom:8px}
+.frow{display:flex;align-items:center;gap:8px;margin-bottom:6px;font-size:12px}
+.frow label{width:210px;color:var(--dim)}
+.frow .hint{color:#5a5f6a;font-size:11px}
+footer{background:var(--pan);padding:5px 16px;font-size:11px;color:var(--dim);border-top:1px solid var(--line);display:flex;gap:16px}
+.fps{color:var(--ok);font-weight:600}
+#toast{position:fixed;bottom:44px;right:16px;background:#1d3a5f;color:#dbe9ff;border:1px solid var(--acc);border-radius:4px;padding:8px 14px;font-size:12px;display:none;max-width:420px}
+#toast.err{background:#3a2020;border-color:#5a2a2a;color:#ffb0b0}
+.ll{display:flex;align-items:center;gap:6px;margin-bottom:6px;padding:4px;border-radius:3px;background:#0d0f12}
+.ll input[type=range]{flex:1}
+.ll .nm{width:110px;font-size:11px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.ll .val{width:34px;text-align:right;font-size:11px;color:var(--dim)}
+</style>
+</head>
+<body>
+<header>
+ <h1>HMS MediaEngine</h1>
+ <span class="badge" id="b-run">–</span>
+ <span class="badge" id="b-dmx">Art-Net: …</span>
+ <div id="tabbar">
+  <button data-p="live" class="on">Live</button>
+  <button data-p="media">Medien</button>
+  <button data-p="layers">Layer</button>
+  <button data-p="settings">Einstellungen</button>
+ </div>
+</header>
+<main>
+ <div id="page-live" class="page on">
+  <div id="live-left"><div class="preview"><img src="/stream.mjpg" id="pv"></div></div>
+  <div id="live-right">
+   <h2>Master</h2>
+   <div class="ctl"><label>Intensität <span id="mv">100%</span></label>
+    <input type="range" id="master" min="0" max="100" value="100"></div>
+   <div class="row">
+    <button onclick="api('playback',{playing:true})">Play</button>
+    <button onclick="api('playback',{playing:false})">Pause</button>
+    <button onclick="api('retrigger',{})">Restart</button>
+    <button class="danger" id="blk">BLK</button>
+   </div>
+   <h2>Layer (Schnellzugriff)</h2>
+   <div id="quick"></div>
+   <h2>Diagnose</h2>
+   <table><tbody>
+    <tr><th>Frames</th><td id="d-frames">–</td></tr>
+    <tr><th>DMX-Pakete</th><td id="d-pkts">–</td></tr>
+    <tr><th>DMX angenommen</th><td id="d-acc">–</td></tr>
+    <tr><th>Medien</th><td id="d-media">–</td></tr>
+    <tr><th>Fehler</th><td id="d-err">–</td></tr>
+   </tbody></table>
+  </div>
+ </div>
+
+ <div id="page-media" class="page">
+  <div id="drop">📄 Dateien hierher ziehen oder klicken zum Hochladen<br><small>Videos: mp4, mkv, avi, mov, webm · Bilder: jpg, png, bmp</small></div>
+  <input type="file" id="file" multiple accept=".mp4,.m4v,.avi,.mkv,.mov,.webm,.jpg,.jpeg,.png,.bmp" style="display:none">
+  <div id="upbar" style="display:none;margin-bottom:10px"><div id="uptext" style="font-size:12px;color:var(--dim)"></div><progress id="uprog" style="width:100%"></progress></div>
+  <div class="grid" id="mgrid"></div>
+ </div>
+
+ <div id="page-layers" class="page">
+  <div class="row"><button class="acc" onclick="location.hash='#media';showTab('media')">+ Medien hinzufügen</button>
+   <span style="color:var(--dim);font-size:11px;align-self:center">Aktive Layer bearbeiten:</span></div>
+  <div id="ledit"></div>
+ </div>
+
+ <div id="page-settings" class="page">
+  <div class="setgrp"><h3>Web-UI</h3>
+   <div class="frow"><label>Port</label><input type="number" id="s-web-port"></div>
+   <div class="frow"><label>Bind-Adresse</label><input type="text" id="s-web-bind" style="width:140px"><span class="hint">0.0.0.0 = alle Interfaces</span></div>
+  </div>
+  <div class="setgrp"><h3>Preview</h3>
+   <div class="frow"><label>Breite</label><input type="number" id="s-preview-width"> × <input type="number" id="s-preview-height"> px</div>
+   <div class="frow"><label>FPS</label><input type="number" id="s-preview-fps"></div>
+   <div class="frow"><label>JPEG-Qualität</label><input type="number" id="s-preview-q"></div>
+  </div>
+  <div class="setgrp"><h3>Art-Net (DMX)</h3>
+   <div class="frow"><label>Aktiviert</label><input type="checkbox" id="s-artnet-enabled"></div>
+   <div class="frow"><label>UDP-Port</label><input type="number" id="s-artnet-port"><span class="hint">Standard 6454</span></div>
+   <div class="frow"><label>Universes</label><input type="text" id="s-artnet-universes" style="width:200px"><span class="hint">z. B. 0,1,2</span></div>
+   <div class="frow"><label>Kanal Master</label><input type="number" id="s-artnet-master" min="1" max="512"></div>
+   <div class="frow"><label>Kanal Layer (Start)</label><input type="number" id="s-artnet-layer" min="1" max="512"><span class="hint">je +1 pro Layer</span></div>
+   <div class="frow"><label>Kanal Playback</label><input type="number" id="s-artnet-playback" min="1" max="512"></div>
+   <div class="frow"><label>Kanal Retrigger</label><input type="number" id="s-artnet-retrigger" min="1" max="512"></div>
+   <div class="frow"><label>Kanal Blackout</label><input type="number" id="s-artnet-blackout" min="1" max="512"></div>
+   <div class="frow"><label>Signalverlust</label><select id="s-artnet-policy"><option value="hold">Letzten Zustand halten</option><option value="fade_black">Auf schwarz fallen</option></select>
+   <div class="frow"><label>Timeout Signalverlust</label><input type="number" id="s-artnet-timeout"> s</div>
+  </div>
+  <div class="setgrp"><h3>Engine</h3>
+   <div class="frow"><label>Max. Layer</label><input type="number" id="s-engine-max"></div>
+   <div class="frow"><label>Loop als Standard</label><input type="checkbox" id="s-engine-loop"></div>
+   <div class="frow"><label>Fullscreen-Ausgabe</label><input type="checkbox" id="s-output-fs"><span class="hint">Windows: D3D11 · Linux: autovideosink</span></div>
+  </div>
+  <div class="setgrp"><h3>Medien</h3>
+   <div class="frow"><label>Ordnername</label><input type="text" id="s-media-dir" style="width:140px"></div>
+   <div class="frow"><label>Max. Upload</label><input type="number" id="s-media-max"> MB</div>
+  </div>
+  <button class="acc" style="padding:8px 20px" onclick="saveSettings()">Speichern &amp; Anwenden</button>
+  <span id="setmsg" style="margin-left:10px;color:var(--ok)"></span>
+ </div>
+</main>
+<footer><span class="fps" id="fps">–</span> fps · <span id="f-frames">–</span> Frames · MJPEG-Preview · REST /api/status</footer>
+<div id="toast"></div>
+<script>
+'use strict';
+const $=id=>document.getElementById(id);
+let lastStatus=null;
+
+function toast(msg,err){const t=$('toast');t.textContent=msg;t.className=err?'err':'';t.style.display='block';clearTimeout(t._h);t._h=setTimeout(()=>t.style.display='none',3500)}
+async function api(path,body){try{const r=await fetch('/api/'+path,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body||{})});const d=await r.json();if(!r.ok)toast(d.error||'Fehler',true);return d}catch(e){toast('Netzwerkfehler',true);return{}}}
+
+// Tabs
+document.querySelectorAll('#tabbar button').forEach(b=>b.onclick=()=>showTab(b.dataset.p));
+function showTab(p){document.querySelectorAll('.page').forEach(x=>x.classList.remove('on'));$('page-'+p).classList.add('on');document.querySelectorAll('#tabbar button').forEach(x=>x.classList.toggle('on',x.dataset.p===p));if(p==='media')loadMedia();if(p==='settings')loadSettings();}
+
+// Live-Steuerung
+$('master').oninput=e=>{api('master',{intensity:e.target.value/100});$('mv').textContent=e.target.value+'%'};
+$('blk').onclick=async()=>{await api('blackout',{on:true});setTimeout(()=>api('blackout',{on:false}),500)};
+
+// FPS
+let fc=0,fpsC=0,last=performance.now();
+$('pv').onload=()=>{fc++;fpsC++;const n=performance.now();if(n-last>1000){$('fps').textContent=fpsC;fpsC=0;last=n}$('f-frames').textContent=fc};
+
+// Status-Poll
+async function poll(){try{const s=await(await fetch('/api/status')).json();lastStatus=s;
+ $('b-run').textContent=s.running?'läuft':'gestoppt';$('b-run').className='badge'+(s.running?'':' err');
+ const a=s.artnet||{},st=a.stats||{};
+ $('b-dmx').textContent=a.enabled?('Art-Net: '+st.packets+' Pkts'):'Art-Net: aus';
+ $('d-frames').textContent=s.frames_rendered;$('d-pkts').textContent=st.packets||0;
+ $('d-acc').textContent=st.accepted||0;$('d-media').textContent=s.media_count??'–';
+ $('d-err').textContent=s.error||'–';
+ if(document.activeElement!==$('master')){$('master').value=s.master*100;$('mv').textContent=Math.round(s.master*100)+'%'}
+ renderQuick(s.layers||[]);renderLayerEdit(s.layers||[]);
+}catch(e){}setTimeout(poll,1000)}
+
+function renderQuick(ls){const q=$('quick');
+ if(q.childElementCount!==ls.length){q.innerHTML=ls.map(L=>`<div class="ll"><span class="nm" title="${L.name}">${L.id}: ${L.name}</span><input type="range" min="0" max="100" value="${L.alpha*100}" oninput="api('layers/update',{id:${L.id},alpha:this.value/100});this.nextElementSibling.textContent=this.value+'%'"><span class="val">${Math.round(L.alpha*100)}%</span></div>`).join('')}
+ else{ls.forEach((L,i)=>{const r=q.children[i].children[1];if(document.activeElement!==r)r.value=L.alpha*100;q.children[i].children[2].textContent=Math.round(L.alpha*100)+'%'})}}
+
+function renderLayerEdit(ls){const e=$('ledit');
+ if(e.dataset.n!=String(ls.length)){e.dataset.n=ls.length;
+ e.innerHTML=ls.map(L=>`<div class="setgrp"><h3>#${L.id} ${L.name} <button class="danger" style="float:right" onclick="api('layers/remove',{id:${L.id}})">Entfernen</button></h3>
+  <div class="frow"><label>Alpha</label><input type="range" id="la${L.id}" min="0" max="100" value="${L.alpha*100}" oninput="api('layers/update',{id:${L.id},alpha:this.value/100})"></div>
+  <div class="frow"><label>Position X</label><input type="number" id="lx${L.id}" value="${L.x}" onchange="api('layers/update',{id:${L.id},x:this.value})"> Y <input type="number" id="ly${L.id}" value="${L.y}" onchange="api('layers/update',{id:${L.id},y:this.value})"></div>
+  <div class="frow"><label>Größe</label><input type="number" id="lw${L.id}" value="${L.width}" onchange="api('layers/update',{id:${L.id},width:this.value})"> × <input type="number" id="lh${L.id}" value="${L.height}" onchange="api('layers/update',{id:${L.id},height:this.value})"> px</div>
+  <div class="frow"><label>Z-Order</label><input type="number" id="lz${L.id}" min="0" max="15" value="${L.z}" onchange="api('layers/update',{id:${L.id},z:this.value})"></div>
+ </div>`).join('')||'<p style="color:var(--dim)">Keine aktiven Layer. Medien-Tab öffnen und Datei als Layer hinzufügen.</p>'}}
+
+// Medien
+async function loadMedia(){try{const d=await(await fetch('/api/media')).json();
+ $('mgrid').innerHTML=(d.items||[]).map(m=>`<div class="card">
+  <img src="/thumb/${encodeURIComponent(m.name)}" onerror="this.src='data:image/svg+xml,%3Csvg xmlns=%22http://www.w3.org/2000/svg%22 width=%22192%22 height=%22108%22%3E%3Crect fill=%22%230d0f12%22 width=%22192%22 height=%22108%22/%3E%3Ctext x=%2260%22 y=%2256%22 fill=%22%238a8f9a%22 font-size=%2213%22%3E${m.type==='video'?'🎬 Video':'🖼 Bild'}%3C/text%3E%3C/svg%3E'" onclick="window.open('/media/${encodeURIComponent(m.name)}')">
+  <div class="nm" title="${m.name}">${m.name}</div>
+  <div class="meta">${fmtSize(m.size)}${m.duration_s?' · '+m.duration_s+'s':''}</div>
+  <div class="btns"><button class="acc" onclick="addLayer('${m.name.replace(/'/g,"\\'")}')">Als Layer</button><button class="danger" onclick="delMedia('${m.name.replace(/'/g,"\\'")}')">✕</button></div>
+ </div>`).join('')||'<p style="color:var(--dim)">Noch keine Medien. Dateien oben hochladen.</p>'}catch(e){}}
+function fmtSize(b){if(b>1048576)return(b/1048576).toFixed(1)+' MB';if(b>1024)return(b/1024).toFixed(0)+' KB';return b+' B'}
+async function addLayer(name){const d=await api('layers/add',{name});if(d.layer){toast('Layer #'+d.layer.id+' hinzugefügt ('+name+')');showTab('live')}}
+async function delMedia(name){if(!confirm(name+' löschen?'))return;await api('media/delete',{name});loadMedia()}
+
+// Upload (Drag&Drop + Klick + Fortschritt)
+const drop=$('drop'),file=$('file');
+drop.onclick=()=>file.click();
+drop.ondragover=e=>{e.preventDefault();drop.classList.add('hot')};
+drop.ondragleave=()=>drop.classList.remove('hot');
+drop.ondrop=e=>{e.preventDefault();drop.classList.remove('hot');uploadFiles(e.dataTransfer.files)};
+file.onchange=()=>{uploadFiles(file.files);file.value=''};
+function uploadFiles(files){let i=0;
+ const next=()=>{if(i>=files.length){$('upbar').style.display='none';loadMedia();return}
+  const f=files[i++];upOne(f,()=>next())};next()}
+function upOne(f,done){
+ $('upbar').style.display='block';$('uptext').textContent='Lade '+f.name+' ('+fmtSize(f.size)+')…';$('uprog').value=0;
+ const xhr=new XMLHttpRequest();
+ xhr.open('POST','/api/media/upload');
+ xhr.setRequestHeader('X-Filename',encodeURIComponent(f.name));
+ xhr.upload.onprogress=e=>{if(e.lengthComputable)$('uprog').value=e.loaded/e.total};
+ xhr.onload=()=>{if(xhr.status===200){toast(f.name+' gespeichert')}else{let m='';try{m=JSON.parse(xhr.responseText).error}catch(e){}toast('Upload fehlgeschlagen: '+(m||xhr.status),true)}done()};
+ xhr.onerror=()=>{toast('Netzwerkfehler beim Upload',true);done()};
+ xhr.send(f);}
+
+// Settings
+async function loadSettings(){try{const s=await(await fetch('/api/settings')).json();
+ $('s-web-port').value=s.web.port;$('s-web-bind').value=s.web.bind;
+ $('s-preview-width').value=s.preview.width;$('s-preview-height').value=s.preview.height;$('s-preview-fps').value=s.preview.fps;$('s-preview-q').value=s.preview.jpeg_quality;
+ $('s-artnet-enabled').checked=s.artnet.enabled;$('s-artnet-port').value=s.artnet.listen_port;
+ $('s-artnet-universes').value=s.artnet.universes.join(',');
+ $('s-artnet-master').value=s.artnet.master_channel;$('s-artnet-layer').value=s.artnet.layer_start_channel;
+ $('s-artnet-playback').value=s.artnet.playback_channel;$('s-artnet-retrigger').value=s.artnet.retrigger_channel;$('s-artnet-blackout').value=s.artnet.blackout_channel;
+ $('s-artnet-policy').value=s.artnet.signal_loss_policy;$('s-artnet-timeout').value=s.artnet.signal_loss_timeout_s;
+ $('s-engine-max').value=s.engine.max_layers;$('s-engine-loop').checked=s.engine.loop_default;$('s-output-fs').checked=s.output.fullscreen;
+ $('s-media-dir').value=s.media.dir;$('s-media-max').value=s.media.max_upload_mb;
+}catch(e){}}
+async function saveSettings(){const body={
+ web:{port:+$('s-web-port').value,bind:$('s-web-bind').value},
+ preview:{width:+$('s-preview-width').value,height:+$('s-preview-height').value,fps:+$('s-preview-fps').value,jpeg_quality:+$('s-preview-q').value},
+ artnet:{enabled:$('s-artnet-enabled').checked,listen_port:+$('s-artnet-port').value,
+  universes:$('s-artnet-universes').value.split(',').map(x=>parseInt(x.trim())).filter(x=>!isNaN(x)),
+  master_channel:+$('s-artnet-master').value,layer_start_channel:+$('s-artnet-layer').value,
+  playback_channel:+$('s-artnet-playback').value,retrigger_channel:+$('s-artnet-retrigger').value,blackout_channel:+$('s-artnet-blackout').value,
+  signal_loss_policy:$('s-artnet-policy').value,signal_loss_timeout_s:+$('s-artnet-timeout').value},
+ engine:{max_layers:+$('s-engine-max').value,loop_default:$('s-engine-loop').checked},
+ output:{fullscreen:$('s-output-fs').checked},
+ media:{dir:$('s-media-dir').value,max_upload_mb:+$('s-media-max').value}};
+ const d=await api('settings',body);
+ if(d.saved){$('setmsg').textContent='Gespeichert ✓';setTimeout(()=>$('setmsg').textContent='',2500);
+  if(d.hint)toast(d.hint)}}
+
+poll();
+</script>
+</body>
+</html>'''