From d6f8bc72dbe3d7ba900db1ac5bc07914a569a6ad Mon Sep 17 00:00:00 2001
From: Thorsten <thorsten.seine@gmail.com>
Date: Thu, 12 Feb 2026 17:01:16 +0100
Subject: [PATCH] .

---
 py_jellyfin_trickplay_generator.py | 684 ++++++++++++++++++-----------
 settings.ini                       |   9 +-
 2 files changed, 433 insertions(+), 260 deletions(-)

diff --git a/py_jellyfin_trickplay_generator.py b/py_jellyfin_trickplay_generator.py
index 5bf2744..dc7ef2f 100644
--- a/py_jellyfin_trickplay_generator.py
+++ b/py_jellyfin_trickplay_generator.py
@@ -3,21 +3,18 @@
 #
 # 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
+# Features:
+# - Parallel media processing (ProcessPool)
+# - HW decode: none|vaapi|qsv|cuda|d3d11va|amf|auto (auto decides per-file + per-device, falls back to CPU)
+# - Resume/Incremental with per-width fingerprint + markers (.meta.json/.complete/.inprogress)
+# - Nice progress UI (rich) including live ffmpeg extraction progress via -progress pipe:1
+# - Self-bootstrapping venv (PEP668-safe) with fallback to ~/.cache if script dir is on FUSE/cloud mounts
 #
 # Dependencies:
-#   - ffmpeg + ffprobe
-#   - pip install pillow
-#   - optional: pip install rich
+# - ffmpeg + ffprobe
+# - pillow (required)
+# - rich (optional, recommended)
 
 from __future__ import annotations
 
@@ -26,6 +23,7 @@ import concurrent.futures as cf
 import configparser
 import hashlib
 import json
+import math
 import multiprocessing as mp
 import os
 import queue as queue_mod
@@ -36,17 +34,19 @@ import sys
 import tempfile
 import time
 from dataclasses import dataclass
+from functools import lru_cache
 from pathlib import Path
 from typing import Dict, Iterable, List, Optional, Tuple
 
 
+# ---------------- bootstrap venv (PEP668-safe) ----------------
+
 def ensure_venv_and_reexec():
     # Already inside a venv?
     if sys.prefix != sys.base_prefix:
         return
 
     script_dir = Path(__file__).resolve().parent
-
     preferred_venv = script_dir / ".venv"
     fallback_venv = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) / "py_jellyfin_trickplay_generator" / "venv"
 
@@ -56,8 +56,7 @@ def ensure_venv_and_reexec():
         return venv_dir / "bin" / "python"
 
     def is_valid_venv(venv_dir: Path) -> bool:
-        py = venv_python(venv_dir)
-        return py.is_file()
+        return venv_python(venv_dir).is_file()
 
     def recreate_venv(venv_dir: Path) -> None:
         if venv_dir.exists():
@@ -65,9 +64,7 @@ def ensure_venv_and_reexec():
         venv_dir.parent.mkdir(parents=True, exist_ok=True)
         subprocess.check_call([sys.executable, "-m", "venv", str(venv_dir)])
 
-    # Pick a venv location that works
     venv_dir = preferred_venv
-
     try:
         if not is_valid_venv(venv_dir):
             print("[INFO] Creating local virtual environment (.venv)...")
@@ -84,11 +81,7 @@ def ensure_venv_and_reexec():
         raise RuntimeError(f"venv python not found after creation: {py}")
 
     print("[INFO] Ensuring required packages (pillow, rich)...")
-
-    # Ensure pip exists inside venv (some builds need this)
     subprocess.check_call([str(py), "-m", "ensurepip", "--upgrade"])
-
-    # Upgrade pip + install packages
     subprocess.check_call([str(py), "-m", "pip", "install", "--upgrade", "pip", "setuptools", "wheel"])
     subprocess.check_call([str(py), "-m", "pip", "install", "pillow", "rich"])
 
@@ -96,20 +89,14 @@ def ensure_venv_and_reexec():
     os.execv(str(py), [str(py)] + sys.argv)
 
 
-
-
 ensure_venv_and_reexec()
 
-
-
-
-
-from PIL import Image
+from PIL import Image  # noqa: E402
 
 try:
-    from rich.console import Console, Group
-    from rich.live import Live
-    from rich.progress import (
+    from rich.console import Console, Group  # noqa: E402
+    from rich.live import Live  # noqa: E402
+    from rich.progress import (  # noqa: E402
         Progress,
         BarColumn,
         TextColumn,
@@ -122,13 +109,12 @@ except Exception:
     RICH_AVAILABLE = False
 
 
+# ---------------- constants / defaults ----------------
+
 VIDEO_EXTS = {".mkv", ".mp4", ".m4v", ".avi", ".mov", ".ts", ".m2ts", ".webm"}
 
 DEFAULTS: Dict[str, Dict[str, str]] = {
-    "input": {
-        "paths": "",
-        "recursive": "false",
-    },
+    "input": {"paths": "", "recursive": "false"},
     "general": {
         "output": "alongside",  # alongside | dir
         "out_dir": "",
@@ -147,8 +133,8 @@ DEFAULTS: Dict[str, Dict[str, str]] = {
     "ffmpeg": {
         "ffmpeg": "",
         "ffprobe": "",
-        "hw": "none",  # none|vaapi|qsv|cuda|d3d11va|amf
-        "hw_device": "",
+        "hw": "none",  # none|vaapi|qsv|cuda|d3d11va|amf|auto
+        "hw_device": "",  # for vaapi: /dev/dri/renderD128, or empty (auto)
     },
 }
 
@@ -160,14 +146,13 @@ class ProbeInfo:
     color_trc: str
     colorspace: str
     sar: str
+    codec: str  # e.g. h264, hevc, av1, vp9
 
 
-# ---------- small helpers ----------
+# ---------------- small helpers ----------------
 
 def short_path(p: str, max_len: int = 90) -> str:
-    if len(p) <= max_len:
-        return p
-    return "…" + p[-(max_len - 1):]
+    return p if len(p) <= max_len else "…" + p[-(max_len - 1):]
 
 
 def send_evt(q, **evt) -> None:
@@ -179,10 +164,11 @@ def send_evt(q, **evt) -> None:
         pass
 
 
-def run_cmd(cmd: List[str], *, cwd: Optional[Path] = None) -> subprocess.CompletedProcess:
+def run_cmd(cmd: List[str], *, cwd: Optional[Path] = None, env: Optional[dict] = None) -> subprocess.CompletedProcess:
     return subprocess.run(
         cmd,
         cwd=str(cwd) if cwd else None,
+        env=env,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         text=True,
@@ -193,9 +179,7 @@ def run_cmd(cmd: List[str], *, cwd: Optional[Path] = None) -> subprocess.Complet
 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."
-        )
+        raise FileNotFoundError(f"'{exe}' not found in PATH. Install it or set it in settings.ini / via CLI.")
     return p
 
 
@@ -261,9 +245,8 @@ 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))
+        if part:
+            vals.append(int(part))
     return vals
 
 
@@ -298,19 +281,15 @@ def sha1_of_obj(obj: dict) -> str:
     return hashlib.sha1(raw).hexdigest()
 
 
-# ---------- jellyfin-ish media probing / filters ----------
+# ---------------- 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",
+        "-v", "error",
+        "-select_streams", "v:0",
+        "-show_entries", "format=duration:stream=codec_name,color_primaries,color_transfer,colorspace,sample_aspect_ratio",
+        "-of", "json",
         str(media_path),
     ]
     cp = run_cmd(cmd)
@@ -318,7 +297,6 @@ def ffprobe_media(ffprobe: str, media_path: Path) -> ProbeInfo:
         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:
@@ -328,12 +306,18 @@ def ffprobe_media(ffprobe: str, media_path: Path) -> ProbeInfo:
     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)
+    codec = (stream.get("codec_name") or "").strip().lower() or "unknown"
+    # normalize some common names
+    if codec in {"h265", "hevc"}:
+        codec = "hevc"
+    if codec in {"h264"}:
+        codec = "h264"
+
+    return ProbeInfo(duration_s=duration, color_primaries=prim, color_trc=trc, colorspace=csp, sar=sar, codec=codec)
 
 
 def jellyfin_like_fps_value(interval_ms: int) -> str:
@@ -351,32 +335,173 @@ def build_scale_expr(target_width_px: int) -> str:
     )
 
 
+def expected_frames(duration_s: float, interval_ms: int) -> int:
+    if duration_s <= 0:
+        return 1
+    step = interval_ms / 1000.0
+    if step <= 0:
+        return 1
+    return max(1, int(math.ceil(duration_s / step)))
+
+
+# ---------------- hw auto-detect ----------------
+
+@lru_cache(maxsize=1)
+def ffmpeg_hwaccels(ffmpeg: str) -> set[str]:
+    cp = run_cmd([ffmpeg, "-hide_banner", "-hwaccels"])
+    accels: set[str] = set()
+    for ln in (cp.stdout or "").splitlines():
+        ln = ln.strip().lower()
+        if not ln:
+            continue
+        if ln.startswith("hardware"):
+            continue
+        if ln.startswith("hwaccels"):
+            continue
+        accels.add(ln)
+    return accels
+
+
+def list_render_nodes() -> List[str]:
+    dri = Path("/dev/dri")
+    if not dri.exists():
+        return []
+    nodes = sorted([str(p) for p in dri.glob("renderD*") if p.is_char_device() or p.exists()])
+    return nodes
+
+
+def parse_vainfo_profiles(text: str) -> set[str]:
+    # returns codec tags like {"h264","hevc","vp9","av1","jpeg"}
+    s = text.splitlines()
+    out: set[str] = set()
+    for line in s:
+        line = line.strip()
+        if not line.startswith("VAProfile"):
+            continue
+        # coarse matching is fine for our decision
+        if "H264" in line:
+            out.add("h264")
+        if "HEVC" in line:
+            out.add("hevc")
+        if "VP9" in line:
+            out.add("vp9")
+        if "AV1" in line:
+            out.add("av1")
+        if "JPEG" in line:
+            out.add("jpeg")
+    return out
+
+
+@lru_cache(maxsize=32)
+def vainfo_codecs_for_device(render_node: str) -> set[str]:
+    # Try stable way: vainfo --display drm --device /dev/dri/renderD128
+    # If that fails, fall back to plain vainfo (may pick default device).
+    cmd = ["vainfo", "--display", "drm", "--device", render_node]
+    cp = run_cmd(cmd)
+    if cp.returncode != 0:
+        # fallback: some setups only support plain vainfo
+        cp2 = run_cmd(["vainfo"])
+        if cp2.returncode != 0:
+            return set()
+        return parse_vainfo_profiles((cp2.stdout or "") + "\n" + (cp2.stderr or ""))
+    return parse_vainfo_profiles((cp.stdout or "") + "\n" + (cp.stderr or ""))
+
+
+def pick_vaapi_device_for_codec(codec: str, preferred: Optional[str]) -> Optional[str]:
+    if preferred:
+        return preferred
+    nodes = list_render_nodes()
+    if not nodes:
+        return None
+    # choose first device that advertises the codec
+    for n in nodes:
+        try:
+            if codec in vainfo_codecs_for_device(n):
+                return n
+        except Exception:
+            continue
+    # otherwise, return first render node (still may work/fallback in ffmpeg)
+    return nodes[0]
+
+
+def select_hw_for_media(
+    *,
+    ffmpeg: str,
+    hw_setting: str,
+    hw_device: Optional[str],
+    probe: ProbeInfo,
+) -> Tuple[str, Optional[str], str]:
+    """
+    Returns (chosen_hw, chosen_device, reason)
+    hw_setting may be explicit or 'auto'.
+    """
+    hw_setting = (hw_setting or "none").lower()
+    codec = (probe.codec or "unknown").lower()
+    accels = ffmpeg_hwaccels(ffmpeg)
+
+    if hw_setting != "auto":
+        chosen = hw_setting
+        dev = hw_device
+        reason = "explicit"
+        return chosen, dev, reason
+
+    # AUTO decision:
+    # Windows: prefer d3d11va, then cuda, then qsv
+    if os.name == "nt":
+        if "d3d11va" in accels:
+            return "d3d11va", None, "auto: d3d11va"
+        if "cuda" in accels:
+            return "cuda", None, "auto: cuda"
+        if "qsv" in accels:
+            return "qsv", None, "auto: qsv"
+        return "none", None, "auto: cpu"
+
+    # Linux: choose best available per codec.
+    # Prefer QSV for h264/hevc (Intel iGPU often strongest), then VAAPI if it advertises codec, then CUDA.
+    if codec in {"h264", "hevc", "vp9", "av1"}:
+        if "qsv" in accels:
+            return "qsv", None, f"auto: qsv ({codec})"
+
+    if "vaapi" in accels:
+        dev = pick_vaapi_device_for_codec(codec, hw_device)
+        if dev:
+            # only choose VAAPI if vainfo advertises this codec on that device
+            try:
+                caps = vainfo_codecs_for_device(dev)
+            except Exception:
+                caps = set()
+            if codec in caps:
+                return "vaapi", dev, f"auto: vaapi {dev} ({codec})"
+
+    if codec in {"h264", "hevc", "vp9", "av1"} and "cuda" in accels:
+        return "cuda", None, f"auto: cuda ({codec})"
+
+    return "none", None, "auto: cpu"
+
+
 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 [
-            "-hwaccel",
-            "vaapi",
-            "-hwaccel_device",
-            dev,
-            "-hwaccel_output_format",
-            "vaapi",
-        ]
+        # decode acceleration only; keep frames in system memory for CPU filters
+        return ["-hwaccel", "vaapi", "-hwaccel_device", dev]
     if hw == "qsv":
-        return ["-hwaccel", "qsv", "-noautoscale"]
+        return ["-hwaccel", "qsv"]
     if hw == "cuda":
         return ["-hwaccel", "cuda"]
     if hw == "d3d11va":
         return ["-hwaccel", "d3d11va"]
     if hw == "amf":
+        # decode path typically d3d11va on Windows
         return ["-hwaccel", "d3d11va"]
-    raise ValueError(f"Unknown hw='{hw}' (none|vaapi|qsv|cuda|d3d11va|amf)")
+    raise ValueError(f"Unknown hw='{hw}' (none|vaapi|qsv|cuda|d3d11va|amf|auto)")
 
 
-def extract_thumbs(
+# ---------------- extraction with live progress ----------------
+
+def extract_thumbs_with_progress(
     ffmpeg: str,
     media_path: Path,
     out_dir: Path,
@@ -386,7 +511,17 @@ def extract_thumbs(
     hw: str,
     hw_device: Optional[str],
     loglevel: str,
+    expected_count: int,
+    progress_q,
+    pid: int,
+    units_total: int,
+    units_base_done: int,
+    stage_prefix: str,
+    hw_label: str,
 ) -> None:
+    """
+    Runs ffmpeg extraction and streams progress updates from ffmpeg (-progress pipe:1).
+    """
     fps_val = jellyfin_like_fps_value(interval_ms)
     setparams = (
         f"setparams=color_primaries={probe.color_primaries}:"
@@ -400,41 +535,106 @@ def extract_thumbs(
     cmd = [
         ffmpeg,
         "-hide_banner",
-        "-loglevel",
-        loglevel,
+        "-loglevel", loglevel,
+        "-nostats",
         *hw_decode_args(hw, hw_device),
-        "-threads",
-        "1",
+        "-threads", "1",
         "-noautorotate",
-        "-i",
-        str(media_path),
+        "-progress", "pipe:1",
+        "-i", str(media_path),
         "-an",
         "-sn",
-        "-vf",
-        vf,
-        "-c:v",
-        "mjpeg",
-        "-qscale:v",
-        "4",
-        "-fps_mode",
-        "passthrough",
-        "-f",
-        "image2",
+        "-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}"
+
+    p = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        bufsize=1,
+    )
+
+    last_report_t = 0.0
+    last_frames = 0
+
+    try:
+        assert p.stdout is not None
+        for line in p.stdout:
+            line = line.strip()
+            if not line or "=" not in line:
+                continue
+
+            k, v = line.split("=", 1)
+            if k == "frame":
+                try:
+                    frames = int(v)
+                except Exception:
+                    continue
+                if frames < last_frames:
+                    frames = last_frames
+                last_frames = frames
+
+                now = time.time()
+                if now - last_report_t >= 0.25:
+                    cur = units_base_done + min(frames, expected_count)
+                    send_evt(
+                        progress_q,
+                        type="update",
+                        pid=pid,
+                        media=str(media_path),
+                        total=units_total,
+                        done=cur,
+                        stage=f"{stage_prefix} {width_px}px {min(frames, expected_count)}/{expected_count}",
+                        hw=hw_label,
+                    )
+                    last_report_t = now
+
+            elif k == "progress" and v == "end":
+                break
+
+        rc = p.wait()
+        if rc != 0:
+            err = (p.stderr.read() if p.stderr else "") or ""
+            raise RuntimeError(
+                f"ffmpeg failed for {media_path} (width={width_px}, hw={hw_label})\n"
+                f"CMD:\n{' '.join(cmd)}\n\nSTDERR:\n{err}"
+            )
+
+        cur = units_base_done + expected_count
+        send_evt(
+            progress_q,
+            type="update",
+            pid=pid,
+            media=str(media_path),
+            total=units_total,
+            done=cur,
+            stage=f"{stage_prefix} {width_px}px {expected_count}/{expected_count}",
+            hw=hw_label,
         )
+    finally:
+        try:
+            if p.stdout:
+                p.stdout.close()
+        except Exception:
+            pass
+        try:
+            if p.stderr:
+                p.stderr.close()
+        except Exception:
+            pass
 
 
-# ---------- tiling (legacy layout) + completeness markers ----------
+# ---------------- tiling + markers ----------------
 
 def chunked(seq: List[Path], n: int) -> Iterable[List[Path]]:
     for i in range(0, len(seq), n):
-        yield seq[i : i + n]
+        yield seq[i:i + n]
 
 
 def width_dir(base_out: Path, width_px: int, tile_cols: int, tile_rows: int) -> Path:
@@ -454,19 +654,10 @@ def width_inprogress_path(wdir: Path) -> Path:
 
 
 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
+def width_fingerprint(*, interval_ms: int, width_px: int, tile_cols: int, tile_rows: int, jpeg_quality: int) -> str:
     payload = {
         "interval_ms": interval_ms,
         "width_px": width_px,
@@ -474,15 +665,12 @@ def width_fingerprint(
         "tile_rows": tile_rows,
         "jpeg_quality": jpeg_quality,
         "layout": "jellyfin_legacy",
-        "impl_version": 1,  # bump if we change algorithm (filenames, tiling, etc.)
+        "impl_version": 3,  # auto-hw + live extract
     }
     return sha1_of_obj(payload)
 
 
-def is_width_complete_expected(
-    wdir: Path,
-    expected_fp: str,
-) -> bool:
+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):
@@ -501,7 +689,6 @@ 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()
@@ -525,9 +712,8 @@ def build_tiles_jellyfin_legacy_rebuild(
     tile_rows: int,
     jpeg_quality: int,
 ) -> None:
+    # keep marker files, only replace tile JPGs
     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()
@@ -542,7 +728,7 @@ def build_tiles_jellyfin_legacy_rebuild(
         thumb_w, thumb_h = im0.size
 
     per_tile = tile_cols * tile_rows
-    for tile_idx, group in enumerate(chunked(thumbs, per_tile)):  # 0-based
+    for tile_idx, group in enumerate(chunked(thumbs, per_tile)):
         canvas = Image.new("RGB", (thumb_w * tile_cols, thumb_h * tile_rows))
         for idx, img_path in enumerate(group):
             r = idx // tile_cols
@@ -554,8 +740,7 @@ def build_tiles_jellyfin_legacy_rebuild(
         canvas.save(wdir / f"{tile_idx}.jpg", format="JPEG", quality=jpeg_quality, optimize=True)
 
 
-
-# ---------- root markers (job-level) ----------
+# ---------------- root job markers ----------------
 
 def job_meta_path(base_out: Path) -> Path:
     return base_out / ".trickplay.job.json"
@@ -569,14 +754,7 @@ 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:
+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,
@@ -584,7 +762,7 @@ def job_fingerprint(
         "tile_rows": tile_rows,
         "jpeg_quality": jpeg_quality,
         "layout": "jellyfin_legacy",
-        "impl_version": 1,
+        "impl_version": 3,
     }
     return sha1_of_obj(payload)
 
@@ -604,7 +782,6 @@ 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()
@@ -621,7 +798,7 @@ def mark_root_complete(base_out: Path) -> None:
     atomic_write_text(root_complete_path(base_out), "ok\n")
 
 
-# ---------- filesystem mapping ----------
+# ---------------- filesystem mapping ----------------
 
 def media_output_base(media_path: Path) -> Path:
     return media_path.with_suffix(media_path.suffix + ".trickplay")
@@ -645,7 +822,7 @@ def discover_media(paths: List[Path], recursive: bool) -> List[Path]:
     return sorted(set(found))
 
 
-# ---------- worker task ----------
+# ---------------- worker task ----------------
 
 def process_one_media(
     media_path: Path,
@@ -657,8 +834,8 @@ def process_one_media(
     tile_rows: int,
     output_mode: str,
     out_dir: Optional[Path],
-    hw: str,
-    hw_device: Optional[str],
+    hw_setting: str,              # can be 'auto'
+    hw_device_setting: Optional[str],
     replace: bool,
     keep_temp: bool,
     loglevel: str,
@@ -668,16 +845,36 @@ def process_one_media(
     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:
+        send_evt(progress_q, type="start", pid=pid, media=str(media_path), total=1, done=0, stage="start", hw="-")
         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
+        exp = expected_frames(probe.duration_s, interval_ms)
+        units_total = 1 + sum((exp + 1) for _ in widths)
+        units_done = 1
+
+        chosen_hw, chosen_dev, reason = select_hw_for_media(
+            ffmpeg=ffmpeg,
+            hw_setting=hw_setting,
+            hw_device=hw_device_setting,
+            probe=probe,
+        )
+        hw_label = chosen_hw if chosen_hw != "vaapi" else f"vaapi:{Path(chosen_dev or '').name or 'auto'}"
+        if chosen_hw == "none":
+            hw_label = "cpu"
+
+        send_evt(
+            progress_q,
+            type="update",
+            pid=pid,
+            media=str(media_path),
+            total=units_total,
+            done=units_done,
+            stage=f"probe ({probe.codec}) [{reason}]",
+            hw=hw_label,
+        )
+
+        # output base
         if output_mode == "alongside":
             base_out = media_output_base(media_path)
         elif output_mode == "dir":
@@ -687,7 +884,6 @@ def process_one_media(
         else:
             raise ValueError("output must be alongside|dir")
 
-        # job fingerprint (for root convenience marker)
         job_fp = job_fingerprint(
             interval_ms=interval_ms,
             widths=widths,
@@ -704,22 +900,18 @@ def process_one_media(
             "tile_rows": tile_rows,
             "jpeg_quality": jpeg_quality,
             "layout": "jellyfin_legacy",
-            "impl_version": 1,
+            "impl_version": 3,
         }
 
-        # 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)")
+            send_evt(progress_q, type="done", pid=pid, media=str(media_path), total=units_total, done=units_total, stage="skip (job complete)", hw=hw_label)
             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)
@@ -727,10 +919,9 @@ def process_one_media(
             shutil.rmtree(tmp_root, ignore_errors=True)
         tmp_root.mkdir(parents=True, exist_ok=True)
 
-        # build widths incrementally
+        # per-width incremental
         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,
@@ -747,40 +938,80 @@ def process_one_media(
                 "tile_rows": tile_rows,
                 "jpeg_quality": jpeg_quality,
                 "layout": "jellyfin_legacy",
-                "impl_version": 1,
+                "impl_version": 3,
             }
 
-            # 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")
+                units_done += exp + 1
+                send_evt(progress_q, type="update", pid=pid, media=str(media_path), total=units_total, done=units_done, stage=f"skip {w}px", hw=hw_label)
                 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")
+            # try chosen HW; if auto and it fails, retry CPU once
+            try:
+                extract_thumbs_with_progress(
+                    ffmpeg=ffmpeg,
+                    media_path=media_path,
+                    out_dir=tmp_thumbs,
+                    probe=probe,
+                    interval_ms=interval_ms,
+                    width_px=w,
+                    hw=chosen_hw,
+                    hw_device=chosen_dev,
+                    loglevel=loglevel,
+                    expected_count=exp,
+                    progress_q=progress_q,
+                    pid=pid,
+                    units_total=units_total,
+                    units_base_done=units_done,
+                    stage_prefix="extract",
+                    hw_label=hw_label,
+                )
+            except RuntimeError as e:
+                if (hw_setting or "").lower() == "auto" and chosen_hw != "none":
+                    # retry CPU
+                    send_evt(
+                        progress_q,
+                        type="update",
+                        pid=pid,
+                        media=str(media_path),
+                        total=units_total,
+                        done=units_done,
+                        stage=f"hw fail -> retry CPU ({hw_label})",
+                        hw="cpu",
+                    )
+                    extract_thumbs_with_progress(
+                        ffmpeg=ffmpeg,
+                        media_path=media_path,
+                        out_dir=tmp_thumbs,
+                        probe=probe,
+                        interval_ms=interval_ms,
+                        width_px=w,
+                        hw="none",
+                        hw_device=None,
+                        loglevel=loglevel,
+                        expected_count=exp,
+                        progress_q=progress_q,
+                        pid=pid,
+                        units_total=units_total,
+                        units_base_done=units_done,
+                        stage_prefix="extract",
+                        hw_label="cpu",
+                    )
+                    # after fallback, lock label to cpu for the rest of the file
+                    chosen_hw, chosen_dev, hw_label = "none", None, "cpu"
+                else:
+                    raise e
 
-            # build tiles into width dir (rebuild width dir content)
+            units_done += exp
+
+            send_evt(progress_q, type="update", pid=pid, media=str(media_path), total=units_total, done=units_done, stage=f"tile {w}px", hw=hw_label)
             build_tiles_jellyfin_legacy_rebuild(
                 thumbs_dir=tmp_thumbs,
                 wdir=wdir,
@@ -789,41 +1020,33 @@ def process_one_media(
                 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")
+            send_evt(progress_q, type="update", pid=pid, media=str(media_path), total=units_total, done=units_done, stage=f"tile {w}px done", hw=hw_label)
 
             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,
-            )
+            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")
+        send_evt(progress_q, type="done", pid=pid, media=str(media_path), total=units_total, done=units_total, stage="done", hw=hw_label)
         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))
+        send_evt(progress_q, type="error", pid=pid, media=str(media_path), total=1, done=0, stage="error", error=str(e), hw="?")
         return (str(media_path), False, str(e))
 
 
-# ---------- CLI parsing ----------
+# ---------------- CLI parsing ----------------
 
 def parse_args_with_ini(argv: List[str]) -> Tuple[argparse.Namespace, Path]:
     pre = argparse.ArgumentParser(add_help=False)
@@ -856,38 +1079,32 @@ def parse_args_with_ini(argv: List[str]) -> Tuple[argparse.Namespace, Path]:
         "hw_device": get_str(cfg, "ffmpeg", "hw_device", ""),
     }
 
-    ap = argparse.ArgumentParser(
-        description="Generate Jellyfin legacy trickplay tiles (INI + CLI override).",
-    )
+    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)")
+    rec_group.add_argument("--recursive", dest="recursive", action="store_true", default=None)
+    rec_group.add_argument("--no-recursive", dest="recursive", action="store_false", default=None)
 
-    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("--output", choices=["alongside", "dir"], default=def_ini["output"])
+    ap.add_argument("--out-dir", default=def_ini["out_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("--workers", type=int, default=def_ini["workers"])
+    ap.add_argument("--replace", action="store_true", default=def_ini["replace"])
+    ap.add_argument("--keep-temp", action="store_true", default=def_ini["keep_temp"])
+    ap.add_argument("--loglevel", default=def_ini["loglevel"])
+    ap.add_argument("--jpeg-quality", type=int, default=def_ini["jpeg_quality"])
 
-    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("--interval-ms", type=int, default=def_ini["interval_ms"])
+    ap.add_argument("--widths", default=def_ini["widths"])
+    ap.add_argument("--tile-cols", type=int, default=def_ini["tile_cols"])
+    ap.add_argument("--tile-rows", type=int, default=def_ini["tile_rows"])
 
-    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)")
+    ap.add_argument("--ffmpeg", default=def_ini["ffmpeg"])
+    ap.add_argument("--ffprobe", default=def_ini["ffprobe"])
+    ap.add_argument("--hw", choices=["auto", "none", "vaapi", "qsv", "cuda", "d3d11va", "amf"], default=def_ini["hw"])
+    ap.add_argument("--hw-device", default=def_ini["hw_device"])
 
     ns = ap.parse_args(argv)
 
@@ -896,54 +1113,17 @@ def parse_args_with_ini(argv: List[str]) -> Tuple[argparse.Namespace, Path]:
     else:
         effective_paths = def_ini["ini_paths"]
 
-    if ns.recursive is None:
-        effective_recursive = def_ini["ini_recursive"]
-    else:
-        effective_recursive = bool(ns.recursive)
+    effective_recursive = def_ini["ini_recursive"] if ns.recursive is None else 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 ----------
+# ---------------- main ----------------
 
 def main(argv: List[str]) -> int:
-    args, config_path = parse_args_with_ini(argv)
+    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")
@@ -970,9 +1150,6 @@ def main(argv: List[str]) -> int:
         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}, "
@@ -988,7 +1165,7 @@ def main(argv: List[str]) -> int:
         mgr = mp.Manager()
         progress_q = mgr.Queue()
     else:
-        print("[INFO] Optional: install 'rich' for progress UI: py -m pip install rich")
+        print("[INFO] Optional: install 'rich' for progress UI: python -m pip install rich")
 
     with cf.ProcessPoolExecutor(max_workers=int(args.workers)) as ex:
         futures = [
@@ -1042,6 +1219,7 @@ def main(argv: List[str]) -> int:
             TextColumn("Worker {task.fields[pid]}"),
             BarColumn(),
             TextColumn("{task.percentage:>5.1f}%"),
+            TextColumn("{task.fields[hw]}"),
             TextColumn("{task.fields[stage]}"),
             TextColumn("{task.fields[file]}"),
             expand=True,
@@ -1054,6 +1232,7 @@ def main(argv: List[str]) -> int:
             pid = int(evt.get("pid", 0) or 0)
             media = str(evt.get("media", "") or "")
             stage = str(evt.get("stage", "") or "")
+            hw = str(evt.get("hw", "-") or "-")
             total = int(evt.get("total", 1) or 1)
             done = int(evt.get("done", 0) or 0)
 
@@ -1063,16 +1242,11 @@ def main(argv: List[str]) -> int:
                     total=total,
                     pid=str(pid),
                     stage=stage,
+                    hw=hw,
                     file=short_path(media),
                 )
             task_id = pid_to_task[pid]
-            workers.update(
-                task_id,
-                total=total,
-                completed=done,
-                stage=stage,
-                file=short_path(media),
-            )
+            workers.update(task_id, total=total, completed=done, stage=stage, hw=hw, file=short_path(media))
 
         layout = Group(overall, workers)
 
diff --git a/settings.ini b/settings.ini
index 361a931..e3840a0 100644
--- a/settings.ini
+++ b/settings.ini
@@ -1,8 +1,7 @@
 [input]
 paths =
-  /home/thorsten/mnt/unRAID/Media/Filme/[Art]/Asian School Girls (2014)/
-  /home/thorsten/mnt/unRAID/Media/Filme/[Art]/Auf die Freude (2023)/
-  
+  /home/thorsten/mnt/unRAID/Media/Filme/[Art]/Test/
+ 
 recursive = true
 
 [general]
@@ -23,5 +22,5 @@ tile_rows = 10
 [ffmpeg]
 ffmpeg =
 ffprobe =
-hw = none
-hw_device = /dev/dri/renderD128
+hw = auto
+hw_device =