Desenvolvimento Python no DeepStream - MarianaMendanha/DeepstreamNvidia GitHub Wiki

Desenvolvimento Python no DeepStream

O desenvolvimento de aplicações Python no NVIDIA DeepStream é possível por meio dos Python bindings do GStreamer (GST), que facilitam a criação e controle de pipelines complexos de processamento de vídeo e inferência de IA. DeepStream fornece bindings adicionais para o acesso à MetaData do fluxo de vídeo, que permite rastrear objetos, realizar inferências e aplicar regras de negócio em tempo real.

Python Bindings e GStreamer no DeepStream

No DeepStream, as pipelines de processamento de vídeo são construídas usando bindings do GStreamer para Python. O GStreamer é um framework multimídia que manipula o fluxo de dados de vídeos e áudio, enquanto o DeepStream usa esses dados para executar inferências e outras análises. As Python bindings permitem que você integre inferências de IA e manipule metadados específicos do DeepStream.

Principais Componentes:

  1. GStreamer Python Bindings: Usadas para construir e controlar o pipeline multimídia.
  2. DeepStream MetaData: Accessada através de bindings específicos que permitem manipular dados de inferência de IA, como objetos detectados e suas características.

Estrutura de uma Aplicação Python com DeepStream

Uma aplicação DeepStream em Python usa o PyGObject (GST Python Bindings) para construir pipelines e manipular os elementos que realizam a captura de vídeo, decodificação, inferência, e pós-processamento. O DeepStream adiciona novos elementos GST (como nvinfer e nvdsmeta) e módulos para manipulação de MetaData (via Pybind11).

Aqui está uma visão básica de como é estruturada uma aplicação Python utilizando o DeepStream:

Exemplo de Pipeline DeepStream em Python:

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

# Inicializando GStreamer
Gst.init(None)

# Criando o pipeline do DeepStream
pipeline = Gst.Pipeline()

# Elementos do DeepStream
source = Gst.ElementFactory.make("uridecodebin", "source")
pgie = Gst.ElementFactory.make("nvinfer", "primary-inference")  # Inferência IA
tracker = Gst.ElementFactory.make("nvtracker", "tracker")  # Rastreamento de objetos
sink = Gst.ElementFactory.make("nveglglessink", "sink")  # Exibição do vídeo

# Configurando o elemento de inferência com o modelo treinado
pgie.set_property('config-file-path', 'dstest1_pgie_config.txt')

# Adicionando os elementos ao pipeline
pipeline.add(source)
pipeline.add(pgie)
pipeline.add(tracker)
pipeline.add(sink)

# Ligando os elementos
source.link(pgie)
pgie.link(tracker)
tracker.link(sink)

Manipulando MetaData com DeepStream Bindings

O DeepStream oferece acesso a MetaData, permitindo trabalhar com informações como objetos detectados, seus limites, classes de detecção, e muito mais. Para isso, utilizamos os bindings fornecidos, que são gerados com Pybind11.

Exemplo de Acesso à MetaData:

from gi.repository import Gst, GObject, GLib
import pyds  # DeepStream bindings

def osd_sink_pad_buffer_probe(pad, info, u_data):
    frame_number = 0
    # Acessando o buffer da inferência
    gst_buffer = info.get_buffer()
    if not gst_buffer:
        print("Não foi possível obter o buffer")
        return

    # Obtendo a MetaData do DeepStream
    batch_meta = pyds.gst_buffer_get_nvds_batch_meta(hash(gst_buffer))
    l_frame = batch_meta.frame_meta_list
    while l_frame is not None:
        try:
            frame_meta = pyds.NvDsFrameMeta.cast(l_frame.data)
        except StopIteration:
            break
        
        # Exemplo: Contar o número de objetos detectados em cada frame
        l_obj = frame_meta.obj_meta_list
        while l_obj is not None:
            try:
                obj_meta = pyds.NvDsObjectMeta.cast(l_obj.data)
                print(f"Objeto detectado: {obj_meta.class_id}")
            except StopIteration:
                break
            l_obj = l_obj.next
        
        l_frame = l_frame.next
    return Gst.PadProbeReturn.OK

Exemplo Completo: RTSP-in RTSP-out Pipeline

O repositório de aplicações Python do DeepStream contém exemplos como o deepstream-rtsp-in-rtsp-out, que demonstra como construir um pipeline DeepStream que recebe um fluxo de vídeo RTSP, processa a inferência e transmite o resultado novamente em RTSP.

Você pode conferir este e mais exemplos em: