Prateekiiitg56/ffmpeg-pipeline

Was macht ffmpeg-pipeline?

Hilfsskripte befinden sich im Verzeichnis scripts/ neben dieser Datei. Führen Sie sie mit python <skill_dir>/scripts/<name>.py aus.

• probe.py IN... – einzeilige Zusammenfassung pro Datei (Größe, fps, Rotation, HDR, Dauer, Audio).
• export.py IN OUT --preset instagram|tiktok|shorts|youtube|master|preview – endgültige Kodierung mit den richtigen Einstellungen.
• frames.py IN OUTDIR --times 0.5,3,7.2 oder --every 1 – Aufnahme von Prüfbildern.

1. Zuerst prüfen und normalisieren

Fallstricke bei Handyvideos:

• Rotation: iPhones speichern Landschaftspixel + ein Rotations-Flag. ffmpeg rotiert beim Dekodieren automatisch (-noautorotate deaktiviert). OpenCV VideoCapture tut dies möglicherweise nicht – überprüfen Sie frame.shape und rotieren Sie selbst.
• VFR: Handys nehmen mit variabler Bildrate auf. Konvertieren Sie beim Extrahieren in CFR: -vf fps=30 (oder -r 30 Ausgabe), damit die Bildberechnung exakt ist.
• HDR: color_transfer=arib-std-b67 (HLG) oder smpte2084 (PQ). Unbehandelt wirkt das Bild in SDR verwaschen/grau. Tonemapping:

# HDR (HLG oder PQ) -> SDR Rec.709, CPU zscale-Pfad
-vf "zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=hable:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p"

hable = filmisch; mobius erhält mehr Sättigung. Fehlt zscale, verwenden Sie libplacebo (-vf libplacebo=tonemapping=bt.2390:colorspace=bt709:color_primaries=bt709:color_trc=bt709).

• Apple Log / Kamera-Log: Wenden Sie zuerst die LUT des Herstellers Log → Rec.709 an (lut3d=AppleLog_to_Rec709.cube), dann gradieren.
• 10-Bit-Quellen: Behalten Sie 10-Bit in Zwischenformaten (-pix_fmt yuv422p10le ProRes oder yuv420p10le x265) bei starker Gradierung bei; konvertieren Sie erst beim endgültigen Export für soziale Medien in 8-Bit yuv420p.

2. Architektur eines Build-Skripts

sources/ (niemals ändern)
edit/
  build.py          # erzeugt alles aus Quellen und Datendateien neu
  edl.json          # [{src, in, out, speed, grade, transition}]
  segments/         # eine gradierte, normalisierte Datei pro EDL-Eintrag (verlustfrei oder nahezu)
  overlays/         # PNG / PNG-Sequenz / ProRes 4444 / WebM Alpha
  preview.mp4, final.mp4

Regeln:

1. Segmentweise extrahieren mit allen arbeitsspezifischen Schritten (Trimmen, Geschwindigkeit, Skalieren/Zuschneiden, Gradieren, fps) in einem Durchlauf → Zwischendatei mit -crf 10 (x264) oder ProRes 422 HQ.
2. Segmente zusammenfügen mit dem concat-Demuxer und -c copy, wenn keine Übergänge benötigt werden (alle Segmente müssen Codec, Auflösung, fps, pix_fmt, Zeitbasis gemeinsam haben).
3. Overlays und Text in einem einzigen letzten Durchlauf über das zusammengefügte Video, dann einmal in das Lieferformat kodieren.
4. Audio wird separat erstellt (Musik + SFX + Dialog → eine WAV), dann im letzten Durchlauf gemuxt.

Präzises Trimmen

# -ss vor -i ist schnell und bildgenau beim Neukodieren (ffmpeg >= 2.1)
ffmpeg -ss 12.40 -i IN.mov -t 2.333 -vf "fps=30,scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920" \
  -c:v libx264 -crf 10 -preset medium -pix_fmt yuv420p -an seg_003.mp4

Verwenden Sie niemals -c copy für Trimmungen, die bildgenau sein müssen (es rastet an Keyframes ein).

Ausfüllen von 9:16 aus 16:9

• Zuschneiden (Cover): scale=-2:1920,crop=1080:1920:(iw-1080)*X:0 mit X 0..1, um die Subjektposition zu wählen (verfolgen Sie sie, wenn sich das Subjekt bewegt).
• Unschärfer Hintergrund (Contain): split[a][b];[a]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,boxblur=40:2[bg];[b]scale=1080:-2[fg];[bg][fg]overlay=(W-w)/2:(H-h)/2

Zusammenfügen

# list.txt:  file 'segments/seg_001.mp4'  (eine pro Zeile)
ffmpeg -f concat -safe 0 -i list.txt -c copy joined.mp4

Übergänge mit xfade

ffmpeg -i a.mp4 -i b.mp4 -filter_complex \
 "[0:v][1:v]xfade=transition=fade:duration=0.5:offset=4.5,format=yuv420p[v]; \
  [0:a][1:a]acrossfade=d=0.5[a]" -map "[v]" -map "[a]" out.mp4

offset = Dauer des ersten Clips − Übergangsdauer. Typen: fade, fadeblack, fadewhite, wipeleft, slideup, smoothleft, circleopen, radial, zoomin, hblur, pixelize, dissolve… Offsets bei vielen Clips kumulativ verketten (jeder xfade verkürzt die Gesamtlänge um seine Dauer).

Overlays

# statisches PNG (Vollbild, transparent) für das gesamte Video – kein -loop nötig
[0:v][1:v]overlay=0:0:format=auto
# zeitbegrenzt
overlay=0:0:enable='between(t,2.0,5.5)'
# animierter Overlay-Clip, der bei T in der Ausgabe beginnt
[1:v]setpts=PTS-STARTPTS+T/TB[ov];[0:v][ov]overlay=0:0:eof_action=pass

Alpha-Overlays: PNG-Sequenz (-framerate 30 -i ov/%04d.png), ProRes 4444 (-c:v prores_ks -profile:v 4444 -pix_fmt yuva444p10le) oder VP9 WebM (-c:v libvpx-vp9 -pix_fmt yuva420p). Verwenden Sie nicht -loop 1 für ein 4K-RGBA-PNG bei langen Videos; das verbraucht RAM. Ein einzelnes Bild wird von overlay automatisch wiederholt.

Piping von Rohbildern aus Python (PIL/OpenCV-Komposition) in ffmpeg:

p = subprocess.Popen(["ffmpeg","-y","-f","rawvideo","-pix_fmt","rgb24","-s",f"{W}x{H}","-r","30","-i","-",
                      "-c:v","libx264","-crf","12","-pix_fmt","yuv420p","out.mp4"], stdin=subprocess.PIPE)
p.stdin.write(frame.tobytes())   # numpy uint8 HxWx3, pro Bild

Lesen Sie Quellbilder auf die gleiche Weise (-f rawvideo -pix_fmt rgb24 -), was OpenCV-Rotations- und Codec-Probleme vermeidet.

Geschwindigkeit

• Konstant: setpts=PTS/2 (2x) + atempo=2.0 (atempo-Bereich 0.5-100; für mehr verketten).
• Sanftes Zeitlupe von 30 fps: minterpolate=fps=60:mi_mode=mci:mc_mode=aobmc:vsbmc=1, dann setpts=2*PTS. Auf Verzerrungen an Kanten/Händen achten.
• Variable Geschwindigkeitsrampen: Bild für Bild aus einer Zeitkarte rendern (siehe beat-sync), niemals viele setpts-Ausdrücke stapeln.

Untertitel (zuletzt)

-vf "subtitles=captions.ass:fontsdir=fonts"     # ASS bietet volle Formatierungskontrolle

3. Export-Voreinstellungen

Ziel	Video	Audio	Hinweise
Instagram Reels / TikTok / Shorts	1080x1920 (oder 2160x3840) H.264 High, 30 fps, CRF 16-18, -maxrate 25M -bufsize 50M, yuv420p	AAC 48 kHz 256-320k	-movflags +faststart; Plattformen kodieren neu, also eine qualitativ hochwertige Datei liefern
YouTube 16:9	3840x2160 oder 1920x1080, H.264 CRF 16 oder HEVC CRF 18, Quell-fps	AAC 48 kHz 320k	4K hochladen, selbst für 1080p-Inhalte, um die bessere VP9/AV1-Kodierung zu erhalten
Master	ProRes 422 HQ oder x264 CRF 10 / x265 CRF 14 -tag:v hvc1	PCM 24-bit 48 kHz	Archiv
Vorschau	720p, CRF 28, -preset veryfast	AAC 128k	schnelle Iteration

Fügen Sie für soziale Medien immer -pix_fmt yuv420p hinzu (10-Bit oder 4:2:2 können nach dem Upload fehlschlagen oder falsch aussehen) und -color_primaries bt709 -color_trc bt709 -colorspace bt709, um SDR korrekt zu kennzeichnen.

4. Überprüfen

ffprobe -v error -show_entries stream=codec_name,width,height,r_frame_rate,pix_fmt -show_entries format=duration -of compact out.mp4
ffmpeg -i out.mp4 -af ebur128=peak=true -f null - 2>&1 | tail -12
ffmpeg -i out.mp4 -vf "select='gt(scene,0.3)',showinfo" -f null - 2>&1 | grep pts_time   # wo die Schnitte tatsächlich sind