Diffusez de la vidéo sur votre flux vidéo Kinesis - Amazon Kinesis Video Streams
Utiliser du matérielProblèmes d'exécution

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Diffusez de la vidéo sur votre flux vidéo Kinesis

Pour exécuter cet exemple d'application, vous avez besoin des informations suivantes :

  1. Définissez les informations d'identification et la région.

    export AWS_ACCESS_KEY_ID=YourAccessKey
export AWS_SECRET_ACCESS_KEY=YourSecretKey
export AWS_DEFAULT_REGION=us-west-2

    Pour les autres méthodes d'authentification, consultezFournissez des informations d'identification à kvssink.

    Note

    Le SDK C++ Producer utilise par défaut la région USA Ouest (Oregonus-west-2) (). Pour utiliser la valeur par défaut, Région AWS créez votre flux vidéo Kinesis dans la région de l'ouest des États-Unis (Oregon).

    Pour utiliser une autre région pour votre flux vidéo Kinesis, définissez la variable d'environnement suivante sur votre région (par exemple,us-east-1) :

    export AWS_DEFAULT_REGION=us-east-1

  2. En fonction de votre support d'entrée, choisissez l'une des options suivantes :

    Sample GStreamer video

    Ce GStreamer pipeline génère un flux vidéo de test en direct avec un modèle de test standard qui s'exécute à 10 images par seconde avec une résolution de 640 x 480 pixels. Une superposition est ajoutée pour afficher l'heure et la date actuelles du système. La vidéo est ensuite encodée au format H.264 et des images-clés sont générées au maximum toutes les 10 images, ce qui se traduit par une durée de fragment (également appelée taille d'un groupe d'images (GoP)) de 1 seconde. kvssink prend le flux vidéo encodé en H.264, le conditionne dans le format conteneur Matroska (MKV) et le télécharge sur votre flux vidéo Kinesis.

    Exécutez la commande suivante :

    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"

    Pour arrêter le GStreamer pipeline, sélectionnez la fenêtre du terminal et appuyez sur CTRL+C.

    L'exemple de GStreamer pipeline vidéo ressemble à ceci :

    Image du modèle de test standard avec horodatage superposé.
    USB web cam

    Exécutez la commande suivante pour GStreamer détecter automatiquement votre caméra USB :

    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"

    Pour arrêter le GStreamer pipeline, sélectionnez la fenêtre du terminal et appuyez sur CTRL+C.

    Plutôt que de laisser la GStreamer détection automatique, vous pouvez utiliser v4l2src un identifiant d'appareil spécifique. Exécutez la commande suivante :

    gst-device-monitor-1.0

    Dans le résultat, vous verrez certains appareils et le début d'un GStreamer pipeline expliquant comment utiliser l'appareil :

    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 ! ...

    Pour arrêter le GStreamer pipeline, sélectionnez la fenêtre du terminal et appuyez sur CTRL+C.

    Raspberry Pi camera module 1

    Si vous utilisez le module de caméra Pi 1 ou le module de caméra Pi 2 avecbcm2835-v4l2, utilisez ce qui suit :

    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"

    Pour arrêter le GStreamer pipeline, sélectionnez la fenêtre du terminal et appuyez sur CTRL+C.

    Raspberry Pi camera module 2 or 3

    Si vous utilisez la libcamera pile moderne, utilisez le GStreamer pipeline suivant :

    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"

    Pour arrêter le GStreamer pipeline, sélectionnez la fenêtre du terminal et appuyez sur CTRL+C.

    Sample RTSP camera

    Dans cet exemple, nous hébergeons Gst-Rtsp-Server localement un flux de caméra RTSP de démonstration. Nous construisons ensuite un GStreamer pipeline pour télécharger ce flux de caméra RTSP vers le flux vidéo Kinesis spécifié.

    À configurer Gst-Rtsp-Server sur votre Raspberry Pi

    1. Installez les bibliothèques de dépendances nécessaires pour créer le Gst-Rtsp-Server projet. Assurez-vous que les prérequis logiciels sont également installés. Tapez ce qui suit dans votre terminal :

      sudo apt-get update
sudo apt-get install libgstrtspserver-1.0

    2. Téléchargez la version 1.22 de GStreamer sur votre Raspberry Pi.

      git clone https://gitlab.freedesktop.org/gstreamer/gstreamer.git --single-branch -b 1.22

    3. Remplacez les répertoires par le répertoire des exemples dans le gst-rtsp-server.

      cd gstreamer
cd subprojects
cd gst-rtsp-server
cd examples

    4. Compilez le fichier test-launch.c dans un exécutable appelé test-launch en utilisant gcc.

      gcc -o test-launch test-launch.c `pkg-config --cflags --libs gstreamer-rtsp-server-1.0`

    5. Exécutez le fichier exécutable avec les arguments suivants. Remarque : le premier chargement GStreamer peut prendre un certain temps.

      ./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"

      Vous devriez voir la sortie suivante :

      stream ready at rtsp://127.0.0.1:8554/test

    6. Vérifiez le flux vidéo RTSP. Vous pouvez utiliser n'importe quel visualiseur RTSP. Par exemple, le lecteur multimédia VLC. Pour utiliser le lecteur multimédia VLC pour visionner votre diffusion en direct, ouvrez un nouveau terminal et tapez :

      sudo apt-get install vlc

      pour installer le lecteur multimédia VLC. Tapez ensuite :

      vlc rtsp://127.0.0.1:8554/test

      Une fenêtre VLC devrait apparaître avec le flux en direct. Si ce n'est pas le cas, vérifiez que le fichier exécutable de lancement du test est toujours en cours d'exécution et vérifiez qu'il n'y a pas d'erreur dans le résultat.

      Une autre méthode pour vérifier le flux RTSP consiste à utiliser l'utilitaire gst-discoverer-1.0. Type:

      gst-discoverer-1.0 "rtsp://127.0.0.1:8554/test"

      Le résultat attendu ressemble à ceci :

      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

    Pour envoyer le flux RTSP vers votre flux vidéo Kinesis à l'aide de kvssink

    Ce GStreamer pipeline est utilisé rtspsrc pour se connecter au serveur RTSP afin de récupérer le flux vidéo RTP. Il transmet les images aurtph264depay, qui extrait les images vidéo codées H.264 des paquets RTP. h264parseregroupe les images vidéo dans le format que je kvssink peux comprendre. kvssinkprend le flux vidéo encodé H.264, l'empaquette dans le format conteneur Matroska (MKV) et le télécharge sur votre flux vidéo Kinesis.

    Exécutez la commande suivante :

    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"

    Pour arrêter le GStreamer pipeline, sélectionnez la fenêtre du terminal et appuyez sur CTRL+C.

Utiliser du matériel

Certains modèles de Raspberry Pi sont équipés d'encodeurs H.264 accélérés par matériel. Vous pouvez les utiliser à la place x264enc d'un encodeur logiciel.

  1. Assurez-vous que les GStreamer plugins sont installés :

    sudo apt-get install gstreamer1.0-tools gstreamer1.0-plugins-bad

  2. Type:

    gst-inspect-1.0 | grep h264

    Déterminez si les éléments suivants sont disponibles :

    • omxh264enc

    • v4l2h264enc

    S'ils sont disponibles, vous pouvez les utiliser. Voici quelques exemples de pipelines utilisant ces éléments :

    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"

    v4l2h264encet 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"

Problèmes d'exécution

Vous trouverez ci-dessous certains problèmes d'exécution fréquemment rencontrés et la manière de les résoudre.

Aucun élément de ce type « xxxxxxxxx »

Si vous recevez un message d'erreur comme celui-ci, cela signifie qu'il vous manque un GStreamer plugin :

WARNING: erroneous pipeline: no element "videoconvert"

Résolution :

En fonction de l'élément manquant, déterminez l'action appropriée :

Erreur « Échec de l'activation du pool de mémoire tampon »

Si vous recevez une erreur comme celle-ci, cela signifie que le pipeline utilisé est en cours d'utilisationv4l2src, mais qu'il devrait l'utiliser à la libcamerasrc place.

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)

Par exemple, si vous utilisez le pipeline suivant alors que le module de caméra 2 n' GStreamer est pas libcamerasrc installé, vous risquez de rencontrer cette erreur lorsque vous essayez de détecter automatiquement les éléments à utiliser.

gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink

Résolution :

Assurez-vous qu'il libcamerasrc est installé et utilisez-le comme élément source, plutôt quev4l2src. Tapez ce qui suit pour installer l'libcamerasrc GStreamer élément :

sudo apt-get update
sudo apt-get install gstreamer1.0-libcamera

Une fois libcamerasrc installé, si vous utilisez l'autovideosrcélément, vous GStreamer devriez automatiquement passer à la bonne source libcamerasrc au lieu dev4l2src.

Erreur de bus

Si vous recevez une erreur de bus peu après le démarrage kvssink (généralement, au moment où l'appel HTTP est PutMedia terminé), cela signifie que votre Raspberry Pi ne prend pas en charge l'accès à la mémoire non aligné. Les journaux ressembleront à ce qui suit :

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 utilise un accès mémoire non aligné pour optimiser l'utilisation de la mémoire, ce qui n'est pas pris en charge par tous les appareils.

Résolution :

Pour utiliser le SDK en mode d'accès à la mémoire aligné, vous devez définir explicitement l'ALIGNED_MEMORY_MODEL CMake indicateur sur ON lors de la compilationkvssink, car il est défini par défaut sur. OFF Voir Téléchargez et créez le SDK Kinesis Video Streams C++ pour le producteur pour des instructions plus détaillées.

L'horodatage se bloque et le pipeline s'arrête

Lors de l'utilisation x264enc dans un GStreamer pipeline, vous pouvez rencontrer des situations où la chronologie du pipeline ralentit considérablement ou s'arrête complètement en quelques secondes.

Cela se produit parce que les paramètres x264enc par défaut peuvent introduire une latence de codage élevée, qui dépasse la capacité de la mémoire tampon d'entrée par défaut. Par conséquent, la mémoire tampon d'entrée se remplit, ce qui provoque le blocage des éléments en amont et le blocage du pipeline.

Pour plus d’informations, consultez la documentation GStreamer .

Résolution :

Configurez x264enc avec l'option de zerolatency réglage. Cela réduit considérablement la latence d'encodage en optimisant les scénarios en temps réel, garantissant ainsi un traitement et une sortie plus rapides des images.

Exemple de configuration :

... ! x264enc tune=zerolatency byte-stream=true speed-preset=ultrafast bframes=0 key-int-max=60 ! ...
Note

Bien que cette solution empêche efficacement le blocage du pipeline, elle peut avoir un impact sur l'efficacité et la qualité de l'encodage. Pour les scénarios nécessitant à la fois une faible latence et une haute qualité, envisagez d'autres approches, telles que l'utilisation d'optimisations matérielles ou la recherche d'une webcam produisant directement du H.264, en sautant cette étape de codage.

Pour de plus amples informations, veuillez consulter Utiliser du matériel.

Impossible d'exécuter plusieurs pipelines à partir du même v4l2 appareil en même temps

Les appareils tels que /dev/video0 ceux-ci ne sont accessibles que par un seul processus à la fois. Si plusieurs processus tentent d'y accéder en même temps, le second attend que le premier soit terminé.

Résolution :

Créez un dispositif de bouclage permettant à plusieurs processus d'utiliser l'interface de bouclage en même temps. Pour plus d'informations, consultez Stack Exchange.

Erreur de flux de données interne

Lorsque vous créez un GStreamer pipeline, vous connectez des éléments en reliant le bloc source d'un élément au bloc récepteur d'un autre élément. Ce processus de liaison permet le flux de données de l'élément source vers l'élément récepteur, formant ainsi un pipeline de données.

Le message d'erreur « La connexion au pad a échoué » dans le journal indique qu'un problème GStreamer a été rencontré lors de la tentative d'établissement d'une connexion (lien) entre les pads de deux éléments de votre pipeline.

Pad link failed
Error received from element udpsrc0: Internal data stream error.

Résolution :

Déterminez quels éléments ne sont pas liés les uns aux autres. Pour réduire la portée du pipeline, supprimez des éléments du pipeline. Remplacez l'élément le plus à droite par fakesink des éléments et supprimez-les un par un.

Vous devrez peut-être ajuster les éléments capsfilter, and/or modifier les éléments utilisés par votre pipeline.

Les cas courants demandent un framerate ou resolution que l'appareil photo ne prend pas en charge. gst-device-monitor-1.0À utiliser dans le terminal pour obtenir les valeurs prises en charge frameratesresolutions, etformats. Vous pouvez utiliser l' GStreamer élément Videoscale pour régler la résolution vidéo et Videorate pour ajuster la fréquence d'images vidéo.

Pour vérifier les formats pris en charge pour un GStreamer élément individuel, saisissez gst-inspect-1.0 element-name le terminal.