Création d’un plugin GStreamer personnalisé pour NVIDIA DeepStream

Création d'un plugin GStreamer personnalisé pour NVIDIA DeepStream

NVIDIA DeepStream est un framework puissant pour construire des applications d'analyse vidéo basées sur l'IA, permettant le traitement en temps réel de flux vidéo à l'aide de modèles d'apprentissage profond. Au cœur de DeepStream se trouve GStreamer, un framework multimédia open source, qui permet de construire des pipelines flexibles et efficaces. Bien que DeepStream soit livré avec un ensemble riche de plugins pré-construits, de nombreux cas d'usage avancés — comme le prétraitement personnalisé, la logique d'inférence spécialisée ou le post-traitement unique — nécessitent la création de votre propre plugin GStreamer. Cet article fournit un guide pratique, étape par étape, pour créer un plugin GStreamer personnalisé pour NVIDIA DeepStream, couvrant les prérequis, l'installation et des exemples d'utilisation.

À la fin de ce guide, vous comprendrez comment étendre les capacités de DeepStream en écrivant un élément personnalisé simple qui modifie les trames vidéo avant de les transmettre en aval. Cette approche est largement utilisée dans les systèmes de production, comme le soulignent des ressources comme le blog Towards Data Science, qui explore souvent des composants de pipeline personnalisés pour les applications d'IA.

Prérequis

Avant de vous lancer dans le développement de plugins, assurez-vous que votre système répond aux prérequis suivants. Ces étapes sont basées sur des configurations standard recommandées dans la documentation NVIDIA et les pratiques générales de développement en IA.

Prérequis matériels

• **GPU NVIDIA avec support CUDA** : Une Tesla T4, V100, ou toute GeForce/Quadro moderne est recommandée pour l'accélération matérielle.
• **RAM suffisante** : Au moins 8 Go (16 Go ou plus pour les flux haute résolution).

Prérequis logiciels

• **Ubuntu 20.04 ou 22.04 LTS** : DeepStream est optimisé pour ces distributions.
• **Pilote NVIDIA** : Version 525 ou ultérieure (vérifiez avec `nvidia-smi`).
• **CUDA Toolkit** : Version 11.8 ou 12.x.
• **Bibliothèques de développement GStreamer** : Version 1.18 ou ultérieure.
• **SDK NVIDIA DeepStream** : Version 6.3 ou 7.0 (dernière version stable).
• **Outils de compilation** : `gcc`, `g++`, `make`, `cmake` et `pkg-config`.

Vérification de l'installation

Commencez par confirmer que GStreamer et DeepStream sont installés :

# Vérifier la version de GStreamer
gst-launch-1.0 --version

# Vérifier l'installation de DeepStream (chercher deepstream-app)
which deepstream-app

# Vérifier la disponibilité de CUDA
nvcc --version

Si une commande échoue, consultez le guide d'installation officiel de DeepStream de NVIDIA (disponible sur leur site développeur) pour résoudre le problème.

Installation étape par étape

La création d'un plugin GStreamer personnalisé implique la création d'un nouvel élément qui implémente l'interface du plugin GStreamer. Les plugins DeepStream héritent généralement de `GstBaseTransform` ou `GstElement`, ce qui leur permet de s'intégrer parfaitement au framework. Nous décrivons ci-dessous le processus depuis le début.

1. Configuration de l'environnement de développement

Créez un répertoire de projet et initialisez une structure de plugin de base :

mkdir custom-deepstream-plugin
cd custom-deepstream-plugin
mkdir src include

Installez les paquets de développement nécessaires :

sudo apt-get update
sudo apt-get install -y libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \
    libgstreamer-plugins-bad1.0-dev gstreamer1.0-plugins-base \
    gstreamer1.0-plugins-good gstreamer1.0-plugins-bad \
    gstreamer1.0-plugins-ugly gstreamer1.0-libav \
    libgstrtspserver-1.0-dev libjson-glib-dev

Pour les en-têtes spécifiques à DeepStream, assurez-vous que le SDK DeepStream est installé. Le chemin courant est `/opt/nvidia/deepstream/deepstream-7.0/`.

2. Écriture du code source du plugin

Créez un fichier nommé `src/gstmycustomplugin.c`. Cet exemple implémente un filtre simple qui convertit les trames vidéo en niveaux de gris (une étape de prétraitement courante pour certains modèles d'IA).

#include <gst/gst.h>
#include <gst/video/video.h>
#include <gst/video/gstvideofilter.h>

/* Code standard du plugin */
GST_DEBUG_CATEGORY_STATIC (gst_my_custom_plugin_debug);
#define GST_CAT_DEFAULT gst_my_custom_plugin_debug

/* Structure du filtre */
typedef struct _GstMyCustomPlugin {
  GstVideoFilter base_videofilter;
  /* Ajouter des propriétés personnalisées ici */
} GstMyCustomPlugin;

typedef struct _GstMyCustomPluginClass {
  GstVideoFilterClass base_videofilter_class;
} GstMyCustomPluginClass;

/* Définir les modèles de pads de l'élément */
static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE (
    "sink",
    GST_PAD_SINK,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ GRAY8, NV12 }"))
);

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE (
    "src",
    GST_PAD_SRC,
    GST_PAD_ALWAYS,
    GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ GRAY8, NV12 }"))
);

/* Fonction de transformation : conversion en niveaux de gris (simplifiée) */
static GstFlowReturn
gst_my_custom_plugin_transform_frame_ip (GstVideoFilter *filter,
                                         GstVideoFrame *frame)
{
  GstMapInfo map;
  gst_buffer_map (frame->buffer, &map, GST_MAP_WRITE);

  guint8 *data = map.data;
  guint width = GST_VIDEO_FRAME_WIDTH (frame);
  guint height = GST_VIDEO_FRAME_HEIGHT (frame);
  guint stride = GST_VIDEO_FRAME_PLANE_STRIDE (frame, 0);

  /* Niveaux de gris simples : moyenne R, V, B pour chaque pixel (suppose RVB) */
  for (guint y = 0; y < height; y++) {
    for (guint x = 0; x < width; x++) {
      guint8 *pixel = data + y * stride + x * 3;
      guint8 gray = (pixel[0] + pixel[1] + pixel[2]) / 3;
      pixel[0] = gray;
      pixel[1] = gray;
      pixel[2] = gray;
    }
  }

  gst_buffer_unmap (frame->buffer, &map);
  return GST_FLOW_OK;
}

/* Enregistrer l'élément */
#define PACKAGE "MyCustomPlugin"
#define PACKAGE_NAME "My Custom Plugin"
#define PACKAGE_VERSION "1.0.0"
#define PACKAGE_STRING "MyCustomPlugin 1.0.0"
#define PACKAGE_BUGREPORT "https://example.com"

GST_BOILERPLATE_FULL (GstMyCustomPlugin, gst_my_custom_plugin, GstVideoFilter,
                      GST_TYPE_VIDEO_FILTER, PACKAGE, PACKAGE_VERSION,
                      PACKAGE_STRING, PACKAGE_BUGREPORT);

static void
gst_my_custom_plugin_base_init (gpointer g_class)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details_simple (element_class,
      "My Custom Plugin",
      "Filter/Effect/Video",
      "Convertit la vidéo en niveaux de gris",
      "Auteur <auteur@exemple.com>");

  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&sink_factory));
  gst_element_class_add_pad_template (element_class,
      gst_static_pad_template_get (&src_factory));
}

static void
gst_my_custom_plugin_class_init (GstMyCustomPluginClass *klass)
{
  GstVideoFilterClass *video_filter_class = GST_VIDEO_FILTER_CLASS (klass);
  video_filter_class->transform_frame_ip = gst_my_custom_plugin_transform_frame_ip;
}

static void
gst_my_custom_plugin_init (GstMyCustomPlugin *filter)
{
  /* Initialiser les propriétés personnalisées ici */
}

/* Point d'entrée du plugin */
static gboolean
plugin_init (GstPlugin *plugin)
{
  GST_DEBUG_CATEGORY_INIT (gst_my_custom_plugin_debug, "mycustomplugin", 0,
                           "My Custom Plugin");
  return gst_element_register (plugin, "mycustomplugin", GST_RANK_NONE,
                               GST_TYPE_MY_CUSTOM_PLUGIN);
}

GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR,
                   mycustomplugin, "My Custom Plugin",
                   plugin_init, PACKAGE_VERSION, GST_LICENSE,
                   PACKAGE, PACKAGE_BUGREPORT)

3. Création du système de compilation

Créez un fichier `CMakeLists.txt` à la racine du projet :

cmake_minimum_required(VERSION 3.10)
project(mycustomplugin VERSION 1.0.0 LANGUAGES C)

find_package(PkgConfig REQUIRED)
pkg_check_modules(GSTREAMER REQUIRED gstreamer-1.0 gstreamer-video-1.0)
pkg_check_modules(GSTREAMER_BASE REQUIRED gstreamer-base-1.0)

add_library(gstmycustomplugin MODULE src/gstmycustomplugin.c)
target_include_directories(gstmycustomplugin PRIVATE include ${GSTREAMER_INCLUDE_DIRS})
target_link_libraries(gstmycustomplugin PRIVATE ${GSTREAMER_LIBRARIES} ${GSTREAMER_BASE_LIBRARIES})
set_target_properties(gstmycustomplugin PROPERTIES PREFIX "")

4. Compilation du plugin

Compilez le plugin :

mkdir build
cd build
cmake ..
make

Ceci produit une bibliothèque partagée `libgstmycustomplugin.so`.

5. Installation du plugin

Copiez la bibliothèque dans le répertoire des plugins de GStreamer :

sudo cp libgstmycustomplugin.so /usr/lib/x86_64-linux-gnu/gstreamer-1.0/
sudo ldconfig

Alternativement, définissez la variable d'environnement `GST_PLUGIN_PATH` pour pointer vers le répertoire de compilation pour les tests :

export GST_PLUGIN_PATH=$PWD

6. Vérification du plugin

Utilisez `gst-inspect-1.0` pour confirmer que le plugin est reconnu :

gst-inspect-1.0 mycustomplugin

Vous devriez voir une sortie détaillant les pads et les capacités de l'élément.

Exemples d'utilisation

Maintenant que votre plugin personnalisé est compilé, intégrez-le dans un pipeline DeepStream. Voici deux exemples pratiques.

Exemple 1 : Conversion en niveaux de gris basique

Testez le plugin de manière autonome avec un fichier vidéo :

gst-launch-1.0 filesrc location=/chemin/vers/entree.mp4 ! \
    qtdemux ! h264parse ! nvv4l2decoder ! \
    nvvidconv ! video/x-raw,format=NV12 ! \
    mycustomplugin ! \
    nvvidconv ! nveglglessink

Ce pipeline décode une vidéo H.264, la convertit au format NV12 (courant dans DeepStream), applique votre filtre personnalisé en niveaux de gris et affiche le résultat.

Exemple 2 : Intégration avec DeepStream

Pour un pipeline DeepStream complet, utilisez le plugin comme filtre entre l'inférence et l'affichage :

import sys
import gi
gi.require_version('Gst', '1.0')
from gi.repository import Gst, GLib

# Initialiser GStreamer
Gst.init(None)

# Construire la chaîne du pipeline
pipeline_str = """
    filesrc location=/chemin/vers/video.mp4 ! qtdemux ! h264parse ! nvv4l2decoder ! 
    nvstreammux batch-size=1 width=1920 height=1080 ! 
    nvinfer config-file-path=/opt/nvidia/deepstream/deepstream-7.0/samples/configs/deepstream-app/config_infer_primary.txt ! 
    nvtracker ! 
    mycustomplugin ! 
    nvdsosd ! 
    nveglglessink
"""

# Créer et exécuter le pipeline
pipeline = Gst.parse_launch(pipeline_str)
pipeline.set_state(Gst.State.PLAYING)

bus = pipeline.get_bus()
msg = bus.timed_pop_filtered(Gst.CLOCK_TIME_NONE, Gst.MessageType.EOS | Gst.MessageType.ERROR)
pipeline.set_state(Gst.State.NULL)

Cet exemple insère `mycustomplugin` après le tracker pour appliquer la transformation en niveaux de gris avant le rendu de la superposition. Ajustez le chemin du fichier de configuration selon votre installation DeepStream.

Exemple 3 : Application DeepStream en ligne de commande

Alternativement, utilisez `deepstream-app` avec un fichier de configuration personnalisé qui inclut votre plugin :

deepstream-app -c deepstream_app_config.txt

Dans le fichier de configuration, ajoutez votre plugin à la définition du pipeline :

[primary-gie]
enable=1
config-file-path=config_infer_primary.txt

[tracker]
enable=1

[mycustomplugin]
# Aucune configuration supplémentaire nécessaire pour ce plugin simple

[sink0]
enable=1
type=3  # Fakesink pour fonctionnement sans tête

Conclusion

La création d'un plugin GStreamer personnalisé pour NVIDIA DeepStream permet aux développeurs d'adapter les pipelines d'analyse vidéo à des besoins uniques. Ce guide a parcouru l'ensemble du processus — de la configuration de l'environnement de développement et de l'écriture d'un simple filtre en niveaux de gris à la compilation, l'installation et l'intégration du plugin dans des pipelines réels. En maîtrisant cette compétence, vous pouvez étendre les capacités de DeepStream pour des tâches comme le prétraitement personnalisé, la logique d'inférence spécialisée ou les effets de post-traitement uniques.

L'approche décrite ici est fondamentale, comme le soulignent des ressources comme le blog Towards Data Science, qui explore souvent ces composants personnalisés pour les applications d'IA. Pour des plugins plus avancés — comme ceux intégrant des modèles TensorRT ou gérant plusieurs flux — référez-vous à la documentation de l'API des plugins DeepStream de NVIDIA et aux exemples de la communauté. Avec ces connaissances, vous êtes prêt à construire des systèmes d'analyse vidéo sophistiqués et de qualité production qui exploitent toute la puissance des GPU NVIDIA et la flexibilité de GStreamer.