Étape 2 : Écrire et examiner le code

Dans cette section de la procédure de la bibliothèque Producer C++, vous examinez le code dans l'environnement de test C++ (tst/ProducerTestFixture.h et 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éation d'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éation d'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 :

• 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 plus d'informations, consultez la section Utilisation du chiffrement côté serveur avec Kinesis Video Streams.

• 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 à l'aide de la StreamDefinition méthode AddTrack :

stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO);

La méthode addTrack a besoin des 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 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));

Note

L'exemple Producteur C++ précédent envoie un 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 de l'image, consultez le 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. Appelez d'abord le getFrameData Buffer pour obtenir un pointeur vers l'un des tampons préalloués afin de renseigner les KinesisVideoFrame données. Ensuite, vous pouvez appeler le putFrameMulti Track pour l'envoyer KinesisVideoFrame avec la valeur booléenne indiquant 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 méthode putFrameMulti Track 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 et journalisation des métriques

Le kit SDK Producteur C++ comprend la fonctionnalité de métriques et de journalisation de métrique.

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); 
            

Étape suivante

Étape 3 : Exécuter et vérifier le code