Cette page est une accmulation de notes prises avec le temps pour mes usages personnels, je vais l'étoffer avec le temps.

Table of Content

Vidéo

Capture avec Vokoscreen(-ng), en encapsulation mkv, audio flac, vidéo x264 qualitté 5 ou moins. mkv est forcé sous les versions récentes de vokoscreen, wp-recorder utilise aussi le mkv par défaut.

Sous X11/X.org on peut utiliser Vokoscreen-ng, sous wayland c'est plus compliqué, cela dépend du compositeur.

Sous Wayland:

Les bureaux KDE Plasma, LxQt, basés sur Qt, utiliser les outils intégrés.
Le bureau Gnome basé sur GTK et possédant son propre compositeur utiliser les outils intégrés.
Même dans les bureaux utilisant la bibliothèque wl-roots, cela dépend vraiment du compositeur utilisé, et cela concerne les compositeurs. wlroots-dlna-screencast, could be a solution, obs support screen capture too :
- labwc (XFCE, autres)
- Sway, a i3wm adaptation to Wayland.
- Hyprland, a tiling desktop environment), etc.

Capture avec wf-records avec wl-roots

wf-recorder permet d'enregistrer tout l'écran ou une zone. La zone est définie à l'aide à l'aid du paramètre --geometry

Par défaut, la destionation sera ~/Vidéos/recording.mkv

Par exemple, pour la position à l'écran (en pixels) de 611,368, avec une taille de 720×347 pixels :

wf-recoreder --geometry "611,368 720x347"

La ligne suivante permet de capturer une fenêtre dans un compositeur basés sur wl-roots (cela ne marche pas avec toutes les fenêtres)

wf-recorder --geometry "`xwininfo | awk '/geometry/{print $2}' | sed 's/+/ /' | sed 's/+/,/' | awk '{print $2,$1}'`"

Pour une région, il est possible d'utiliser slop (Arch/Deb: slop), pour sélectionner une région à la souris qui servira à l'enregistrement :

wf-recorder --geometry "`slop -f '%x,%y %wx%h'`"

Plus slimpe avec slurp qui utilise directement le même format, le -f file.mkv est optionnel, sinon il crée un fichier record.mkv dans le dossier courant (et demande si on veut l'écraser si il existe déjà).

wf-recorder -g "`slurp`" -f file.mkv

Ajout d'anotations lors du screencast

gromit-mpx (github) permet de dessiner en overtlay de l'écran, pour mettre en avant des choses essentielles. (AUR: gromit-mx).
key-mon (github) sur pypi permet de visualiser les touches clavier pressées lors de la capture vidéo (AUR: key-mon).

Capture audio via micro ou autre

Pour trouver le périphérique utiliser arecord d'alsa-utils par exemple dans ce cas, la sortie sera :

arecord -l
->  Sous-périphérique #0 : subdevice #0

Cela correspondra sous ffmpeg au hardware:0,0 c'est à dire ``hw:${subperiph},${subdevice}

ffmpeg -f alsa -t 10 -i hw:0,0 out.wav

Quand utilisé avant -i : limite les données lues, avant la sortie, arrête d'écrire au temps t (durée t)
Voir: https://ffmpeg.org/ffmpeg-utils.html#time-duration-syntax

Séparer en un fichier audio et un vidéo

file=VokoscreenNGxxxxxx
intermediaire=nom_intermediaire

# extraction de la vidéo
ffmpeg -i $file.mkv -vcodec copy -an $intermediaire.mp4
# extraire de l'audio :
ffmpeg -i $file.mkv -vn -acodec copy $intermediaire.flac

Normalisation de l'audio via Audacity

audacity $intermediaire.flac

normaliser:

Menu Effets → Volumet et compression → Normaliser

Débruiter

Menu Effets → Réduction du bruit et réparation → Réduction du Bruit.

Si possible faire une première passe en sélectionant une partie de bruit de fond blanc, puis une deuxième qui n'en sera que plus efficace.
Si besoin, vocoder

Menu Effets → Mixer différents effets (attention accélération/décélération/inversion facilement reversible.

sauvegarder en opus

Remixage

Il y a différentes options selon les codecs, mais le principe esst le même :

ffmpeg -i video_file -i audio_file -c:v ${codec_video} ${settings_codec_video} -acodec copy ${fichierfinale}.${ext}

Encodage dans différents formats

x264 (H.264)

Veryslow est beaucoup plus long, mais très efficace, si c'est une vidéo un peu longue, un encodage en double pass s'impose. Pour une vidéo courte de screencast, cela peut suffir:

ffmpeg -i $intermediaire.mp4 -i $intermédiare.opus  -c:v libx264 -preset veryslow -acodec copy  ${file}-final.mp4

VP9

ffmpeg -i $intermediaire.mp4 -i $intermédiare.opus  -c:v vp9 -threads 4 -row-mt 1 -acodec copy  $file.mp4

Plus rapide et plus compact

ffmpeg -i $intermediaire.mp4 -i $intermédiare.opus  -c:v vp9 -acodec copy  $file.mp4

x265

ffmpeg -i $intermediaire.mp4 -i $intermédiare.opus  -c:v libx265 -acodec copy  $file.mp4

AV1

AV1 (libsvt-avi1)

Paquet : Arch: svt-av1

ffmpeg -i "$src" -an -c:v libsvtav1 $3 $4 "$dst"

AV1 (Rav1e)

Paquet : Arch: rav1e

ffmpeg -i "$src" -c:a libopus -c:v librav1e -preset veryslow  "$dst"

AV1 (libaom-av1)

Paquet : Arch: aom

ffmpeg -i "$src" -c:a libopus -c:v libaom-av1 -preset veryslow  "$dst"

Av1an

Outil d'aide à la compression Av1an

Gif

Via ffmpeg:

ffmpeg -i $input -ss 00:33 -t 00:03 -s 480x272 extrait_video.gif

via ffmpeg mais meilleure sortie via Gisicle pour les couleurs, et mieux qu'Imagemagick

name=particle
ffmpeg -i ${name}.mp4 -filter:v "crop=200:200:0:0" -vsync 0 ${name}%3d.png

Via Gifsicle, meilleur choix

gifsicle --loopcount=forever --optimize --colors 4 *.gif >../${name}_gs.gif
# si colormap (lignes de type "0 255 0" ou bien "#00FF00")
gifsicle --loopcount=forever --optimize --colors 4 --use-colormap colormap *.gif >../${name}_gs2.gif

Via imagemagick, mais moins bon que gifsicle

ls ${name}*.png | while read file; do magick ${name} ${name//png}gif; done

Paramètres d'encodage intéressants

précision à la frame près

-c copy -avoid_negative_ts make_zero

Redimensionnage

-vf scale=960:540

Crop w;h;x;y and scale (/2 et -2 pour s'assurer d'un multiple de 2)

-vf 'crop=1080:1080:0:420,scale=iw*.5:-2'

Plus lent => plus compact ou si bitrate précisé, meilleure qualité -preset veryslow

Bite rate (bufsize pour qu'il s'adapte au débit, pas lié au reste)

-b:v 1000K -maxrate 1000K -bufsize 1M

Formats vectoriels

PDF

Crée un PDF multipage depuis plusieurs fichier SVG.

L'importation dans Inkscape des pages une par une peut être fastidieux, trouver une méthode pour automatiser.

Ouvrir la première page via Inkscape
Importer une par une les autres pages (en précisant ajouter comme nouvelle page)
Imprimer → Dans un fichier (PDF)

Il est ensuite possible d'optimiser encore le PDF à l'aide de Ghostscript (paquet ghostscript)

Le format PDFSETTIGNS, supporte screen (plus compact), epub, un peu moins, etc

input=file_in
ouput=file_out
gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/screen -dNOPAUSE -dQUIET -dBATCH -sOutputFile=${output}.pdf ${input}.pdf

Vecteurs animés

Voir le billet de mon ancien blog sur Lottie et Glaxnimate (à porter sur ce blog)

Formats bitmaps

connaître les dimensions et modes de couleurs utilisés par des images

Basé sur ImageMagick

magick identify *.png

Affichera une sortie du type :

buisson1_texture.png PNG 256x256 256x256+0+0 8-bit sRGB 81691B 0.000u 0:00.000
chenille.png PNG 512x118 512x118+0+0 8-bit sRGB 107489B 0.000u 0:00.000
fleursheet.png PNG 1024x128 1024x128+0+0 16-bit sRGB 169473B 0.000u 0:00.000
marche2sheet.png PNG 760x240 760x240+0+0 16-bit sRGB 333515B 0.000u 0:00.000

Pour convertir le tout vers du 8bits/couleurs. Crée un dossier 8bits, dans lequel sont copiés à l'identique tous les fichiers déjà en 8 bits et convertit tous les 16 bits en 8bits.

mkdir 8bits
magick identify *.png | awk '/16-bit/{print $1}' | while read file; do magick $file -depth 8 8bits/${file//.png}.png; done
magick identify *.png | awk '/8-bit/{print $1}' | while read file; do cp -a $file 8bits/; done

Comme il s'agît probablement d'une version pour la distribution (sans plus aucun traitement et que les originaux sont de toute façon gardés). il peut convenir de réduire leur taille avec pngquant et de remplacer ces versions pour la diffusion:

cd 8bits
pnquant --speed 1 --strip *.png
ls *-fs8.png | while read file; do  mv $file ${file//-fs8.png}.png; done

Pense bête encodage et conversion

I wrote here and update several transcoding methods I use