Wissen

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Sie befinden sich hier: Start » ffmpeg
Zuletzt angesehen: • security_key • mysql-dump • ffprobe • nmap • programmiersprachen • iptables • ubuntu_14.04_mit_apache_und_ssl • systemd • zfs • ffmpeg
ffmpeg

Dies ist eine alte Version des Dokuments!

Inhaltsverzeichnis

FFmpeg

Von FFmpeg gibt es auch einen Fork mit dem Namen AVconv.

  • probier es einfach mal aus:
    • ASP@L5: ffmpeg -benchmark -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts+igndts -i Quelle.avi -c:v mpeg4 -b:v 8192k -profile:v 15 -level 5 -g 300 -c:a ac3 -f avi -y Ziel.avi
    • ASP@L4: ffmpeg -benchmark -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts+igndts -i Quelle.avi -c:v mpeg4 -b:v 3072k -profile:v 15 -level 4 -g 300 -c:a ac3 -f avi -y Ziel.avi
Diese Optionen haben folgende Bedeutung:

-benchmark                                                -> erzeugt eine bessere Ausgabe

-probesize 9223372036854M -analyzeduration 9223372036854M -> durchsucht den GANZEN Film, sonst werden beispielsweise Untertitelspuren nicht gefunden, die erst sehr spät im Film einsetzen (hier wurden die größtmöglichen Werte gewählt, um auf jeden Fall absolut jeden Film komplett zu durchsuchen)

-fflags +genpts+igndts                                    -> repariert bestimmte Beschädigungen an Containern, betroffene Filme können sonst nicht gelesen werden
FFmpeg 4.1.3 (Sept. 2019):
opus in MP4 support is experimental, add '-strict -2' if you want to use it.
Could not write header for output file #0 (incorrect codec parameters ?): Experimental feature
Error initializing output stream 0:1 --
  • 2018-10-02: Dav1d: Ein Decoder für AV1 ⇒ Open-Source-Entwickler haben einen neuen Decoder namens Dav1d angekündigt. Der soll schon bald AV1, den Codec der Alliance for Open Media, zum Leben erwecken.
  • 2018-11-08: FFmpeg 4.1 bringt zahlreiche neue Filter ⇒ Für das AV1-Format enthält FFmpeg 4.1 einen entsprechenden Parser, zudem unterstützt das Framework das Format in MP4-Dateien. Ein Decoder fehlt allerdings noch. Dieser soll mit der nächsten FFmpeg-Version erscheinen.
  • https://github.com/FlatheadV8/Film2MP4 → hier ist ein Skript welches auf Basis von FFmpeg/AVconv und x264 Filme bearbeiten kann
  • http://ffmpeg.org/faq.html
  • FFmpeg -benchmark option
    • ffmpeg -benchmark ...
    • bench: utime=8.483s
    • bench: maxrss=52736000kB
  • FFmpeg Filtering Guide
  • FFmpeg - QSV (Intel QuickSync Video encoders)
  • FFmpeg, freie Codecs und Standardformate
    • x264
      • https://sites.google.com/site/linuxencoding/x264-ffmpeg-mapping
      • mögliche Voreinstellungen (-preset): ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow und placebo
        • ffmpeg -i Film.vob -c:a libfdk_aac -b:a 160k -c:v libx264 -preset medium -x264-params crf=23 -f mp4 Film.mp4
        • ffmpeg -i Film.vob -c:a aac -vbr 2 -c:v libx264 -preset medium -x264-params crf=23 -f mp4 Film.mp4
      • mögliche Profile (-profile:v): baseline, main, high, high10, high422, high444
        • Die Option -profile:v hat nur dann Wirkung, wenn auch die Option -level angegeben wird!
        • mögliche Level (-level):
          • -profile:v baseline -level 3.0
          • -profile:v baseline -level 3.1
          • -profile:v main -level 3.1
          • -profile:v main -level 4.0
          • -profile:v high -level 4.0
          • -profile:v high -level 4.1
          • -profile:v high -level 4.2
            • ffmpeg -i Film.vob -c:a libfdk_aac -afterburner 1 -profile:a aac_low -vbr 5 -c:v libx264 -profile:v high -level 4.1 -f mp4 Film.mp4
            • ffmpeg -i Film.vob -c:a aac -q:a 2 -c:v libx264 -profile:v high -level 4.1 -f mp4 Film.mp4
    • x265
      • mögliche Voreinstellungen (-preset): ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow und placebo
        • alles was hinter der Option "-x265-params" angegeben wird, dass wird direkt dem "x265" übergeben
          • ffmpeg -i Film.vob -c:a libfdk_aac -b:a 160k -c:v libx265 -preset medium -x265-params crf=23 -f mp4 -y Film.mp4
          • ffmpeg -i Film.vob -c:a aac -vbr 2 -c:v libx265 -preset medium -crf 23 -f mp4 -y Film.mp4
    • VP9
      1. ffmpeg -i input.avi -map 0:v -c:v libvpx-vp9 -crf 32 -b:v 0 -c:a libvorbis -q:a 6 -map 0:a:0 -c:s copy -f matroska film.mkv
      2. ffmpeg -i input.avi -pix_fmt yuv420p10le -map 0:v -c:v libvpx-vp9 -crf 32 -b:v 0 -c:a libvorbis -q:a 6 -map 0:a:0 -c:s copy -f matroska film.mkv
      3. ffmpeg -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts -i input.avi -map 0:v -c:v libvpx-vp9 -crf 32 -b:v 0 -vf yadif=1/3,mcdeint=mode=extra_slow,scale=768x576,pad='max(iw\,ih*(4/3)):ow/(4/3):(ow-iw)/2:(oh-ih)/2:black',scale=744x558,setdar='4/3' -g 300 -keyint_min 300 -c:a libvorbis -q:a 6 -map 0:a:0 -c:s copy -disposition:a:0 default -metadata title="Filmname" -metadata description='Filmbeschreibung' -f matroska film.mkv
      4. ffmpeg -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts -i film.avi -map 0:v -c:v libvpx-vp9 -crf 32 -b:v 0 -vf yadif=1/3,mcdeint=mode=extra_slow,scale=1024x576,pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2:black',scale=858x482,setdar='16/9' -g 300 -keyint_min 300 -c:a libvorbis -q:a 6 -map 0:a:0 -c:s copy -disposition:a:0 default -metadata title="Filmname" -metadata description='Filmbeschreibung' -f matroska film.mkv
        • ffmpeg -h encoder=libvpx-vp9
    • AV1
      1. ffmpeg -benchmark -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts+igndts -i Quelle.avi -c:v av1 -crf 38 -cpu-used 8 -row-mt 1 -aq-mode 1 -tune 1 -g 300 -c:a aac -movflags faststart -f mp4 -y Ziel.mp4 - Es werden nur interne Codecs verwendet, sodas dieses Kommando immer und überall funktioniert.
      2. ffmpeg -i input.mp4 -c:v libaom-av1 -crf 38 -b:v 0 -cpu-used 5 -row-mt 1 -tile-columns 1 -tile-rows 0 -f matroska ausgabe.mkv - libaom-av1 ist seit dem 23. Sep. 2020 nicht mehr experimentell
        • ffmpeg -h encoder=libaom-av1
      3. ffmpeg -i input.mp4 -c:v librav1e -qp 80 -tile-columns 1 -tile-rows 0 -rav1e-params speed=5:low_latency=true -f matroska ausgabe.mkv
        • ffmpeg -h encoder=librav1e
      4. ffmpeg -i input.mp4 -c:v libsvt_av1 -qp 32 -preset 8 -profile 0 -level 0 -rc 0 -f matroska ausgabe.mkv
        • ffmpeg -h encoder=libsvt_av1
      5. ffmpeg -i input.mp4 -c:v av1 -crf 38 -f matroska ausgabe.mkv

In einem nicht repräsentativen FullHD-Transkodier-Test wurden bei gleicher Qualität (gleiche Optionen: -qp 32 -b:v 0, das entspricht ungefähr der FullHD-Qualität von YouTube), gegenüber dem Codec AVC (h264_nvenc), mit dem Codec HEVC (hevc_nvenc) ca. 20% an Dateigröße eingespart aber ca. 60% mehr Zeit zum transkodieren benötigt.

http://wiki.ubuntuusers.de/FFmpeg#Libav ⇒ Das Projekt Libav ist eine Abspaltung von FFmpeg und wurde im Januar 2011 ins Leben gerufen, als ein Teil der Entwickler mit der Projektleitung unzufrieden war. Der Funktionsumfang ist größtenteils identisch zu FFmpeg, es kann von den gleichen Anwendungen verwendet werden, und unterstützt derzeit bis auf einige Ausnahmen (Stand: August 2012) die gleichen Formate und Codecs. Ein Großteil der Änderungen, die an Libav vorgenommen werden, fließen ebenfalls bei FFmpeg ein (vor allem, um die ABI-Kompatibilität zu wahren).

  • ffmpeg/avconv ist ein Kommandozeilenprogramm, um von einem Video-, Audio- oder Bild-Format zu einem anderen zu konvertieren. Es unterstützt auch das Aufnehmen und Enkodieren von einer TV-Karte in Echtzeit.
  • ffserver/avserver ist ein HTTP Multimedia Streamer Server für Live-Übertragungen über das Internet
  • ffplay/avplay ist ein sehr einfacher Medienplayer für die Kommandozeile
  • ffprobe/avprobe ist ein einfaches Befehlszeilenwerkzeug zum Analysieren von Multimedia-Streams
  • libavcodec enthält alle ffmpeg Audio- und Video-Encoder bzw. -Decoder. Die meisten Codecs wurden von Grund auf neu geschrieben, um die beste Ausführungsgeschwindigkeit sicherzustellen. Diese Bibliothek kann von anderen Programmen benutzt werden, um dann die Filme selber darzustellen.
  • libavformat enthält alle Container-Parser und -Ersteller für alle herkömmlichen Audio- und Video-Containerformate (z. B. AVI, MKV, OGG, Media etc.)

Ubuntu verwendet in der Version 12.04 die FF- und die AV-Programme, bei Verwendung der FF-Programme wird man jedoch darauf hingewiesen, dass sie in zukünftigen Ubuntu-Versionen nicht mehr enthalten sein werden.

unterstützte Codecs

unterstützte Video-Codecs anzeigen: 

> ffmpeg -encoders
...
 V..... libaom-av1           libaom AV1 (codec av1)
...
 V..... h261                 H.261
 V..... h263                 H.263 / H.263-1996
 V.S... h263p                H.263+ / H.263-1998 / H.263 version 2
 V..... libx264              libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (codec h264)
 V..... libx264rgb           libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB (codec h264)
 V....D h264_vaapi           H.264/AVC (VAAPI) (codec h264)
 V..... libx265              libx265 H.265 / HEVC (codec hevc)
 V....D hevc_vaapi           H.265/HEVC (VAAPI) (codec hevc)
 VF.... huffyuv              Huffyuv / HuffYUV
...
 V..... libtheora            libtheora Theora (codec theora)
 VF.... tiff                 TIFF image
 VF.... utvideo              Ut Video
 V..... v210                 Uncompressed 4:2:2 10-bit
 V..... v308                 Uncompressed packed 4:4:4
 V..... v408                 Uncompressed packed QT 4:4:4:4
 V..... v410                 Uncompressed 4:4:4 10-bit
 V..... libvpx               libvpx VP8 (codec vp8)
 V....D vp8_vaapi            VP8 (VAAPI) (codec vp8)
 V..... libvpx-vp9           libvpx VP9 (codec vp9)
 V....D vp9_vaapi            VP9 (VAAPI) (codec vp9)
...

die möglichen Optionen zu einem Codec anzeigen lassen: 

> ffmpeg -h encoder=libx264
  Encoder libx264 [libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10]:
    General capabilities: delay threads 
    Threading capabilities: other
    Supported pixel formats: yuv420p yuvj420p yuv422p yuvj422p yuv444p yuvj444p nv12 nv16 nv21 yuv420p10le yuv422p10le yuv444p10le nv20le gray gray10le
libx264 AVOptions:
  -preset            <string>     E..V....... Set the encoding preset (cf. x264 --fullhelp) (default "medium")
  -tune              <string>     E..V....... Tune the encoding params (cf. x264 --fullhelp)
  -profile           <string>     E..V....... Set profile restrictions (cf. x264 --fullhelp) 
  -fastfirstpass     <boolean>    E..V....... Use fast settings when encoding first pass (default true)
  -level             <string>     E..V....... Specify level (as defined by Annex A)
  -passlogfile       <string>     E..V....... Filename for 2 pass stats
  -wpredp            <string>     E..V....... Weighted prediction for P-frames
  -a53cc             <boolean>    E..V....... Use A53 Closed Captions (if available) (default true)
  -x264opts          <string>     E..V....... x264 options
  -crf               <float>      E..V....... Select the quality for constant quality mode (from -1 to FLT_MAX) (default -1)
...

> ffmpeg -h encoder=libx265

> ffmpeg -h encoder=libvpx-vp9

> ffmpeg -h encoder=libaom-av1
> aomenc --help

Beschriftung von Tonspur und Untertitel

In diesem Beispiel hat der Film drei Tonspuren (deutsch, englisch und französisch) und ein Untertitelspur (deutsch).

die drei Tonspuren werden so beschriftet: 

# -metadata:s:a:0 language=ger
# -metadata:s:a:1 language=eng
# -metadata:s:a:2 language=fra

die Untertitelspur wird so beschriftet: 

# -metadata:s:s:0 language=ger

so könnte beispielsweise ein DVD-Rip (Original: 16/9 mit 720x576 Bildpunkten) aussehen, welcher in quadratische Bildpunkte (1024x576) ähnlicher Bildpunkteanzahl (858x432) umgerechnet wird: 

> ffmpeg  -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts -i Film.mpg -map 0:v -c:v libvpx-vp9 -crf 32 -b:v 0 -vf scale=1024x576,pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2:black',scale=858x482,setdar='16/9' -keyint_min 2 -8 -c:a libvorbis -q:a 6 -map 0:a:0 -map 0:a:1 -map 0:a:2 -c:s copy -map 0:s:0? -map 0:s:1? -disposition:a:0 default -disposition:a:1 0 -disposition:a:2 0 -disposition:s:0 default -disposition:s:1 0 -metadata:s:a:0 language=ger -metadata:s:a:1 language=eng -metadata:s:a:2 language=fra -metadata:s:s:0 language=ger -metadata title="Spielfilm" -metadata description='FSK 16 / 2014 / 101 Minuten' -f matroska -y Film.mkv

FFmpeg Metadata (Tag)

Mit FFmpeg Metadata (Tag) in eine Multimediadatei einbinden.

spezielle FFmpeg-Optionen

Zum "Tiefenscan" kann man die Parameter -probesize (in Bytes; mind. 32 Byte) oder -analyzeduration (in Mikrosekunden) verwenden. Standardwert ist jeweils 5 Millionen (also 5 MBytes oder 5 Sekunden), wohl je nach dem was früher erreicht wird. Große Zahlen darf man mit SI-Suffixen angeben (M/G/T *1000, Mi/Gi/Ti *1024). 

-analyzeduration   <int64>      .D....... specify how many microseconds are analyzed to probe the input (from 0 to I64_MAX) (default 0)
-probesize         <int64>      .D....... set probing size (from 32 to I64_MAX) (default 5e+06)
-formatprobesize   <int>        .D....... number of bytes to probe file format (from 0 to 2.14748e+09) (default 1.04858e+06)
-fpsprobesize      <int>        .D....... number of frames used to probe fps (from -1 to 2.14748e+09) (default -1)
$ du -k Avengers_4_-_Endgame.mpg
7448081 Avengers_4_-_Endgame.mpg

$ ffprobe -probesize 7448081KiB -formatprobesize 255MiB -fpsprobesize 255MiB Avengers_4_-_Endgame.mpg

Die Option -probesize funktioniert nicht alleine, es muss mindestens zusammen mit -fpsprobesize verwendet werden. 

$ ffprobe -probesize 7448081KiB -fpsprobesize 255MiB -i Avengers_4_-_Endgame.mpg

Die besten Ergebnisse erhält man, wenn die beiden Optionen -probesize und -analyzeduration zusammen verwendet werden (man kann hier ganz einfach immer den Maximalwert angeben): 

$ ffprobe -probesize 9223372036G -analyzeduration 9223372036G -i Avengers_4_-_Endgame.mpg 
$ ffmpeg  -probesize 9223372036G -analyzeduration 9223372036G -i Avengers_4_-_Endgame.mpg ...

pad

Fügen Sie dem Eingabevideo Paddings mit der Farbe „Violett“ hinzu. Die Größe des Ausgabevideos beträgt 640x480, und die obere linke Ecke des Eingabevideos wird in Spalte 0 (von links), Zeile 40 (von oben) platziert: 

  pad=640:480:0:40:violet

Das obige Beispiel entspricht dem folgenden Befehl: 

  pad=width=640:height=480:x=0:y=40:color=violet

Füllen Sie die Eingabe auf, um eine Ausgabe mit um 3/2 vergrößerten Abmessungen zu erhalten, und platzieren Sie das Eingabevideo in der Mitte des aufgefüllten Bereichs: 

  pad="3/2*iw:3/2*ih:(ow-iw)/2:(oh-ih)/2"

Füllen Sie die Eingabe auf, um eine quadratische Ausgabe mit einer Größe zu erhalten, die dem Maximalwert zwischen Eingabebreite und -höhe entspricht, und platzieren Sie das Eingabevideo in der Mitte des aufgefüllten Bereichs: 

  pad="max(iw\,ih):ow:(ow-iw)/2:(oh-ih)/2"

Füllen Sie den Eingang auf, um ein endgültiges w/h-Verhältnis von 16:9 zu erhalten: 

  pad="ih*16/9:ih:(ow-iw)/2:(oh-ih)/2"
  pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2:black'

Im Fall von anamorphotischem Video ist es notwendig, um das Seitenverhältnis der Ausgabeanzeige korrekt einzustellen, entsprechend der Beziehung sar im Ausdruck zu verwenden: 

  (ih * X / ih) * sar = output_dar
  X = output_dar / sar

Daher muss das vorherige Beispiel modifiziert werden: 

  pad="ih*16/9/sar:ih:(ow-iw)/2:(oh-ih)/2"

Verdoppeln Sie die Ausgabegröße und platzieren Sie das Eingabevideo in der unteren rechten Ecke des aufgefüllten Ausgabebereichs: 

  pad="2*iw:2*ih:ow-iw:oh-ih"

Filme in ein HTML5-kompatibles MP4-Format umrechnen

> ffmpeg -nostdin -fflags +genpts -i film.avi -c:v libx264 -crf 20 -c:a libfaac -b:a 160k -f mp4 -y film.mp4

zum Beispiel (ohne änderung des Bildformates): 

> ffmpeg -i Jack_Reacher_-_720x576.avi -map 0:v -c:v libx264 -crf 20 -keyint_min 2-8 -map 0:a:0 -c:a libfaac -b:a 160k -f mp4 -y Jack_Reacher_-_originalformat.mp4

oder so, Bildformat wird auf 4/3 mit quadratischen Pixeln umgewandelt: 

> ffmpeg -i Jack_Reacher_-_720x576.avi -map 0:v -c:v libx264 -crf 20 -vf scale=736x552,pad='max(iw\,ih*(4/3)):ow/(4/3):(ow-iw)/2:(oh-ih)/2',setsar='1/1' -keyint_min 2-8 -map 0:a:0 -c:a libfaac -b:a 160k -f mp4 -y Jack_Reacher_-_4zu3.mp4

oder so, Bildformat wird auf 16/9 mit quadratischen Pixeln umgewandelt: 

> ffmpeg -i Jack_Reacher_-_720x576.avi -map 0:v -c:v libx264 -crf 20 -vf scale=864x486,pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2',setsar='1/1' -keyint_min 2-8 -map 0:a:0 -c:a libfaac -b:a 160k -f mp4 -y Jack_Reacher_-_16zu9.mp4

oder einfach mit Skript (siehe: Filmwandler, Film2MP4): 

> /home/bin/Filme2MP4.sh -q Jack_Reacher.avi -z Jack_Reacher.mp4
> /home/bin/Filmwandler.sh -q Jack_Reacher.avi -z Jack_Reacher.mp4

Bitrate abschätzen an Hand von CRF

Diese Beispielreihe wurde an Hand von einem Ausschnitt aus Thor 3 - Tag der Entscheidung (von der 5. bis zur 25. Minute - FullHD - 1920x1080 = 2073600 Bildpunkte) ermittelt. Weiterhin wurden u.a. diese Parameter dem ffmpeg übergeben

  1. -fflags +genpts
  2. -c:v libx264 -profile:v high
crf 15 ~ 8350 kb/s
crf 16 ~ 7250 kb/s
crf 17 ~ 6290 kb/s
crf 18 ~ 5460 kb/s
crf 19 ~ 4740 kb/s
crf 20 ~ 4130 kb/s
crf 21 ~ 3590 kb/s
crf 22 ~ 3130 kb/s
crf 23 ~ 2720 kb/s
crf 24 ~ 2370 kb/s
crf 25 ~ 2070 kb/s
crf 26 ~ 1810 kb/s
crf 27 ~ 1590 kb/s
crf 28 ~ 1400 kb/s
crf 29 ~ 1240 kb/s
crf 30 ~ 1100 kb/s
crf 31 ~ 980 kb/s
crf 32 ~ 870 kb/s
crf 33 ~ 780 kb/s
crf 34 ~ 700 kb/s
crf 35 ~ 630 kb/s

CRF kann Werte zwischen 0 (Verlustfrei) und 51 annehmen. Es werden für crf Werte zwischen 15 (beste Blu-ray Disk - Qualität) und 35 (nur auf 2-4 Zoll großen Displays sinnvoll) empfohlen.

Kapitel, Menüs oder leere Untertitelspuren entfernen/vermeiden

Mit -map_chapters -1 kann man vermeiden, dass im Ziel Kapitel oder Menüs angelegt werden. Manchmal werden fehlerhafte Einträge in der Quelle als Untertitel übernommen, welche dann im Videoplayer so angezeigt werden, aber nicht funktionieren.

Beispiel: 

> ffmpeg -i Venom_-_Let_There_Be_Carnage.en.mp4 -itsoffset -0.75 -i Venom_-_Let_There_Be_Carnage.de.mp4 -i Venom_-_Let_There_Be_Carnage.en.vtt -itsoffset 0.75 -i Venom_-_Let_There_Be_Carnage.de.vtt -c:v copy -c:a copy -c:s mov_text -map 0:v:0 -map 0:a:0 -map 1:a:0 -map 2:s:0 -map 3:s:0 -metadata:s:a:0 language=eng -metadata:s:a:1 language=ger -metadata:s:s:0 language=eng -metadata:s:s:1 language=ger -map_chapters -1 Venom_-_Let_There_Be_Carnage.mp4

Kompilieren / Compile

~/bin/ffmpeg-compile-debian.sh
#!/usr/bin/env bash
 
set -o errexit
set -o nounset
set -o pipefail
shopt -s inherit_errexit
 
if test -z "${FFMPEG_VERSION}"
then
	echo "You need to set the FFMPEG_VERSION environment variable (see https://git.ffmpeg.org/gitweb/ffmpeg.git/tags)"
	exit 1
fi
 
FFMPEG_VERSION="${FFMPEG_VERSION#n}"
 
sudo apt-get update -qq
sudo apt-get -qq install \
	autoconf \
	automake \
	build-essential \
	cmake \
	git-core \
	libass-dev \
	libfreetype6-dev \
	libgnutls28-dev \
	libmp3lame-dev \
	libsdl2-dev \
	libtool \
	libva-dev \
	libvdpau-dev \
	libvorbis-dev \
	libxcb1-dev \
	libxcb-shm0-dev \
	libxcb-xfixes0-dev \
	meson \
	ninja-build \
	pkg-config \
	texinfo \
	wget \
	yasm \
	zlib1g-dev
sudo apt-get -qq install libunistring-dev libaom-dev libdav1d-dev
sudo apt-get -qq install nasm
sudo apt-get -qq install libx264-dev
sudo apt-get -qq install libx265-dev libnuma-dev
sudo apt-get -qq install libvpx-dev
sudo apt-get -qq install libfdk-aac-dev
sudo apt-get -qq install libopus-dev
 
mkdir -p ~/ffmpeg_sources ~/bin
 
# libaom
cd ~/ffmpeg_sources && \
git -C aom pull --prune > /dev/null 2>&1 || git clone https://aomedia.googlesource.com/aom aom && \
git -C aom switch --detach $(git -C aom describe --tag --abbrev=0) && \
mkdir -p aom_build && \
cd aom_build && \
PATH="${HOME}/bin:${PATH}" cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="${HOME}/ffmpeg_build" -DENABLE_TESTS=OFF -DENABLE_NASM=on ../aom && \
PATH="${HOME}/bin:${PATH}" make -j$(nproc) && \
make -j$(nproc) install
 
# libsvtav1
cd ~/ffmpeg_sources && \
git -C svt-av1 pull --prune > /dev/null 2>&1 || git clone https://gitlab.com/AOMediaCodec/SVT-AV1.git svt-av1 && \
git -C svt-av1 switch --detach $(git -C svt-av1 describe --tag --abbrev=0) && \
mkdir -p svt-av1_build && \
cd svt-av1_build && \
PATH="${HOME}/bin:${PATH}" cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="${HOME}/ffmpeg_build" -DCMAKE_BUILD_TYPE=Release -DBUILD_DEC=OFF -DBUILD_SHARED_LIBS=OFF ../svt-av1 && \
PATH="${HOME}/bin:${PATH}" make -j$(nproc) && \
make -j$(nproc) install
 
# libvmaf
cd ~/ffmpeg_sources && \
git -C vmaf pull --prune > /dev/null 2>&1 || git clone https://github.com/Netflix/vmaf.git vmaf && \
git -C vmaf switch --detach $(git -C vmaf describe --tag --abbrev=0) && \
mkdir -p vmaf_build && \
cd vmaf_build && \
meson setup -Denable_tests=false -Denable_docs=false --buildtype=release --default-library=static ../vmaf/libvmaf --prefix "${HOME}/ffmpeg_build" --bindir="bin" --libdir="lib" && \
ninja -j$(nproc) && \
ninja -j$(nproc) install
 
# ffmpeg
FFMPEG_VERSION_STRING="ffmpeg-${FFMPEG_VERSION}"
cd ~/ffmpeg_sources && \
wget -O ${FFMPEG_VERSION_STRING}.tar.gz https://ffmpeg.org/releases/${FFMPEG_VERSION_STRING}.tar.gz && \
tar xvf ${FFMPEG_VERSION_STRING}.tar.gz && \
cd ${FFMPEG_VERSION_STRING} && \
PATH="${HOME}/bin:${PATH}" PKG_CONFIG_PATH="${HOME}/ffmpeg_build/lib/pkgconfig" ./configure \
	--prefix="$HOME/ffmpeg_build" \
	--pkg-config-flags="--static" \
	--extra-cflags="-I${HOME}/ffmpeg_build/include" \
	--extra-ldflags="-L${HOME}/ffmpeg_build/lib" \
	--extra-libs="-lpthread -lm" \
	--ld="g++" \
	--bindir="${HOME}/bin" \
	--enable-gpl \
	--enable-gnutls \
	--enable-libaom \
	--enable-libass \
	--enable-libdav1d \
	--enable-libfdk-aac \
	--enable-libfreetype \
	--enable-libmp3lame \
	--enable-libopus \
	--enable-libsvtav1 \
	--enable-libvmaf \
	--enable-libvorbis \
	--enable-libvpx \
	--enable-libx264 \
	--enable-libx265 \
	--enable-nonfree && \
PATH="${HOME}/bin:${PATH}" make -j$(nproc) && \
make -j$(nproc) install && \
hash -r
 
. ~/.profile
~/bin/compile-ffmpeg-debian.sh

HDR10

> mediainfo Film_HDR10.mp4
...
Color primaries                          : BT.2020
Transfer characteristics                 : PQ
Matrix coefficients                      : BT.2020 non-constant
...
  • Technische Details
    • Auflösung
      • Empfehlung 2020 definiert zwei Auflösungen, 3840x2160 ("4K") und 7680x4320 ("8K").
      • Diese Auflösungen haben ein Seitenverhältnis von 16:9 und nutzen quadratische Bildpunkte.
    • Bildfrequenz
      • Empfehlung 2020 spezifiziert die folgenden Bildfrequenzen:
        • 120p
        • 119,88p
        • 100p
        • 60p
        • 59,94p
        • 50p
        • 30p
        • 29,97p
        • 25p
        • 24p
        • 23,976p
        • Nur Vollbildverfahren sind erlaubt.
      • Digitale Darstellung
        • Empfehlung 2020 definiert eine Farbtiefe von entweder 10 oder 12 Bits pro Abtastwert.
> ffmpeg -i Film_HDR10.mp4 ... -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 ... -f mp4 -y Film_SDR.mp4
> ffmpeg -i Film_HDR10.mp4 ... -vf zscale=t=linear:npl=100,zscale=p=bt709,tonemap=hable:desat=0,zscale=t=bt709:m=bt709,format=yuv420p ... -f mp4 -y Film_SDR.mp4
> ffmpeg -i Film_HDR10.mp4 ... -vf zscale=t=linear,tonemap=gamma,zscale=p=709:t=709:m=709,format=yuv420p ... -f mp4 -y Film_SDR.mp4

Film drehen

Video um 90 Grad nach rechts drehen: 

ffmpeg -i input_falsch.mp4 -vf "transpose=1" -qscale 0 -c:a copy output_richtig.mp4

Video um 90 Grad nach links drehen: 

ffmpeg -i input_falsch.mp4 -vf "transpose=2" -qscale 0 -c:a copy output_richtig.mp4

Video um 180 Grad drehen: 

ffmpeg -i input_falsch.mp4 -vf "hflip,vflip" -qscale 0 -c:a copy output_richtig.mp4

Daumenkino mit FFmpeg

aus einem einzigen Bild (Bild.png), ein AV1-Video (Film_-_stumm.webm), von 3600 Sekunden Länge, machen: 

> ffmpeg -loop 1 -i Bild.png -t 3600 -map 0:v -c:v libsvtav1 -crf 42 -preset 5 -svtav1-params enable-overlays=1:enable-tf=0:film-grain=0:film-grain-denoise=0:keyint=5s:scd=1:tune=0:fast-decode=0 -vf fps=1,format=yuv420p,pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2:black',setdar='16/9' -f webm -y Film_-_stumm.webm

verschiedene Beispiele: 

ffmpeg -framerate 1/5 -i img%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p out.mp4
ffmpeg -framerate 1/5 -start_number 126 -i img%03d.png -c:v libx264 -r 30 -pix_fmt yuv420p out.mp4
ffmpeg -framerate 1/5 -i img%03d.png -c:v libx264 -vf fps=25 -pix_fmt yuv420p out.mp4
ffmpeg -framerate 1/5 -i img%03d.png -c:v libx264 -vf "fps=25,format=yuv420p" out.mp4
ffmpeg -framerate 1 -pattern_type glob -i '*.jpg' -c:v libx264 out.mp4
ffmpeg -framerate 1 -pattern_type glob -i '*.png' -c:v libx264 -pix_fmt yuv420p out.mp4

In diesem Beispiel werden alle Bilder (*.png) sortiert, nacheinander für jeweils 15 Sekunden, zu einem Film (out.mp4) im AVC-Format mit 25 Bilder pro Sekunde umgewandelt: 

ffmpeg -c:v libx264 -r 25 -pattern_type glob -i '*.png' -framerate 1/15 -y out.mp4

Wenn man aus diesen Dateien 

      B00.png
      B01.png
      B02.png
      B03.png
      B04.png
      B05.png
      B06.png
      B07.png
      B08.png
      B09.png
      B10.png
      B11.png
      B12.png

einen Daumenkino-Film (mit 2 Bildern pro Sekunde) machen will, dann geht das so: 

ffmpeg -framerate 2 -pattern_type glob -i '*.png' -c:v libx264 -vf 'format=yuv420p,fps=25' -y Film.mp4

Die 'framerate' gibt an, wieviele Bilder pro Sekunde angezeigt werden: 

'1' -> jedes Bild wird für eine Sekunde angezeigt
'2' -> zwei Bild werden pro Sekunde angezeigt
'1/5' -> jedes Bild wird für fünf Sekunden angezeigt

Bild mit Tonspur

Wenn man ein Bild mit einer Tonspur aus einem Video untermalen will (ein sehr einfaches Beispiel), der neue Film wird im DivX-Format erstellt:

Film_avi.sh
ffmpeg \
        -i Film_mit_Tonspur.mp4 \
        -loop 1 \
        -i Bild.png \
        -map 1:v \
        -c:v mpeg4 \
        -b:v 3072k \
        -profile:v 15 \
        -level 4 \
        -vtag DX50 \
        -g 300 \
        -map 0:a:0 \
        -c:a ac3 \
        -f avi \
        -y Neuer_Film.avi

der neue Film hat das Format MP4+AVC+AAC und kann von jedem modernen Browser (z.B. Firefox) abgespielt werden:

Film_mp4.sh
ffmpeg \
        -benchmark \
        -probesize 9223372036854M \
        -analyzeduration 9223372036854M \
        -fflags +genpts+igndts \
        -i Film_mit_Tonspur.mp4 \
        -loop 1 \
        -i Bild.png \
        -map 1:v \
        -c:v libx264 \
        -crf 35 \
        -b:v 0 \
        -preset slower \
        -tune film \
        -x264opts bluray-compat=1:vbv-maxrate=15000:vbv-bufsize=15000:nal-hrd=vbr:level=4:slices=1:b-adapt=2:direct=auto:colorprim=bt709:transfer=bt709:colormatrix=bt709:keyint=50:subme=9 \
        -vf pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2:black',setdar='16/9' \
        -g 300 \
        -afterburner 1 \
        -map 0:a:0 \
        -c:a:0 libfdk_aac \
        -b:a:0 140k \
        -metadata:s:a:0 language=de \
        -disposition:a:0 default \
        -sn \
        -ss 9.2 \
        -to 1633.2 \
        -metadata title="So soll der neue Film heißen" \
        -metadata description='Hier können nähere Informationen zum neuen Film hinterlegt werden' \
        -f mp4 \
        -y Neuer_Film.mp4

der neue Film hat das Format WebM+AV1+Opus und kann von jedem modernen Browser (z.B. Firefox) abgespielt werden:

Film_webm.sh
ffmpeg 
        -benchmark \
        -probesize 9223372036854M \
        -analyzeduration 9223372036854M \
        -fflags +genpts+igndts \
        -i Film_mit_Tonspur.mp4 \
        -loop 1 \
        -i Bild.png \
        -map 1:v \
        -c:v libsvtav1 \
        -crf 42 \
        -preset 5 \
        -svtav1-params enable-overlays=1:enable-tf=0:film-grain=0:film-grain-denoise=0:keyint=5s:scd=1:tune=0:fast-decode=0 \
        -vf pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2:black',setdar='16/9' \
        -compression_level 10 \
        -map 0:a:0 \
        -c:a:0 libopus \
        -b:a:0 128k \
        -vbr:a:0 on \
        -mapping_family:a:0 0 \
        -filter:a:0 aformat=channel_layouts='stereo|mono' \
        -metadata:s:a:0 language=de \
        -disposition:a:0 default \
        -sn \
        -ss 9.2 \
        -to 1633.2 \
        -metadata title="So soll der neue Film heißen" \
        -metadata description='Hier können nähere Informationen zum neuen Film hinterlegt werden' \
        -f webm \
        -y Neuer_Film.webm

Die Tonspur aus dem Film, soll von Sekunde 9.2 bis Sekunde 1633.2, in den neuen Film übernommen werden.

Film in Einzelbilder zerlegen

ffmpeg -i film.mp4 -q:v 2 %05d.jpg

ls -lha
drwxrwxr-x  2 fritz fritz  12K Dez 23 17:19 .
drwxrwxrwt 20 fritz fritz  12K Dez 23 17:23 ..
-rw-rw-r--  1 fritz fritz 213K Dez 23 17:19 00001.jpg
-rw-rw-r--  1 fritz fritz 211K Dez 23 17:19 00002.jpg
-rw-rw-r--  1 fritz fritz 210K Dez 23 17:19 00003.jpg
-rw-rw-r--  1 fritz fritz 156K Dez 23 17:19 00004.jpg
...

animiertes GIF mit FFmpeg erzeugen

Filmausschnitt 1:1 als "animiertes GIF" ablegen: 

> ffmpeg -i Film.mp4 -ss 4608.9 -t 5.2 -y Filmausschnitt.gif

Filmausschnitt mit schwarzen Balken auf 4/3 erweitern, dann in die Auflösung 360x270 skalieren und als "animiertes GIF" ablegen: 

> ffmpeg -i Film.mp4 -vf pad='max(iw\,ih*(4/3)):ow/(4/3):(ow-iw)/2:(oh-ih)/2',setsar='1/1' -s 360x270 -ss 4608.9 -t 5.2 -y Filmausschnitt_4-3.gif

Filmausschnitt mit schwarzen Balken auf 16/9 erweitern, dann in die Auflösung 480x270 skalieren und als "animiertes GIF" ablegen: 

> ffmpeg -i Film.mp4 -vf pad='max(iw\,ih*(16/9)):ow/(16/9):(ow-iw)/2:(oh-ih)/2',setsar='1/1' -s 480x270 -ss 4608.9 -t 5.2 -y Filmausschnitt_16-9.gif

spezielle Beispiele

Target

"vcd", "svcd", "dvd", "dv", "dv50" 

> ffmpeg -i file.avi -target vcd /tmp/test.mpg
Could not determine norm (PAL/NTSC/NTSC-Film) for target.
Please prefix target with "pal-", "ntsc-" or "film-",
or set a framerate with "-r xxx".

> ffmpeg -i file.vob -target pal-vcd /tmp/test.mpg
> ffmpeg -i file.vob -target pal-dv50 /tmp/test.avi

WAVE in AC3 (a52) umwandeln

Wenn sich mehr als zwei Spuren in der Datei befinden, dann ist AC3 der kompatibelste Codec für einen Film: 

> ffmpeg -i Film_Tonspur.wav -codec:a ac3 Film_Tonspur.ac3

eine beliebige Tonspur in WAVE umwandeln

Meistens wird die Umwandlung genau andersherum gemacht. Aber manchmal möchte man eine MP3-Datei auch auf eine klassische Musik-CD brennen, dann braucht man meistens eine WAVE oder eine AU-Datei. 

> ffmpeg -i Beispiel.mp3 -vn -acodec pcm_s16le -ar 44100 -ac 2 -y Beispiel.wav
> ffmpeg -i Beispiel.avi -vn -acodec pcm_s16le -ar 44100 -ac 2 -y Beispiel.wav

Auf eine Musik-CD brennt man diese WAVE-Dateien dann zum Beispiel unter FreeBSD so:

  • für IDE-Brenner (P-ATA) ⇒ BurnCD
  • für SCSI- und S-ATA-Brenner ⇒ CDRecord

Audio-transkodier-Skripte

eine beliebige Audio-Spur ins Wave-Format umwandeln
#!/bin/bash

#
# mit diesem Skript kann man die Tonspur aus einem Film im CD-kompatibelen
# Wave-Format extrahieren;
# oder jede Audio-Datei in das CD-kompatibelen Wave-Format umwandeln;
#
# die hiermit erzeugten Wave-Dateien können auf CD gebrannt werden
#

if [ -r "${1}" ] ; then
        ffmpeg -i ${1} -vn -acodec pcm_s16le -ar 44100 -ac 2 ${1}.wav
        ls -lha ${1}.wav
else
        echo "${0} Film.mkv"
        echo "${0} Audio-Datei"
        exit 1
fi
eine beliebige Audio-Spur ins MP3-Format umwandeln
#!/bin/bash

#
# mit diesem Skript kann eine beliebige Audio-Datei
# in eine MP3-Datei umgewandelt werden
#

if [ -r "${1}" ] ; then
        PROGRAMM="$(which ffmpeg)"
        if [ -z "${PROGRAMM}" ] ; then
                PROGRAMM="$(which avconv)"
        fi

        #${PROGRAMM} -i ${1} -vn -c:a libmp3lame -ar 44100 -ac 2 ${1}.mp3
        ${PROGRAMM} -i ${1} -vn -c:a libmp3lame -aq 2 -ac 2 ${1}.mp3
        ls -lha ${1}.mp3
else
        echo "${0} Film.mkv"
        echo "${0} Audio-Datei"
        exit 1
fi
eine beliebige Audio-Spur ins FLAC-Format umwandeln
> ffmpeg -h encoder=flac
Encoder flac [FLAC (Free Lossless Audio Codec)]:
    General capabilities: delay small lossless 
    Threading capabilities: none
    Supported sample formats: s16 s32
FLAC encoder AVOptions:
  -lpc_coeff_precision <int>        E...A.... LPC coefficient precision (from 0 to 15) (default 15)
  -lpc_type          <int>        E...A.... LPC algorithm (from -1 to 3) (default -1)
     none                         E...A....
     fixed                        E...A....
     levinson                     E...A....
     cholesky                     E...A....
  -lpc_passes        <int>        E...A.... Number of passes to use for Cholesky factorization during LPC analysis (from 1 to INT_MAX) (default 2)
  -min_partition_order <int>        E...A.... (from -1 to 8) (default -1)
  -max_partition_order <int>        E...A.... (from -1 to 8) (default -1)
  -prediction_order_method <int>        E...A.... Search method for selecting prediction order (from -1 to 5) (default -1)
     estimation                   E...A....
     2level                       E...A....
     4level                       E...A....
     8level                       E...A....
     search                       E...A....
     log                          E...A....
  -ch_mode           <int>        E...A.... Stereo decorrelation mode (from -1 to 3) (default auto)
     auto                         E...A....
     indep                        E...A....
     left_side                    E...A....
     right_side                   E...A....
     mid_side                     E...A....
  -exact_rice_parameters <boolean>    E...A.... Calculate rice parameters exactly (default false)
  -multi_dim_quant   <boolean>    E...A.... Multi-dimensional quantization (default false)
  -min_prediction_order <int>        E...A.... (from -1 to 32) (default -1)
  -max_prediction_order <int>        E...A.... (from -1 to 32) (default -1)

Beispiel 1 (minimal): 

> ffmpeg -i Film.mkv -vn -c:a flac Audio.flac

Beispiel 2 (üblich): 

> ffmpeg -i Film.mkv -vn -c:a flac -sample_fmt s32 -ar 48000 -y Audio.flac

Beispiel 3 (schnell + größere Datei): 

> ffmpeg -i Film.mkv -vn -c:a flac -sample_fmt s32 -ar 48000 -compression_level 0 -y Audio.flac

Beispiel 4 (langsam + kleinere Datei): 

> ffmpeg -i Film.mkv -vn -c:a flac -sample_fmt s32 -ar 48000 -compression_level 12 -y Audio.flac

3gp erzeugen

siehe auch: mp4 verlustbehaftet aus einem MKV erstellen

Einfachste Möglichkeit, die ein Video erzeugt, das auf den meisten Geräten laufen sollte
allerdings sind in diesem 3GP-Film die Kreise nur dann rund, wenn das Quell-Format "11:9" ist (192k - normale Qualitaet bei 15FPS):
ffmpeg -i Film.mpg -vcodec h263 -s 176x144 -vf "setsar=1:1" -b 192k -r 15 -acodec libfaac -ar 24k -ab 64k -ac 1 -y Film.3gp
ffmpeg -i Film.mpg -vf scale=320:240 -vcodec mpeg4 -acodec aac -strict -2 -f 3gp Film.3gp
ffmpeg -i Film.mpg -vcodec mpeg4 -s 176x144 -qscale:v 12 -r 10 -level 8 -brand 3gp6 -vf 'pad=max(iw\,ih*(11/9)):ow/(11/9):(ow-iw)/2:(oh-ih)/2,scale=iw*sar:ih' acodec libfaac -ar 22050 -ac 1 -qscale:a 45 Film.3gp

Damit die Kreise in den 3GP-Filmen immer rund sind,
muss man das Quellformat richtig auf das Zielformat umrechnen!

ACHTUNG!
Einige Geräte, wie z.B. die Handy-Uhr/Smartwatch "BURG 12", zeigen nur akkurate 3GP-Filme an, dafür reicht schon ein nicht richtig gesetzter Aspect (Seitenverhältnis des Bildes). Es müssen auf jeden Fall quadratische Bildpunkte sein. Die Handy-Uhr/Smartwatch "PW-315" von simvalley dagegen spielt alles ab, egal wie das Seitenverhältnis des Bildes aussieht.

Damit die Pixel (Bildpunkte) auch immer quadratisch sind und somit das Bild auch auf der "BURG 12" immer angezeigt wird, habe ich den VideoFilter "setsar=1:1" immer mitverwendet.
ffmpeg -i Film.mpg -vcodec h263 -s 176x144 -vf "setsar=1:1" -b 192k -r 15 -acodec libfaac -ar 24k -ab 64k -ac 1 -y Film.3gp

So transcodiert man einen 4:3-Film in einen sauberen 3GP-Film um:
ffmpeg -i Film.mpg -vcodec h263 -s 176x132 -vf "pad=176:144:0:6:black,setsar=1:1" -b 192k -r 15 -acodec libfaac -ar 24k -ab 64k -ac 1 -y Film.3gp

so transcodiert man einen 16:9-Film in einen sauberen 3GP-Film um:
ffmpeg -i Film.mpg -vcodec h263 -s 176x108 -vf "pad=176:144:0:18:black,setsar=1:1" -b 192k -r 15 -acodec libfaac -ar 24k -ab 64k -ac 1 -y Film.3gp

Manche Geräte vertragen auch eine höhere Datenrate, dann kann man die Bildqualität etwas anheben (384k - hohe Qualitaet bei 25FPS):
ffmpeg -i Film.mpg -vcodec h263 -s 176x144 -vf "setsar=1:1" -b 384k -r 25 -acodec libfaac -ar 24k -ab 64k -ac 1 -y Film.3gp

Die hiermit erzeugten 3GP-Filme können aber trotzdem nicht auf allen 3GP-Geräten im QCIF-Format angezeigt werden, weil ins besondere ältere Geräte den Audio-Codec "AAC" nicht verarbeiten können und stattdessen die Tonspur im "AMR (Adaptive Multi-Rate) Narrow band"-Format benötigen.

Meine lieblings-Variante: 

> ffmpeg -i __Film.mpg__ -c:v h263 -s 176x144 -vf "pad=max(iw\,ih*(176/144)):ow/(176/144):(ow-iw)/2:(oh-ih)/2,setsar=1/1,scale=iw*sar:ih" -b:v 192k -r 15 -c:a libfaac -ar 24k -b:a 64k -ac 1 -y __Film.3gp__

mp4 erzeugen (getestet auf LG GD510)

Daten des LG GD510: 

Video            : MPEG4p2 (max. 700 kbps) / H.263 (128x96, 176x144, 352x288, 704x576, 1408x1152)
Video-Format     : 400x240
FPS              : bis 50/s positiv getestet
Audio            : MP3 (max. 256 kbps) / AAC (max. 512 kbps)
Sampel-Rate      : 44100
Tonspuren        : 2
Kontainer        : *.3gp / *.mp4

So wird der Film "Film.mkv" mit optimaler Qualität für das GD510 zum "Film.mp4" transkodiert.
FreeBSD 10.1 (alter Programmname): 

ffmpeg -i Film.mkv -c:a libfaac -ar 44100 -b:a 128k -ac 2 -b:v 512k -c:v mpeg4 -s 400x240 -vf scale=iw*sar:ih,pad="max(iw\,ih*(5/3)):ow/(5/3):(ow-iw)/2:(oh-ih)/2","setsar=1/1" -y Film.mp4

Linux / Ubuntu 14.04 (neuer Programmname): 

avconv -i Film.mkv -c:a libfaac -ar 44100 -b:a 128k -ac 2 -b:v 512k -c:v mpeg4 -s 400x240 -vf scale=iw*sar:ih,pad="max(iw\,ih*(5/3)):ow/(5/3):(ow-iw)/2:(oh-ih)/2","setsar=1/1" -y Film.mp4

mit diesem Kommando kann man Videos für die folgenden Geräte transkodieren:

  • LG GD510 POP
  • LG KP500 Cookie
  • Samsung S5230 Star

Transkodier-Programme für Windows: 

#!/bin/sh

ffmpeg -i ${1} -s 400x240 -vf scale=iw*sar:ih,pad="max(iw\,ih*(5/3)):ow/(5/3):(ow-iw)/2:(oh-ih)/2","setsar=1/1" -b:v 512k -c:v mpeg4 -c:a libfaac -ar 44100 -b:a 128k -ac 2 -y ${1}_GD510.mp4

DivX erzeugen

SD: 

> ffmpeg -benchmark -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts+igndts -i ALTERFILM.mpg -c:v mpeg4 -vtag DX50 -profile:v 15 -level 4 -b:v 3072k -g 300 -c:a ac3 -f avi -y NEUERFILM.avi

HD: 

> ffmpeg -benchmark -probesize 9223372036854M -analyzeduration 9223372036854M -fflags +genpts+igndts -i ALTERFILM.mpg -c:v mpeg4 -vtag DX50 -profile:v 15 -level 5 -b:v 8192k -g 300 -c:a libmp3lame -aq 2 -ac 2 -f avi -y NEUERFILM.avi

XviD erzeugen

> ffmpeg -i Film.mp4 -c:a libmp3lame -aq 2 -ac 2 -c:v libxvid -sameq -f avi -y test.avi

AVC erzeugen

> ffmpeg -i Film.mp4 -acodec libfaac -vcodec libx264 -vpre baseline -f matroska -y test.mkv

mehrere Filme zusammenfühgen

MPEG / MPEGTS (ts) / AVI

Das aneinander reihen (hintereinander zusammen fühgen) kann ffmpeg leider nur mit MPEG-, MPEGTS- (ts) und AVI-Dateien! 

> ffmpeg -i a.avi -i b.avi -i c.avi -i d.avi -c:v copy -c:a copy -c:v copy -c:a copy -c:v copy -c:a copy -c:v copy -c:a copy -f avi -y abcd.avi
> ffmpeg -fflags +genpts -i a.avi -i b.avi -i c.avi -i d.avi -c:v copy -c:a copy -c:v copy -c:a copy -c:v copy -c:a copy -c:v copy -c:a copy -f matroska -y abcd.mkv

https://openscript.ch/de/articles/videodateien-mit-ffmpeg-zusammenfuegen 

> ffmpeg -i "concat:a.avi|b.avi|c.avi|d.avi" -c:v copy -c:a copy -f avi -y abcd.avi

https://trac.ffmpeg.org/wiki/How%20to%20concatenate%20%28join,%20merge%29%20media%20files 

> ffmpeg -i "concat:a.avi|b.avi|c.avi|d.avi" -c copy -f avi -y abcd.avi

hat man zwei Filme mit H.264/AAC - Kodec, dann müssen diese Filme erst in den TS-Container überführt werden: 

> ffmpeg -i input1.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts intermediate1.ts
> ffmpeg -i input2.mp4 -c copy -bsf:v h264_mp4toannexb -f mpegts intermediate2.ts
> ffmpeg -i "concat:intermediate1.ts|intermediate2.ts" -c copy -bsf:a aac_adtstoasc -f mp4 output.mp4

MP4

siehe auch: MP4

MP4-Teile per Liste zusammen setzen: 

# echo "file 'teil_01_name.mp4'"  > Filmliste.txt
# echo "file 'teil_02_name.mp4'" >> Filmliste.txt
# echo "file 'teil_03_name.mp4'" >> Filmliste.txt
# echo "file 'teil_04_name.mp4'" >> Filmliste.txt
# ffmpeg -f concat -i Filmliste.txt -c:v copy -c:a copy -c:s copy -movflags faststart -f mp4 -y name.mp4

MKV

In allen anderen Fällen könnte man zum Beispiel mkvmerge von MKVToolnix zur Hilfe nehmen.

Für diesen Zweck müsste man die Filmteile jeweils einmal in den MKV-Container überführen.
Dann kann man ihn mit dem MKV-Tools prima zusammensetzen (siehe Abschnitt Filmteile zusammensetzen).

Neuerdings funktioniert auch die folgende Methode für Matroska.

MKV-Teile per Liste zusammen setzen: 

# echo "file 'teil_01_name.mkv'"  > Filmliste.txt
# echo "file 'teil_02_name.mkv'" >> Filmliste.txt
# echo "file 'teil_03_name.mkv'" >> Filmliste.txt
# echo "file 'teil_04_name.mkv'" >> Filmliste.txt
# ffmpeg -f concat -i Filmliste.txt -c:v copy -c:a copy -c:s copy -movflags faststart -f matroska -y name.mkv

CROPing durchführen

In diesem Beispiel werden links und oben jeweils ein 100 Bildpunkte breiter Streifen vom Bild entfernt: 

> ffmpeg -i Film.mp4 -acodec libfaac -vcodec libx264 -vf crop=in_w-100:in_h-100:100:100 -vpre baseline -f matroska -y test.mkv

-vf crop=width:height:x:y
width:height stellt die Bildgröße dar
x:y stellt die Position der linken oberen Ecke des Bildes dar

zum testen, ob man die richtigen CROP-Werte gewählt hat, eignet sich diese Zeile ganz gut: 

> ffmpeg -i Film.mp4 -map 0:v -c:v libx264 -vf yadif,crop=716:428:2:72,setsar='1/1' -map 0:a:0 -c:a libfdk_aac -ss 321 -t 4 -f matroska -y test.mkv

die 8. Tonspur aus einem Film extrahieren

In diesem Beispiel wird die achte Audio-Spur in einem CD-kompatiblen Format abgelegt: 

> ffmpeg -i Film.vob -vn -map 0:a:7 -acodec pcm_s16le -ar 44100 -ac 2 -y test.wav
-map 0:a:7      Verwende nur die achte Tonspur (Zählung beginnt mit "0") der ersten Eingangsdatei (Zählung beginnt mit "0")

nur bestimmte Tonspuren verwenden

In diesem Beispiel werden mit der Video-Spur (-map 0:v) nur die erste (-map 0:a:0) und zweite (-map 0:a:1) Audio-Spur transcodiert und als neue Filmdatei "test.mkv" abgelegt: 

> ffmpeg -i Film.vob -map 0:v -map 0:a:0 -map 0:a:1 -acodec libfaac -vcodec libx264 -vpre baseline -f matroska -y test.mkv
-map 0:v        Verwende von der ersten Eingangsdatei (Zählung beginnt mit "0") nur die Videospuren (Zählung beginnt mit "0")
-map 1:a:4      Verwende von der zweiten Eingangsdatei (Zählung beginnt mit "0") nur die fünfte Tonspur (Zählung beginnt mit "0")
-map 0:v -map 0:a:0 -map 0:a:1      Verwende von der ersten Eingangsdatei nur die Videospuren sowie die erste und zweite Tonspur

allgemeines

Only VP8 or VP9 or AV1 video and Vorbis or Opus audio and WebVTT subtitles are supported for WebM.

Audio- bzw. Video-Spur verzögern

Audio-Spur um 0,7 Sekunden verzögern: 

> ffmpeg -itsoffset 0.7 ...

Video-Spur um 0,4 Sekunden verzögern: 

> ffmpeg -itsoffset -0.4 ...

FFmpeg-Profile

FFmpeg-Profile

allgemeine Beispiele

Infos über einen Film auslesen: 

> ffmpeg -i Film.mpg
> ffmpeg -i <rein>

Film im "RAW YUV420P"-Format in eine Datei schreiben: 

> ffmpeg -i <rein> -o <raus>.yuv

aus der Video-Datei "a.yuv" mit der Auflösung "720x576" und der Audio-Datei "a.wav" den MPEG-Film "a.mpg" umwandeln: 

> ffmpeg -i a.wav -s 720x576 -i a.yuv a.mpg

Film im "RAW YUV420P"-Format an eine Pipe übergeben: 

> ffmpeg       -i <rein> -an -vcodec rawvideo -pix_fmt yuv420p -f matroska <raus>.mkv
> ffmpeg       -i <rein> -an -vcodec rawvideo -pix_fmt yuv420p -f rawvideo - | ...
> ffmpeg -r 25 -i <rein> -an -vcodec rawvideo -pix_fmt yuv420p -f rawvideo -v 0 -vsync 0 -r 25 - | ...
> ffmpeg -r 25 -i <rein> -an -vcodec rawvideo -pix_fmt yuv420p -f rawvideo -v 0 -vsync 0 -r 25 -s 720x320 -aspect 16:9 - | ...
> ffmpeg -r 25 -i <rein> -an -vcodec rawvideo -pix_fmt yuv420p -f rawvideo -v 0 -vsync 0 -r 25 -vf scale=720x320 - | ...
> ffmpeg -r 25 -i <rein> -an -vcodec rawvideo -pix_fmt yuv420p -f rawvideo -v 0 -vsync 0 -r 25 -vf scale=720x320,setdar=16:9 - | ...
> ffmpeg -r 25 -i <rein> -an -vcodec rawvideo -pix_fmt yuv420p -f rawvideo -v 0 -vsync 0 -r 25 -vf scale=720:576,crop=704:432:08:72,setdar=16:9 - | ...

Film im "YUV4MPEG"-Pipe-Format an eine Pipe übergeben (ohne Ton): 

> ffmpeg -i <rein> -an -f yuv4mpegpipe - | ...

Nur die erste Tonspur im WAVE-Format in eine Datei schreiben: 

> ffmpeg -i Beispiel.mpg -map 0.1:0.0 -async 0 -acodec pcm_s16le -vn -y Beispiel.wav
> ffmpeg -i Beispiel.mpg -map 0.1:0.0 -async 0 -c:a pcm_s16le -vn -y Beispiel.wav

alle 24 Bilder soll ein KeyFrame sein: 

> ffmpeg -i <rein> -g 24 <raus>.mkv

nur die zweite Tonspur verwenden, dafür muss man als erstes die IDs aller Spuren auslesen und danach das Mapping aller verwendeter Spuren angeben: 

> ffmpeg -i <rein>
...
    Stream #0.0(eng): Video: h264 (High), yuv420p, 720x576 [PAR 64:45 DAR 16:9], 24 fps, 24 tbr, 1k tbn, 48 tbc (default)
    Stream #0.1: Audio: aac, 48000 Hz, stereo, s16 (default)
    Stream #0.2: Audio: aac, 48000 Hz, stereo, s16 (default)
...
> ffmpeg -i <rein> -map 0.0:0.0 -map 0.2:0.1 <raus>.mkv

Formatauswahl absteigend angegeben (Formate für 48, 32, 24, 16 und 12 Bit): 

> ffmpeg -i <rein> -vf format=yuv444p16le:yuv422p16le:yuv444p:yuv422p:yuv420p <raus>.mkv

Untertitel in Filmen

ffmpeg Subtitle encoding currently only possible from text to text or bitmap to bitmap 

Input #0, mpeg, from 'Avengers_4_-_Endgame.mpg':
  Duration: 02:53:46.02, start: 0.287267, bitrate: 5848 kb/s
    Stream #0:0[0x1e0]: Video: mpeg2video (Main), yuv420p(tv, progressive), 720x576 [SAR 64:45 DAR 16:9], 8000 kb/s, 25 fps, 25 tbr, 90k tbn, 50 tbc
    Stream #0:1[0x80]: Audio: ac3, 48000 Hz, 5.1(side), fltp, 384 kb/s
    Stream #0:2[0x81]: Audio: ac3, 48000 Hz, 5.1(side), fltp, 384 kb/s
    Stream #0:3[0x21]: Subtitle: dvd_subtitle
    Stream #0:4[0x22]: Subtitle: dvd_subtitle
    Stream #0:5[0x23]: Subtitle: dvd_subtitle
    Stream #0:6[0x20]: Subtitle: dvd_subtitle
    Stream #0:7[0x25]: Subtitle: dvd_subtitle
    Stream #0:8[0x24]: Subtitle: dvd_subtitle
Stream mapping:
  Stream #0:0 -> #0:0 (mpeg2video (native) -> av1 (libaom-av1))
  Stream #0:2 -> #0:1 (ac3 (native) -> opus (libopus))
  Stream #0:3 -> #0:2 (dvd_subtitle (dvdsub) -> webvtt (native))
Subtitle encoding currently only possible from text to text or bitmap to bitmap

so konvertiert man einen Film in einen anderen Kontainer (nicht in jeden Kontainer ist das einfach): 

for Datei in *.mts; do ffmpeg -i "${Datei}" ${Datei%.mts}.mp4; done
ffmpeg -i 00001.mts 00001.mp4

muss man den Film noch bearbeiten, dann tut man das am besten in einem verlusstfreien Format tun (2. Videospur, 1. Tonspur, alle 4 Bilder ein Vollbild): 

> ffmpeg -i Beispiel.mpg -sameq -map 0.1:0.2 -async 0 -acodec pcm_s16le -map 0.0:0.0 -vsync 0 -g 4 -vcodec ffv1 -vf format=yuv444p16le:yuv422p16le:yuv444p:yuv422p:yuv420p -f matroska -y verlustfreies_zwischenformat.mkv

http://ubuntuforums.org/archive/index.php/t-1309647.html: 

> ffmpeg -i $input -deinterlace -r $fps -f rawvideo - | x264 -q $qp -f $db --sar $par -o $output - ${width}x$height --fps $fps
> ffmpeg -i $input -an -vcodec libx264 -crf $crf -vpre hq -threads 0 $output

Beispiel für das transkodieren einer Videospur ins BlueRay-Format: 

> ffmpeg -v 0 -i Beispiel.mpg -an -sameq -g 4 -vcodec rawvideo -s 864x486 -vf format=yuv420p -f yuv4mpegpipe -threads 1 - | x264 - --demuxer raw --input-res 864x486 --fps 25 --crf 23 --profile high --threads 1 --b-adapt 2 --direct auto --slow-firstpass --no-fast-pskip --me tesa --merange 24 --partitions all --rc-lookahead 60 --ref 5 --subme 10 --trellis 2 --nr 0 --weightp 0 --bframes 3 --nal-hrd vbr --vbv-maxrate 12500 --vbv-bufsize 12500 --level 3.0 --keyint 24 --min-keyint 2 --b-pyramid strict --slices 1 --aud --colorprim bt709 --transfer bt709 --colormatrix bt709 --sar 1:1 -o Beispiel_videospur.mkv
> ffmpeg -v 0 -i Beispiel.mpg -an -sameq -g 4 -vcodec rawvideo -pix_fmt yuv420p -s 864x486 -f yuv4mpegpipe -threads 1 - | x264 - --demuxer raw --input-res 864x486 --fps 25 --crf 23 --profile high --threads 1 --b-adapt 2 --direct auto --slow-firstpass --no-fast-pskip --me tesa --merange 24 --partitions all --rc-lookahead 60 --ref 5 --subme 10 --trellis 2 --nr 0 --weightp 0 --bframes 3 --nal-hrd vbr --vbv-maxrate 12500 --vbv-bufsize 12500 --level 3.0 --keyint 24 --min-keyint 2 --b-pyramid strict --slices 1 --aud --colorprim bt709 --transfer bt709 --colormatrix bt709 --sar 1:1 -o Beispiel_videospur.mkv

ein Stück aus dem Film rausschneiden

siehe auch: Film zuschneiden

hier werden 400 Sekunden ab der 60. Sekunde rauskopiert, mit der alten FFmpeg-Syntax und als MKV abgelegt: 

> ffmpeg -i film.mp4 -ss 60 -t 400 -acodec copy -vcodec copy -f matroska film.mkv

und hier mit der neuen avconv-Syntax für die Codec-Angabe: 

> ffmpeg -i film.mp4 -ss 60 -t 400 -c:a copy -c:v copy -f matroska film.mkv

Leider hängt die genaue Schnittposition von den vorhandenen I-Frames ab, die in einigen Filmen dichter beieinander liegen können, dann geht es recht gut. Oder sie können in manchen Filmen auch sehr große Abstände zueinander aufweisen, das spart ein wenig Speicherplatz aber der Suchlauf und der Schitt nach I-Frames ist dann sehr grob.

Will man den Schnitt etwas genauer positionieren können, dann geht es nur, wenn alles transcodiert wird: 

> ffmpeg -i film.avi -ss 60 -t 400 -c:v libx264 -crf 20 -c:a libfaac -q:a 160 -ar 44100 -f mp4 -y film.mp4

In diesem Fall wird das rausgeschnittene Stück, HTML5-kompatibel (AVC+AAC+MP4) transkodiert.

Will man den Film anschließend, beim vor- oder zurückspulen bzw. bei anschließenden Schnitt mit "copy", genauer positionieren können, dann muss man einen sehr kurzen Abstand zwischen den I-Frames angeben (in diesem Beispiel "-keyint_min 1-4" [Standard sind "25"]): 

> ffmpeg -i film.avi -ss 60 -t 400 -keyint_min 1-4 -c:v libx264 -crf 20 -c:a libfaac -q:a 160 -ar 44100 -f mp4 -y film.mp4

Audio und Video trennen

Manchmal ist es nötig die Audio- und Videospur getrennt zu bearbeiten.

Audiospur extrahieren

erste Tonspur aus dem Film extrahieren: 

> ffmpeg -i <rein> -vn <raus>.wav
  • -vn die Videospur wird nicht benötigt

hier werden von der ersten Tonspur ab der 1870. Sekunde 217 Sekunden im CD-kompatiblen WAVE-Format exportiert: 

> ffmpeg -i Film.mkv -vn -acodec pcm_s16le -ar 44100 -ac 2 -ss 1870 -t 217 -y Ton_217Sekunden.wav

nicht nur die erste Tonspur extrahieren

Nummern der einzelnen Tonspuren ermitteln: 

> ffmpeg -i <rein> 2>&1 | fgrep Stream
    Duration: 00:01:56.38, start: 0.287267, bitrate: 430530 kb/s
    Stream #0.0[0x1e0]: Video: mpeg2video (Main), yuv420p, 720x576 [PAR 64:45 DAR 16:9], 9800 kb/s, 25 fps, 25 tbr, 90k tbn, 50 tbc
    Stream #0.1[0x25]: Subtitle: dvdsub
    Stream #0.2[0x26]: Subtitle: dvdsub
    Stream #0.3[0x27]: Subtitle: dvdsub
    Stream #0.4[0x28]: Subtitle: dvdsub
    Stream #0.5[0x29]: Subtitle: dvdsub
    Stream #0.6[0x2a]: Subtitle: dvdsub
    Stream #0.7[0x2b]: Subtitle: dvdsub
    Stream #0.8[0x2c]: Subtitle: dvdsub
    Stream #0.9[0x2d]: Subtitle: dvdsub
    Stream #0.10[0x2e]: Subtitle: dvdsub
    Stream #0.11[0x2f]: Subtitle: dvdsub
    Stream #0.12[0x30]: Subtitle: dvdsub
    Stream #0.13[0x31]: Subtitle: dvdsub
    Stream #0.14[0x32]: Subtitle: dvdsub
    Stream #0.15[0x80]: Audio: ac3, 48000 Hz, 5.1, s16, 384 kb/s
    Stream #0.16[0x81]: Audio: ac3, 48000 Hz, 5.1, s16, 384 kb/s
    Stream #0.17[0x82]: Audio: ac3, 48000 Hz, 5.1, s16, 384 kb/s
    Stream #0.18[0x83]: Audio: ac3, 48000 Hz, stereo, s16, 192 kb/s
    Stream #0.19[0x84]: Audio: ac3, 48000 Hz, 5.1, s16, 384 kb/s

Hier sehen wir, dass die Tonspuren die Nummern von "0.15" bis "0.19" haben.

zweite Tonspur aus dem Film extrahieren: 

> ffmpeg -i <rein> -vn -map 0.16 <raus>.wav
...
Stream mapping:
  Stream #0.16 -> #0.0
...

dritte Tonspur aus dem Film extrahieren: 

> ffmpeg -i <rein> -vn -map 0.17 <raus>.wav
...
Stream mapping:
  Stream #0.17 -> #0.0
...

Tonspur transcodieren

Wie die Tonspur vom WAVE- in MP3-Format transcodiert wird, steht hier : von WAV zu MP3.

zum Beispiel so (nur stereo): 

> lame -q 0 -V 3 tonspur.wav tonspur.mp3

5.1 Kanäle erhalten und in ein 5.1 AAC (M4A) übertragen: 

> faac -I 5,6 -C 6 -q 160 -w -o tonspur.m4a tonspur.wav

Videospur extrahieren

> ffmpeg -i <rein> -an -vcodec copy film_stumm.mp4
  • -an ohne Ton
  • -vcodec copy die Videospur unverändert kopieren

Video und Audio wieder zu einem Film vereinen

einfach nur zusammen-muxen: 

> ffmpeg -i film_stumm.mp4 -i tonspur.mp4 -c:v copy -c:a copy -f mp4 film.mp4

mit Anpassung der Tonspur: 

> ffmpeg -i film_stumm.mp4 -i tonspur.mp3 -vcodec copy -async 10 -ab 128k film.mp4
  • -vcodec copy (Videospur nicht verändern, nur kopieren)
  • -async 10 (Da die Tonspur jetzt etwas länger ist, muss hier angepasst werden)
  • -ab 128k (Bitrate der Tonspur)

mit der Option -shortest wird der Film nur so groß, wie das kürzeste INPUT-Stück ist: 

> ffmpeg -i film_stumm.mp4 -i tonspur.mp4 -c:a copy -c:v copy -shortest -f mp4 film.mp4

eine Video-Spur mit mehrere Tonspuren zusammen-muxen: 

> ffmpeg -i Video.mp4 -i deutsch_Audio.flac -i englisch_Audio.flac -c:v copy -c:a copy -map 0:0 -map 1:0 -map 2:0 -metadata:s:a:0 language=ger -metadata:s:a:1 language=eng -f matroska -y Video_-_deutsch+englisch.mkv
# -i Video.mp4 -i deutsch_Audio.flac -i englisch_Audio.flac      - 1., 2. und 3. Datei
# -c:v copy                                                      - Video-Spuren kopieren
# -c:a copy                                                      - Audio-Spuren kopieren
# -map 0:0                                                       - aus der 1. Datei die erste Spur (Video)
# -map 1:0                                                       - aus der 2. Datei die erste Spur (Audio - Deutsch)
# -map 2:0                                                       - aus der 3. Datei die erste Spur (Audio - Englisch)
# -metadata:s:a:0 language=ger                                   - die 1. Audio-Spur ist Deutsch
# -metadata:s:a:1 language=eng                                   - die 2. Audio-Spur ist Englisch

zu einem Video eine weitere Tonspur hinzufügen: 

> ffmpeg -i Video_englisch.mp4 -i deutsch_Audio.flac -c:v copy -c:a copy -map 0:0 -map 1:0 -map 2:1 -metadata:s:a:0 language=ger -metadata:s:a:1 language=eng -f matroska -y Video_-_deutsch+englisch.mkv
# -i Video.mp4 -i deutsch_Audio.flac -i englisch_Audio.flac      - 1., 2. und 3. Datei
# -c:v copy                                                      - Video-Spuren kopieren
# -c:a copy                                                      - Audio-Spuren kopieren
# -map 0:0                                                       - aus der 1. Datei die erste Spur (Video)
# -map 1:0                                                       - aus der 2. Datei die erste Spur (Audio - Deutsch)
# -map 0:1                                                       - aus der 1. Datei die zweite Spur (Audio - Englisch)
# -metadata:s:a:0 language=ger                                   - die 1. Audio-Spur ist Deutsch
# -metadata:s:a:1 language=eng                                   - die 2. Audio-Spur ist Englisch

zu einem Video mit zwei Tonspuren, eine Untertitelspur hinzufügen: 

> ffmpeg -i Video_-_deutsch+englisch.mkv -i untertitel_-_englisch.srt -c:v copy -c:a copy -c:s copy -map 0:0 -map 0:1 -map 0:2 -map 1 -metadata:s:a:0 language=ger -metadata:s:a:1 language=eng -metadata:s:s:0 language=eng -f matroska -y Video_-_deutsch+englisch+untertitel.mkv
# -i Video_-_deutsch+englisch.mkv -i untertitel_-_englisch.srt   - 1. und 2. Datei
# -c:v copy                                                      - Video-Spuren kopieren
# -c:a copy                                                      - Audio-Spuren kopieren
# -c:s copy                                                      - Untertitel-Spuren kopieren
# -map 0:0                                                       - aus der 1. Datei die erste Spur (Video)
# -map 0:1                                                       - aus der 1. Datei die zweite Spur (Audio - Deutsch)
# -map 0:2                                                       - aus der 1. Datei die dritte Spur (Audio - Englisch)
# -map 1                                                         - aus der 2. Datei die Spur (Untertitel - Englisch)
# -metadata:s:a:0 language=ger                                   - die 1. Audio-Spur ist Deutsch
# -metadata:s:a:1 language=eng                                   - die 2. Audio-Spur ist Englisch
# -metadata:s:s:0 language=eng                                   - die 1. Untertitel-Spur ist Englisch

Film in den Matroska-Kontainer schreiben

> ffmpeg -i film.mpg -c:a copy -c:v copy -f matroska film.mkv
> ffmpeg -fflags +genpts -i film.mpg -acodec copy -vcodec copy -f matroska film.mkv

Film in den MP4-Kontainer schreiben

> ffmpeg -i film.mpg -c:a copy -c:v copy -f mp4 film.mp4

eine kleine Kurzanleitung

Target: DVD

Quelle-PAL.avi 

dargestellt in 720x576 => 1024x576 (16/9)

...
==========================================================================
Opening video decoder: [ffmpeg] FFmpeg's libavcodec codec family
libavcodec version 53.35.0 (external)
Mismatching header version 53.32.2
Selected video codec: [ffh264] vfm: ffmpeg (FFmpeg H.264)
==========================================================================
==========================================================================
Requested audio codec family [mpg123] (afm=mpg123) not available.
Enable it at compilation.
Opening audio decoder: [ffmpeg] FFmpeg/libavcodec audio decoders
AUDIO: 48000 Hz, 2 ch, floatle, 192.0 kbit/6.25% (ratio: 24000->384000)
Selected audio codec: [ffmp3float] afm: ffmpeg (FFmpeg MPEG layer-3 audio)
==========================================================================
...
ntsc-dvd

Zielformat: 720x480 (dargestellt in ⇒ 854x480) 

> ffmpeg -i Quelle-PAL.avi -target ntsc-dvd -y <raus>.mpeg
...
==========================================================================
Opening video decoder: [ffmpeg] FFmpeg's libavcodec codec family
libavcodec version 53.35.0 (external)
Mismatching header version 53.32.2
Selected video codec: [ffmpeg2] vfm: ffmpeg (FFmpeg MPEG-2)
==========================================================================
==========================================================================
Opening audio decoder: [ffmpeg] FFmpeg/libavcodec audio decoders
AUDIO: 48000 Hz, 2 ch, s16le, 448.0 kbit/29.17% (ratio: 56000->192000)
Selected audio codec: [ffac3] afm: ffmpeg (FFmpeg AC-3)
==========================================================================
...
pal-dvd

Zielformat: 720x576 (dargestellt in ⇒ 1024x576) 

> ffmpeg -i Quelle-PAL.avi -target pal-dvd -y <raus>.mpeg
...
==========================================================================
Opening video decoder: [ffmpeg] FFmpeg's libavcodec codec family
libavcodec version 53.35.0 (external)
Mismatching header version 53.32.2
Selected video codec: [ffmpeg2] vfm: ffmpeg (FFmpeg MPEG-2)
==========================================================================
==========================================================================
Opening audio decoder: [ffmpeg] FFmpeg/libavcodec audio decoders
AUDIO: 48000 Hz, 2 ch, s16le, 448.0 kbit/29.17% (ratio: 56000->192000)
Selected audio codec: [ffac3] afm: ffmpeg (FFmpeg AC-3)
==========================================================================
...
film-dvd

Zielformat: 720x480 (dargestellt in ⇒ 854x480) 

> ffmpeg -i Quelle-PAL.avi -target film-dvd -y <raus>.mpeg
...
==========================================================================
Opening video decoder: [ffmpeg] FFmpeg's libavcodec codec family
libavcodec version 53.35.0 (external)
Mismatching header version 53.32.2
Selected video codec: [ffmpeg2] vfm: ffmpeg (FFmpeg MPEG-2)
==========================================================================
==========================================================================
Opening audio decoder: [ffmpeg] FFmpeg/libavcodec audio decoders
AUDIO: 48000 Hz, 2 ch, s16le, 448.0 kbit/29.17% (ratio: 56000->192000)
Selected audio codec: [ffac3] afm: ffmpeg (FFmpeg AC-3)
==========================================================================
...
ein Skript um Filme ins DVD-Format zu transkodieren
#!/bin/bash

#------------------------------------------------------------------------------#
#
# Dieses Skript übersetzt einen Film, der als Parameter uebergeben wurde,
# in DVD-Format (MPEG-2).
#
# Ein Film mit folgenden Eigenschaften:
# - 725 MB gross
# - 1 Stunde Spieldauer
# - 720x576 Bildpunkte (PAL) im 16/9 - Format
# - H264 - Video-Codec, 1460.2 kbps, 24bpp  25.000 fps
# - MP3 - Audio-Codec, 192.0 kbit, 48000 Hz, 2 ch,
# dauert die Uebersetzung auf einem "Intel(R) Core(TM) i7 CPU 2.93GHz"
# ca. 12 Minuten.
# Das Ergebnis ist dann 2670 MB groß.
#
#------------------------------------------------------------------------------#

if [ -z "${1}" ] ; then
        echo "${0} Film.avi"
        exit 1
else
        ### Zielformat: 720x480 (dargestellt in => 854x480)
        #ffmpeg -i ${1} -target ntsc-dvd -y ${1}.mpeg

        ### Zielformat: 720x576 (dargestellt in => 1024x576)
        ffmpeg -i ${1} -target pal-dvd -y ${1}.mpeg

        ### Zielformat: 720x480 (dargestellt in => 854x480)
        #ffmpeg -i ${1} -target film-dvd -y ${1}.mpeg
fi

mpeg1/mp2/mpeg

> rm -f ffmpeg2pass-*.log
> ffmpeg -i <rein> -b 3000k -pass 1 -y <raus>.mpg
> ffmpeg -i <rein> -b 3000k -pass 2 -y <raus>.mpg
> rm -f ffmpeg2pass-*.log

mpeg2/mp2/mpeg

> rm -f ffmpeg2pass-*.log
> ffmpeg -i <rein> -b 3000k -vcodec mpeg2video -pass 1 -y <raus>.mpg
> ffmpeg -i <rein> -b 3000k -vcodec mpeg2video -pass 2 -y <raus>.mpg
> rm -f ffmpeg2pass-*.log

mpeg4/mp2 (ASP/DivX5)

> ffmpeg -i <rein> -vcodec mpeg4 -y <raus>.avi
> ffmpeg -i <rein> -vcodec mpeg4 -y <raus>.mkv

mpeg4/aac/mp4 (ASP/DivX5)

> ffmpeg -i <rein> -vcodec mpeg4 -y <raus>.mp4

mpeg4/mp3 (ASP/DivX5)

> ffmpeg -i <rein> -acodec libmp3lame -y <raus>.avi
> ffmpeg -i <rein> -acodec libmp3lame -y <raus>.mp4
> ffmpeg -i <rein> -acodec libmp3lame -y <raus>.mkv

mpeg4/mp2/avi (ASP/Xvid)

> ffmpeg -i <rein> -vcodec libxvid -y <raus>.avi

mpeg4/mp3/avi (ASP/Xvid)

> ffmpeg -i <rein> -vcodec libxvid -acodec libmp3lame -y <raus>.avi

mpeg4/mp2 (AVC)

Bei dem x264-Codec reicht der Parameter "-vcodec" nicht mehr aus (wie bei den oben genannten), hier muss noch ein "Preset" mit dem Parameter "-vpre" angegeben werden. 

> ffmpeg -i <rein> -vcodec libx264 -vpre max -y <raus>.avi
> ffmpeg -i <rein> -vcodec libx264 -vpre max -y <raus>.mkv

mpeg4/mp3 (AVC)

> ffmpeg -i <rein> -vcodec libx264 -vpre max -acodec libmp3lame -y <raus>.avi
> ffmpeg -i <rein> -vcodec libx264 -vpre max -acodec libmp3lame -y <raus>.mp4
> ffmpeg -i <rein> -vcodec libx264 -vpre max -acodec libmp3lame -y <raus>.mkv

mpeg4/aac/mkv (AVC)

> ffmpeg -i <rein> -vcodec libx264 -vpre max -acodec libfaac -y <raus>.mkv

mpeg4/aac/mp4 (AVC)

FreeBSD 9.2: 

> portmaster multimedia/ffmpeg
> ffmpeg -i <rein> -c:v libx264 -y <raus>.mp4

> ffmpeg -i <rein> -vcodec libx264 -c:a libfaac -y <raus>.mp4
> ffmpeg -i <rein> -vcodec libx264 -vpre max -c:a libfaac -y <raus>.mp4

Installation auf Ubuntu 12.04: 

> aptitude install libav-tools libavcodec-extra-53
> avconv -i <rein> -c:v libx264 -y <raus>.mp4

> avconv -i <rein> -c:v libx264 -c:a libvo_aacenc -y <raus>.mp4
> avconv -i <rein> -c:v libx264 -preset veryslow -c:a libvo_aacenc -y <raus>.mp4

Beispiele: 

# In Klammern steht die Anzahl von kodierten Bildern pro Sekunde,
# wie sie bei einem Beispeil kodiert wurden.
# Wenig kodierte Bilder pro Sekunde deuten auf eine längere Kodierzeit und
# eine bessere Bildqualitaet im kodierten Video hin.
# Zu beachten ist auch, dass die Bildqualitaet nicht besser als im Original
# werden kann!

# veryslow (30):
> avconv -i <rein> -c:v libx264 -preset veryslow -crf 25 -c:a libvo_aacenc -y <raus>.mp4

# medium (115):
> avconv -i <rein> -c:v libx264 -preset medium -crf 25 -c:a libvo_aacenc -y <raus>.mp4

# Standard (130):
> avconv -i <rein> -c:v libx264 -c:a libvo_aacenc -y <raus>.mp4

# fast (130):
> avconv -i <rein> -c:v libx264 -preset fast -crf 25 -c:a libvo_aacenc -y <raus>.mp4

# faster (170):
> avconv -i <rein> -c:v libx264 -preset faster -crf 25 -c:a libvo_aacenc -y <raus>.mp4

# veryfast (230):
> avconv -i <rein> -c:v libx264 -preset veryfast -crf 25 -c:a libvo_aacenc -y <raus>.mp4

# superfast (355):
> avconv -i <rein> -c:v libx264 -preset superfast -crf 25 -c:a libvo_aacenc -y <raus>.mp4

# ultrafast (420):
> avconv -i <rein> -c:v libx264 -preset ultrafast -crf 25 -c:a libvo_aacenc -y <raus>.mp4
#
### Test-Kommandos:
#
# Standard  (bester Kompromis):  avconv -i ${1} -c:v libx264 -c:a libvo_aacenc -y ${1}.mp4
# veryslow  (am kleinsten):  avconv -i ${1} -c:v libx264 -preset veryslow -crf 25 -c:a libvo_aacenc -y ${1}.mp4
# ultrafast (am schnellsten):  avconv -i ${1} -c:v libx264 -preset ultrafast -crf 25 -c:a libvo_aacenc -y ${1}.mp4
#
#
### Testergebnisse:

 Gr. in % | Orig.-Gr. |  neue Gr.  | preset    | Transkodierdauer         | transkod. FPS | subjektive Qualität
----------+-----------+------------+-----------+--------------------------+---------------+----------------------------
  100.0 % | 741668 kB |  741668 kB | Original  | ---                      |   ---         | 
   67.0 % | 741668 kB |  497268 kB | veryfast  | 06:35 Minuten (~07 Min.) | ~ 230         | schlechter als superfast
   71.3 % | 741668 kB |  529156 kB | veryslow  | 65:27 Minuten (~65 Min.) | ~  30         | wie Original
   72.2 % | 741668 kB |  535272 kB | faster    | 08:48 Minuten (~09 Min.) | ~ 170         | 
   73.7 % | 741668 kB |  546652 kB | medium    | 12:22 Minuten (~12 Min.) | ~ 120         | 
   74.7 % | 741668 kB |  554044 kB | fast      | 10:57 Minuten (~11 Min.) | ~ 130         | 
   90.6 % | 741668 kB |  671876 kB | superfast | 04:07 Minuten (~04 Min.) | ~ 355         | schlechter als ultrafast
   91.6 % | 741668 kB |  679264 kB | Standard  | 13:16 Minuten (~13 Min.) | ~ 130         | 
  149.3 % | 741668 kB | 1107644 kB | ultrafast | 03:16 Minuten (~03 Min.) | ~ 420         | fast wie Original

FFmpeg mit dem x264-Encoder

# ffmpeg -r 25 -i <rein> -v 0 -vcodec rawvideo -vsync 0 -an -r 25 -pix_fmt yuv420p -f rawvideo - | x264 --fps 25 --crf 16 -b 3 --vbv-maxrate 40000 --vbv-bufsize 30000 --level 4.1 --keyint 24 --b-pyramid --aud --colorprim bt709 --transfer bt709 --colormatrix bt709 --sar 1:1 -o <raus>.mkv - 720x576

Fehlermeldungen

Past duration 0.XXXXXX too large

stackoverflow - Antwort 47:
Die Fehlermeldung verschwindet, wenn anstelle der Ausgabe-Bildwiederholfrequenz die Bildwiederholfrequenz (FPS) für die Eingabe (Originalfilm) angegeben wird. Die Ausgabe-Bildwiederholfrequenz wird dann automatisch so gewählt, dass sie der, der Eingabe-Bildwiederholfrequenz entspricht.

Es muss die Option -framerate mit der richtigen Bildwiederholfrequenz vor dem Film angegeben werden! 

> ffprobe Originalfilm.mp4
...
Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p(tv, smpte170m/smpte170m/bt470m), 1680x1050 [SAR 1:1 DAR 8:5], 20313 kb/s, 59.64 fps, 59.94 tbr, 90k tbn, 120 tbc (default)
...

Allerdings hat bei mir die Option -framerate nicht funktioniert, deshalb musste ich -r verwenden. 

> ffmpeg -r 59.64 Originalfilm.mp4 -map 0:v -c:v libx264 -profile:v high -preset veryslow -tune film -crf 20 -map 0:a:0 -c:a libfdk_aac -b:a 160k -f mp4 -y Film.mp4
/home/http/wiki/data/attic/ffmpeg.1713700631.txt · Zuletzt geändert: von manfred