"""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 # Auswurf und ioctl-Konstanten leben seit V2-1 im gemeinsamen Treiber # (rippy/drives/linux.py). Vorher stand derselbe Ablauf ZWEIMAL im Repo — # hier und in docker/api/devices.py, mit unterschiedlichen Vertraegen. # # Die Namen werden hier weiter angeboten, weil tasks.py und die Tests sie so # kennen; `wirf_disc_aus` ist der Worker-Vertrag (gibt False zurueck, wirft nie). from rippy.drives.linux import ( # noqa: F401 AUSWURF_WARTEN_SEKUNDEN, CDROM_DRIVE_STATUS, CDROM_LOCKDOOR, CDROMCLOSETRAY, CDROMEJECT, CDS_DISC_OK, CDS_DRIVE_NOT_READY, CDS_NO_DISC, CDS_TRAY_OPEN, _auswurf_geglueckt, ) from rippy.drives.linux import auswerfen_versuchen as wirf_disc_aus # noqa: F401 from rippy.platform.winlauf import OHNE_FENSTER from rippy.rip.makemkv_aufruf import KRITISCHE_CODES, text_von from rippy.rip.makemkv_aufruf import quelle as makemkv_quelle from rippy.tools import katalog as werkzeuge _NACKTER_NAME = {"makemkv": "makemkvcon", "handbrake": "HandBrakeCLI"} def werkzeug(name: str) -> str: """Der Pfad zu einem Werkzeug — oder sein blosser Name als Rueckfall. ## Warum hier nicht mehr `shutil.which` steht Bis V2-4 stand ueberall in dieser Datei der nackte Programmname ("makemkvcon", "HandBrakeCLI"). Im Container stimmt das — dort liegen beide in /usr/local/bin. **Unter Windows findet es NICHTS**, auch wenn beide installiert sind: Windows-Programme liegen in Program Files und stehen nicht im PATH. Am 28.08.2026 auf dem Commander-PC nachgesehen — MakeMKV lag da, und `shutil.which` sah es nicht. Fuer einen Rippy, der unter Windows eigenstaendig arbeiten soll, ist das der Unterschied zwischen "laeuft" und "laeuft nicht". Der Rueckfall auf den blossen Namen ist Absicht: Im Container aendert sich damit NICHTS — subprocess findet das Programm dort ueber den PATH wie bisher. """ return werkzeuge.finden(name) or _NACKTER_NAME[name] 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).""" def check_makemkv_installed() -> bool: """Prüft, ob makemkvcon installiert ist.""" return bool(werkzeuge.finden("makemkv")) 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: 'all' oder eine Titel-Nummer (Hauptfilm) """ return [ werkzeug("makemkv"), "-r", "--noscan", "--progress=-same", "mkv", makemkv_quelle(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:,,,"" — 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( [werkzeug("makemkv"), "-r", "--noscan", "info", makemkv_quelle(device_path)], capture_output=True, timeout=timeout, # binaer: siehe text_von creationflags=OHNE_FENSTER, ) ausgabe = text_von(ergebnis.stdout) 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, meta: dict = None): """Titel-Nummer für den Hauptfilm (pure Funktion). Mit meta['runtime'] wird heuristisch der Titel gesucht, dessen Laufzeit am nächsten an der TMDB-Laufzeit liegt (vermeidet 'Play All'-Tracks, die länger als der Film sind). Ohne runtime wird klassisch der längste Titel gewählt. """ if not dauern: return None ziel_s = (meta.get("runtime") or 0) * 60 if meta else 0 if ziel_s > 0: bester = min(dauern, key=lambda t: abs(dauern[t] - ziel_s)) if abs(dauern[bester] - ziel_s) <= 20 * 60: return bester return max(dauern, key=dauern.get) def episoden_titel(dauern: dict, meta: dict) -> list: """Findet Episoden-Titel anhand der TMDB-Episoden-Laufzeiten. Toleranz: +/- 10 Minuten (600 Sekunden) zum Durchschnitt. Gibt eine sortierte Liste der gefundenen Titelnummern zurück. """ if not dauern or not meta or not meta.get("episode_runtimes"): return [] runtimes_s = [r * 60 for r in meta["episode_runtimes"]] avg_runtime = sum(runtimes_s) / len(runtimes_s) gefundene_titel = [] for titel, dauer in dauern.items(): if abs(dauer - avg_runtime) <= 10 * 60: gefundene_titel.append(int(titel)) return sorted(gefundene_titel) 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( [werkzeug("makemkv"), "-r", "--noscan", "info", makemkv_quelle(device_path)], capture_output=True, timeout=timeout, # binaer: siehe text_von creationflags=OHNE_FENSTER, ) except (OSError, subprocess.TimeoutExpired): return {} return parse_tinfo_dauern(text_von(ergebnis.stdout)) 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( [werkzeug("handbrake"), "--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 bool(werkzeuge.finden("handbrake")) 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 #: Endung -> HandBrake-Container. Am mitgelieferten HandBrake 1.11.2 #: gegengeprueft (`--help`, Abschnitt `-f, --format`). FORMATE = {".mkv": "av_mkv", ".mp4": "av_mp4", ".m4v": "av_mp4", ".mov": "av_mov", ".webm": "av_webm"} 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 = [ werkzeug("handbrake"), "--input", input_path, "--output", output_path, "--preset", preset, ] # Den Container zur Endung erzwingen (Befund 29.08.2026). # # Commander: „Kompression fehlgeschlagen bei title_t00.mkv: HandBrake # endete mit Code 0" # # Code 0 heisst bei HandBrake ERFOLG — und trotzdem lag am erwarteten Ort # keine Datei. Der Grund: **HandBrake bestimmt den Container aus dem # Preset, nicht aus der Endung.** Steht ein MP4-Preset ein, schreibt es # `title_t00.mp4` neben das verlangte `title_t00.mkv`, meldet „Output # format changed" — und beendet sich mit 0. Rippy sah an seiner Stelle # nichts und nannte das „fehlgeschlagen". # # `-f/--format` ist der dokumentierte Schalter dafuer (an dem # mitgelieferten HandBrake 1.11.2 gegengeprueft: av_mp4, av_mov, av_mkv, # av_webm). Damit sind Endung und Container EINE Entscheidung statt zwei, # die auseinanderlaufen koennen. format_name = FORMATE.get(os.path.splitext(output_path)[1].lower()) if format_name: befehl += ["--format", format_name] 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 _datei_daneben(erwartet: str) -> str: """Dieselbe Datei mit anderer Endung im selben Ordner — oder "". HandBrake waehlt den Container nach dem Preset. Passt er nicht zur verlangten Endung, liegt das Ergebnis unter demselben Namen mit anderer Endung daneben (Befund 29.08.2026). Gesucht wird nur in den Endungen, die HandBrake ueberhaupt schreiben kann. """ ordner = os.path.dirname(erwartet) stamm = os.path.splitext(os.path.basename(erwartet))[0] for endung in FORMATE: kandidat = os.path.join(ordner, stamm + endung) if kandidat != erwartet and os.path.isfile(kandidat): return kandidat return "" 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} # Code 0, aber die Datei fehlt: HandBrake hat sie woanders hingeschrieben. # # Commander 29.08.2026: „Kompression fehlgeschlagen bei title_t00.mkv: # HandBrake endete mit Code 0". Code 0 heisst ERFOLG — HandBrake meldet # Fehler notorisch nicht ueber den Rueckgabewert. Der haeufigste Fall ist # der Container: Er kommt aus dem PRESET, nicht aus der Endung. Ein # MP4-Preset schreibt `title_t00.mp4` neben das verlangte `.mkv`. # # Verhindert wird das jetzt mit `--format` (siehe build_handbrake_cmd). # Dieser Zweig bleibt trotzdem: Er FINDET die Datei, statt einen # erfolgreichen Lauf wegzuwerfen — und sagt, was passiert ist. if process.returncode == 0: daneben = _datei_daneben(output_path) if daneben: return {"status": "success", "output_path": daneben, "hinweis": "HandBrake hat %s geschrieben statt %s " "(der Container kommt aus dem Preset)." % (os.path.basename(daneben), os.path.basename(output_path))} return { "status": "error", "error": ("HandBrake meldet Erfolg, aber es ist keine Datei " "entstanden. Meist ist der Zielordner nicht " "beschreibbar: %s" % os.path.dirname(output_path)), "return_code": 0, } 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, # BINAER lesen und selbst dekodieren (siehe `text_von`): # `text=True` nahm die Gebietsschema-Kodierung, makemkvcon # schrieb aber UTF-8 — daraus wurde beim Commander # „Das Öffnen der Disk schlug fehl". # # bufsize=0 statt 1: Zeilenpufferung gibt es im Binaermodus # nicht (Python warnt und puffert doch). Ungepuffert kommt # jede Fortschrittszeile sofort an — bei einem Rip, der # Stunden laeuft, ist das der Unterschied zwischen einem # Balken und einem eingefrorenen Fenster. bufsize=0, 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 = [] # Die Textmuster bleiben als Rueckfall fuer englische Installationen — # die MELDUNGSNUMMERN sind aber die verlaessliche Quelle. Beim # Commander meldet MakeMKV deutsch, also traf hier am 29.08.2026 kein # einziges Muster: Im Fehler stand nur „Das Öffnen der Disk schlug # fehl", waehrend die Ursache eine Zeile darueber („Der Testzeitraum # ist abgelaufen", MSG 5051) unter den Tisch fiel. KRITISCH = ( "volume key is unknown", "evaluation period has expired", "registration key", "Too old version", ) try: for rohzeile in process.stdout: line = text_von(rohzeile) 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 code in KRITISCHE_CODES: kritische_meldungen.append( "%s (%s)" % (KRITISCHE_CODES[code], letzte_meldung.strip())) elif 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, meta: dict = 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 heuristisch den besten Titel rippen. """ 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) # Serien-Erkennung: Wenn keine Titel explizit gewählt wurden und es eine Serie ist if meta and meta.get("series") and meta.get("episode_runtimes"): dauern = lies_titel_dauern(device_path) episoden = episoden_titel(dauern, meta) if episoden: os.makedirs(output_dir, exist_ok=True) return rip_titel_auswahl(device_path, output_dir, episoden, progress_cb, log_cb) titel = "all" if nur_hauptfilm: dauern = lies_titel_dauern(device_path) haupt = laengster_titel(dauern, meta) 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_windows(device_path: str, disc_id: str, progress_cb=None, output_dir: str = None, auswerfen: bool = True) -> dict: """Audio-CD unter Windows: selbst lesen, mit FLAC kodieren. Die Rechnung steht in `rippy.rip.audio_cd` (ohne Laufwerk pruefbar), das Lesen im Windows-Treiber (der einzige Ort mit Win32-Aufrufen). """ from rippy.drives import windows as win from rippy.rip import audio_cd class Leser: toc = staticmethod(win.audio_toc) @staticmethod def spur(geraet, start, sektoren, schreiben, fortschritt=None): return win.audio_spur_lesen(geraet, start, sektoren, schreiben, fortschritt) ziel = output_dir or os.path.join(RIP_OUTPUT_DIR, "cd", disc_id) ergebnis = audio_cd.rippen(device_path, ziel, Leser(), werkzeuge.finden("flac"), fortschritt=progress_cb) if auswerfen and ergebnis.get("status") == "success": wirf_disc_aus(device_path) return ergebnis 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).""" # ── Windows geht einen eigenen Weg (Befund 29.08.2026) ───────────── # # `abcde` und `cdparanoia` sind Linux-Werkzeuge; es gibt sie fuer Windows # nicht, und ein Nachbau ihrer Shell-Logik waere ein zweites Projekt. # Windows bietet stattdessen zwei Steuercodes an, mit denen sich eine # Audio-CD direkt lesen laesst — `rippy.rip.audio_cd`, kodiert wird mit # dem FLAC-Encoder aus dem Werkzeug-Katalog. # # Das war die letzte offene Luecke des Windows-Betriebs; sie stand seit # Wochen so im SAVEPOINT. if os.name == "nt": return _rip_cd_windows(device_path, disc_id, progress_cb, output_dir, auswerfen) 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