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 duUtiliser la bibliothèque de production C++, vous examinez le code du harnais de test C++ (tst/ProducerTestFixture.het 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 :

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 :

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<StreamDefinition>(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 :

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 :

Si vous avez des données privées du codec pour la piste audio, vous pouvez les transmettre lors de l'appel de la addTrack fonction. 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 utilisantKinesisVideoStream::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::nanoseconds>(
                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));

L'objet Frame comporte les champs suivants :

Pour plus d'informations sur le format du cadre, consultez Modèle de données Kinesis Video Streams.

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 MKV fragments conservent des horodatages d'image qui augmentent de façon monotone et que deux fragments ne se chevauchent pas. Par exemple, l'MKVhorodatage de la première image d'un fragment doit toujours être supérieur à l'MKVhorodatage de la dernière image du fragment précédent.

PutFrameHelpercomporte les champs suivants :

Métriques d'accès et journalisation des métriques

Le producteur C++ SDK inclut des fonctionnalités pour les métriques et la journalisation des métriques.

Vous pouvez utiliser les getKinesisVideoStreamMetrics API opérations getKinesisVideoMetrics et 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 :

L'objet PStreamMetrics rempli par getKinesisVideoStreamMetrics contient les informations suivantes :

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 invoquant ce qui suit : API

kinesis_video_producer_->freeStream(kinesis_video_stream);