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.
# Rédiger et examiner le code
Dans cette section du[Utiliser la bibliothèque de production C\+\+](producer-sdk-cpp.md), vous examinez le code du harnais de test C\+\+ (`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\+\+ 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) \* 3 (minutes) \* 60 (secondes par minute) \* 10000 (ko) \* 1,2 (tolérance de défragmentation) = 194,4 Mo \~ 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\_AAC »).
+ Type de piste (par exemple, utilisez la valeur enum de MKV\_TRACK\_INFO\_TYPE\_AUDIO 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\+\+ 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\+\+ 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);
```