GStreamer, la théorie…

Le Framework multimédia libre

Nicolas Hennion

Nous allons dans cet article aller un peu plus dans le détail du fonctionnement de GStreamer (le Framework multimédia libre).

N'hésitez pas à commenter cet article ! Commentez

- Titre : GStreamer, la théorie…

- Auteur : Nicolas Hennion

- Parution : 21 novembre 2013

- Mise à jour : 19 novembre 2019

- Licence : Le contenu de cet article est rédigé par Nicolargo et est mis à disposition selon les termes de la Licence Creative Commons Attribution 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Sommaire

- I. C'est quoi donc ?

- II. Architecture générale de Gstreamer

- III. Comment fonctionne GStreamer

- III-A. Pipeline

- III-B. Élément

- III-C. Pads

- III-D. Bins

- IV. Conclusion

- V. Remerciements Developpez

I - C'est quoi donc ?

GStreamer est un framework multimédia : c'est-à-dire un ensemble de bibliothèques, d'outils et de conventions permettant le développement d'applications (source Wikipédia). Par multimédia, on attend ici la manipulation d'objets vidéo et audio.

Il est composé :

- d'une architecture logicielle comprenant un cœur et de nombreux plugins (plus de 150 pour la version 0.10) ;

- d'API pour le développement avec le support de nombreux langages ;

- d'outils de test (gst-launch), de documentation (gst-inspect) et de présentation (gsteditor).

II - Architecture générale de Gstreamer

GStreamer est composé d'un cœur (GStreamer Core) permettant de construire une séquence d'actions à effectuer sur vos objets multimédia. Ce cœur s'occupe de la communication entre les différentes briques en gérant les entrées/sorties. Il manipule les données sous forme de blocs et se base sur une architecture logicielle objet.

Les plugins manipulent les objets multimédias. On peut diviser les plugins en différentes catégories :

- gestion des entrées (sources) audio et vidéo : les entrées peuvent être des fichiers multimédias, des équipements (Webcam, caméra DV) ou des flux réseau (par exemple venant d'un streaming) ;

- gestion des protocoles : permet une gestion des protocoles de communication réseau. Avec le support de protocoles simples (UDP, TCP) ou plus complexes (RTP/RTSP) ;

- gestion des formats : les données multimédias sont dans des conteneurs (AVI, OGG, MPEG…). Gstreamer permet, via des plugins, de gérer ces conteneurs (lecture, mux, demux…) ;

- gestion des codecs : le fait que les codecs audio/vidéo soient proposés dans Gstreamer sous la forme de plugins comporte de gros avantages (normalisation d'un codec à l'autre, facilité de changement de codec dans une application, cycle de développement plus court pour inclure un plugin dans Gstreamer) ;

- gestion des filtres : il existe autant de possibilités de filtres audio et vidéo que votre imagination peut produire ;

- gestion des sorties (sinks) audio et vidéo : les sorties peuvent être des fichiers, des équipements (écrans) ou des flux réseau.

Il faut noter que les plugins GStreamer sont livrés sous la forme de trois packages :

gst-plugins-good : ceux qui sont les plugins jugés de bonne qualité par les développeurs et qui sont distribués sous licence LGPL ;

gst-plugins-ugly : ceux qui sont les plugins jugés de bonne qualité, mais qui peuvent poser des problèmes de licences (non libres) ;

gst-plugins-bad : ceux qui sont les plugins en développement, dont la qualité et/ou stabilité doivent être améliorées.

III - Comment fonctionne GStreamer

Afin d'expliquer le plus simplement le fonctionnement de GStreamer, nous allons prendre l'exemple d'une application ayant pour but de lire un fichier multimédia au format OGG (contenant des données audio encodées en Vorbis et vidéo encodées en Theroa) pour l'afficher sur votre écran et l'écouter sur vos haut-parleurs.

Le schéma du framework correspondant est le suivant :

III-A - Pipeline

La classe principale est nommée pipeline. C'est l'enveloppe qui va contenir l'ensemble des actions à effectuer.

III-B - Élément

Le Pipeline contient une chaîne d'éléments (elements). L'élément est la classe la plus importante dans GStreamer. À chaque élément est associée une fonction (plugin).

On distingue trois types d'éléments :

- les éléments source (« source element »). Ils produisent des données.

- les éléments de sorties (« sink element »). Ils ne produisent pas de donnée. Ils sont donc souvent en bout de pipeline (exemple : xvideosink, permet d'afficher une vidéo à l'écran).

- les éléments de filtrage (« filter element »). Ils ont une ou plusieurs entrées et une ou plusieurs sorties. Ils effectuent des traitements sur les données et les réinjectent dans le pipeline.

Voici par exemple l'élément qui permet la lecture d'un fichier depuis votre disque dur : file-source.

Pour vous donner une idée, voici le code C qui permet la création d'un élément de test (fakesrc) :

#include <gst/gst.h>
int
main (int argc, char *argv[])
{
GstElement *element;
/* init GStreamer */
gst_init (&argc, &argv);
/* create element */
element = gst_element_factory_make ("fakesrc", "source");
if (!element) {
g_print ("Failed to create element of type 'fakesrc'n");
return -1;
}
gst_object_unref (GST_OBJECT (element));
return 0;
}

Les lecteurs familiers avec GLib ne seront pas dépaysés…

III-C - Pads

Les pads sont les entrées/sorties des éléments. Ils servent à interconnecter les éléments. Ils peuvent inclure des fonctions de vérification afin de s'assurer que le format des données correspond à ce qu'ils attendent. On peut distinguer deux sous-ensembles de pads :

- les pads de type « sink », permettant de faire entrer des données dans un élément ;

- les pads de type « src » (source), permettant de faire sortir des données d'un élément.

Il est possible d'associer plusieurs pads sinks et srcs à un même élément.

Exemples de pads pour l'élément vorbis-decoder :

Les liens entre les éléments se font toujours entre un pad src et un pad sink :

Les pads sont de loin les objets les plus complexes dans GStreamer. Ils contiennent un ensemble de paramètres (statiques ou dynamiques) permettant de définir les données attendues ou générées. Par exemple en tapant la commande « gst-inspect theoraenc » qui donne la description du plugin de décodage vidéo Theroa :

Pad Templates:
SRC template: 'src'
Availability: Always
Capabilities:
video/x-raw-yuv
format: I420
framerate: [ 0/1, 2147483647/1 ]
width: [ 1, 2147483647 ]
height: [ 1, 2147483647 ]
SINK template: 'sink'
Availability: Always
Capabilities:
video/x-theora

On peut y voir qu'il s'attend à avoir comme source une vidéo au format RAW-YUV, avec un nombre d'images par seconde et une taille pouvant varier selon l'intervalle affiché. En sortie, l'élément produira un vidéo au format THEORA.

III-D - Bins

Les bins sont des pipelines prédéfinis que l'on peut inclure comme de simples éléments dans un nouveau pipeline. Cela permet de simplifier grandement certaines actions complexes (rtpbin en est un bon exemple !).

Exemple de création d'un bin en langage C :

#include <gst/gst.h>

int main (int argc, char *argv[])
{
GstElement *bin, *pipeline, *source, *sink;
/* init */
gst_init (&argc, &argv);
/* create */
pipeline = gst_pipeline_new ("my_pipeline");
bin = gst_bin_new ("my_bin");
source = gst_element_factory_make ("fakesrc", "source");
sink = gst_element_factory_make ("fakesink", "sink");
/* First add the elements to the bin */
gst_bin_add_many (GST_BIN (bin), source, sink, NULL);
/* add the bin to the pipeline */
gst_bin_add (GST_BIN (pipeline), bin);
/* link the elements */
gst_element_link (source, sink);
[..]
}

IV - Conclusion

J'espère que cette rapide introduction vous aura un peu éclairé sur les possibilités de GStreamer.

V - Remerciements Developpez

L'équipe Libres et Open source tient à remercier Nicolargo pour la rédaction de ce tutoriel.

Nos remerciements à Littlewhite pour sa gabarisation.

N'hésitez pas à commenter cet article ! Commentez