fix(worker): Hardware-Encoder und CPU-Merkmale auf Windows - plus ehrliche Transcode-Fehler
Aus dem gescheiterten Test-Rip des Commanders (Job 95afdc89) und seiner
UI-Durchsicht. Der Reihe nach.
## 1. Der externe Encoder wurde SEHR WOHL gesehen (Diagnose-Korrektur)
Der Commander schloss aus der Meldung, das System sehe seinen PC nicht. Live
gemessen sagt das Gegenteil:
meta.transcode_node = tobisnicerpc@TobisNicerPC
VM-Worker-Log = nur rip_disc, KEIN transcode_files
22:19:41.271 Kompression eingereiht
22:19:41.453 "Keine Roh-MKVs gefunden" <- 182 ms spaeter
Das Routing hat funktioniert. Sein PC nahm die Aufgabe an und lehnte sie sofort
ab, weil er /app/media/rippy/<job> nicht finden kann - ein Pfad, der nur INNEN
im Container existiert. Der Rip war vollstaendig (79,6 GB auf der NAS).
## 2. Der Hardware-Encoder-Bug war meiner
leite_backends_ab() verlangte zusaetzlich ein Geraet: /dev/dri fuer
VAAPI/QSV/VCE bzw. nvidia-smi fuer NVENC. Unter WINDOWS gibt es beides nicht -
der PC des Commanders (RX 9070 XT) meldete deshalb nur CPU-Encoder, obwohl
HandBrakes Windows-Build vce_*/nvenc_*/qsv_* beherrscht. Der Bug traf genau den
Anwendungsfall, fuer den externe Worker gedacht sind.
Die Pruefung war ausserdem ueberfluessig: HandBrake probiert Hardware beim
Start selbst an und listet nur Nutzbares - auf der VM belegt durch
"qsv: not available on this system" bei gleichzeitig fehlendem qsv_* in --help.
Jetzt ist HandBrakes Liste die einzige Auskunft.
Dazu nach FAMILIE unterschieden (nvenc/qsv/vce/vaapi) statt alles in "vaapi" zu
werfen - eine AMD-Karte lief unter dem Intel-Namen. Hardware-AV1 bekommt eine
eigene Kennung, weil es die beste Kombination aus Tempo und Groesse ist und
sonst unsichtbar bliebe.
## 3. Vektorbefehle unter Windows - gemessen, nicht "unbekannt"
Es gibt dort kein /proc/cpuinfo, also meldete der Windows-Worker
"Vektorbefehle unbekannt" - gerade auf der Maschine, die encodieren soll.
Jetzt ueber IsProcessorFeaturePresent (kernel32, winnt.h dokumentiert) plus
CPU-Name aus der Registry. Auf dem Commander-PC gegengeprueft:
vorher: AMD64 Family 26 Model 68 Stepping 0 / Vektorbefehle unbekannt
jetzt: AMD Ryzen 7 9700X 8-Core Processor / avx512f / 16 Kerne
Damit verschwindet die AVX2-Warnung fuer diesen Worker von selbst - genau das
hatte der Commander gefordert.
## 4. Ehrliche Fehlermeldung statt "Keine Roh-MKVs gefunden"
Neues _erreichbarkeit_pruefen() unterscheidet jetzt drei Faelle statt einem:
Pfad nicht erreichbar UND kein Mapping gesetzt (nennt RIPPY_PATH_MAP samt
Beispiel), Mapping gesetzt aber greift nicht, oder Pfad einfach nicht da. Und
es prueft BEIDE Pfade - im Fall des Commanders lag die Quelle auf der
erreichbaren NAS, das ZIEL aber auf der VM-Platte ohne Samba; das waere erst
beim Schreiben nach Stunden Rechenzeit aufgefallen.
Jede Meldung sagt jetzt ausdruecklich, dass die Rohdaten NICHT verloren sind
und "Neu komprimieren" genuegt.
## 5. Persoenliche Werte raus
Vier Platzhalter trugen die Umgebung des Commanders (192.168.178.20,
TOBIS-PC, seine Jellyfin- und Rippy-IP). In einem Repo, das weitergegeben
wird, hat das nichts verloren.
Nebenbei dreimal in die eigene Falle getappt: deutsche Anfuehrungszeichen in
DOPPELT gequoteten Python-Strings beenden den String vorzeitig. Der Bestand
nutzt dafuer einfach gequotete f-Strings - jetzt auch meine.
NOCH OFFEN und wichtig: RIPPY_PATH_MAP wird von niemandem GESETZT (Installer,
UI, Compose). Ein Windows-Worker kann damit grundsaetzlich nicht transcodieren.
Das ist der naechste Schritt.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Hitonabi
+119
-24
@@ -50,16 +50,41 @@ def parse_encoder_liste(hilfe_text: str) -> list:
|
||||
return encoder
|
||||
|
||||
|
||||
def leite_backends_ab(hb_encoder, dri_da: bool, nvidia_da: bool) -> list:
|
||||
# Hardware-Encoder-Familien, wie HandBrake sie benennt → Backend-Kennung.
|
||||
# Reihenfolge = Anzeige-Reihenfolge; AV1 zuerst, weil es das modernste ist.
|
||||
HW_FAMILIEN = (
|
||||
("nvenc", "nvenc"), # NVIDIA
|
||||
("qsv", "qsv"), # Intel QuickSync
|
||||
("vce", "vce"), # AMD VCE/VCN
|
||||
("vaapi", "vaapi"), # generisch (Linux)
|
||||
)
|
||||
|
||||
|
||||
def leite_backends_ab(hb_encoder) -> list:
|
||||
"""Übersetzt die HandBrake-Encoder-Namen in die Backends, die das UI zeigt.
|
||||
|
||||
Zwei Ehrlichkeits-Regeln, die vorher fehlten (Befund 25.07.2026):
|
||||
* Ohne HandBrake gibt es KEINE Encoder. Vorher standen `cpu-x264` und
|
||||
`cpu-x265` fest verdrahtet in der Liste („immer dabei") — ein reiner
|
||||
Rip-Worker ohne HandBrake behauptete damit, komprimieren zu können.
|
||||
* Hardware zählt nur, wenn das Gerät da ist UND HandBrake den Encoder
|
||||
überhaupt kennt. Vorher genügte `/dev/dri` — das Worker-Image kann
|
||||
laut eigener Auskunft aber gar keinen Hardware-Encoder.
|
||||
## HandBrakes Liste IST die Auskunft — keine zweite Meinung nötig
|
||||
|
||||
Frühere Fassung (25.07.2026) verlangte zusätzlich ein Gerät: `/dev/dri`
|
||||
für VAAPI/QSV/VCE bzw. `nvidia-smi` für NVENC. Das war doppelt falsch:
|
||||
|
||||
1. **Unter Windows gibt es beides nicht.** Der Commander-PC (RX 9070 XT)
|
||||
meldete deshalb nur CPU-Encoder, obwohl HandBrakes Windows-Build
|
||||
`vce_*`, `nvenc_*` und `qsv_*` beherrscht. Ein Bug, der genau den
|
||||
Anwendungsfall traf, für den externe Worker gedacht sind.
|
||||
2. **Die Prüfung war überflüssig.** HandBrake probiert Hardware-Encoder
|
||||
beim Start selbst an und listet nur, was es wirklich benutzen kann. Auf
|
||||
der Rippy-VM belegt: `--version` meldet „qsv: not available on this
|
||||
system" und „Cannot load libnvidia-encode.so.1" — und genau diese
|
||||
Encoder fehlen dann in `--help`. Wer die Liste hat, hat die Antwort.
|
||||
|
||||
Bleibt die eine Regel, die weiter gilt: **ohne HandBrake gibt es keine
|
||||
Encoder.** Vorher standen `cpu-x264`/`cpu-x265` fest verdrahtet drin, und
|
||||
ein reiner Rip-Worker behauptete damit, komprimieren zu können.
|
||||
|
||||
Hardware wird jetzt nach Familie unterschieden (nvenc/qsv/vce/vaapi) statt
|
||||
alles in „vaapi" zu werfen — sonst kann das UI nicht sagen, welches Preset
|
||||
passt, und AMD-Karten liefen unter einem Intel-Namen.
|
||||
"""
|
||||
namen = {e.lower() for e in (hb_encoder or [])}
|
||||
gefunden = []
|
||||
@@ -69,10 +94,15 @@ def leite_backends_ab(hb_encoder, dri_da: bool, nvidia_da: bool) -> list:
|
||||
gefunden.append("cpu-x265")
|
||||
if any(n.startswith("svt_av1") for n in namen):
|
||||
gefunden.append("cpu-av1")
|
||||
if dri_da and any(("qsv" in n) or ("vce" in n) or ("vaapi" in n) for n in namen):
|
||||
gefunden.append("vaapi")
|
||||
if nvidia_da and any("nvenc" in n for n in namen):
|
||||
gefunden.append("nvenc")
|
||||
for kennzeichen, backend in HW_FAMILIEN:
|
||||
treffer = [n for n in namen if kennzeichen in n]
|
||||
if not treffer:
|
||||
continue
|
||||
gefunden.append(backend)
|
||||
# AV1 in Hardware ist die derzeit beste Kombination aus Tempo und
|
||||
# Dateigröße — das muss sichtbar sein, nicht in „nvenc" verschwinden.
|
||||
if any("av1" in n for n in treffer):
|
||||
gefunden.append(f"{backend}-av1")
|
||||
return gefunden
|
||||
|
||||
|
||||
@@ -109,6 +139,72 @@ def _lies_cpuinfo() -> tuple:
|
||||
return modell, flags, kerne
|
||||
|
||||
|
||||
# Merkmals-Nummern für IsProcessorFeaturePresent (Win32, winnt.h).
|
||||
# Absteigend nach Stärke — der erste Treffer ist die höchste Stufe.
|
||||
WIN_MERKMALE = (
|
||||
("avx512f", 41), # PF_AVX512F_INSTRUCTIONS_AVAILABLE
|
||||
("avx2", 40), # PF_AVX2_INSTRUCTIONS_AVAILABLE
|
||||
("avx", 39), # PF_AVX_INSTRUCTIONS_AVAILABLE
|
||||
("sse4_2", 38), # PF_SSE4_2_INSTRUCTIONS_AVAILABLE
|
||||
)
|
||||
|
||||
|
||||
def _simd_windows() -> str:
|
||||
"""Höchste Vektor-Befehlsstufe unter Windows.
|
||||
|
||||
Es gibt dort kein /proc/cpuinfo, deshalb meldete der Windows-Worker bis
|
||||
25.07.2026 „Vektorbefehle unbekannt" — gerade auf der Maschine, die das
|
||||
Encodieren übernehmen soll, also genau da, wo die Angabe zählt.
|
||||
|
||||
Gefragt wird `IsProcessorFeaturePresent` aus kernel32 (Win32-API, in
|
||||
winnt.h dokumentiert). Kein Zusatzpaket, kein Registry-Gefummel, keine
|
||||
Fremdprozesse.
|
||||
"""
|
||||
try:
|
||||
import ctypes
|
||||
|
||||
kernel32 = ctypes.windll.kernel32
|
||||
except (ImportError, AttributeError, OSError):
|
||||
return "unbekannt"
|
||||
for name, nummer in WIN_MERKMALE:
|
||||
try:
|
||||
if kernel32.IsProcessorFeaturePresent(nummer):
|
||||
return name
|
||||
except OSError:
|
||||
return "unbekannt"
|
||||
return "unbekannt"
|
||||
|
||||
|
||||
def _modell_windows() -> str:
|
||||
"""Lesbarer CPU-Name unter Windows.
|
||||
|
||||
platform.processor() liefert dort nur „AMD64 Family 26 Model 68 …" — die
|
||||
Registry kennt den Namen, den auch der Aufkleber trägt.
|
||||
"""
|
||||
try:
|
||||
import winreg
|
||||
|
||||
with winreg.OpenKey(
|
||||
winreg.HKEY_LOCAL_MACHINE,
|
||||
r"HARDWARE\DESCRIPTION\System\CentralProcessor\0",
|
||||
) as schluessel:
|
||||
name, _ = winreg.QueryValueEx(schluessel, "ProcessorNameString")
|
||||
return " ".join(str(name).split())
|
||||
except (ImportError, OSError):
|
||||
return ""
|
||||
|
||||
|
||||
def cpu_merkmale() -> tuple:
|
||||
"""(Modell, SIMD-Stufe, Kernzahl) — plattformübergreifend, nie leer."""
|
||||
modell, flags, kerne = _lies_cpuinfo()
|
||||
simd = beste_simd(flags)
|
||||
if simd == "unbekannt" and platform.system() == "Windows":
|
||||
simd = _simd_windows()
|
||||
if not modell:
|
||||
modell = _modell_windows() or platform.processor() or "unbekannt"
|
||||
return modell, simd, (kerne or os.cpu_count() or 0)
|
||||
|
||||
|
||||
def hole_handbrake_hilfe() -> str:
|
||||
"""`HandBrakeCLI --help` einmal abrufen (leer, wenn nicht installiert)."""
|
||||
if not shutil.which("HandBrakeCLI"):
|
||||
@@ -123,14 +219,13 @@ def hole_handbrake_hilfe() -> str:
|
||||
|
||||
|
||||
def erkenne_encoder() -> list:
|
||||
"""Encoder-Backends, die auf DIESER Maschine wirklich nutzbar sind."""
|
||||
hb_encoder = parse_encoder_liste(hole_handbrake_hilfe())
|
||||
dri_da = os.path.exists("/dev/dri/renderD128")
|
||||
nvidia_da = bool(
|
||||
shutil.which("nvidia-smi")
|
||||
or os.path.exists("/usr/lib/x86_64-linux-gnu/libnvidia-encode.so.1")
|
||||
)
|
||||
return leite_backends_ab(hb_encoder, dri_da, nvidia_da)
|
||||
"""Encoder-Backends, die auf DIESER Maschine wirklich nutzbar sind.
|
||||
|
||||
Gefragt wird ausschließlich HandBrake selbst — es probiert Hardware beim
|
||||
Start an und listet nur Nutzbares. Eine zusätzliche Geräteprüfung wäre
|
||||
plattformabhängig (und war unter Windows falsch), siehe leite_backends_ab.
|
||||
"""
|
||||
return leite_backends_ab(parse_encoder_liste(hole_handbrake_hilfe()))
|
||||
|
||||
|
||||
def erkenne_ip() -> str:
|
||||
@@ -163,7 +258,7 @@ def werkzeug_versionen() -> dict:
|
||||
"""
|
||||
import socket
|
||||
|
||||
modell, flags, kerne = _lies_cpuinfo()
|
||||
modell, simd, kerne = cpu_merkmale()
|
||||
info = {
|
||||
# Zuordnung im UI: hostname (für den Celery-Online-Abgleich) + IP
|
||||
"hostname": socket.gethostname(),
|
||||
@@ -171,9 +266,9 @@ def werkzeug_versionen() -> dict:
|
||||
# Rechenleistung fürs Software-Encodieren. Ohne diese drei Angaben war
|
||||
# am 25.07.2026 nicht zu sehen, dass ein 4K-Encode auf dieser Maschine
|
||||
# Tage statt Stunden braucht (kein AVX2, 4 Kerne).
|
||||
"cpu_modell": modell or (platform.processor() or "unbekannt"),
|
||||
"cpu_kerne": str(kerne or os.cpu_count() or 0),
|
||||
"cpu_simd": beste_simd(flags),
|
||||
"cpu_modell": modell,
|
||||
"cpu_kerne": str(kerne),
|
||||
"cpu_simd": simd,
|
||||
}
|
||||
hb_encoder = parse_encoder_liste(hole_handbrake_hilfe())
|
||||
if hb_encoder:
|
||||
|
||||
Reference in New Issue
Block a user