====== ffmpeg et avconv ======
<code bash>sudo apt-get install ffmpeg</code>
avconv était un fork de ffmpeg sous Ubuntu.

Liens directs vers builds Windows :
  * https://ffmpeg.zeranoe.com/builds/win32/static/ffmpeg-latest-win32-static.7z
  * https://ffmpeg.zeranoe.com/builds/win64/static/ffmpeg-latest-win64-static.7z
====== liste les formats disponibles en import/export ======
<code bash>ffmpeg -formats</code>
====== liste les encoders disponibles ======
<code bash>ffmpeg -encoders</code>
====== Encodage hardware avec carte nVidia ======
Sous Windows, vérifier que la build ffmpeg est fonctionnelle avec l'encodage hardware :
<code bash>ffmpeg -encoders | findstr /R /I /C:"nvidia"</code>
Linux :
<code bash>ffmpeg -encoders | grep -i nvidia</code>
Dans tous les cas, on doit avoir un retour du style :
<code bash> V..... h264_nvenc           NVIDIA NVENC H.264 encoder (codec h264)
 V..... nvenc                NVIDIA NVENC H.264 encoder (codec h264)
 V..... nvenc_h264           NVIDIA NVENC H.264 encoder (codec h264)
 V..... nvenc_hevc           NVIDIA NVENC hevc encoder (codec hevc)
 V..... hevc_nvenc           NVIDIA NVENC hevc encoder (codec hevc)</code>

On a donc bien les encoders nVidia, pour x264 et HEVC/h265.
Il ne reste plus qu'à modifier les commandes pour profiter de l'encodage hardware :
  * ''-c:v libx264'' sera remplacé par ''-c:v h264_nvenc'',
  * ''-c:v libx265'' sera lui remplacé par ''-c:v hevc_nvenc''.

Petite comparaison de durée, sur une base core i7 4790k GeForce 980, 16Go RAM, sur une vidéo mpeg2 (.ts) :
<code bash>ffmpeg -i test.ts -c:v h264_nvenc -crf 23 -acodec copy h264_nvenc.mp4
ffmpeg -i test.ts -c:v hevc_nvenc -crf 23 -acodec copy hevc_nvenc.mp4
ffmpeg -i test.ts -c:v libx264 -crf 23 -acodec copy libx264.mp4
ffmpeg -i test.ts -c:v libx265 -crf 23 -acodec copy libx265.mp4</code>
On se retrouve avec :
<code bash>h264_nvenc : 00:00:37.1873675 (37s),
hevc_nvenc : 00:01:28.3609427 (88s),
libx264 : 00:09:04.4235522 (544s, ~x15),
libx265 : 00:25:45.6305339 (1545s, ~x18).</code>

====== infos d'un fichier ======
<code bash>ffmpeg -i input.mp4 -hide_banner</code>
====== bitrate constant ======
**-minrate**, **-maxrate** and the bitrate **-b:v** sont obligatoires pour le bitrate constant.
<code bash>ffmpeg -i input.mp4 -c:v libvpx -minrate 1M -maxrate 1M -b:v 1M output.webm</code>
====== bitrate variable ======
  * **-qmin** : minimum quantization parameter (default 4)
  * **-qmax** : maximum quantization parameter (default 63)
  * **-b:v** : target bit rate setting. If not set, the encoder will choose ~1000 kBit/s as a default, but only when the -crf option is used.
  * **-crf** : overall quality setting. If not set, the encoder will do "normal" VBR, trying to reach the target bitrate in within the qmin/qmax bounds. If set, the encoder will use CQ mode, and the target bitrate will become the maximum allowed bitrate. The CRF value is 10 by default.
<code bash>ffmpeg -i input.mp4 -c:v libvpx -qmin 0 -qmax 50 -crf 10 -b:v 2M output.webm</code>
====== conserver la qualité ======
**qscale 0**
<code bash>ffmpeg -i input.mp4 -qscale 0 output.avi</code>
====== copier seulement un passage d'une vidéo ======
  * **-ss** starting time
  * **-t** durée
<code bash>ffmpeg -i input.avi -ss 00:15:30.00 -t 00:00:30.00 -c:v copy -c:a copy  ouput.avi</code>
====== rip dvd ======
Via : http://kaocode.fr/sauvegarder-ses-dvd-video-avec-ffmpeg/
==== h264 + aac ====
<code bash>ffmpeg -i concat:VTS_01_1.VOB\|VTS_01_2.VOB\|VTS_01_3.VOB -map 0:v -map 0:a -c:v libx264 -crf 18 -maxrate 4000k -vf yadif -c:a libfdk_aac -b:a 320k MonDVD.mkv</code>
==== h265 + aac ====
<code bash>ffmpeg -i concat:VTS_01_1.VOB\|VTS_01_2.VOB\|VTS_01_3.VOB -map 0:v -map 0:a -c:v libx265 -crf 18 -maxrate 4000k -vf yadif -c:a libfdk_aac -b:a 320k MonDVD-h265.mkv</code>
==== VP9 + OPUS ====
<code bash>ffmpeg -i concat:VTS_01_1.VOB\|VTS_01_2.VOB\|VTS_01_3.VOB -map 0:v -map 0:a -c:v libvpx-vp9 -threads 8 -crf 14 -vb 6M -vf yadif -acodec libopus -ab 256k MonDVD-VP9.mkv</code>
====== video rapide à partir d'une image et d'une piste audio ======
<code bash>ffmpeg -loop 1 -i img.jpg -i music.mp3 -shortest -c:v libx264 -c:a copy output.mp4</code>
Si on veut affiner un peu les pas de 'seek' (option -g : par défaut 250, diminuer pour augmenter la fréquence des pas, mais augmente la taille finale de la vidéo) :
<code bash>ffmpeg -loop 1 -i img.jpg -i music.mp3 -shortest -g 100 -c:v libx264 -c:a copy output.mp4</code>
====== accélérer / ralentir vidéo ======
Via : https://trac.ffmpeg.org/wiki/How%20to%20speed%20up%20/%20slow%20down%20a%20video
<code bash>ffmpeg -i input.mkv -filter:v "setpts=0.5*PTS" output.mkv</code>
The filter works by changing the presentation timestamp (PTS) of each video frame. For example, if there are two succesive frames shown at timestamps 1 and 2, and you want to speed up the video, those timestamps need to become 0.5 and 1, respectively. Thus, we have to multiply them by 0.5.

Note that this method will drop frames to achieve the desired speed. You can avoid dropped frames by specifying a higher output frame rate than the input. For example, to go from an input of 4 FPS to one that is sped up to 4x that (16 FPS):

<code bash>ffmpeg -i input.mkv -r 16 -filter:v "setpts=0.25*PTS" output.mkv</code>

To slow down your video, you have to use a multiplier greater than 1:

<code bash>ffmpeg -i input.mkv -filter:v "setpts=2.0*PTS" output.mkv</code>

Speeding up/slowing down audio

You can speed up or slow down audio with the ​atempo audio filter. To double the speed of audio:

<code bash>ffmpeg -i input.mkv -filter:a "atempo=2.0" -vn output.mkv</code>

The atempo filter is limited to using values between 0.5 and 2.0 (so it can slow it down to no less than half the original speed, and speed up to no more than double the input). If you need to, you can get around this limitation by stringing multiple atempo filters together. The following with quadruple the audio speed:

<code bash>ffmpeg -i input.mkv -filter:a "atempo=2.0,atempo=2.0" -vn output.mkv</code>

Using a complex filtergraph, you can speed up video and audio at the same time:

<code bash>ffmpeg -i input.mkv -filter_complex "[0:v]setpts=0.5*PTS[v];[0:a]atempo=2.0[a]" -map "[v]" -map "[a]" output.mkv</code>

====== convertir un FLAC en MP3 ======
<code bash>ffmpeg -i mon.flac -ab 192k mon.mp3</code>
Et en gardant les metadatas :
<code bash>ffmpeg -i mon.flac -ab 320k -map_metadata 0 -id3v2_version 3 mon.mp3</code>
====== extraire audio ======
<code bash>ffmpeg -i input.mp4 -vn -ac 2 -ar 44100 -ab 128k -f mp3 output.mp3</code>

====== convertir vidéo en GIF ======
Via : http://mwholt.blogspot.com/2014/08/convert-video-to-animated-gif-with.html
  * **-r** : fps du GIF
  * **-delay** : 100/x fps : 100/5 => 20 fps
<code bash>ffmpeg -i input.mp4 -r 20 -f image2pipe -vcodec ppm - | convert -delay 5 - gif:- | convert -layers Optimize - output.gif</code>
====== créer miniature d'une vidéo ======
Via : http://superuser.com/questions/538112/meaningful-thumbnails-for-a-video-using-ffmpeg
<code bash>ffmpeg -ss 3 -i input.mp4 -vf "select=gt(scene\,0.5)" -frames:v 5 -vsync vfr out%02d.jpg</code>
<code bash>ffmpeg -itsoffset -4 -i input.mp4 -vcodec png -vframes 1 -an -f rawvideo -s 120x90 -y output.png</code>
====== Extraire toute la vidéo en images ======
<code bash>ffmpeg -i input.mp4 -r 25 output_%04d.png</code>
====== Inverse : compiler une série d'images et les animer ======
<code bash>ffmpeg -r 60 -f image2 -s 1920x1080 -i pic%04d.png -vcodec libx264 -crf 25  -pix_fmt yuv420p output.mp4</code>
Avec :
  * ''-r'' : les FPS de la sortie,
  * ''-s'' : la résolution de sortie,
  * ''%04d'' : marge entre images, ici, 04 pour un compteur numérique à 4 chiffres en complétant avec des ''0'', donc de ''pic0001.png'' à ''pic WXYZ.pg''.
====== Ajouter un overlay ======
<code bash>ffmpeg -i input.mp4 -i image.png -filter_complex "[0:v][1:v] overlay=25:25:enable='between(t,0,20)'" -pix_fmt yuv420p -c:a copy output.mp4</code>

  * ''overlay=25:25'' : Position de l'overlay : l'origine 0:0 est le coin supérieur gauche, donc à 25px à droite et 25px vers le bas,
  * ''enable='between(t,0,20)''' : Afficher entre les secondes 0 et 20, donc pendant les 20 premières secondes de la vidéo,
  * ''[0:v][1:v]'' : Le premier fichier (ID:0) en entrée (''-i'') de type vidéo ('':v''), sur lequel on appose le seconde fichier (ID:1) toujours en entrée (''-i'') et encore aussi de type vidéo ('':v''),
  * ''-c:a copy'' : copier la piste audio sans réencoder.

====== sous-titres ======
Via : https://en.wikibooks.org/wiki/FFMPEG_An_Intermediate_Guide/subtitle_options
  * **-metadata:s:s:0** : that means to set the metadata for ... Stream:Subtitle:Number of stream, starting with 0
  * **language code** : eng,,fre ou fra,ger,ita,spa
Copie vidéo :
<code bash>ffmpeg -i input.mkv -sub_charenc CP1252 -i subtitle.srt -vcodec copy -acodec copy -scodec srt -metadata:s:s:0 language=fre output.mkv</code>
Réencoder vidéo :
<code bash>ffmpeg -i input.avi -sub_charenc ISO-8859-1 -i subtitle.srt -vcodec h264 -acodec ac3 -scodec srt -metadata:s:s:0 language=fre output2.mkv</code>
Insertion brute depuis fichier source identique (''.mkv'' contenant vidéo et sous-titres) :
<code bash>ffmpeg -i input.mkv -vf subtitles=input.mkv output.mp4</code>
Insertion brute depuis fichiers source distincts (vidéo ''.mp4'' et sous-titres externes en ''.srt'' par exemple) :
<code bash>ffmpeg -i input.mp4 -vf subtitles=input.srt output.mp4</code>
La même, mais en utilisant le second sous-titres d'un fichier ''.mkv'' :
<code bash>ffmpeg -i input.mkv -vf subtitles=input.mkv:si=1 output.mp4</code>
Forcer la police d'un sous-titre externe ''.srt'' :
<code bash>ffmpeg -i input.mp4 -vf subtitles=input.srt:force_style='FontName=DejaVu Serif,PrimaryColour=&HAA00FF00' output.mp4</code>
====== Scaling ======
Via : [[https://trac.ffmpeg.org/wiki/Scaling%20(resizing)%20with%20ffmpeg]]
Forcer une taille :
<code bash>ffmpeg -i input.avi -vf scale=320:240 output.avi</code>
Garder le ratio :
<code bash>ffmpeg -i input.avi -vf scale=320:-1 output.avi</code>
En fonction de la taille originale :
<code bash>ffmpeg -i input.avi -vf scale=iw*2:ih*2 output.avi</code>
Forcer à respecter la taille maximale tout en conservant ratio :
<code bash>ffmpeg -i input.avi -vf scale=w=320:h=240:force_original_aspect_ratio=decrease output.avi</code>
====== Mapper plusieurs pistes audio ======
<code bash>ffmpeg -i input.m2ts -map 0:0 -c:v libx265 -preset ultrafast -x265-params crf=23 -map 0:1 -c:a libopus -map 0:2 -c:a libopus -map 0:3 -c:a libopus -t 120 output.mkv</code>
====== Ajouter piste audio ======
<code bash>ffmpeg -i input.mp4 -i input.mp3 -c copy -map 0:0 -map 1:0 output.mp4</code>

====== Exemples MP4 x265 ======
=== x265 scale /  crf  / variable bitrate  ===
<code bash>ffmpeg -i input.mp4 -c:v libx265 -s 1280x720 -x265-params crf=30 -preset veryslow -c:a copy output.mkv</code>
=== 2pass / x265 / windows ===
<code bash>ffmpeg -i "input.avi" -vf pad=608:360:0:4:black -c:v libx265 -preset slow -b:v 250k -x265-params pass=1 -c:a libfdk_aac -vbr 4 -f mp4 NUL && ffmpeg -i "input.avi" -vf pad=608:360:0:4:black -c:v libx265 -preset slow -b:v 250k -x265-params pass=2 -c:a libfdk_aac -vbr 4 "output.mkv"</code>
=== gntm x265 crf ===
<code bash>ffmpeg -i "input.mp4"  -c:v libx265 -x265-params crf=27 -c:a libfdk_aac -profile:a aac_he -b:a 48k  "output.mp4"</code>
====== Exemples MP4 x264 ======
=== scaling forced x264 ===
<code bash>ffmpeg -i "input.avi" -c:v libx264 -preset veryslow -b:v 2000k -aspect 16:9 -vf scale=1280x720,pad=1280:720:0:0:black output.mp4</code>
=== 720p x264 crf ===
<code bash>ffmpeg -i "input.wmv" -c:v libx264 -preset slow -crf 28 -s 1280:720  -c:a libfdk_aac -profile:a aac_he_v2 -b:a 24k "output.mp4"</code>
=== 2pass x264 ===
<code bash>ffmpeg -i "input.mp4"  -c:v libx264 -b:v 10k  -pass 1 -c:a copy -f mp4 NUL && ffmpeg -i "input.mp4" -c:v libx264  -b:v 10k -pass 2 -c:a copy "output.mp4"</code>
=== slowing down flip rotate slow mo framerate 24fps ===
<code bash>ffmpeg -i "input.mp4" -c:v libx264 -filter:v "setpts=5.0*PTS" -filter:v "transpose=1" -r 24 -map 0:0 "output.mp4"</code>
=== slowing down flip rotate slow mo framerate 15fps ===
<code bash>ffmpeg -i "input.mp4" -c:v libx264 -filter:v "setpts=8.0*PTS" -filter:v "transpose=1" -r 15 -map 0:0 "output.mp4"</code>
=== trim trimming cutting to (from 60s to 180s) ===
<code bash>ffmpeg -i input.mp4 -ss 60 -to 180 -c:a copy -c:v copy output.mp4</code>
====== Exemples MP4 AAC ======
=== aac low bitrate 48k 64k v1 ===
<code bash>ffmpeg -i "input.mp4"  -c:v copy -c:a libfdk_aac -profile:a aac_he -b:a 48k  "output.mp4"</code>
=== aac low bitrate 32k v2 ===
<code bash>ffmpeg -i "input.mp4"  -c:v copy -c:a libfdk_aac -profile:a aac_he_v2 -b:a 32k  "output.mp4"</code>
=== aac vbr 4 ===
<code bash>ffmpeg "input.mp3" -c:a libfdk_aac -vbr 4   "output.m4a"</code>
====== Optimisations Web ======
Utiliser l'attribut "faststart" :
<code bash>ffmpeg -i input.mp4 -movflags faststart -acodec copy -vcodec copy output.mp4</code>
Avoir un ''x264'' (''libx264'') qui ne plante pas avec Firefox : forcer le format de pixel en ''yuv420p'' et pas en ''yuv444'' :
<code bash>ffmpeg -i input.mp4 -acodec copy -vcodec libx264 -pix_fmt yuv420p output.mp4</code>
====== Presets & Tune ======
Liste des presets (''-preset X'') disponibles en x264 :
  * ultrafast,
  * superfast,
  * veryfast,
  * faster,
  * fast,
  * medium,
  * slow,
  * slower,
  * veryslow,
  * placebo.
Liste des "tune" (''-tune X'') disponibles :
  * film,
  * animation,
  * grain,
  * stillimage,
  * psnr,ssim,
  * fastdecode,
  * zerolatency.
====== Paramètres basiques ======
  * **-i [fichier source]** – Nom et chemin du fichier source,
  * **-codec:v** – indique l'encodeur vidéo utilisé, pour nous c'est la librairie libvpx pour du webm VP8,
  * **-b:v [bitrate]** – indique le débit vidéo souhaité,
  * **-quality good** – indique la qualité de l'encodeur vidéo. les choix disponibles sont "best" / "good" / "realtime". (La choix "best" apporte un gain de qualité insignifiant),
  * **-cpu-used [0-5]** – indique la vitesse de l'encodeur vidéo. (Une valeur faible indique une bonne qualité),
  * **-r [25]** – indique à l'encodeur, le nombre d'image par seconde (fps) du fichier de sortie,
  * **-maxrate** – Indique la limite haute sur le flux vidéo à ne pas dépasser,
  * **-bufsize** – indique à l'encodeur le niveau auquel il est possible d'aller de façon ponctuel en terme de débit en cas de besoin. de façon générale le double du maxrate est utilisé afin de tenir sur 2 secondes,
  * **-qmin 10** -qmax 42 – Minimum et maximum des valeurs de quantification (un qmax bas entraine une qualité élevée),
  * **-threads [num]** – indique le nombre de fil d'exécution à utiliser. Indiquez le nombre de CPU disponibles,
  * **-vf scale=[width:height]** – Changer de résolution. (La valeur "-1" signifie "conserver le ratio", exemple: "-1:360" produira un fichier de 360p),
  * **-codec:a libvorbis** – indique à l'encodeur libvorbis de produire un fichier audio vorbis,
  * **-b:a [bitrate]** – Débit du flux audio,
  * **-f webm** – indique à FFmpeg le format de sortie (si l'extension webm est présente sur le fichier de sortie, ce paramètre devient inutile),
  * **-pass [1|2]** – indique à FFmpeg de faire du multiple passes et indique quelle passe est à traiter,
  * **-an** – désactive l'encodage audio, pour gagner du temps au premier à la première passe d'encodage.

====== webm VP8 ======
=== Forcer le téléchargement progressif : ===
http://sourceforge.net/projects/matroska/files/mkclean/
<code bash>mkclean --optimize --remux input.webm output.webm</code>
=== Erreur Type MIME pour serveur web : ===
<code bash>AddType video/webm .webm</code>
=== WEBM 1 passe: ===
<code bash>ffmpeg -i input.mp4 -c:a libvorbis -b:a 128k -c:v libvpx -quality good -cpu-used 0 -slices 4 -qmax 30 -threads 8 output.webm</code>
=== WEBM 1 passe avec resize max 1280x720 en gardant le ratio: ===
<code bash>ffmpeg -i input.mp4 -vf scale=w=1280:h=720:force_original_aspect_ratio=decrease -c:a libvorbis -b:a 128k -c:v libvpx -quality good -cpu-used 0 -slices 4 -qmax 30 -threads 8 output.webm</code>
=== WEBM 2 passes (Linux : "/dev/null" | Windows : "NUL"): ===
<code bash>ffmpeg -i input.mp4 -codec:v libvpx -quality good -cpu-used 0 -b:v 600k -qmin 10 -qmax 42 -maxrate 500k -bufsize 1000k -threads 2 -vf scale=-1:480 -an -pass 1 -f webm /dev/null
ffmpeg -i input.mp4 -codec:v libvpx -quality good -cpu-used 0 -b:v 600k -qmin 10 -qmax 42 -maxrate 500k -bufsize 1000k -threads 2 -vf scale=-1:480 -codec:a libvorbis -b:a 128k -pass 2 -f webm output.webm</code>
=== WEBM 2 passes: ===
<code bash>ffmpeg -i input.mp4 -c:v libvpx -quality good -cpu-used 0 -slices 4 -qmax 30 -threads 8 -an -f webm -pass 1 NUL
ffmpeg -i input.mp4 -c:a libvorbis -b:a 128k -c:v libvpx -quality good -cpu-used 0 -slices 4 -qmax 30 -threads 8 -pass 2 output.webm</code>

====== webm VP9 ======
=== VOD ===
<code bash>ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 1 -b:v 1000K -threads 8 -speed 4 -tile-columns 6 -frame-parallel 1 -an -f webm /dev/null
ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 2 -b:v 1000K -threads 8 -speed 1 -tile-columns 6 -frame-parallel 1 -auto-alt-ref 1 -lag-in-frames 25 -c:a libopus -b:a 64k -f webm output.webm</code>

=== Best Quality (Slowest) Recommended Settings ===
<code bash>ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 1 -b:v 1000K -threads 1 -speed 4 -tile-columns 0 -frame-parallel 0 -g 9999 -aq-mode 0 -an -f webm /dev/null
ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 2 -b:v 1000K -threads 1 -speed 0 -tile-columns 0 -frame-parallel 0 -auto-alt-ref 1 -lag-in-frames 25 -g 9999 -aq-mode 0 -c:a libopus -b:a 64k -f webm output.webm</code>

=== Constant Quality Recommended Settings ===
<code bash>ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 1 -b:v 0 -crf 33 -threads 8 -speed 4 -tile-columns 6 -frame-parallel 1 -an -f webm /dev/null
ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 2 -b:v 0 -crf 33 -threads 8 -speed 2 -tile-columns 6 -frame-parallel 1 -auto-alt-ref 1 -lag-in-frames 25 -c:a libopus -b:a 64k -f webm output.webm</code>

=== Recommandation Google (best quality) ===
<code bash>ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 1 -b:v 1000K -threads 1 -speed 4  -tile-columns 0 -frame-parallel 0 -auto-alt-ref 1 -lag-in-frames 25 -g 9999 -aq-mode 0 -an -f webm /dev/null
ffmpeg -i input.mp4 -c:v libvpx-vp9 -pass 2 -b:v 1000K -threads 1 -speed 0  -tile-columns 0 -frame-parallel 0 -auto-alt-ref 1 -lag-in-frames 25 -g 9999 -aq-mode 0 -c:a libopus -b:a 64k -f webm out.webm</code>
=== Sources ===
  * [[http://wiki.webmproject.org/ffmpeg/vp9-encoding-guide|Webm Project]],
  * [[https://trac.ffmpeg.org/wiki/Encode/VP9|ffmpeg VP9]].
====== Représentation "Waveform" d'un fichier audio ======
Via : [[https://trac.ffmpeg.org/wiki/Waveform]]
<code bash>ffmpeg -i input.mp3 -filter_complex "[0:a]showwaves=s=1280x720:mode=line,format=yuv420p[v]" -map "[v]" -map 0:a -c:v libx264 -c:a copy output.mkv</code>
====== Stabiliser une vidéo ======
Il nous faudra une build ''ffmpeg'' prennant en charge le module ''libvidstab''. Si le module n'est pas disponible par défaut, on pourra télécharger ici des builds qui l'ont compilé : [[https://www.johnvansickle.com/ffmpeg/]].
\\
\\
Enfin, on pourra tester soit en 1 passe avec :
<code bash>
ffmpeg -i input.mp4 -vf vidstabtransform,unsharp=5:5:0.8:3:3:0.4 output.mp4</code>
Ou en 2 passes :
<code bash>
ffmpeg -i input.mp4 -vf vidstabdetect -f null -
ffmpeg -i input.mp4 -vf vidstabtransform=input="transforms.trf" output.mp4
</code>
2 autres exemples, en commencant par une vidéo moyennement stable : 
<code bash>ffmpeg -i input.mp4 -vf vidstabdetect=shakiness=5:accuracy=7:show=1 output.mp4
ffmpeg -i input.mp4 -vf vidstabtransform=smoothing=15:zoom=1:input="transforms.trf" output.mp4</code>
Et avec une vidéo très instable :
<code bash>ffmpeg -i input.mp4 -vf vidstabdetect=shakiness=10:accuracy=15:result="mytransforms.trf"
ffmpeg -i input.mp4 -vf vidstabtransform=smoothing=30:zoom=1:input="transforms.trf" output.mp4</code>
Et les définitions des options, en reprenant ce qui est dit sur la source [[https://hiob.fr/ffmpeg-vidstab/]] :
  * Vidstabdetect (pass 1/2) :
      * ''shakiness'' : le degré de tremblement de la vidéo et la rapidité de la caméra. Il accepte un nombre entier compris entre 1 et 10, une valeur de 1 signifie peu de tremblements, une valeur de 10 signifie un fort tremblement. La valeur par défaut est 5.
      * ''accuracy'' : la précision du processus de détection. Ce doit être une valeur comprise entre 1 et 15. Une valeur de 1 signifie une faible précision, une valeur de 15 signifie une précision élevée. La valeur par défaut est 15.
  * Vidstabtransform (pass 2/2)
      * ''smoothing'' : le nombre d'images (valeur * 2 + 1) utilisées pour le filtrage lowpass des mouvements de la caméra. La valeur par défaut est 10. Un nombre de 10 signifie que 21 images sont utilisées (10 dans le passé et 10 dans le futur) pour lisser le mouvement dans la vidéo. Une valeur plus élevée conduit à une vidéo plus fluide, mais limite l'accélération de la caméra (mouvements de panoramique / inclinaison). 0 est un cas spécial où une caméra statique est simulée.
      * ''crop'' : le rognage des bordures a appliqué selon la compensation des mouvements. Les valeurs disponibles sont keep pour conserver les informations de l'image précédente (par défaut) et black remplir la bordure de noir.
      * ''zoom'' : le pourcentage à zoomer. Une valeur positive entraînera un effet de zoom, une valeur négative un effet de zoom arrière. La valeur par défaut est 0 (pas de zoom).
====== Streaming LAN via ffmpeg ======
Source : [[https://wiki.labomedia.org/index.php/LAN_Streaming_avec_ffmpeg]]
====== DNxHD (aka AVID) ======
Via : [[http://hd3g.tv/b/2011/08/transcoder-des-fichiers-videos-avec-ffmpeg-en-dnxhd/]],\\
Doc codec : [[http://www.avid.com/fr/products/Avid-DNxHR-and-DNxHD]].
<code  bash>ffmpeg -i input.mov -vcodec dnxhd -b <bitrate> -acodec pcm_s16le -f mov output.mov</code>
Exemples de bitrates disponibles et compatibles pour ''DNxHD'' :
  * 1080p/25fps et 1080i/50fps : ''36M'', ''120M'', et ''185M''.
  * 1080p/24fps : ''36M'', ''115M'', et ''175M''.
  * 1080p/29,97fps et 1080i/59,9fps4 : ''36M'', ''145M'', et ''220M''.
===== Bonus : normalisation du son ======
Normaliser le son avec ffmpeg-normalize (Via [[https://lepouf.info/normaliser-le-son-avec-ffmpeg-normalize/]]) :\\
On installe les dépendances, puis le paquet voulu (''ffmpeg-normalize'') :
<code bash>apt-get install python python-pip ffmpeg
pip install ffmpeg-normalize</code>
Exemples d’utilisation de ''ffmpeg-normalize'' :\\
Normalisation de volume :
<code bash>ffmpeg-normalize -vu input.mp4</code>
Normalisation de crête :
<code bash>ffmpeg-normalize -vum input.mp4</code>
Normalisation de crête à un volume spécifique (ici -10db) :
<code bash>ffmpeg-normalize -vum -l -10 input.mp4</code>
Normalisation de volume, avec codec et bitrate spécifique (les codecs disponibles sont ceux disponibles par ''ffmpeg'') :
<code bash>ffmpeg-normalize -vu -a libvorbis -e "-b:a 192k" input.mp4</code>
Source de ''ffmpeg-normalize'' : [[https://github.com/slhck/ffmpeg-normalize]]

===== Bonus 2 : faire du reverse =====
Ou comment inverser le sens de lecture vidéo/audio.\\
Ici, les commandes simples pour inverser le sens, ne pas oublier d'y rajouter les options d'encodage voulues.\\
\\
Pour inverser la vidéo (''-vf reverse'') :
<code bash>ffmpeg -i input.mp4 -vf reverse output.mp4</code>
Pour inverser l'audio (''-af areverse'') :
<code bash>ffmpeg -i input.mp4 -af areverse output.mp4</code>
Et pour les 2 en même temps (''-vf reverse'' + ''-af areverse'') :
<code bash>ffmpeg -i input.mp4 -vf reverse -af areverse output.mp4</code>
===== Pages Supplémentaires =====
<catlist -noHead -noLinkStartHead >
====== webm sources ======
  * https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/
  * https://trac.ffmpeg.org/wiki/Encode/VP8
  * http://www.webmproject.org/docs/encoder-parameters/
  * http://wiki.webmproject.org/ffmpeg
  * https://doc.ubuntu-fr.org/webm

====== A ajouter ======
https://www.ostechnix.com/20-ffmpeg-commands-beginners/