#!/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()