Erstellen eines benutzerdefinierten GStreamer-Plugins für NVIDIA DeepStream

Erstellen eines benutzerdefinierten GStreamer-Plugins für NVIDIA DeepStream

NVIDIA DeepStream ist ein leistungsstarkes Framework für KI-gestützte Videoanalyse-Anwendungen, das die Echtzeitverarbeitung von Videostreams mithilfe von Deep-Learning-Modellen ermöglicht. Im Kern nutzt DeepStream GStreamer, ein Open-Source-Multimedia-Framework, um flexible und effiziente Pipelines zu erstellen. Obwohl DeepStream eine umfangreiche Sammlung vorgefertigter Plugins mitbringt, erfordern viele fortgeschrittene Anwendungsfälle – wie benutzerdefinierte Vorverarbeitung, spezialisierte Inferenzlogik oder einzigartige Nachbearbeitung – die Entwicklung eigener GStreamer-Plugins. Dieser Artikel bietet eine praktische Schritt-für-Schritt-Anleitung zur Erstellung eines benutzerdefinierten GStreamer-Plugins für NVIDIA DeepStream, einschließlich Anforderungen, Installation und Anwendungsbeispielen.

Am Ende dieses Leitfadens werden Sie verstehen, wie Sie die Fähigkeiten von DeepStream erweitern können, indem Sie ein einfaches benutzerdefiniertes Element schreiben, das Videobilder modifiziert, bevor es sie an nachgelagerte Komponenten weitergibt. Dieser Ansatz wird häufig in Produktionssystemen verwendet, wie auch in Ressourcen wie dem Towards Data Science Blog erwähnt, der oft benutzerdefinierte Pipeline-Komponenten für KI-Anwendungen untersucht.

Anforderungen

Bevor Sie mit der Plugin-Entwicklung beginnen, stellen Sie sicher, dass Ihr System die folgenden Voraussetzungen erfüllt. Diese Schritte basieren auf Standardkonfigurationen, die in der NVIDIA-Dokumentation und allgemeinen KI-Entwicklungspraktiken empfohlen werden.

Hardware-Anforderungen

• **NVIDIA GPU mit CUDA-Unterstützung**: Eine Tesla T4, V100 oder eine moderne GeForce/Quadro GPU wird für Hardwarebeschleunigung empfohlen.
• **Ausreichend RAM**: Mindestens 8 GB (16 GB oder mehr für hochauflösende Streams).

Software-Anforderungen

• **Ubuntu 20.04 oder 22.04 LTS**: DeepStream ist für diese Distributionen optimiert.
• **NVIDIA Treiber**: Version 525 oder neuer (überprüfen mit `nvidia-smi`).
• **CUDA Toolkit**: Version 11.8 oder 12.x.
• **GStreamer-Entwicklungsbibliotheken**: Version 1.18 oder neuer.
• **NVIDIA DeepStream SDK**: Version 6.3 oder 7.0 (aktuellste stabile Version).
• **Build-Tools**: `gcc`, `g++`, `make`, `cmake` und `pkg-config`.

Installation überprüfen

Bestätigen Sie zunächst, dass GStreamer und DeepStream installiert sind:

# GStreamer-Version prüfen
gst-launch-1.0 --version

# DeepStream-Installation prüfen (nach deepstream-app suchen)
which deepstream-app

# CUDA-Verfügbarkeit prüfen
nvcc --version

Wenn einer der Befehle fehlschlägt, lesen Sie die offizielle NVIDIA DeepStream-Installationsanleitung (verfügbar auf der Entwickler-Website) zur Fehlerbehebung.

Schritt-für-Schritt-Installation

Die Erstellung eines benutzerdefinierten GStreamer-Plugins umfasst die Entwicklung eines neuen Elements, das die GStreamer-Plugin-Schnittstelle implementiert. DeepStream-Plugins erben typischerweise von `GstBaseTransform` oder `GstElement`, was eine nahtlose Integration in das Framework ermöglicht. Im Folgenden beschreiben wir den gesamten Prozess von Grund auf.

1. Entwicklungsumgebung einrichten

Erstellen Sie ein Projektverzeichnis und initialisieren Sie eine grundlegende Plugin-Struktur:

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

Installieren Sie die erforderlichen Entwicklungspakete:

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

Für DeepStream-spezifische Header stellen Sie sicher, dass das DeepStream SDK installiert ist. Der übliche Pfad ist `/opt/nvidia/deepstream/deepstream-7.0/`.

2. Plugin-Quellcode schreiben

Erstellen Sie eine Datei mit dem Namen `src/gstmycustomplugin.c`. Dieses Beispiel implementiert einen einfachen Filter, der Videobilder in Graustufen umwandelt (ein häufiger Vorverarbeitungsschritt für bestimmte KI-Modelle).

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

/* Plugin-Grundgerüst */
GST_DEBUG_CATEGORY_STATIC (gst_my_custom_plugin_debug);
#define GST_CAT_DEFAULT gst_my_custom_plugin_debug

/* Filter-Struktur */
typedef struct _GstMyCustomPlugin {
  GstVideoFilter base_videofilter;
  /* Hier benutzerdefinierte Eigenschaften hinzufügen */
} GstMyCustomPlugin;

typedef struct _GstMyCustomPluginClass {
  GstVideoFilterClass base_videofilter_class;
} GstMyCustomPluginClass;

/* Pad-Vorlagen des Elements definieren */
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 }"))
);

/* Transformationsfunktion: In Graustufen umwandeln (vereinfacht) */
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);

  /* Einfache Graustufen: Durchschnitt von R, G, B für jedes Pixel (nimmt RGB an) */
  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;
}

/* Element registrieren */
#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",
      "Konvertiert Video in Graustufen",
      "Autor <autor@example.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)
{
  /* Hier benutzerdefinierte Eigenschaften initialisieren */
}

/* Plugin-Einstiegspunkt */
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. Build-System erstellen

Erstellen Sie eine `CMakeLists.txt`-Datei im Projektverzeichnis:

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. Plugin erstellen

Kompilieren Sie das Plugin:

mkdir build
cd build
cmake ..
make

Dies erzeugt eine Shared Library `libgstmycustomplugin.so`.

5. Plugin installieren

Kopieren Sie die Bibliothek in das GStreamer-Plugin-Verzeichnis:

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

Alternativ können Sie die Umgebungsvariable `GST_PLUGIN_PATH` auf das Build-Verzeichnis setzen, um zu testen:

export GST_PLUGIN_PATH=$PWD

6. Plugin überprüfen

Verwenden Sie `gst-inspect-1.0`, um zu bestätigen, dass das Plugin erkannt wird:

gst-inspect-1.0 mycustomplugin

Sie sollten eine Ausgabe sehen, die die Pads und Fähigkeiten des Elements detailliert beschreibt.

Anwendungsbeispiele

Nachdem Ihr benutzerdefiniertes Plugin erstellt ist, integrieren Sie es in eine DeepStream-Pipeline. Im Folgenden finden Sie zwei praktische Beispiele.

Beispiel 1: Einfache Graustufen-Konvertierung

Testen Sie das Plugin eigenständig mit einer Videodatei:

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

Diese Pipeline dekodiert ein H.264-Video, konvertiert es in das NV12-Format (häufig in DeepStream), wendet Ihren benutzerdefinierten Graustufenfilter an und zeigt die Ausgabe an.

Beispiel 2: Integration mit DeepStream

Für eine vollständige DeepStream-Pipeline verwenden Sie das Plugin als Filter zwischen Inferenz und Anzeige:

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

# GStreamer initialisieren
Gst.init(None)

# Pipeline-String erstellen
pipeline_str = """
    filesrc location=/pfad/zu/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
"""

# Pipeline erstellen und ausführen
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)

Dieses Beispiel fügt `mycustomplugin` nach dem Tracker ein, um die Graustufentransformation vor der Overlay-Darstellung anzuwenden. Passen Sie den Konfigurationsdateipfad an Ihre DeepStream-Installation an.

Beispiel 3: DeepStream-Kommandozeilen-App

Alternativ können Sie `deepstream-app` mit einer benutzerdefinierten Konfigurationsdatei verwenden, die Ihr Plugin enthält:

deepstream-app -c deepstream_app_config.txt

Fügen Sie in der Konfigurationsdatei Ihr Plugin zur Pipeline-Definition hinzu:

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

[tracker]
enable=1

[mycustomplugin]
# Für dieses einfache Plugin ist keine zusätzliche Konfiguration erforderlich

[sink0]
enable=1
type=3  # Fakesink für headless Betrieb

Fazit

Die Erstellung eines benutzerdefinierten GStreamer-Plugins für NVIDIA DeepStream ermöglicht es Entwicklern, Videoanalyse-Pipelines an spezifische Anforderungen anzupassen. Dieser Leitfaden führte durch den gesamten Prozess – von der Einrichtung der Entwicklungsumgebung und dem Schreiben eines einfachen Graustufenfilters bis hin zum Kompilieren, Installieren und Integrieren des Plugins in reale Pipelines. Durch die Beherrschung dieser Fähigkeit können Sie die Möglichkeiten von DeepStream für Aufgaben wie benutzerdefinierte Vorverarbeitung, spezialisierte Inferenzlogik oder einzigartige Nachbearbeitungseffekte erweitern.

Der hier beschriebene Ansatz ist grundlegend, wie auch in Ressourcen wie dem Towards Data Science Blog erwähnt, der oft solche benutzerdefinierten Komponenten für KI-Anwendungen untersucht. Für fortgeschrittenere Plugins – wie solche, die TensorRT-Modelle integrieren oder mehrere Streams verarbeiten – lesen Sie die NVIDIA DeepStream Plugin-API-Dokumentation und Community-Beispiele. Mit diesem Wissen sind Sie bereit, anspruchsvolle, produktionsreife Videoanalyse-Systeme zu entwickeln, die die volle Leistungsfähigkeit von NVIDIA GPUs und die Flexibilität von GStreamer nutzen.