Évidemment, le plus dur c’est le montage et l’encodage. On peut le faire avec des logiciels de montage vidéo non-linéaire tels que KDEenLive, mais depuis qu’on utilise un caméscope HD, les captures 1080i font tout ramer et c’est compliqué. Ainsi, certains préféreront le faire en ligne de commande. Vu que le montage est tout simple, c’est possible avec des outils tels que ffmpeg et mkvmerge.

Quels que soient les logiciels utilisés pour monter et encoder la vidéo, il faut avoir quelques bases en encodage : savoir ce qu’est un codec, un conteneur, un filtre vidéo, le (dé)muxage… Pour ce qui est des vidéos de Toulibre en particulier, voici quelques trucs à savoir.

Le caméscope ne peut pas enregistrer de fichiers de plus de 2 Go. Ce qui fait qu’une seule prise sera divisée en plusieurs parties. Or, le découpage de ces fichiers ne s’aligne pas sur les keyframes. Ainsi, si on essaie de lire le deuxième fichier résultant du découpage par le caméscope, vu qu’il ne commencera pas par une keyframe, les premières images ne pourront être décodées complètement et contiendront des tas d’erreurs. Et ce jusqu’à ce que le décodeur rencontre une keyframe et puisse faire un décodage complet des images.

Bref, avant de faire un quelconque traitement des rushs, il faut les fusionner. Le format MPEG-TS produit par le caméscope est un flux, il dont très flexible et on peut concaténer les morceaux à l’aide de cat. Par exemple : cat 000001.MTS 000002.MTS 000003.MTS > all.mts

La vidéo capturée par le caméscope est entrelacée. Il est nécessaire de la désentrelacer avant de l’encoder (mais souvent le logiciel d’encodage fera à la fois le désentrelacement et l’encodage, comme il faut). Autrement, le codec essaiera d’encoder des images pleines de combing et le résultat sera très moche.

En tant qu’association de promotion du Libre, nous nous devons de diffuser des fichiers dont le conteneur et le codec sont dans des format ouverts. Dans ce domaine, le WebM offre de loin la meilleure qualité.

La capture d’une source analogique (image filmée) introduit plus ou moins de bruit vidéo (noise). Plus l’image est sombre, et plus on aura de bruit. Pour remédier à ça, on peut utiliser un filtre de débruitage (denoise). L’inconvéniant du débruitage est qu’on pert des détails (ça peut par exemple manger du texte écrit en petit sur le diaporama). Trop de débruitage introduit du color banding, il faut donc le doser avec précaution. L’avantage du débruitage est une vidéo plus nette, plus agréable à regarder, et plus facile à compresser par le codec.

Le filtre hqdn3d présent dans mplayer/mencoder et ffmpeg fonctionne bien. Il est bien documenté dans la page de manuel d’mplayer (il faut regarder à denoise3d). Je ne m’y connais pas dans ce domaine et je connais pas la signification des paramètres de hqdn3d, mais j’ai effectué pas mal de tests sur la vidéo de la conférence d’Enlightenment. Les paramètres par défaut (hqdn3d=4:3:6:4.5) laissaient des trainées derrière les mouvements. Avec hqdn3d=4:3:6:0, le résultat semble être identique mais sans ces trainées. Si je veux diminuer ou augmenter le débruitage, je baisse ou j’augmente tous les paramètres d’un même facteur (par exemple hqdn3d=3:2.25:4.5:0). Ça semble bien fonctionner aussi.

Voici une solution pour monter et encoder en ligne de commande (il y en a certainement beaucoup d’autres). Le but est de minimiser le plus possible les interventions humaines, et d’automatiser au maximum à l’aide de scripts. Mais tout n’est pas réalisable automatiquement.

Le but est d’arriver à une vidéo qui ressemble à ceci :

Les « ← » représentent des fondus de début, et les « → » des fondus de fin.

Pour ce faire, on va :

• Assembler les rushs avec cat.
• Extraire le son dans un .wav avec ffmpeg.
• Traiter ce son avec sox : couper le début et la fin, ajouter des fondus de début et de fin, éventuellement le filtrer en appliquant un gain, un compander, un noise reduction…
• Encoder le son traité avec ffmpeg.
• Encoder la vidéo avec ffmpeg, avec un fondu de début et de fin, et en positionnant le début et la fin pour qu’elle reste synchronisée avec l’audio, conformément aux positions de découpage du son, au temps de silence de début et au temps d’affichage de l’image d’intro.
• Générer l’image d’intro en SVG à partir d’un template, avec les bonnes infos dedans.
• La rastériser avec Inkscape (possible sans interface graphique).
• Encoder avec ffmpeg la séquence d’intro avec un fondu de début et de fin.
• Muxer avec mkvmerge l’intro suivi de la vidéo, et l’audio.

Tout ceci nous fait beaucoup de lignes de commandes à taper avec beaucoup de paramètres. Pour simplifier ce processus, j’ai créé un outil de chaîne de traitement nommé encoc.sh.

Encoc.sh (pour encoding chain) n’est pas un script magique qui va tout faire tout seul : il faut savoir ce qu’on fait. Le but de cet outil est de simplifier l’exécution de toutes ces commandes en se concentrant sur les paramètres qui nous intéressent. Chacune des étapes ci-dessus a été codée dans un script, qui lit un fichier en entrée et en produit un autre en sortie. Tous ces scripts mis bout à bout forment une chaîne d’encodage. Encoc.sh permet d’exécuter chacune des étapes indépendamment et selon une configuration globale donnée. Cette configuration est propre à un « projet », et transversale à toutes les étapes. Elle centralise tous les paramètres utiles, qui pourront ainsi être utilisés dans plusieurs scripts différents (par exemple, une fois la taille de la vidéo inscrite dans la configuration, elle sera utilisée par les scripts de l’image d’intro et d’encodage vidéo).

Il est maintenu sous subversion, pour le récupérer tapez :

svn co https://dotsec.fr/svn/encoc encoc

Pour l’avoir dans votre PATH, faites un lien symbolique. Par exemple :

sudo ln -s /là/où/est/le/checkout/encoc/encoc.sh /usr/local/bin/encoc.sh

Pour commencer, il faut se créer un répertoire de travail avec beaucoup d’espace disque, y copier la vidéo source, et concaténer les rushs :

mkdir foobar
cd foobar/
cp /media/caméra/*.MTS .
cat *.MTS > all.mts

Sur le SVN, il y a déjà une chaîne nommée toulibre, conçue pour les conférences des rencontre de Toulibre. Initialisez le répertoire de travail avec :

encoc.sh init /là/où/est/le/checkout/encoc/toulibre/ all.mts

Cela créera un fichier de configuration encoc.config, avec des tas de variables prédéfinies avec des valeurs par défaut. La plupart sont bonnes, mais quelques-unes sont vides et doivent être remplies. On verra plus tard comment.

Maintenant qu’on a notre fichier de configuration qui contient notamment le chemin de la chaîne d’encodage, si on lance encoc.sh depuis ce répertoire il se servira toujours de cette chaîne. En lançant encoc.sh sans paramètres, il affichera en plus de l’aide les scripts disponibles dans la chaîne d’encodage utilisée. On peut obtenir plus d’informations sur un script en particulier en donnant -h suivi du script.

encoc.sh -h audio.extract

Le script audio.extract est tout simple. On peut voir ce qu’il prend en entrée et produit en sortie. Ces fichiers correspondent aux variables $MTS et $AUDIO_TRACK du fichier de configuration encoc.config. On peut les modifier, ce qui peut être utile si ne veut pas suivre à la lettre la chaîne de traitement en utilisant des fichiers alternatifs.

Pour lancer le script, il suffit de taper encoc.sh audio.extract.

Voyons un script un peu plus complexe. Tapez :

encoc.sh -h audio.mix

En plus des fichiers d’entrée et de sortie, ce script utilise d’autres variables de la configuration. Certaines sont requises, d’autres optionnelles. Lorsqu’une variable requise est définie, elle apparaît en vert, sinon elle est en rouge. Pour audio.mix il va nous falloir définir AUDIO_START et AUDIO_END, respectivement le début et la fin de la conférence, en audio.

Pour définir ces variables, il y a deux façons de faire. Soit temporairement, pour tester, en les donnant directement dans la ligne de commande :

encoc.sh AUDIO_START=07:56.8 AUDIO_END=1:04:57 audio.mix

Soit en éditant les variables dans le fichier de configuration. On peut aussi demander à encoc.sh qu’il modifie le fichier de configuration avec les valeurs qu’on lui donne, à l’aide de l’option -w :

encoc.sh -w AUDIO_START=07:56.8 AUDIO_END=1:04:57

Le format des temps est toujours [[[[heures:]minutes:]:secondes]:milisecondes]. En interne encoc.sh converti toujours les temps en secondes, ce qui permet de faire des additions et soustractions, et qui marche pour tous les logiciels. On peut voir la ligne de commande qu’encoc compte lancer avec l’option -p (pretend) :

encoc.sh -p audio.mix

Ceci peut s’avérer très utile si on souhaite modifier la ligne de commande et la lancer soi-même, cependant rien de tout ça ne sera sauvegardé.

L’option -t permet de lancer chaque commande avec time, pour voir combien de temps elle prend.

Les avantages à utiliser encoc sont :

• D’avoir une chaîne d’encodage facilement réutilisable et modifiable. Il suffit de copier le répertoire et d’y modifier ce qu’on veut.
• De retenir ce qu’on a fait auparavant pour éventuellement revenir dessus si on découvre une meilleure façon de faire.
• De pouvoir s’arrêter puis reprendre plus tard le travail sans avoir à tout retenir de ce qu’on était en train de faire.
• De ne pas être contraint de suivre à la lettre la chaîne de traitement donnée. On peut facilement exécuter une des étapes soi-même (c.f. option -p) si le script n’y arrive pas ou qu’on pense pouvoir mieux faire.

Les scripts forment un arbre (inversé) de dépendances qui ressemble à ceci :

upload
 `-mux
    `+-audio.enco
     |  `-audio.mix
     |     `-audio.extract
     +-intro.enco
     |  `-intro.rasterize
     |     `-intro.gensvg
     `-video.enco

Les paramètres par défaut de la chaîne toulibre correspondent à une conférence classique d’une rencontre Toulibre. Dans chaque étape interviennent des variables de configuration qui peuvent être vues avec -h. Dans ce qui suit on ne détaille que les variables les plus importantes, mais d’autres peuvent être assez utiles.

Le son :

• Tout d’abord extraire le son : encoc.sh audio.extract
• L’idée, c’est de commencer par régler le début et la fin de la vidéo selon l’audio, à l’oreille, car c’est plus précis. Une fois ceci fait, on peut si on le souhaite dores et déjà s’attaquer à l’encodage vidéo.
• Repérer le début et la fin. Il faut essayer de couper le début à un moment où il y a un silence, pour ne pas commencer sur un bruit. Pour jouer directement un découpage, utilisez play audio.track.wav trim <début> fade <fade-in>
• Régler éventuellement le silence de départ (AUDIO_START_DELAY). On ne pourra plus le modifier plus tard car les calculs de position de découpage de la vidéo se basent en partie là-dessus.
• Éventuellement améliorer le son en positionnant AUDIO_SOX_CHAIN. On peut notamment se servir des filtres noisered et compand, mais c’est assez technique, je ne détaille pas cela ici.
• encoc.sh audio.mix
• encoc.sh audio.enco

La vidéo :

• La valeur prédéfinie pour ENCODING_OPTS est bonne et n’a normalement pas besoin d’être modifiée.
• On peut éventuellement réduire la résolution, ce qui fera qu’on obtiendra une qualité d’image équivalente avec un bitrate plus petit.
• Il faut surtout donner de bonnes valeurs à VIDEO_FILTERS et VIDEO_BITRATE. Pour une résolution de 1280 x 720, je dirais qu’il faut au grand minimum 200k, et 400k pour une qualité bonne/correcte.
• Pour tester ce que ça donne sur un extrait de la video :
  • encoc.sh sample.extract <position> <durée>
  • encoc.sh sample.enco test.webm
• Une fois des paramètres satisfaisants déterminés, lancer le long encodage : encoc.sh video.enco

L’intro :

• Remplir les variables CONF_*.
• encoc.sh intro.gensvg
• encoc.sh intro.rasterize
• Changez INTRO_DURATION selon la longueur du titre à lire. Pour trouver une bonne durée d’exposition, faites en sorte que ayez le temps de tout lire deux fois.
• encoc.sh intro.enco.

Le muxage :

• Modifier éventuellement CONF_LANG
• encoc.sh mux

L’upload :

• Vérifier les options d’upload, puis uploader avec : encoc.sh upload
• Ce script fait une vérification du fichier envoyé avec md5sum.