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 de production C\$1\$1 Vous pouvez utiliser la bibliothèque de production C\$1\$1 fournie par Amazon Kinesis Video Streams pour écrire du code d'application afin d'envoyer des données multimédia d'un appareil vers un flux vidéo Kinesis. ## Modèle d'objet La bibliothèque C\$1\$1 fournit les objets suivants pour gérer l'envoi de données vers un flux vidéo Kinesis : + **KinesisVideoProducer:** contient des informations sur votre source multimédia et vos AWS informations d'identification, et gère des rappels pour signaler les événements liés à Kinesis Video Streams. + **KinesisVideoStream:** représente le flux vidéo Kinesis. Contient 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\$1\$1 (par exemple,`PutFrame`) 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. ## Interfaces de rappel Cette couche propose un ensemble d'interfaces de rappel, ce qui lui permet de consulter la couche d'application. Parmi ces interfaces de rappel, on trouve : + **Interface de rappel de service (`CallbackProvider`) :** la bibliothèque invoque les événements obtenus via cette interface lorsqu'elle crée un flux, obtient une description de flux et supprime un flux. + **État prêt pour le client ou interface d'événements à faible capacité de stockage (`ClientCallbackProvider`) :** la bibliothèque invoque des événements sur cette interface lorsque le client est prêt ou lorsqu'elle détecte qu'il n'y a peut-être plus de stockage ou de mémoire disponible. + **Interface de rappel des événements de flux (`StreamCallbackProvider`) :** la bibliothèque invoque des événements sur cette interface lorsque des événements de flux se produisent, tels que l'entrée du flux dans l'état prêt, la perte d'images ou des erreurs de flux. Kinesis Video Streams fournit des implémentations par défaut pour ces interfaces. Vous pouvez également fournir votre propre implémentation personnalisée, par exemple, si vous avez besoin d'une logique réseau personnalisée ou si vous souhaitez exposer l'interface utilisateur à un faible niveau de stockage. Pour plus d'informations sur les rappels dans les bibliothèques du producteur, consultez[Rappels du SDK pour les producteurs](producer-reference-callbacks.md). ## Procédure : Utiliser le SDK du producteur C\$1\$1 Cette procédure explique comment utiliser le client Kinesis Video Streams et les sources multimédia dans une application C\$1\$1 pour envoyer des données à votre flux vidéo Kinesis. La procédure comprend les étapes suivantes : **Topics** # Conditions préalables Avant de configurer le SDK C\$1\$1 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` **Note** Cela n'est nécessaire que si vous créez une interface native Java (JNI). + Définissez la variable d'environnement :`JAVA_HOME` `export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/` # Téléchargez et configurez le code de la bibliothèque C\$1\$1 Producer Pour plus d'informations sur le téléchargement et la configuration de la bibliothèque de production C\$1\$1, consultez [Amazon Kinesis Video Streams CPP Producer GStreamer , Plugin](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) and JNI. Pour les prérequis et plus d'informations sur cet exemple, consultez[Utiliser la bibliothèque de production C\$1\$1](producer-sdk-cpp.md). ## CMake arguments Vous trouverez ci-dessous un tableau de référence pour les arguments spécifiques au SDK CMake C\$1\$1 Producer. Vous pouvez également transmettre les [ CMake options CMake standard](https://cmake.org/cmake/help/latest/manual/cmake-env-variables.7.html) à. **Important** Elles sont toutes facultatives. **Drapeaux indiquant l'inclusion ou l'exclusion de certaines fonctionnalités** | CMake argument | Type | Par défaut | Explication | | --- | --- | --- | --- | | `BUILD_DEPENDENCIES` | Booléen | ON | Créez des dépendances à partir de la source. Dans le cas contraire, utilisez les dépendances déjà installées sur le système. Si l'une des dépendances requises est introuvable, une erreur sera renvoyée. | | `BUILD_GSTREAMER_PLUGIN` | Booléen | OFF | Construit le kvssink GStreamer plugin. | | `BUILD_JNI` | Booléen | OFF | Construit l'interface native Java (JNI) pour pouvoir appeler ce code depuis un environnement d'exécution Java. | | `ALIGNED_MEMORY_MODEL` | Booléen | OFF | Si les allocations de mémoire doivent être alignées sur des limites de 8 octets. Certaines architectures n'autorisent pas l'accès à la mémoire non aligné. | | `CONSTRAINED_DEVICE` | Booléen | OFF | Uniquement pour les appareils autres que Windows. Lorsque cette option est activée, définit la taille de la pile de threads sur0.5 MiB. Nécessaire pour les versions d'[Alpine Linux](https://wiki.alpinelinux.org/wiki/Main_Page). Dans le cas contraire, c'est le système d'exploitation par défaut qui est utilisé. | | `BUILD_STATIC` | Booléen | OFF | Créez des bibliothèques et des exécutables [partagés](https://en.wikipedia.org/wiki/Shared_library) (OFF) ou [statiques](https://en.wikipedia.org/wiki/Static_library) (ON). | | `ADD_MUCLIBC` | Booléen | OFF | Lien vers [UClibc](https://en.wikipedia.org/wiki/UClibc) au lieu de la bibliothèque C standard, qui est une bibliothèque standard C plus petite conçue pour les systèmes embarqués. | | `OPEN_SRC_INSTALL_PREFIX` | String | .. /open-source/local | Emplacement où installer les dépendances open source, si vous créez à partir des sources. | **Drapeaux pour la compilation croisée** **Important** Définissez ces paramètres si les architectures de processeur de votre machine cible et de votre machine hôte sont différentes. | CMake argument | Type | Par défaut | Explication | | --- | --- | --- | --- | | `BUILD_LOG4CPLUS_HOST` | String | "" | Créez la log4cplus dépendance pour l'architecture de processeur spécifiée. S'il n'est pas défini, log4cplus il détectera automatiquement et utilisera l'architecture du processeur de la machine hôte. | | `BUILD_OPENSSL_PLATFORM` | String | "" | Créez la OpenSSL dépendance pour l'architecture de processeur spécifiée. S'il n'est pas défini, OpenSSL il détectera automatiquement et utilisera l'architecture du processeur de la machine hôte. | **Drapeaux liés aux tests** | CMake argument | Type | Par défaut | Explication | | --- | --- | --- | --- | | `BUILD_TEST` | Booléen | OFF | Créez les tests unitaires et d'intégration. Pour exécuter tous les tests, exécutez-les ./tst/producerTest depuis le répertoire de construction. AWS Des informations d'identification sont nécessaires pour exécuter les tests. | | `CODE_COVERAGE` | Booléen | OFF | Disponible uniquement pour les GNU/Clang compilateurs. Activez la collecte de la couverture du code avec [gcov et la génération](https://gcc.gnu.org/onlinedocs/gcc/Gcov.html) de rapports. | | `COMPILER_WARNINGS` | Booléen | OFF | Disponible uniquement pour les GNU/Clang compilateurs. Activez tous les avertissements du compilateur. | | `ADDRESS_SANITIZER` | Booléen | OFF | Disponible uniquement pour les GNU/Clang compilateurs. Construisez avec [AddressSanitizer](https://compiler-rt.llvm.org/). | | `MEMORY_SANITIZER` | Booléen | OFF | Disponible uniquement pour les GNU/Clang compilateurs. Construisez avec [MemorySanitizer](https://compiler-rt.llvm.org/). | | `THREAD_SANITIZER` | Booléen | OFF | Disponible uniquement pour les GNU/Clang compilateurs. Construisez avec [ThreadSanitizer](https://compiler-rt.llvm.org/). | | `UNDEFINED_BEHAVIOR_SANITIZER` | Booléen | OFF | Disponible uniquement pour les GNU/Clang compilateurs. Construisez avec [UndefinedBehaviorSanitizer](https://compiler-rt.llvm.org/). | Pour utiliser ces CMake arguments, transmettez-les sous forme de liste de `-Dkey=value` paires séparées par des espaces après la `cmake ..` commande. Par exemple : ``` cmake .. -DBUILD_GSTREAMER_PLUGIN=ON -DBUILD_DEPENDENCIES=OFF -DALIGNED_MEMORY_MODEL=ON ``` CMake recherchera la chaîne d'outils du compilateur en suivant la `$PATH` variable. Avant l'exécution CMake, définissez les variables d'`CXX`environnement `CC` et pour définir explicitement la chaîne d'outils à utiliser pour la compilation croisée. # Rédiger et examiner le code Dans cette section du[Utiliser la bibliothèque de production C\$1\$1](producer-sdk-cpp.md), vous examinez le code du harnais de test C\$1\$1 (`tst/ProducerTestFixture.h`et d'autres fichiers). Vous avez téléchargé ce code dans la section précédente. L'exemple de **Plateforme indépendante** C\$1\$1 suivant illustre le modèle de codage suivant : + Créez une instance de `KinesisVideoProducer` pour accéder à Kinesis Video Streams. + Créez une instance de `KinesisVideoStream`. Cela crée un flux vidéo Kinesis dans votre Compte AWS si aucun flux du même nom n'existe déjà. + Appelez `putFrame` sur le `KinesisVideoStream` pour chaque image de données à mesure de sa disponibilité, pour l'envoyer au flux. Les sections suivantes fournissent plus d'informations sur ce modèle de codage. ## Créez une instance de KinesisVideoProducer Vous créez l'objet `KinesisVideoProducer` en appelant la méthode `KinesisVideoProducer::createSync`. L'exemple suivant crée l'`KinesisVideoProducer` dans le fichier `ProducerTestFixture.h` : ``` kinesis_video_producer_ = KinesisVideoProducer::createSync(move(device_provider_), move(client_callback_provider_), move(stream_callback_provider_), move(credential_provider_), defaultRegion_); ``` La méthode `createSync` prend les paramètres suivants : + Un objet `DeviceInfoProvider` qui renvoie un objet `DeviceInfo` contenant des informations relatives à la configuration de l'appareil ou du stockage. **Note** Vous configurez la taille de votre magasin de contenu à l'aide du paramètre `deviceInfo.storageInfo.storageSize`. Vos flux de contenu partagent le magasin de contenu. Pour déterminer les exigences en termes de taille de stockage, multipliez la taille d'image moyenne par le nombre d'images stockées pendant la durée maximale pour tous les flux. Ensuite, multipliez le résultat par 1,2 pour prendre en compte la défragmentation. Par exemple, supposez que votre application a la configuration suivante : Trois flux 3 minutes de durée maximale Chaque flux comprend 30 images par seconde (FPS) Chaque image a une taille de 10 000 Ko L'exigence de stockage de contenu pour cette application est de **3 (flux) \$1 3 (minutes) \$1 60 (secondes par minute) \$1 10000 (ko) \$1 1,2 (tolérance de défragmentation) = 194,4 Mo \$1 200 Mo**. + Un objet `ClientCallbackProvider` objet qui renvoie les pointeurs de fonction rapportant les événements spécifiques au client. + Un objet `StreamCallbackProvider` qui renvoie les pointeurs de fonction qui sont appelés lors d'événements spécifiques au flux. + Un `CredentialProvider` objet qui donne accès aux variables d'environnement AWS d'identification. + Le Région AWS (« us-west-2 »). Le point de terminaison de service est déterminé selon la région. ## Créez une instance de KinesisVideoStream Vous créez l'objet `KinesisVideoStream` en appelant la méthode `KinesisVideoProducer::CreateStream` avec un paramètre `StreamDefinition`. L'exemple crée le flux `KinesisVideoStream` dans le fichier `ProducerTestFixture.h` avec le type de piste vidéo et l'ID de piste 1 : ``` auto stream_definition = make_unique(stream_name, hours(2), tags, "", STREAMING_TYPE_REALTIME, "video/h264", milliseconds::zero(), seconds(2), milliseconds(1), true, true, true); return kinesis_video_producer_->createStream(move(stream_definition)); ``` L'objet `StreamDefinition` comporte les champs suivants : + Nom du flux. + Durée de conservation. + Balises pour le flux. Ces balises peuvent être utilisées par des applications de consommateurs pour trouver le bon flux ou pour obtenir plus d'informations sur le flux. Les balises peuvent également être affichés dans la AWS Management Console. + AWS KMS clé de chiffrement pour le flux. Pour de plus amples informations, veuillez consulter [Protection des données dans Kinesis Video Streams](how-kms.md). + Type de streaming. Actuellement, la seule valeur valide est `STREAMING_TYPE_REALTIME`. + Type de contenu média. + Latence de média. Cette valeur n'est pas utilisée actuellement et doit être définie sur 0. + Durée de lecture de chaque fragment. + Mise à l'échelle du timecode média. + Si le média utilise la fragmentation des images de la clé. + Si le média utilise des timecodes. + Si le média utilise des fragments absolus. ## Ajouter une piste audio au flux vidéo Kinesis Vous pouvez ajouter les détails d'une piste audio à la définition d'un flux de piste vidéo en utilisant la `addTrack` méthode suivante `StreamDefinition` : ``` stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO); ``` La `addTrack` méthode nécessite les paramètres suivants : + Identifiant de piste (identique à celui de l'audio). Il doit s'agir d'une valeur unique différente de zéro. + Nom de piste défini par l'utilisateur (par exemple, « audio » pour la piste audio). + Identifiant du codec pour cette piste (par exemple, pour la piste audio « A\$1AAC »). + Type de piste (par exemple, utilisez la valeur enum de MKV\$1TRACK\$1INFO\$1TYPE\$1AUDIO pour l'audio). Si vous avez des données privées codec pour la piste audio, vous pouvez les transmettre lors de l'appel de la fonction addTrack. Vous pouvez également envoyer les données privées du codec après avoir créé l' KinesisVideoStream objet lors de l'appel de la méthode start in KinesisVideoStream. ## Insérer une image dans le flux vidéo Kinesis Vous insérez du contenu multimédia dans le flux vidéo Kinesis en utilisant`KinesisVideoStream::putFrame`, en transmettant un `Frame` objet contenant l'en-tête et les données multimédia. L'exemple appelle `putFrame` dans le fichier `ProducerApiTest.cpp` : ``` frame.duration = FRAME_DURATION_IN_MICROS * HUNDREDS_OF_NANOS_IN_A_MICROSECOND; frame.size = SIZEOF(frameBuffer_); frame.frameData = frameBuffer_; MEMSET(frame.frameData, 0x55, frame.size); while (!stop_producer_) { // Produce frames timestamp = std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch()).count() / DEFAULT_TIME_UNIT_IN_NANOS; frame.index = index++; frame.decodingTs = timestamp; frame.presentationTs = timestamp; // Key frame every 50th frame.flags = (frame.index % 50 == 0) ? FRAME_FLAG_KEY_FRAME : FRAME_FLAG_NONE; ... EXPECT_TRUE(kinesis_video_stream->putFrame(frame)); ``` **Note** L'exemple de producteur C\$1\$1 précédent envoie une mémoire tampon de données de test. Dans une application réelle, vous devez obtenir le tampon et la taille de l'image depuis les données de l'image à partir d'une source média (par exemple, une caméra). L'objet `Frame` comporte les champs suivants : + Index d'image. Ce doit être une valeur croissante de manière monotone. + Indicateurs associés à l'image. Par exemple, si l'encodeur a été configuré pour produire un image de clé, cette image sera attribuée à l'indicateur `FRAME_FLAG_KEY_FRAME`. + Horodatage de décodage. + Horodatage de la présentation. + Durée de l'image (jusqu'à 100 unités ns). + Taille de l'image, en octets. + Données de l'image. Pour plus d'informations sur le format du cadre, consultez [Modèle de données Kinesis Video Streams](how-data.md). ## Placer un KinesisVideoFrame dans une piste spécifique de KinesisVideoStream Vous pouvez utiliser la `PutFrameHelper` classe pour placer des données de trame dans une piste spécifique. Tout d'abord, appelez le `getFrameDataBuffer` pour obtenir un pointeur vers l'un des tampons préalloués afin de renseigner les `KinesisVideoFrame` données. Ensuite, vous pouvez appeler le `putFrameMultiTrack` pour envoyer le `KinesisVideoFrame` avec la valeur booléenne pour indiquer le type de données de trame. Utilisez la valeur true s'il s'agit de données vidéo ou false si la trame contient des données audio. La `putFrameMultiTrack` méthode utilise un mécanisme de mise en file d'attente pour garantir que les fragments MKV conservent des horodatages d'image qui augmentent de façon monotone et que deux fragments ne se chevauchent pas. Par exemple, l'horodatage MKV de la première image d'un fragment doit toujours être supérieur à l'horodatage MKV de la dernière image du fragment précédent. `PutFrameHelper`comporte les champs suivants : + Nombre maximal d'images audio dans la file d'attente. + Nombre maximum d'images vidéo dans la file d'attente. + Taille à allouer pour une seule image audio. + Taille à allouer pour une seule image vidéo. ## Métriques d'accès et journalisation des métriques Le SDK C\$1\$1 Producer inclut des fonctionnalités pour les métriques et la journalisation des métriques. Vous pouvez utiliser les opérations `getKinesisVideoMetrics` et `getKinesisVideoStreamMetrics` API pour récupérer des informations sur Kinesis Video Streams et vos flux actifs. Le code suivant provient du fichier `kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h`. ``` /** * Gets information about the storage availability. * * @param 1 CLIENT_HANDLE - the client object handle. * @param 2 PKinesisVideoMetrics - OUT - Kinesis Video metrics to be filled. * * @return Status of the function call. */ PUBLIC_API STATUS getKinesisVideoMetrics(CLIENT_HANDLE, PKinesisVideoMetrics); /** * Gets information about the stream content view. * * @param 1 STREAM_HANDLE - the stream object handle. * @param 2 PStreamMetrics - Stream metrics to fill. * * @return Status of the function call. */ PUBLIC_API STATUS getKinesisVideoStreamMetrics(STREAM_HANDLE, PStreamMetrics); ``` L'objet `PClientMetrics` rempli par `getKinesisVideoMetrics` contient les informations suivantes : + **contentStoreSize:** taille globale en octets du magasin de contenu (mémoire utilisée pour stocker les données de streaming). + **contentStoreAvailableTaille :** mémoire disponible dans le magasin de contenu, en octets. + **contentStoreAllocatedTaille :** mémoire allouée dans le magasin de contenu. + **totalContentViewsTaille :** mémoire totale utilisée pour l'affichage du contenu. L'affichage du contenu est une série d'indices d'informations dans le magasin de contenu. + **totalFrameRate:** le nombre total d'images par seconde pour tous les flux actifs. + **totalTransferRate:** le nombre total de bits par seconde (bps) envoyés dans tous les flux. L'objet `PStreamMetrics` rempli par `getKinesisVideoStreamMetrics` contient les informations suivantes : + **currentViewDuration:** différence en unités de 100 ns entre la tête de la vue du contenu (lorsque les images sont codées) et la position actuelle (lorsque les données d'image sont envoyées à Kinesis Video Streams). + **overallViewDuration:** différence en unités de 100 ns entre la tête de la vue du contenu (lorsque les images sont codées) et la fin (lorsque les images sont vidées de la mémoire, soit parce que l'espace total alloué à l'affichage du contenu est dépassé, soit parce qu'un `PersistedAck` message est reçu de Kinesis Video Streams et que les images connues pour être persistantes sont vidées). + **currentViewSize:** taille en octets du contenu affiché entre la tête (lorsque les images sont codées) et la position actuelle (lorsque les images sont envoyées à Kinesis Video Streams). + **overallViewSize:** taille totale en octets de l'affichage du contenu. + **currentFrameRate:** dernière fréquence mesurée du flux, en images par seconde. + **currentTransferRate:** dernier débit mesuré du flux, en octets par seconde. ## Démontage Si vous souhaitez envoyer les octets restants dans un tampon et attendre le `ACK`, vous pouvez utiliser `stopSync` : ``` kinesis_video_stream->stopSync(); ``` Vous pouvez également appeler `stop` pour mettre fin au streaming : ``` kinesis_video_stream->stop(); ``` Après avoir arrêté le flux, vous pouvez le libérer en appelant l'API suivante : ``` kinesis_video_producer_->freeStream(kinesis_video_stream); ``` # 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), consultez les instructions spécifiques au système d'exploitation suivantes : + [Linux](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/linux.md) + [macOS](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/macos.md) + [Windows](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/windows.md) + [OS Raspberry Pi](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/raspberry-pi.md) Vous pouvez surveiller le trafic sur votre stream en observant les métriques associées à votre stream dans la CloudWatch console Amazon, telles que`PutMedia.IncomingBytes`. # Utiliser le SDK C\$1\$1 Producer en tant que plugin GStreamer [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. Pour plus d'informations sur l'utilisation du SDK C\$1\$1 Producer en tant que GStreamer plug-in, consultez[Exemple : plugin GStreamer SDK Kinesis Video Streams Producer - kvssink](examples-gstreamer-plugin.md). # Utiliser le SDK C\$1\$1 Producer en tant que GStreamer plugin dans un conteneur Docker [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. En outre, 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'exécution de l'application. Pour plus d'informations sur l'utilisation du SDK C\$1\$1 Producer en tant que GStreamer plug-in dans un conteneur Docker, consultez. [Exécuter l' GStreamer élément dans un conteneur Docker](examples-gstreamer-plugin.md#examples-gstreamer-plugin-docker) # Utiliser la journalisation avec le SDK C\$1\$1 Producer Vous configurez la journalisation pour les applications du SDK C\$1\$1 Producer dans le `kvs_log_configuration` fichier du `kinesis-video-native-build` dossier. L'exemple suivant montre la première ligne du fichier de configuration par défaut, qui configure l'application pour écrire les entrées de journal de niveau `DEBUG` dans la AWS Management Console: ``` log4cplus.rootLogger=DEBUG, KvsConsoleAppender ``` Vous pouvez définir le niveau de journalisation sur `INFO` pour une journalisation avec moins de commentaires. Pour configurer l'application afin qu'elle écrive des entrées de journal dans un fichier journal, mettez à jour la première ligne du fichier comme suit : ``` log4cplus.rootLogger=DEBUG, KvsConsoleAppender, KvsFileAppender ``` Cela configure l'application pour écrire les entrées de journal dans `kvs.log`, dans le dossier `kinesis-video-native-build/log`. Pour modifier l'emplacement du fichier journal, mettez à jour la ligne suivante avec le nouveau chemin d'accès : ``` log4cplus.appender.KvsFileAppender.File=./log/kvs.log ``` **Note** Si la journalisation de niveau `DEBUG` s'effectue dans un fichier, le fichier journal peut rapidement utiliser tout l'espace de stockage disponible sur l'appareil.