| L'échelle de code horaire MKV en millisecondes qui spécifie la granularité des codes horaires pour les images au sein du cluster MKV. Le code horaire d'image MKV est toujours relatif par rapport au démarrage du cluster. MKV utilise une valeur 16 bits signée (0-32767) pour représenter le code horaire au sein du cluster (fragment). Vérifiez que le code temporel de l'image peut être représenté avec l'échelle de code temporel donnée. La valeur d'échelle de code horaire par défaut de 1 ms garantit la représentation de la plus grande image en 32767 ms \$1 = 32 secondes. Cela dépasse la durée de fragment maximum spécifiée dans [Quotas du service Amazon Kinesis Video Streams](limits.md) qui est de 10 secondes. | 1 |
| key\$1frame\$1fragmentation | bool | Indique s'il faut générer des fragments sur une image clé. Si la valeur est true, le kit SDK génère un début de fragment à chaque image clé. Sifalse, Kinesis Video Streams attend fragment\$1duration au moins et produit un nouveau fragment sur l'image clé qui le suit. | true |
| frame\$1timecodes | bool | Indique s'il faut utiliser codes horaires d'image ou générer des horodatages à l'aide du rappel actuel. De nombreux encodeurs ne génèrent pas d'horodatages avec les images. La spécification false de ce paramètre garantit donc que les images sont horodatées lorsqu'elles sont placées dans Kinesis Video Streams. | true |
| absolute\$1fragment\$1times | bool | Kinesis Video Streams utilise MKV comme mécanisme d'empaquetage sous-jacent. La spécification MKV est stricte en ce qui concerne l'aspect relatif du code horaire d'image par rapport au début du cluster (fragment). Toutefois, les codes horaires de cluster peuvent être absolus ou relatifs par rapport à l'heure de démarrage du flux. Si les horodatages sont relatifs, l'appel de l'API de service PutMedia utilisera l'horodatage de démarrage de flux facultatif et ajustera les horodatages de cluster. Le service stocke toujours les fragments avec leurs horodatages absolus. | true |
| fragment\$1acks | bool | S'il faut recevoir un fragment au niveau de l'application ACKs (accusés de réception). | true, ce qui signifie que le SDK les recevra ACKs et agira en conséquence. |
| restart\$1on\$1error | bool | Indique s'il faut redémarrer en cas d'erreurs spécifiques. | La valeur true signifie que le kit SDK essaie de redémarrer le streaming en cas d'erreur. |
| recalculate\$1metrics | bool | Indique s'il faut recalculer les métriques. Chaque appel à extraire les métriques peut recalculer celles qui permettent d'obtenir la dernière valeur « en cours », ce qui peut avoir un léger impact sur le processeur. Il se peut que vous deviez définir cette valeur sur false pour les périphériques à très faible consommation / couverture afin d'économiser les cycles de processeur. Dans le cas contraire, nous vous déconseillons false d'utiliser cette valeur. | true |
| nal\$1adaptation\$1flags | uint32\$1t | Spécifie les indicateurs d'adaptation d'unité Network Abstraction Layer (NAL). Si le flux binaire est codé en H.264, il peut ensuite être traité comme brut ou empaqueté. NALUs Ils sont au format Annex-B ou AVCC. La plupart des producteurs et consommateurs de flux élémentaires (encodeurs de lecture et décodeurs) utilisent le format Annex-B car il présente des avantages, tels que la récupération des erreurs. Les systèmes de niveau supérieur utilisent le format AVCC qui est le format par défaut pour MPEG, HLS, DASH, etc. La lecture de console utilise les extensions MSE (media source extensions) du navigateur pour décoder et lire le flux utilisant le format AVCC. Pour H.264 (et pour M-JPEG et H.265), le kit SDK fournit des capacités d'adaptation. De nombreux flux élémentaires sont au format suivant. Dans cet exemple, `Ab` est le code de démarrage Annex-B (001 ou 0001). Ab(Sps)Ab(Pps)Ab(I-frame)Ab(P/B-frame) Ab(P/B-frame)…. Ab(Sps)Ab(Pps)Ab(I-frame)Ab(P/B-frame) Ab(P/B-frame)
Dans le cas du H.264, les données privées du codec (CPD) se trouvent dans les paramètres SPS (ensemble de paramètres de séquence) et PPS (ensemble de paramètres d'image) et peuvent être adaptées au format AVCC. L'application peut extraire les CPD de l'image, sauf si le pipeline multimédia les fournit séparément. Il peut le faire en recherchant la première trame IDR (qui doit contenir le SPS et le PPS), en extrayant les deux NALUs (qui le sont`Ab(Sps)Ab(Pps)`) et en la définissant dans le CPD in. `StreamDefinition` Pour de plus amples informations, veuillez consulter [Référence concernant les indicateurs d'adaptation NAL (Network Abstraction Layer)](producer-reference-nal.md). | La valeur par défaut consiste à adapter le format Annex-B au format AVCC pour les données d'image et les données privées codec. |
| frame\$1rate | uint32\$1t | Débit d'images attendu. Cette valeur est utilisée pour mieux calculer les besoins de mise en mémoire tampon. | 25 |
| avg\$1bandwidth\$1bps | uint32\$1t | Bande passante moyenne attendue pour le flux. Cette valeur est utilisée pour mieux calculer les besoins de mise en mémoire tampon. | 4 \$1 1024 \$1 1024 |
| buffer\$1duration | duration | Durée de la mémoire tampon de flux en secondes. Le SDK conserve les cadres du magasin de contenu pendant une durée maximale debuffer\$1duration, après quoi les cadres précédents sont supprimés au fur et à mesure que la fenêtre avance. Si le cadre supprimé n'a pas été envoyé au backend, le rappel du cadre supprimé est appelé. Si la durée de mise en tampon actuelle est supérieure à max\$1latency, le rappel de sollicitation de latence de flux est appelé. La mémoire tampon est tronquée au début du fragment suivant lorsque l'accusé de réception de conservation de ce dernier est reçu. Cela indique que le contenu a été conservé durablement dans le cloud, afin de le stockage du contenu sur l'appareil local ne soit plus nécessaire. | 120 |
| replay\$1duration | duration | Durée, en secondes, nécessaire pour faire reculer le lecteur actuel pour le rejouer en cas d'erreur si le redémarrage est activé. La restauration s'arrête au début du tampon (si le streaming vient de commencer ou si l'accusé de réception de conservation est arrivé). La restauration essaie de se poser sur une image clé qui indique un début de fragment. Si l'erreur « à l'origine du redémarrage » n'indique pas un hôte mort (l'hôte est toujours en vie et contient les données de trame dans ses tampons internes), le rollback s'arrête à la dernière trame ACK reçue. Ensuite, la restauration se poursuit jusqu'à l'image clé suivante, car l'ensemble du fragment est déjà stocké dans la mémoire hôte. | 40 |
| connection\$1staleness | duration | Durée, en secondes, après laquelle le rappel de stagnation du flux est appelé si le SDK ne reçoit pas l'ACK de mise en mémoire tampon. Cela indique que les images sont envoyées depuis l'appareil, mais le backend ne les accuse pas de réception. Cet état indique une connexion coupée au niveau du saut intermédiaire ou de l'équilibreur de charge. | 30 |
| codec\$1id | string | ID de codec de la piste MKV. | V\$1MPEG4/ISO/AVC |
| track\$1name | string | Nom de la piste MKV. | kinesis\$1video |
| codecPrivateData | unsigned char\$1 | La mémoire tampon des données privées codec (CPD). Si le pipeline média contient les informations sur les données de type CPD avant que le flux démarre, elle peut être définie dans StreamDefinition.codecPrivateData. Les bits sont copiés et la mémoire tampon peut être réutilisée ou libérée après l'appel pour créer le flux. Toutefois, si les données ne sont pas disponibles lors de la création du flux, elles peuvent être définies dans l'une des surcharges de la KinesisVideoStream.start(cpd) fonction. | null |
| codecPrivateDataTaille | uint32\$1t | La taille de la mémoire tampon des données privées codec. | 0 |
## ClientMetrics
L'**ClientMetrics**objet est rempli en appelant`getKinesisVideoMetrics`.
### Champs réservés aux membres
****
| Champ | Type de données | Description |
| --- | --- | --- |
| Version | UINT32 | Version de la structure, définie dans la macro CLIENT\$1METRICS\$1CURRENT\$1VERSION. |
| contentStoreSize | UINT64 | Taille du magasin de contenu global, en octets. Il s'agit de la valeur spécifiée dans DeviceInfo.StorageInfo.storageSize. |
| contentStoreAvailableTaille | UINT64 | Taille de stockage actuellement disponible en octets. |
| contentStoreAllocatedTaille | UINT64 | Taille actuellement allouée. Le total de la taille allouée et de la taille disponible doit être légèrement inférieur à la taille de stockage globale, en raison des données comptables internes et de l'implémentation du magasin de contenu. |
| totalContentViewsTaille | UINT64 | Taille de la mémoire allouée pour l'ensemble des affichages de contenu pour tous les flux. Cela n'est pas pris en compte dans la taille de stockage. Cette mémoire est allouée à l'aide de la macro MEMALLOC, qui peut être remplacée pour fournir un allocateur personnalisé. |
| totalFrameRate | UINT64 | Débit d'images total observé pour tous les flux. |
| totalTransferRate | UINT64 | Débit de flux total observé, en octets par seconde, pour tous les flux. |
## StreamMetrics
L'**StreamMetrics**objet est rempli en appelant`getKinesisVideoMetrics`.
### Champs réservés aux membres
****
| Champ | Type de données | Description |
| --- | --- | --- |
| Version | UINT32 | Version de la structure, définie dans la macro STREAM\$1METRICS\$1CURRENT\$1VERSION. |
| currentViewDuration | UINT64 | Durée des images accumulées. Dans le cas d'un réseau rapide, cette durée est soit nulle, soit la durée de la trame (lorsque la trame est transmise). Si la durée devient plus longue que celle max\$1latency spécifiée dans leStreamDefinition, le rappel de latence du flux est appelé s'il est spécifié. La durée est spécifiée en unités de 100ns, qui constitue l'unité de temps par défaut pour la couche PIC. |
| overallViewDuration | UINT64 | Durée d'affichage globale. Si le flux est configuré avec absence ACKs ou persistance, cette valeur augmente au fur et à mesure que les images sont insérées dans le flux vidéo Kinesis et devient égale à celle dubuffer\$1duration. StreamDefinition Lorsque ACKs sont activés et que l'ACK persistant est reçu, la mémoire tampon est réduite à l'image clé suivante. Cela est dû au fait que l'horodatage ACK indique le début de l'ensemble du fragment. La durée est spécifiée en unités de 100-ns qui constitue l'unité de temps par défaut pour la couche PIC. |
| currentViewSize | UINT64 | Taille, en octets, de la mémoire tampon actuelle. |
| overallViewSize | UINT64 | Taille de l'affichage global, en octets. |
| currentFrameRate | UINT64 | Débit d'images observé pour le flux actuel. |
| currentTransferRate | UINT64 | Débit de transfert observé, en octets par seconde, pour le flux actuel. |
# Rappels du SDK pour les producteurs
Les classes et les méthodes du SDK Amazon Kinesis Video Streams Producer ne gèrent pas leurs propres processus. À la place, elles utilisent les appels et les événements entrants de la fonction afin de planifier les rappels pour communiquer avec l'application.
Il existe deux schémas de rappel que l'application peut utiliser pour interagir avec le kit SDK :
+ `CallbackProvider`— Cet objet expose tous les rappels du composant de code indépendant de la plate-forme (PIC) à l'application. Ce schéma permet des fonctionnalités complètes, mais cela signifie également que l'implémentation doit gérer toutes les méthodes d'API publique et les signatures dans la couche C\$1\$1.
+ [StreamCallbackProvider](#producer-reference-callbacks-streamcallbackprovider)et [ClientCallbackProvider](#producer-reference-callbacks-clientcallbackprovider) — Ces objets exposent les rappels spécifiques au flux et au client, et la couche C\$1\$1 du SDK expose le reste des rappels. Il s'agit du schéma de rappel préféré pour interagir avec le kit SDK Producteur.
Le diagramme suivant illustre le modèle d'objet des objets de rappel :
![\[Schéma illustrant l'interaction entre producteurs et consommateurs dans Kinesis Video Streams.\]](http://docs.aws.amazon.com/fr_fr/kinesisvideostreams/latest/dg/images/callbacks-10.png)
Dans le diagramme précédent, `DefaultCallbackProvider` dérive de `CallbackProvider` (qui expose tous les rappels dans le PIC) et contient `StreamCallbackProvider` et `ClientCallbackProvider`.
**Topics**
+ [ClientCallbackProvider](#producer-reference-callbacks-clientcallbackprovider)
+ [StreamCallbackProvider](#producer-reference-callbacks-streamcallbackprovider)
+ [ClientCallbacks structure](#producer-reference-callbacks-clientcallbacks)
+ [Implémentations de callback pour réessayer le streaming](#producer-reference-callbacks-retry)
## ClientCallbackProvider
L'objet `ClientCallbackProvider` expose des fonctions de rappel au niveau du client. Les détails des fonctions sont décrites dans la section [ClientCallbacks structure](#producer-reference-callbacks-clientcallbacks).
**Méthodes de rappel :**
+ `getClientReadyCallback`— Signale un état de préparation pour le client.
+ `getStorageOverflowPressureCallback`— Signale un débordement ou une pression de stockage. Ce rappel est appelé lorsque l'utilisation du stockage est inférieure à la valeur `STORAGE_PRESSURE_NOTIFICATION_THRESHOLD`, qui correspond à 5 pour cent du volume de stockage global. Pour de plus amples informations, veuillez consulter [StorageInfo](producer-reference-structures-producer.md#producer-reference-structures-producer-storageinfo).
## StreamCallbackProvider
L'objet `StreamCallbackProvider` expose des fonctions de rappel au niveau du flux.
**Méthodes de rappel :**
+ `getDroppedFragmentReportCallback` : Signale un fragment abandonné.
+ `getDroppedFrameReportCallback`— Signale la perte d'une image.
+ `getFragmentAckReceivedCallback`— Signale qu'un fragment ACK a été reçu pour le flux.
+ `getStreamClosedCallback`— Signale une condition de fermeture d'un cours d'eau.
+ `getStreamConnectionStaleCallback`— Signale un état de connexion périmé. Dans cette situation, le producteur envoie des données au service mais ne reçoit aucun accusé de réception.
+ `getStreamDataAvailableCallback`— Indique que les données sont disponibles dans le flux.
+ `getStreamErrorReportCallback`— Signale une condition d'erreur de flux.
+ `getStreamLatencyPressureCallback`— Signale une condition de latence du flux, c'est-à-dire lorsque la taille de la mémoire tampon cumulée est supérieure à la `max_latency` valeur. Pour de plus amples informations, veuillez consulter [StreamDefinition/StreamInfo](producer-reference-structures-stream.md#producer-reference-structures-stream-streaminfo).
+ `getStreamReadyCallback`: —Signale une condition de disponibilité pour le flux.
+ `getStreamUnderflowReportCallback`— Signale un état de sous-débit d'un cours d'eau. Cette fonction n'est pas utilisée actuellement et est réservée pour une utilisation future.
Pour le code source de`StreamCallbackProvider`, voir [StreamCallbackProvider.h.](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/d1684599a141785752582c16264e3123866f3cf8/kinesis-video-producer/src/StreamCallbackProvider.h)
## ClientCallbacks structure
La structure `ClientCallbacks` contient les points d'entrée de la fonction de rappel que le PIC appelle en cas d'événements spécifiques. La structure contient également des informations de version dans le champ `CALLBACKS_CURRENT_VERSION` ainsi qu'un champ `customData` pour les données définies par l'utilisateur et renvoyées avec les fonctions de rappel individuelles.
L'application client peut utiliser un pointeur `this` pour le champ `custom_data` afin de mapper les fonctions de membre vers les fonctions `ClientCallback` statiques lors de l'exécution, comme illustré dans l'exemple de code suivant :
```
STATUS TestStreamCallbackProvider::streamClosedHandler(UINT64 custom_data, STREAM_HANDLE stream_handle, UINT64 stream_upload_handle) {
LOG_INFO("Reporting stream stopped.");
TestStreamCallbackProvider* streamCallbackProvider = reinterpret_cast (custom_data);
streamCallbackProvider->streamClosedHandler(...);
```
**Événements**
| Fonction | Description | Type |
| --- | --- | --- |
| CreateDeviceFunc | Pas implémenté actuellement sur le backend. Cet appel échoue lorsque appelé à partir de Java ou C\$1\$1. Les autres clients effectuent une initialisation propre à la plateforme. | API de backend |
| CreateStreamFunc | Appelé lors de la création du flux. | API de backend |
| DescribeStreamFunc | Appelé lorsque DescribeStream est appelé. | API de backend |
| GetStreamingEndpointFunc | Appelé lorsque GetStreamingEndpoint est appelé. | API de backend |
| GetStreamingTokenFunc | Appelé lorsque GetStreamingToken est appelé. | API de backend |
| PutStreamFunc | Appelé lorsque PutStream est appelé. | API de backend |
| TagResourceFunc | Appelé lorsque TagResource est appelé. | API de backend |
| | | |
| CreateMutexFunc | Crée un mutex de synchronisation. | Synchronisation |
| FreeMutexFunc | Libère les mutex. | Synchronisation |
| LockMutexFunc | Verrouille le mutex de synchronisation. | Synchronisation |
| TryLockMutexFunc | Essaie de verrouiller les mutex. Pas implémenté actuellement. | Synchronisation |
| UnlockMutexFunc | Déverrouille le mutex. | Synchronisation |
| | | |
| ClientReadyFunc | Appelé lorsque le client passe en l'état prêt. | Notification |
| DroppedFrameReportFunc | Signale lorsqu'une image est abandonnée. | Notification |
| DroppedFragmentReportFunc | Signale lorsqu'un fragment est abandonné. Cette fonction n'est pas utilisée actuellement et est réservée pour une utilisation future. | Notification |
| FragmentAckReceivedFunc | Appelé lorsqu'un accusé de réception de fragment (mise en mémoire tampon, réception, conservation et erreur) est reçu. | Notification |
| StorageOverflowPressureFunc | Appelé lorsque l'utilisation du stockage est inférieure à la valeur STORAGE\$1PRESSURE\$1NOTIFICATION\$1THRESHOLD qui correspond à 5 pour cent du volume de stockage global. | Notification |
| StreamClosedFunc | Appelé lorsque les derniers bits des images restantes sont diffusés en continu. | Notification |
| StreamConnectionStaleFunc | Appelé lorsque le flux passe en état de connexion obsolète. Dans cet état, l'application Producteur envoie des données vers le service, mais ne reçoit pas d'accusés de réception. | Notification |
| StreamDataAvailableFunc | Appelé lorsque les données de flux sont disponibles. | Notification |
| StreamErrorReportFunc | Appelé en cas d'erreur de flux. Dans cet état, le PIC ferme automatiquement le flux. | Notification |
| StreamLatencyPressureFunc | Appelé lorsque le flux passe en état de latence qui correspond au moment où la taille de la mémoire tampon accumulée est supérieure à la valeur max\$1latency. Pour de plus amples informations, veuillez consulter [StreamDefinition/StreamInfo](producer-reference-structures-stream.md#producer-reference-structures-stream-streaminfo). | Notification |
| StreamReadyFunc | Appelé lorsque le flux passe en état prêt. | Notification |
| StreamUnderflowReportFunc | Cette fonction n'est pas utilisée actuellement et est réservée pour une utilisation future. | Notification |
| | | |
| DeviceCertToTokenFunc | Renvoie le certificat de connexion sous la forme d'un jeton. | Intégration de plateforme |
| GetCurrentTimeFunc | Renvoie l'heure actuelle. | Intégration de plateforme |
| GetDeviceCertificateFunc | Renvoie le certificat de l'appareil. Cette fonction n'est pas utilisée actuellement et est réservée pour une utilisation future. | Intégration de plateforme |
| GetDeviceFingerprintFunc | Renvoie l'empreinte de l'appareil. Cette fonction n'est pas utilisée actuellement et est réservée pour une utilisation future. | Intégration de plateforme |
| GetRandomNumberFunc | Renvoie un nombre aléatoire entre 0 et RAND\$1MAX. | Intégration de plateforme |
| GetSecurityTokenFunc | Renvoie le jeton de sécurité transmis aux fonctions qui communiquent avec l'API principale. L'implémentation peut spécifier les AccessKeyId, SecretKeyId sérialisés et le jeton de session. | Intégration de plateforme |
| LogPrintFunc | Consigne une ligne de texte avec la balise et le niveau de journalisation. Pour de plus amples informations, veuillez consulter PlatformUtils.h. | Intégration de plateforme |
Pour les fonctions d'intégration de plateforme dans le tableau précédent, le dernier paramètre est une structure `ServiceCallContext` qui comporte les champs suivants :
+ `version` : La version de la structure.
+ `callAfter` : Un délai absolu après lequel appeler la fonction.
+ `timeout` : Le délai d'expiration de l'opération en unités de 100 nanosecondes.
+ `customData` : Une valeur définie par l'utilisateur à retransmettre au client.
+ `pAuthInfo` : les informations d'identification pour l'appel. Pour plus d'informations, consultez la structure (`__AuthInfo`) suivante.
Les informations d'autorisation sont fournies à l'aide de la structure `__AuthInfo` sous la forme d'informations d'identification sérialisées ou de jeton d'authentification propre au fournisseur. Cette structure possède les champs suivants :
+ `version` : La version de la structure `__AuthInfo`.
+ `type` : Une valeur `AUTH_INFO_TYPE` définissant le type d'informations d'identification (certificat ou jeton de sécurité).
+ `data` : Une matrice à octets contenant les informations d'authentification.
+ `size` : La taille du paramètre `data`.
+ `expiration` : Le délai d'expiration des informations d'identification en unités de 100 nanosecondes.
## Implémentations de callback pour réessayer le streaming
Le kit SDK Kinesis Video Producer fournit le statut de diffusion en continu par le biais de fonctions de rappel. Nous vous recommandons de mettre en œuvre les mécanismes de rappel suivants pour remédier à tout problème réseau momentané rencontré pendant le streaming.
+ **Rappel de la pression de latence du flux** : ce mécanisme de rappel est lancé lorsque le SDK rencontre une condition de latence du flux. Cela se produit lorsque la taille de mémoire tampon accumulée est supérieure à la valeur MAX\$1LATENCY. Lorsque le flux est créé, l'application de diffusion en continu définit une valeur par défaut de 60 secondes pour MAX\$1LATENCY. L'implémentation standard pour ce rappel est de réinitialiser la connexion. Vous pouvez utiliser l'exemple d'implémentation à l'adresse [https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/kinesis-video-c-producer/src/source/StreamLatencyStateMachine.c](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/StreamLatencyStateMachine.c) selon vos besoins. Notez qu'il n'est pas possible de stocker les trames non livrées en raison d'une panne du réseau dans un stockage secondaire à des fins de remblayage.
+ Rappel **de temporisation des flux** : ce rappel est lancé lorsque le producteur peut envoyer des données au service Amazon Kinesis Data Streams (liaison montante) mais qu'il n'est pas en mesure de récupérer les accusés de réception (ACK mis en mémoire tampon) à temps (la valeur par défaut est de 60 secondes). Selon les paramètres du réseau, le rappel de la pression de latence du flux ou le rappel de l'obsolescence du flux, ou les deux, peuvent être initiés. À l’image de l’implémentation d’un nouveau rappel de sollicitation de latence de flux, l'implémentation standard consiste à réinitialiser la connexion et à en démarrer une nouvelle pour la diffusion en continu. Vous pouvez utiliser l'exemple d'implémentation disponible sur [https://github.com/awslabs/amazon-kinesis-video-streams-producer- c/blob/master/src/source/ConnectionStaleStateMachine .c selon](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/ConnectionStaleStateMachine.c) vos besoins.
+ **Rappel d'erreur de flux** : ce rappel est lancé lorsque le SDK rencontre un délai d'expiration sur la connexion réseau ou d'autres erreurs lors de l'appel aux appels du service API KVS.
+ **Rappel de trame supprimé** : ce rappel est lancé lorsque la taille de stockage est pleine, soit en raison d'une lenteur du réseau, soit d'une erreur de flux. Si la vitesse du réseau entraîne des pertes d'images, vous pouvez augmenter la taille de stockage, réduire la taille des images vidéo ou la fréquence d'images pour qu'elle corresponde à la vitesse du réseau.
# Utilisation des métadonnées de streaming avec Kinesis Video Streams
Vous pouvez utiliser le SDK Amazon Kinesis Video Streams Producer pour intégrer des métadonnées au niveau du fragment individuel dans un flux vidéo Kinesis. Dans Kinesis Video Streams, les métadonnées sont une paire clé-valeur modifiable. Vous pouvez l'utiliser pour décrire le contenu du fragment, intégrer les mesures de capteur associées qui doivent être transférées avec le fragment lui-même ou répondre à d'autres besoins personnalisés. Les métadonnées sont mises à disposition dans le cadre des opérations d'API [GetMedia](API_dataplane_GetMedia.md) ou [GetMediaForFragmentList](API_reader_GetMediaForFragmentList.md). Il est stocké avec les fragments pendant toute la durée de conservation du stream. Vos applications consommatrices peuvent lire, traiter et réagir en fonction des métadonnées à l'aide du[Regardez le résultat des caméras à l'aide de la bibliothèque d'analyseurs](parser-library.md).
Il existe deux modes dans lequel les métadonnées peuvent être intégrées à des fragments dans un flux :
+ **Non persistant** : vous pouvez apposer des métadonnées de manière ponctuelle ou ad hoc sur des fragments d'un flux, en fonction de critères spécifiques à l'entreprise qui se sont produits. Par exemple, une caméra intelligente détecte un mouvement et ajoute des métadonnées aux fragments correspondants contenant le mouvement avant de les envoyer vers son flux vidéo Kinesis. Vous pouvez appliquer les métadonnées au fragment selon le format suivant : `Motion = true`.
+ **Persistant** : vous pouvez apposer des métadonnées sur des fragments consécutifs et successifs d'un flux en fonction d'un besoin continu. Par exemple, une caméra intelligente envoie les coordonnées de latitude et de longitude actuelles associées à tous les fragments qu'elle envoie à son flux vidéo Kinesis. Vous pouvez appliquer les métadonnées à tous les fragments selon le format suivant : `Lat = 47.608013N , Long = -122.335167W`.
Vous pouvez associer simultanément les métadonnées au même fragment dans ces deux modes, en fonction des besoins de votre application. Les métadonnées intégrées peuvent inclure les objets détectés, l'activité suivie, les coordonnées GPS ou d'autres données personnalisées que vous souhaitez associer aux fragments du flux. Les métadonnées sont codées sous forme de paires de chaînes clé-valeur.
## Ajouter des métadonnées à un flux vidéo Kinesis
Les métadonnées que vous ajoutez à un flux vidéo Kinesis sont modélisées sous forme de balises MKV, qui sont implémentées sous forme de paires clé-valeur.
Les métadonnées peuvent être *transitoires*, pour marquer un événement dans le flux par exemple, ou *persistantes*, pour identifier les fragments dans lesquels un événement donné est en cours par exemple. Un élément de métadonnées persistant est conservé et est appliqué à chaque fragment consécutif jusqu'à son annulation.
**Note**
Les éléments de métadonnées ajoutés à l'aide de [Transférer vers Kinesis Video Streams](producer-sdk.md) sont distincts du balisage au niveau du flux APIs implémenté avec[TagStream](API_TagStream.md), et[UntagStream](API_UntagStream.md). [ListTagsForStream](API_ListTagsForStream.md)
### API de métadonnées de streaming
Vous pouvez utiliser les opérations suivantes dans le SDK du producteur pour implémenter les métadonnées de streaming.
**Topics**
+ [PIC](#how-meta-api-pic)
+ [SDK pour le producteur de C\$1\$1](#how-meta-api-cpp)
+ [SDK pour le producteur Java](#how-meta-api-java)
+ [Métadonnées persistantes et non persistantes](#how-meta-api-persistence)
#### PIC
```
PUBLIC_API STATUS putKinesisVideoFragmentMetadata(STREAM_HANDLE streamHandle,
PCHAR name,
PCHAR value,
BOOL persistent);
```
#### SDK pour le producteur de C\$1\$1
```
/**
* Appends a "tag" or metadata - a key/value string pair into the stream.
*/
bool putFragmentMetadata(const std::string& name, const std::string& value, bool persistent = true);
```
#### SDK pour le producteur Java
Vous pouvez utiliser le SDK Java Producer pour ajouter des métadonnées à un utilisateur `MediaSource` : `MediaSourceSink.onCodecPrivateData`
```
void onFragmentMetadata(final @Nonnull String metadataName, final @Nonnull String metadataValue, final boolean persistent)
throws KinesisVideoException;
```
#### Métadonnées persistantes et non persistantes
Pour les métadonnées non persistantes, vous pouvez ajouter plusieurs éléments de métadonnées portant le même *nom*. Le SDK du producteur collecte les éléments de métadonnées dans la file d'attente de métadonnées jusqu'à ce qu'ils soient ajoutés au fragment suivant. La file d'attente des métadonnées est effacée lorsque les éléments de métadonnées sont appliqués au flux. Pour reproduire les métadonnées, appelez à nouveau `putKinesisVideoFragmentMetadata` ou `putFragmentMetadata`.
Pour les métadonnées persistantes, le SDK du producteur collecte les éléments de métadonnées dans la file d'attente de métadonnées de la même manière que pour les métadonnées non persistantes. Toutefois, les éléments de métadonnées ne sont pas supprimés de la file d'attente lorsqu'ils sont ajoutés au fragment suivant.
L'appel de `putKinesisVideoFragmentMetadata` ou `putFragmentMetadata` avec `persistent` défini sur `true` a le comportement suivant :
+ L'appel de l'API place l'élément des métadonnées dans la file d'attente. Les métadonnées sont ajoutées sous la forme d'une balise MVK à chaque fragment tandis que l'élément se trouve dans la file d'attente.
+ L'appel de l'API avec le même *nom* et une autre *valeur* en tant qu'élément de métadonnées précédemment ajouté remplace l'élément.
+ L'appel de l'API avec une *valeur* vide supprime (annule) l'élément de métadonnées de la file d'attente des métadonnées.
# Utilisation IPv6 avec Kinesis Video Streams
Vous pouvez configurer Kinesis Video Streams pour l' IPv6 utiliser à la fois pour les opérations du plan de contrôle et du plan de données. Cela permet à vos applications de communiquer avec les services Kinesis Video Streams à l' IPv6 aide d'adresses via des points de terminaison à double pile.
**Note**
IPv6 le support nécessite des versions du SDK et des paramètres de configuration spécifiques. Assurez-vous que vos versions IPv6 du SDK AWS et du SDK Kinesis Video Streams prennent en charge les points de terminaison à double pile. Les points de terminaison à double pile prennent en charge à la fois le IPv6 trafic IPv4 et sont disponibles pour certains services dans certaines régions.
Kinesis Video Streams IPv6 prend en charge, via des points de terminaison à double pile, les applications destinées aux producteurs et aux consommateurs. Vous pouvez configurer vos applications IPv6 pour les appels d'API du plan de contrôle et les opérations de streaming du plan de données.
## Configurer le AWS SDK pour IPv6
Si vous utilisez le AWS SDK pour appeler le APIs plan de contrôle Kinesis Video Streams dans votre configuration de production, vous pouvez l' IPv6 activer en configurant des points de terminaison à double pile. Le AWS SDK fournit plusieurs méthodes standardisées pour activer les points de terminaison à double pile.
**Important**
Lorsque les points de terminaison à double pile sont activés, le SDK tente d'utiliser des points de terminaison à double pile pour effectuer des requêtes réseau. S'il n'existe pas de point de terminaison à double pile pour le service ou la région, la demande échoue.
### Utiliser des variables d'environnement
Définissez la variable d'environnement suivante pour activer les points de terminaison IPv6 à double pile :
```
export AWS_USE_DUALSTACK_ENDPOINT=true
```
### Utiliser le fichier AWS de configuration
Ajoutez le paramètre suivant à votre fichier AWS de configuration (`~/.aws/config`) :
```
[default]
use_dualstack_endpoint = true
```
### Utiliser les propriétés du système JVM (Java et Kotlin uniquement SDKs )
Pour les applications Java et Kotlin, définissez la propriété système JVM suivante :
```
-Daws.useDualstackEndpoint=true
```
Ou par programmation dans votre code Java :
```
System.setProperty("aws.useDualstackEndpoint", "true");
```
### Prise en charge de SDK
Les configurations de point de terminaison à double pile prises en AWS SDKs charge sont les suivantes :
| Kit SDK | Pris en charge | Méthodes de configuration |
| --- | --- | --- |
| AWS CLI v2 | Oui | Variable d'environnement, fichier de configuration |
| SDK pour C\$1\$1 | Oui | Variable d'environnement, fichier de configuration |
| SDK pour Go V2 (1.x) | Oui | Variable d'environnement, fichier de configuration |
| SDK pour Java 2.x | Oui | Variable d'environnement, fichier de configuration, propriété JVM |
| Kit SDK pour Java 1.x | Non | Non pris en charge |
| SDK pour 3.x JavaScript | Oui | Variable d'environnement, fichier de configuration |
| Kit SDK for Python (Boto3) | Oui | Variable d'environnement, fichier de configuration |
Une fois que vous avez configuré des points de terminaison à double pile, le AWS SDK utilise automatiquement les points de IPv6 terminaison lorsque vous appelez le plan de contrôle Kinesis Video Streams. APIs
## Configurer le SDK Kinesis Video Streams Producer pour IPv6
Le SDK Kinesis Video Streams Producer IPv6 fournit des options de configuration pour les opérations du plan de contrôle et du plan de données. Ces paramètres fonctionnent avec la configuration du point de terminaison à double pile du AWS SDK.
### Configuration du SDK C/C\$1\$1 Producer
Les points de terminaison par défaut et la chaîne de résolution DNS sont implémentés par le SDK KVS Producer-C version 1.6.0. Il vérifie séquentiellement chaque endroit où vous pouvez définir la configuration de ces paramètres, puis sélectionne le premier que vous définissez. La séquence prédéfinie est la suivante :
Pour plus d'informations sur le Producer SDKs, consultez les rubriques relatives au [SDK Producer pour C](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c), au [SDK Producer pour](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) C\$1\$1 [et au SDK Producer](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk.html#producer-sdk-related-topics).
#### Configuration du terminal
1. Le `controlPlaneUrl` paramètre pour`createAbstractDefaultCallbacksProvider`.
1. CMake Paramètres de configuration du point de terminaison : (`-DAWS_KVS_USE_LEGACY_ENDPOINT_ONLY=TRUE`,`-DAWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY=TRUE`)
1. Variables d'environnement : (`export AWS_USE_DUALSTACK_ENDPOINT=TRUE`)
+ Si tel `AWS_USE_DUALSTACK_ENDPOINT` est le cas `TRUE` (sans distinction majuscules/majuscules), le point de terminaison à double pile sera utilisé.
1. Dans le cas contraire, l'ancien point de terminaison sera construit et utilisé.
Avec 2, 3 et 4, le point de terminaison sera construit en fonction de la région fournie à`createAbstractDefaultCallbacksProvider`.
#### Filtrage DNS
Le SDK KVS Producer définira le `CURLOPT_IPRESOLVE` paramètre approprié en fonction de la configuration :
1. CMake Paramètres de résolution DNS : (`-DAWS_KVS_IPV4_ONLY=TRUE`,`-DAWS_KVS_IPV6_ONLY=TRUE`,`-DAWS_KVS_IPV4_AND_IPV6_ONLY=TRUE`)
1. Variables d'environnement (`export AWS_KVS_USE_IPV4=TRUE`,`export AWS_KVS_USE_IPV6=TRUE`)
1. Dans le cas contraire, aucun filtrage n'aura lieu. Les deux adresses, IPv4 ainsi que les adresses IPv6 IP, si elles sont renvoyées par le DNS, peuvent être utilisées.
**Note**
Si les paramètres du filtre DNS sont définis pour filtrer les adresses IPV6 IP, mais que la configuration du SDK consiste à utiliser l'ancien point de terminaison (renvoie IPV4 uniquement les adresses), la demande échouera.
La version 3.5.0 du SDK C\$1\$1 Producer utilise le SDK Producer-C 1.6.0 pour les appels d'API KVS.
### Configurer le GStreamer plugin
Le GStreamer plugin utilise le SDK C Producer sous-jacent, de sorte que IPv6 la configuration est gérée automatiquement lorsque vous configurez le SDK C IPv6 comme décrit précédemment.
Il n'est pas nécessaire de modifier le code, il suffit de créer le SDK avec les CMake paramètres ou de définir les variables d'environnement appropriées comme décrit dans la section précédente.
### Résolution des extrémités du plan de données
Pour les opérations sur le plan de données, utilisez l'`GetDataEndpoint`API pour récupérer le point de terminaison du plan de données à double pile approprié. Le service renvoie le point de terminaison correspondant en fonction de l'URL de la demande.
Exemple :
+ Si la demande `GetDataEndpoint` d'API est adressée à l'ancien point de terminaison se terminant par`.amazonaws.com`, Kinesis Video Streams renvoie l'ancien point de terminaison du plan de données se terminant par. `.amazonaws.com`
+ Si la demande `GetDataEndpoint` d'API est envoyée au point de terminaison à double pile se terminant par`.api.aws`, Kinesis Video Streams renvoie le point de terminaison du plan de données à double pile se terminant par. `.api.aws`
## Configurez le AWS CLI pour IPv6
Si vous utilisez les opérations Kinesis Video Streams (généralement AWS CLI proof-of-concept pour le travail), vous pouvez l' IPv6 activer en configurant des points de terminaison à double pile.
### Utiliser une variable d'environnement
```
export AWS_USE_DUALSTACK_ENDPOINT=true
```
### Utiliser le fichier AWS de configuration
Ajoutez ce qui suit à votre fichier AWS CLI de configuration (`~/.aws/config`) :
```
[default]
use_dualstack_endpoint = true
```
## Exemples de configuration
### Exemple de SDK C
Pour créer le SDK KVS Producer-C en mode IPV6 -only et ignorer la configuration des variables d'environnement, utilisez les commandes suivantes pour créer le SDK :
```
cmake .. -DAWS_KVS_USE_DUAL_STACK_ENDPOINT_ONLY=TRUE -DAWS_KVS_IPV6_ONLY=TRUE
make -j
```
**Note**
Si vous avez déjà créé le SDK, vous devrez effectuer une nouvelle génération. Supprimez les dossiers de compilation, de code source ouvert et de dépendance existants avant d'exécuter les commandes de génération.
## Considérations
### Exigences réseau
+ Assurez-vous que votre infrastructure réseau prend en charge IPv6 la connectivité
+ Vérifiez que vos groupes de sécurité et votre réseau ACLs autorisent IPv6 le trafic
+ Testez la connectivité aux AWS IPv6 terminaux depuis votre environnement de déploiement
+ Des points de terminaison à double pile sont disponibles pour certains services dans certaines régions. Vérifiez la disponibilité pour vos régions cibles
### Compatibilité avec le SDK
+ Assurez-vous que vous utilisez une version du AWS SDK prise en charge
+ Le AWS SDK pour Java 1.x ne prend pas en charge la configuration des points de terminaison à double pile
+ Pour le SDK pour Go 1.x (V1), vous devez activer le chargement depuis le fichier de configuration pour utiliser les paramètres du fichier de configuration partagés
### Tests et validation
Avant de déployer des applications Kinesis Video Streams IPv6 compatibles en production :
+ Tester les opérations du plan de contrôle (création de flux, suppression, listage)
+ Vérifier le fonctionnement du plan de données (ingestion et consommation de vidéos)
+ Validez les performances et la connectivité dans votre environnement réseau
+ Exécutez des tests Canary pour garantir des IPv6 fonctionnalités cohérentes
+ Testez le comportement du basculement lorsque les points de terminaison à double pile ne sont pas disponibles
## Les clients concernés par la mise à niveau incluent IPv6
Lorsque vous activez IPv6 Kinesis Video Streams, vous devrez peut-être mettre à jour vos configurations et politiques existantes dans plusieurs domaines afin de garantir le fonctionnement continu.
### Politiques IAM et filtrage des adresses IP
Si vous utilisez le filtrage des adresses IP source dans vos politiques utilisateur IAM, vos politiques de rôle ou vos politiques basées sur les ressources, vous devez mettre à jour ces politiques pour inclure IPv6 les plages d'adresses.
**Important**
Les politiques IAM existantes qui utilisent des blocs `IpAddress` ou des `NotIpAddress` conditions IPv4 CIDR ne fonctionneront pas automatiquement avec IPv6 les adresses. Vous devez ajouter des IPv6 plages de manière explicite pour maintenir le contrôle d'accès.
Exemple de mise à jour de la politique IAM pour IPv6 :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "kinesisvideo:*",
"Resource": "*",
"Condition": {
"IpAddress": {
"aws:SourceIp": [
"192.0.2.0/24",
"203.0.113.0/24",
"2001:db8::/32"
]
}
}
}
]
}
```
### Journalisation et surveillance
IPv6 les adresses ont un format différent de celui IPv4 des adresses, ce qui peut avoir un impact sur vos systèmes de journalisation, de surveillance et d'analyse.
#### journaux
les journaux contiendront IPv6 les adresses dans le `sourceIPAddress` champ lorsque les demandes seront effectuées IPv6. Mettez à jour vos outils et scripts d'analyse des journaux pour gérer les formats d' IPv6 adresses.
Exemple IPv6 d'adresse dans les journaux :
```
{
"sourceIPAddress": "2001:db8::1",
"eventName": "CreateStream",
"eventSource": "kinesisvideo.amazonaws.com"
}
```
## Résolution des problèmes
### Problèmes courants
+ Défaillances de connexion — Vérifiez la connectivité IPv6 réseau et la résolution DNS
+ Erreurs du SDK : assurez-vous que vous utilisez des versions du SDK compatibles qui prennent en charge les points de terminaison à double pile
+ Problèmes d'authentification — Vérifiez que les politiques et les informations d'identification IAM fonctionnent avec IPv6 les points de terminaison
+ Point de terminaison non disponible : si aucun point de terminaison à double pile n'existe pour le service ou la région, les demandes échouent
### Étapes de vérification
+ Vérifiez que `AWS_USE_DUALSTACK_ENDPOINT=true` c'est défini ou qu'`use_dualstack_endpoint = true`il se trouve dans votre fichier de configuration
+ Vérifiez que les indicateurs de configuration du IPv6 SDK Kinesis Video Streams sont correctement définis
+ Testez la connectivité réseau aux AWS IPv6 terminaux
+ Consultez les journaux des applications pour détecter les IPv6 messages d'erreur spécifiques
+ Vérifiez que votre région prend en charge les points de terminaison à double pile pour Kinesis Video Streams
### Validation de configuration
Vous pouvez vérifier la configuration de votre point de terminaison à double pile en vérifiant :
+ Variables d'environnement : `echo $AWS_USE_DUALSTACK_ENDPOINT`
+ AWS fichier de configuration : `cat ~/.aws/config | grep use_dualstack_endpoint`
+ Propriétés de la JVM (Java) : vérifiez les propriétés du système dans les journaux de vos applications