Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Streamen Sie das Video in Ihren Kinesis-Videostream
Zur Ausführung der Beispielanwendung benötigen Sie die folgenden Informationen:
+ Name des Streams, der von Ihnen im Abschnitt [Voraussetzungen](producersdk-cpp-rpi-prerequisites.md) erstellt wurde.
+ Die Konto-Anmeldeinformationen (Zugriffsschlüssel-ID und geheimer Zugriffsschlüssel), die von Ihnen unter [Erstellen Sie einen IAM-Benutzer mit der Berechtigung, in Kinesis Video Streams zu schreiben](producersdk-cpp-rpi-iam.md) erstellt wurden
+ GStreamer ist in der Lage, das Plugin zu finden. `kvssink` Weitere Informationen finden Sie unter [Laden Sie das Kinesis Video Streams C\+\+ Producer SDK herunter und erstellen Sie es](producersdk-cpp-rpi-download.md).
1. Legen Sie die Anmeldeinformationen und die Region fest.
```
export AWS_ACCESS_KEY_ID={{YourAccessKey}}
export AWS_SECRET_ACCESS_KEY={{YourSecretKey}}
export AWS_DEFAULT_REGION={{us-west-2}}
```
Weitere Authentifizierungsmethoden finden Sie unter[Geben Sie Anmeldeinformationen für kvssink ein ``](examples-gstreamer-plugin-parameters.md#credentials-to-kvssink).
**Anmerkung**
Das C\+\+ Producer SDK verwendet standardmäßig die Region USA West (Oregon`us-west-2`) (). Um die Standardeinstellung zu verwenden, AWS-Region erstellen Sie Ihren Kinesis-Videostream in der Region USA West (Oregon).
Um eine andere Region für Ihren Kinesis-Videostream zu verwenden, setzen Sie die folgende Umgebungsvariable auf Ihre Region (z. B.{{us-east-1}}):
```
export AWS_DEFAULT_REGION={{us-east-1}}
```
1. Wählen Sie je nach Eingabemedium eine der folgenden Optionen aus:
------
#### [ Sample GStreamer video ]
Diese GStreamer-Pipeline generiert einen Live-Testvideostream mit einem Standardtestmuster, das mit 10 Bildern pro Sekunde und einer Auflösung von 640x480 Pixeln ausgeführt wird. Es wird ein Overlay hinzugefügt, das die aktuelle Systemzeit und das aktuelle Systemdatum anzeigt. Das Video wird dann in ein H.264 Format codiert und Keyframes werden höchstens alle 10 Bilder generiert, was zu einer Fragmentdauer (auch als Größe einer Gruppe von Bildern (GoP) bezeichnet) von 1 Sekunde resultiert. kvssink nimmt den H.264-encoded Videostream, verpackt ihn in das Matroska-Containerformat (MKV) und lädt ihn in Ihren Kinesis-Videostream hoch.
Führen Sie den folgenden Befehl aus:
```
gst-launch-1.0 -v videotestsrc is-live=true \
! video/x-raw,framerate=10/1,width=640,height=480 \
! clockoverlay time-format="%a %B %d, %Y %I:%M:%S %p" \
! x264enc bframes=0 key-int-max=10 \
! h264parse \
! kvssink stream-name="{{YourStreamName}}"
```
Um die GStreamer-Pipeline zu beenden, wählen Sie das Terminalfenster aus und drücken Sie STRG\+C. ** **
Die GStreamer-Pipeline für ein Beispielvideo sieht wie folgt aus:
------
#### [ USB web cam ]
Führen Sie den folgenden Befehl aus, damit GStreamer Ihre USB-Kamera automatisch erkennt:
```
gst-launch-1.0 autovideosrc \
! videoconvert \
! video/x-raw,format=I420,width=640,height=480 \
! x264enc bframes=0 key-int-max=45 tune=zerolatency byte-stream=true speed-preset=ultrafast \
! h264parse \
! video/x-h264,stream-format=avc,alignment=au,profile=baseline \
! kvssink stream-name="{{YourStreamname}}"
```
Um die GStreamer-Pipeline zu beenden, wählen Sie das Terminalfenster aus und drücken Sie STRG\+C. ** **
Anstatt GStreamer automatisch erkennen zu lassen, können Sie es mit einer bestimmten Geräte-ID verwenden`v4l2src`. Führen Sie den folgenden Befehl aus:
```
gst-device-monitor-1.0
```
In der Ausgabe sehen Sie einige Geräte und den Beginn einer GStreamer-Pipeline zur Verwendung des Geräts:
```
Device found:
name : H264 USB Camera: USB Camera
class : Video/Source
caps : video/x-h264, stream-format=(string)byte-stream, alignment=(string)au, width=(int)1920, height=(int)1080, pixel-aspect-ratio=(fraction)1/1, colorimetry=(string){ 2:4:7:1 }, framerate=(fraction){ 30/1, 25/1, 15/1 };
...
properties:
device.path = /dev/video4
udev-probed = false
device.api = v4l2
v4l2.device.driver = uvcvideo
v4l2.device.card = "H264\ USB\ Camera:\ USB\ Camera"
v4l2.device.bus_info = usb-3f980000.usb-1.3
v4l2.device.version = 265767 (0x00040e27)
v4l2.device.capabilities = 2216689665 (0x84200001)
v4l2.device.device_caps = 69206017 (0x04200001)
gst-launch-1.0 {{v4l2src device=/dev/video4}} ! ...
```
Um die GStreamer-Pipeline zu beenden, wählen Sie das Terminalfenster aus und drücken Sie STRG\+C. ** **
------
#### [ Raspberry Pi camera module 1 ]
Wenn Sie das Pi-Kameramodul 1 oder das Pi-Kameramodul 2 mit verwenden`bcm2835-v4l2`, verwenden Sie Folgendes:
```
gst-launch-1.0 v4l2src device=/dev/video0 \
! videoconvert \
! video/x-raw,format=I420,width=640,height=480 \
! x264enc bframes=0 key-int-max=45 bitrate=500 tune=zerolatency \
! h264parse ! video/x-h264,stream-format=avc,alignment=au,profile=baseline \
! kvssink stream-name="{{YourStreamname}}"
```
Um die GStreamer-Pipeline zu beenden, wählen Sie das Terminalfenster aus und drücken ** Sie STRG\+C. **
------
#### [ Raspberry Pi camera module 2 or 3 ]
Wenn Sie den modernen `libcamera` Stack verwenden, verwenden Sie die folgende GStreamer-Pipeline:
```
gst-launch-1.0 libcamerasrc \
! video/x-raw,width=640,height=480,framerate=30/1,format=I420 \
! videoconvert \
! x264enc speed-preset=ultrafast tune=zerolatency byte-stream=true key-int-max=75 \
! video/x-h264,level='(string)4' \
! h264parse \
! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1 \
! kvssink stream-name="{{YourStreamname}}"
```
Um die GStreamer-Pipeline zu beenden, wählen Sie das Terminalfenster aus und drücken Sie STRG\+C. ** **
------
#### [ Sample RTSP camera ]
In diesem Beispiel verwenden wir es, Gst-Rtsp-Server um einen Demo-RTSP-Kamera-Feed lokal zu hosten. Anschließend erstellen wir eine GStreamer-Pipeline, um diesen RTSP-Kamera-Feed in den angegebenen Kinesis-Videostream hochzuladen.
**Zur Einrichtung auf Ihrem Raspberry Pi Gst-Rtsp-Server **
1. Installieren Sie die notwendigen Abhängigkeitsbibliotheken, um das Gst-Rtsp-Server Projekt zu erstellen. Stellen Sie sicher, dass Sie auch die Softwarevoraussetzungen installiert haben. Geben Sie Folgendes in Ihr Terminal ein:
```
sudo apt-get update
sudo apt-get install libgstrtspserver-1.0
```
1. Laden Sie die 1.22-Version von GStreamer auf Ihren Raspberry Pi herunter.
```
git clone https://gitlab.freedesktop.org/gstreamer/gstreamer.git --single-branch -b 1.22
```
1. Wechseln Sie in das Verzeichnis examples im gst-rtsp-Server.
```
cd gstreamer
cd subprojects
cd gst-rtsp-server
cd examples
```
1. Kompilieren Sie die Datei test-launch.c mit gcc in eine ausführbare Datei namens test-launch.
```
gcc -o test-launch test-launch.c `pkg-config --cflags --libs gstreamer-rtsp-server-1.0`
```
1. Führen Sie die ausführbare Datei mit den folgenden Argumenten aus. Hinweis: Es kann einige Zeit dauern, bis GStreamer zum ersten Mal geladen wird.
```
./test-launch "videotestsrc is-live=true ! video/x-raw,height=480,width=640,framerate=10/1 ! videoconvert ! x264enc tune=zerolatency bitrate=512 key-int-max=25 bframes=0 ! h264parse ! rtph264pay ! name=pay0 pt=96"
```
Die Ausgabe sollte folgendermaßen aussehen:
```
stream ready at rtsp://127.0.0.1:8554/test
```
1. Überprüfen Sie den RTSP-Videostream. Sie können jeden RTSP-Viewer verwenden. Zum Beispiel VLC Media Player. Um Ihren Live-Stream mit dem VLC Media Player anzusehen, öffnen Sie ein neues Terminal und geben Sie Folgendes ein:
```
sudo apt-get install vlc
```
um den VLC Media Player zu installieren. Geben Sie dann Folgendes ein:
```
vlc rtsp://127.0.0.1:8554/test
```
Ein VLC-Fenster sollte mit dem Live-Stream erscheinen. Wenn nicht, überprüfen Sie, ob die ausführbare Teststartdatei noch läuft, und überprüfen Sie die Ausgabe auf Fehler.
Eine andere Möglichkeit, den RTSP-Stream zu überprüfen, ist die Verwendung des Dienstprogramms gst-discoverer-1.0. Type:
```
gst-discoverer-1.0 "rtsp://127.0.0.1:8554/test"
```
Die erwartete Ausgabe sieht wie folgt aus:
```
Analyzing rtsp://127.0.0.1:8554/test
Done discovering rtsp://127.0.0.1:8554/test
Properties:
Duration: 99:99:99.999999999
Seekable: no
Live: yes
unknown #0: application/x-rtp
video #1: H.264 (Constrained Baseline Profile)
Stream ID: 359314d7d4bba383223927d7e57d4244d0800e629c626be81c505055c62170e2/video:0:0:RTP:AVP:96
Width: 640
Height: 480
Depth: 24
Frame rate: 10/1
Pixel aspect ratio: 1/1
Interlaced: false
Bitrate: 0
Max bitrate: 0
```
**Um den RTSP-Feed mit kvssink an Ihren Kinesis-Videostream zu senden **
Diese GStreamer-Pipeline wird verwendet, um eine Verbindung `rtspsrc` zum RTSP-Server herzustellen, um den RTP-Videostream abzurufen. Sie übergibt die Frames an den`rtph264depay`, der die H.264-encoded Videoframes aus den RTP-Paketen extrahiert. `h264parse`gruppiert die Videobilder in das Format, das `kvssink` sie verstehen können. `kvssink`nimmt den H.264-encoded Videostream, packt ihn in das Matroska-Containerformat (MKV) und lädt ihn in Ihren Kinesis-Videostream hoch.
Führen Sie den folgenden Befehl aus:
```
gst-launch-1.0 -v rtspsrc location="rtsp://127.0.0.1:8554/test" short-header=true \
! rtph264depay \
! h264parse \
! video/x-h264,format=avc,alignment=au \
! kvssink stream-name="{{YourStreamName}}"
```
Um die GStreamer-Pipeline zu beenden, wählen Sie das Terminalfenster aus und drücken Sie STRG\+C. ** **
------
## Verwenden Sie Hardware
Einige Raspberry Pi-Modelle sind mit hardwarebeschleunigten H.264 Encodern ausgestattet. Sie können sie anstelle von verwenden, bei dem es sich um einen `x264enc` Software-Encoder handelt.
1. Stellen Sie sicher, dass die GStreamer-Plugins installiert sind:
```
sudo apt-get install gstreamer1.0-tools gstreamer1.0-plugins-bad
```
1. Type:
```
gst-inspect-1.0 | grep h264
```
Stellen Sie fest, ob die folgenden Elemente verfügbar sind:
+ omxh264enc
+ v4l2h264enc
Wenn sie verfügbar sind, können Sie sie verwenden. Hier sind einige Pipeline-Beispiele, die diese Elemente verwenden:
**`omxh264enc`:**
```
gst-launch-1.0 v4l2src device=/dev/video0 \
! videoconvert \
! video/x-raw,format=I420,width=640,height=480 \
! {{omxh264enc}} control-rate=2 target-bitrate=512000 periodicity-idr=45 inline-header=FALSE \
! h264parse ! video/x-h264,stream-format=avc,alignment=au,profile=baseline \
! kvssink stream-name="{{raspberry}}"
```
**`v4l2h264enc`und`v4l2convert`: **
```
gst-launch-1.0 libcamerasrc \
! video/x-raw,width=640,height=480,framerate=30/1,format=I420 \
! {{v4l2convert}} \
! {{v4l2h264enc}} extra-controls="controls,repeat_sequence_header=1" \
! video/x-h264,level='(string)4' \
! h264parse \
! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1 \
! kvssink stream-name="{{test-stream}}"
```
## Probleme mit der Laufzeit
Im Folgenden finden Sie einige häufig auftretende Laufzeitprobleme und deren Behebung.
### Kein solches Element „xxxxxxxxx“
Wenn du eine Fehlermeldung wie die folgende erhältst, bedeutet das, dass dir ein GStreamer-Plugin fehlt:
```
WARNING: erroneous pipeline: no element "videoconvert"
```
**Auflösung**
Ermitteln Sie anhand dessen, welches Element fehlt, die entsprechende Aktion:
+ `kvssink`: Siehe [Laden Sie das Kinesis Video Streams C\+\+ Producer SDK herunter und erstellen Sie es](producersdk-cpp-rpi-download.md).
+ `libcamerasrc`: Siehe So [Fehler „Die Aktivierung des Pufferpools ist fehlgeschlagen“](#rpi-troubleshoot-buffer) installieren Sie das `libcamerasrc` GStreamer-Element.
+ `omxh264enc`oder: `v4l2h264enc`
Folgen Sie [Installieren Sie die Softwarevoraussetzungen](producersdk-cpp-rpi-software.md) den Anweisungen, um alle GStreamer-Bibliotheken zu installieren. Wenn Sie sie alle installiert haben und diese Elemente nicht angezeigt werden, bedeutet das, dass Ihr Raspberry Pi nicht über die entsprechende Hardware verfügt. Verwenden Sie `x264enc` stattdessen den Software-Encoder.
+ Sonstiges: Folgen Sie[Installieren Sie die Softwarevoraussetzungen](producersdk-cpp-rpi-software.md), um alle GStreamer-Bibliotheken zu installieren. Verschiedene GStreamer-Elemente befinden sich in den verschiedenen GStreamer-Plugin-Gruppen (gut, schlecht, hässlich). Stellen Sie also sicher, dass Sie sie alle installieren.
### Fehler „Die Aktivierung des Pufferpools ist fehlgeschlagen“
Wenn Sie einen Fehler wie den folgenden erhalten, bedeutet dies, dass die verwendete Pipeline verwendet wird`v4l2src`, aber `libcamerasrc` stattdessen sollte sie verwendet werden.
```
ERROR bufferpool gstbufferpool.c:572:gst_buffer_pool_set_active:source:pool0:src start failed
WARN v4l2src gstv4l2src.c:976:gst_v4l2src_decide_allocation: error: Failed to allocate required memory.
WARN v4l2src gstv4l2src.c:976:gst_v4l2src_decide_allocation: error: Buffer pool activation failed
WARN basesrc gstbasesrc.c:3352:gst_base_src_prepare_allocation: Subclass failed to decide allocation
Error received from element source: Failed to allocate required memory.
WARN basesrc gstbasesrc.c:3132:gst_base_src_loop: error: Internal data stream error.
Debugging information: ../sys/v4l2/gstv4l2src.c(976): gst_v4l2src_decide_allocation (): /GstPipeline:live-kinesis-pipeline/GstV4l2Src:source:
Buffer pool activation failed
WARN basesrc gstbasesrc.c:3132:gst_base_src_loop: error: streaming stopped, reason not-negotiated (-4)
```
Wenn Sie beispielsweise die folgende Pipeline verwenden, bei der das Kameramodul 2 nicht `libcamerasrc` installiert ist, kann dieser Fehler auftreten, wenn GStreamer versucht, automatisch zu erkennen, welche Elemente verwendet werden sollen.
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
**Auflösung**
Vergewissern Sie sich, dass das Programm installiert `libcamerasrc` ist, und verwenden Sie es als Quellelement und nicht. `v4l2src` Geben Sie Folgendes ein, um das `libcamerasrc` GStreamer-Element zu installieren:
```
sudo apt-get update
sudo apt-get install gstreamer1.0-libcamera
```
Sobald `libcamerasrc` das Element installiert ist und Sie das `autovideosrc` Element verwenden, sollte GStreamer automatisch auf die richtige Quelle umschalten. `libcamerasrc` `v4l2src`
### Busfehler
Wenn Sie kurz nach dem Start einen Busfehler erhalten `kvssink` (normalerweise etwa zu dem Zeitpunkt, zu dem der HTTP-Aufruf `PutMedia` abgeschlossen ist), bedeutet das, dass Ihr Raspberry Pi keinen unausgerichteten Speicherzugriff unterstützt. Die Protokolle werden wie folgt aussehen:
```
INFO Camera camera.cpp:1197 configuring streams: (0) 640x480-YUV420
INFO RPI pisp.cpp:1450 Sensor: /base/axi/pcie@120000/rp1/i2c@88000/imx708@1a - Selected sensor format: 1536x864-SBGGR10_1X10 - Selected CFE format: 1536x864-PC1B
[INFO ] kinesisVideoStreamFormatChanged(): Stream format changed.
[DEBUG] setRequestHeader(): Appending header to request: user-agent -> AWS-SDK-KVS-CPP-CLIENT/3.4.2/1.5.3 GCC/12.2.0 Linux/6.6.51+rpt-rpi-v8 aarch64 CPPSDK
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-stream-name -> demo-stream
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-producer-start-timestamp -> 1732012345.678
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-fragment-acknowledgment-required -> 1
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-fragment-timecode-type -> ABSOLUTE
[DEBUG] setRequestHeader(): Appending header to request: transfer-encoding -> chunked
[DEBUG] setRequestHeader(): Appending header to request: connection -> keep-alive
[INFO ] putStreamResultEvent(): Put stream result event. New upload handle 0
[WARN ] notifyDataAvailable(): [demo-stream] Failed to un-pause curl with error: 43. Curl object 0xe2f6f418
Bus error
```
Kinesis Video Streams PIC verwendet unabgestimmten Speicherzugriff, um die Speichernutzung zu optimieren. Dies wird nicht von allen Geräten unterstützt.
**Auflösung**
Um das SDK im angepassten Speicherzugriffsmodus zu verwenden, müssen Sie das `ALIGNED_MEMORY_MODEL` CMake-Flag `ON` beim Kompilieren explizit auf setzen`kvssink`, da es standardmäßig auf ist. `OFF` Eine detailliertere [Laden Sie das Kinesis Video Streams C\+\+ Producer SDK herunter und erstellen Sie es](producersdk-cpp-rpi-download.md) Anleitung finden Sie unter.
### Timestamp friert ein und die Pipeline kommt zum Stillstand
Bei `x264enc` der Verwendung in einer GStreamer-Pipeline können Situationen auftreten, in denen sich die Zeitleiste der Pipeline erheblich verlangsamt oder innerhalb weniger Sekunden vollständig zum Stillstand kommt.
Dies liegt daran, dass die `x264enc` Standardeinstellungen zu einer hohen Kodierungslatenz führen können, die die Kapazität des Standard-Eingabepuffers übersteigt. Infolgedessen füllt sich der Eingabepuffer, was dazu führt, dass Upstream-Elemente blockiert werden und die Pipeline zum Stillstand kommt.
Weitere Informationen finden Sie in der [ GStreamer-Dokumentation. ](https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c)
**Auflösung**
Konfigurieren Sie `x264enc` mit der `zerolatency` Tuning-Option. Dies reduziert die Codierungslatenz erheblich, indem es für Echtzeitszenarien optimiert wird und sicherstellt, dass Frames schneller verarbeitet und ausgegeben werden.
Beispielkonfiguration:
```
... ! x264enc {{tune=zerolatency}} byte-stream=true speed-preset=ultrafast bframes=0 key-int-max=60 ! ...
```
**Anmerkung**
Diese Lösung verhindert zwar effektiv das Stoppen der Pipeline, kann sich jedoch auf die Effizienz und Qualität der Codierung auswirken. Für Szenarien, die sowohl eine niedrige Latenz als auch eine hohe Qualität erfordern, sollten Sie alternative Herangehensweisen in Betracht ziehen, z. B. die Verwendung von Hardwareoptimierungen oder die Suche nach einer Webcam, die H.264 direkt ausgibt, wobei dieser Codierungsschritt übersprungen wird.
Weitere Informationen finden Sie unter [Verwenden Sie Hardware](#producersdk-cpp-rpi-utilize).
### Es können nicht mehrere Pipelines gleichzeitig von demselben `` v4l2-Gerät aus ausgeführt werden
Auf Geräte wie `/dev/video0` kann jeweils nur von einem Prozess zugegriffen werden. Wenn mehrere Prozesse gleichzeitig versuchen, darauf zuzugreifen, wartet der zweite Prozess, bis der erste abgeschlossen ist.
**Auflösung**
Erstellen Sie ein Loopback-Gerät, das es mehreren Prozessen ermöglicht, die Loopback-Schnittstelle gleichzeitig zu verwenden. Weitere Informationen finden Sie unter Stack Exchange. [https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897](https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897)
### Interner Datenstromfehler
Wenn Sie eine GStreamer-Pipeline erstellen, verbinden Sie Elemente, indem Sie das Quell-Pad eines Elements mit dem Sink-Pad eines anderen Elements verknüpfen. Dieser Verbindungsprozess ermöglicht den Datenfluss vom Quellelement zum Senkenelement und bildet so eine Datenpipeline.
Die Fehlermeldung „Pad link failed“ im Protokoll weist darauf hin, dass GStreamer beim Versuch, eine Verbindung (Link) zwischen den Pads zweier Elemente in Ihrer Pipeline herzustellen, auf ein Problem gestoßen ist.
```
Pad link failed
Error received from element udpsrc0: Internal data stream error.
```
**Auflösung**
Stellen Sie fest, welche Elemente nicht miteinander verknüpft werden können. Um den Umfang der Pipeline einzugrenzen, entfernen Sie Elemente aus der Pipeline. Ersetzen Sie das Element ganz rechts durch Elemente `fakesink` und entfernen Sie sie nacheinander.
Möglicherweise müssen Sie die [https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c](https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c) Capsfilter-Elemente anpassen und and/or ändern, welche Elemente Ihre Pipeline verwendet.
In den meisten Fällen wird nach einem `framerate` oder gefragt, was `resolution` die Kamera nicht unterstützt. Verwenden Sie es `gst-device-monitor-1.0` im Terminal, um das unterstützte `framerates``resolutions`, und abzurufen`formats`. Sie können das [ Videoscale ](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoscale.html?gi-language=c) GStreamer-Element verwenden, um die Videoauflösung anzupassen, und [ videorate, ](https://gstreamer.freedesktop.org/documentation/videorate/?gi-language=c) um die Videobildrate anzupassen.
Geben Sie im Terminal ein, um die unterstützten Formate für ein einzelnes GStreamer-Element zu überprüfen. `gst-inspect-1.0 element-name`