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.
# Utiliser le SDK du producteur C\$1\$1 sur le Raspberry Pi
Le Raspberry Pi est un petit ordinateur peu onéreux qui peut être utilisé pour enseigner et apprendre des compétences élémentaires de programmation d'ordinateur. Ce didacticiel explique comment configurer et utiliser le SDK de production Amazon Kinesis Video Streams C\$1\$1 sur un appareil Raspberry Pi. Les étapes incluent également comment vérifier l'installation à l'aide de l'application de GStreamer démonstration.
**Topics**
+ [Conditions préalables](producersdk-cpp-rpi-prerequisites.md)
+ [Création d'un utilisateur IAM autorisé à écrire sur Kinesis Video Streams](producersdk-cpp-rpi-iam.md)
+ [Connectez votre Raspberry Pi à votre réseau Wi-Fi](producersdk-cpp-rpi-wifi.md)
+ [Connectez-vous à distance à votre Raspberry Pi](producersdk-cpp-rpi-connect.md)
+ [Configuration de la caméra Raspberry Pi](producersdk-cpp-rpi-camera.md)
+ [Installation des prérequis logiciels](producersdk-cpp-rpi-software.md)
+ [Téléchargez et créez le SDK Kinesis Video Streams C\$1\$1 pour le producteur](producersdk-cpp-rpi-download.md)
+ [Diffusez de la vidéo sur votre flux vidéo Kinesis](producersdk-cpp-rpi-run.md)
+ [Lire le contenu multimédia de votre flux vidéo Kinesis](producersdk-cpp-rpi-playback.md)
+ [Résolution des problèmes de compilation sur le SDK C\$1\$1 Producer pour Raspberry Pi](troubleshoot-rpi.md)
# Conditions préalables
Avant de configurer le SDK du producteur C\$1\$1 sur votre Raspberry Pi, assurez-vous de remplir les conditions préalables suivantes :
+ Un appareil Raspberry Pi doté de la configuration suivante :
+ Version de carte : Modèle 3 B ou version ultérieure.
+ Un [module de caméra](https://www.raspberrypi.com/documentation/accessories/camera.html) connecté ou une caméra USB connectée (webcam).
+ Une carte SD d'une capacité d'au moins 8 Go.
+ Le système d'exploitation Raspbian (version de noyau 4.9 ou ultérieure) installé. Vous pouvez télécharger la dernière image du système d'exploitation Raspberry Pi (précédemment appelé Raspbian) sur le [site Web du Raspberry Pi](https://www.raspberrypi.com/software/). Suivez les instructions de Raspberry Pi pour [installer l'image téléchargée sur une carte SD](https://www.raspberrypi.com/documentation/computers/getting-started.html#install-an-operating-system).
+ Et Compte AWS avec un flux vidéo Kinesis. Pour plus d'informations, consultez [Démarrez avec Flux vidéo Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html).
# Création d'un utilisateur IAM autorisé à écrire sur Kinesis Video Streams
Si ce n'est pas déjà fait, configurez un utilisateur Gestion des identités et des accès AWS (IAM) autorisé à écrire sur un flux vidéo Kinesis.
Ces procédures ont pour but de vous aider à commencer rapidement à utiliser une paire de clés d' AWS accès. Les appareils peuvent utiliser des certificats X.509 pour se connecter à AWS IoT. Consultez [Contrôle de l'accès aux ressources Kinesis Video Streams à l'aide de AWS IoT](how-iot.md) pour plus d'informations sur la configuration de votre appareil pour utiliser l'authentification basée sur des certificats.
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Dans le menu de navigation de gauche, choisissez **Utilisateurs**.
1. Pour créer un nouvel utilisateur, choisissez **Add user** (Ajouter un utilisateur).
1. Choisissez un **nom d'utilisateur** descriptif pour l'utilisateur, par exemple **kinesis-video-raspberry-pi-producer**.
1. Sous **Access type** (Type d'accès), choisissez **Programmatic access** (Accès par programme).
1. Choisissez **Suivant : Autorisations**.
1. Sous **Définir les autorisations pour kinesis-video-raspberry-pi -producer**, choisissez **Joindre directement les politiques existantes**.
1. Choisissez **Create Policy** (Créer une politique). La page **Create policy** (Créer la stratégie) s'ouvre dans un nouvel onglet du navigateur web.
1. Choisissez l’onglet **JSON**.
1. Copiez la stratégie JSON suivante et collez-la dans la zone de texte. Cette politique autorise votre utilisateur à créer et à écrire des données dans les flux vidéo Kinesis.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:CreateStream",
"kinesisvideo:GetDataEndpoint",
"kinesisvideo:PutMedia"
],
"Resource": [
"*"
]
}]
}
```
------
1. Choisissez **Examiner une politique**.
1. Attribuez un **nom** à votre stratégie, par exemple **kinesis-video-stream-write-policy**.
1. Choisissez **Create Policy** (Créer une politique).
1. Revenez à l'onglet **Add user** (Ajouter un utilisateur) dans votre navigateur, puis choisissez **Refresh** (Actualiser).
1. Dans la zone de recherche, saisissez le nom de la stratégie que vous avez créée.
1. Cochez la case en regard de la nouvelle stratégie dans la liste.
1. Choisissez **Next: Review (Suivant : Vérification)**.
1. Choisissez **Create user**.
1. La console affiche l'**ID de clé d'accès** pour votre nouvel utilisateur. Choisissez **Afficher** pour afficher la **clé d'accès secrète**. Enregistrez ces valeurs ; elles sont nécessaires lorsque vous configurez l'application.
# Connectez votre Raspberry Pi à votre réseau Wi-Fi
Si vous utilisez un clavier et un moniteur connectés, passez à [Configuration de la caméra Raspberry Pi](producersdk-cpp-rpi-camera.md).
Ces instructions sont écrites pour vous aider à configurer votre Raspberry Pi lorsqu'il est exécuté en mode *headless*, c'est-à-dire sans clavier, moniteur ou câble réseau connecté. Suivez les instructions ci-dessous pour configurer votre Raspberry Pi afin qu'il tente automatiquement de se connecter au réseau spécifié, permettant ainsi à votre machine hôte de s'y connecter par SSH.
1. Sur votre ordinateur, créez un dossier nommé `wpa_supplicant.conf`.
1. Copiez le texte suivant et collez-le dans le `wpa_supplicant.conf` fichier :
```
country=US
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid="Your Wi-Fi SSID"
scan_ssid=1
key_mgmt=WPA-PSK
psk="Your Wi-Fi Password"
}
```
Remplacez les valeurs `ssid` et `psk` par les informations relatives à votre réseau Wi-Fi.
1. Copiez le fichier `wpa_supplicant.conf` dans la carte SD. Il doit être copié à la racine du volume `boot`.
1. Insérez la carte SD dans l'appareil Raspberry Pi et allumez ce dernier. Il accède à votre réseau Wi-Fi et la fonctionnalité SSH est activée.
# Connectez-vous à distance à votre Raspberry Pi
Si vous utilisez un clavier et un moniteur connectés, passez à [Configuration de la caméra Raspberry Pi](producersdk-cpp-rpi-camera.md).
Ces instructions sont écrites pour vous aider à configurer votre Raspberry Pi lorsqu'il est exécuté en mode *headless*, c'est-à-dire sans clavier, moniteur ou câble réseau connecté. Suivez les instructions ci-dessous pour localiser votre Raspberry Pi sur votre réseau et y accéder par SSH depuis votre machine hôte.
1. Avant de vous connecter à distance à votre appareil Raspberry Pi, effectuez l'une des actions suivantes pour déterminer son adresse IP :
+ Si vous avez accès au routeur Wi-Fi de votre réseau, regardez les appareils Wi-Fi connectés. Recherchez l'appareil nommé `Raspberry Pi` pour trouver l'adresse IP de votre appareil.
+ Si vous n'avez pas accès au routeur Wi-Fi de votre réseau, vous pouvez utiliser d'autres logiciels pour trouver les appareils sur votre réseau. [Fing](https://www.fing.com/) est une application populaire disponible à la fois pour les appareils Android et iOS. Vous pouvez utiliser la version gratuite de cette application pour trouver les adresses IP des appareils figurant sur votre réseau.
1. Lorsque vous connaissez l'adresse IP de l'appareil Raspberry Pi, vous pouvez utiliser n'importe quelle application de terminal pour vous connecter.
+ Sur macOS ou Linux, utilisez `ssh` :
```
ssh pi@
```
+ Sur Windows, utilisez [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), un client SSH gratuit pour Windows.
Pour une nouvelle installation de Raspbian, le nom d'utilisateur est **pi** et le mot de passe est **raspberry**. Nous vous recommandons de [changer le mot de passe par défaut](https://www.raspberrypi.com/documentation/computers/configuration.html#change-user-password-nonint).
# Configuration de la caméra Raspberry Pi
Procédez comme suit pour configurer le [module de caméra Raspberry Pi](https://www.raspberrypi.com/documentation/accessories/camera.html) afin qu'il envoie de la vidéo depuis l'appareil vers un flux vidéo Kinesis.
**Note**
Si vous utilisez une webcam USB, passez directement à[Installation des prérequis logiciels](producersdk-cpp-rpi-software.md).
------
#### [ Camera module 1 ]
Suivez ces instructions pour mettre à jour le fichier des modules, activer l'interface de la caméra et vérifier le fonctionnement de votre caméra. La mise à jour du fichier de modules indique au Raspberry Pi quels modules du noyau charger au moment du démarrage. Le pilote de caméra n'est pas chargé par défaut afin de préserver les ressources du système sur les appareils Raspberry Pi qui n'utilisent pas de caméra.
1. Ouvrez un éditeur pour apporter des modifications au fichier des modules. Ouvrez le terminal et utilisez la commande suivante pour modifier le fichier à l'aide de l'`nano`éditeur :
```
sudo nano /etc/modules
```
1. Ajoutez la ligne suivante à la fin du fichier, si ce n'est pas déjà fait :
```
bcm2835-v4l2
```
1. Enregistrez le fichier et quittez l'éditeur. Pour enregistrer et quitter à l'aide de l'`nano`éditeur, utilisez Ctrl\$1X.
1. Redémarrez l'appareil Raspberry Pi :
```
sudo reboot
```
1. Lorsque l'appareil redémarre, connectez-vous y à nouveau par le biais de votre application de terminal si vous vous connectez à distance.
1. Ouvrir `raspi-config`:
```
sudo raspi-config
```
1. Choisissez **Options d'interfaçage**, **Legacy Camera**. **Dans les anciennes versions du système d'exploitation Raspbian, cette option de menu peut se trouver sous **Options d'interfaçage, Caméra**.**
Activez la caméra si elle n'est pas déjà activée, et redémarrez si vous y êtes invité.
1. Vérifiez que la caméra fonctionne en tapant la commande suivante :
```
raspistill -v -o test.jpg
```
Si votre appareil photo est correctement configuré, cette commande capture une image depuis l'appareil photo, l'enregistre dans un fichier nommé `test.jpg` et affiche des messages d'information.
------
#### [ Camera module 2 or 3 ]
Si vous utilisez un module de caméra 2, vous utilisez soit `bcm2835-v4l2` (ancien) soit `libcamera` (moderne). Cependant, la `libcamera` pile est recommandée pour un meilleur support et de meilleures fonctionnalités. Suivez les étapes ci-dessous pour vérifier que cela `libcamera` se trouve up-to-date sur votre système.
1. [libcamera](https://www.raspberrypi.com/documentation/computers/camera_software.html#libcamera) devrait être préinstallé sur votre Raspberry Pi. Vérifiez les mises à jour et mettez à jour la dernière version pour les corrections de bogues et les mises à jour de sécurité. Ouvrez le terminal et saisissez les commandes suivantes :
```
sudo apt-get update
sudo apt-get upgrade
```
1. Redémarrez votre système pour que les mises à jour prennent effet.
```
sudo reboot
```
1. Testez votre appareil photo. Cette application lance un flux d'aperçu de la caméra et l'affiche à l'écran.
```
libcamera-hello
```
Si vous rencontrez des problèmes avec votre module de caméra, consultez la [documentation du Raspberry Pi](https://raspberrypi.com/documentation/computers/camera_software.html#troubleshooting) pour le dépannage.
------
# Installation des prérequis logiciels
Le SDK C\$1\$1 Producer nécessite que vous installiez les prérequis logiciels suivants sur le Raspberry Pi.
1. Mettez à jour la liste des packages et installez les bibliothèques nécessaires à la création du SDK. Ouvrez le terminal et saisissez les commandes suivantes :
```
sudo apt-get update
sudo apt-get install -y \
automake \
build-essential \
cmake \
git \
gstreamer1.0-plugins-base-apps \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-ugly \
gstreamer1.0-tools \
gstreamer1.0-omx-generic \
libcurl4-openssl-dev \
libgstreamer1.0-dev \
libgstreamer-plugins-base1.0-dev \
liblog4cplus-dev \
libssl-dev \
pkg-config
```
1. Si vous utilisez la `libcamera` pile, installez également le `libcamerasrc` GStreamer plugin. Ce GStreamer plugin n'est pas installé par défaut.
```
sudo apt-get install gstreamer1.0-libcamera
```
1. Copiez le fichier PEM suivant dans `/etc/ssl/cert.pem`:
```
sudo curl https://www.amazontrust.com/repository/AmazonRootCA1.pem -o /etc/ssl/AmazonRootCA1.pem
sudo chmod 644 /etc/ssl/AmazonRootCA1.pem
```
# Téléchargez et créez le SDK Kinesis Video Streams C\$1\$1 pour le producteur
Suivez les procédures ci-dessous pour télécharger et créer le SDK [Kinesis Video Streams C\$1\$1 Producer](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp). Assurez-vous d'avoir installé les prérequis logiciels ; consultez [Installation des prérequis logiciels](producersdk-cpp-rpi-software.md) ces étapes.
1. Accédez au répertoire de téléchargement. Ouvrez un terminal et accédez à votre répertoire de téléchargement préféré.
Par exemple :
```
cd ~/Downloads
```
1. Clonez le référentiel du SDK. Utilisez la `git clone` commande pour télécharger le SDK depuis le GitHub référentiel. Type :
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git --single-branch -b master kvs-producer-sdk-cpp
```
Cette commande ne clone qu'une seule branche (la `master` branche), réduisant ainsi la taille et la durée du téléchargement. Il place également le contenu téléchargé dans un dossier appelé `kvs-producer-sdk-cpp` dans le répertoire actuel.
1. Vérifiez le téléchargement. Une fois le processus de clonage terminé, listez le contenu du `kvs-producer-sdk-cpp` dossier pour vérifier que le SDK a été téléchargé.
```
ls kvs-producer-sdk-cpp
```
1. Préparez un répertoire de compilation. Type :
```
mkdir -p kvs-producer-sdk-cpp/build
cd kvs-producer-sdk-cpp/build
```
1. Configurez le build. Exécutez la `cmake` commande suivante pour configurer l'environnement de génération avec des options spécifiques :
```
cmake .. -DBUILD_GSTREAMER_PLUGIN=ON -DBUILD_DEPENDENCIES=OFF -DALIGNED_MEMORY_MODEL=ON
```
[CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html)utilise les options suivantes pour générer le fichier approprié `Makefiles` :
+ Utiliser le dossier du projet (`..`) comme répertoire source.
+ Utilisation du répertoire actuel (`.`) (`build/`) pour la sortie de compilation.
+ `-DBUILD_GSTREAMER_PLUGIN=ON`permet de créer le GStreamer plugin kvssink.
+ `-DBUILD_DEPENDENCIES=OFF`désactive la création de dépendances externes à partir de la source. Le projet trouvera et utilisera les dépendances externes installées lors d'une étape précédente.
+ `-DALIGNED_MEMORY_MODEL=ON`désactive le modèle de mémoire non aligné. L'accès à la mémoire non aligné n'est pas pris en charge par certains appareils Raspberry Pi.
**Note**
Pour une liste complète des CMake arguments, voir[Téléchargez et configurez le code de la bibliothèque C\$1\$1 Producer](producersdk-cpp-download.md).
1. Générez le projet. Après avoir configuré le build, utilisez la `make` commande pour compiler à l'aide de la commande `Makefile` générée par`cmake`.
```
make -j$(nproc)
```
L'`-j`argument to `make` lui permet d'exécuter plusieurs tâches de compilation en parallèle. Pour réduire les temps de construction, utilisez la `nproc` commande pour calculer dynamiquement le nombre de cœurs de processeur de votre Raspberry Pi.
1. Confirmez que c'`libgstkvssink.so`est bien le cas.
Répertoriez les fichiers du répertoire en cours.
**Prompt :**
```
ls
```
**Réponse :**
```
CMakeCache.txt dependency kvs_gstreamer_sample
CMakeFiles kvs_gstreamer_audio_video_sample kvssink_gstreamer_sample
Makefile kvs_gstreamer_file_uploader_sample libKinesisVideoProducer.so
cmake_install.cmake kvs_gstreamer_multistream_sample libgstkvssink.so
```
1. Confirmez que cela GStreamer peut se charger`kvssink`.
Définissez la variable d'`GST_PLUGIN_PATH`environnement sur le répertoire contenant`libgstkvssink.so`.
```
export GST_PLUGIN_PATH=`pwd`
```
Avoir une GStreamer charge `kvssink` :
```
gst-inspect-1.0 kvssink
```
Vous devriez voir de la documentation sur`kvssink`. Utilisez les touches fléchées pour naviguer et appuyez `q` pour quitter.
1. (**Facultatif**) Mettez à jour le script de démarrage de votre shell pour inclure la définition de la variable d'`GST_PLUGIN_PATH`environnement. Cela garantit `GST_PLUGIN_PATH` un réglage correct lors d'une nouvelle session de terminal. Sur les appareils Raspberry Pi, le script de démarrage du shell est`~/.bashrc`.
Exécutez la commande suivante pour ajouter la commande à la fin du script de démarrage du shell.
```
echo "export GST_PLUGIN_PATH=~/Downloads/kvs-producer-sdk-cpp/build" >> ~/.bashrc
```
Tapez ce qui suit pour exécuter le script de démarrage du shell ou fermer le shell actuel et en ouvrir un nouveau.
```
source ~/.bashrc
```
Confirmez que le `GST_PLUGIN_PATH` paramètre est réglé et que vous pouvez charger`kvssink`.
```
echo $GST_PLUGIN_PATH
```
```
gst-inspect-1.0 kvssink
```
# Diffusez de la vidéo sur votre flux vidéo Kinesis
Pour exécuter cet exemple d'application, vous avez besoin des informations suivantes :
+ Le nom du flux que vous avez créé dans la section [Conditions préalables](producersdk-cpp-rpi-prerequisites.md).
+ Les informations d'identification de compte (ID de clé d'accès et clé d'accès secrète) que vous avez créées dans [Création d'un utilisateur IAM autorisé à écrire sur Kinesis Video Streams](producersdk-cpp-rpi-iam.md).
+ GStreamer est capable de localiser le `kvssink` plugin. Pour plus d’informations, consultez [Téléchargez et créez le SDK Kinesis Video Streams C\$1\$1 pour le producteur](producersdk-cpp-rpi-download.md).
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, consultez[Fournissez des informations d'identification à `kvssink`](examples-gstreamer-plugin-parameters.md#credentials-to-kvssink).
**Note**
Le SDK C\$1\$1 Producer utilise par défaut la région USA Ouest (Oregon`us-west-2`) (). Pour utiliser la valeur par défaut, Région AWS créez votre flux vidéo Kinesis dans la région USA Ouest (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
```
1. 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\$1C**.
L'exemple de GStreamer pipeline vidéo ressemble à ceci :
![\[Image du modèle de test standard avec horodatage superposé.\]](http://docs.aws.amazon.com/fr_fr/kinesisvideostreams/latest/dg/images/sample-video.png)
------
#### [ 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\$1C**.
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\$1C**.
------
#### [ Raspberry Pi camera module 1 ]
Si vous utilisez le module de caméra Pi 1 ou le module de caméra Pi 2 avec`bcm2835-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\$1C**.
------
#### [ 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\$1C**.
------
#### [ 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
```
1. 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
```
1. 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
```
1. 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`
```
1. 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
```
1. 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 la sortie pour détecter d'éventuelles erreurs.
Un autre moyen de 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 au`rtph264depay`, qui extrait les images vidéo codées H.264 des paquets RTP. `h264parse`regroupe les images vidéo dans le format que je `kvssink` peux comprendre. `kvssink`prend 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\$1C**.
------
## 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
```
1. 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"
```
**`v4l2h264enc`et `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 :
+ `kvssink`: Voir[Téléchargez et créez le SDK Kinesis Video Streams C\$1\$1 pour le producteur](producersdk-cpp-rpi-download.md).
+ `libcamerasrc`: Voir [Erreur « Échec de l'activation du pool de mémoire tampon »](#rpi-troubleshoot-buffer) pour installer l'`libcamerasrc` GStreamer élément.
+ `omxh264enc`ou `v4l2h264enc` :
Suivez [Installation des prérequis logiciels](producersdk-cpp-rpi-software.md) pour installer toutes les GStreamer bibliothèques. Si vous les avez tous installés et que ces éléments n'apparaissent pas, cela signifie que votre Raspberry Pi n'a pas le matériel nécessaire. Utilisez `x264enc` plutôt l'encodeur logiciel.
+ Autre : suivez [Installation des prérequis logiciels](producersdk-cpp-rpi-software.md) pour installer toutes les GStreamer bibliothèques. Différents GStreamer éléments se trouvent dans les différents groupes de GStreamer plugins (bons, mauvais, moches), alors assurez-vous de tous les installer.
### 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'utilisation`v4l2src`, 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 que`v4l2src`. 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 de`v4l2src`.
### Erreur de bus
Si vous recevez une erreur de bus peu après le démarrage `kvssink` (généralement, au moment de la `PutMedia` fin de l'appel HTTP), 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 compilation`kvssink`, car il est défini par défaut sur. `OFF` Voir [Téléchargez et créez le SDK Kinesis Video Streams C\$1\$1 pour le producteur](producersdk-cpp-rpi-download.md) 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 ](https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c).
**Résolution :**
Configurez `x264enc` à l'aide de 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](#producersdk-cpp-rpi-utilize).
### Impossible d'exécuter plusieurs pipelines à partir du même `v4l2` appareil en même temps
De tels appareils ne sont `/dev/video0` 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](https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897).
### 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](https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c), 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 `framerates``resolutions`, et`formats`. Vous pouvez utiliser l' GStreamer élément [Videoscale](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoscale.html?gi-language=c) pour régler la résolution vidéo et [Videorate pour ajuster la fréquence](https://gstreamer.freedesktop.org/documentation/videorate/?gi-language=c) 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.
# Lire le contenu multimédia de votre flux vidéo Kinesis
Ouvrez la console [Kinesis Video Streams](https://console.aws.amazon.com//kinesisvideo/home/) et sélectionnez **le nom du flux** que vous avez créé.
Le flux vidéo qui est envoyé à partir de l'appareil Raspberry Pi apparaît dans la console.
**Note**
Quelques secondes peuvent s'écouler avant que la vidéo n'apparaisse dans la console.
Une fois le stream diffusé, vous pouvez tester les fonctionnalités suivantes dans la console :
+ Dans la section **Video preview** (Aperçu vidéo), utilisez les contrôles de navigation pour revenir en arrière et avancer rapidement dans le flux.
+ Dans la section **Informations sur le flux**, passez en revue le codec, la résolution et le débit du flux. Les valeurs de résolution et de débit sont délibérément définies à un niveau bas sur le Raspberry Pi afin de minimiser l'utilisation de la bande passante pour ce didacticiel.
Pour consulter les CloudWatch métriques Amazon créées pour votre stream, sélectionnez **Afficher les métriques du stream dans CloudWatch**.
+ Sous **Durée de conservation**, notez que le flux vidéo est conservé une journée. Vous pouvez modifier cette valeur en spécifiant **No data retention** (Pas de rétention des données) ou une valeur pouvant aller d'une journée jusqu'à plusieurs années.
+ Dans la section **Chiffrement côté serveur**, notez que vos données sont chiffrées au repos à l'aide d'une clé gérée par le AWS Key Management Service ()AWS KMS.
## Problèmes de lecture
Vous trouverez ci-dessous certains problèmes de lecture fréquemment rencontrés et la procédure à suivre pour les résoudre.
### Aucun média, mais il y a des Acks persistants dans les journaux
Si vous voyez PERSISTED Acks dans les journaux, cela signifie que Kinesis Video Streams a correctement ingéré et stocké le contenu multimédia chargé par. `kvssink` Les acks reçus de Kinesis Video Streams ressemblent à ceci. Dans le JSON, examinez la valeur de la `"EventType"` clé.
```
{"EventType":"RECEIVED","FragmentTimecode":252200,"FragmentNumber":"12345678901234567890123456724587702494771079511"}
{"EventType":"BUFFERING","FragmentTimecode":252467,"FragmentNumber":"12345678901234567890123456781729223736853277017"}
{"EventType":"RECEIVED","FragmentTimecode":252467,"FragmentNumber":"12345678901234567890123456781729223736853277017"}
{"EventType":"BUFFERING","FragmentTimecode":253000,"FragmentNumber":"12345678901234567890123456738870744847093249408"}
{"EventType":"PERSISTED","FragmentTimecode":252200,"FragmentNumber":"12345678901234567890123456724587702494771079511"}
{"EventType":"PERSISTED","FragmentTimecode":252467,"FragmentNumber":"1234567890123456789012345671729223736853277017"}
```
**Résolution :**
Patientez une minute ou deux dans la console Kinesis Video Streams, puis utilisez la double flèche droite. Si aucun média n'apparaît, vérifiez que votre stream est envoyé vers la bonne région et vérifiez l'orthographe du nom du stream. Vous pouvez trouver ces informations dans les journaux.
Consultez [Indiquez une région pour `kvssink`](examples-gstreamer-plugin-parameters.md#kvssink-region) pour plus d'informations sur la façon dont kvssink détermine la région à utiliser.
### Le contenu multimédia met beaucoup de temps à se charger dans le AWS Management Console
**Important**
L'expérience de lecture sur console est différente de l'expérience de lecture HLS et DASH. Utilisez également l'exemple de [page Web hébergée par](https://aws-samples.github.io/amazon-kinesis-video-streams-media-viewer/) le lecteur multimédia GitHub pour tester la lecture. Le code source de la page Web se trouve [ici](https://github.com/aws-samples/amazon-kinesis-video-streams-media-viewer).
Le contenu multimédia peut se charger lentement dans la console en raison d'une faible bande passante réseau ou d'un périphérique restreint, mais cela peut également être dû à l'encodage vidéo et à la fragmentation.
**Principes de base de l'encodage vidéo :**
+ Les codeurs H.264 et H.265 utilisent des images clés (images I) et des images prédites (images P) pour une compression efficace.
+ Les images-clés contiennent des données d'image complètes, tandis que les images P contiennent uniquement les modifications par rapport aux images précédentes.
+ L' « intervalle entre images clés » détermine la fréquence à laquelle les images-clés apparaissent dans le flux vidéo.
**Fragmentation dans le streaming :**
+ Dans Kinesis Video Streams, les nouveaux fragments commencent par chaque image-clé. Pour de plus amples informations, veuillez consulter [Modèle de données Kinesis Video Streams](how-data.md).
+ *La longueur du fragment (en secondes) peut être estimée comme suit : *intervalle entre images clé ÷ fréquence* d'images*
**Exemple :**
Pour un flux avec un intervalle d'images clé de 30 et une fréquence d'images de 15 images par seconde :
Longueur du fragment = 30 ÷ 15 = 2 secondes
En raison de l'allongement des intervalles entre les images-clés, les fragments plus longs augmentent la latence dans le streaming multimédia.
**Résolution :**
Pour améliorer les temps de chargement, pensez à réduire l'intervalle entre les images-clés. Cela créera des fragments plus courts, diminuera la latence, mais augmentera également la taille du fichier vidéo.
Pour l'`x264enc` GStreamer élément, vous pouvez définir explicitement l'intervalle entre les images-clés via la `key-int-max` propriété :
```
x264enc bframes=0 key-int-max=60
```
Lorsque vous examinez les résultats du journal, notez la fréquence à laquelle le client de téléchargement reçoit des messages ACKs de Kinesis Video Streams. Plus le nombre d'images-clés générées est élevé, plus le nombre d'images ACKs renvoyées est élevé.
### Le média est déformé ou contient des artefacts
Pour résoudre ce problème, assurez-vous que tous les câbles sont bien connectés. Vérifiez la sortie `libcamera-hello` (ou `raspistill` pour les anciennes caméras Pi) des modules de caméra.
Dans votre GStreamer pipeline, remplacez `kvssink` par `autovideosink` ou `matroskamux` et`filesink`. Par exemple :
```
... x264enc tune=zerolatency speed-preset=ultrafast bframes=0 key-int-max=60 byte-stream=true ! h264parse ! matroskamux ! filesink location=output.mkv
```
Passez en revue le fichier de sortie `filesink` ou le lecteur multimédia qui s'ouvre lors `autovideosink` de l'utilisation pour voir si les artefacts sont également présents.
Passez également en revue le résultat du pipeline suivant :
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
L'ajout d'éléments à votre pipeline, tels que le [dewarp](https://gstreamer.freedesktop.org/documentation/opencv/dewarp.html?gi-language=c), peut corriger les résultats des caméras Fish Eye.
Vérifiez les codecs de sortie pris en charge par votre caméra et ajustez les éléments selon vos besoins.
Par exemple, si votre caméra USB ne prend en charge que la sortie JPEG, vous devrez utiliser les `jpegdec` éléments `jpegparse` et pour transformer le support avant de l'encoder en H.264 à l'aide `x264enc` de. Recherchez de l'aide sur les GStreamer forums pour d'autres utilisateurs utilisant des pipelines et/ou des configurations de webcam similaires.
# Résolution des problèmes de compilation sur le SDK C\$1\$1 Producer pour Raspberry Pi
Si vous rencontrez un problème de compilation et que vous souhaitez essayer différents CMake arguments, veillez à effectuer une nouvelle génération. Supprimez les `build` dossiers `open-source``dependency`, et avant de réessayer.
## Problèmes de création avec OpenSSL
Si vous recevez un résultat similaire à ce qui suit, cela indique qu'OpenSSL a mal détecté l'architecture de votre système.
```
crypto/md5/md5-aarch64.S: Assembler messages:
crypto/md5/md5-aarch64.S:3: Error: unrecognized symbol type ""
crypto/md5/md5-aarch64.S:6: Error: bad instruction `stp x19,x20,[sp,#-80]!'
crypto/md5/md5-aarch64.S:7: Error: bad instruction `stp x21,x22,[sp,#16]'
crypto/md5/md5-aarch64.S:8: Error: bad instruction `stp x23,x24,[sp,#32]'
crypto/md5/md5-aarch64.S:9: Error: bad instruction `stp x25,x26,[sp,#48]'
```
Dans cet exemple, il tente de créer une version 64 bits (`linux-aarch64`) alors que ce Raspberry Pi est en réalité 32 bits. Certains appareils Raspberry Pi ont un noyau 64 bits, mais un espace utilisateur 32 bits.
Déterminez l'architecture pour laquelle OpenSSL essaie de créer. Vous pouvez trouver la ligne de journal lors de l'`configure`étape pour OpenSSL :
```
[ 33%] Performing update step for 'project_libopenssl'
-- Already at requested tag: OpenSSL_1_1_1t
[ 44%] No patch step for 'project_libopenssl'
[ 55%] Performing configure step for 'project_libopenssl'
Operating system: x86_64-whatever-linux2
Configuring OpenSSL version 1.1.1t (0x1010114fL) for linux-x86_64
Using os-specific seed configuration
Creating configdata.pm
Creating Makefile
```
Vérifiez l'architecture de votre système :
+ Vérifiez le nombre de bits du noyau : exécutez `uname -m`
+ Vérifiez le nombre de bits de l'espace utilisateur : exécuter `getconf LONG_BIT`
Vous pouvez également consulter les informations relatives à votre processeur à l'aide des `lscpu` commandes `cat /proc/cpuinfo` ou.
**Résolution :**
Pour résoudre ce problème, ajoutez l' CMake argument suivant lors de la création, afin de vous assurer qu'OpenSSL se construit correctement pour l'architecture ARM 32 bits :
```
-DBUILD_OPENSSL_PLATFORM=linux-armv4
```
## Résoudre les problèmes `kvssink` de chargement dans GStreamer
Confirmer `GST_PLUGIN_PATH`
Assurez-vous que la variable d'`GST_PLUGIN_PATH`environnement de votre session shell en cours pointe vers le répertoire contenant`kvssink`. Les variables d'environnement étant spécifiques à une session, vous devez les définir pour chaque nouvelle session. Pour rendre cette modification permanente, consultez « Mettre à jour le script de démarrage de votre shell pour inclure la définition de la variable d'environnement GST\$1PLUGIN\$1PATH ».
**Erreur : Impossible d'ouvrir le fichier objet partagé : aucun fichier ou répertoire de ce type**
Si le message d'erreur s'affiche`Cannot open shared object file: No such file or directory`, exécutez la commande suivante :
```
gst-inspect-1.0 /path/to/libgstkvssink.so
```
Si vous recevez le résultat suivant, cela indique que l'éditeur de liens dynamiques ne parvient pas à localiser les bibliothèques requises pour`kvssink`. Cela se produit généralement pour les raisons suivantes :
+ Déménagement `kvssink` vers un endroit différent de celui où il a été construit.
+ Compilation croisée pour une architecture de processeur incorrecte.
+ Une dépendance requise est manquante.
**Sortie** :
```
WARNING: erroneous pipeline: no element "kvssink"
error while loading shared libraries: libcproducer.so: cannot open shared object file: No such file or directory
```
**Résolution :**
Pour les **bibliothèques déplacées**, ajoutez le répertoire contenant les bibliothèques manquantes à`LD_LIBRARY_PATH`.
À partir du répertoire racine du dépôt d'origine, vous pouvez localiser la bibliothèque manquante à l'aide de l'`find`utilitaire. Dans le terminal, tapez :
```
find . -name "*libcproducer*"
```
**Sortie** :
```
./build/dependency/libkvscproducer/kvscproducer-src/libcproducer.so
```
Le séparateur de chemin de fichier sur les appareils Linux est`:`. La commande ci-dessous ajoute un nouveau chemin de dossier à la variable d'`LD_LIBRARY_PATH`environnement existante, en préservant les valeurs précédentes.
Dans votre terminal, saisissez :
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/build/dependency/libkvscproducer/kvscproducer-src
```
**Important**
Les variables d'environnement sont spécifiques à la session. Pour conserver les modifications d'une session à l'autre, modifiez le script de démarrage de votre shell.
Vous devrez peut-être également ajouter le `open-source/local/lib` à votre`$LD_LIBRARY_PATH`.
**Erreur :. /path/to/libcproducer.so.1 : en-tête ELF non valide**
Si vous recevez cette erreur lors du chargement des **bibliothèques partagées**, cela peut être dû à des liens symboliques rompus (`symlinks`). Les liens symboliques peuvent être interrompus si le système d'exploitation de la machine hôte ne correspond pas à celui de la machine cible. Par exemple, la compilation croisée sur un MacBook pour un Raspberry Pi.
Une autre cause possible est que les fichiers binaires créés étaient destinés à la mauvaise architecture. Par exemple, si les fichiers binaires ont été conçus pour x86 (le Raspberry Pi utilise ARM CPUs).
Accédez à l'emplacement de bibliothèque spécifié dans l'erreur et tapez : `ls -la` pour inspecter la bibliothèque`symlinks`.
**Réponse :**
```
drwxr-xr-x 16 me staff 512 Sep 10 17:16 .
drwxr-xr-x 7 me staff 224 Jan 6 23:46 ..
drwxr-xr-x 4 me staff 128 Sep 10 17:16 engines-1.1
-rwxr-xr-x 1 me staff 2294496 Sep 10 17:16 libcrypto.1.1.so
-rw-r--r-- 1 me staff 4002848 Sep 10 17:16 libcrypto.a
lrwxr-xr-x 1 me staff 19 Sep 10 17:16 libcrypto.so -> libcrypto.1.1.so
-rwxr-xr-x 1 me staff 631176 Sep 10 17:12 liblog4cplus-2.0.3.so
lrwxr-xr-x 1 me staff 24 Sep 10 17:12 liblog4cplus.so -> liblog4cplus-2.0.3.so
-rwxr-xr-x 1 me staff 1012 Sep 10 17:12 liblog4cplus.a
-rwxr-xr-x 1 me staff 694328 Sep 10 17:12 liblog4cplusU-2.0.3.so
lrwxr-xr-x 1 me staff 25 Sep 10 17:12 liblog4cplusU.dylib -> liblog4cplusU-2.0.3.so
-rwxr-xr-x 1 me staff 1017 Sep 10 17:12 liblog4cplusU.a
-rwxr-xr-x 1 me staff 536416 Sep 10 17:16 libssl.1.1.so
-rw-r--r-- 1 me staff 795184 Sep 10 17:16 libssl.a
lrwxr-xr-x 1 me staff 16 Sep 10 17:16 libssl.so -> libssl.1.1.so
drwxr-xr-x 6 me staff 192 Sep 10 17:16 pkgconfig
```
Dans l'exemple de sortie ci-dessus, `symlinks` ils ne sont pas cassés. Les Broken n'`symlinks`auront pas de flèches pointant vers leurs cibles.
**Résolution :**
Il existe deux options pour corriger les liens symboliques :
+ **Recommandé :** Recréez le `symlink` avec la `ln` commande. Type :
```
ln -s /path/to/actual/library /path/to/symlink
```
+ Copiez le fichier de bibliothèque actuel et renommez-le pour qu'il corresponde au`symlink`.
**Note**
Cette option entraîne une augmentation de l'utilisation du stockage.
La meilleure pratique consiste à compiler sur le même système d'exploitation à l'aide d'outils tels que Docker pour éviter les problèmes de compilation croisée.
**Dépendances manquantes :**
Si le nom de bibliothèque manquant commence par`libkvs`, consultez la section « bibliothèques déplacées » ci-dessus pour installer les bibliothèques Kinesis Video Streams de l'appareil hôte vers l'appareil cible.
Dans le cas [Installation des prérequis logiciels](producersdk-cpp-rpi-software.md) contraire, assurez-vous que tous les logiciels open source requis sont installés sur l'appareil cible.