

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.

# Recherche de visages dans une collection en vidéo streaming
<a name="collections-streaming"></a>

Vous pouvez utiliser Vidéo Amazon Rekognition pour détecter et reconnaître des visages dans une collection de vidéos diffusées en streaming. Avec Amazon Rekognition Video, vous pouvez créer un processeur de flux [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)() pour démarrer et gérer l'analyse du streaming vidéo. 

Pour détecter un visage connu dans un flux vidéo (recherche faciale), Vidéo Amazon Rekognition utilise Amazon Kinesis Video Streams pour recevoir et traiter un flux vidéo. Les résultats d’analyse représentent une sortie de Vidéo Amazon Rekognition vers un flux de données Kinesis, ensuite lue par votre application cliente. 

Pour utiliser Vidéo Amazon Rekognition avec une vidéo en streaming, votre application doit implémenter les éléments suivants :
+ Un flux vidéo Kinesis pour envoyer des vidéos en streaming à Vidéo Amazon Rekognition. Pour plus d’informations, consultez le [Guide du développeur Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/what-is-kinesis-video.html). 
+ Un processeur de flux Vidéo Amazon Rekognition pour gérer l’analyse de la vidéo en streaming. Pour de plus amples informations, veuillez consulter [Présentation des opérations du processeur de flux Vidéo Amazon Rekognition](streaming-video.md#using-rekognition-video-stream-processor).
+ Un consommateur de flux de données Kinesis chargé de lire les résultats d’analyse que Vidéo Amazon Rekognition envoie au flux de données Kinesis. Pour plus d’informations, consultez [Consommateurs de flux de données Kinesis](https://docs.aws.amazon.com/streams/latest/dev/amazon-kinesis-consumers.html). 

Cette section contient des informations sur la création d’une application qui crée le flux vidéo Kinesis et les autres ressources nécessaires, diffuse des vidéos sur Vidéo Amazon Rekognition et reçoit les résultats de l’analyse.

**Topics**
+ [Configuration de vos ressources Vidéo Amazon Rekognition et Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md)
+ [Recherche de visages dans une vidéo en streaming](rekognition-video-stream-processor-search-faces.md)
+ [Streaming à l'aide d'un GStreamer plugin](streaming-using-gstreamer-plugin.md)
+ [Résolution des problèmes de streaming vidéo](streaming-video-troubleshooting.md)

# Configuration de vos ressources Vidéo Amazon Rekognition et Amazon Kinesis
<a name="setting-up-your-amazon-rekognition-streaming-video-resources"></a>

 Les procédures suivantes décrivent les étapes à suivre pour approvisionner le flux vidéo Kinesis et les autres ressources utilisées pour reconnaître les visages dans une vidéo en streaming.

## Conditions préalables
<a name="streaming-video-prerequisites"></a>

Pour exécuter cette procédure, vous devez l'avoir AWS SDK pour Java installé. Pour de plus amples informations, veuillez consulter [Premiers pas avec Amazon Rekognition](getting-started.md). L'utilisateur Compte AWS que vous utilisez doit disposer d'autorisations d'accès à l'API Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Actions définies par Amazon Rekognition](https://docs.aws.amazon.com/IAM/latest/UserGuide/list_amazonrekognition.html#amazonrekognition-actions-as-permissions) dans le *Guide de l’utilisateur IAM*. 

**Pour reconnaître des visages dans un flux vidéo (AWS SDK)**

1. Si ce n’est pas déjà fait, créez une fonction du service IAM pour permettre à Vidéo Amazon Rekognition d’accéder à vos flux vidéo Kinesis et à vos flux de données Kinesis. Notez l’ARN. Pour de plus amples informations, veuillez consulter [Donner accès aux streams à l'aide de AmazonRekognitionServiceRole](api-streaming-video-roles.md#api-streaming-video-roles-all-stream).

1. [Créez une collection](create-collection-procedure.md) et notez l’identifiant de collection que vous avez utilisé.

1. [Indexez les visages](add-faces-to-collection-procedure.md) à rechercher dans la collection que vous avez créée lors de l’étape 2.

1. [Créez un flux vidéo stream](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/gs-createstream.html) et notez l’Amazon Resource Name (ARN) du flux.

1. [Créer un flux de données Kinesis](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html). Ajoutez le nom du flux au début *AmazonRekognition*et notez l'ARN du flux.

Vous pouvez ensuite [créer le processeur de flux de recherche faciale](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor) et [démarrer le processeur de flux](rekognition-video-stream-processor-search-faces.md#streaming-video-starting-stream-processor) en utilisant le nom de processeur de flux que vous avez choisi.

**Note**  
 Vous ne devez démarrer le processeur de diffusion qu’après avoir vérifié que vous pouvez intégrer du contenu multimédia dans le flux vidéo Kinesis. 

## Diffusion de vidéos sur Vidéo Amazon Rekognition
<a name="video-streaming-kinesisvideostreams-stream"></a>

Pour diffuser une vidéo dans Vidéo Amazon Rekognition, vous devez utiliser le SDK Amazon Kinesis Video Streams pour créer et utiliser un flux vidéo Kinesis. L’opération `PutMedia` écrit des *fragments* de données vidéo dans un flux vidéo utilisé par Vidéo Amazon Rekognition. Chaque fragment de donnée vidéo dure environ 2–10 secondes et contient une trame d’images vidéo autonome. Vidéo Amazon Rekognition prend en charge les vidéos encodées en H.264, qui peuvent avoir trois types de trames (I, B et P). Pour en savoir plus, consultez [Inter Frame](https://en.wikipedia.org/wiki/Inter_frame). La première trame dans le fragment doit être une I-frame. Une I-frame peut être décodée indépendamment de n’importe quelle autre trame. 

Au fur et à mesure que les données arrivent dans le flux vidéo Kinesis, Kinesis Video Streams attribue un numéro unique au fragment. Pour un exemple, voir [Exemple PutMedia d'API](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html).
+  Si vous diffusez à partir d'une source codée en Matroska (MKV), utilisez cette [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)opération pour diffuser la vidéo source dans le flux vidéo Kinesis que vous avez créé. Pour plus d'informations, consultez [PutMedia l'exemple d'API](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-putmedia.html). 
+  Si vous diffusez à partir de la caméra d’un appareil, consultez [Streaming à l'aide d'un GStreamer plugin](streaming-using-gstreamer-plugin.md).

# Octroi à Vidéo Amazon Rekognition d’un accès à vos ressources
<a name="api-streaming-video-roles"></a>

Vous utilisez un rôle de service Gestion des identités et des accès AWS (IAM) pour donner à Amazon Rekognition Video un accès en lecture aux flux vidéo Kinesis. Si vous utilisez un processeur de flux de recherche faciale, vous utilisez une fonction du service IAM pour autoriser Vidéo Amazon Rekognition à accéder en écriture aux flux de données Kinesis. Si vous utilisez un processeur de flux de surveillance de la sécurité, vous utilisez des rôles IAM pour permettre à Vidéo Amazon Rekognition d’accéder à votre compartiment Amazon S3 et à une rubrique Amazon SNS.

## Octroi d’un accès aux processeurs de flux de recherche faciale
<a name="api-streaming-video-roles-single-stream"></a>

Vous pouvez créer une politique d’autorisation qui autorise Vidéo Amazon Rekognition à accéder à des flux vidéo et à des flux de données Kinesis individuels.

**Pour autoriser Vidéo Amazon Rekognition d’accéder à un processeur de flux de recherche faciale**

1. [ Créez une nouvelle stratégie d’autorisations avec l’éditeur de stratégie IAM JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor), et utilisez la stratégie suivante. Remplacez `video-arn` par l’ARN du flux vidéo Kinesis souhaité. Si vous utilisez un processeur de flux de recherche faciale, remplacez `data-arn` par l’ARN du flux de données Kinesis souhaité.

1. [Créez une fonction du service IAM;](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console), ou mettez à jour une fonction du service IAM existant. Utilisez les informations suivantes pour créer la fonction du service IAM :

   1. Choisissez **Rekognition** pour le nom du service.

   1. Choisissez **Rekognition** pour le cas d’utilisation de la fonction de service.

   1. Attachez la stratégie d’autorisations que vous avez créée à l’étape 1.

1. Notez l’ARN de la fonction du service. Vous en aurez besoin pour démarrer les opérations d’analyse vidéo.

## Donner accès aux streams à l'aide de AmazonRekognitionServiceRole
<a name="api-streaming-video-roles-all-stream"></a>

 Vous pouvez utiliser la politique d’autorisation `AmazonRekognitionServiceRole` comme option alternative pour configurer l’accès aux flux vidéo et aux flux de données Kinesis. IAM présente le cas d’utilisation de la fonction du service *Rekognition* qui, lorsqu’elle est utilisée avec la stratégie d’autorisations `AmazonRekognitionServiceRole`, peut écrire dans plusieurs flux de données Kinesis et lire à partir de tous vos flux de données Kinesis. Pour permettre à Amazon Rekognition Video d'accéder en écriture à plusieurs flux de données Kinesis, vous pouvez ajouter, par exemple, au début des noms des flux de données Kinesis. *AmazonRekognition*`AmazonRekognitionMyDataStreamName` 

**Pour autoriser Vidéo Amazon Rekognition à accéder à votre flux vidéo Kinesis et à votre flux de données Kinesis**

1. [Créez une fonction du service IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html?icmpid=docs_iam_console). Utilisez les informations suivantes pour créer la fonction du service IAM :

   1. Choisissez **Rekognition** pour le nom du service.

   1. Choisissez **Rekognition** pour le cas d’utilisation de la fonction de service.

   1. Choisissez la politique **AmazonRekognitionServiceRole**d'autorisation, qui donne à Amazon Rekognition Video un accès en écriture aux flux de données Kinesis préfixés *AmazonRekognition*et un accès en lecture à tous vos flux vidéo Kinesis.

1. Pour garantir votre Compte AWS sécurité, limitez l'étendue de l'accès de Rekognition aux seules ressources que vous utilisez. Pour ce faire, attachez une politique de confiance à votre fonction du service IAM. Pour plus d’informations sur la procédure à utiliser, consultez [Prévention du problème de l’adjoint confus entre services](cross-service-confused-deputy-prevention.md).

1. Notez l’Amazon Resource Name (ARN) de la fonction du service. Vous en aurez besoin pour démarrer les opérations d’analyse vidéo.

# Recherche de visages dans une vidéo en streaming
<a name="rekognition-video-stream-processor-search-faces"></a>

Vidéo Amazon Rekognition peut rechercher, dans une collection, des visages qui correspondent à des visages ayant été détectés dans une vidéo en streaming. Pour en savoir plus sur les collections, consultez [Recherche de visages dans une collection](collections.md).

**Topics**
+ [Création du processeur de flux de recherche faciale Vidéo Amazon Rekognition](#streaming-video-creating-stream-processor)
+ [Démarrage du processeur de flux de recherche faciale Vidéo Amazon Rekognition](#streaming-video-starting-stream-processor)
+ [Utilisation de processeurs de flux pour la recherche faciale (exemple Java V2)](#using-stream-processors-v2)
+ [Utilisation de processeurs de flux pour la recherche faciale (exemple Java V1)](#using-stream-processors)
+ [Lecture des résultats d’analyse de vidéo en streaming](streaming-video-kinesis-output.md)
+ [Afficher les résultats de Rekognition avec Kinesis Video Streams en local](displaying-rekognition-results-locally.md)
+ [Comprendre l'enregistrement de trame JSON de reconnaissance faciale Kinesis](streaming-video-kinesis-output-reference.md)

Le diagramme suivant montre comment Vidéo Amazon Rekognition; détecte et reconnaît les visages dans une vidéo en streaming.

![\[Schéma du flux de travail pour l'utilisation d'Amazon Rekognition Video pour traiter des flux vidéo provenant d'Amazon Kinesis.\]](http://docs.aws.amazon.com/fr_fr/rekognition/latest/dg/images/VideoRekognitionStream.png)


## Création du processeur de flux de recherche faciale Vidéo Amazon Rekognition
<a name="streaming-video-creating-stream-processor"></a>

Avant de pouvoir analyser une vidéo en streaming, vous devez créer un processeur de streaming Amazon Rekognition Video (). [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html) Le processeur de flux contient des informations sur le flux de données Kinesis et le flux vidéo Kinesis. Il comprend également l’identifiant de la collection contenant les visages que vous voulez reconnaître dans la vidéo en streaming d’entrée. Vous définissez aussi un nom pour le processeur de flux. L’exemple suivant est un exemple JSON de requête `CreateStreamProcessor`.

```
{
       "Name": "streamProcessorForCam",
       "Input": {
              "KinesisVideoStream": {
                     "Arn": "arn:aws:kinesisvideo:us-east-1:nnnnnnnnnnnn:stream/inputVideo"
              }
       },
       "Output": {
              "KinesisDataStream": {
                     "Arn": "arn:aws:kinesis:us-east-1:nnnnnnnnnnnn:stream/outputData"
              }
       },
       "RoleArn": "arn:aws:iam::nnnnnnnnnnn:role/roleWithKinesisPermission",
       "Settings": {
              "FaceSearch": {
                     "CollectionId": "collection-with-100-faces",
                     "FaceMatchThreshold": 85.5
              }
       }
}
```

Voici un exemple de réponse de `CreateStreamProcessor`.

```
{
       “StreamProcessorArn”: “arn:aws:rekognition:us-east-1:nnnnnnnnnnnn:streamprocessor/streamProcessorForCam”
}
```

## Démarrage du processeur de flux de recherche faciale Vidéo Amazon Rekognition
<a name="streaming-video-starting-stream-processor"></a>

Pour démarrer l'analyse de vidéo en streaming, appelez [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html) avec le nom de processeur de flux que vous avez spécifié dans `CreateStreamProcessor`. L’exemple suivant est un exemple JSON de requête `StartStreamProcessor`.

```
{
       "Name": "streamProcessorForCam"
}
```

Si le processeur de flux démarre avec succès, une réponse HTTP 200 est renvoyée avec un corps de JSON vide.

## Utilisation de processeurs de flux pour la recherche faciale (exemple Java V2)
<a name="using-stream-processors-v2"></a>

L'exemple de code suivant montre comment appeler diverses opérations du processeur de flux, telles que [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)et [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html), à l'aide du AWS SDK pour Java version 2.

Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet [ici](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/CreateStreamProcessor.java).

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.CreateStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.CreateStreamProcessorResponse;
import software.amazon.awssdk.services.rekognition.model.FaceSearchSettings;
import software.amazon.awssdk.services.rekognition.model.KinesisDataStream;
import software.amazon.awssdk.services.rekognition.model.KinesisVideoStream;
import software.amazon.awssdk.services.rekognition.model.ListStreamProcessorsRequest;
import software.amazon.awssdk.services.rekognition.model.ListStreamProcessorsResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.StreamProcessor;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorInput;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorSettings;
import software.amazon.awssdk.services.rekognition.model.StreamProcessorOutput;
import software.amazon.awssdk.services.rekognition.model.StartStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeStreamProcessorRequest;
import software.amazon.awssdk.services.rekognition.model.DescribeStreamProcessorResponse;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 * <p>
 * For more information, see the following documentation topic:
 * <p>
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateStreamProcessor {
    public static void main(String[] args) {
        final String usage = """
                
                Usage:    <role> <kinInputStream> <kinOutputStream> <collectionName> <StreamProcessorName>
                
                Where:
                   role - The ARN of the AWS Identity and Access Management (IAM) role to use. \s
                   kinInputStream - The ARN of the Kinesis video stream.\s
                   kinOutputStream - The ARN of the Kinesis data stream.\s
                   collectionName - The name of the collection to use that contains content. \s
                   StreamProcessorName - The name of the Stream Processor. \s
                """;

        if (args.length != 5) {
            System.out.println(usage);
            System.exit(1);
        }

        String role = args[0];
        String kinInputStream = args[1];
        String kinOutputStream = args[2];
        String collectionName = args[3];
        String streamProcessorName = args[4];

        Region region = Region.US_EAST_1;
        RekognitionClient rekClient = RekognitionClient.builder()
                .region(region)
                .build();

        processCollection(rekClient, streamProcessorName, kinInputStream, kinOutputStream, collectionName,
                role);
        startSpecificStreamProcessor(rekClient, streamProcessorName);
        listStreamProcessors(rekClient);
        describeStreamProcessor(rekClient, streamProcessorName);
        deleteSpecificStreamProcessor(rekClient, streamProcessorName);
    }

    public static void listStreamProcessors(RekognitionClient rekClient) {
        ListStreamProcessorsRequest request = ListStreamProcessorsRequest.builder()
                .maxResults(15)
                .build();

        ListStreamProcessorsResponse listStreamProcessorsResult = rekClient.listStreamProcessors(request);
        for (StreamProcessor streamProcessor : listStreamProcessorsResult.streamProcessors()) {
            System.out.println("StreamProcessor name - " + streamProcessor.name());
            System.out.println("Status - " + streamProcessor.status());
        }
    }

    private static void describeStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
        DescribeStreamProcessorRequest streamProcessorRequest = DescribeStreamProcessorRequest.builder()
                .name(StreamProcessorName)
                .build();

        DescribeStreamProcessorResponse describeStreamProcessorResult = rekClient
                .describeStreamProcessor(streamProcessorRequest);
        System.out.println("Arn - " + describeStreamProcessorResult.streamProcessorArn());
        System.out.println("Input kinesisVideo stream - "
                + describeStreamProcessorResult.input().kinesisVideoStream().arn());
        System.out.println("Output kinesisData stream - "
                + describeStreamProcessorResult.output().kinesisDataStream().arn());
        System.out.println("RoleArn - " + describeStreamProcessorResult.roleArn());
        System.out.println(
                "CollectionId - "
                        + describeStreamProcessorResult.settings().faceSearch().collectionId());
        System.out.println("Status - " + describeStreamProcessorResult.status());
        System.out.println("Status message - " + describeStreamProcessorResult.statusMessage());
        System.out.println("Creation timestamp - " + describeStreamProcessorResult.creationTimestamp());
        System.out.println("Last update timestamp - " + describeStreamProcessorResult.lastUpdateTimestamp());
    }

    private static void startSpecificStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
        try {
            StartStreamProcessorRequest streamProcessorRequest = StartStreamProcessorRequest.builder()
                    .name(StreamProcessorName)
                    .build();

            rekClient.startStreamProcessor(streamProcessorRequest);
            System.out.println("Stream Processor " + StreamProcessorName + " started.");

        } catch (RekognitionException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }

    private static void processCollection(RekognitionClient rekClient, String StreamProcessorName,
                                          String kinInputStream, String kinOutputStream, String collectionName, String role) {
        try {
            KinesisVideoStream videoStream = KinesisVideoStream.builder()
                    .arn(kinInputStream)
                    .build();

            KinesisDataStream dataStream = KinesisDataStream.builder()
                    .arn(kinOutputStream)
                    .build();

            StreamProcessorOutput processorOutput = StreamProcessorOutput.builder()
                    .kinesisDataStream(dataStream)
                    .build();

            StreamProcessorInput processorInput = StreamProcessorInput.builder()
                    .kinesisVideoStream(videoStream)
                    .build();

            FaceSearchSettings searchSettings = FaceSearchSettings.builder()
                    .faceMatchThreshold(75f)
                    .collectionId(collectionName)
                    .build();

            StreamProcessorSettings processorSettings = StreamProcessorSettings.builder()
                    .faceSearch(searchSettings)
                    .build();

            CreateStreamProcessorRequest processorRequest = CreateStreamProcessorRequest.builder()
                    .name(StreamProcessorName)
                    .input(processorInput)
                    .output(processorOutput)
                    .roleArn(role)
                    .settings(processorSettings)
                    .build();

            CreateStreamProcessorResponse response = rekClient.createStreamProcessor(processorRequest);
            System.out.println("The ARN for the newly create stream processor is "
                    + response.streamProcessorArn());

        } catch (RekognitionException e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }

    private static void deleteSpecificStreamProcessor(RekognitionClient rekClient, String StreamProcessorName) {
        rekClient.stopStreamProcessor(a -> a.name(StreamProcessorName));
        rekClient.deleteStreamProcessor(a -> a.name(StreamProcessorName));
        System.out.println("Stream Processor " + StreamProcessorName + " deleted.");
    }
}
```

## Utilisation de processeurs de flux pour la recherche faciale (exemple Java V1)
<a name="using-stream-processors"></a>

L'exemple de code suivant montre comment appeler diverses opérations du processeur de flux, telles que [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html)et [StartStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartStreamProcessor.html), à l'aide de Java V1. L'exemple inclut une classe de gestionnaire de processeur de flux (StreamManager) qui fournit des méthodes pour appeler les opérations du processeur de flux. La classe de démarrage (Starter) crée un StreamManager objet et appelle diverses opérations. 

**Pour configurer l’exemple:**

1. Attribuez les valeurs souhaitées aux champs de membre de la classe Starter.

1. Dans la fonction `main` de la classe Starter, supprimez la mise en commentaire de l’appel de fonction souhaité.

### Classe Starter
<a name="streaming-started"></a>

```
//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

// Starter class. Use to create a StreamManager class
// and call stream processor operations.
package com.amazonaws.samples;
import com.amazonaws.samples.*;

public class Starter {

	public static void main(String[] args) {
		
		
    	String streamProcessorName="Stream Processor Name";
    	String kinesisVideoStreamArn="Kinesis Video Stream Arn";
    	String kinesisDataStreamArn="Kinesis Data Stream Arn";
    	String roleArn="Role Arn";
    	String collectionId="Collection ID";
    	Float matchThreshold=50F;

		try {
			StreamManager sm= new StreamManager(streamProcessorName,
					kinesisVideoStreamArn,
					kinesisDataStreamArn,
					roleArn,
					collectionId,
					matchThreshold);
			//sm.createStreamProcessor();
			//sm.startStreamProcessor();
			//sm.deleteStreamProcessor();
			//sm.deleteStreamProcessor();
			//sm.stopStreamProcessor();
			//sm.listStreamProcessors();
			//sm.describeStreamProcessor();
		}
		catch(Exception e){
			System.out.println(e.getMessage());
		}
	}
}
```

### StreamManager classe
<a name="streaming-manager"></a>

```
//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

// Stream manager class. Provides methods for calling
// Stream Processor operations.
package com.amazonaws.samples;

import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.CreateStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.CreateStreamProcessorResult;
import com.amazonaws.services.rekognition.model.DeleteStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.DeleteStreamProcessorResult;
import com.amazonaws.services.rekognition.model.DescribeStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.DescribeStreamProcessorResult;
import com.amazonaws.services.rekognition.model.FaceSearchSettings;
import com.amazonaws.services.rekognition.model.KinesisDataStream;
import com.amazonaws.services.rekognition.model.KinesisVideoStream;
import com.amazonaws.services.rekognition.model.ListStreamProcessorsRequest;
import com.amazonaws.services.rekognition.model.ListStreamProcessorsResult;
import com.amazonaws.services.rekognition.model.StartStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.StartStreamProcessorResult;
import com.amazonaws.services.rekognition.model.StopStreamProcessorRequest;
import com.amazonaws.services.rekognition.model.StopStreamProcessorResult;
import com.amazonaws.services.rekognition.model.StreamProcessor;
import com.amazonaws.services.rekognition.model.StreamProcessorInput;
import com.amazonaws.services.rekognition.model.StreamProcessorOutput;
import com.amazonaws.services.rekognition.model.StreamProcessorSettings;

public class StreamManager {

    private String streamProcessorName;
    private String kinesisVideoStreamArn;
    private String kinesisDataStreamArn;
    private String roleArn;
    private String collectionId;
    private float matchThreshold;

    private AmazonRekognition rekognitionClient;
    

    public StreamManager(String spName,
    		String kvStreamArn,
    		String kdStreamArn,
    		String iamRoleArn,
    		String collId,
    		Float threshold){
    	streamProcessorName=spName;
    	kinesisVideoStreamArn=kvStreamArn;
    	kinesisDataStreamArn=kdStreamArn;
    	roleArn=iamRoleArn;
    	collectionId=collId;
    	matchThreshold=threshold;
    	rekognitionClient=AmazonRekognitionClientBuilder.defaultClient();
    	
    }
    
    public void createStreamProcessor() {
    	//Setup input parameters
        KinesisVideoStream kinesisVideoStream = new KinesisVideoStream().withArn(kinesisVideoStreamArn);
        StreamProcessorInput streamProcessorInput =
                new StreamProcessorInput().withKinesisVideoStream(kinesisVideoStream);
        KinesisDataStream kinesisDataStream = new KinesisDataStream().withArn(kinesisDataStreamArn);
        StreamProcessorOutput streamProcessorOutput =
                new StreamProcessorOutput().withKinesisDataStream(kinesisDataStream);
        FaceSearchSettings faceSearchSettings =
                new FaceSearchSettings().withCollectionId(collectionId).withFaceMatchThreshold(matchThreshold);
        StreamProcessorSettings streamProcessorSettings =
                new StreamProcessorSettings().withFaceSearch(faceSearchSettings);

        //Create the stream processor
        CreateStreamProcessorResult createStreamProcessorResult = rekognitionClient.createStreamProcessor(
                new CreateStreamProcessorRequest().withInput(streamProcessorInput).withOutput(streamProcessorOutput)
                        .withSettings(streamProcessorSettings).withRoleArn(roleArn).withName(streamProcessorName));

        //Display result
        System.out.println("Stream Processor " + streamProcessorName + " created.");
        System.out.println("StreamProcessorArn - " + createStreamProcessorResult.getStreamProcessorArn());
    }

    public void startStreamProcessor() {
        StartStreamProcessorResult startStreamProcessorResult =
                rekognitionClient.startStreamProcessor(new StartStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " started.");
    }

    public void stopStreamProcessor() {
        StopStreamProcessorResult stopStreamProcessorResult =
                rekognitionClient.stopStreamProcessor(new StopStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " stopped.");
    }

    public void deleteStreamProcessor() {
        DeleteStreamProcessorResult deleteStreamProcessorResult = rekognitionClient
                .deleteStreamProcessor(new DeleteStreamProcessorRequest().withName(streamProcessorName));
        System.out.println("Stream Processor " + streamProcessorName + " deleted.");
    }

    public void describeStreamProcessor() {
        DescribeStreamProcessorResult describeStreamProcessorResult = rekognitionClient
                .describeStreamProcessor(new DescribeStreamProcessorRequest().withName(streamProcessorName));

        //Display various stream processor attributes.
        System.out.println("Arn - " + describeStreamProcessorResult.getStreamProcessorArn());
        System.out.println("Input kinesisVideo stream - "
                + describeStreamProcessorResult.getInput().getKinesisVideoStream().getArn());
        System.out.println("Output kinesisData stream - "
                + describeStreamProcessorResult.getOutput().getKinesisDataStream().getArn());
        System.out.println("RoleArn - " + describeStreamProcessorResult.getRoleArn());
        System.out.println(
                "CollectionId - " + describeStreamProcessorResult.getSettings().getFaceSearch().getCollectionId());
        System.out.println("Status - " + describeStreamProcessorResult.getStatus());
        System.out.println("Status message - " + describeStreamProcessorResult.getStatusMessage());
        System.out.println("Creation timestamp - " + describeStreamProcessorResult.getCreationTimestamp());
        System.out.println("Last update timestamp - " + describeStreamProcessorResult.getLastUpdateTimestamp());
    }

    public void listStreamProcessors() {
        ListStreamProcessorsResult listStreamProcessorsResult =
                rekognitionClient.listStreamProcessors(new ListStreamProcessorsRequest().withMaxResults(100));

        //List all stream processors (and state) returned from Rekognition
        for (StreamProcessor streamProcessor : listStreamProcessorsResult.getStreamProcessors()) {
            System.out.println("StreamProcessor name - " + streamProcessor.getName());
            System.out.println("Status - " + streamProcessor.getStatus());
        }
    }
}
```

# Lecture des résultats d’analyse de vidéo en streaming
<a name="streaming-video-kinesis-output"></a>

Vous pouvez utiliser la bibliothèque client Amazon Kinesis Data Streams pour consommer des résultats d’analyse envoyés vers le flux de sortie Amazon Kinesis Data Streams. Pour en savoir plus, consultez [Lecture de données d’un flux de données Kinesis](https://docs.aws.amazon.com/streams/latest/dev/building-consumers.html). Vidéo Amazon Rekognition place un enregistrement de trame JSON pour chaque trame analysée dans le flux de sortie Kinesis. Vidéo Amazon Rekognition n’analyse pas toutes les images qui lui sont transmises via le flux vidéo Kinesis. 

Un enregistrement de trame envoyé à un flux de données Kinesis comprend des informations sur le fragment de flux vidéo Kinesis où se trouve la trame dans le fragment et les visages reconnus dans la trame. Il inclut également des informations de statut pour le processeur de flux. Pour de plus amples informations, veuillez consulter [Comprendre l'enregistrement de trame JSON de reconnaissance faciale Kinesis](streaming-video-kinesis-output-reference.md).

La bibliothèque d’analyseurs Amazon Kinesis Video Streams contient des exemples de tests qui utilisent les résultats de Vidéo Amazon Rekognition et les intègre au flux vidéo Kinesis d’origine. Pour de plus amples informations, veuillez consulter [Afficher les résultats de Rekognition avec Kinesis Video Streams en local](displaying-rekognition-results-locally.md).

Vidéo Amazon Rekognition diffuse les informations d’analyse Vidéo Amazon Rekognition vers le flux de données Kinesis. L’exemple suivant est un exemple JSON pour un enregistrement unique. 

```
{
  "InputInformation": {
    "KinesisVideo": {
      "StreamArn": "arn:aws:kinesisvideo:us-west-2:nnnnnnnnnnnn:stream/stream-name",
      "FragmentNumber": "91343852333289682796718532614445757584843717598",
      "ServerTimestamp": 1510552593.455,
      "ProducerTimestamp": 1510552593.193,
      "FrameOffsetInSeconds": 2
    }
  },
  "StreamProcessorInformation": {
    "Status": "RUNNING"
  },
  "FaceSearchResponse": [
    {
      "DetectedFace": {
        "BoundingBox": {
          "Height": 0.075,
          "Width": 0.05625,
          "Left": 0.428125,
          "Top": 0.40833333
        },
        "Confidence": 99.975174,
        "Landmarks": [
          {
            "X": 0.4452057,
            "Y": 0.4395594,
            "Type": "eyeLeft"
          },
          {
            "X": 0.46340984,
            "Y": 0.43744427,
            "Type": "eyeRight"
          },
          {
            "X": 0.45960626,
            "Y": 0.4526856,
            "Type": "nose"
          },
          {
            "X": 0.44958648,
            "Y": 0.4696949,
            "Type": "mouthLeft"
          },
          {
            "X": 0.46409217,
            "Y": 0.46704912,
            "Type": "mouthRight"
          }
        ],
        "Pose": {
          "Pitch": 2.9691637,
          "Roll": -6.8904796,
          "Yaw": 23.84388
        },
        "Quality": {
          "Brightness": 40.592964,
          "Sharpness": 96.09616
        }
      },
      "MatchedFaces": [
        {
          "Similarity": 88.863960,
          "Face": {
            "BoundingBox": {
              "Height": 0.557692,
              "Width": 0.749838,
              "Left": 0.103426,
              "Top": 0.206731
            },
            "FaceId": "ed1b560f-d6af-5158-989a-ff586c931545",
            "Confidence": 99.999201,
            "ImageId": "70e09693-2114-57e1-807c-50b6d61fa4dc",
            "ExternalImageId": "matchedImage.jpeg"
          }
        }
      ]
    }
  ]
}
```

Dans l’exemple JSON, notez les éléments suivants :
+ **InputInformation**— Informations sur le flux vidéo Kinesis utilisé pour diffuser des vidéos sur Amazon Rekognition Video. Pour de plus amples informations, veuillez consulter [InputInformation](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-inputinformation).
+ **StreamProcessorInformation**— Informations sur l'état du processeur de streaming Amazon Rekognition Video. La seule valeur possible pour le champ `Status` est RUNNING. Pour de plus amples informations, veuillez consulter [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md).
+ **FaceSearchResponse**— Contient des informations sur les visages de la vidéo en streaming qui correspondent aux visages de la collection d'entrées. [FaceSearchResponse](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facesearchresponse)contient un [DetectedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-detectedface) objet, qui est un visage détecté dans l'image vidéo analysée. Pour chaque visage détecté, le tableau `MatchedFaces` contient une série d’objets visage correspondants ([MatchedFace](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-facematch)) trouvés dans la collection d’entrée, avec un pourcentage de similarité. 

## Mappage du flux vidéo Kinesis au flux de données Kinesis
<a name="mapping-streams"></a>

Vous pouvez vouloir mapper les trames de flux vidéo Kinesis aux trames analysées envoyées au flux de données Kinesis. Par exemple, lors de l’affichage d’une vidéo en streaming, vous pouvez souhaiter afficher des cadres autour des visages des personnes reconnues. Les coordonnées du cadre de délimitation sont envoyées au flux de données Kinesis comme faisant partie de l’enregistrement de reconnaissance faciale Kinesis. Pour afficher correctement le cadre de délimitation, vous devez mapper les informations horaires qui sont envoyées avec l’enregistrement de reconnaissance faciale Kinesis aux trames correspondantes dans le flux vidéo Kinesis.

La technique que vous utilisez pour mapper le flux vidéo Kinesis au flux de données Kinesis varie selon que vous diffusez du contenu multimédia en direct (vidéo de streaming en direct) ou du contenu multimédia archivé (vidéo stockée).

### Mappage en cas de diffusion de contenu multimédia en direct
<a name="mapping-streaming-video"></a>

**Pour mapper une trame de flux vidéo Kinesis à une trame de flux de données Kinesis**

1. Définissez le paramètre d'entrée `FragmentTimeCodeType` de l'[PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)opération sur`RELATIVE`. 

1. Appelez `PutMedia` pour diffuser du contenu multimédia en direct dans le flux vidéo Kinesis.

1. Lorsque vous recevez un enregistrement de reconnaissance faciale Kinesis du flux de données Kinesis, stockez les valeurs de `ProducerTimestamp` et `FrameOffsetInSeconds` du champ [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo).

1. Calculez l’horodatage système qui correspond à la trame du flux vidéo Kinesis en ajoutant les valeurs des champs `ProducerTimestamp` et `FrameOffsetInSeconds`. 

### Mappage en cas de diffusion de contenu multimédia archivé
<a name="map-stored-video"></a>

**Pour mapper une trame de flux vidéo Kinesis à une trame de flux de données Kinesis**

1. Appelez [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)pour transférer du contenu multimédia archivé dans le flux vidéo Kinesis.

1. Lorsque vous recevez un objet `Acknowledgement` dans la réponse de l’opération `PutMedia`, stockez la valeur du champ `FragmentNumber` à partir du champ [Payload](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html#API_dataplane_PutMedia_ResponseSyntax). `FragmentNumber` est le numéro de fragment du cluster MKV. 

1. Lorsque vous recevez un enregistrement de reconnaissance faciale Kinesis du flux de données Kinesis, stockez les valeurs de champ `FrameOffsetInSeconds` du champ [KinesisVideo](streaming-video-kinesis-output-reference.md#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo). 

1. Calculez le mappage en utilisant les valeurs `FrameOffsetInSeconds` et `FragmentNumber` stockées aux étapes 2 et 3. `FrameOffsetInSeconds` est le décalage dans le fragment avec le paramètre spécifique `FragmentNumber` qui est envoyé au Amazon Kinesis Data Streams. Pour plus d’informations sur l’obtention des trames vidéo pour un numéro de fragment donné, consultez le [contenu multimédia archivé Amazon Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_Operations_Amazon_Kinesis_Video_Streams_Archived_Media.html).

# Afficher les résultats de Rekognition avec Kinesis Video Streams en local
<a name="displaying-rekognition-results-locally"></a>

 [Vous pouvez consulter les résultats d'Amazon Rekognition Video Video Streams affichés dans votre flux d'Amazon Kinesis Video Streams à l'aide des exemples de tests de la bibliothèque d'analyseurs Amazon Kinesis Video Streams fournis sur - Rekognition Examples. KinesisVideo ](https://github.com/aws/amazon-kinesis-video-streams-parser-library#kinesisvideo---rekognition-examples) Il `KinesisVideoRekognitionIntegrationExample` affiche des zones de délimitation au-dessus des visages détectés et restitue la vidéo localement. JFrame Ce processus suppose que vous avez correctement connecté une entrée multimédia provenant de la caméra de l’appareil à un flux vidéo Kinesis, et que vous avez démarré un processeur de flux Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Streaming à l'aide d'un GStreamer plugin](streaming-using-gstreamer-plugin.md). 

## Étape 1 : installation de la bibliothèque d’analyseurs Kinesis Video Streams
<a name="step-1-install-parser-library"></a>

 Pour créer un répertoire et télécharger le référentiel Github, exécutez la commande suivante : 

```
$ git clone https://github.com/aws/amazon-kinesis-video-streams-parser-library.git
```

 Accédez au répertoire de la bibliothèque et exécutez la commande Maven suivante pour effectuer une installation propre : 

```
$ mvn clean install
```

## Étape 2 : configuration de l’exemple de test d’intégration de Kinesis Video Streams et Rekognition
<a name="step-2-configure-kinesis-video-rekognition-example-test"></a>

 Ouvrez le fichier `KinesisVideoRekognitionIntegrationExampleTest.java`. Supprimez le `@Ignore` juste après l’en-tête de la classe. Renseignez les champs de données avec les informations provenant de vos ressources Amazon Kinesis et Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Configuration de vos ressources Vidéo Amazon Rekognition et Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md). Si vous diffusez une vidéo sur votre flux vidéo Kinesis, supprimez le paramètre `inputStream`. 

 Consultez l’exemple de code suivant : 

```
RekognitionInput rekognitionInput = RekognitionInput.builder()
  .kinesisVideoStreamArn("arn:aws:kinesisvideo:us-east-1:123456789012:stream/rekognition-test-video-stream")
  .kinesisDataStreamArn("arn:aws:kinesis:us-east-1:123456789012:stream/AmazonRekognition-rekognition-test-data-stream")
  .streamingProcessorName("rekognition-test-stream-processor")
  // Refer how to add face collection :
  // https://docs.aws.amazon.com/rekognition/latest/dg/add-faces-to-collection-procedure.html
  .faceCollectionId("rekognition-test-face-collection")
  .iamRoleArn("rekognition-test-IAM-role")
  .matchThreshold(0.95f)
  .build();                
            
KinesisVideoRekognitionIntegrationExample example = KinesisVideoRekognitionIntegrationExample.builder()
  .region(Regions.US_EAST_1)
  .kvsStreamName("rekognition-test-video-stream")
  .kdsStreamName("AmazonRekognition-rekognition-test-data-stream")
  .rekognitionInput(rekognitionInput)
  .credentialsProvider(new ProfileCredentialsProvider())
  // NOTE: Comment out or delete the inputStream parameter if you are streaming video, otherwise
  // the test will use a sample video. 
  //.inputStream(TestResourceUtil.getTestInputStream("bezos_vogels.mkv"))
  .build();
```

## Étape 3 : exécution de l’exemple de test d’intégration de Kinesis Video Streams et Rekognition
<a name="step-3-run-kinesis-video-rekognition-example-test"></a>

 Assurez-vous que votre flux vidéo Kinesis reçoit une entrée multimédia si vous le diffusez, et commencez à analyser votre flux avec un processeur de diffusion vidéo Amazon Rekognition en cours d’exécution. Pour de plus amples informations, veuillez consulter [Présentation des opérations du processeur de flux Vidéo Amazon Rekognition](streaming-video.md#using-rekognition-video-stream-processor). Exécutez la `KinesisVideoRekognitionIntegrationExampleTest` classe en tant que JUnit test. Après un court laps de temps, une nouvelle fenêtre s’ouvre avec un flux vidéo issu de votre flux vidéo Kinesis, avec des cadres de délimitation dessinés au-dessus des visages détectés. 

**Note**  
 Les visages de la collection utilisée dans cet exemple doivent avoir un ID d'image externe (le nom du fichier) spécifié dans ce format pour que les étiquettes des encadrés affichent un texte significatif : PersonName 1-Trusted, PersonName 2-Intruder, 3-Neutral, etc. PersonName Les étiquettes peuvent également être codées par couleur et sont personnalisables dans le FaceType fichier .java. 

# Comprendre l'enregistrement de trame JSON de reconnaissance faciale Kinesis
<a name="streaming-video-kinesis-output-reference"></a>

Vidéo Amazon Rekognition peut reconnaître des visages dans une vidéo diffusée en streaming. Pour chaque trame analysée, Vidéo Amazon Rekognition transmet un enregistrement de trame JSON à un flux de données . Vidéo Amazon Rekognition n’analyse pas toutes les images qui lui sont transmises via le flux vidéo Kinesis. 

L’enregistrement de trame JSON contient des informations sur les flux d’entrée et de sortie, le statut du processeur de flux, ainsi que des informations sur les visages reconnus dans les trames analysées. Cette section contient des informations de référence pour l’enregistrement de fréquence JSON.

Voici la syntaxe JSON pour un enregistrement de flux de données Kinesis. Pour de plus amples informations, veuillez consulter [Utilisation des vidéos streaming](streaming-video.md).

**Note**  
L’API de Vidéo Amazon Rekognition compare les visages de votre flux d’entrée à une collection de visages, puis renvoie les correspondances les plus proches trouvées, ainsi qu’un score de similarité.

```
{
    "InputInformation": {
        "KinesisVideo": {
            "StreamArn": "string",
            "FragmentNumber": "string",
            "ProducerTimestamp": number,
            "ServerTimestamp": number,
            "FrameOffsetInSeconds": number
        }
    },
    "StreamProcessorInformation": {
        "Status": "RUNNING"
    },
    "FaceSearchResponse": [
        {
            "DetectedFace": {
                "BoundingBox": {
                    "Width": number,
                    "Top": number,
                    "Height": number,
                    "Left": number
                },
                "Confidence": number,
                "Landmarks": [
                    {
                        "Type": "string",
                        "X": number,
                        "Y": number
                    }
                ],
                "Pose": {
                    "Pitch": number,
                    "Roll": number,
                    "Yaw": number
                },
                "Quality": {
                    "Brightness": number,
                    "Sharpness": number
                }
            },
            "MatchedFaces": [
                {
                    "Similarity": number,
                    "Face": {
                        "BoundingBox": {
                            "Width": number,
                            "Top": number,
                            "Height": number,
                            "Left": number
                        },
                        "Confidence": number,
                        "ExternalImageId": "string",
                        "FaceId": "string",
                        "ImageId": "string"
                    }
                }
            ]
        }
    ]
}
```

## Enregistrement JSON
<a name="streaming-video-kinesis-output-reference-processorresult"></a>

L’enregistrement JSON contient inclut des informations sur une trame traitée par Vidéo Amazon Rekognition. L’enregistrement contient des informations sur la vidéo streaming, le statut de la trame analysée et les visages reconnus dans la trame.

**InputInformation**

Informations sur le flux vidéo Kinesis utilisé pour diffuser des vidéos dans Vidéo Amazon Rekognition.

Type : objet [InputInformation](#streaming-video-kinesis-output-reference-inputinformation)

**StreamProcessorInformation**

Informations sur le processeur de flux Vidéo Amazon Rekognition. Comprend des informations sur le statut en cours du processeur de flux.

Type : objet [StreamProcessorInformation](streaming-video-kinesis-output-reference-streamprocessorinformation.md) 

**FaceSearchResponse**

Informations sur les visages détectés dans la trame vidéo en streaming et sur les visages correspondants trouvés dans la collection d’entrée.

Type : tableau d’objets [FaceSearchResponse](#streaming-video-kinesis-output-reference-facesearchresponse)

## InputInformation
<a name="streaming-video-kinesis-output-reference-inputinformation"></a>

Informations sur un flux vidéo source utilisé par Vidéo Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Utilisation des vidéos streaming](streaming-video.md).

**KinesisVideo**

Type : objet [KinesisVideo](#streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo)

## KinesisVideo
<a name="streaming-video-kinesis-output-reference-kinesisvideostreams-kinesisvideo"></a>

Informations sur le flux vidéo Kinesis qui diffuse la vidéo source sur Vidéo Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Utilisation des vidéos streaming](streaming-video.md).

**StreamArn**

Le Amazon Resource Name (ARN) du flux vidéo Kinesis.

Type : Chaîne 

**FragmentNumber**

Le fragment de vidéo streaming qui contient la trame que cet enregistrement représente.

Type : Chaîne

**ProducerTimestamp**

L’horodatage Unix côté producteur du fragment. Pour de plus amples informations, veuillez consulter [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Type : Number

**ServerTimestamp**

L’horodatage Unix côté serveur du fragment. Pour de plus amples informations, veuillez consulter [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html).

Type : Number

**FrameOffsetInSeconds**

Le décalage de la trame (en secondes) dans le fragment.

Type : Number 

# StreamProcessorInformation
<a name="streaming-video-kinesis-output-reference-streamprocessorinformation"></a>

Informations de statut sur le processeur de flux.

**Statut**

Le statut en cours du processeur de flux. La seule valeur possible est RUNNING.

Type : Chaîne

## FaceSearchResponse
<a name="streaming-video-kinesis-output-reference-facesearchresponse"></a>

Informations sur un visage détecté dans la trame vidéo en streaming et sur les visages dans une collection qui correspondent au visage détecté. Vous spécifiez la collection dans un appel à [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html). Pour de plus amples informations, veuillez consulter [Utilisation des vidéos streaming](streaming-video.md). 

**DetectedFace**

Détails d’un visage détecté dans une trame vidéo analysée.

Type : objet [DetectedFace](#streaming-video-kinesis-output-reference-detectedface)

**MatchedFaces**

Tableau de détails de visages pour des visages dans une collection qui correspond au visage détecté dans `DetectedFace`.

Type : tableau d’objets [MatchedFace](#streaming-video-kinesis-output-reference-facematch)

## DetectedFace
<a name="streaming-video-kinesis-output-reference-detectedface"></a>

Informations sur un visage détecté dans une trame vidéo en streaming. Les visages correspondants dans la collection d’entrée sont disponibles dans le champ d’objet [MatchedFace](#streaming-video-kinesis-output-reference-facematch).

**BoundingBox**

Le cadre de délimitation s’accorde avec un visage détecté dans une trame vidéo analysée. L' BoundingBox objet possède les mêmes propriétés que l' BoundingBox objet utilisé pour l'analyse d'image.

Type : objet [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html) 

**Fiabilité**

Correspond au niveau de confiance (1 à 100) de Vidéo Amazon Rekognition quant au fait que le visage détecté est bien un visage. 1 correspond au niveau de confiance le plus faible, 100 au niveau le plus élevé.

Type : Number

**Traits caractéristiques**

Un tableau de traits caractéristiques de visage.

Type : tableau d’objets [repères](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Landmark.html)

**Expression**

Indique l’expression du visage selon les axes vertical, horizontal, et l’orientation.

Type : objet [d’expression](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Pose.html)

**Qualité**

Identifie la luminosité et la netteté de l’image du visage. 

Type : objet [ImageQuality](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_ImageQuality.html)

## MatchedFace
<a name="streaming-video-kinesis-output-reference-facematch"></a>

Informations sur un visage correspondant à un visage détecté dans une trame vidéo analysée.

**Visage**

Informations de correspondance de visages pour un visage de la collection d’entrée qui correspond au visage dans l’objet [DetectedFace](#streaming-video-kinesis-output-reference-detectedface). 

Type : objet [facial](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Face.html) 

**Similarité**

Le niveau de confiance (1 à 100) auquel les visages correspondent. 1 est le niveau de confiance le plus faible, 100 le plus élevé.

Type : Number 

# Streaming à l'aide d'un GStreamer plugin
<a name="streaming-using-gstreamer-plugin"></a>

Vidéo Amazon Rekognition peut analyser une vidéo diffusée en direct à partir de la caméra d’un appareil. Pour accéder à l'entrée multimédia à partir d'une source de périphérique, vous devez procéder à l'installation GStreamer. GStreamer est un logiciel de framework multimédia tiers qui connecte les sources multimédia et les outils de traitement dans des pipelines de flux de travail. Vous devez également installer le plugin [Amazon Kinesis Video Streams Producer](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) pour Gstreamer. Ce processus suppose que vous avez correctement configuré vos ressources Vidéo Amazon Rekognition et Amazon Kinesis. Pour de plus amples informations, veuillez consulter [Configuration de vos ressources Vidéo Amazon Rekognition et Amazon Kinesis](setting-up-your-amazon-rekognition-streaming-video-resources.md).

## Étape 1 : installer Gstreamer
<a name="step-1-install-gstreamer"></a>

 Téléchargez et installez Gstreamer, un logiciel de plateforme multimédia tiers. Vous pouvez utiliser un logiciel de gestion de paquets tel que Homebrew ([Gstreamer sur Homebrew](https://formulae.brew.sh/formula/gstreamer)) ou vous le procurer directement depuis le [site Web de Freedesktop.](https://gstreamer.freedesktop.org/download/) 

 Vérifiez la réussite de l’installation de Gstreamer en lançant un flux vidéo avec une source de test depuis votre terminal de ligne de commande. 

```
$ gst-launch-1.0 videotestsrc ! autovideosink
```

## Étape 2 : installation du plugin Kinesis Video Streams Producer
<a name="step-2-install-kinesis-video-plugin"></a>

 Dans cette section, vous allez télécharger la bibliothèque [Amazon Kinesis Video Streams Producer](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/) et installer le plugin Kinesis Video Streams Gstreamer. 

 Créez un répertoire et clonez l’exemple de code source à partir du référentiel GitHub. Assurez-vous d’inclure le paramètre `--recursive`. 

```
$ git clone --recursive https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git
```

Suivez les [instructions fournies par la bibliothèque](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/README.md) pour configurer et créer le projet. Assurez-vous d’utiliser les commandes spécifiques à la plate-forme pour votre système d’exploitation. Utilisez le paramètre `-DBUILD_GSTREAMER_PLUGIN=ON` lorsque vous exécutez `cmake` pour installer le plug-in Kinesis Video Streams Gstreamer. Ce projet nécessite les packages supplémentaires suivants inclus dans l’installation : GCC ou Clang, Curl, Openssl et Log4CPlus. Si votre compilation échoue à cause d’un package manquant, vérifiez que le package est installé et qu’il figure dans votre PATH. Si vous rencontrez une erreur « Impossible d’exécuter le programme compilé en C » lors de la construction, réexécutez la commande de construction. Parfois, le compilateur C correct n’est pas trouvé. 

 Vérifiez l’installation du plug-in Kinesis Video Streams en exécutant la commande suivante. 

```
$ gst-inspect-1.0 kvssink
```

 Les informations suivantes, telles que les informations relatives à l’usine et au plug-in, doivent apparaître : 

```
Factory Details:
  Rank                     primary + 10 (266)
  Long-name                KVS Sink
  Klass                    Sink/Video/Network
  Description              GStreamer AWS KVS plugin
  Author                   AWS KVS <kinesis-video-support@amazon.com>
                
Plugin Details:
  Name                     kvssink
  Description              GStreamer AWS KVS plugin
  Filename                 /Users/YOUR_USER/amazon-kinesis-video-streams-producer-sdk-cpp/build/libgstkvssink.so
  Version                  1.0
  License                  Proprietary
  Source module            kvssinkpackage
  Binary package           GStreamer
  Origin URL               http://gstreamer.net/
  
  ...
```

## Étape 3 : Exécuter Gstreamer avec le plug-in Kinesis Video Streams
<a name="step-3-run-gstreamer-with-kinesis-video-plugin"></a>

 Avant de commencer le streaming depuis la caméra d’un appareil vers Kinesis Video Streams, vous devrez peut-être convertir la source multimédia en un codec acceptable pour Kinesis Video Streams. Pour déterminer les spécifications et les capacités de formatage des appareils actuellement connectés à votre machine, exécutez la commande suivante.

```
$ gst-device-monitor-1.0
```

 Pour commencer le streaming, lancez Gstreamer à l’aide de l’exemple de commande suivant, et ajoutez vos informations d’identification et les informations Amazon Kinesis Video Streams. Vous devez utiliser les clés d’accès et la région correspondant à la fonction du service IAM que vous avez créée lorsque vous autorisez [Amazon Rekognition à accéder à vos flux Kinesis.](https://docs.aws.amazon.com/rekognition/latest/dg/api-streaming-video-roles.html#api-streaming-video-roles-all-stream) Pour de plus amples informations sur les clés d’accès, veuillez consulter [Gestion des clés d’accès pour les utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) dans le *Guide de l’utilisateur IAM*. Vous pouvez également ajuster les paramètres des arguments du format vidéo en fonction de votre utilisation et de leur disponibilité sur votre appareil. 

```
$ gst-launch-1.0 autovideosrc device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! 
                x264enc bframes=0 key-int-max=45 bitrate=500 ! video/x-h264,stream-format=avc,alignment=au,profile=baseline ! 
                kvssink stream-name="YOUR_STREAM_NAME" storage-size=512 access-key="YOUR_ACCESS_KEY" secret-key="YOUR_SECRET_ACCESS_KEY" aws-region="YOUR_AWS_REGION"
```

 Pour plus de commandes de lancement, voir [Exemples de commandes de GStreamer lancement](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/examples-gstreamer-plugin.html#examples-gstreamer-plugin-launch). 

**Note**  
 Si votre commande de lancement se termine par une erreur non liée à la négociation, vérifiez le résultat du Device Monitor, et assurez-vous que les valeurs des paramètres `videoconvert`correspondent aux fonctionnalités valides de votre appareil. 

 Au bout de quelques secondes, un flux vidéo provenant de la caméra de votre appareil s’affiche sur votre flux vidéo Kinesis. Pour commencer à détecter et à associer des visages avec Amazon Rekognition, démarrez votre processeur de streaming Vidéo Amazon Rekognition. Pour de plus amples informations, veuillez consulter [Présentation des opérations du processeur de flux Vidéo Amazon Rekognition](streaming-video.md#using-rekognition-video-stream-processor). 

# Résolution des problèmes de streaming vidéo
<a name="streaming-video-troubleshooting"></a>

Cette rubrique fournit des informations permettant de résoudre les problèmes d’utilisation de Vidéo Amazon Rekognition avec des vidéos en streaming.

**Topics**
+ [Je ne sais pas si mon processeur de flux a été créé avec succès](#ts-streaming-video-create-sp)
+ [Je ne sais pas si j’ai configuré mon processeur de flux correctement](#ts-configured-sp)
+ [Mon processeur de flux ne renvoie pas de résultats.](#ts-streaming-video-no-results-from-sp)
+ [L’état de mon processeur de flux est FAILED](#ts-failed-state)
+ [Mon processeur de flux ne renvoie pas les résultats attendus](#w2aac27c79c27c15)

## Je ne sais pas si mon processeur de flux a été créé avec succès
<a name="ts-streaming-video-create-sp"></a>

Utilisez la AWS CLI commande suivante pour obtenir la liste des processeurs de flux et leur état actuel.

```
aws rekognition list-stream-processors
```

Vous pouvez obtenir des informations supplémentaires à l'aide de la AWS CLI commande suivante. Remplacez `stream-processor-name` par le nom du processeur de flux requis.

```
aws rekognition describe-stream-processor --name stream-processor-name
```

## Je ne sais pas si j’ai configuré mon processeur de flux correctement
<a name="ts-configured-sp"></a>

Si votre code ne donne pas des résultats d’analyse à partir de Vidéo Amazon Rekognition, votre processeur de flux n’est peut-être pas configuré correctement. Procédez comme suit pour vérifier que votre processeur de flux est configuré correctement et capable de produire des résultats.

**Pour déterminer si votre solution est configurée correctement**

1. Exécutez la commande suivante pour vérifier que votre processeur de flux est en cours d’exécution. Remplacez `stream-processor-name` par le nom de votre processeur de flux. Le processeur de flux est en cours d’exécution si la valeur de `Status` est `RUNNING`. Si le statut est `RUNNING` et que vous n’obtenez pas de résultats, consultez [Mon processeur de flux ne renvoie pas de résultats.](#ts-streaming-video-no-results-from-sp). Si l’état est `FAILED`, consultez [L’état de mon processeur de flux est FAILED](#ts-failed-state).

   ```
   aws rekognition describe-stream-processor --name stream-processor-name
   ```

1. Si votre processeur de flux est en cours d'exécution, exécutez le Bash ou la PowerShell commande suivante pour lire les données du flux de données Kinesis en sortie. 

   **Bash**

   ```
   SHARD_ITERATOR=$(aws kinesis get-shard-iterator --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON --stream-name kinesis-data-stream-name --query 'ShardIterator')
                           aws kinesis get-records --shard-iterator $SHARD_ITERATOR
   ```

   **PowerShell**

   ```
   aws kinesis get-records --shard-iterator ((aws kinesis get-shard-iterator --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON --stream-name kinesis-data-stream-name).split('"')[4])
   ```

1. Utilisez l’[outil de décodage](https://www.base64decode.org/) sur le site web Base64 Decode pour décoder la sortie en chaîne compréhensible par les utilisateurs. Pour plus d’informations, consultez [Etape 3 : Obtenir l’enregistrement](https://docs.aws.amazon.com/streams/latest/dev/fundamental-stream.html#get-records).

1. Si les commandes fonctionnent et que vous voyez des résultats de détection de visages dans les flux de données Kinesis, cela signifie que votre solution a été configurée correctement. Si la commande échoue, vérifiez les autres suggestions de résolution de problèmes et consultez [Octroi à Vidéo Amazon Rekognition d’un accès à vos ressources](api-streaming-video-roles.md).

Vous pouvez également utiliser le AWS Lambda plan « kinesis-process-record » pour enregistrer les messages provenant du flux de données Kinesis CloudWatch afin de les visualiser en continu. Cela entraîne des coûts supplémentaires pour AWS Lambda et. CloudWatch 

## Mon processeur de flux ne renvoie pas de résultats.
<a name="ts-streaming-video-no-results-from-sp"></a>

Plusieurs raisons peuvent expliquer pourquoi votre processeur de flux ne renvoie pas de résultats. 

### Raison 1 : votre processeur de flux n’est pas configuré correctement
<a name="w2aac27c79c27c11b5"></a>

Il est possible que votre processeur de flux ne soit pas configuré correctement. Pour de plus amples informations, veuillez consulter [Je ne sais pas si j’ai configuré mon processeur de flux correctement](#ts-configured-sp).

### Raison 2 : votre processeur de flux n’est pas dans l’état RUNNING
<a name="w2aac27c79c27c11b7"></a>

**Pour résoudre un problème d’état du processeur de flux**

1. Vérifiez l'état du processeur de flux à l'aide de la AWS CLI commande suivante.

   ```
   aws rekognition describe-stream-processor --name stream-processor-name
   ```

1. Si la valeur de `Status` est `STOPPED`, démarrez votre processeur de flux à l’aide de la commande suivante :

   ```
   aws rekognition start-stream-processor --name stream-processor-name
   ```

1. Si la valeur de `Status` est `FAILED`, consultez [L’état de mon processeur de flux est FAILED](#ts-failed-state).

1. Si la valeur de `Status` est `STARTING`, attendez 2 minutes et vérifiez l’état en répétant l’étape 1. Si la valeur de l’état est toujours `STARTING`, procédez comme suit :

   1. Supprimez le processeur de flux à l’aide de la commande suivante.

      ```
      aws rekognition delete-stream-processor --name stream-processor-name
      ```

   1. Créez processeur de flux avec la même configuration. Pour de plus amples informations, veuillez consulter [Utilisation des vidéos streaming](streaming-video.md).

   1. Si le problème persiste, contactez le AWS Support.

1. Si la valeur de `Status` est `RUNNING`, consultez [Raison 3 : il n’y a pas de données actives dans le flux vidéo Kinesis](#ts-no-data).

### Raison 3 : il n’y a pas de données actives dans le flux vidéo Kinesis
<a name="ts-no-data"></a>

**Pour vérifier s’il n’y a pas de données actives dans le flux vidéo Kinesis**

1. Connectez-vous à la AWS Management Console console [https://console.aws.amazon.com/kinesisvideo/](https://console.aws.amazon.com/kinesisvideo/)Amazon Kinesis Video Streams et ouvrez-la à l'adresse.

1. Sélectionnez le flux vidéo Kinesis qui est l’entrée du processeur de flux Amazon Rekognition.

1. Si l’aperçu indique **No data on stream**, cela signifie qu’il n’y a pas de données à traiter dans le flux d’entrée par Vidéo Amazon Rekognition.

Pour plus d’informations sur la production de vidéos avec Kinesis Video Streams, consultez [Bibliothèques de production de flux vidéo Kinesis](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-sdk.html). 

## L’état de mon processeur de flux est FAILED
<a name="ts-failed-state"></a>

Vous pouvez vérifier l'état d'un processeur de flux à l'aide de la AWS CLI commande suivante.

```
aws rekognition describe-stream-processor --name stream-processor-name
```

Si la valeur de l’état est FAILED, vérifiez les informations de résolution de problèmes pour les messages d’erreur suivants.

### Erreur : « Access denied to Role »
<a name="w2aac27c79c27c13b9"></a>

Le rôle IAM qui est utilisé par le processeur de flux n’existe pas ou Vidéo Amazon Rekognition n’a pas l’autorisation d’assumer ce rôle.

**Pour résoudre les problèmes d’accès au rôle IAM**

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.

1. Dans le panneau de navigation gauche, choisissez **Roles (Rôles)** et vérifiez que le rôle existe. 

1. Si le rôle existe, vérifiez qu'il est conforme à la politique *AmazonRekognitionServiceRole*d'autorisation.

1. Si le rôle n’existe pas ou n’a pas les autorisations appropriées, consultez [Octroi à Vidéo Amazon Rekognition d’un accès à vos ressources](api-streaming-video-roles.md).

1. Démarrez le processeur de flux à l'aide de la AWS CLI commande suivante.

   ```
   aws rekognition start-stream-processor --name stream-processor-name
   ```

### Erreur : « Access denied to Kinesis Video *ou* Access denied to Kinesis Data »
<a name="w2aac27c79c27c13c11"></a>

Le rôle n’a pas accès aux opérations d’API Kinesis Video Streams `GetMedia` et `GetDataEndpoint`. Il est également possible qu’il n’ait pas accès aux opérations d’API flux de données Kinesis `PutRecord` et `PutRecords`. 

**Pour résoudre les problèmes relatifs aux autorisations d’API**

1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.

1. Ouvrez le rôle et assurez-vous que la stratégie d’autorisations suivante lui est attachée.

1. S’il manque l’une des autorisations, mettez à jour la stratégie. Pour de plus amples informations, veuillez consulter [Octroi à Vidéo Amazon Rekognition d’un accès à vos ressources](api-streaming-video-roles.md).

### Erreur : « Le flux *input-video-stream-name* n'existe pas »
<a name="w2aac27c79c27c13c13"></a>

L’entrée flux vidéo Kinesis du processeur de flux n’existe pas ou n’a pas été configurée correctement. 

**Pour résoudre les problèmes de flux de vidéo Kinesis**

1. Utilisez la commande suivante pour vérifier que le flux existe. 

   ```
   aws kinesisvideo list-streams
   ```

1. Si le flux existe, vérifiez les points suivants.
   + L’Amazon Resource Name (ARN) est identique à l’ARN du flux d’entrée pour le processeur de flux.
   + Le flux vidéo Kinesis doit se trouver dans la même région que le processeur de flux.

   Si le processeur de flux n'est pas configuré correctement, supprimez-le à l'aide de la AWS CLI commande suivante.

   ```
   aws rekognition delete-stream-processor --name stream-processor-name
   ```

1. Créez un processeur de flux avec les flux vidéo Kinesis. Pour de plus amples informations, veuillez consulter [Création du processeur de flux de recherche faciale Vidéo Amazon Rekognition](rekognition-video-stream-processor-search-faces.md#streaming-video-creating-stream-processor).

### Erreur  : « Collection non trouvée »
<a name="w2aac27c79c27c13c15"></a>

La collection Amazon Rekognition utilisée par le processeur de flux pour trouver les correspondances de visages n’existe pas ou la mauvaise collection est utilisée.

**Pour vérifier qu’il s’agit de la bonne collection**

1. Utilisez la AWS CLI commande suivante pour déterminer si la collection requise existe. Passez `region` à la AWS région dans laquelle vous utilisez votre processeur de streaming.

   ```
   aws rekognition list-collections --region region
   ```

   Si la collection requise n’existe pas, créez-en une nouvelle et ajoutez des informations sur le visage. Pour de plus amples informations, veuillez consulter [Recherche de visages dans une collection](collections.md).

1. Dans votre appel à [CreateStreamProcessor](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_CreateStreamProcessor.html), vérifiez que la valeur du paramètre d'entrée `CollectionId` est correcte.

1. Démarrez le processeur de flux à l'aide de la AWS CLI commande suivante.

   ```
   aws rekognition start-stream-processor --name stream-processor-name
   ```

### Erreur : « Impossible de trouver *output-kinesis-data-stream-name* le stream sous le compte *account-id* »
<a name="w2aac27c79c27c13c17"></a>

Le flux de données Kinesis de sortie utilisé par le processeur de flux n'existe pas dans votre région Compte AWS ou ne se trouve pas dans la même AWS région que votre processeur de flux.

**Pour résoudre les problèmes de flux de données Kinesis**

1. Utilisez la AWS CLI commande suivante pour déterminer si le flux de données Kinesis existe. Passez `region` à la AWS région dans laquelle vous utilisez votre processeur de streaming.

   ```
   aws kinesis list-streams --region region
   ```

1. Si le flux de données Kinesis existe, vérifiez que le nom de flux de données Kinesis est le même que celui du flux de sortie qui est utilisé par le processeur de flux.

1. Si le flux de données Kinesis n'existe pas, il se peut qu'il existe dans une autre AWS région. Le flux de données Kinesis doit se trouver dans la même région que le processeur de flux.

1. Le cas échéant, créez un flux de données Kinesis. 

   1. Créez un flux de données Kinesis avec le même nom que celui utilisé par le processeur de flux. Pour plus d’informations, consultez [Etape 1 : Création d’un flux de données](https://docs.aws.amazon.com/streams/latest/dev/learning-kinesis-module-one-create-stream.html).

   1. Démarrez le processeur de flux à l'aide de la AWS CLI commande suivante.

      ```
      aws rekognition start-stream-processor --name stream-processor-name
      ```

## Mon processeur de flux ne renvoie pas les résultats attendus
<a name="w2aac27c79c27c15"></a>

Si votre processeur de flux ne renvoie pas les correspondances de visages attendues, utilisez les informations suivantes.
+ [Recherche de visages dans une collection](collections.md)
+ [Recommandations pour la configuration de la caméra (vidéo en streaming)](recommendations-camera-streaming-video.md)