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.
# Exemples d'Amazon Kinesis Video Streams
Les exemples de code suivants montrent comment utiliser l'API Kinesis Video Streams :
## Exemples : envoi de données vers Kinesis Video Streams
+ [Exemple : plugin GStreamer SDK Kinesis Video Streams Producer - kvssink](examples-gstreamer-plugin.md): montre comment créer le SDK Kinesis Video Streams Producer à utiliser comme GStreamer destination.
+ [Exécuter l' GStreamer élément dans un conteneur Docker](examples-gstreamer-plugin.md#examples-gstreamer-plugin-docker): montre comment utiliser une image Docker prédéfinie pour envoyer une vidéo RTSP (Real-Time Streaming Protocol) depuis une caméra IP vers Kinesis Video Streams.
+ [Exemple : diffusion en continu depuis une source RTSP](examples-rtsp.md): montre comment créer votre propre image Docker et envoyer une vidéo RTSP depuis une caméra IP vers Kinesis Video Streams.
+ [Exemple : envoi de données à Kinesis Video Streams à l'aide PutMedia de l'API](examples-putmedia.md): montre comment utiliser le pour envoyer [Utiliser la bibliothèque Java Producer](producer-sdk-javaapi.md) à Kinesis Video Streams des données déjà au format conteneur (MKV) à l'aide [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)de l'API.
## Exemples : extraction de données depuis Kinesis Video Streams
+ [KinesisVideoExample](parser-library-write.md#parser-library-write-example): montre comment analyser et enregistrer des fragments vidéo à l'aide de la bibliothèque d'analyseurs Kinesis Video Streams.
+ [Exemple : analyse et rendu de fragments Kinesis Video Streams](examples-renderer.md): montre comment analyser et afficher des fragments [JCodec](http://jcodec.org/)de flux vidéo Kinesis à l'aide de et. [JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html)
## Exemples : lecture de données vidéo
+ [Exemple : utilisez HLS en HTML et JavaScript](hls-playback.md#how-hls-ex1): montre comment récupérer une session de streaming HLS pour un flux vidéo Kinesis et la lire sur une page Web.
## Conditions préalables
+ Dans l'exemple de code, vous fournissez des informations d'identification en spécifiant un profil que vous définissez dans votre fichier de profil AWS d'informations d'identification ou en fournissant des informations d'identification dans les propriétés du système Java de votre environnement de développement intégré (IDE). Si ce n'est pas déjà fait, configurez d'abord vos informations d'identification. Pour plus d'informations, voir [Configurer les AWS informations d'identification et la région pour le développement](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html).
+ Nous vous recommandons d'utiliser un IDE Java pour afficher et exécuter le code, par exemple :
+ [Eclipse Java Néon](https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-jee-neon-3)
+ [JetBrains IntelliJ IDEA](https://www.jetbrains.com/idea/)
# Exemple : plugin GStreamer SDK Kinesis Video Streams Producer - kvssink
Cette rubrique explique comment créer le SDK Amazon Kinesis Video Streams Producer à utiliser comme GStreamer plugin.
**Topics**
+ [Téléchargez, créez et configurez l' GStreamer élément](#examples-gstreamer-plugin-download)
+ [Exécutez l' GStreamer élément](#examples-gstreamer-plugin-run)
+ [Exemples de commandes GStreamer de lancement](#examples-gstreamer-plugin-launch)
+ [Exécuter l' GStreamer élément dans un conteneur Docker](#examples-gstreamer-plugin-docker)
+ [GStreamer référence de paramètre d'élément](examples-gstreamer-plugin-parameters.md)
[GStreamer](https://gstreamer.freedesktop.org/)est un framework multimédia populaire utilisé par plusieurs caméras et sources vidéo pour créer des pipelines multimédias personnalisés en combinant des plugins modulaires. Le plugin Kinesis Video GStreamer Streams rationalise l'intégration de votre pipeline multimédia GStreamer existant à Kinesis Video Streams. Après l'intégration GStreamer, vous pouvez diffuser des vidéos depuis une webcam ou une caméra RTSP (Real Time Streaming Protocol) vers Kinesis Video Streams pour une lecture, un stockage et une analyse plus approfondie en temps réel ou ultérieurement.
Le GStreamer plugin gère automatiquement le transfert de votre flux vidéo vers Kinesis Video Streams en encapsulant les fonctionnalités fournies par le SDK GStreamer du producteur Kinesis Video Streams dans un élément récepteur,. `kvssink` Le GStreamer framework fournit un environnement géré standard pour créer un flux multimédia à partir d'un périphérique tel qu'une caméra ou une autre source vidéo pour un traitement, un rendu ou un stockage ultérieurs.
Le GStreamer pipeline consiste généralement en un lien entre une source (caméra vidéo) et l'élément récepteur (soit un lecteur pour le rendu de la vidéo, soit un stockage pour la récupération hors ligne). Dans cet exemple, vous utilisez le kit SDK Producteur en tant que *récepteur* ou une destination multimédia pour votre source vidéo (webcam ou caméra IP). L'élément du plugin qui encapsule le SDK envoie ensuite le flux vidéo à Kinesis Video Streams.
Cette rubrique explique comment créer un pipeline GStreamer multimédia capable de diffuser des vidéos à partir d'une source vidéo, telle qu'une caméra Web ou un flux RTSP, généralement connectée via des étapes de codage intermédiaires (à l'aide du codage H.264) à Kinesis Video Streams. Lorsque votre flux vidéo est disponible sous forme de flux vidéo Kinesis, vous pouvez l'utiliser [Regardez le résultat des caméras à l'aide de la bibliothèque d'analyseurs](parser-library.md) pour poursuivre le traitement, la lecture, le stockage ou l'analyse de votre flux vidéo.
![\[Vue fonctionnelle du pipeline GStreamer multimédia pour le streaming vidéo d'une caméra vers le service.\]](http://docs.aws.amazon.com/fr_fr/kinesisvideostreams/latest/dg/images/gstreamer-pipeline.png)
## Téléchargez, créez et configurez l' GStreamer élément
L'exemple de GStreamer plugin est inclus dans le SDK Kinesis Video Streams C\$1\$1 Producer. Pour plus d'informations sur les prérequis et le téléchargement du kit SDK, consultez [Téléchargez et configurez le code de la bibliothèque C\$1\$1 Producer](producersdk-cpp-download.md).
Vous pouvez créer le GStreamer récepteur du SDK du producteur sous forme de bibliothèque dynamique sur macOS, Ubuntu, Raspberry Pi ou Windows. Le GStreamer plugin se trouve dans votre `build` répertoire. Pour charger ce plugin, il doit se trouver dans votre`GST_PLUGIN_PATH`. Exécutez la commande suivante :
```
export GST_PLUGIN_PATH=`pwd`/build
```
**Note**
Sur macOS, vous ne pouvez diffuser de la vidéo à partir d'une caméra réseau que si vous l'exécutez GStreamer dans un conteneur Docker. Le streaming de contenu vidéo à partir d'une caméra USB sur macOS dans un conteneur Docker n'est pas pris en charge.
## Exécutez l' GStreamer élément
Pour fonctionner GStreamer avec l'élément SDK du producteur Kinesis Video Streams comme récepteur, utilisez `gst-launch-1.0` la commande. Utilisez des éléments en amont adaptés à l'utilisation du GStreamer plugin. Par exemple, [v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page) pour les appareils v4l2 sur les systèmes Linux ou [rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) pour les appareils RTSP. Spécifiez `kvssink` en tant qu'élément récepteur (destination finale du pipeline) pour envoyer des vidéos au kit SDK Producteur.
En plus de [fournir des informations d'identification](https://docs.aws.amazon.com//kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html#credentials-to-kvssink) et [une région](https://docs.aws.amazon.com//kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html#kvssink-region), l'`kvssink`élément possède le paramètre obligatoire suivant :
+ `stream-name`— Le nom du Kinesis Video Streams de destination.
Pour plus d'informations sur les paramètres facultatifs `kvssink`, consultez [GStreamer référence de paramètre d'élément](examples-gstreamer-plugin-parameters.md).
Pour obtenir les dernières informations sur les GStreamer plug-ins et les paramètres, consultez la section [GStreamer Plugins](https://gstreamer.freedesktop.org/documentation/plugins_doc.html?gi-language=c). Vous pouvez également utiliser le `gst-inspect-1.0` suivi du nom d'un GStreamer élément ou d'un plugin pour imprimer ses informations et vérifier qu'il est disponible sur votre appareil :
```
gst-inspect-1.0 kvssink
```
Si la construction `kvssink` échoue ou si GST\$1PLUGIN\$1PATH n'est pas correctement défini, votre sortie ressemblera à ceci :
```
No such element or plugin 'kvssink'
```
## Exemples de commandes GStreamer de lancement
Les exemples suivants montrent comment utiliser le `kvssink` GStreamer plugin pour diffuser des vidéos à partir de différents types d'appareils.
### Exemple 1 : Diffuser une vidéo depuis une caméra RTSP sur Ubuntu
La commande suivante crée un GStreamer pipeline sur Ubuntu qui diffuse à partir d'une caméra réseau RTSP, à l'aide du plugin [ GStreamer rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html?gi-language=c) :
```
gst-launch-1.0 -v rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! h264parse ! kvssink stream-name="YourStreamName" storage-size=128
```
### Exemple 2 : Encoder et diffuser une vidéo à partir d'une caméra USB sur Ubuntu
La commande suivante crée un GStreamer pipeline sur Ubuntu qui encode le flux depuis une caméra USB au format H.264 et le diffuse vers Kinesis Video Streams. Cet exemple utilise le plugin [ GStreamer v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page).
```
gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! x264enc bframes=0 key-int-max=45 bitrate=500 ! video/x-h264,stream-format=avc,alignment=au,profile=baseline ! kvssink stream-name="YourStreamName" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```
### Exemple 3 : Diffuser une vidéo pré-encodée à partir d'une caméra USB sur Ubuntu
La commande suivante crée un GStreamer pipeline sur Ubuntu qui diffuse des vidéos déjà codées par la caméra au format H.264 vers Kinesis Video Streams. Cet exemple utilise le plugin [ GStreamer v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page).
```
gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! h264parse ! video/x-h264,stream-format=avc,alignment=au ! kvssink stream-name="plugin" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```
### Exemple 4 : Diffuser une vidéo depuis une caméra réseau sous macOS
La commande suivante crée un GStreamer pipeline sur macOS qui diffuse des vidéos vers Kinesis Video Streams à partir d'une caméra réseau. Cet exemple utilise le plugin [rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) GStreamer .
```
gst-launch-1.0 rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! h264parse ! video/x-h264, format=avc,alignment=au ! kvssink stream-name="YourStreamName" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```
### Exemple 5 : Diffuser une vidéo à partir d'une caméra réseau sous Windows
La commande suivante crée un GStreamer pipeline sous Windows qui diffuse des vidéos vers Kinesis Video Streams à partir d'une caméra réseau. Cet exemple utilise le plugin [rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) GStreamer .
```
gst-launch-1.0 rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! video/x-h264, format=avc,alignment=au ! kvssink stream-name="YourStreamName" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```
### Exemple 6 : Diffuser une vidéo depuis une caméra sur un Raspberry Pi
La commande suivante crée un GStreamer pipeline sur le Raspberry Pi qui diffuse des vidéos vers Kinesis Video Streams. Cet exemple utilise le plugin [ GStreamer v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page).
```
gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! omxh264enc control-rate=1 target-bitrate=5120000 periodicity-idr=45 inline-header=FALSE ! h264parse ! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1,profile=baseline ! kvssink stream-name="YourStreamName" access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```
### Exemple 7 : Diffuser de l'audio et de la vidéo dans Raspberry Pi et Ubuntu
Découvrez comment [exécuter la commande gst-launch-1.0 pour commencer à diffuser en streaming du contenu audio et vidéo dans Raspberry-PI et Ubuntu](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/linux.md#running-the-gst-launch-10-command-to-start-streaming-both-audio-and-video-in-raspberry-pi-and-ubuntu).
### Exemple 8 : Diffuser du son et de la vidéo à partir des sources de l'appareil sous macOS
Découvrez comment [exécuter la commande gst-launch-1.0 pour commencer à diffuser en streaming du contenu audio et vidéo dans MacOS](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/macos.md#running-the-gst-launch-10-command-to-start-streaming-both-audio-and-raw-video-in-mac-os).
### Exemple 9 : télécharger un fichier MKV contenant à la fois de l'audio et de la vidéo
Découvrez comment [exécuter la commande gst-launch-1.0 pour télécharger le fichier MKV ayant du contenu audio et vidéo](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/windows.md#running-the-gst-launch-10-command-to-upload-mkv-file-that-contains-both-audio-and-video). Vous aurez besoin d'un fichier de test MKV avec des supports codés H.264 et AAC.
## Exécuter l' GStreamer élément dans un conteneur Docker
Docker est une plateforme permettant de développer, de déployer et d'exécuter des applications à l'aide de conteneurs. L'utilisation de Docker pour créer le GStreamer pipeline normalise l'environnement d'exploitation de Kinesis Video Streams, ce qui rationalise la création et l'utilisation de l'application.
Pour installer et configurer Docker, consultez les éléments suivants :
+ [Instructions pour télécharger Docker](https://docs.docker.com/engine/install/)
+ [Démarrez avec Docker](https://docs.docker.com/guides/getting-started/)
Après avoir installé Docker, vous pouvez télécharger le SDK ( GStreamer et le plugin) Kinesis Video Streams C\$1\$1 Producer depuis Amazon Elastic Container Registry à l'aide de l'une des commandes ci-dessous. `docker pull`
Pour exécuter GStreamer l'élément du SDK Kinesis Video Streams Producer en tant que récepteur dans un conteneur Docker, procédez comme suit :
**Topics**
+ [Authentifiez votre client Docker](#examples-gstreamer-plugin-docker-authenticate)
+ [Téléchargez l'image Docker pour Ubuntu, macOS, Windows ou Raspberry Pi](#examples-gstreamer-plugin-docker-download)
+ [Exécutez l'image Docker](#examples-gstreamer-plugin-docker-run)
### Authentifiez votre client Docker
Authentifiez votre client Docker auprès du registre Amazon ECR à partir duquel l'image doit être extraite. Vous devez obtenir des jetons d'authentification pour chaque registre utilisé. Les jetons sont valides pendant 12 heures. Pour plus d'informations, veuillez consulter [Authentification de registre](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) dans le *Guide de l'utilisateur Amazon Elastic Container Registry*.
**Example Authentification avec Amazon ECR**
Pour vous authentifier auprès d'Amazon ECR, copiez et collez la commande suivante comme indiqué.
```
sudo aws ecr get-login-password --region us-west-2 | docker login -u AWS --password-stdin https://546150905175.dkr.ecr.us-west-2.amazonaws.com
```
En cas de succès, la sortie imprime `Login Succeeded`.
### Téléchargez l'image Docker pour Ubuntu, macOS, Windows ou Raspberry Pi
Téléchargez l'image Docker dans votre environnement Docker à l'aide d'une des commandes suivantes en fonction de votre système d'exploitation :
#### Téléchargez l'image Docker pour Ubuntu
```
sudo docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux:latest
```
#### Téléchargez l'image Docker pour macOS
```
docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux:latest
```
#### Téléchargez l'image Docker pour Windows
```
docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-windows:latest
```
#### Téléchargez l'image Docker pour Raspberry Pi
```
sudo docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-raspberry-pi:latest
```
Pour vérifier que l'image a été ajoutée avec succès, utilisez la commande suivante :
```
docker images
```
### Exécutez l'image Docker
Utilisez l'une des commandes suivantes pour exécuter l'image Docker en fonction de votre système d'exploitation :
#### Exécutez l'image Docker sur Ubuntu
```
sudo docker run -it --network="host" --device=/dev/video0 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux /bin/bash
```
#### Exécutez l'image Docker sur macOS
```
sudo docker run -it --network="host" 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux /bin/bash
```
#### Exécutez l'image Docker sous Windows
```
docker run -it 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-windows AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY RTSP_URL STREAM_NAME
```
#### Exécutez l'image Docker sur Raspberry Pi
```
sudo docker run -it --device=/dev/video0 --device=/dev/vchiq -v /opt/vc:/opt/vc 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-raspberry-pi /bin/bash
```
Docker lance le conteneur et vous présente une invite de commande pour utiliser les commandes dans le conteneur.
Dans le conteneur, définissez les variables d'environnement à l'aide de la commande suivante :
```
export LD_LIBRARY_PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH
export PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/bin:$PATH
export GST_PLUGIN_PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$GST_PLUGIN_PATH
```
Commencez à diffuser en `kvssink` utilisant le `gst-launch-1.0` pour exécuter un pipeline adapté à votre appareil et à votre source vidéo. Par exemple, les pipelines, voir[Exemples de commandes GStreamer de lancement](#examples-gstreamer-plugin-launch).
# GStreamer référence de paramètre d'élément
Pour envoyer une vidéo au SDK C\$1\$1 Amazon Kinesis Video Streams Producer, vous devez *le `kvssink`* spécifier comme récepteur ou destination finale du pipeline. Cette référence fournit des informations sur les paramètres obligatoires et facultatifs de l'élément `kvssink`. Pour de plus amples informations, veuillez consulter [Exemple : plugin GStreamer SDK Kinesis Video Streams Producer - kvssink](examples-gstreamer-plugin.md).
**Rubriques**
+ [Fournissez des informations d'identification à `kvssink`](#credentials-to-kvssink)
+ [Indiquez une région pour `kvssink`](#kvssink-region)
+ [`kvssink`paramètres facultatifs](#kvssink-optional-parameters)
## Fournissez des informations d'identification à `kvssink`
Pour autoriser l'`kvssink` GStreamer élément à envoyer des demandes AWS, fournissez des AWS informations d'identification à utiliser lorsqu'il appelle le service Amazon Kinesis Video Streams. La chaîne de fournisseurs d'informations d'identification recherche les informations d'identification dans l'ordre suivant :
### 1. AWS IoT informations d'identification
Pour configurer les AWS IoT informations d'identification, voir[Contrôle de l'accès aux ressources Kinesis Video Streams à l'aide de AWS IoT](how-iot.md).
La valeur du `iot-credentials` paramètre doit commencer par `iot-certificate,` et être suivie d'une liste séparée par des virgules des paires *key* = *value* suivantes.
****
| Clé | Obligatoire | Description |
| --- | --- | --- |
| ca-path | Oui | Chemin du fichier vers le certificat CA utilisé pour établir la confiance avec le service principal via TLS.
**Example**
**Exemple** : ` /file/path/to/certificate.pem` |
| cert-path | Oui | Chemin du fichier vers le certificat X.509.
**Example**
**Exemple** : `/file/path/to/certificateID-certificate.pem.crt` |
| endpoint | Oui | Le point de terminaison AWS IoT Core du fournisseur d'informations d'identification pour votre AWS compte. Consultez le [guide AWS IoT du développeur](https://docs.aws.amazon.com//iot/latest/developerguide/authorizing-direct-aws.html).
**Example**
**Exemple** : `credential-account-specific-prefix.credentials.iot.aws-region.amazonaws.com` |
| key-path | Oui | Chemin du fichier vers la clé privée utilisée dans la paire de public/private clés.
**Example**
**Exemple** : `/file/path/to/certificateID-private.pem.key` |
| role-aliases | Oui | Nom de l'alias de rôle pointant vers le rôle AWS IAM à utiliser lors de la connexion. AWS IoT Core
**Example**
**Exemple** : `KvsCameraIoTRoleAlias` |
| iot-thing-name | Non | L’option `iot-thing-name` est facultative. Si `iot-thing-name` ce n'est pas le cas, la valeur du `stream-name` paramètre est utilisée.
**Example**
**Exemple** : `kvs_example_camera` |
**Example**
**Exemple :**
```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" iot-certificate="iot-certificate,endpoint=credential-account-specific-prefix.credentials.iot.aws-region.amazonaws.com,cert-path=certificateID-certificate.pem.crt,key-path=certificateID-private.pem.key,ca-path=certificate.pem,role-aliases=YourRoleAlias,iot-thing-name=YourThingName"
```
### 2. Variables d’environnement
Pour `kvssink` utiliser les informations d'identification de l'environnement, définissez les variables d'environnement suivantes :
****
| Nom de la variable d'environnement | Obligatoire | Description |
| --- | --- | --- |
| AWS\$1ACCESS\$1KEY\$1ID | Oui | La clé AWS d'accès utilisée pour accéder à Amazon Kinesis Video Streams. |
| AWS\$1SECRET\$1ACCESS\$1KEY | Oui | La clé AWS secrète associée à la clé d'accès. |
| AWS\$1SESSION\$1TOKEN | Non | Spécifie la valeur du jeton de session requis si vous utilisez des informations d'identification de sécurité temporaires provenant directement AWS STS des opérations. |
La définition de la variable d’environnement permet de modifier la valeur utilisée jusqu’à la fin de votre session shell, ou jusqu’à ce que vous définissiez la variable sur une autre valeur. Pour que les variables soient persistantes au cours des futures sessions, définissez-les dans le script de démarrage de votre shell.
### 3. `access-key`, `secret-key` paramètres
Pour spécifier les informations d'identification directement en tant que `kvssink` paramètre, définissez les paramètres suivants :
****
| `kvssink`Nom du paramètre | Obligatoire | Description |
| --- | --- | --- |
| access-key | Oui | La clé AWS d'accès utilisée pour accéder à Amazon Kinesis Video Streams. |
| secret-key | Oui | La clé AWS secrète associée à la clé d'accès. |
| session-token | Non | Spécifie la valeur du jeton de session requis si vous utilisez des informations d'identification de sécurité temporaires provenant directement AWS STS des opérations. |
**Example**
**À l'aide d'informations d'identification statiques :**
```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" access-key="AKIDEXAMPLE" secret-key="SKEXAMPLE"
```
**Example**
**À l'aide d'informations d'identification temporaires :**
```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" access-key="AKIDEXAMPLE" secret-key="SKEXAMPLE" session-token="STEXAMPLE"
```
### 4. Fichier d'informations d'identification
**Important**
Si vous avez sélectionné l'une des méthodes précédentes, vous ne pouvez pas utiliser le `credential-path` `kvssink` paramètre.
****
| `kvssink`Nom du paramètre | Obligatoire | Description |
| --- | --- | --- |
| credential-path | Oui | Chemin d'accès au fichier texte contenant les informations d'identification dans un format spécifique. |
Le fichier texte doit contenir des informations d'identification dans l'un des formats suivants :
+ INFORMATIONS D'IDENTIFICATION *YourAccessKey* *YourSecretKey*
+ INFORMATIONS D'IDENTIFICATION *YourAccessKey* *Expiration* *YourSecretKey* *SessionToken*
**Example**
**Exemple :** votre `credentials.txt` fichier se trouve à l'adresse suivante `/home/ubuntu` et contient les éléments suivants :
`CREDENTIALS AKIDEXAMPLE 2023-08-10T22:43:00Z SKEXAMPLE STEXAMPLE`
Pour l'utiliser dans`kvssink`, tapez :
```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" credential-path="/home/ubuntu/credentials.txt"
```
Le délai d'expiration doit être d'au moins 5 \$1 30 \$1 3 = **38** secondes dans le futur. Le délai de grâce est défini comme la `IOT_CREDENTIAL_FETCH_GRACE_PERIOD` variable dans [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/Common/IotCredentialProvider.h](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/Common/IotCredentialProvider.h). Si les informations d'identification sont trop proches de leur date d'expiration lorsque vous démarrez`kvssink`, le code d'erreur s'affiche`0x52000049 - STATUS_INVALID_TOKEN_EXPIRATION`.
`kvssink`ne modifie pas le fichier d'informations d'identification. Si vous utilisez des informations d'identification temporaires, le fichier d'informations d'identification doit être mis à jour par une source externe avant la date d'expiration, déduction faite du délai de grâce.
## Indiquez une région pour `kvssink`
L'ordre de recherche des régions est le suivant :
1. `AWS_DEFAULT_REGION`la variable d'environnement est examinée en premier. Si elle est définie, cette région est utilisée pour configurer le client.
1. `aws-region`le paramètre est ensuite revu. Si elle est définie, cette région est utilisée pour configurer le client.
1. Si aucune des méthodes précédentes n'a été utilisée, la `kvssink` valeur par défaut est. `us-west-2`
## `kvssink`paramètres facultatifs
Les paramètres facultatifs pour l'élément `kvssink` sont les suivants. Pour obtenir plus d’informations sur ces paramètres, consultez [Structures de flux vidéo Kinesis](producer-reference-structures-stream.md).
****
| Paramètre | Description | Unité / Type | Par défaut |
| --- | --- | --- | --- |
| stream-name | Nom du flux vidéo Amazon Kinesis de destination. Si aucun nom de flux n'est spécifié, le nom de flux par défaut sera utilisé : « DEFAULT\$1STREAM ». Si un flux portant ce nom par défaut n'existe pas déjà, il sera créé. | | |
| absolute-fragment-times | Indique s'il faut utiliser des fragments absolus. | Booléen | true |
| access-key | La clé AWS d'accès utilisée pour accéder à Kinesis Video Streams. Vous devez soit avoir défini les AWS informations d'identification, soit fournir ce paramètre. Pour fournir ces informations, saisissez ce qui suit : export AWS_ACCESS_KEY_ID=
| | |
| avg-bandwidth-bps | Bande passante moyenne attendue pour le flux. | Bits par seconde | 4194304 |
| aws-region | Le Région AWS à utiliser. Vous pouvez également fournir la variable d'`AWS_DEFAULT_REGION`environnement à la région. Les variables d'environnement sont prioritaires si la variable d'environnement et les paramètres kvssink sont définis. La région sera définie par `us-west-2` défaut sur sauf indication contraire. | String | "us-west-2" |
| buffer-duration | Durée de la mémoire tampon du flux. | Secondes | 120 |
| codec-id | L'ID de codec du flux. | String | "V\$1MPEG4/ISO/AVC" |
| connection-staleness | Le délai après lequel le rappel de l'obsolescence du flux est appelé. | Secondes | 60 |
| content-type | Le type de contenu du flux. | String | "video/h264" |
| fragment-acks | S'il faut utiliser un fragment ACKs. | Booléen | true |
| fragment-duration | La durée de fragment souhaitée. | Millisecondes | 2000 |
| framerate | Débit d'images attendu. | Images par seconde | 25 |
| frame-timecodes | Indique s'il faut utiliser codes horaires d'image ou générer des horodatages à l'aide du rappel actuel. | Booléen | true |
| key-frame-fragmentation | Indique s'il faut générer des fragments sur une image clé. | Booléen | true |
| log-config | Le chemin d'accès de configuration du journal. | String | "../kvs\$1log\$1configuration" |
| max-latency | La latence maximum pour le flux. | Secondes | 60 |
| recalculate-metrics | Indique s'il faut recalculer les métriques. | Booléen | true |
| replay-duration | La durée de restauration du lecteur actuel pour relire en cas d'erreur si le redémarrage est activé. | Secondes | 40 |
| restart-on-error | Indique s'il faut redémarrer en cas d'erreur. | Booléen | true |
| retention-period | La durée pendant laquelle le flux est conservé. | heures | 2 |
| rotation-period | La période de rotation des clés d'accès. Pour plus d'informations, voir [Rotation AWS KMS des touches](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html). | Secondes | 3600 |
| secret-key | La clé AWS secrète utilisée pour accéder à Kinesis Video Streams. Vous devez soit avoir défini les AWS informations d'identification, soit fournir ce paramètre. export AWS_SECRET_ACCESS_KEY=
| | |
| session-token | Spécifie la valeur du jeton de session requis si vous utilisez des informations d'identification de sécurité temporaires provenant directement AWS STS des opérations. | | |
| storage-size | Taille de stockage de l'appareil en mébioctet (MiB). Pour plus d'informations sur la configuration du stockage de l'appareil, consultez [StorageInfo](producer-reference-structures-producer.md#producer-reference-structures-producer-storageinfo). | Mebioctet (MiB) | 128 |
| streaming-type | Le type de streaming. Les valeurs valides sont les suivantes : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html) | Enum GstKvsSinkStreamingType | 0 : temps réel |
| timecode-scale | L'échelle de code horaire MKV. | Millisecondes | 1 |
| track-name | Nom de la piste MKV. | String | "kinesis\$1video" |
| iot-certificate | AWS IoT informations d'identification à utiliser dans l'`kvssink`élément. `iot-certificate`accepte les clés et valeurs suivantes : `iot-thing-name`C'est **facultatif**. Si `iot-thing-name` ce n'est pas le cas, la valeur du `stream-name` paramètre est utilisée. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html) | String | Aucune |
# Exemple : envoi de données à Kinesis Video Streams à l'aide PutMedia de l'API
Cet exemple montre comment utiliser l'[PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)API. Il montre comment envoyer des données déjà au format conteneur (MKV). Si vos données doivent être assemblées dans un format conteneur avant d'être envoyées (par exemple, si vous assemblez les données vidéo de la caméra en images), voir[Transférer vers Kinesis Video Streams](producer-sdk.md).
**Note**
L'`PutMedia`opération n'est disponible qu'en C\$1\$1 et en Java SDKs. Cela est dû à la gestion en duplex intégral des connexions, du flux de données et des accusés de réception. Il n'est pas pris en charge dans les autres langues.
**Topics**
+ [Téléchargez et configurez le code](#examples-putmedia-download)
+ [Rédiger et examiner le code](#examples-putmedia-write)
+ [Exécutez et vérifiez le code](#examples-putmedia-run)
## Téléchargez et configurez le code
Suivez les étapes pour télécharger l'exemple de code Java, importer le projet dans votre IDE Java, configurer les emplacements des bibliothèques et configurer le code pour utiliser vos AWS informations d'identification.
1. Créez un répertoire et clonez l'exemple de code source à partir du GitHub référentiel. L'exemple `PutMedia` fait partit de [Java](producer-sdk-javaapi.md).
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-java
```
1. Ouvrez l'IDE Java que vous utilisez (par exemple, [Eclipse](https://www.eclipse.org/) ou [IntelliJ IDEA](https://www.jetbrains.com/idea/)) et importez le projet Apache Maven que vous avez téléchargé :
+ **Dans Eclipse :** Choisissez **Fichier**, **Importer**, **Maven**, **Projets Maven existants** et accédez à la racine du package téléchargé. Sélectionnez le fichier `pom.xml`.
+ **Dans IntelliJ Idea : ** Choisissez **Importer**. Naviguez vers le fichier `pom.xml` dans la racine du package téléchargé.
Pour plus d'informations, consultez la documentation relative à IDE.
1. Mettez à jour le projet de manière à ce que IDE trouve l'emplacement des bibliothèques que vous avez importées.
+ Pour IntelliJ IDEA, procédez comme suit :
1. Ouvrez le menu contextuel (via un clic droit) du répertoire **lib** du projet, puis choisissez **Ajouter en tant que bibliothèque**.
1. Choisissez **Fichier**, puis **Structure du projet**.
1. Sous **Paramètres du projet**, choisissez **Modules**.
1. Dans l'onglet **Sources**, définissez **Niveau de langue** sur**7** ou une valeur supérieure.
+ Pour Eclipse, procédez comme suit :
1. Ouvrez le menu contextuel (clic droit) du projet et choisissez **Propriétés**, **Chemin de création Java**, **Source**. Ensuite, procédez comme suit :
1. Sur l'onglet **Source**, double-cliquez sur **Emplacement de la bibliothèque native**.
1. Dans l'assistant **Configuration du dossier de la bibliothèque Native**, choisissez **Workspace**.
1. Dans la sélection **Dossier de la bibliothèque native**, choisissez le répertoire **lib** dans le projet.
1. Ouvrez le menu contextuel (clic droit) pour le projet et choisissez **Propriétés**. Ensuite, procédez comme suit :
1. Dans l'onglet **Bibliothèques**, choisissez **Ajouter Jars**.
1. Dans l'assistant **Sélection JAR**, choisissez tous les fichiers .jars dans le répertoire `lib` du projet.
## Rédiger et examiner le code
L'exemple d'API `PutMedia` () présente le modèle de codage suivant :`PutMediaDemo`
**Topics**
+ [Créez le PutMediaClient](#producersdk-javaapi-writecode-putmediaapi-putmediaclient)
+ [Diffuser du média et interrompre le thread](#producersdk-javaapi-writecode-putmediaapi-run)
Les exemples de code de cette section proviennent de la clase `PutMediaDemo`.
### Créez le PutMediaClient
La création de `PutMediaClient` l'objet nécessite les paramètres suivants :
+ L'URI pour le point de terminaison `PutMedia`.
+ Un `InputStream` indiquant le fichier MKV à diffuser.
+ Nom du flux. Cet exemple utilise le flux qui a été créé dans [Utiliser la bibliothèque Java Producer](producer-sdk-javaapi.md) (`my-stream`). Pour utiliser un flux différent, modifiez le paramètre suivant :
```
private static final String STREAM_NAME="my-stream";
```
**Note**
L'exemple `PutMedia` d'API ne crée pas de flux. Vous devez créer un flux soit à l'aide de l'application de test pour la [Utiliser la bibliothèque Java Producer](producer-sdk-javaapi.md) console Kinesis Video Streams, soit AWS CLIà l'aide du.
+ L'horodatage actuel.
+ Le type de time code. L'exemple utilise `RELATIVE`, indiquant que l'horodatage est relatif au début du conteneur.
+ Un objet `AWSKinesisVideoV4Signer` qui vérifie que les paquets reçus ont été envoyés par l'expéditeur autorisé.
+ Le montant maximum de la bande passante en Kbps.
+ Un objet `AckConsumer` pour recevoir les accusés de réception des paquets reçus.
Le code suivant crée l'objet `PutMediaClient` :
```
/* actually URI to send PutMedia request */
final URI uri = URI.create(KINESIS_VIDEO_DATA_ENDPOINT + PUT_MEDIA_API);
/* input stream for sample MKV file */
final InputStream inputStream = new FileInputStream(MKV_FILE_PATH);
/* use a latch for main thread to wait for response to complete */
final CountDownLatch latch = new CountDownLatch(1);
/* a consumer for PutMedia ACK events */
final AckConsumer ackConsumer = new AckConsumer(latch);
/* client configuration used for AWS SigV4 signer */
final ClientConfiguration configuration = getClientConfiguration(uri);
/* PutMedia client */
final PutMediaClient client = PutMediaClient.builder()
.putMediaDestinationUri(uri)
.mkvStream(inputStream)
.streamName(STREAM_NAME)
.timestamp(System.currentTimeMillis())
.fragmentTimeCodeType("RELATIVE")
.signWith(getKinesisVideoSigner(configuration))
.upstreamKbps(MAX_BANDWIDTH_KBPS)
.receiveAcks(ackConsumer)
.build();
```
### Diffuser du média et interrompre le thread
Une fois le client créé, l'échantillon commence la diffusion asynchrone avec `putMediaInBackground`. Le thread principal est alors interrompu avec `latch.await` jusqu'au retour de `AckConsumer`, le client est alors fermé.
```
/* start streaming video in a background thread */
client.putMediaInBackground();
/* wait for request/response to complete */
latch.await();
/* close the client */
client.close();
```
## Exécutez et vérifiez le code
Pour exécuter l'exemple d'API `PutMedia`, procédez comme suit :
1. Créez un flux nommé `my-stream` dans la console Kinesis Video Streams ou à l'aide AWS CLI du.
1. Remplacez votre répertoire de travail par le répertoire du kit SDK Producteur Java :
```
cd //amazon-kinesis-video-streams-producer-sdk-java/
```
1. Compilez le kit SDK Java et l'application de démonstration :
```
mvn package
```
1. Créez un nom de fichier temporaire dans le répertoire `/tmp` :
```
jar_files=$(mktemp)
```
1. Créez une chaîne de chemin de classe de dépendances à partir du référentiel local vers un fichier :
```
mvn -Dmdep.outputFile=$jar_files dependency:build-classpath
```
1. Définissez la valeur de la variable d'environnement `LD_LIBRARY_PATH` comme suit :
```
export LD_LIBRARY_PATH=//amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH
$ classpath_values=$(cat $jar_files)
```
1. Exécutez la démo à partir de la ligne de commande comme suit, en fournissant vos AWS informations d'identification :
```
java -classpath target/kinesisvideo-java-demo-1.0-SNAPSHOT.jar:$classpath_values -Daws.accessKeyId=${ACCESS_KEY} -Daws.secretKey=${SECRET_KEY} -Djava.library.path=/opt/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build com.amazonaws.kinesisvideo.demoapp.DemoAppMain
```
1. Ouvrez la console [Kinesis Video Streams](https://console.aws.amazon.com//kinesisvideo/home/) et choisissez votre flux sur **la page Gérer les** flux. La vidéo est lue dans le volet **Aperçu vidéo**.
# Exemple : diffusion en continu depuis une source RTSP
[C\$1\$1](producer-sdk-cpp.md)Il contient la définition d'un conteneur [Docker](https://www.docker.com/) qui se connecte à une caméra réseau RTSP (Real-Time Streaming Protocol). L'utilisation de Docker normalise l'environnement d'exploitation de Kinesis Video Streams, ce qui rationalise la création et l'utilisation de l'application.
La procédure suivante illustre comment configurer et utiliser l'application de démonstration RTSP.
**Topics**
+ [Didacticiels vidéo](#rtsp-video)
+ [Conditions préalables](#examples-rtsp-prerequisites)
+ [Créez l'image Docker](#examples-rtsp-build)
+ [Exécutez l'exemple d'application RTSP](#examples-rtsp-procedure)
## Didacticiels vidéo
Cette vidéo explique comment configurer un Raspberry Pi pour envoyer des flux RTSP vers le AWS cloud et Amazon Kinesis Video Streams. Il s'agit d'une end-to-end démonstration.
[](http://www.youtube.com/watch?v=YoOYTCD_v3Q?si=ajdNXZpRhNnpAOKk)
Cette vidéo montre comment capturer des images à partir d'un flux pour utiliser la vision par ordinateur et Amazon Rekognition pour traiter les images et envoyer des alertes.
## Conditions préalables
Pour exécuter l'exemple d'application Kinesis Video Streams RTSP, vous devez disposer des éléments suivants :
+ **Docker :** Pour plus d'informations sur l'installation et l'utilisation de Docker, consultez les liens suivants :
+ [Instructions pour télécharger Docker](https://docs.docker.com/desktop/)
+ [Démarrez avec Docker](https://docs.docker.com/guides/getting-started/)
+ **Source de la caméra RTSP en réseau :** Pour plus d'informations sur les caméras recommandées, consultez [Configuration système requise](system-requirements.md).
## Créez l'image Docker
Créez d'abord l'image Docker dans laquelle l'application de démonstration sera exécutée.
1. Clonez le référentiel de démos d'Amazon Kinesis Video Streams.
```
git clone https://github.com/aws-samples/amazon-kinesis-video-streams-demos.git
```
1. Accédez au répertoire contenant le Dockerfile. Dans ce cas, il s'agit du répertoire [docker-rtsp](https://github.com/aws-samples/amazon-kinesis-video-streams-demos/blob/master/producer-cpp/docker-rtsp/).
```
cd amazon-kinesis-video-streams-demos/producer-cpp/docker-rtsp/
```
1. Utilisez la commande suivante pour créer l'image Docker. Cette commande crée l'image et la balise rtspdockertest.
```
docker build -t rtspdockertest .
```
1. Exécutez `docker images` et recherchez l'identifiant de l'image marqué avec`rtspdockertest`.
Par exemple, dans l'exemple de sortie ci-dessous, le `IMAGE ID` est`54f0d65f69b2`.
```
REPOSITORY TAG IMAGE ID CREATED PLATFORM SIZE BLOB SIZE
rtspdockertest latest 54f0d65f69b2 10 minutes ago linux/arm64 653.1 MiB 292.4 MiB
```
Vous en aurez besoin ultérieurement.
## Exécutez l'exemple d'application RTSP
Vous pouvez exécuter l'exemple d'application RTSP à l'intérieur ou à l'extérieur du conteneur Docker. Suivez les instructions appropriées ci-dessous.
**Topics**
+ [Dans le conteneur Docker](#examples-rtsp-within)
+ [À l'extérieur du conteneur Docker](#examples-rtsp-outside)
### Dans le conteneur Docker
**Exécutez l'exemple d'application RTSP**
1. Démarrez le conteneur Docker Amazon Kinesis Video Streams à l'aide de la commande suivante :
```
docker run -it YourImageId /bin/bash
```
1. Pour démarrer l'exemple d'application, entrez vos informations AWS d'identification, le nom du flux vidéo Amazon Kinesis et l'URL de la caméra réseau RTSP.
**Important**
Si vous utilisez des informations d'identification temporaires, vous devrez également fournir votre`AWS_SESSION_TOKEN`. Voir le deuxième exemple ci-dessous.
```
export AWS_ACCESS_KEY_ID=YourAccessKeyId
export AWS_SECRET_ACCESS_KEY=YourSecretKeyId
export AWS_DEFAULT_REGION=YourAWSRegion
./kvs_gstreamer_sample YourStreamName YourRtspUrl
```
**Informations d'identification temporaires :**
```
export AWS_ACCESS_KEY_ID=YourAccessKeyId
export AWS_SECRET_ACCESS_KEY=YourSecretKeyId
export AWS_SESSION_TOKEN=YourSessionToken
export AWS_DEFAULT_REGION=YourAWSRegion
./kvs_gstreamer_sample YourStreamName YourRtspUrl
```
1. Connectez-vous à la console [Kinesis Video Streams AWS Management Console](https://console.aws.amazon.com//kinesisvideo/home/) et ouvrez-la.
Visionnez le stream.
1. Pour quitter le conteneur Docker, fermez la fenêtre du terminal ou tapez`exit`.
### À l'extérieur du conteneur Docker
Depuis **l'extérieur** du conteneur Docker, utilisez la commande suivante :
```
docker run -it YourImageId /bin/bash -c "export AWS_ACCESS_KEY_ID=YourAccessKeyId; export AWS_SECRET_ACCESS_KEY=YourSecretKeyId; export AWS_SESSION_TOKEN=YourSessionToken; export AWS_DEFAULT_REGION=Your AWS Region; ./kvs_gstreamer_sample YourStreamName YourRtspUrl"
```
# Exemple : analyse et rendu de fragments Kinesis Video Streams
[Diffuser à l'aide de la bibliothèque d'analyseurs](parser-library.md)Il contient une application de démonstration nommée `KinesisVideoRendererExample` qui explique l'analyse et le rendu de fragments de flux vidéo Amazon Kinesis. L'exemple permet [JCodec](http://jcodec.org/)de décoder les trames codées H.264 qui sont ingérées à l'aide de l'application. [Exemple : plugin GStreamer SDK Kinesis Video Streams Producer - kvssink](examples-gstreamer-plugin.md) Une fois le cadre décodé à l'aide JCodec, l'image visible est rendue à l'aide [JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html)de.
Cet exemple montre comment effectuer les opérations suivantes :
+ Récupérez des images d'un flux vidéo Kinesis à l'aide de l'`GetMedia`API et restituez le flux pour le visionner.
+ Affichez le contenu vidéo des flux dans une application personnalisée au lieu d'utiliser la console Kinesis Video Streams.
Vous pouvez également utiliser les classes de cet exemple pour afficher le contenu d'un flux vidéo Kinesis qui n'est pas codé au format H.264, tel qu'un flux de fichiers JPEG qui ne nécessitent pas de décodage avant d'être affichés.
La procédure suivante montre comment configurer et utiliser la démonstration du moteur de rendu.
## Conditions préalables
Pour examiner et utiliser l'exemple de bibliothèque de moteur de rendu, vous avez besoin des éléments suivants :
+ Un compte Amazon Web Services (AWS). Si vous n'avez pas encore de AWS compte, consultez [Getting Started with Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html).
+ Un environnement de développement intégré (IDE) Java, tel qu'[Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-jee-neon-3) ou [JetBrains IntelliJ](https://www.jetbrains.com/idea/download/) Idea.
## Exemple d'exécution du moteur de rendu
1. Créez un répertoire, puis clonez l'exemple de code source à partir du GitHub référentiel.
```
git clone https://github.com/aws/amazon-kinesis-video-streams-parser-library
```
1. Ouvrez l'IDE Java que vous utilisez (par exemple, [Eclipse](https://www.eclipse.org/) ou [IntelliJ IDEA](https://www.jetbrains.com/idea/)) et importez le projet Apache Maven que vous avez téléchargé :
+ **Dans Eclipse :** Choisissez **Fichier**, **Importer**, **Maven**, **Projets Maven existants**. Accédez au répertoire `kinesis-video-streams-parser-lib`.
+ **Dans IntelliJ Idea : ** Choisissez **Importer**. Naviguez vers le fichier `pom.xml` dans la racine du package téléchargé.
**Note**
Si IntelliJ ne parvient pas à trouver vos dépendances, vous pourriez avoir à exécuter les tâches suivantes :
**Nettoyage de build :** Choisissez **File (Fichier)**, **Settings (Paramètre)**, **Build, Execution, Deployment (Génération, exécution, déploiement)**, **Compiler (Compilateur)**. Vérifiez que l'option **Effacer le répertoire de sortie lors de la reconstruction** est sélectionnée, puis choisissez **Build**, **Build Project**.
**Réimportation du projet :** Ouvrez le menu contextuel (clic droit) du projet, puis choisissez**Maven**, **Reimport (Réimporter)**.
Pour plus d'informations, consultez la documentation relative à IDE.
1. À partir de votre IDE Java, ouvrez `src/test/java/com.amazonaws.kinesisvideo.parser/examples/KinesisVideoRendererExampleTest`.
1. Supprimez la directive `@Ignore` du fichier.
1. Mettez à jour le `.stream` paramètre avec le nom de votre flux vidéo Kinesis.
1. Exécutez le test `KinesisVideoRendererExample`.
## Comment ça marche
**Topics**
+ [Envoi des données MKV](#examples-renderer-howitworks-send)
+ [Analyse de fragments MKV en cadres](#examples-renderer-howitworks-parse)
+ [Décodage et affichage du cadre](#examples-renderer-howitworks-display)
### Envoi des données MKV
L'exemple envoie des exemples de données MKV à partir du `rendering_example_video.mkv` fichier, en les utilisant `PutMedia` pour envoyer des données vidéo à un flux nommé **render-example-stream**.
L'application crée un objet `PutMediaWorker` :
```
PutMediaWorker putMediaWorker = PutMediaWorker.create(getRegion(),
getCredentialsProvider(),
getStreamName(),
inputStream,
streamOps.amazonKinesisVideo);
executorService.submit(putMediaWorker);
```
Pour obtenir des informations sur la classe `PutMediaWorker`, consultez [Appel PutMedia](parser-library-write.md#parser-library-write-example-putmedia) dans la documentation de [Diffuser à l'aide de la bibliothèque d'analyseurs](parser-library.md).
### Analyse de fragments MKV en cadres
Cet exemple récupère et analyse ensuite les fragments MKV depuis le flux à l'aide d'un objet `GetMediaWorker` :
```
GetMediaWorker getMediaWorker = GetMediaWorker.create(getRegion(),
getCredentialsProvider(),
getStreamName(),
new StartSelector().withStartSelectorType(StartSelectorType.EARLIEST),
streamOps.amazonKinesisVideo,
getMediaProcessingArgumentsLocal.getFrameVisitor());
executorService.submit(getMediaWorker);
```
Pour plus d'informations sur la classe `GetMediaWorker`, consultez [Appel GetMedia](parser-library-write.md#parser-library-write-example-getmedia) dans la documentation de [Diffuser à l'aide de la bibliothèque d'analyseurs](parser-library.md).
### Décodage et affichage du cadre
L'exemple décode et affiche ensuite le cadre à l'aide [JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html)de.
L'exemple de code suivant provient de la classe `KinesisVideoFrameViewer`, qui étend `JFrame` :
```
public void setImage(BufferedImage bufferedImage) {
image = bufferedImage;
repaint();
}
```
L'image est affichée sous la forme d'une instance de [java.awt.image. BufferedImage](https://docs.oracle.com/javase/7/docs/api/java/awt/image/BufferedImage.html). Pour obtenir des exemples montrant comment utiliser `BufferedImage`, consultez [Lecture/Chargement d'une image](https://docs.oracle.com/javase/tutorial/2d/images/loadimage.html).