Nous allons dans ce billet voir comment effectuer ce transcodage dans trois formats “standard” (industriellement parlant…):

• MP4 avec codec vidéo H.264 et codec audio AAC
• OGG avec codec vidéo Theora et codec audio Vorbis
• WEBM avec codec vidéo VP8 et codec audio Vorbis

Installation des plugins GStreamer

L’installation standard de GStreamer n’inclue pas la prise en charge de tout les codecs vidéos et audios. Afin de remédier à ça, je vous conseille d’installer “la totale” avec les commandes suivantes:

wget http://svn.nicolargo.com/ubuntupostinstall/trunk/gstreamerinstall.sh

chmod a+x ./gstreamerinstall.sh

sudo ./gstreamerinstall.sh

rm ./gstreamerinstall

Ces commandes vont récupérer un script maison qui va installer le PPA de l’équipe de développement de GStreamer, puis installer les paquets GStreamer.

Un peu de pipeline

Je donnerai en fin d’article un lien vers trois scripts shell qui vont automatiser les phases de transcodage. Cependant, nous allons dans ce paragraphe voir comment faire un transcodage à la main en utilisant la commande gst-launch.

Pour illustrer notre exemple, prenons une vidéo au format .MOV (H.264 + AAC) que l’on soughaite convertir dans un format plus “libre”, c’est à dire WEBM (VP8 + VORBIS). La pipeline (ligne de commande) correspondante est la suivante:

gst-launch -t filesrc location=source.mov ! progressreport ! decodebin name=decoder \

decoder. ! queue ! audioconvert ! vorbisenc ! queue ! \

webmmux name=muxer \

decoder. ! queue ! ffmpegcolorspace ! vp8enc ! queue ! \

muxer. muxer. ! queue ! filesink location=destination.webm

La première ligne (filesrc location=source.mov ! progressreport ! decodebin name=decoder \) permet de charger le fichier source au format .MOV et de décoder les pistes audio et vidéo.

La seconde ligne (decoder. ! queue ! audioconvert ! vorbisenc ! queue ! \) prend la piste audio du fichier source et la transcode au format VORBIS.

La troisième ligne (webmmux name=muxer \) précise que l’on utilisera un conteneur multimédia de destination de type Webm.

La quatrième ligne (decoder. ! queue ! ffmpegcolorspace ! vp8enc ! queue ! \) prend la piste vidéo du fichier source et la transcode au format VP8.

Enfin la dernière ligne (muxer. muxer. ! queue ! filesink location=destination.webm) prend les pistes audio et vidéo transcodées puis génère le fichier destination au format .WEBM.

Des scripts ! Des scripts !

“C’est bien beau la théorie mais moi je veux juste faire rapidement un transcodage…”…

Ok Michel, voici trois script shell permettant de faire un transcodage de n’importe quel type de vidéo vers un des formats suivants:

• Script mp4encoder.sh pour transcoder en MP4 avec codec vidéo H.264 et codec audio AAC
• Script oggencoder.sh pour transcoder en OGG avec codec vidéo Theora et codec audio Vorbis
• Script webmencoder.sh pour transcoder en WEBM avec codec vidéo VP8 et codec audio Vorbis

Pour les utiliser, il faut dans un premier temps les rendre executable avec la commande:

chmod a+x *encoder.sh

L’utilisation est des plus simple. Exemple de transcodage en MP4:

./mp4encoder.sh Inception-1080p.mov

Exemple de transcodage en OGG:

./oggencoder.sh Inception-1080p.mov

Exemple de transcodage en WEBM:

./webmencoder.sh Inception-1080p.mov

Et si je veux modifier les paramètres de transcodage ?

Ben c’est possible Miche, Nicolargo a pensé à toi. Il suffit d’éditer le script puis de mettre les paramètres dans la variable AUDIO_ENCODER_PARAMETERS pour le codec audio et VIDEO_ENCODER_PARAMETERS pour le codec vidéo.

Par exemple pour modifier le script webmencoder.sh afin d’encoder avec une qualité vidéo supérieure, il faut éditer le fichier et modifier la ligne suivante:

VIDEO_ENCODER_PARAMETERS="quality=7 speed=2"

Pour avoir la liste des paramètres pour un codec (par exemple pour l’encodeur VP8 ; vp8enc), il faut saisir la commande suivante:

gst-inspect vp8enc

Conclusion

C’est à vous de jouer pour intégrer ces scripts dans vos processus d’automatisation de transcodage de vidéo/audio !

Affichage des touches / clicks souris

Suite à un message de Sylvain, je viens d’ajouter une nouvelle option permettant d’afficher sur l’écran les touches cliqués (clavier et souris) lors du screencast. J’utilise pour cela le logiciel libre key-mon (licence Apache v2).

Comme il n’est pas encore disponible via un PPA, il faut installer le logiciel (version 1.2.2 au moment de l’écriture de ce billet) à la mimine:

wget -q http://key-mon.googlecode.com/files/keymon_1.2.2_all.deb

sudo dpkg -i keymon_1.2.2_all.deb

rm keymon_1.2.2_all.deb

Support de WebM

J’ai modifier le script pour qu’il demande à la fin de la capture le format dans lequel le screencast doit être compressé, les formats disponibles sont les suivants:

• H.264 (codec vidéo X.264 et audio AAC)
• OGV (codec vidéo Théora et audio Vorbis)
• WebM (codec vidéo VP8 et audio Vorbis)

Comment tester ces nouvelles fonctions ?

Il faut récupérer la dernière version du script:

MyScreencast

version 0.9

Puis de lancer la ligne de commande suivante:

chmod a+x ./myscreencast.sh
./myscreencast.sh -k -w

PS1: le flag -k permet de lancer le logiciel key-mon

PS2: le flag -w permet, si vous avez une webcam d’afficher votre tête dans une fenêtre…

Je suis toujours preneur de pistes d’amèliorations sur ce script !

Bon screencast à vous !

On télécharge, le script, puis on le lance:

wget http://svn.nicolargo.com/ubuntupostinstall/trunk/gstreamerinstall.sh

chmod a+x ./gstreamerinstall.sh

sudo ./gstreamerinstall.sh

rm ./gstreamerinstall

Vous devriez vous retrouver avec environ 230 plugins dont les fameux webmmux et vp8enc pour encoder vos vidéo au format WebM

WebM, c’est quoi donc ?

En fait WebM est un conteneur multimédia, une enveloppe au même titre que OGG, MP4  ou AVI. Quand on parle de fichiers au “format WebM”, cela sous entant l’utilisation des codecs audio Vorbis et vidéo VP8 (racheté il y a quelques mois par Google à la societé On2).

Avant de tester l’encodage d’un fichier WebM sur votre distribution GNU/Linux. Sous Ubuntu, il faut d’abord vérifier que vous disposez de la dernière version PPA de GStreamer:

sudo add-apt-repository ppa:gstreamer-developers

sudo aptitude update

sudo aptitude upgrade

sudo aptitude install gstreamer0.10-x gstreamer-tools gstreamer0.10-plugins-base gstreamer0.10-plugins-good gstreamer0.10-plugins-bad gstreamer0.10-plugins-bad-multiverse gstreamer0.10-plugins-ugly gstreamer0.10-plugins-ugly-multiverse gstreamer0.10-ffmpeg gstreamer0.10-alsa gstreamer0.10-sdl

Enfin on vérifie que l’on a les bons plugins:

# gst-inspect | grep webmmux
matroska:  webmmux: WebM muxer

# gst-inspect | grep vp8enc
vp8:  vp8enc: On2 VP8 Encoder

gst-inspect | grep vorbisenc
vorbis:  vorbisenc: Vorbis audio encoder

Passons maintenant aux choses sérieurses…

Encodage au format WebM

Pour mes test j’ai utilisé une bande annonce du film “Prince of persia” en qualité HD 1080p récupérée sur le site HDTrailers.

J’utilise ensuite la pipeline (ligne de commande) suivante pour effectuer l’encodage:

gst-launch -t filesrc location=pp_rltA_1080.mov ! progressreport \
! decodebin name=decoder  decoder. \
! queue ! audioconvert ! vorbisenc quality=0.5 \
! queue !  webmmux name=muxer  decoder. \
! queue ! ffmpegcolorspace ! vp8enc quality=5 speed=2 \
! queue !  muxer. muxer. ! queue ! filesink location=pp_rltA_1080-Q5.webm

La qualité vidéo par défaut (option quality=5) n’est pas terrible, on obtient de meilleurs résultats en l’augmentent. Voici un tableau comparatif:

Format	Codecs	Taille	Aperçu (clique pour agrandir)
Source HQ .mov	Audio: AAC 48 Khz Video: H.264	126 Mo
WebM	Audio: Vorbis Video: VP8 “Quality 5″	24 Mo
WebM	Audio: Vorbis Video: VP8 “Quality 6″	30 Mo
WebM	Audio: Vorbis Video: VP8 “Quality 7″	40 Mo
WebM	Audio: Vorbis Video: VP8 “Quality 8″	61 Mo
WebM	Audio: Vorbis Video: VP8 “Quality 9″	73 Mo
WebM	Audio: Vorbis Video: VP8 “Quality 10″	92 Mo

Je trouve que la paramètre quality=7 est un bon compromis taille/qualité. Il faut noter que la source est d’un  qualité nettement supérieure (je ne connais pas les paramètre H.264 utilisés).

Comparaison avec les codecs Theora et H.264

Pour compléter ce petit test de WebM, nous allons comparer maintenant le résultat obtenu avec le paramètre quality=7 et les codecs Theora (avec une qualité égale à 7) et X.264 (avec une qualité de 23 équivalente).

Voici les lignes de commandes utilisées, pour l’encodage en WebM (VP8/Vorbis):

gst-launch -t filesrc location=pp_rltA_1080.mov ! progressreport \
! decodebin name=decoder  decoder. \
! queue ! audioconvert ! vorbisenc quality=0.5 \
! queue !  webmmux name=muxer  decoder. \
! queue ! ffmpegcolorspace ! vp8enc quality=7 speed=2 \
! queue !  muxer. muxer. ! queue ! filesink location=pp_rltA_1080-Q7.webm

puis en OGG (Theora/Vorbis):

ffmpeg2theora  -v 7 --optimize pp_rltA_1080.mov -o pp_rltA-1080-Q7.ogg

et enfin en MP4 (X.264/FAAC):

x264 --tune animation --crf 23 -o pp_rltA-1080-Q7.mp4 pp_rltA_1080.mov

On obtient les résultats suivants:

Format	Codecs	Taille	Aperçu (clique pour agrandir)
WebM	Audio: Vorbis Video: VP8 “Quality 7″	40 Mo
OGG	Audio: Vorbis Video: Theora “-v 7″	57 Mo
MP4	Audio: AAC Video: X.264 “CRF 23″	56 Mo

Que peut on en déduire ? Niveau qualité, le format H.264 garde une longueur d’avance (mais pour combien de temps). Theora est en dessous. Par contre le taux de compression est bien meilleur avec le codec VP8 mais encore faut il être sur que l’on peut comparer les paramètres utilisés…

A vous de vous faire une idée !

Conclusion

Bien que “jeune” ce format de fichier semble avoir un bel avenir. Surtout si Google arrive à l’imposer comme un “standard industriel” (sic). Avec des leviers comme YouTube et Google Chrome, j’ai peu de doute sur le résultat des courses qui ne se fera pas sur un plan technique mais sur la capacité de chacun de défendre son format.

Ce billet est donc un appel à la communauté pour développer CE logiciel en question !

Nous allons dans un premier temps donner les bases techniques permettant de faire un screencast à partir du framework GStreamer (fourni en standard sous Linux). Puis donner dans les grandes largeurs les spécifications DU logiciel.

On commence par la fin: le résultat

Voici le screencast obtenu (format libre OGV – Theora/Vorbis – hébergé sur blip.tv): si votre navigateur est compatible…

Sinon vous pouvez toujours consulter la vidéo en ligne sur Blip.tv ou sur Vimeo (codec H.264/AAC)

Les fichiers générés sont au format HD 720p et ont une taille d’environ 11 Mo pour le format M4V et 13 Mo pour le format OGV.

Screencast avec GStreamer en ligne de commande

On commence par vérifier que l’on dispose bien du plugin gstreamer istximagesrc:

gst-inspect istximagesrc
...
version 0.2.2
...

Si ce n’est pas le cas, il suffit d’installer le package Istanbul qui inclue ce plugin:

sudo aptitude install istanbul

Aller, une fois ces menus préparatifs passés,  on commence par lancer un capture vidéo de l’écran et sonore en utilisant la ligne de commande GStreamer (pipeline) suivante:

gst-launch avimux name=mux ! filesink location=screencast.avi \
 alsasink ! audioconvert ! queue ! mux. \
 istximagesrc name=videosource use-damage=false ! video/x-raw-rgb,framerate=10/1 \
 ! ffmpegcolorspace ! queue ! videorate ! ffmpegcolorspace ! videoscale method=1 \
 ! video/x-raw-yuv,width=1152,height=720,framerate=10/1 ! mux.

Cette commande va capturer l’écran à 10 images par secondes (istximagesrc), le son (alsasink) et mixer le tout (sans compression mais avec une redimensionnement de la vidéo au format 720p) dans un fichier temporaire au format AVI. Ce fichier aura une taille très importante mais c’est juste une étape temporaire avant la compression.

Pour cette compression j’utilise deux pipelines permettant de générer des screencasts au format libre OGV (Theora/Vorbis) et propriétaire M4V (H.264/AAC), comme cela, tous les navigateurs sont heureux:

gst-launch filesrc location=screencast.avi ! decodebin name="decode" \
 decode. ! videoparse format=1 width=1152 height=720 framerate=10/1 \
 ! queue ! ffmpegcolorspace ! theoraenc ! queue ! \
 oggmux name=mux ! filesink location=screencast.ogv \
 decode. ! queue ! audioconvert ! vorbisenc ! queue ! mux.

 gst-launch filesrc location=screencast.avi ! decodebin name="decode" \
 decode. ! videoparse format=1 width=1152 height=720 framerate=10/1 \
 ! queue ! ffmpegcolorspace ! x264enc pass=4 quantizer=23 threads=0 ! queue ! \
 ffmux_mp4 name=mux ! filesink location=screencast.m4v \
 decode. ! queue ! audioconvert ! faac tns=true ! queue ! mux.

Un script qui fait tout…

Comme je suis un bon loulou, voici un script shell qui automatise

1. le lancement de votre Webcam pour avoir une incrustation de votre image dans le screencast
2. le lancement de la capture video de l’écran + capture audio (après un délais de 3 secondes histoire de refaire son nœud de cravate)
3. (on arrête la capture en faisant un CTRL-C dans la fenêtre)
4. la compression du screencast dans un fichier screencast-dateetheure.ogv (codec Theora/Vorbis)
5. la compression du screencast dans un fichier screencast-dateetheure.m4v (codec H.264/AAC)
6. la suppression du fichier temporaire

A télécharger ici: http://svn.nicolargo.com/myscreencast/trunk/myscreencast.sh

Vous pouvez éditer le fichier et notamment la configuration suivante:

### Variables à ajuster selon votre configuration
AUDIODEVICE="alsasrc"
WEBCAMDEVICE="/dev/video0"
WEBCAMHEIGHT="240"
OUTPUTHEIGHT="720"
OUTPUTFPS="10"
### Fin des variables à ajuster

… en attendant LE programme ultime

qui devra reprendre en gros les étapes de mon script mais en ajoutant:

• une interface graphique
• le choix d’une portion de l’écran à capturer
• le choix d’une application (fenêtre) à capturer
• le choix de la source audio (mixage possible avec la librairie Jack)
• paramétrage fin des codecs audio et video

1. ffmpeginstall.sh permet d’installer les dernières versions de FFMpeg (svn) et du codec X.264 (git) à partir des sources.
2. ffmpegupdate.sh permet de mettre à jour ces deux logiciels à partir des sources.

Suivi des modifications:

• 26/04/2010: Scripts version 0.1 (validé sous Ubuntu 9.10 et 10.04)

Récupération des scripts

On commence par récupérer les scripts:

mkdir ~/src

cd ~/src

wget http://svn.nicolargo.com/ubuntupostinstall/trunk/ffmpeginstall.sh

wget http://svn.nicolargo.com/ubuntupostinstall/trunk/ffmpegupdate.sh

chmod a+ ffmpeg*.sh

Lancement des scripts

Pour une installation initiale:

cd ~src

./ffmpeginstall.sh

Pour une mise à jour:

cd ~src

./ffmpegupdate.sh

Le résultat

ffmpeg -version
FFmpeg version SVN-r22965, Copyright (c) 2000-2010 the FFmpeg developers
 built on Apr 26 2010 16:57:27 with gcc 4.4.3
 configuration: --enable-gpl --enable-version3 --enable-nonfree --enable-postproc --enable-pthreads --enable-libfaac --enable-libfaad --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libtheora --enable-libx264 --enable-libxvid --enable-x11grab

x264 --version
x264 0.94.1564 a927654
built on Apr 26 2010, gcc: 4.4.3

Et si je veux revenir avec les versions systèmes ?

Rien de plus simple, il suffit de saisir la commande suivante:

sudo apt-get remove x264 ffmpeg build-essential subversion git-core checkinstall yasm texi2html libfaac-dev libfaad-dev libmp3lame-dev libsdl1.2-dev libtheora-dev libx11-dev libxfixes-dev libxvidcore-dev zlib1g-dev

Je suis preneur de tout retour/amélioration sur ces scripts…

Installation de Flumotion sous Ubuntu

A partir des dépôts (sous Ubuntu 9.04, 9.10 ou 10.04):

sudo aptitude install flumotion

Ou alors en compilant depuis les sources.

Le serveur Flumotion qui se compose de deux daemon (flumotion-manager et flumotion-worker) devrait se lancer automatiquement à la fin de l’installation:

* Restarting Flumotion Streaming Server flumotion                       [ OK ]

ps auxw | grep flumotion

118      17263  0.0  0.6  18784 13252 ?        S    16:46   0:00 /usr/bin/python /usr/bin/flumotion-manager -D --daemonize-to /var/cache/flumotion --service-name default /etc/flumotion/managers/default/planet.xml
118      17291  0.0  0.5  26604 11412 ?        Sl   16:46   0:00 /usr/bin/python /usr/bin/flumotion-worker -D --daemonize-to /var/cache/flumotion --service-name default /etc/flumotion/workers/default.xml

Configuration de Flumotion

Nous allons configurer Flumotion pour faire de la vidéo à la demande (comme Youtube ou Daily Motion) . Pour celà il faut d’abord créer un répertoire sur le serveur dans lequel les vidéos seront mises à disposition (/home/flumotion/Videos dans mon cas).

sudo mkdir /home/flumotion
sudo chown -R flumotion:flumotion flumotion

Puis y copier quelques vidéos pour vos tests Par exemple j’ai récupéré sur le site HD-Trailer des bandes annonces HD 720p au format MOV/H.264/AAC que j’ai converti en utilisant les codecs libres Theora/Vorbis (le seul, l’unique / fin de troll).

ffmpeg2theora -v 6 -y 240 shutterisland-720p.mov -o shutterisland-240p.ogv
ffmpeg2theora -v 6 -y 480 shutterisland-720p.mov -o shutterisland-480p.ogv
ffmpeg2theora -v 8 -y 720 shutterisland-720p.mov -o  shutterisland-720p.ogv

L’interface graphique d’administration de Flumotion peut être lancé en lugne de commande (flumotion-admin) ou via le menu “Application > Son et vidéo > Flumotion Streamin server administration“.

On commence par configurer l’administrateur pour se connecter sur le serveur actuellement lancé:

Puis rentre les informations sur le serveur (nom d’hôte et port, par défaut 7531):

Enfin on entre le login/password d’administration (par défaut user/test). Pour changer le login/password, il faut éditer les fichiers  /etc/flumotion/managers/default/planet.xml et /etc/flumotion/workers/default.xml puis relancer flumotion (# sudo /etc/init.d/flumotion restart).

La fenêtre suivante devrait apparaitre (sinon il faut aller cliquer dans le menu Controler > Lancer l’assistant):

On demande la création d’un serveur de vidéo à la demande (VoD):

On entre ensuite le répertoire ou se trouve les vidéos (/home/flumotion/Videos par exemple), le port sur lequel le serveur va répondre, un éventuel point de montage (si vous voulez que le serveur réponde à l’URL http://serveur:8800/pointdemontage) ainsi que l’emplacement du fichier de log.

Et enfin:

Test de Flumotion

Il ne reste plus qu’a pointer un navigateur Web sur l’adresse http://addresseserveur:8800/fichiervideo.ogg

Par exemple, si j’ouvre l’URL http://localhost:8800/shutterisland-240p.ogv avec un Firefox (compatible HTML5 et Theora) la video va s’afficher et il est possible d’utiliser les boutons de contrôle du playeur HTML5 (play / stop / pause / dépacement dans la vidéo).

J’ai testé sur un LAN jusqu’a des résolutions HD de 720p et même 1080p et la vidéo s’affiche rapidement (moins de 3 secondes entre l’affichage de la page HTML et le début du streaming) et de manière fluide (pas de coupure ou d’arrêt).

Si vous souhaitez heberger votre serveur Flumotion sur Internet, il faudra bien évidemment vérifier que le FAI autorise se genre de traffic de streaming dans le contrat et qu’il n’y a pas de  limite en terme de volume ni de goulet d’étranglement en terme de débit.

Conclusion

Il ne vous reste plus qu’a “web coder” la présentation autour des vidéos (avec du HTML/CSS /JS par exemple) et vous êtes fin prés pour concurrence Vimeo and co !

Nous allons dans ce billet essayer d’optimiser le streaming d’un flux SD sur un réseau local (LAN de 100 Mbps) en utilisant le framework GStreamer.

Environnement des tests

Deux PC Ubuntu connectés sur un même switch (100 Mbps full-duplex).

• PC serveur: Intel(R) Core(TM)2 Duo CPU P8400 @ 2.26GHz / 2 Go RAM
• PC client: Intel(R) Core(TM)2 Duo CPU E6750 @ 2.66GHz / 1 Go RAM

GStreamer version 0.10.25.

Vidéo source: Big Buck Bunny 480p

Tests avec le codec X.264

Ligne de commande sur la machine générant le streaming (serveur):
serveur> gst-launch -v \
        filesrc location="../Vidéos/big_buck_bunny_480p_stereo.ogg" \
        ! queue ! decodebin \
        ! queue ! videoscale method=1 ! video/x-raw-yuv,width=854,height=480 \
        ! queue ! videorate ! video/x-raw-yuv,framerate=\(fraction\)24/1 \
        ! queue ! x264enc byte-stream=true bitrate=2000 bframes=4 ref=4 me=hex subme=4 weightb=true threads=0 \
        ! queue ! rtph264pay \
        ! queue ! udpsink port=5000 host=192.168.29.150 sync=false async=false

Ligne de commande sur la machine recevant le streaming (client):

client> gst-launch -v udpsrc caps="application/x-rtp, media=\(string\)video, clock-rate=\(int\)90000, encoding-name=\(string\)H264, payload=\(int\)96" port=5000 \
 ! queue ! rtph264depay \
 ! queue ! ffdec_h264 ! xvimagesink

Résultat:
Visuel: vidéo saccadé (environ 2 img/sec)
Bande passante mesurée: entre 2 et 3 Mbps
Resource serveur: %CPU=135 / %MEM=5
Resource client: %CPU=10 / %MEM=2

On ajoute un buffer juste avant le depay et le décodage (au niveau du client):

client> gst-launch -v udpsrc caps="application/x-rtp, media=\(string\)video, clock-rate=\(int\)90000, encoding-name=\(string\)H264, payload=\(int\)96" port=5000 \
        ! queue ! gstrtpjitterbuffer latency=3000 \
        ! queue ! rtph264depay \
        ! queue ! ffdec_h264 ! xvimagesink

Résultat:
Visuel: vidéo beaucoup plus fluide mais variation de la gigue (accéleration de la video par moment). On a par contre un décalage de 3 secondes, donc inutilisable pour des flux lives.
Bande passante mesurée: entre 2 et 3 Mbps
Resource serveur: %CPU=140 / %MEM=6
Resource client: %CPU=14 / %MEM=2

On modifie ensuite les paramètres d’encodage X.264 (au niveau du serveur):

serveur> gst-launch -v --gst-debug-level=2 \
        filesrc location="../Vidéos/big_buck_bunny_480p_stereo.ogg" \
        ! queue ! decodebin \
        ! queue ! videoscale method=1 ! video/x-raw-yuv,width=720,height=480 \
        ! queue ! videorate ! video/x-raw-yuv,framerate=\(fraction\)24/1 \
        ! queue ! x264enc vbv-buf-capacity=3000 byte-stream=true bitrate=900 subme=4 ref=2 bframes=1 b-pyramid=true weightb=true \
        ! queue ! rtph264pay \
        ! queue ! udpsink port=5000 host=192.168.29.150 sync=false async=false

Résultat:
Visuel: Presque plus de sacade ni de variation de gigue. On a par contre un décalage de 3 secondes, donc inutilisable pour des flux lives.
Bande passante mesurée: entre 2 et 3 Mbps
Resource serveur: %CPU=120 / %MEM=4
Resource client: %CPU=10 / %MEM=2

Pourquoi ces formats ?

Je me limite à ces deux formats pour la simple et bonne raison qu’il se complète dans mon utilisation quotidienne. En effet, le format OGG (Theora/Vorbis), outre le fait qu’il soit basée sur des codecs libres, permet une intégration simplifié des vidéos dans les navigateurs supportant le HTML5 (lire ce billet), de son coté le format MP4 (H264/AAC) est un standard qui permet de lire ce type de fichiers sur une PlayStation 3.

Avant d’encoder…

Avant de commencer, il faut choisir une source de bonne qualité. Les codecs ne font pas des miracles et si la source est mauvaise, les fichiers encodés le seront aussi. Pour mes tests, j’ai récupéré un trailer haute définition sur le site HD-Trailers.net.  Les caractéristiques du fichier sont les suivantes:

ffmpeg -i shutterisland-tlr1r2r_h720p.mov
Duration: 00:02:22.27, start: 0.000000, bitrate: 6178 kb/s
Stream #0.0(eng): Video: h264, yuv420p, 1280x544, 23.98 tbr, 23.98 tbn, 47.95 tbc
Stream #0.1(eng): Audio: aac, 48000 Hz, 5.1, s16

Pour jouer cette vidéo sur votre machine, il faut saisir la pipeline suivante:

gst-launch filesrc location=~/Vidéos/shutterisland-tlr1r2r_h720p.mov ! decodebin name=decoder \
 decoder. ! queue ! audioconvert ! audioresample ! autoaudiosink \
 decoder. ! queue ! ffmpegcolorspace ! autovideosink

Voici le résultat:

Le fichier source a une talle de 11 Mo

Fichier source

Comment encoder ?

En basse qualité

Nous obtiendrons ici des fichiers dont la taille sera réduite mais avec une qualité plus basse, notamment lors des phases ou la caméra bouge beaucoup (par exemple sur les travelings).

Encodage OGG (Theora/Vorbis)

La pipeline:

gst-launch filesrc location=~/Vidéos/shutterisland-tlr1r2r_h720p.mov ! decodebin name=decoder \
 decoder. ! queue ! audioconvert ! vorbisenc ! queue ! \
 oggmux name=muxer \
 decoder. ! queue ! ffmpegcolorspace ! theoraenc ! queue ! \
 muxer. muxer. ! queue ! filesink location=~/Vidéos/shutterisland-tlr1r2r_h720p_lq.ogv

Le fichier a une taille 1.7 Mo de donne le résultat suivant:
Fichier basse qualité OGG

Encodage MP4 (H264/AAC)

La pipeline:

gst-launch filesrc location=~/Vidéos/shutterisland-tlr1r2r_h720p.mov ! decodebin name=decoder \
 decoder. ! queue ! audioconvert ! faac profile=2 ! queue ! \
 ffmux_mp4 name=muxer \
 decoder. ! queue ! ffmpegcolorspace ! x264enc pass=4 quantizer=30 subme=4 threads=0 ! queue ! \
 muxer. muxer. ! queue ! filesink location=~/Vidéos/shutterisland-tlr1r2r_h720p_lq.mp4

Le fichier a une taille 2 Mo de donne le résultat suivant:
Fichier basse qualité MP4

En moyenne qualité

Nous obtiendrons ici un bon compromis entre la taille des fichiers et la qualité de l’image.

Encodage OGG (Theora/Vorbis)

La pipeline:

gst-launch filesrc location=~/Vidéos/shutterisland-tlr1r2r_h720p.mov ! decodebin name=decoder \
 decoder. ! queue ! audioconvert ! vorbisenc ! queue ! \
 oggmux name=muxer \
 decoder. ! queue ! ffmpegcolorspace ! theoraenc quality=32 ! queue ! \
 muxer. muxer. ! queue ! filesink location=~/Vidéos/shutterisland-tlr1r2r_h720p_mq.ogv

Le fichier a une taille 2.8 Mo de donne le résultat suivant:
Fichier moyenne qualité OGG

Encodage MP4 (H264/AAC)

La pipeline:

gst-launch filesrc location=~/Vidéos/shutterisland-tlr1r2r_h720p.mov ! decodebin name=decoder \
 decoder. ! queue ! audioconvert ! faac profile=2 ! queue ! \
 ffmux_mp4 name=muxer \
 decoder. ! queue ! ffmpegcolorspace ! x264enc pass=4 quantizer=25 subme=5 me=2 ref=3 threads=0 ! queue ! \
 muxer. muxer. ! queue ! filesink location=~/Vidéos/shutterisland-tlr1r2r_h720p_mq.mp4

Le fichier a une taille 3.6 Mo de donne le résultat suivant:
Fichier moyenne qualité MP4

En haute qualité

Nous obtiendrons ici une très bonne qualité d’image mais une taille importante des fichiers.

Encodage OGG (Theora/Vorbis)

La pipeline:

gst-launch filesrc location=~/Vidéos/shutterisland-tlr1r2r_h720p.mov ! decodebin name=decoder \
 decoder. ! queue ! audioconvert ! vorbisenc ! queue ! \
 oggmux name=muxer \
 decoder. ! queue ! ffmpegcolorspace ! theoraenc quality=48 ! queue ! \
 muxer. muxer. ! queue ! filesink location=~/Vidéos/shutterisland-tlr1r2r_h720p_hq.ogv

Le fichier a une taille 5 Mo de donne le résultat suivant:
Fichier haute qualité OGG

Encodage MP4 (H264/AAC)

La pipeline:

gst-launch filesrc location=~/Vidéos/shutterisland-tlr1r2r_h720p.mov ! decodebin name=decoder \
 decoder. ! queue ! audioconvert ! faac profile=2 ! queue ! \
 ffmux_mp4 name=muxer \
 decoder. ! queue ! ffmpegcolorspace ! x264enc pass=4 quantizer=20 subme=6 me=2 ref=3 threads=0 ! queue ! \
 muxer. muxer. ! queue ! filesink location=~/Vidéos/shutterisland-tlr1r2r_h720p_hq.mp4

Le fichier a une taille 7.3 Mo de donne le résultat suivant:
Fichier haute qualité MP4

Pour conclure

Nous avons vu dans ce billet les bases de l’encodage de fichiers vidéos avec GStreamer. Il est imporant de signaler que par la magie des pipeline, on pourrait très bien appliquer ces méthodes avec une source live comme une Webcam ou un flux venant d’un serveur de streaming vidéo.

Si vous avez des pipelines d’encodages que vous voulez partager avec les lecteurs de ce blog, les commentaires sont là pour ça !

Avant de commencer

On ouvre un terminal et on lance les commandes suivantes afin d’installer les librairies nécessaires à la compilation de Handbrake:

sudo yum groupinstall "Development Tools" "Development Libraries" "X Software Development" "GNOME Software Development"
sudo yum install yasm zlib-devel bzip2-devel dbus-glib-devel hal-devel webkitgtk-devel libnotify-devel gstreamer-devel gstreamer-plugins-base-devel

Installation de Handbrake

On récupère la dernière version de Handbrake à parit du dépôt SVN:

cd ~
mkdir src
cd src
svn checkout svn://svn.handbrake.fr/HandBrake/trunk handbrake

On lance la préparation de la compilation:

cd handbrake
./configure --launch

On compile et on installe:

cd build
sudo make install

Pour lancer le logiciel Handbrake, il faut aller dans le menu Applications / Son et vidéo / Handbrake (si vous êtes sous Gnome…). Et voilà le travail:

Configuration d’un profil PlayStation 3

On commence par cliquer sur le profil “High Profile” puis sur le bouton “Save current settings to new preset”. On entre un nom et une description pour le profil:

J’utilise les paramètres suivants:

Il ne reste plus qu’a insérer un DVD dans votre lecteur, choisir le profil “PlayStation 3″ et lancer l’encodage !