258 lines
10 KiB
Python
258 lines
10 KiB
Python
|
|
#!/usr/bin/env python3
|
||
|
|
"""Reduziert die Bildrate einer MP4-Datei und skaliert sie auf 1920x1280.
|
||
|
|
|
||
|
|
Ausgabename: <dateiname>_fps_<zielbildrate>.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
|
||
|
|
<quelldateiname>_fps_<zielbildrate>.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()
|