feat: Video-Werkzeuge ins Repo (tools/video)
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.
This commit is contained in:
parent
89e77a43cc
commit
ec3336550d
4 changed files with 576 additions and 1 deletions
|
|
@ -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
|
||||
|
|
|
|||
90
tools/video/README.md
Normal file
90
tools/video/README.md
Normal file
|
|
@ -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/<name>.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: `<name>__cutted_<von>_<bis>.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: `<name>_fps_<ziel>.mp4`.
|
||||
|
||||
### 5. In die Werkbank übernehmen
|
||||
|
||||
```bash
|
||||
./tools/rotoscope.sh reference <pfad/zum/clip.mp4>
|
||||
```
|
||||
|
||||
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.
|
||||
212
tools/video/cut_video.py
Executable file
212
tools/video/cut_video.py
Executable file
|
|
@ -0,0 +1,212 @@
|
|||
#!/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()
|
||||
257
tools/video/downsample.py
Executable file
257
tools/video/downsample.py
Executable file
|
|
@ -0,0 +1,257 @@
|
|||
#!/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()
|
||||
Loading…
Add table
Add a link
Reference in a new issue