diff --git a/docs/rotoscoping.md b/docs/rotoscoping.md index d637e77..b4ab328 100644 --- a/docs/rotoscoping.md +++ b/docs/rotoscoping.md @@ -12,7 +12,8 @@ Workbench-Archiv; das Repo enthält die Skripte und die Dokumentation. - Das Produktions-Rig: `workbench/source/characters/skater/skater_rig_v008.blend` (Rig der jeweils aktiven Figur, siehe `docs/assets.md`). -- Für den synthetischen Testfilm: `ffmpeg`. +- `ffmpeg` zum Sichten und Schneiden der Referenzclips + (siehe `tools/video/README.md`). - Für den FTP-Upload: `docs/credentials.txt` wie beim Asset-Sync. Der Default ist nur die **Quelldatei für neue Arbeitsdateien**. Das @@ -51,6 +52,21 @@ Die Kamera steht standardmäßig auf einer ganzen-Rink-Ansicht (28 mm, 55 m entfernt). Für eine Nahaufnahme die Kamera näher an den Skater schieben; das `CameraTarget` bleibt der Blickpunkt. +## Referenz vorbereiten + +Lange Aufnahmen werden vor dem Rotoscoping geschnitten und verkleinert. Die +beiden Skripte dafür liegen in `tools/video/`, die Kurzanleitung daneben: + +```bash +tools/video/cut_video.py DJI_0002.MP4 0:16 0:32 +tools/video/downsample.py DJI_0002__cutted_16_32.mp4 24 +``` + +Ein Clip zeigt eine Bewegung; 1920 × 1280 bei 24 fps reichen für die +Blender-Vorschau. Die Suche nach dem passenden Zeitfenster (Kontaktabzüge, +Figurengröße je Take) übernehmen `scan_takes.py` und `window_scan.py` aus der +Werkbank. + ## Referenz laden ```bash diff --git a/tools/video/README.md b/tools/video/README.md new file mode 100644 index 0000000..3ec68d4 --- /dev/null +++ b/tools/video/README.md @@ -0,0 +1,90 @@ +# Video sichten und schneiden + +Werkzeuge für den ersten Schritt der Rotoscoping-Kette: Aus langen Aufnahmen +die Sekunden herausschneiden, die als Referenz für die Blender-Werkbank +dienen — und sie so verkleinern, dass Blender sie flüssig abspielt. + +Die Referenzen selbst bleiben im Workbench-Archiv (`docs/assets.md`); hier +liegen nur die Skripte. Maßgeblich ist **dieses Verzeichnis**: In der Werkbank +verweisen `cut_video.py` und `downsample.py` per Symlink hierher, damit es +keine zweite Fassung gibt. + +## Voraussetzungen + +- **`ffmpeg` und `ffprobe`** im Pfad. macOS: `brew install ffmpeg`. +- Python 3.8 oder neuer (keine zusätzlichen Pakete für diese beiden Skripte). + +Die beiden Analyse-Skripte (siehe unten) brauchen zusätzlich +`opencv-python`, `numpy` und `ultralytics` samt YOLOv8x-Pose-Gewichten. + +## Die Skripte + +| Datei | Zweck | Abhängigkeiten | +| :--- | :--- | :--- | +| `cut_video.py` | schneidet einen Abschnitt aus einer MP4 | `ffmpeg` | +| `downsample.py` | reduziert die Bildrate, skaliert auf 1920 × 1280 | `ffmpeg` | + +Zwei weitere Helfer liegen bewusst **nicht** hier, sondern in der Werkbank +(`workbench_rinkplanner/tools/`): `scan_takes.py` und `window_scan.py`. Sie +enthalten feste Pfade und Zeitfenster der jeweiligen Aufnahme (plus +YOLO-Gewichte) und taugen nur für diese eine Sitzung. + +## Ablauf + +### 1. Takes sichten + +`scan_takes.py` misst über alle Dateien die Figurengröße (nur Keyframes, daher +schnell) und schreibt `take_scan/.csv` nach `/tmp`. Aus der Tabelle +sieht man, in welchen Dateien die Läuferin groß genug ist. + +### 2. Kandidaten prüfen + +`window_scan.py` legt für fest eingetragene Zeitfenster Kontaktabzüge an +(Crops um die Läuferin, 5 Bilder/s). Damit findet man den Moment mit bloßem +Auge — etwa einen Sprung, bei dem beide Füße in der Luft sind. + +### 3. Schneiden + +```bash +./cut_video.py DJI_0002.MP4 16 32 +./cut_video.py DJI_0002.MP4 0:16 0:32 --outdir ~/Dokumente/clips +./cut_video.py DJI_0002.MP4 16 32 --copy # verlustfrei, aber Keyframe-genau +``` + +Ohne `--copy` wird neu kodiert: exakter Schnitt, Hardware-Decode wenn +vorhanden. Mit `--copy` bleibt der Stream unverändert — schnell und +verlustfrei, aber der Schnitt landet auf dem Keyframe davor (bei den +Drohnen-Dateien im 1-Sekunden-Raster). + +Ausgabe: `__cutted__.mp4`, standardmäßig neben der Quelle. + +### 4. Verkleinern + +```bash +./downsample.py DJI_0002__cutted_16_32.mp4 24 +``` + +Ziel ist 1920 × 1280 bei 24 fps. Das Zielformat ist 3:2, das Material meist +16:9 — Standard ist `--fit pad` (unverzerrt, schwarze Balken), alternativ +`crop` oder `stretch`. Dauer und Farben bleiben erhalten, Ton wird +übernommen. + +Ausgabe: `_fps_.mp4`. + +### 5. In die Werkbank übernehmen + +```bash +./tools/rotoscope.sh reference +``` + +Details zum Rig, zu den Posen und zum Export stehen in +`docs/rotoscoping.md`. + +## Merksätze + +- **Ein Clip = eine Bewegung.** Lieber drei kurze Referenzen als eine lange + Aufnahme, in der drei Elemente vorkommen. +- **Immer verkleinern, bevor Blender geöffnet wird.** 4K-Material ruckelt in + der Vorschau, ohne dass es beim Keyframing hilft. +- **Originale nicht überschreiben.** `cut_video.py` und `downsample.py` legen + neue Dateien an; `--overwrite` nur bewusst. diff --git a/tools/video/cut_video.py b/tools/video/cut_video.py new file mode 100755 index 0000000..4748d5b --- /dev/null +++ b/tools/video/cut_video.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +"""Schneidet einen Abschnitt aus einer MP4-Datei. + +Ausgabename: __cutted__.mp4 + +Beispiele: + ./cut_video.py DJI_0002.MP4 16 32 + ./cut_video.py DJI_0002.MP4 0:16 0:32 --outdir /tmp/clips + ./cut_video.py DJI_0002.MP4 16 32 --copy # verlustfrei, aber keyframe-genau + +Standard ist ein exakter Schnitt (Neu-Encoding, Hardware-Decode wenn vorhanden). +Mit --copy wird der Stream unveraendert kopiert: sehr schnell und verlustfrei, +aber der Schnitt landet auf dem naechsten Keyframe davor (bei diesen Drohnen- +Dateien ist das Raster 1 s). +""" +import argparse +import json +import os +import shutil +import subprocess +import sys +from pathlib import Path + + +# ---------------------------------------------------------------- Hilfsfunktionen +def parse_time(text): + """"16", "16.5", "0:16", "1:02:03.5" -> Sekunden.""" + text = text.strip().replace(",", ".") + if ":" in text: + parts = text.split(":") + if len(parts) == 2: + return int(parts[0]) * 60 + float(parts[1]) + if len(parts) == 3: + return int(parts[0]) * 3600 + int(parts[1]) * 60 + float(parts[2]) + raise ValueError(f"Zeitangabe nicht verstanden: {text}") + return float(text) + + +def fmt_num(sec): + """"16.0" -> "16", "16.50" -> "16.5" (fuer den Dateinamen).""" + s = f"{sec:.3f}".rstrip("0").rstrip(".") + return s if s else "0" + + +def probe(path): + cmd = ["ffprobe", "-v", "error", "-print_format", "json", + "-show_format", "-show_streams", str(path)] + res = subprocess.run(cmd, capture_output=True, text=True) + if res.returncode != 0: + sys.exit(f"ffprobe-Fehler:\n{res.stderr.strip()}") + return json.loads(res.stdout) + + +def keyframes_near(path, t, window=4.0): + """Keyframe-Zeitpunkte im Fenster [t-window, t+window].""" + start = max(0.0, t - window) + cmd = ["ffprobe", "-v", "error", "-select_streams", "v:0", "-skip_frame", "nokey", + "-show_entries", "frame=pts_time", "-of", "csv=p=0", + "-read_intervals", f"{start}%+{2 * window}"] + res = subprocess.run(cmd + [str(path)], capture_output=True, text=True) + times = [] + for line in res.stdout.splitlines(): + line = line.strip().rstrip(",") + if not line: + continue + try: + times.append(float(line)) + except ValueError: + pass + return sorted(times) + + +def has_cuda(): + if shutil.which("ffmpeg") is None: + return False + res = subprocess.run(["ffmpeg", "-hide_banner", "-hwaccels"], capture_output=True, text=True) + if "cuda" not in res.stdout: + return False + if shutil.which("nvidia-smi") is None: + return False + return subprocess.run(["nvidia-smi"], capture_output=True).returncode == 0 + + +def run_ffmpeg(cmd, label): + print(f" {label} ...", end=" ", flush=True) + res = subprocess.run(cmd, capture_output=True, text=True) + if res.returncode != 0: + print("FEHLER") + print(res.stderr.strip()[-2000:]) + return False + print("ok") + return True + + +# ---------------------------------------------------------------- Hauptprogramm +def main(): + ap = argparse.ArgumentParser( + description="Schneidet einen Abschnitt aus einer MP4-Datei.", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=__doc__) + ap.add_argument("input", type=Path, help="Quelldatei (.mp4)") + ap.add_argument("start", help="Start in Sekunden oder als m:ss") + ap.add_argument("end", help="Ende in Sekunden oder als m:ss") + ap.add_argument("--outdir", type=Path, default=None, + help="Zielordner (Standard: Ordner der Quelldatei)") + ap.add_argument("--copy", action="store_true", + help="verlustfreie Stream-Kopie (schnell, schnittet auf Keyframes)") + ap.add_argument("--crf", type=int, default=18, + help="Qualitaet beim Neu-Encoding (kleiner = besser, Standard 18)") + ap.add_argument("--preset", default="medium", + help="x264-Preset (Standard: medium)") + ap.add_argument("--overwrite", action="store_true", help="vorhandene Zieldatei ersetzen") + ap.add_argument("--dry-run", action="store_true", help="nur zeigen, was passieren wuerde") + args = ap.parse_args() + + src = args.input.expanduser() + if not src.is_file(): + sys.exit(f"Datei nicht gefunden: {src}") + + try: + start = parse_time(args.start) + end = parse_time(args.end) + except ValueError as e: + sys.exit(str(e)) + + if start < 0: + sys.exit("Start darf nicht negativ sein.") + if end <= start: + sys.exit(f"Ende ({end:g} s) muss nach dem Start ({start:g} s) liegen.") + + info = probe(src) + duration = float(info["format"].get("duration", 0)) + video = next((s for s in info["streams"] if s.get("codec_type") == "video"), None) + if video is None: + sys.exit("Kein Videostream gefunden.") + if duration and end > duration + 0.001: + sys.exit(f"Ende ({end:g} s) liegt hinter dem Dateiende ({duration:.3f} s).") + + fps = 30.0 + rate = video.get("avg_frame_rate") or video.get("r_frame_rate") or "30/1" + try: + num, den = rate.split("/") + if float(den) != 0: + fps = float(num) / float(den) + except (ValueError, ZeroDivisionError): + pass + + outdir = args.outdir.expanduser() if args.outdir else src.parent + outdir.mkdir(parents=True, exist_ok=True) + out = outdir / f"{src.stem}__cutted_{fmt_num(start)}_{fmt_num(end)}.mp4" + + print(f"Quelle : {src.name}") + print(f" {video.get('width')}x{video.get('height')}, " + f"{fps:.2f} fps, {video.get('codec_name')}, {duration:.2f} s") + print(f"Schnitt: {start:g} s -> {end:g} s ({end - start:g} s)") + print(f"Ziel : {out}") + + if out.exists() and not args.overwrite: + sys.exit("Zieldatei existiert bereits (mit --overwrite ersetzen).") + + cmd = ["ffmpeg", "-hide_banner", "-y", "-ss", f"{start:.3f}", "-i", str(src), + "-t", f"{end - start:.3f}"] + + if args.copy: + # Keyframe-Raster pruefen und melden + kfs = keyframes_near(src, start) + before = [k for k in kfs if k <= start + 1e-6] + if before: + delta = start - before[-1] + if delta > 0.5 / fps: + print(f"Hinweis: Keyframe davor liegt bei {before[-1]:.3f} s " + f"-> der Schnitt beginnt {delta:.3f} s zu frueh.") + print(" Fuer einen exakten Schnitt ohne --copy aufrufen.") + cmd += ["-map", "0:v:0", "-map", "0:a?", "-c", "copy", "-avoid_negative_ts", "make_zero"] + label = "Stream-Kopie" + else: + if has_cuda(): + cmd = cmd[:2] + ["-hwaccel", "cuda"] + cmd[2:] + cmd += ["-map", "0:v:0", "-map", "0:a?", + "-c:v", "libx264", "-crf", str(args.crf), "-preset", args.preset, + "-pix_fmt", "yuv420p"] + if any(s.get("codec_type") == "audio" for s in info["streams"]): + cmd += ["-c:a", "aac", "-b:a", "192k"] + label = "Neu-Encoding" + + cmd += ["-movflags", "+faststart", str(out)] + + if args.dry_run: + print("\nBefehl:") + print(" " + " ".join(cmd)) + return + + for attempt in range(2): + if run_ffmpeg(cmd, label + ("" if attempt == 0 else " (ohne Hardware-Decode)")): + break + if "-hwaccel" in cmd: + i = cmd.index("-hwaccel") + del cmd[i:i + 2] + print(" Hardware-Decode nicht moeglich, neuer Versuch ohne.") + else: + sys.exit("Schnitt fehlgeschlagen.") + else: + sys.exit("Schnitt fehlgeschlagen.") + + res = probe(out) + print(f"\nFertig: {out}") + print(f" {res['format']['duration']} s, " + f"{int(res['format']['size']) / 1e6:.1f} MB") + + +if __name__ == "__main__": + main() diff --git a/tools/video/downsample.py b/tools/video/downsample.py new file mode 100755 index 0000000..eaff11d --- /dev/null +++ b/tools/video/downsample.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +"""Reduziert die Bildrate einer MP4-Datei und skaliert sie auf 1920x1280. + +Ausgabename: _fps_.mp4 + +Beispiele: + downsample.py DJI_0002.MP4 30 + downsample.py DJI_0002.MP4 24 --fit stretch + downsample.py DJI_0002.MP4 30 --dry-run + +Die Laenge (Dauer) bleibt erhalten: Es werden Frames verworfen, nicht die +Wiedergabe verlangsamt. Ton wird mit uebernommen. + +Seitenverhaeltnis: Das Ziel 1920x1280 ist 3:2, das Quellmaterial meist 16:9. +Standard ist deshalb "pad" (Bild bleibt unverzerrt, oben/unten schwarze +Balken). Alternativen: --fit crop (Bild ausfuellen, ragt oben/unten heraus) +oder --fit stretch (exakt 1920x1280, Bild wird gestaucht). +""" +import argparse +import json +import shutil +import subprocess +import sys +from pathlib import Path + +WIDTH, HEIGHT = 1920, 1280 + + +def fmt_fps(value): + s = f"{value:.3f}".rstrip("0").rstrip(".") + return s if s else "0" + + +def probe(path): + cmd = ["ffprobe", "-v", "error", "-print_format", "json", + "-show_format", "-show_streams", str(path)] + res = subprocess.run(cmd, capture_output=True, text=True) + if res.returncode != 0: + sys.exit(f"ffprobe-Fehler:\n{res.stderr.strip()}") + return json.loads(res.stdout) + + +def source_fps(video): + rate = video.get("avg_frame_rate") or video.get("r_frame_rate") or "0/1" + try: + num, den = rate.split("/") + if float(den) != 0: + return float(num) / float(den) + except (ValueError, ZeroDivisionError): + pass + return 0.0 + + +def has_cuda(): + if shutil.which("ffmpeg") is None: + return False + res = subprocess.run(["ffmpeg", "-hide_banner", "-hwaccels"], capture_output=True, text=True) + if "cuda" not in res.stdout: + return False + if shutil.which("nvidia-smi") is None: + return False + return subprocess.run(["nvidia-smi"], capture_output=True).returncode == 0 + + +def build_filter(fps, fit, width, height): + if fit == "stretch": + scale = f"scale={width}:{height}" + elif fit == "crop": + scale = (f"scale={width}:{height}:force_original_aspect_ratio=increase," + f"crop={width}:{height}") + else: # pad + scale = (f"scale={width}:{height}:force_original_aspect_ratio=decrease," + f"pad={width}:{height}:(ow-iw)/2:(oh-ih)/2:color=black") + return f"{scale},fps={fps:g}" + + +def build_parser(): + epilog = """\ +Beispiele + downsample.py klip.mp4 30 + -> klip_fps_30.mp4, 1920x1280, 30 fps, unverzerrt mit Balken + + downsample.py klip.mp4 24 --fit crop + -> bildfuellend, oben und unten wird Bildinhalt abgeschnitten + + downsample.py klip.mp4 30 --fit stretch --width 1280 --height 720 + -> exakt 1280x720, Bild wird gestaucht + + downsample.py klip.mp4 30 --crf 22 --outdir ~/exports + -> kleinere Datei, anderer Zielordner + + downsample.py klip.mp4 30 --dry-run + -> zeigt nur den ffmpeg-Befehl, schreibt nichts + +Ablauf + 1. Datei und Parameter werden geprueft (Existenz, fps > 0, gerade + Aufloesung, Zielrate kleiner als Quellrate). + 2. Bildrate und Aufloesung werden in einem ffmpeg-Durchlauf geaendert. + Die Dauer bleibt erhalten, es werden Frames verworfen. + 3. Der Ton wird als AAC 192 kbit/s uebernommen. + 4. Zum Schluss werden Dauer, Aufloesung, Framezahl und Groesse des + Ergebnisses ausgegeben. + +Ausgabe + _fps_.mp4 im Ordner der Quelldatei + (oder in --outdir). + +Hinweis zum Seitenverhaeltnis + 1920x1280 ist 3:2, Quellmaterial meist 16:9. Deshalb ist --fit pad + Standard: Das Bild bleibt unverzerrt, oben und unten entstehen schwarze + Balken. --fit crop schneidet stattdessen oben und unten ab, --fit stretch + verzerrt das Bild. Fuer Personenaufnahmen ist pad oder crop sinnvoll, + stretch verfaelscht Proportionen. +""" + ap = argparse.ArgumentParser( + prog="downsample.py", + description="Reduziert die Bildrate einer MP4-Datei und skaliert das Bild auf " + "1920x1280 (einstellbar). Farben und Dauer bleiben erhalten.", + formatter_class=argparse.RawTextHelpFormatter, + add_help=False, + epilog=epilog) + ap.add_argument("-h", "--help", action="help", + help="Diese Hilfe anzeigen und beenden. Erklaert alle Parameter\n" + "und zeigt Beispiele. Es wird nichts verarbeitet.") + ap.add_argument("input", type=Path, metavar="MP4_DATEI", + help="Quelldatei (.mp4). Relativ oder absolut.") + ap.add_argument("fps", type=float, metavar="FPS", + help="Zielbildrate, z. B. 30 oder 24. Muss kleiner als die\n" + "Bildrate der Quelle sein, sonst bricht das Skript ab\n" + "(mit --force trotzdem erlaubt).") + ap.add_argument("--fit", choices=("pad", "crop", "stretch"), default="pad", + metavar="{pad,crop,stretch}", + help="Umgang mit abweichendem Seitenverhaeltnis.\n" + " pad - Bild unverzerrt, Rest schwarz (Standard)\n" + " crop - Bild fuellt die Flaeche, Raender werden beschnitten\n" + " stretch - exakte Zielgroesse, Bild wird verzerrt") + ap.add_argument("--width", type=int, default=WIDTH, metavar="PX", + help=f"Zielbreite in Pixeln (Standard {WIDTH}, muss gerade sein).") + ap.add_argument("--height", type=int, default=HEIGHT, metavar="PX", + help=f"Zielhoehe in Pixeln (Standard {HEIGHT}, muss gerade sein).") + ap.add_argument("--outdir", type=Path, default=None, metavar="ORDNER", + help="Zielordner. Standard: Ordner der Quelldatei.") + ap.add_argument("--crf", type=int, default=18, metavar="N", + help="Qualitaet des H.264-Encoders, 0-51 (Standard 18).\n" + "Kleiner = besser und groesser, 23 ist sichtbar schlechter.") + ap.add_argument("--preset", default="medium", metavar="NAME", + help="x264-Geschwindigkeit: ultrafast, fast, medium, slow.\n" + "Schneller = groessere Datei bei gleicher Qualitaet (Standard medium).") + ap.add_argument("--encoder", choices=("cpu", "nvenc"), default="cpu", + help="cpu - libx264, beste Qualitaet pro Bit (Standard)\n" + "nvenc - NVIDIA-GPU-Encoder, etwa 5-10x schneller,\n" + " bei gleicher Dateigroesse etwas weicher") + ap.add_argument("--force", action="store_true", + help="Auch ausfuehren, wenn die Zielrate nicht kleiner als die\n" + "Quellrate ist (dann werden Frames verdoppelt).") + ap.add_argument("--overwrite", action="store_true", + help="Vorhandene Zieldatei ersetzen (sonst Abbruch).") + ap.add_argument("--dry-run", action="store_true", + help="Nur den erzeugten ffmpeg-Befehl anzeigen, nichts schreiben.") + return ap + + +def main(): + ap = build_parser() + args = ap.parse_args() + + src = args.input.expanduser() + if not src.is_file(): + sys.exit(f"Datei nicht gefunden: {src}") + if args.fps <= 0: + sys.exit("Die Bildrate muss groesser als 0 sein.") + if args.width <= 0 or args.height <= 0: + sys.exit("Breite und Hoehe muessen groesser als 0 sein.") + if args.width % 2 or args.height % 2: + sys.exit("Breite und Hoehe muessen gerade Zahlen sein (H.264 verlangt das).") + + info = probe(src) + video = next((s for s in info["streams"] if s.get("codec_type") == "video"), None) + if video is None: + sys.exit("Kein Videostream gefunden.") + + src_fps = source_fps(video) + duration = float(info["format"].get("duration", 0)) + + if src_fps and args.fps >= src_fps and not args.force: + sys.exit(f"Quelle hat bereits {src_fps:.2f} fps - {args.fps:g} fps ist keine " + f"Reduktion (mit --force trotzdem).") + + outdir = args.outdir.expanduser() if args.outdir else src.parent + outdir.mkdir(parents=True, exist_ok=True) + out = outdir / f"{src.stem}_fps_{fmt_fps(args.fps)}.mp4" + + vf = build_filter(args.fps, args.fit, args.width, args.height) + + print(f"Quelle : {src.name}") + print(f" {video.get('width')}x{video.get('height')}, " + f"{src_fps:.2f} fps, {duration:.2f} s, {video.get('codec_name')}") + print(f"Ziel : {args.fps:g} fps, {args.width}x{args.height} ({args.fit}) -> {out}") + + sw, sh = int(video.get("width", 0)), int(video.get("height", 0)) + if sw and sh and abs(sw / sh - args.width / args.height) > 0.01: + print(f"Hinweis: Quelle ist {sw / sh:.3f}:1, Ziel {args.width / args.height:.3f}:1 " + f"-> --fit {args.fit} wird angewendet.") + + if out.exists() and not args.overwrite: + sys.exit("Zieldatei existiert bereits (mit --overwrite ersetzen).") + + cmd = ["ffmpeg", "-hide_banner", "-y"] + if has_cuda(): + cmd += ["-hwaccel", "cuda"] + cmd += ["-i", str(src), + "-map", "0:v:0", "-map", "0:a?", + "-vf", vf, + ] + if args.encoder == "nvenc": + cmd += ["-c:v", "h264_nvenc", "-preset", "p5", "-rc", "vbr", + "-cq", str(args.crf), "-b:v", "0", "-pix_fmt", "yuv420p"] + else: + cmd += ["-c:v", "libx264", "-crf", str(args.crf), "-preset", args.preset, + "-pix_fmt", "yuv420p"] + if any(s.get("codec_type") == "audio" for s in info["streams"]): + cmd += ["-c:a", "aac", "-b:a", "192k"] + cmd += ["-movflags", "+faststart", str(out)] + + if args.dry_run: + print("\nBefehl:") + print(" " + " ".join(cmd)) + return + + for attempt in range(2): + print(f" Umwandeln{'' if attempt == 0 else ' (ohne Hardware-Decode)'} ...", + end=" ", flush=True) + res = subprocess.run(cmd, capture_output=True, text=True) + if res.returncode == 0: + print("ok") + break + print("FEHLER") + print(res.stderr.strip()[-1500:]) + if "-hwaccel" in cmd: + i = cmd.index("-hwaccel") + del cmd[i:i + 2] + else: + sys.exit("Umwandlung fehlgeschlagen.") + else: + sys.exit("Umwandlung fehlgeschlagen.") + + res = probe(out) + out_video = next((s for s in res["streams"] if s.get("codec_type") == "video"), {}) + print(f"\nFertig: {out}") + print(f" {float(res['format']['duration']):.3f} s, " + f"{out_video.get('width')}x{out_video.get('height')}, " + f"{out_video.get('nb_frames', '?')} Frames, " + f"{int(res['format']['size']) / 1e6:.1f} MB") + + +if __name__ == "__main__": + main()