Die beiden allgemeinen Schnitt-Skripte lagen nur in der Werkbank und waren damit nicht auf dem Mac verfügbar: - `tools/video/cut_video.py` — exakter Schnitt aus einer MP4 (ffmpeg). - `tools/video/downsample.py` — Bildrate reduzieren, auf 1920x1280 skalieren. - `tools/video/README.md` — Kurzanleitung: Voraussetzungen, Ablauf vom Sichten bis zur Übergabe an Blender, Merksätze. Die Analyse-Helfer `scan_takes.py` und `window_scan.py` bleiben in der Werkbank: Sie enthalten feste Pfade und Zeitfenster der jeweiligen Aufnahme (YOLO-Gewichte) und taugen nur für diese Sitzung. In der Werkbank verweisen die beiden Skripte jetzt per Symlink hierher, damit es keine zweite Fassung gibt. `docs/rotoscoping.md` nennt den neuen Ort.
212 lines
7.7 KiB
Python
Executable file
212 lines
7.7 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
"""Schneidet einen Abschnitt aus einer MP4-Datei.
|
|
|
|
Ausgabename: <dateiname>__cutted_<von>_<bis>.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()
|