From 973f490b9f3e83a077e8be9ac1aceb6a8484bceb Mon Sep 17 00:00:00 2001
From: Thorsten <thorsten.seine@gmail.com>
Date: Thu, 12 Feb 2026 09:26:42 +0100
Subject: [PATCH] first commit

---
 README.md                          |  222 ++++++
 py_jellyfin_trickplay_generator.py | 1049 ++++++++++++++++++++++++++++
 settings.ini                       |   26 +
 3 files changed, 1297 insertions(+)
 create mode 100644 README.md
 create mode 100644 py_jellyfin_trickplay_generator.py
 create mode 100644 settings.ini

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..08bdaf5
--- /dev/null
+++ b/README.md
@@ -0,0 +1,222 @@
+# Jellyfin Trickplay Generator (Legacy Layout)
+
+Dieses Script erzeugt **Jellyfin-kompatible Trickplay-Tiles** im **Legacy-Layout** – also genauso, wie du es in deinem Medienordner beobachtet hast:
+
+```
+<VideoDatei>.trickplay/
+  640 - 10x10/
+    0.jpg
+    1.jpg
+    ...
+```
+
+✅ **Keine JSON-Datei** im Trickplay-Ordner (Legacy).  
+✅ **Parallelisierbar** (mehrere Medien gleichzeitig) – anders als Jellyfin intern.  
+✅ **Optional Hardware-Decode** via ffmpeg (`vaapi`, `qsv`, `cuda`, `d3d11va`, `amf`).  
+✅ **Resume/Incremental**: Generiert nur fehlende Auflösungen bzw. nur wenn Settings geändert wurden (per-Width Fingerprint).  
+✅ **Schöne Konsole** mit Fortschritt (optional via `rich`).
+
+---
+
+## Voraussetzungen
+
+### Python
+- Windows: `py --version`
+- Linux: `python3 --version`
+
+### ffmpeg + ffprobe
+Beide müssen verfügbar sein:
+
+```bash
+ffmpeg -version
+ffprobe -version
+```
+
+Wenn nicht im PATH, kannst du die Pfade in `settings.ini` setzen.
+
+### Python-Pakete
+Pflicht:
+```bash
+pip install pillow
+```
+
+Optional (für hübsche Fortschrittsbalken):
+```bash
+pip install rich
+```
+
+---
+
+## Installation (Windows Beispiel)
+
+```powershell
+cd "C:\Users\Thorsten\Documents\Scripte"
+py -m pip install pillow rich
+py .\py_jellyfin_trickplay_generator.py
+```
+
+---
+
+## Installation (Linux Beispiel)
+
+```bash
+cd /pfad/zum/script
+python3 -m pip install --user pillow rich
+python3 ./py_jellyfin_trickplay_generator.py
+```
+
+---
+
+## Konfiguration: `settings.ini`
+
+Beim ersten Start wird automatisch eine `settings.ini` im gleichen Ordner erstellt.
+
+Beispiel:
+
+```ini
+[input]
+paths =
+  L:\TV Serien\FSK 0
+  L:\Filme
+recursive = true
+
+[general]
+output = alongside
+out_dir =
+workers = 6
+replace = false
+keep_temp = false
+loglevel = error
+jpeg_quality = 90
+
+[trickplay]
+interval_ms = 10000
+widths = 320,640
+tile_cols = 10
+tile_rows = 10
+
+[ffmpeg]
+ffmpeg =
+ffprobe =
+hw = none
+hw_device =
+```
+
+### Erklärung wichtiger Optionen
+
+#### `[input]`
+- `paths`: Eine oder mehrere Wurzeln. Multi-line empfohlen.
+- `recursive`: `true` findet Medien rekursiv in Unterordnern.
+
+#### `[general]`
+- `workers`: Anzahl paralleler Prozesse (Medien parallel).
+- `replace`:
+  - `false`: Incremental/Resume (nur fehlende Widths / nur wenn Fingerprint nicht passt)
+  - `true`: Alles neu (löscht vorhandene Trickplay-Daten für die Datei)
+- `output`:
+  - `alongside` (Standard): direkt neben der Videodatei als `*.trickplay`
+  - `dir`: in einem zentralen `out_dir` (selten sinnvoll für Jellyfin Legacy)
+- `loglevel`: ffmpeg Log-Level (`error`, `warning`, `info`, ...)
+
+#### `[trickplay]`
+- `interval_ms`: Abstand zwischen Thumbnails (10000ms = alle 10 Sekunden)
+- `widths`: Zielbreiten, z.B. `640` oder `320,640,720`
+- `tile_cols`, `tile_rows`: Grid der Tile-Spritesheets (z.B. `10x10`)
+
+#### `[ffmpeg]`
+- `hw` (Hardware-Decode):
+  - `none` (Standard)
+  - `vaapi` (Linux Intel/AMD iGPU, /dev/dri/…)
+  - `qsv` (Intel QuickSync)
+  - `cuda` (NVIDIA)
+  - `d3d11va` (Windows: Intel/AMD/NVIDIA – Decode über D3D11)
+  - `amf` (AMD – intern ebenfalls d3d11va für Decode genutzt)
+- `hw_device`: z.B. `/dev/dri/renderD128` bei VAAPI
+
+---
+
+## CLI Nutzung (Overrides)
+
+CLI-Argumente überschreiben Werte aus der INI:
+
+```bash
+python3 py_jellyfin_trickplay_generator.py --workers 8 --widths 640 --interval-ms 10000 /pfad/zu/Medien
+```
+
+Rekursiv:
+```bash
+python3 py_jellyfin_trickplay_generator.py --recursive /pfad/zu/Serien
+```
+
+---
+
+## Fortschritt / Konsole
+
+Wenn `rich` installiert ist, zeigt das Script:
+
+- **Overall** (Gesamtfortschritt Dateien)
+- **Worker** pro Prozess (Stage: probe / extract / tile / skip)
+
+Wenn `rich` fehlt, gibt es einfache Textausgaben pro Datei.
+
+---
+
+## Resume / Incremental Build (Marker-Dateien)
+
+Damit man erkennt, ob ein Durchlauf sauber fertig wurde und um nur fehlende Dinge zu generieren, werden Marker-Dateien genutzt.
+
+### Root (pro Video)
+Im `*.trickplay` Root:
+
+- `.inprogress` → Job lief / wurde evtl. unterbrochen
+- `.complete` → Job komplett (für genau diese Job-Settings)
+- `.trickplay.job.json` → Job-Settings + Job-Fingerprint
+
+### Pro Width
+In jedem Width-Ordner (z.B. `640 - 10x10/`):
+
+- `.inprogress` → diese Width wurde gerade gebaut
+- `.complete` → diese Width ist vollständig
+- `.meta.json` → Width-Settings + Width-Fingerprint
+
+**Wichtig:** Der Skip passiert nur, wenn
+- Tiles existieren (`0.jpg` vorhanden),
+- `.complete` existiert,
+- und `.meta.json`-Fingerprint zu den aktuellen Settings passt.
+
+So kannst du z.B. später `widths = 320,640,720` einstellen und es wird nur 720 nachgezogen.
+
+---
+
+## Typische Probleme
+
+### `ffmpeg not found in PATH`
+- Windows: PowerShell neu öffnen nachdem ffmpeg installiert wurde
+- oder Pfade in `settings.ini` setzen:
+
+```ini
+[ffmpeg]
+ffmpeg = C:\Tools\ffmpeg\bin\ffmpeg.exe
+ffprobe = C:\Tools\ffmpeg\bin\ffprobe.exe
+```
+
+### `ModuleNotFoundError: No module named 'PIL'`
+```bash
+pip install pillow
+```
+
+### Windows: `python3` öffnet Microsoft Store
+Nutze:
+```powershell
+py script.py
+```
+
+---
+
+## Notes
+
+- Das Script implementiert das beobachtete Jellyfin **Legacy** Trickplay-Layout.
+- Wenn Jellyfin in deiner Installation irgendwann auf ein anderes Layout umstellt (mit JSON/Manifest),
+  müsste das Script entsprechend erweitert werden.
+
+---
\ No newline at end of file
diff --git a/py_jellyfin_trickplay_generator.py b/py_jellyfin_trickplay_generator.py
new file mode 100644
index 0000000..611780a
--- /dev/null
+++ b/py_jellyfin_trickplay_generator.py
@@ -0,0 +1,1049 @@
+#!/usr/bin/env python3
+# py_jellyfin_trickplay_generator.py
+#
+# Jellyfin-style (legacy) trickplay tiles:
+#   <video>.trickplay/<width> - <cols>x<rows>/<tileIndex>.jpg  (0-based)
+#   NO JSON from Jellyfin (legacy layout)
+#
+# Resume / incremental logic (replace=false):
+#   - per width folder has its own .meta.json + .complete
+#   - width is skipped only if (tiles exist) AND .complete exists AND fingerprint matches
+#   - root has .trickplay.job.json + .complete as convenience and for quick skip
+#
+# Progress UI:
+#   - Uses 'rich' if installed (overall + per worker)
+#   - Fallback to plain output
+#
+# Dependencies:
+#   - ffmpeg + ffprobe
+#   - pip install pillow
+#   - optional: pip install rich
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures as cf
+import configparser
+import hashlib
+import json
+import multiprocessing as mp
+import os
+import queue as queue_mod
+import shutil
+import struct
+import subprocess
+import sys
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Tuple
+
+from PIL import Image
+
+try:
+    from rich.console import Console, Group
+    from rich.live import Live
+    from rich.progress import (
+        Progress,
+        BarColumn,
+        TextColumn,
+        TimeElapsedColumn,
+        TimeRemainingColumn,
+    )
+
+    RICH_AVAILABLE = True
+except Exception:
+    RICH_AVAILABLE = False
+
+
+VIDEO_EXTS = {".mkv", ".mp4", ".m4v", ".avi", ".mov", ".ts", ".m2ts", ".webm"}
+
+DEFAULTS: Dict[str, Dict[str, str]] = {
+    "input": {
+        "paths": "",
+        "recursive": "false",
+    },
+    "general": {
+        "output": "alongside",  # alongside | dir
+        "out_dir": "",
+        "workers": str(max(1, (os.cpu_count() or 4) // 2)),
+        "replace": "false",
+        "keep_temp": "false",
+        "loglevel": "error",
+        "jpeg_quality": "90",
+    },
+    "trickplay": {
+        "interval_ms": "10000",
+        "widths": "640",
+        "tile_cols": "10",
+        "tile_rows": "10",
+    },
+    "ffmpeg": {
+        "ffmpeg": "",
+        "ffprobe": "",
+        "hw": "none",  # none|vaapi|qsv|cuda|d3d11va|amf
+        "hw_device": "",
+    },
+}
+
+
+@dataclass(frozen=True)
+class ProbeInfo:
+    duration_s: float
+    color_primaries: str
+    color_trc: str
+    colorspace: str
+    sar: str
+
+
+# ---------- small helpers ----------
+
+def short_path(p: str, max_len: int = 90) -> str:
+    if len(p) <= max_len:
+        return p
+    return "…" + p[-(max_len - 1):]
+
+
+def send_evt(q, **evt) -> None:
+    if q is None:
+        return
+    try:
+        q.put_nowait(evt)
+    except Exception:
+        pass
+
+
+def run_cmd(cmd: List[str], *, cwd: Optional[Path] = None) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        cmd,
+        cwd=str(cwd) if cwd else None,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        check=False,
+    )
+
+
+def which_or_fail(exe: str) -> str:
+    p = shutil.which(exe)
+    if not p:
+        raise FileNotFoundError(
+            f"'{exe}' not found in PATH. Install it or set it in settings.ini / via CLI."
+        )
+    return p
+
+
+def render_ini(cfg: configparser.ConfigParser) -> str:
+    out_lines: List[str] = []
+    for section in cfg.sections():
+        out_lines.append(f"[{section}]")
+        for k, v in cfg[section].items():
+            out_lines.append(f"{k} = {v}")
+        out_lines.append("")
+    return "\n".join(out_lines).strip() + "\n"
+
+
+def ensure_ini(path: Path) -> configparser.ConfigParser:
+    cfg = configparser.ConfigParser()
+    if path.exists():
+        cfg.read(path, encoding="utf-8")
+    else:
+        for section, kv in DEFAULTS.items():
+            cfg[section] = dict(kv)
+        path.write_text(render_ini(cfg), encoding="utf-8")
+        print(f"[INFO] Created default settings: {path}")
+
+    changed = False
+    for section, kv in DEFAULTS.items():
+        if section not in cfg:
+            cfg[section] = {}
+            changed = True
+        for k, v in kv.items():
+            if k not in cfg[section]:
+                cfg[section][k] = v
+                changed = True
+
+    if changed:
+        path.write_text(render_ini(cfg), encoding="utf-8")
+        print(f"[INFO] Updated settings with missing defaults: {path}")
+
+    return cfg
+
+
+def get_bool(cfg: configparser.ConfigParser, section: str, key: str, default: bool) -> bool:
+    try:
+        return cfg.getboolean(section, key, fallback=str(default))
+    except Exception:
+        return default
+
+
+def get_int(cfg: configparser.ConfigParser, section: str, key: str, default: int) -> int:
+    try:
+        return cfg.getint(section, key, fallback=str(default))
+    except Exception:
+        return default
+
+
+def get_str(cfg: configparser.ConfigParser, section: str, key: str, default: str) -> str:
+    try:
+        return cfg.get(section, key, fallback=default)
+    except Exception:
+        return default
+
+
+def parse_int_list(csv: str) -> List[int]:
+    vals: List[int] = []
+    for part in (csv or "").split(","):
+        part = part.strip()
+        if not part:
+            continue
+        vals.append(int(part))
+    return vals
+
+
+def parse_paths_value(v: str) -> List[str]:
+    if not v:
+        return []
+    raw_lines = [ln.strip() for ln in v.splitlines() if ln.strip()]
+    if len(raw_lines) > 1:
+        return raw_lines
+    one = raw_lines[0] if raw_lines else ""
+    parts: List[str] = []
+    for chunk in one.replace(";", ",").split(","):
+        s = chunk.strip()
+        if s:
+            parts.append(s)
+    return parts
+
+
+def atomic_write_text(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(text, encoding="utf-8")
+    tmp.replace(path)
+
+
+def atomic_write_json(path: Path, obj: dict) -> None:
+    atomic_write_text(path, json.dumps(obj, indent=2, ensure_ascii=False))
+
+
+def sha1_of_obj(obj: dict) -> str:
+    raw = json.dumps(obj, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha1(raw).hexdigest()
+
+
+# ---------- jellyfin-ish media probing / filters ----------
+
+def ffprobe_media(ffprobe: str, media_path: Path) -> ProbeInfo:
+    cmd = [
+        ffprobe,
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "format=duration:stream=color_primaries,color_transfer,colorspace,sample_aspect_ratio",
+        "-of",
+        "json",
+        str(media_path),
+    ]
+    cp = run_cmd(cmd)
+    if cp.returncode != 0:
+        raise RuntimeError(f"ffprobe failed for {media_path}\nSTDERR:\n{cp.stderr}")
+
+    data = json.loads(cp.stdout or "{}")
+    duration = 0.0
+    try:
+        duration = float(data.get("format", {}).get("duration", 0.0) or 0.0)
+    except Exception:
+        duration = 0.0
+
+    stream = (data.get("streams") or [{}])[0] or {}
+    prim = (stream.get("color_primaries") or "").strip() or "bt709"
+    trc = (stream.get("color_transfer") or "").strip() or "bt709"
+    csp = (stream.get("colorspace") or "").strip() or "bt709"
+
+    sar = (stream.get("sample_aspect_ratio") or "").strip() or "1:1"
+    if sar in ("0:1", "N/A", "unknown", ""):
+        sar = "1:1"
+
+    return ProbeInfo(duration_s=duration, color_primaries=prim, color_trc=trc, colorspace=csp, sar=sar)
+
+
+def jellyfin_like_fps_value(interval_ms: int) -> str:
+    interval_s = interval_ms / 1000.0
+    fps = 1.0 / interval_s if interval_s > 0 else 0.1
+    f32 = struct.unpack("!f", struct.pack("!f", fps))[0]
+    return f"{f32:.17g}"
+
+
+def build_scale_expr(target_width_px: int) -> str:
+    W = int(target_width_px)
+    return (
+        f"scale=trunc(min(max(iw\\,ih*(a*sar))\\,{W})/2)*2:"
+        f"trunc(ow/(a*sar)/2)*2"
+    )
+
+
+def hw_decode_args(hw: str, hw_device: Optional[str]) -> List[str]:
+    hw = (hw or "none").lower()
+    if hw == "none":
+        return []
+    if hw == "vaapi":
+        dev = hw_device or "/dev/dri/renderD128"
+        return [
+            "-init_hw_device",
+            f"vaapi=va:{dev}",
+            "-filter_hw_device",
+            "va",
+            "-hwaccel",
+            "vaapi",
+            "-hwaccel_output_format",
+            "vaapi",
+            "-noautoscale",
+        ]
+    if hw == "qsv":
+        return ["-hwaccel", "qsv", "-noautoscale"]
+    if hw == "cuda":
+        return ["-hwaccel", "cuda"]
+    if hw == "d3d11va":
+        return ["-hwaccel", "d3d11va"]
+    if hw == "amf":
+        return ["-hwaccel", "d3d11va"]
+    raise ValueError(f"Unknown hw='{hw}' (none|vaapi|qsv|cuda|d3d11va|amf)")
+
+
+def extract_thumbs(
+    ffmpeg: str,
+    media_path: Path,
+    out_dir: Path,
+    probe: ProbeInfo,
+    interval_ms: int,
+    width_px: int,
+    hw: str,
+    hw_device: Optional[str],
+    loglevel: str,
+) -> None:
+    fps_val = jellyfin_like_fps_value(interval_ms)
+    setparams = (
+        f"setparams=color_primaries={probe.color_primaries}:"
+        f"color_trc={probe.color_trc}:"
+        f"colorspace={probe.colorspace}"
+    )
+    scale = build_scale_expr(width_px)
+    vf = f"fps={fps_val},{setparams},{scale},format=yuv420p"
+    out_pattern = str(out_dir / "%08d.jpg")
+
+    cmd = [
+        ffmpeg,
+        "-hide_banner",
+        "-loglevel",
+        loglevel,
+        *hw_decode_args(hw, hw_device),
+        "-threads",
+        "1",
+        "-noautorotate",
+        "-i",
+        str(media_path),
+        "-an",
+        "-sn",
+        "-vf",
+        vf,
+        "-c:v",
+        "mjpeg",
+        "-qscale:v",
+        "4",
+        "-fps_mode",
+        "passthrough",
+        "-f",
+        "image2",
+        out_pattern,
+    ]
+    cp = run_cmd(cmd)
+    if cp.returncode != 0:
+        raise RuntimeError(
+            f"ffmpeg failed for {media_path} (width={width_px}, hw={hw})\n"
+            f"CMD:\n{' '.join(cmd)}\n\nSTDERR:\n{cp.stderr}"
+        )
+
+
+# ---------- tiling (legacy layout) + completeness markers ----------
+
+def chunked(seq: List[Path], n: int) -> Iterable[List[Path]]:
+    for i in range(0, len(seq), n):
+        yield seq[i : i + n]
+
+
+def width_dir(base_out: Path, width_px: int, tile_cols: int, tile_rows: int) -> Path:
+    return base_out / f"{width_px} - {tile_cols}x{tile_rows}"
+
+
+def width_meta_path(wdir: Path) -> Path:
+    return wdir / ".meta.json"
+
+
+def width_complete_path(wdir: Path) -> Path:
+    return wdir / ".complete"
+
+
+def width_inprogress_path(wdir: Path) -> Path:
+    return wdir / ".inprogress"
+
+
+def width_tiles_exist(wdir: Path) -> bool:
+    # at least 0.jpg exists
+    return (wdir / "0.jpg").is_file()
+
+
+def width_fingerprint(
+    *,
+    interval_ms: int,
+    width_px: int,
+    tile_cols: int,
+    tile_rows: int,
+    jpeg_quality: int,
+) -> str:
+    # include only settings that affect THIS width output
+    payload = {
+        "interval_ms": interval_ms,
+        "width_px": width_px,
+        "tile_cols": tile_cols,
+        "tile_rows": tile_rows,
+        "jpeg_quality": jpeg_quality,
+        "layout": "jellyfin_legacy",
+        "impl_version": 1,  # bump if we change algorithm (filenames, tiling, etc.)
+    }
+    return sha1_of_obj(payload)
+
+
+def is_width_complete_expected(
+    wdir: Path,
+    expected_fp: str,
+) -> bool:
+    if not width_complete_path(wdir).is_file():
+        return False
+    if not width_tiles_exist(wdir):
+        return False
+    mpth = width_meta_path(wdir)
+    if not mpth.is_file():
+        return False
+    try:
+        meta = json.loads(mpth.read_text(encoding="utf-8"))
+        return meta.get("fingerprint") == expected_fp
+    except Exception:
+        return False
+
+
+def mark_width_inprogress(wdir: Path, meta: dict) -> None:
+    wdir.mkdir(parents=True, exist_ok=True)
+    atomic_write_json(width_meta_path(wdir), meta)
+    atomic_write_text(width_inprogress_path(wdir), f"started={time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+    # if previous complete exists (from old run), remove to avoid lying
+    if width_complete_path(wdir).exists():
+        try:
+            width_complete_path(wdir).unlink()
+        except Exception:
+            pass
+
+
+def mark_width_complete(wdir: Path) -> None:
+    if width_inprogress_path(wdir).exists():
+        try:
+            width_inprogress_path(wdir).unlink()
+        except Exception:
+            pass
+    atomic_write_text(width_complete_path(wdir), "ok\n")
+
+
+def build_tiles_jellyfin_legacy_rebuild(
+    thumbs_dir: Path,
+    wdir: Path,
+    tile_cols: int,
+    tile_rows: int,
+    jpeg_quality: int,
+) -> None:
+    wdir.mkdir(parents=True, exist_ok=True)
+
+    # only remove old tiles, keep marker files (.meta.json/.inprogress/.complete)
+    for p in wdir.glob("*.jpg"):
+        try:
+            p.unlink()
+        except Exception:
+            pass
+
+    thumbs = sorted(thumbs_dir.glob("*.jpg"))
+    if not thumbs:
+        raise RuntimeError(f"No thumbs extracted into {thumbs_dir}")
+
+    with Image.open(thumbs[0]) as im0:
+        thumb_w, thumb_h = im0.size
+
+    per_tile = tile_cols * tile_rows
+    for tile_idx, group in enumerate(chunked(thumbs, per_tile)):  # 0-based
+        canvas = Image.new("RGB", (thumb_w * tile_cols, thumb_h * tile_rows))
+        for idx, img_path in enumerate(group):
+            r = idx // tile_cols
+            c = idx % tile_cols
+            with Image.open(img_path) as im:
+                if im.size != (thumb_w, thumb_h):
+                    im = im.resize((thumb_w, thumb_h))
+                canvas.paste(im, (c * thumb_w, r * thumb_h))
+        canvas.save(wdir / f"{tile_idx}.jpg", format="JPEG", quality=jpeg_quality, optimize=True)
+
+
+
+# ---------- root markers (job-level) ----------
+
+def job_meta_path(base_out: Path) -> Path:
+    return base_out / ".trickplay.job.json"
+
+
+def root_complete_path(base_out: Path) -> Path:
+    return base_out / ".complete"
+
+
+def root_inprogress_path(base_out: Path) -> Path:
+    return base_out / ".inprogress"
+
+
+def job_fingerprint(
+    *,
+    interval_ms: int,
+    widths: List[int],
+    tile_cols: int,
+    tile_rows: int,
+    jpeg_quality: int,
+) -> str:
+    payload = {
+        "interval_ms": interval_ms,
+        "widths": widths,
+        "tile_cols": tile_cols,
+        "tile_rows": tile_rows,
+        "jpeg_quality": jpeg_quality,
+        "layout": "jellyfin_legacy",
+        "impl_version": 1,
+    }
+    return sha1_of_obj(payload)
+
+
+def root_meta_matches(base_out: Path, expected_fp: str) -> bool:
+    mpth = job_meta_path(base_out)
+    if not mpth.is_file():
+        return False
+    try:
+        meta = json.loads(mpth.read_text(encoding="utf-8"))
+        return meta.get("fingerprint") == expected_fp
+    except Exception:
+        return False
+
+
+def mark_root_inprogress(base_out: Path, meta: dict) -> None:
+    base_out.mkdir(parents=True, exist_ok=True)
+    atomic_write_json(job_meta_path(base_out), meta)
+    atomic_write_text(root_inprogress_path(base_out), f"started={time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+    # remove stale complete if any
+    if root_complete_path(base_out).exists():
+        try:
+            root_complete_path(base_out).unlink()
+        except Exception:
+            pass
+
+
+def mark_root_complete(base_out: Path) -> None:
+    if root_inprogress_path(base_out).exists():
+        try:
+            root_inprogress_path(base_out).unlink()
+        except Exception:
+            pass
+    atomic_write_text(root_complete_path(base_out), "ok\n")
+
+
+# ---------- filesystem mapping ----------
+
+def media_output_base(media_path: Path) -> Path:
+    return media_path.with_suffix(media_path.suffix + ".trickplay")
+
+
+def hash_temp_name(media_path: Path) -> str:
+    return hashlib.sha1(str(media_path).encode("utf-8", "ignore")).hexdigest()
+
+
+def discover_media(paths: List[Path], recursive: bool) -> List[Path]:
+    found: List[Path] = []
+    for p in paths:
+        if p.is_file():
+            if p.suffix.lower() in VIDEO_EXTS:
+                found.append(p)
+        elif p.is_dir():
+            it = p.rglob("*") if recursive else p.glob("*")
+            for f in it:
+                if f.is_file() and f.suffix.lower() in VIDEO_EXTS:
+                    found.append(f)
+    return sorted(set(found))
+
+
+# ---------- worker task ----------
+
+def process_one_media(
+    media_path: Path,
+    ffmpeg: str,
+    ffprobe: str,
+    interval_ms: int,
+    widths: List[int],
+    tile_cols: int,
+    tile_rows: int,
+    output_mode: str,
+    out_dir: Optional[Path],
+    hw: str,
+    hw_device: Optional[str],
+    replace: bool,
+    keep_temp: bool,
+    loglevel: str,
+    jpeg_quality: int,
+    progress_q,
+) -> Tuple[str, bool, str]:
+    t0 = time.time()
+    pid = os.getpid()
+
+    units_total = 1 + (2 * len(widths))  # probe + (extract+tile) per width
+    units_done = 0
+    send_evt(progress_q, type="start", pid=pid, media=str(media_path), total=units_total, done=0, stage="start")
+
+    try:
+        probe = ffprobe_media(ffprobe, media_path)
+        units_done += 1
+        send_evt(progress_q, type="update", pid=pid, media=str(media_path), total=units_total, done=units_done, stage="probe")
+
+        # determine output root
+        if output_mode == "alongside":
+            base_out = media_output_base(media_path)
+        elif output_mode == "dir":
+            if not out_dir:
+                raise ValueError("output=dir requires out_dir")
+            base_out = out_dir / f"{media_path.stem}.trickplay"
+        else:
+            raise ValueError("output must be alongside|dir")
+
+        # job fingerprint (for root convenience marker)
+        job_fp = job_fingerprint(
+            interval_ms=interval_ms,
+            widths=widths,
+            tile_cols=tile_cols,
+            tile_rows=tile_rows,
+            jpeg_quality=jpeg_quality,
+        )
+        job_meta = {
+            "fingerprint": job_fp,
+            "media": str(media_path),
+            "interval_ms": interval_ms,
+            "widths": widths,
+            "tile_cols": tile_cols,
+            "tile_rows": tile_rows,
+            "jpeg_quality": jpeg_quality,
+            "layout": "jellyfin_legacy",
+            "impl_version": 1,
+        }
+
+        # replace=true: wipe root entirely
+        if replace and base_out.exists():
+            shutil.rmtree(base_out, ignore_errors=True)
+
+        base_out.mkdir(parents=True, exist_ok=True)
+
+        # fast skip: root says complete for this exact job
+        if (not replace) and root_complete_path(base_out).is_file() and root_meta_matches(base_out, job_fp):
+            send_evt(progress_q, type="done", pid=pid, media=str(media_path), total=units_total, done=units_total, stage="skip (job complete)")
+            dt = time.time() - t0
+            return (str(media_path), True, f"SKIPPED (job complete) in {dt:.1f}s")
+
+        # mark job started/inprogress (even if we will skip some widths)
+        mark_root_inprogress(base_out, job_meta)
+
+        tmp_root = Path(tempfile.gettempdir()) / "jellyfin-trickplay" / hash_temp_name(media_path)
+        if tmp_root.exists() and replace:
+            shutil.rmtree(tmp_root, ignore_errors=True)
+        tmp_root.mkdir(parents=True, exist_ok=True)
+
+        # build widths incrementally
+        for w in widths:
+            wdir = width_dir(base_out, w, tile_cols, tile_rows)
+
+            w_fp = width_fingerprint(
+                interval_ms=interval_ms,
+                width_px=w,
+                tile_cols=tile_cols,
+                tile_rows=tile_rows,
+                jpeg_quality=jpeg_quality,
+            )
+            w_meta = {
+                "fingerprint": w_fp,
+                "media": str(media_path),
+                "width_px": w,
+                "interval_ms": interval_ms,
+                "tile_cols": tile_cols,
+                "tile_rows": tile_rows,
+                "jpeg_quality": jpeg_quality,
+                "layout": "jellyfin_legacy",
+                "impl_version": 1,
+            }
+
+            # width skip if complete for expected fingerprint
+            if (not replace) and is_width_complete_expected(wdir, w_fp):
+                # keep progress moving: treat extract+tile as done
+                units_done += 2
+                send_evt(progress_q, type="update", pid=pid, media=str(media_path), total=units_total, done=units_done, stage=f"skip {w}px")
+                continue
+
+            # mark width in progress
+            mark_width_inprogress(wdir, w_meta)
+
+            # extract thumbs to temp
+            tmp_thumbs = tmp_root / f"thumbs_{w}"
+            if tmp_thumbs.exists():
+                shutil.rmtree(tmp_thumbs, ignore_errors=True)
+            tmp_thumbs.mkdir(parents=True, exist_ok=True)
+
+            extract_thumbs(
+                ffmpeg=ffmpeg,
+                media_path=media_path,
+                out_dir=tmp_thumbs,
+                probe=probe,
+                interval_ms=interval_ms,
+                width_px=w,
+                hw=hw,
+                hw_device=hw_device,
+                loglevel=loglevel,
+            )
+            units_done += 1
+            send_evt(progress_q, type="update", pid=pid, media=str(media_path), total=units_total, done=units_done, stage=f"extract {w}px")
+
+            # build tiles into width dir (rebuild width dir content)
+            build_tiles_jellyfin_legacy_rebuild(
+                thumbs_dir=tmp_thumbs,
+                wdir=wdir,
+                tile_cols=tile_cols,
+                tile_rows=tile_rows,
+                jpeg_quality=jpeg_quality,
+            )
+            units_done += 1
+            send_evt(progress_q, type="update", pid=pid, media=str(media_path), total=units_total, done=units_done, stage=f"tile {w}px")
+
+            mark_width_complete(wdir)
+
+        # cleanup temp
+        if not keep_temp:
+            shutil.rmtree(tmp_root, ignore_errors=True)
+
+        # final: only mark root complete if ALL widths are complete for their fingerprints
+        all_ok = True
+        for w in widths:
+            wdir = width_dir(base_out, w, tile_cols, tile_rows)
+            w_fp = width_fingerprint(
+                interval_ms=interval_ms,
+                width_px=w,
+                tile_cols=tile_cols,
+                tile_rows=tile_rows,
+                jpeg_quality=jpeg_quality,
+            )
+            if not is_width_complete_expected(wdir, w_fp):
+                all_ok = False
+                break
+
+        if all_ok:
+            mark_root_complete(base_out)
+
+        send_evt(progress_q, type="done", pid=pid, media=str(media_path), total=units_total, done=units_total, stage="done")
+        dt = time.time() - t0
+        return (str(media_path), True, f"OK in {dt:.1f}s")
+    except Exception as e:
+        send_evt(progress_q, type="error", pid=pid, media=str(media_path), total=units_total, done=units_done, stage="error", error=str(e))
+        return (str(media_path), False, str(e))
+
+
+# ---------- CLI parsing ----------
+
+def parse_args_with_ini(argv: List[str]) -> Tuple[argparse.Namespace, Path]:
+    pre = argparse.ArgumentParser(add_help=False)
+    pre.add_argument("--config", default="settings.ini", help="Path to settings.ini (default ./settings.ini)")
+    pre_ns, _ = pre.parse_known_args(argv)
+
+    config_path = Path(pre_ns.config).expanduser().resolve()
+    cfg = ensure_ini(config_path)
+
+    ini_paths = parse_paths_value(get_str(cfg, "input", "paths", ""))
+    ini_recursive = get_bool(cfg, "input", "recursive", False)
+
+    def_ini = {
+        "ini_paths": ini_paths,
+        "ini_recursive": ini_recursive,
+        "output": get_str(cfg, "general", "output", "alongside"),
+        "out_dir": get_str(cfg, "general", "out_dir", ""),
+        "workers": get_int(cfg, "general", "workers", int(DEFAULTS["general"]["workers"])),
+        "replace": get_bool(cfg, "general", "replace", False),
+        "keep_temp": get_bool(cfg, "general", "keep_temp", False),
+        "loglevel": get_str(cfg, "general", "loglevel", "error"),
+        "jpeg_quality": get_int(cfg, "general", "jpeg_quality", 90),
+        "interval_ms": get_int(cfg, "trickplay", "interval_ms", 10000),
+        "widths": get_str(cfg, "trickplay", "widths", "640"),
+        "tile_cols": get_int(cfg, "trickplay", "tile_cols", 10),
+        "tile_rows": get_int(cfg, "trickplay", "tile_rows", 10),
+        "ffmpeg": get_str(cfg, "ffmpeg", "ffmpeg", ""),
+        "ffprobe": get_str(cfg, "ffmpeg", "ffprobe", ""),
+        "hw": get_str(cfg, "ffmpeg", "hw", "none"),
+        "hw_device": get_str(cfg, "ffmpeg", "hw_device", ""),
+    }
+
+    ap = argparse.ArgumentParser(
+        description="Generate Jellyfin legacy trickplay tiles (INI + CLI override).",
+    )
+    ap.add_argument("--config", default=str(config_path), help="Path to settings.ini")
+
+    ap.add_argument("paths", nargs="*", help="Media file(s) and/or folder(s). If empty, uses [input].paths from INI.")
+
+    rec_group = ap.add_mutually_exclusive_group()
+    rec_group.add_argument("--recursive", dest="recursive", action="store_true", default=None, help="Recurse into folders (override INI)")
+    rec_group.add_argument("--no-recursive", dest="recursive", action="store_false", default=None, help="No recursion (override INI)")
+
+    ap.add_argument("--output", choices=["alongside", "dir"], default=def_ini["output"], help="Output mode")
+    ap.add_argument("--out-dir", default=def_ini["out_dir"], help="Base directory when --output dir")
+
+    ap.add_argument("--workers", type=int, default=def_ini["workers"], help="Parallel workers (per media file)")
+    ap.add_argument("--replace", action="store_true", default=def_ini["replace"], help="Replace existing output")
+    ap.add_argument("--keep-temp", action="store_true", default=def_ini["keep_temp"], help="Keep temp thumbs for debugging")
+    ap.add_argument("--loglevel", default=def_ini["loglevel"], help="ffmpeg loglevel")
+    ap.add_argument("--jpeg-quality", type=int, default=def_ini["jpeg_quality"], help="JPEG quality for tile spritesheets")
+
+    ap.add_argument("--interval-ms", type=int, default=def_ini["interval_ms"], help="Interval between thumbs (ms)")
+    ap.add_argument("--widths", default=def_ini["widths"], help="Comma-separated widths (e.g. 640 or 320,640)")
+    ap.add_argument("--tile-cols", type=int, default=def_ini["tile_cols"], help="Thumbs per row in a tile")
+    ap.add_argument("--tile-rows", type=int, default=def_ini["tile_rows"], help="Thumbs per col in a tile")
+
+    ap.add_argument("--ffmpeg", default=def_ini["ffmpeg"], help="Path to ffmpeg")
+    ap.add_argument("--ffprobe", default=def_ini["ffprobe"], help="Path to ffprobe")
+    ap.add_argument("--hw", choices=["none", "vaapi", "qsv", "cuda", "d3d11va", "amf"], default=def_ini["hw"], help="Optional HW decode")
+    ap.add_argument("--hw-device", default=def_ini["hw_device"], help="HW device path (e.g. /dev/dri/renderD128)")
+
+    ap.add_argument("--write-settings", action="store_true",
+                    help="Write effective settings back to INI (including used input paths/recursive)")
+
+    ns = ap.parse_args(argv)
+
+    if ns.paths:
+        effective_paths = ns.paths
+    else:
+        effective_paths = def_ini["ini_paths"]
+
+    if ns.recursive is None:
+        effective_recursive = def_ini["ini_recursive"]
+    else:
+        effective_recursive = bool(ns.recursive)
+
+    ns.effective_paths = effective_paths
+    ns.effective_recursive = effective_recursive
+    return ns, config_path
+
+
+def write_effective_settings(config_path: Path, ns: argparse.Namespace) -> None:
+    cfg = configparser.ConfigParser()
+    for section, kv in DEFAULTS.items():
+        cfg[section] = dict(kv)
+
+    used_paths = ns.effective_paths or []
+    if used_paths:
+        cfg["input"]["paths"] = "\n  " + "\n  ".join(used_paths)
+    else:
+        cfg["input"]["paths"] = ""
+    cfg["input"]["recursive"] = str(bool(ns.effective_recursive)).lower()
+
+    cfg["general"]["output"] = str(ns.output)
+    cfg["general"]["out_dir"] = str(ns.out_dir or "")
+    cfg["general"]["workers"] = str(int(ns.workers))
+    cfg["general"]["replace"] = str(bool(ns.replace)).lower()
+    cfg["general"]["keep_temp"] = str(bool(ns.keep_temp)).lower()
+    cfg["general"]["loglevel"] = str(ns.loglevel)
+    cfg["general"]["jpeg_quality"] = str(int(ns.jpeg_quality))
+
+    cfg["trickplay"]["interval_ms"] = str(int(ns.interval_ms))
+    cfg["trickplay"]["widths"] = str(ns.widths)
+    cfg["trickplay"]["tile_cols"] = str(int(ns.tile_cols))
+    cfg["trickplay"]["tile_rows"] = str(int(ns.tile_rows))
+
+    cfg["ffmpeg"]["ffmpeg"] = str(ns.ffmpeg or "")
+    cfg["ffmpeg"]["ffprobe"] = str(ns.ffprobe or "")
+    cfg["ffmpeg"]["hw"] = str(ns.hw)
+    cfg["ffmpeg"]["hw_device"] = str(ns.hw_device or "")
+
+    config_path.write_text(render_ini(cfg), encoding="utf-8")
+    print(f"[INFO] Wrote effective settings to: {config_path}")
+
+
+# ---------- main ----------
+
+def main(argv: List[str]) -> int:
+    args, config_path = parse_args_with_ini(argv)
+
+    ffmpeg = (args.ffmpeg or "").strip() or which_or_fail("ffmpeg")
+    ffprobe = (args.ffprobe or "").strip() or which_or_fail("ffprobe")
+
+    widths = parse_int_list(args.widths)
+    if not widths:
+        print("ERROR: widths empty/invalid", file=sys.stderr)
+        return 2
+
+    out_dir = Path(args.out_dir).expanduser().resolve() if args.out_dir else None
+    if args.output == "dir" and not out_dir:
+        print("ERROR: output=dir requires out_dir", file=sys.stderr)
+        return 2
+
+    hw_device = (args.hw_device or "").strip() or None
+
+    if not args.effective_paths:
+        print("ERROR: No input paths provided (neither CLI nor [input].paths in settings.ini).", file=sys.stderr)
+        return 2
+
+    input_paths = [Path(p).expanduser().resolve() for p in args.effective_paths]
+    media_files = discover_media(input_paths, bool(args.effective_recursive))
+    if not media_files:
+        print("No media files found.")
+        return 0
+
+    if args.write_settings:
+        write_effective_settings(config_path, args)
+
+    print(
+        f"Found {len(media_files)} media file(s). "
+        f"Workers={args.workers}, HW={args.hw}, Interval={args.interval_ms}ms, Widths={widths}, "
+        f"Recursive={args.effective_recursive}, Output={args.output}"
+    )
+
+    ok = 0
+    fail = 0
+
+    progress_q = None
+    mgr = None
+    if RICH_AVAILABLE:
+        mgr = mp.Manager()
+        progress_q = mgr.Queue()
+    else:
+        print("[INFO] Optional: install 'rich' for progress UI: py -m pip install rich")
+
+    with cf.ProcessPoolExecutor(max_workers=int(args.workers)) as ex:
+        futures = [
+            ex.submit(
+                process_one_media,
+                m,
+                ffmpeg,
+                ffprobe,
+                int(args.interval_ms),
+                widths,
+                int(args.tile_cols),
+                int(args.tile_rows),
+                str(args.output),
+                out_dir,
+                str(args.hw),
+                hw_device,
+                bool(args.replace),
+                bool(args.keep_temp),
+                str(args.loglevel),
+                int(args.jpeg_quality),
+                progress_q,
+            )
+            for m in media_files
+        ]
+
+        pending = set(futures)
+
+        if not RICH_AVAILABLE:
+            for fut in cf.as_completed(pending):
+                media, success, msg = fut.result()
+                if success:
+                    ok += 1
+                    print(f"[OK]   {media}\n       {msg}")
+                else:
+                    fail += 1
+                    print(f"[FAIL] {media}\n       {msg}\n")
+            print(f"Done. OK={ok}, FAIL={fail}")
+            return 0 if fail == 0 else 1
+
+        console = Console()
+
+        overall = Progress(
+            TextColumn("[bold]Overall[/bold]"),
+            BarColumn(),
+            TextColumn("{task.completed}/{task.total}"),
+            TimeElapsedColumn(),
+            TimeRemainingColumn(),
+            expand=True,
+        )
+        workers = Progress(
+            TextColumn("Worker {task.fields[pid]}"),
+            BarColumn(),
+            TextColumn("{task.percentage:>5.1f}%"),
+            TextColumn("{task.fields[stage]}"),
+            TextColumn("{task.fields[file]}"),
+            expand=True,
+        )
+
+        overall_task = overall.add_task("", total=len(media_files))
+        pid_to_task: Dict[int, int] = {}
+
+        def handle_event(evt: dict) -> None:
+            pid = int(evt.get("pid", 0) or 0)
+            media = str(evt.get("media", "") or "")
+            stage = str(evt.get("stage", "") or "")
+            total = int(evt.get("total", 1) or 1)
+            done = int(evt.get("done", 0) or 0)
+
+            if pid not in pid_to_task:
+                pid_to_task[pid] = workers.add_task(
+                    "",
+                    total=total,
+                    pid=str(pid),
+                    stage=stage,
+                    file=short_path(media),
+                )
+            task_id = pid_to_task[pid]
+            workers.update(
+                task_id,
+                total=total,
+                completed=done,
+                stage=stage,
+                file=short_path(media),
+            )
+
+        layout = Group(overall, workers)
+
+        with Live(layout, refresh_per_second=10, console=console):
+            while pending:
+                while True:
+                    try:
+                        evt = progress_q.get_nowait()
+                    except queue_mod.Empty:
+                        break
+                    except Exception:
+                        break
+                    else:
+                        handle_event(evt)
+
+                done_set, pending = cf.wait(pending, timeout=0.1, return_when=cf.FIRST_COMPLETED)
+                for fut in done_set:
+                    media, success, msg = fut.result()
+                    if success:
+                        ok += 1
+                    else:
+                        fail += 1
+                        console.print(f"[red][FAIL][/red] {media}\n{msg}\n")
+                    overall.advance(overall_task, 1)
+
+        console.print(f"[bold]Done.[/bold] OK={ok}, FAIL={fail}")
+        if mgr is not None:
+            try:
+                mgr.shutdown()
+            except Exception:
+                pass
+        return 0 if fail == 0 else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/settings.ini b/settings.ini
new file mode 100644
index 0000000..45e1102
--- /dev/null
+++ b/settings.ini
@@ -0,0 +1,26 @@
+[input]
+paths =
+  C:\Users\Thorsten\Desktop\Test
+  
+recursive = true
+
+[general]
+output = alongside
+out_dir =
+workers = 6
+replace = false
+keep_temp = false
+loglevel = error
+jpeg_quality = 90
+
+[trickplay]
+interval_ms = 10000
+widths = 320,640
+tile_cols = 10
+tile_rows = 10
+
+[ffmpeg]
+ffmpeg =
+ffprobe =
+hw = none
+hw_device =