Hitonabi/rippy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d15900d1ebe82e0b2ffaee05ebc631cf0127e7a6
rippy/docker/worker/ripping.py
T
Hitonabi d15900d1eb
Ampel / ampel (push) Failing after 29s
Details
fix(audio): nur die beste Tonspur pro Sprache verlustfrei kopieren
2026-07-26 20:55:57 +02:00

927 lines
36 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Ripping-Tasks: DVD/Blu-ray verlustfrei via MakeMKV (Etappe 10), CD via abcde.
Etappe 10 (23.07.2026): HandBrake ist aus dem Ripp-Pfad entfernt — das KONZEPT
verlangt verlustfreies Sichern (MakeMKV als Muss-Feature). HandBrake war ohnehin
nie im Worker-Image installiert; jeder Rip endete sofort mit "nicht installiert".
MakeMKV-Aufruf und Fortschritts-Format sind dokumentiert unter
https://www.makemkv.com/developers/usage.txt (Robot-Mode `-r`):
PRGV:current,total,max → Fortschritt gesamt = total/max
MSG:code,flags,... → Meldungen
(AGENTS Regel D: externe Schnittstellen nie aus dem Kopf.)
"""
import os
import re
import shutil
import subprocess
import tempfile
from winlauf import OHNE_FENSTER
RIP_OUTPUT_DIR = os.getenv("RIP_OUTPUT_DIR", "/app/media")
class RipAbbruch(Exception):
"""Kooperativer Abbruch: vom Fortschritts-Callback geworfen, wenn der
Nutzer den Job abgebrochen hat (Status 'canceling' in der DB)."""
# include/uapi/linux/cdrom.h — dieselben ioctls wie in api/devices.py
CDROMEJECT = 0x5309
CDROM_LOCKDOOR = 0x5329 # 1 = Tür verriegeln, 0 = entriegeln
CDROM_DRIVE_STATUS = 0x5326
CDROMCLOSETRAY = 0x5319
# Antworten von CDROM_DRIVE_STATUS (cdrom.h)
CDS_NO_DISC = 1
CDS_TRAY_OPEN = 2
CDS_DRIVE_NOT_READY = 3
CDS_DISC_OK = 4
# Wie lange auf die Schublade gewartet wird. Ein Laufwerk braucht dafür ein
# bis zwei Sekunden; fünf sind reichlich und blockieren nichts Wichtiges.
AUSWURF_WARTEN_SEKUNDEN = 5
def _auswurf_geglueckt(status: int) -> bool:
"""Ist die Disc nach dem Auswurf wirklich draußen? (pure Funktion)
Sowohl „Schublade offen" als auch „kein Datenträger" zählen: Ein
Slot-Laufwerk hat keine Schublade und meldet nach dem Auswerfen CDS_NO_DISC.
"""
return status in (CDS_TRAY_OPEN, CDS_NO_DISC)
def wirf_disc_aus(device_path: str, ioctl_fn=None, oeffnen=None,
schliessen=None, warten=None) -> bool:
"""Wirft die Disc aus und PRÜFT, ob sie draußen ist. Wirft NIE.
## Warum `CDROMEJECT` allein nicht genügt (Befund 26.07.2026, gemessen)
Der Commander meldete: „Der Button gibt es in den Settings, aber es passiert
nicht, das Laufwerk geht nicht auf." Am laufenden System nachgestellt:
wirf_disc_aus("/dev/sr0") → True
CDROM_DRIVE_STATUS danach → 4 (Disc drin)
Das ioctl wird also **angenommen und tut nichts**. Ursache: MakeMKV
verriegelt während des Rips die Laufwerkstür (`CDROM_LOCKDOOR 1`) und
entriegelt sie nicht wieder. Ein verriegeltes Laufwerk quittiert den Auswurf
trotzdem mit Erfolg. Deshalb macht das Werkzeug `eject` immer beides:
erst entriegeln, dann auswerfen. Gegenprobe an derselben Disc:
CDROM_LOCKDOOR 0 + CDROMEJECT → Status 2 (SCHUBLADE OFFEN)
## Und deshalb wird das Ergebnis geprüft, nicht geglaubt
Genau diese Sorte Fehler ist zweimal durchgerutscht: In v3.14 stand hier
„Auswurf tat nichts, jetzt entscheidet die Einstellung" — die Einstellung
wurde danach wirklich gelesen, nur ausgeworfen wurde weiterhin nicht, und im
Log stand „Disc ausgeworfen". Ein Rückgabewert eines ioctls beweist nichts;
gefragt wird jetzt das Laufwerk.
Bewusst hier und nicht in detection.py: das Modul ist ein byteweiser
Zwilling der API-Kopie. `fcntl` gibt es nur unter Linux — der native
Windows-Worker lädt ripping.py ebenfalls, rippt dort aber nie.
Die drei Parameter sind nur zum Testen einspritzbar (kein echtes Laufwerk).
"""
if ioctl_fn is None:
try:
from fcntl import ioctl
except ImportError: # Windows — dieser Worker rippt nie
return False
ioctl_fn = ioctl
if warten is None:
import time
warten = time.sleep
oeffnen = oeffnen or (lambda p: os.open(p, os.O_RDONLY | os.O_NONBLOCK))
schliessen = schliessen or os.close
try:
fd = oeffnen(device_path)
except OSError:
return False
try:
# Entriegeln ist der entscheidende Schritt. Scheitert er, wird der
# Auswurf trotzdem versucht — bei einem nicht verriegelten Laufwerk
# (oder einem, das das ioctl nicht kennt) klappt er ohnehin.
try:
ioctl_fn(fd, CDROM_LOCKDOOR, 0)
except OSError:
pass
try:
ioctl_fn(fd, CDROMEJECT, 0)
except OSError:
return False
# Nachsehen statt hoffen: Die Schublade braucht ein bis zwei Sekunden.
for _ in range(AUSWURF_WARTEN_SEKUNDEN):
try:
if _auswurf_geglueckt(ioctl_fn(fd, CDROM_DRIVE_STATUS, 0)):
return True
except OSError:
return False
warten(1)
return False
finally:
try:
schliessen(fd)
except OSError:
pass
def check_makemkv_installed() -> bool:
"""Prüft, ob makemkvcon installiert ist."""
return shutil.which("makemkvcon") is not None
def check_abcde_installed() -> bool:
"""Prüft, ob abcde installiert ist."""
return shutil.which("abcde") is not None
def check_cdparanoia_installed() -> bool:
"""Prüft, ob cdparanoia installiert ist."""
return shutil.which("cdparanoia") is not None
def build_makemkv_cmd(device_path: str, output_dir: str, titel: str = "all") -> list:
"""Baut das MakeMKV-Kommando (pure Funktion, testbar).
-r Robot-Mode: maschinenlesbare Ausgabe (PRGV/MSG-Zeilen)
--noscan KEIN Scan über alle Geräte — der brachte MakeMKV im
Container zum Hängen (1.18.4) bzw. Segfault (1.17.7):
/sys zeigt dort auch Geräte ohne /dev-Knoten (Befund 23.07.)
--progress=-same Fortschritt in denselben Stream wie die Meldungen
mkv dev:<pfad> <titel> <ziel> 'all' oder eine Titel-Nummer (Hauptfilm)
"""
return [
"makemkvcon",
"-r",
"--noscan",
"--progress=-same",
"mkv",
f"dev:{device_path}",
str(titel),
output_dir,
]
def parse_tinfo_dauern(ausgabe: str) -> dict:
"""TINFO-Zeilen → {titel_nr: dauer_sekunden} (pure Funktion, testbar).
makemkvcon-Robot-Format laut makemkv.com/developers/usage.txt:
TINFO:<titel>,<attr_id>,<code>,"<wert>" — Attribut 9 ist die Laufzeit
als "H:MM:SS" (ap_iaDuration).
"""
dauern = {}
for zeile in ausgabe.splitlines():
treffer = re.match(r'TINFO:(\d+),9,\d+,"(\d+):(\d{2}):(\d{2})"', zeile.strip())
if treffer:
nr, h, m, s = (int(g) for g in treffer.groups())
dauern[nr] = h * 3600 + m * 60 + s
return dauern
def parse_titel_info(ausgabe: str) -> list:
"""TINFO-Zeilen → volle Titel-Liste für die Auswahl-Tabelle (pure Funktion).
Attribut-IDs laut MakeMKV apdefs.h (makemkvgui/inc/lgpl/apdefs.h, LGPL):
8 = ChapterCount, 9 = Duration ("H:MM:SS"), 11 = DiskSizeBytes.
Rückgabe: [{"nr", "dauer_s", "groesse_bytes", "kapitel"}, …] sortiert.
"""
titel: dict = {}
for zeile in ausgabe.splitlines():
treffer = re.match(r'TINFO:(\d+),(\d+),\d+,"(.*)"\s*$', zeile.strip())
if not treffer:
continue
nr, attr, wert = int(treffer.group(1)), int(treffer.group(2)), treffer.group(3)
eintrag = titel.setdefault(nr, {"nr": nr, "dauer_s": 0, "groesse_bytes": 0, "kapitel": 0})
if attr == 9:
teile = wert.split(":")
if len(teile) == 3 and all(t.isdigit() for t in teile):
h, m, s = (int(t) for t in teile)
eintrag["dauer_s"] = h * 3600 + m * 60 + s
elif attr == 11 and wert.isdigit():
eintrag["groesse_bytes"] = int(wert)
elif attr == 8 and wert.isdigit():
eintrag["kapitel"] = int(wert)
return [titel[nr] for nr in sorted(titel)]
# Attribut-IDs der SINFO-Zeilen. Am 26.07.2026 an der Akira-Blu-ray im Laufwerk
# der Rippy-VM abgenommen (AGENTS Regel D):
#
# SINFO:0,1,1,6202,"Audio"
# SINFO:0,1,3,0,"deu"
# SINFO:0,1,4,0,"German"
# SINFO:0,1,6,0,"DTS-HD MA"
# SINFO:0,1,14,0,"2"
# SINFO:0,1,30,0,"DTS-HD MA Stereo German"
#
# ⚠️ Die Sprache steht in 3/4 — NICHT in 28/29. Die tragen auf JEDEM Stream
# „eng"/„English", auch auf dem Videostream einer deutschen Tonspur; das ist
# MakeMKVs eigene Anzeigesprache und nicht die des Tracks. Wer 28 nimmt, hält
# jede Disc für englisch.
SINFO_TYP = 1
SINFO_SPRACHE_CODE = 3
SINFO_SPRACHE_NAME = 4
SINFO_CODEC = 6
SINFO_KANAELE = 14
SINFO_BESCHREIBUNG = 30
SINFO_ZEILE = re.compile(r'SINFO:(\d+),(\d+),(\d+),\d+,"(.*)"\s*$')
def parse_stream_info(ausgabe: str) -> dict:
"""SINFO-Zeilen → Tonspuren und Untertitel je Titel (pure Funktion).
Commander-Anforderung 26.07.2026: *„Es muss verfügbar sein, dass man die
Sprache von Medien auswählen kann … Rippy muss VOR dem Rip fragen: Was genau
willst du haben?"* Die Auskunft liegt längst vor — der Titel-Scan liest sie
mit und hat sie bisher weggeworfen.
Rückgabe: {titel_nr: {"audio": [...], "untertitel": [...]}}, jeder Eintrag
{"nr", "lang", "sprache", "codec", "kanaele", "beschreibung"}.
"""
titel: dict = {}
for zeile in (ausgabe or "").splitlines():
treffer = SINFO_ZEILE.match(zeile.strip())
if not treffer:
continue
t_nr, s_nr, attr = (int(treffer.group(i)) for i in (1, 2, 3))
wert = treffer.group(4)
streams = titel.setdefault(t_nr, {})
eintrag = streams.setdefault(s_nr, {"nr": s_nr, "typ": "", "lang": "",
"sprache": "", "codec": "",
"kanaele": "", "beschreibung": ""})
if attr == SINFO_TYP:
eintrag["typ"] = wert
elif attr == SINFO_SPRACHE_CODE:
eintrag["lang"] = wert
elif attr == SINFO_SPRACHE_NAME:
eintrag["sprache"] = wert
elif attr == SINFO_CODEC:
eintrag["codec"] = wert
elif attr == SINFO_KANAELE:
eintrag["kanaele"] = wert
elif attr == SINFO_BESCHREIBUNG:
eintrag["beschreibung"] = wert
ergebnis = {}
for t_nr, streams in titel.items():
audio, untertitel = [], []
for s_nr in sorted(streams):
s = streams[s_nr]
# MakeMKV schreibt „Subtitles" (englisch, Plural) — gemessen.
if s["typ"] == "Audio":
audio.append(s)
elif s["typ"].startswith("Subtitle"):
untertitel.append(s)
ergebnis[t_nr] = {"audio": audio, "untertitel": untertitel}
return ergebnis
def sprachen_zusammenfassen(streams_je_titel: dict) -> dict:
"""Welche Sprachen hat die DISC insgesamt? (pure Funktion)
Für die Frage vor dem Rip zählt nicht Titel 3 Stream 7, sondern: „Diese Disc
hat Ton auf Deutsch, Englisch und Japanisch, Untertitel auf Deutsch und
Englisch." Deshalb über alle Titel vereinigt, Reihenfolge stabil (so wie sie
auf der Disc stehen).
Rückgabe: {"audio": [{"lang","sprache","spuren"}], "untertitel": [...]}
"""
def sammeln(schluessel):
gefunden = {}
for streams in (streams_je_titel or {}).values():
for s in streams.get(schluessel) or []:
code = s.get("lang") or ""
if not code:
continue
eintrag = gefunden.setdefault(
code, {"lang": code, "sprache": s.get("sprache") or code,
"spuren": 0})
eintrag["spuren"] += 1
return list(gefunden.values())
return {"audio": sammeln("audio"), "untertitel": sammeln("untertitel")}
def lies_titel_info(device_path: str, timeout: int = 300) -> tuple:
"""(Titel-Liste, Streams je Titel) der eingelegten Disc — EIN Info-Lauf.
Beides aus demselben Aufruf: Ein `makemkvcon info` dauert je Disc 20–120 s,
und die Sprach-Auskunft steht in derselben Ausgabe. Sie zweimal zu holen
wäre eine Minute Wartezeit für nichts.
"""
ergebnis = subprocess.run(
["makemkvcon", "-r", "--noscan", "info", f"dev:{device_path}"],
capture_output=True, text=True, timeout=timeout,
creationflags=OHNE_FENSTER,
)
ausgabe = ergebnis.stdout or ""
return parse_titel_info(ausgabe), parse_stream_info(ausgabe)
def rip_titel_auswahl(device_path: str, output_dir: str, titel_liste: list,
progress_cb=None, log_cb=None) -> dict:
"""Rippt GENAU die gewählten Titel (makemkvcon kann pro Aufruf nur einen
Titel oder 'all' — also ein Aufruf je Titel, Fortschritt anteilig)."""
gesamt = len(titel_liste)
alle_dateien = []
for index, nr in enumerate(titel_liste):
def anteilig(p, _i=index):
if progress_cb:
progress_cb(int((_i * 100 + p) / gesamt))
ergebnis = run_makemkv(device_path, output_dir, progress_cb=anteilig, titel=str(nr),
log_cb=log_cb)
if ergebnis.get("status") == "cancelled":
return ergebnis
if ergebnis.get("status") != "success":
ergebnis["error"] = f"Titel {nr}: {ergebnis.get('error')}"
return ergebnis
alle_dateien = ergebnis.get("files", []) # kumulativ: run_makemkv listet den Ordner
return {"status": "success", "output_dir": output_dir, "files": alle_dateien}
def laengster_titel(dauern: dict):
"""Titel-Nummer mit der längsten Laufzeit — der Hauptfilm (pure Funktion)."""
if not dauern:
return None
return max(dauern, key=dauern.get)
def lies_titel_dauern(device_path: str, timeout: int = 300) -> dict:
"""Fragt die Titel-Laufzeiten der Disc ab (makemkvcon info, Robot-Mode)."""
try:
ergebnis = subprocess.run(
["makemkvcon", "-r", "--noscan", "info", f"dev:{device_path}"],
capture_output=True, text=True, timeout=timeout,
creationflags=OHNE_FENSTER,
)
except (OSError, subprocess.TimeoutExpired):
return {}
return parse_tinfo_dauern(ergebnis.stdout or "")
def parse_scan_dauer(ausgabe: str) -> int:
"""HandBrake-Scan-Ausgabe → Dauer in Sekunden (pure Funktion, testbar).
HandBrakeCLI --scan schreibt je Titel "+ duration: HH:MM:SS"
(handbrake.fr/docs, Scan-Ausgabe); bei einer MKV-Datei gibt es genau
einen Titel.
"""
treffer = re.search(r"\+ duration: (\d+):(\d{2}):(\d{2})", ausgabe)
if not treffer:
return 0
h, m, s = (int(g) for g in treffer.groups())
return h * 3600 + m * 60 + s
def lies_datei_dauer(pfad: str, timeout: int = 120) -> int:
"""Laufzeit einer MKV-Datei in Sekunden (HandBrakeCLI --scan)."""
if not check_handbrake_installed():
return 0
try:
ergebnis = subprocess.run(
["HandBrakeCLI", "--scan", "-i", pfad],
capture_output=True, text=True, timeout=timeout,
creationflags=OHNE_FENSTER,
)
except (OSError, subprocess.TimeoutExpired):
return 0
return parse_scan_dauer((ergebnis.stdout or "") + (ergebnis.stderr or ""))
_MSG_RE = re.compile(r'^MSG:(\d+),\d+,\d+,"((?:[^"\\]|\\.)*)"')
def parse_msg(zeile: str):
"""MSG-Zeile -> (code, klartext) oder None (pure Funktion, testbar).
Format laut https://www.makemkv.com/developers/usage.txt:
MSG:code,flags,count,"message","format","param0",... — Feld 4 ist der
fertig zusammengesetzte Klartext.
Bis zum 25.07.2026 stand hier line.split(",", 4)[3]: das schnitt JEDE
Meldung ab, die selbst ein Komma enthält — und MakeMKV schreibt solche
laufend ("Title #1 has length of 12 seconds, which is less than ...").
Deshalb eine Regex, die die Anführungszeichen respektiert.
"""
treffer = _MSG_RE.match(zeile.strip())
if not treffer:
return None
return int(treffer.group(1)), treffer.group(2).replace('\\"', '"')
def get_progress_from_prgv(line: str) -> int:
"""Extrahiert Gesamt-Fortschritt (0-100) aus einer PRGV-Zeile.
Format laut MakeMKV-Doku: PRGV:current,total,max
`total` ist der Gesamtfortschritt, `max` die Skala (65536).
"""
match = re.match(r"PRGV:(\d+),(\d+),(\d+)", line.strip())
if not match:
return -1
total, maximum = int(match.group(2)), int(match.group(3))
if maximum <= 0:
return -1
return min(100, int(total * 100 / maximum))
def check_handbrake_installed() -> bool:
"""Prüft, ob HandBrakeCLI installiert ist."""
return shutil.which("HandBrakeCLI") is not None
DEFAULT_HB_PRESET = "H.265 MKV 1080p30"
# Ein Preset je Disc-Typ (Befund 25.07.2026). Vorher galt EIN Preset für
# alles: eine 4K-UHD wurde damit auf 1080p heruntergerechnet und eine DVD auf
# 1080p hochskaliert — beides Unsinn, und beim ersten UHD-Rip wäre die 4K-
# Auflösung still verlorengegangen. Den Disc-Typ kennt Rippy ohnehin.
PRESET_SCHLUESSEL = {
"dvd": "transcodePresetDvd",
"bluray": "transcodePresetBluray",
"uhd": "transcodePresetUhd",
}
# Reservierter Wert im Preset-Feld eines Disc-Typs: „diesen Typ NICHT
# komprimieren". Kein HandBrake-Preset heißt so (gegengeprüft gegen alle 90 aus
# --preset-list), deshalb kann er nicht mit einem echten Namen kollidieren.
#
# Warum es das gibt (Befund 25.07.2026): Ein 4K-HEVC-Encode brauchte auf der
# Rippy-VM gemessene 28-55 Stunden, weil die CPU kein AVX2 hat. Bis hierher gab
# es nur einen globalen Schalter — entweder ALLES komprimieren oder nichts. Wer
# 4K verlustfrei behalten und DVDs trotzdem schrumpfen wollte, hatte keine
# Möglichkeit. Genau die ist das hier.
PRESET_KEINE = "keine"
def komprimieren_fuer(disc_type: str, einstellungen: dict) -> bool:
"""Soll dieser Disc-Typ nach dem Rip komprimiert werden? (pure, testbar)
Der globale Schalter `transcodeEnabled` schlägt alles. Ist er an, kann ein
einzelner Disc-Typ abgewählt werden, indem sein Preset auf PRESET_KEINE
steht — dann bleibt die verlustfreie Datei aus dem Rip stehen.
"""
einstellungen = einstellungen or {}
if not einstellungen.get("transcodeEnabled", True):
return False
schluessel = PRESET_SCHLUESSEL.get(disc_type or "")
if schluessel and (einstellungen.get(schluessel) or "").strip() == PRESET_KEINE:
return False
return True
def preset_fuer(disc_type: str, einstellungen: dict) -> str:
"""Welches HandBrake-Preset gilt für diesen Disc-Typ? (pure, testbar)
Reihenfolge: Preset des Disc-Typs → allgemeines transcodePreset →
DEFAULT_HB_PRESET. Diese Kette hält Bestandsinstallationen am Leben, in
denen nur `transcodePreset` gesetzt ist: solange der Nutzer die neuen
Felder nicht speichert, ändert sich sein Verhalten nicht.
PRESET_KEINE gilt hier absichtlich als „nicht gesetzt" und wird
übersprungen: Diese Funktion darf NIE den Reservewert als Preset-Namen
zurückgeben, sonst bekäme HandBrake `--preset keine` und scheiterte. Ob
überhaupt komprimiert wird, entscheidet komprimieren_fuer(). Wer über
„Neu komprimieren" ausdrücklich doch komprimieren will, bekommt so ein
brauchbares Preset statt eines Fehlers.
"""
einstellungen = einstellungen or {}
schluessel = PRESET_SCHLUESSEL.get(disc_type or "")
if schluessel:
eigen = (einstellungen.get(schluessel) or "").strip()
if eigen and eigen != PRESET_KEINE:
return eigen
return (einstellungen.get("transcodePreset") or "").strip() or DEFAULT_HB_PRESET
def build_handbrake_cmd(input_path: str, output_path: str,
preset: str = DEFAULT_HB_PRESET,
audio_sprachen=None, untertitel_sprachen=None) -> list:
"""Baut das HandBrake-Kommando für die Kompressions-Stufe (pure Funktion).
Arbeitet auf der MKV-DATEI aus dem MakeMKV-Rip — nie auf dem Laufwerk:
HandBrake kann AACS-verschlüsselte Blu-rays nicht lesen, MakeMKV bleibt
deshalb zwingend die erste Stufe. --all-audio/--all-subtitles behalten
alle Sprachen (Preset-Default wäre nur die erste Tonspur).
## Die Sprachauswahl greift HIER, nicht beim Rippen
Commander-Anforderung 26.07.2026. Bewusst in der KOMPRESSION und nicht im
Rip, aus drei Gründen:
1. Der Rip bleibt vollständig und verlustfrei — das ist ein Muss-Feature
(KONZEPT). Wer später eine andere Sprachwahl will, komprimiert neu, statt
die Disc wieder einzulegen.
2. MakeMKV kann Tracks nur über eine Auswahl-Profildatei filtern; HandBrake
hat dafür dokumentierte Schalter, die genau die Codes nehmen, die MakeMKV
liefert (ISO 639-2, „deu"/„eng" — beides am 26.07.2026 gegengeprüft).
3. Wird ein Disc-Typ NICHT komprimiert (4K verlustfrei), bleiben ohnehin alle
Sprachen drin — und das ist bei einer verlustfreien Ablage richtig.
`--audio-lang-list` zusammen mit `--first-audio` heißt: HandBrake pickt pro
Sprache genau die erste (beste) Tonspur heraus. `--audio-codec copy` reicht
diese dann verlustfrei durch, statt sie auf Stereo herunterzurechnen.
"""
befehl = [
"HandBrakeCLI",
"--input", input_path,
"--output", output_path,
"--preset", preset,
]
audio = [s for s in (audio_sprachen or []) if s]
if audio:
befehl += ["--audio-lang-list", ",".join(audio)]
befehl.append("--first-audio")
befehl += ["--audio-codec", "copy", "--audio-fallback", "av_aac"]
untertitel = [s for s in (untertitel_sprachen or []) if s]
if untertitel:
befehl += ["--subtitle-lang-list", ",".join(untertitel)]
befehl.append("--all-subtitles")
return befehl
HB_ENCODE_RE = re.compile(
r'^Encoding:\s*task\s+(\d+)\s+of\s+(\d+),\s*(\d+(?:\.\d+)?)\s*%'
)
def get_progress_from_line(line: str) -> int:
"""Extrahiert den ENCODE-Fortschritt in Prozent aus HandBrake-Ausgabe.
Gibt **-1** zurück, wenn die Zeile kein Encode-Fortschritt ist — genau wie
get_progress_from_prgv. Sonst wäre ein echtes „0 %" nicht von „keine
Angabe" zu unterscheiden, und der Anfang des Encodes bliebe unsichtbar.
Formatstrings aus dem HandBrakeCLI-Binary im Worker-Image gelesen
(AGENTS Regel D — nicht aus dem Kopf):
Scanning title %d of %d, preview %d, %.2f %% → Scan, NICHT Encode
Encoding: task %d of %d, %.2f %% (%.2f fps, avg → Encode
Encoding: task %d of %d, Searching for start time, %.2f → Vorlauf, NICHT Encode
Befund 25.07.2026 (Akira-UHD, live gemessen): Die alte Regex nahm JEDE
Zahl vor einem Prozentzeichen — also auch den Scan-Durchlauf, der VOR dem
Encodieren einmal bis 100 % hochläuft. Die Anzeige stand deshalb auf 99 %,
während der eigentliche Encode bei 1 % war. Zusammen mit dem alten Filter
`progress > 0` im Aufrufer blieb sie dort stundenlang kleben, weil
int(0.87) == 0 verworfen wurde.
`task N of M` wird mitgerechnet: Presets mit zwei Durchläufen zählen die
Prozente je Durchlauf neu, sonst sprang die Anzeige mitten in der Datei
zurück auf 0.
"""
match = HB_ENCODE_RE.match(line.strip())
if not match:
return -1
aktuell, gesamt, prozent = int(match.group(1)), int(match.group(2)), float(match.group(3))
if gesamt < 1 or aktuell < 1:
return -1
return int(((aktuell - 1) * 100 + prozent) / gesamt)
def sprachliste(wert) -> list:
"""„deu, eng , ,DEU" → ["deu", "eng"] (pure Funktion).
Nimmt Komma-Text aus den Einstellungen oder eine fertige Liste. Doppelte und
Leeres fliegen raus, Kleinschreibung wird erzwungen — HandBrake will
ISO-639-2 in Kleinbuchstaben, und ein „DEU" aus einem Eingabefeld soll nicht
still die ganze Auswahl unwirksam machen.
"""
if not wert:
return []
teile = wert.split(",") if isinstance(wert, str) else list(wert)
sauber = []
for t in teile:
code = str(t).strip().lower()
if code and code not in sauber:
sauber.append(code)
return sauber
def run_handbrake(input_path: str, output_path: str, preset: str = DEFAULT_HB_PRESET,
progress_cb=None, abbruch_cb=None,
audio_sprachen=None, untertitel_sprachen=None) -> dict:
"""Komprimiert eine MKV-Datei mit HandBrakeCLI; meldet Fortschritt.
`abbruch_cb` wird bei JEDER Ausgabezeile aufgerufen und soll RipAbbruch
werfen, wenn der Nutzer abgebrochen hat. Bewusst ein eigener Kanal neben
`progress_cb` — aus demselben Grund wie `log_cb` bei run_makemkv: der
Fortschritts-Callback verwirft Aufrufe mit unveränderter Prozentzahl, und
genau daran hing der Abbruch früher. Bei einem 4K-Encode mit einem Prozent
je halber Stunde sah „Abbrechen" deshalb minutenlang wirkungslos aus
(Befund 25.07.2026). Zusätzlich greift es damit auch während des
Scan-Durchlaufs, der gar keine Encode-Prozente ausgibt.
"""
if not check_handbrake_installed():
return {"status": "error", "error": "HandBrakeCLI ist nicht installiert"}
try:
process = subprocess.Popen(
build_handbrake_cmd(input_path, output_path, preset,
audio_sprachen, untertitel_sprachen),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
bufsize=1,
creationflags=OHNE_FENSTER,
)
return _handbrake_schleife(process, output_path, abbruch_cb, progress_cb)
except Exception as e:
return {"status": "error", "error": str(e)}
def unbekanntes_preset(zeile: str) -> str:
"""Meldet HandBrake diese Zeile ein UNBEKANNTES Preset? Name oder "".
Wortlaut aus dem echten Lauf im Worker-Image (26.07.2026, AGENTS Regel D):
$ HandBrakeCLI --preset 'Gibt Es Nicht 999p' …
Invalid preset Gibt Es Nicht 999p
Valid presets are:
Ohne diese Übersetzung stand im UI nur „HandBrake endete mit Code 3" —
und die eigentliche Ursache (ein Preset-Name, den DIESES HandBrake nicht
kennt) war daraus nicht zu erraten. Genau dieser Fall wird häufiger, weil
die Namen je HandBrake-Version verschieden sind und ein Remote-Worker eine
andere Version haben kann als die Rippy-VM.
"""
text = (zeile or "").strip()
kopf = "Invalid preset "
return text[len(kopf):].strip() if text.startswith(kopf) else ""
def _handbrake_schleife(process, output_path: str, abbruch_cb=None, progress_cb=None) -> dict:
"""Liest HandBrakes Ausgabe und wertet sie aus. Eigene Funktion, damit die
Reihenfolge (Abbruch VOR Fortschritt) ohne echtes HandBrake testbar ist."""
falsches_preset = ""
try:
for line in process.stdout:
# Zuerst der Abbruch — unabhängig davon, ob die Zeile überhaupt
# einen Fortschritt enthält. Sonst hängt „Abbrechen" daran, dass
# sich die Prozentzahl bewegt (Befund 25.07.2026).
if abbruch_cb:
abbruch_cb()
if not falsches_preset:
falsches_preset = unbekanntes_preset(line)
progress = get_progress_from_line(line)
# >= 0: ein echtes 0 % ist eine Angabe und muss durch. Der alte
# Filter `> 0` verwarf den gesamten ersten Prozentpunkt — bei
# einem 4K-Encode sind das Stunden ohne sichtbare Bewegung.
if progress >= 0 and progress_cb:
progress_cb(progress)
except RipAbbruch:
process.kill()
process.wait()
return {"status": "cancelled", "error": "Abgebrochen durch Nutzer"}
process.wait()
if process.returncode == 0 and os.path.exists(output_path):
return {"status": "success", "output_path": output_path}
if falsches_preset:
return {
"status": "error",
"error": (
f'Das HandBrake dieses Workers kennt das Preset „{falsches_preset}" '
'nicht. Preset-Namen unterscheiden sich zwischen '
'HandBrake-Versionen. Abhilfe: Einstellungen → Verarbeitung, dort '
'auf „Bestes wählen" klicken — die Liste dort kommt vom Worker '
'selbst und enthält nur Namen, die es wirklich gibt.'
),
"return_code": process.returncode,
}
return {
"status": "error",
"error": f"HandBrake endete mit Code {process.returncode}",
"return_code": process.returncode,
}
def build_abcde_cmd(device_path: str, config_path: str, auswerfen: bool = True) -> list:
"""Baut das abcde-Kommando (pure Funktion, testbar).
-o = Ausgabeformat (flac), -N = nicht-interaktiv, -x = Eject am Ende,
-c = Config-Datei (enthält OUTPUTDIR). NIE ein Verzeichnis an -o geben.
Befund 25.07.2026: `-x` stand fest verdrahtet drin. Damit warf eine
Audio-CD IMMER aus, während eine DVD/Blu-ray NIE auswarf — und die
Einstellung „Automatischer Auswurf" regelte keines von beidem, weil sie
nirgends gelesen wurde. Jetzt entscheidet sie hier mit.
"""
cmd = [
"abcde",
"-d", device_path,
"-o", "flac",
"-N",
]
if auswerfen:
cmd.append("-x")
cmd += ["-c", config_path]
return cmd
def write_abcde_config(output_dir: str) -> str:
"""Schreibt eine minimale abcde-Config mit dem Zielverzeichnis, gibt Pfad zurück."""
tmp = tempfile.NamedTemporaryFile(
"w", suffix=".abcde.conf", delete=False, encoding="utf-8"
)
tmp.write(f"OUTPUTDIR='{output_dir}'\nINTERACTIVE=n\n")
tmp.close()
return tmp.name
def run_makemkv(device_path: str, output_dir: str, progress_cb=None, titel: str = "all",
log_cb=None) -> dict:
"""Rippt eine DVD/Blu-ray verlustfrei mit makemkvcon; meldet Fortschritt.
log_cb(code, text) bekommt JEDE MakeMKV-Meldung. Bewusst ein eigener
Kanal statt progress_cb: der Fortschritts-Callback in tasks.py verwirft
Aufrufe, bei denen sich die Prozentzahl nicht geaendert hat — Meldungen
wären dort also großteils verschwunden. Ohne diesen Kanal war am
25.07.2026 nicht von aussen erkennbar, dass MakeMKV bei der UHD-Disc
nicht einmal versucht, einen Schluessel zu holen (siehe makemkv_daten).
"""
if not check_makemkv_installed():
return {"status": "error", "error": "makemkvcon ist nicht installiert"}
os.makedirs(output_dir, exist_ok=True)
try:
process = subprocess.Popen(
build_makemkv_cmd(device_path, output_dir, titel),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
bufsize=1,
creationflags=OHNE_FENSTER,
)
letzte_meldung = ""
# Kritische Meldungen einsammeln: die LETZTE Zeile ist fast immer nur
# "Failed to open disc" — die URSACHE ("volume key is unknown", Key
# abgelaufen) steht Zeilen davor und ging im Fehlertext verloren
# (Befund 24.07., Summer-Wars-UHD).
kritische_meldungen = []
KRITISCH = (
"volume key is unknown",
"evaluation period has expired",
"registration key",
"Too old version",
)
try:
for line in process.stdout:
progress = get_progress_from_prgv(line)
if progress >= 0:
if progress_cb:
progress_cb(progress)
continue
meldung = parse_msg(line)
if meldung is None:
continue
code, letzte_meldung = meldung
if any(muster in letzte_meldung for muster in KRITISCH):
kritische_meldungen.append(letzte_meldung)
if log_cb:
try:
log_cb(code, letzte_meldung)
except RipAbbruch:
raise
except Exception:
pass # Protokollieren darf einen laufenden Rip nie beenden
except RipAbbruch:
process.kill()
process.wait()
return {"status": "cancelled", "error": "Abgebrochen durch Nutzer"}
process.wait()
mkv_dateien = [
os.path.join(output_dir, f)
for f in sorted(os.listdir(output_dir))
if f.endswith(".mkv")
]
if process.returncode == 0 and mkv_dateien:
return {
"status": "success",
"output_dir": output_dir,
"files": mkv_dateien,
"return_code": process.returncode,
}
return {
"status": "error",
"error": (
f"makemkvcon endete mit Code {process.returncode}"
+ (f" — Ursache: {'; '.join(kritische_meldungen)}" if kritische_meldungen else "")
+ (f" — letzte Meldung: {letzte_meldung}" if letzte_meldung else "")
+ ("" if mkv_dateien else " — keine MKV-Datei entstanden")
),
"return_code": process.returncode,
}
except Exception as e:
return {"status": "error", "error": str(e)}
def rip_video(device_path: str, disc_id: str, disc_type: str = "dvd", progress_cb=None,
output_dir: str = None, nur_hauptfilm: bool = False,
titel_liste: list = None, log_cb=None) -> dict:
"""Rippt eine DVD oder Blu-ray verlustfrei mit MakeMKV.
Bewusst KEIN eigener Celery-Task: der einzige Task ist worker.tasks.rip_disc,
der hier mit seinem eigenen Fortschritts-Callback durchgreift. output_dir
überschreibt das Ziel (Transcode-Fall: Roh-Rip nach /app/temp).
titel_liste: exakte Titel-Auswahl aus dem UI (schlägt nur_hauptfilm).
nur_hauptfilm: Vorab-Info-Lauf, dann nur den LÄNGSTEN Titel rippen —
das löst das eingestellte (vorher wirkungslose) mainFeatureOnly ein.
"""
if output_dir is None:
output_dir = os.path.join(RIP_OUTPUT_DIR, disc_type, disc_id)
if titel_liste:
os.makedirs(output_dir, exist_ok=True)
return rip_titel_auswahl(device_path, output_dir, titel_liste, progress_cb, log_cb)
titel = "all"
if nur_hauptfilm:
dauern = lies_titel_dauern(device_path)
haupt = laengster_titel(dauern)
if haupt is not None:
titel = str(haupt)
# Kein Titel ermittelbar → ehrlich auf 'all' zurückfallen statt raten
return run_makemkv(device_path, output_dir, progress_cb=progress_cb, titel=titel,
log_cb=log_cb)
def rip_cd(device_path: str, disc_id: str, progress_cb=None, output_dir: str = None,
auswerfen: bool = True) -> dict:
"""Rippt eine CD mit abcde (FLAC). `auswerfen` = Einstellung „Automatischer
Auswurf" (abcde macht das selbst per -x)."""
if not check_abcde_installed():
return {
"status": "error",
"error": "abcde ist nicht installiert. Installiere abcde und cdparanoia für CD-Ripping."
}
if not check_cdparanoia_installed():
return {
"status": "error",
"error": "cdparanoia ist nicht installiert. Installiere abcde und cdparanoia für CD-Ripping."
}
if output_dir is None:
output_dir = os.path.join(RIP_OUTPUT_DIR, "cd", disc_id)
os.makedirs(output_dir, exist_ok=True)
def melde(progress: int, message: str = ""):
if progress_cb:
progress_cb(progress, message)
config_path = write_abcde_config(output_dir)
try:
process = subprocess.Popen(
build_abcde_cmd(device_path, config_path, auswerfen=auswerfen),
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
text=True,
bufsize=1,
creationflags=OHNE_FENSTER,
)
try:
for line in process.stdout:
melde(50, line.strip()[:200])
except RipAbbruch:
process.kill()
process.wait()
return {"status": "cancelled", "error": "Abgebrochen durch Nutzer"}
process.wait()
if process.returncode == 0:
melde(90, "MusicBrainz Lookup abgeschlossen")
return {
"status": "success",
"output_dir": output_dir,
"return_code": process.returncode
}
return {
"status": "error",
"error": f"abcde failed with code {process.returncode}",
"return_code": process.returncode
}
except Exception as e:
return {"status": "error", "error": str(e)}
finally:
try:
os.unlink(config_path)
except OSError:
pass
Reference in New Issue View Git Blame Copy Permalink