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 la bibliothèque C Producer
Vous pouvez utiliser la bibliothèque C Producer fournie par Amazon Kinesis Video Streams pour écrire le code d'application permettant d'envoyer des données multimédia d'un appareil vers un flux vidéo Kinesis.
## Modèle d'objet
[La bibliothèque de production Kinesis Video Streams C est basée sur un composant commun appelé Platform Independent Codebase (PIC), disponible GitHub sur https://github.com/awslabs/ amazon-kinesis-video-streams -pic/.](https://github.com/awslabs/amazon-kinesis-video-streams-pic/) Le PIC contient une logique métier indépendante de la plate-forme pour les composants de base. La bibliothèque de production Kinesis Video Streams C intègre à PIC une couche supplémentaire d'API qui permet des rappels et des événements spécifiques au scénario et à la plate-forme. La bibliothèque de production Kinesis Video Streams C comprend les composants suivants basés sur PIC :
+ **Fournisseurs d'informations sur les appareils** : expose la `DeviceInfo` structure qui peut être directement fournie à l'API PIC. Vous pouvez configurer un ensemble de fournisseurs, y compris un fournisseur optimisé pour les scénarios d'application qui peut optimiser le magasin de contenu en fonction du nombre et des types de flux gérés par votre application et de la quantité de mémoire tampon requise configurée en fonction de la quantité de RAM disponible.
+ **Fournisseur d'informations de flux** — Expose la `StreamInfo` structure qui peut être directement fournie à l'API PIC. Il existe un ensemble de fournisseurs spécifiques aux types d'applications et aux types courants de scénarios de streaming. Il s'agit notamment de fournisseurs tels que la vidéo, l'audio et le multipiste audio et vidéo. Chacun de ces scénarios comporte des paramètres par défaut que vous pouvez personnaliser en fonction des exigences de votre application.
+ **Fournisseur de rappel** — Expose la `ClientCallbacks` structure qui peut être directement fournie à l'API PIC. Cela inclut un ensemble de fournisseurs de rappels pour la mise en réseau (rappels d'API basés sur CURL), l'autorisation (API d'AWS identification) et le rappel des tentatives de streaming en cas d'erreur. L'API Callback Provider utilise un certain nombre d'arguments pour être configurée, tels que les informations d'autorisation Région AWS et. Cela se fait en utilisant des certificats IoT ou en utilisant AWS AccessKeyId SecretKey, ou SessionToken. Vous pouvez améliorer le fournisseur de rappel avec des rappels personnalisés si votre application a besoin du traitement ultérieur d’un rappel particulier pour répondre à une logique spécifique à une application.
+ **FrameOrderCoordinator**— Permet de gérer la synchronisation audio et vidéo pour les scénarios multipistes. Il possède un comportement par défaut, que vous pouvez personnaliser pour gérer la logique spécifique de votre application. Il rationalise également l'empaquetage des métadonnées de trame dans la structure PIC Frame avant de le soumettre à l'API PIC de couche inférieure. Pour les scénarios non multipistes, ce composant est une passerelle vers l’API putFrame PIC.
La bibliothèque C fournit les objets suivants pour gérer l'envoi de données vers un flux vidéo Kinesis :
+ **KinesisVideoClient**— Contient des informations sur votre appareil et gère des rappels pour signaler les événements liés à Kinesis Video Streams.
+ **KinesisVideoStream**— Représente des informations sur les paramètres du flux vidéo, tels que le nom, la durée de conservation des données et le type de contenu multimédia.
## Insérez du contenu multimédia dans le stream
Vous pouvez utiliser les méthodes fournies par la bibliothèque C (par exemple,`PutKinesisVideoFrame`) pour insérer des données dans l'`KinesisVideoStream`objet. La bibliothèque gère ensuite l'état interne des données, ce qui peut inclure les tâches suivantes :
+ Réalisation de l'authentification.
+ Supervision de la latence du réseau. Si la latence est trop élevée, la bibliothèque peut choisir d'abandonner des images.
+ Suivi de l'état du streaming en cours.
## Procédure : utiliser le SDK du producteur C
Cette procédure explique comment utiliser le client Kinesis Video Streams et les sources multimédia dans une application C pour envoyer des images vidéo codées en H.264 vers votre flux vidéo Kinesis.
La procédure comprend les étapes suivantes :
+ [Téléchargez le code de la bibliothèque C Producer](producersdk-c-download.md)
+ [Rédiger et examiner le code](producersdk-c-write.md)
+ [Exécutez et vérifiez le code](producersdk-c-test.md)
# Conditions préalables
Avant de configurer le SDK C Producer, assurez-vous de remplir les conditions préalables suivantes :
+ **Informations d'identification** — Dans l'exemple de code, vous fournissez des informations d'identification en spécifiant un profil que vous avez configuré dans votre fichier de profil AWS d'informations d'identification. Si vous n'y avez pas encore procédé, commencez par définir votre profil à 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/v1/developer-guide/setup-credentials.html).
+ **Intégration du magasin de certificats** — La bibliothèque du producteur Kinesis Video Streams doit établir un lien de confiance avec le service qu'elle appelle. Cela se fait en validant les autorités de certification (CAs) dans le magasin de certificats public. Sur les modèles basés sur Linux, ce magasin est localisé dans le répertoire `/etc/ssl`/.
Télécharger le certificat depuis l'emplacement suivant vers votre magasin de certificats :
[https://www.amazontrust.com/repository/SFSRootCAG2.pem](https://www.amazontrust.com/repository/SFSRootCAG2.pem)
+ Installez les dépendances de build suivantes pour macOS :
+ [Autoconf 2.69](http://www.gnu.org/software/autoconf/autoconf.html) (Licence GPLv3 \$1/Autoconf : GNU GPL version 3 ou ultérieure)
+ [CMake 3.7 ou 3.8](https://cmake.org/)
+ [Pkg-Config](https://www.freedesktop.org/wiki/Software/pkg-config/)
+ xCode (macOS) / clang / gcc (xcode-select version 2347)
+ Kit de développement Java (JDK) (pour compilation Java JNI)
+ [Lib-Pkg](https://github.com/freebsd/pkg/tree/master/libpkg)
+ Installez les dépendances de build suivantes pour Ubuntu :
+ Git : `sudo apt install git`
+ [CMake](http://kitware.com/cmake): `sudo apt install cmake`
+ G \$1\$1 : `sudo apt install g++`
+ configuration du fichier : `sudo apt install pkg-config`
+ OpenJDK : `sudo apt install openjdk-8-jdk`
+ Définissez la variable d'environnement :`JAVA_HOME` `export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/`
# Téléchargez le code de la bibliothèque C Producer
Dans cette section, vous téléchargez les bibliothèques de bas niveau. Pour les conditions préalables et autres informations concernant cet exemple, consultez [Utiliser la bibliothèque de production C\$1\$1](producer-sdk-cpp.md).
1. Créez un répertoire, puis clonez l'exemple de code source à partir du GitHub référentiel.
```
git clone --recursive https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git
```
**Note**
Si vous n'exécutez pas la commande git clone avec `--recursive`, exécutez `git submodule update --init` dans le répertoire `amazon-kinesis-video-streams-producer-c/open-source`. Vous devez également installer pkg-config et un CMake environnement de construction.
Pour plus d'informations, consultez le fichier `README.md` in [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git).
1. Ouvrez le code dans l'environnement de développement intégré (IDE) de votre choix (par exemple, [Eclipse](https://www.eclipse.org/)).
# Rédiger et examiner le code
Dans cette section, vous allez examiner le code de l'exemple d'application `KvsVideoOnlyStreamingSample.c` dans le `samples` dossier du dépôt [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c) on. GitHub Vous avez téléchargé ce code lors de l’étape précédente. Cet exemple montre comment utiliser la bibliothèque C Producer pour envoyer des images vidéo codées H.264 à l'intérieur du dossier vers `samples/h264SampleFrames` votre flux vidéo Kinesis.
Cet exemple d'application contient trois sections :
+ Initialisation et configuration :
+ Initialisation et configuration du pipeline de médias spécifique à la pateforme.
+ Initialisation et configuration KinesisVideoClient et KinesisVideoStream pour le pipeline, définition des rappels, intégration de l'authentification spécifique au scénario, extraction et soumission des données privées du codec et mise du flux à l'état READY.
+ Boucle principale :
+ Obtention de l’image de la part du pipeline multimédias avec les horodatages et les balises.
+ Soumission du cadre au KinesisVideoStream.
+ Démontage :
+ Arrêt (synchronisation) KinesisVideoStream, libération KinesisVideoStream, libération KinesisVideoClient.
Cet exemple d'application exécute les tâches suivantes :
+ Appelez l'API `createDefaultDeviceInfo` pour créer l'objet `deviceInfo` qui contient des informations sur le périphérique ou la configuration du stockage.
```
// default storage size is 128MB. Use setDeviceInfoStorageSize after create to change storage size.
CHK_STATUS(createDefaultDeviceInfo(&pDeviceInfo));
// adjust members of pDeviceInfo here if needed
pDeviceInfo->clientInfo.loggerLogLevel = LOG_LEVEL_DEBUG;
```
+ Appelez l'API `createRealtimeVideoStreamInfoProvider` pour créer l'objet `StreamInfo`.
```
CHK_STATUS(createRealtimeVideoStreamInfoProvider(streamName, DEFAULT_RETENTION_PERIOD, DEFAULT_BUFFER_DURATION, &pStreamInfo));
// adjust members of pStreamInfo here if needed
```
+ Appelez l'`createDefaultCallbacksProviderWithAwsCredentials`API pour créer le fournisseur de rappels par défaut sur la base d' AWS informations d'identification statiques.
```
CHK_STATUS(createDefaultCallbacksProviderWithAwsCredentials(accessKey,
secretKey,
sessionToken,
MAX_UINT64,
region,
cacertPath,
NULL,
NULL,
FALSE,
&pClientCallbacks));
```
+ Appelez l'`createKinesisVideoClient`API pour créer l'`KinesisVideoClient`objet qui contient des informations sur le stockage de votre appareil et gère les rappels pour signaler les événements Kinesis Video Streams.
```
CHK_STATUS(createKinesisVideoClient(pDeviceInfo, pClientCallbacks, &clientHandle));
```
+ Appelez l'API `createKinesisVideoStreamSync` pour créer l'objet `KinesisVideoStream`.
```
CHK_STATUS(createKinesisVideoStreamSync(clientHandle, pStreamInfo, &streamHandle));
```
+ Configurez un exemple d’image et appelez l’API `PutKinesisVideoFrame` pour envoyer cette image à l’objet `KinesisVideoStream`.
```
// setup sample frame
MEMSET(frameBuffer, 0x00, frameSize);
frame.frameData = frameBuffer;
frame.version = FRAME_CURRENT_VERSION;
frame.trackId = DEFAULT_VIDEO_TRACK_ID;
frame.duration = HUNDREDS_OF_NANOS_IN_A_SECOND / DEFAULT_FPS_VALUE;
frame.decodingTs = defaultGetTime(); // current time
frame.presentationTs = frame.decodingTs;
while(defaultGetTime() > streamStopTime) {
frame.index = frameIndex;
frame.flags = fileIndex % DEFAULT_KEY_FRAME_INTERVAL == 0 ? FRAME_FLAG_KEY_FRAME : FRAME_FLAG_NONE;
frame.size = SIZEOF(frameBuffer);
CHK_STATUS(readFrameData(&frame, frameFilePath));
CHK_STATUS(putKinesisVideoFrame(streamHandle, &frame));
defaultThreadSleep(frame.duration);
frame.decodingTs += frame.duration;
frame.presentationTs = frame.decodingTs;
frameIndex++;
fileIndex++;
fileIndex = fileIndex % NUMBER_OF_FRAME_FILES;
}
```
+ Démontage :
```
CHK_STATUS(stopKinesisVideoStreamSync(streamHandle));
CHK_STATUS(freeKinesisVideoStream(&streamHandle));
CHK_STATUS(freeKinesisVideoClient(&clientHandle));
```
# Exécutez et vérifiez le code
Pour exécuter et vérifier le code du[Utiliser la bibliothèque de production C\$1\$1](producer-sdk-cpp.md), procédez comme suit :
1. Exécutez les commandes suivantes pour créer un `build` répertoire dans le [SDK C que vous avez téléchargé](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git), puis `cmake` lancez-le :
```
mkdir -p amazon-kinesis-video-streams-producer-c/build;
cd amazon-kinesis-video-streams-producer-c/build;
cmake ..
```
Vous pouvez transmettre les options suivantes à `cmake ..`
+ `-DBUILD_DEPENDENCIES`- s'il faut construire des bibliothèques dépendantes à partir des sources.
+ `-DBUILD_TEST=TRUE`- construire des tests unitaires et d'intégration. Cela peut être utile pour confirmer que votre appareil est compatible.
`./tst/webrtc_client_test`
+ `-DCODE_COVERAGE`- activer les rapports de couverture.
+ `-DCOMPILER_WARNINGS`- active tous les avertissements du compilateur.
+ `-DADDRESS_SANITIZER`- construire avec AddressSanitizer.
+ `-DMEMORY_SANITIZER`- construire avec MemorySanitizer.
+ `-DTHREAD_SANITIZER`- construire avec ThreadSanitizer.
+ `-DUNDEFINED_BEHAVIOR_SANITIZER`- construire avec UndefinedBehaviorSanitizer.
+ `-DALIGNED_MEMORY_MODEL` - créer pour les appareils avec modèle de mémoire alignés uniquement. La valeur par défaut est `OFF`.
1. Accédez au `build` répertoire que vous venez de créer à l'étape précédente et lancez-le `make` pour créer le SDK WebRTC C et les exemples fournis.
```
make
```
1. L'exemple d'application `kinesis_video_cproducer_video_only_sample` envoie à Kinesis Video Streams des images vidéo codées en H.264 contenues dans `samples/h264SampleFrames` le dossier. La commande suivante envoie les images vidéo en boucle pendant dix secondes à Kinesis Video Streams :
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10
```
Si vous souhaitez envoyer des images codées en H.264 depuis un autre dossier (par exemple,`MyH264FramesFolder`), exécutez l'exemple avec les arguments suivants :
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10 MyH264FramesFolder
```
1. Pour activer les journaux commentés, définissez les C-define `HEAP_DEBUG` et `LOG_STREAMING` en supprimant les commentaires des lignes appropriées dans `CMakeList.txt`.
Vous pouvez surveiller la progression de la gamme de test dans la sortie de débogage dans votre IDE. Vous pouvez également surveiller le trafic sur votre stream en regardant les métriques associées à votre stream dans la CloudWatch console Amazon, telles que`PutMedia.IncomingBytes`.
**Note**
La console n'affiche pas les données sous forme de flux vidéo, dans la mesure où le harnais de test envoie uniquement des images vides en octets